Raindrop.io Stella Prompts for Batch Processing Bookmarks

# Stella Bookmark Workflow
Use the Raindrop MCP tools to process the five oldest bookmarks in Unsorted. Analyse each bookmark, show one combined preview, and make no changes until I explicitly confirm.
## Tools
Use only:
* `find_bookmarks`
* `fetch_bookmark_content`
* `find_tags`
* `find_collections`
* `update_bookmarks`
## Constraints
* Do not call `update_bookmarks` before confirmation.
* Fetch and finish one bookmark before fetching the next.
* Do not fetch all bookmark contents upfront.
* Treat the discovered bookmarks as a fixed working set.
* Preserve discovery order throughout.
* Never mix content, notes, tags, titles, URLs, or decisions between bookmarks.
* Titles must come from bookmark metadata, not fetched content.
* Never add quotation marks around extracted passages.
* Flagged changes require separate confirmation by bookmark number and item.
Maintain:
* `working_set`
* `tag_vocabulary`
* `target_collection`
* `proposals`
* `skipped`
* `flagged`
Keep stored values structured. Preview formatting must never replace internal values.
## Phase 1: Working set
Call `find_bookmarks` once with:
* `collectionId: -1`
* `sort: created`
* `perpage: 5`
* `page: 0`
This means Unsorted, oldest first, five results.
Store the returned bookmarks as immutable `working_set`, preserving returned order. If fewer than five are returned, use those.
Retain for each bookmark:
* index
* bookmark ID
* title
* URL
* existing note
* existing tags
* current collection
## Phase 2: Preflight
Before fetching content:
1. Call `find_tags` once for the existing tag vocabulary.
2. Call `find_collections` once to locate `thejaymo` and record its `_id`.
If `thejaymo` is not found, continue analysis but set:
`Collection action: ⚠️ Flagged for review — collection thejaymo was not found`
Do not create a collection.
Use existing tags wherever possible. Use a targeted `find_tags` search only when unsure whether a concrete subject tag exists.
## Phase 3: Analyse sequentially
Process bookmarks in `working_set` order.
For each bookmark:
1. Reset all temporary variables.
2. Fetch only that bookmark’s content.
3. Read only that content.
4. Extract one key passage.
5. Prepare the exact note update.
6. Propose the final tag set.
7. Decide the collection action.
8. Store the proposal.
9. Continue to the next bookmark.
Each proposal must contain:
* `index`
* `bookmark_id`
* `title`
* `url`
* `key_passage`
* `note_field_preview`
* `existing_tags`
* `proposed_tags`
* `collection_action`
* `flagged_items`
`proposed_tags` must always be an array of plain strings without `#` prefixes or review annotations.
## Key passage
Extract exactly one passage per bookmark.
It must:
* be contiguous source text from that bookmark
* preserve exact wording
* contain no more than 100 words
* preferably be a complete paragraph
* contain no quotation marks added by you
Prefer:
1. counter-intuitive beat
2. thesis sentence or paragraph
3. strong statistic
4. buried irony
If no usable passage exists:
`Key passage: ⚠️ No usable passage found — [reason]`
Do not invent or substitute content.
## Notes
When a usable passage exists:
* place it at the top
* preserve it exactly
* do not wrap it in quotation marks
* if the existing note is empty, use only the passage
* otherwise use the passage, one blank line, then the existing note unchanged
If no passage exists, use a subtitle only when clearly appropriate. Otherwise preserve the existing note and flag the note update.
## Tags
Ask what the bookmark is materially about.
Choose three to seven final tags in this order:
1. concrete subject
2. close subject
3. broader subject
4. lens or context
Use existing tags wherever suitable. Precise subject tags beat broad or high-count tags.
`proposed_tags` is the complete desired tag list. Preserve existing tags that remain appropriate. Remove one only when clearly irrelevant, mistaken, or superseded. Proposed tags are tags to add; store them as an array of plain strings and preserve existing tags.
All tag values must:
* be plain strings
* contain no leading `#`
* be lowercase and hyphenated where appropriate
* contain no warning or review text
* be deduplicated
Only propose a new tag when no suitable existing tag exists. Store the plain tag normally and record the review requirement separately in `flagged_items`.
## Collections
Default:
`Collection action: Move to thejaymo`
Flag the move if the bookmark is:
* highly personal or private
* sensitive
* paywalled with no usable excerpt
* too time-sensitive to age well
* unsuitable for public curation
Use:
`Collection action: ⚠️ Flagged for review — [reason]`
Proposed tags are tags to add; store them as an array of plain strings and preserve existing tags.
## Phase 4: Preview
After all proposals are stored, show one combined preview. Do not call `update_bookmarks`.
Use:
### Bookmark [n]
Title: [exact title from working_set]
Key passage: [exact passage, maximum 100 words]
Tags: #tag1 #tag2 #tag3
Note field preview: [exact note value]
Collection action: [Move to thejaymo or flagged action]
The `Tags:` line is display-only formatting derived from `proposed_tags`. Never use or parse it as update input.
For new tags, also show:
`New tag requiring confirmation: #tag`
If the title is missing:
`Title: ⚠️ Missing bookmark title — [URL or bookmark ID]`
After all bookmarks, output exactly:
`Confirm? Reply yes all to apply everything, no all to cancel, skip [n] to exclude a bookmark, or [n] edit [change] to amend a specific bookmark.`
## Phase 5 — Confirmation and apply
Valid commands only: `yes all`, `no all`, `skip [n]`, `[n] edit [change]`,
`yes all + [n] [change]`. Treat ambiguous replies such as `yes`, `looks good`,
`go ahead`, or `do it` as invalid.
Applying means calling `update_bookmarks`. On an apply command, make the first
tool call before any prose.
* `yes all`: apply proposals one bookmark at a time, in `working_set` order.
* `no all`: change nothing and call nothing.
* `skip [n]`: exclude bookmark `n` and reshow the preview.
* `[n] edit [change]`: revise only bookmark `n` and reshow the preview.
* `yes all + [n] [change]`: amend bookmark `n`, then apply as `yes all`.
`yes all` excludes flagged collection actions, flagged note updates, and
unconfirmed new tags.
For each approved bookmark, call `update_bookmarks` using exactly:
```json
{
  "updates": [
    {
      "bookmark_ids": [BOOKMARK_ID],
      "update": {
        "note": "APPROVED NOTE",
        "add_tags": ["tag1", "tag2"],
        "collection_id": TARGET_COLLECTION_ID
      }
    }
  ]
}
```
Include only fields that have an approved change.
Rules:
* `bookmark_ids` must be an array containing the current bookmark ID.
* Tags must use `add_tags`, not `tags`.
* `add_tags` must be an array of plain strings without `#` prefixes.
* The collection must use `collection_id`.
* Build values from the stored proposal, never from the formatted preview.
* Existing tags remain; `add_tags` appends the approved proposed tags.
* Never combine `add_tags` and `remove_tags` in one update operation.
* If tag removal is explicitly approved, call `remove_tags` separately and
  wait for its result before calling `add_tags`.
* Wait for each bookmark’s result before updating the next bookmark.
* After the last call, report note, tag, and collection results separately.
## Applying updates
Process one bookmark at a time in `working_set` order. Finish all operations for that bookmark before continuing.
Build every update from the stored proposal, never from the displayed preview.
Use the live `update_bookmarks` schema exactly as exposed by the MCP tool. Do not assume its field names match the REST API.
For tags:
* use the live schema’s tag argument
* pass an array of plain strings
* never pass hashtags or comma-separated text
* if the tool supports full replacement, pass `proposed_tags`
* if it instead supports separate add/remove operations, derive and apply them from `existing_tags` and `proposed_tags`
Never combine a tag operation with a collection move in the same `update_bookmarks` call.
For each bookmark, apply sequentially:
1. note update, if needed
2. tag removal, if needed and supported
3. tag addition or full replacement, if needed
4. collection move, if confirmed
Wait for each result before making the next call. Never make simultaneous update calls.
Before each call, verify:
* bookmark ID is present
* tag values are arrays of plain strings
* no tag begins with `#`
* no tag contains warning text
* note text matches `note_field_preview`
* collection uses the verified `thejaymo` ID
* the call changes only the intended bookmark and field group
Inspect every tool result. Report note, tags, and collection separately. Do not report the whole bookmark as successfully updated merely because one operation succeeded.
If a tag result exposes the resulting tags and they do not match the intended change, stop before moving the bookmark or processing the next one and report the mismatch.
If the result does not expose tags, report:
`Tags: update requested; the tool result did not provide enough data to verify`