Add prompt files for Bluesky notification processing

prompts/likePrompt.ts

···
+import { Notification } from "../util/types.ts";
+import { doesUserFollow } from "../util/doesUserFollow.ts";
+import { getCleanThread } from "../util/getCleanThread.ts";
+
+export const likePrompt = async (notification: Notification) => {
+  const isFollower = await doesUserFollow(notification.author.did);
+
+  const thread = notification.reasonSubject
+    ? await getCleanThread(notification.reasonSubject)
+    : [{
+      // @TODO: find a better way to handle this
+      authorHandle: undefined,
+      message: "ERROR: could not get thread",
+      uri: undefined,
+      authorDID: undefined,
+      postedDateTime: undefined,
+      bookmarks: undefined,
+      replies: undefined,
+      reposts: undefined,
+      likes: undefined,
+      quotes: undefined,
+    }];
+
+  return `
+# NOTIFICATION: Someone liked your post
+
+## Context
+• **Liked by:** @${notification.author.handle}
+• **Liker DID:** ${notification.author.did}
+• **Post URI:** ${notification.reasonSubject}
+• **Timestamp:** ${notification.record.createdAt}
+
+${isFollower}
+
+${
+    thread
+      ? `
+## your post that was liked by @${notification.author.handle}
+\`\`\`
+${thread[thread.length - 1].message}
+\`\`\`
+`
+      : ""
+  }
+
+${
+    thread
+      ? `
+## the full thread your post was in
+\`\`\`
+${JSON.stringify(thread, null, 2)}
+\`\`\`
+`
+      : ""
+  }
+## Your Task: Observe Only
+
+**REQUIRED ACTION: Take no public action.**
+
+This is a passive signal for pattern recognition and audience understanding. A like is someone appreciating or aknowledging your content. they are not requesting your attention or a response.
+
+### What to Consider (Silently)
+
+**Is this person part of your engaged audience?**
+You MAY search archival_memory for \`@${notification.author.handle}\` or their DID \`${notification.author.did}\` if you suspect there might be relevant interaction history. Only search if you have reason to believe prior context exists. Don't search for every like.
+
+Consider:
+• Have you interacted with this person before?
+• Are they a frequent engager or first-time interaction?
+• Is this part of a pattern worth noting?
+
+**Does this reveal content preferences?**
+• What topic was this post about?
+• Does this help you understand what content resonates with your audience?
+• Is this post receiving unusual engagement levels?
+
+### Archival Decision
+
+Archive this like ONLY if it meets one of these criteria:
+• The liker is someone you've had multiple meaningful interactions with (helps track relationships)
+• This post is receiving unusual engagement that might inform future content strategy
+• The liker is someone notable in your domain where this engagement provides meaningful context
+
+**Do NOT archive:**
+• Random or first-time likes
+• Likes on casual posts
+• Low-signal engagement
+
+**If archiving, keep it minimal:**
+• User handle and relationship context
+• Post topic and why the like is notable
+• Date for temporal tracking
+
+## Available Actions
+
+### ignore_notification — YOUR ONLY PUBLIC ACTION
+Use this to acknowledge the notification without taking any visible action. This is the correct response.
+
+### archival_memory_search — USE VERY SELECTIVELY
+Only search if you have specific reason to believe prior context with this user exists and matters.
+
+Do NOT search for every like notification.
+
+## PROHIBITED Actions
+
+**NEVER:**
+• Reply to likes
+• Like their posts back as reciprocation
+• Follow them because they liked your post
+• Thank them in any way
+• Take any public-facing action in response to a like
+
+---
+
+**Remember:** A like is passive appreciation. Observe, learn from patterns, but do not treat each like as an event requiring response. Most likes should simply be noted and ignored.
+`;
+};

prompts/mentionPrompt.ts

···
+import { Notification } from "../util/types.ts";
+import { doesUserFollow } from "../util/doesUserFollow.ts";
+import { getCleanThread } from "../util/getCleanThread.ts";
+
+export const mentionPrompt = async (notification: Notification) => {
+  const isFollower = await doesUserFollow(notification.author.did);
+  const thread = notification.uri ? await getCleanThread(notification.uri) : [{
+    // @TODO: find a better way to handle this
+    authorHandle: undefined,
+    message: "ERROR: could not get thread",
+    uri: undefined,
+    authorDID: undefined,
+    postedDateTime: undefined,
+    bookmarks: undefined,
+    replies: undefined,
+    reposts: undefined,
+    likes: undefined,
+    quotes: undefined,
+  }];
+
+  return `
+# NOTIFICATION: You've been mentioned on Bluesky
+
+## Context
+• **Mentioned by:** @${notification.author.handle}
+• **Sender DID:** ${notification.author.did}
+• **Mention Post URI:** ${notification.uri}
+• **Mention Post timestamp:** ${notification.record.createdAt}
+
+${isFollower}
+
+## Current Message from @${notification.author.handle} (message you are responding to)
+\`\`\`
+${notification.record.text}
+\`\`\`
+
+## Full Thread Context
+Below is the complete conversation thread leading up to this mention. Each post includes message text, timestamp, author information, and engagement metrics (likes, replies, reposts, quotes, bookmarks).
+
+Engagement signals can help you understand what has resonated with others in the thread.
+
+\`\`\`json
+${JSON.stringify(thread, null, 2)}
+\`\`\`
+
+## Your Task: Assess and Decide
+
+**Your default action is to NOT respond.** Most mentions do not warrant replies.
+
+### Step 1: Understand the Situation
+Identify which scenario applies:
+• **Direct address:** Are you being spoken to directly with a question, request, or reply?
+• **Mid-thread mention:** Are you being pulled into an ongoing conversation? Is your input solicited or would it be intrusive?
+• **Indirect reference:** Are you mentioned but not expected to respond? (e.g., "I saw @agent posted about...")
+
+### Step 2: Determine If Response Is Warranted
+Only consider responding when ALL of these are true:
+✓ You're directly addressed OR your input is clearly solicited
+✓ You have relevant expertise or value to add
+✓ A response aligns with your defined purpose
+✓ This is not spam, harassment, or off-topic
+
+**When in doubt, don't respond.** It's better to miss an optional interaction than to intrude where you're not needed.
+
+## Available Actions
+
+### ignore_notification — YOUR DEFAULT ACTION
+**This is your most common response.** Use this liberally.
+
+Use when:
+• You're mentioned indirectly or in passing
+• You have nothing meaningful to contribute
+• The conversation doesn't relate to your purpose
+• You're unsure whether to engage
+• The mention appears to be spam or harassment
+
+### archival_memory_search — USE SELECTIVELY
+Do NOT automatically search memory for every mention.
+
+Only search for previous interactions with this user when:
+• The user explicitly references past conversations ("as we discussed...", "you mentioned before...")
+• You need to verify specific details from prior exchanges
+• Historical context would materially change your response
+
+If you have no reason to believe prior context exists or matters, skip the search.
+
+### create_bluesky_post — USE JUDICIOUSLY
+Only after deciding a response is warranted.
+
+**Guidelines:**
+• Each call creates one post (maximum 200 characters)
+• **Default to a single post** — most responses should be one post
+• Only create threaded replies (multiple calls) when:
+  • The response genuinely requires extended explanation that cannot fit in 200 characters
+  • You're explicitly asked for a detailed or long response
+  • The topic naturally benefits from a structured multi-part answer
+  • Avoid unnecessary threads — be concise when possible
+
+**Error handling:** If an individual post fails, only recreate that specific post. Do not regenerate the entire thread.
+
+## Archival (After Responding)
+
+If you chose to respond, archive the interaction when it meets ANY of these criteria:
+• Contains a specific argument, opinion, or question relevant to your domain
+• Is the user's second or subsequent message in this thread
+• References external sources (articles, studies, people, events)
+
+**Archival entry must include:**
+• User handle
+• Root post URI
+• Concise summary of the exchange
+• Conceptual tags for retrieval
+• Key context valuable for future interactions
+
+After archiving, update any other relevant memory blocks as needed.
+
+---
+
+**Remember:** Having these tools available does NOT mean you must use them. Selective, intentional engagement is better than reflexive responses to every mention.
+`;
+};

prompts/newFollowerPrompt.ts

···
+import { Notification } from "../util/types.ts";
+
+export const newFollowerPrompt = (notification: Notification) => {
+  return `
+# NOTIFICATION: New follower
+
+## Context
+• **Followed by:** @${notification.author.handle}
+• **Follower DID:** ${notification.author.did}
+• **Timestamp:** ${notification.record.createdAt}
+
+## Your Task: Assess and Decide
+
+**Your default action is to acknowledge silently.** Do NOT automatically follow back.
+
+### Step 1: Gather Context
+
+**Check their profile:**
+Use get_bluesky_user_info to review their profile information. Look for:
+• Bio and stated interests
+• Follower/following counts (spam bots often have unusual ratios)
+• Display name and profile indicators
+• Any red flags suggesting spam/bot behavior
+
+**Check for prior interactions:**
+Search archival_memory for \`@${notification.author.handle}\` or \`${notification.author.did}\` to see if you've interacted before. Previous meaningful interactions are relevant context for follow-back decisions.
+
+### Step 2: Assess Relevance
+
+**Is this account relevant to your domain?**
+• Does their profile indicate interests aligned with your purpose?
+• Are they likely to post content relevant to you?
+• Do they appear to be a genuine human account (not spam/bot)?
+
+**If considering following back:**
+Use fetch_bluesky_posts to review their recent posts (default 25). Assess:
+• Do they regularly post domain-relevant content?
+• Is their content quality and frequency appropriate?
+• Would following them improve your feed quality?
+
+### Step 3: Make Your Decision
+
+**Follow back ONLY if:**
+✓ Their profile shows clear alignment with your domain
+✓ Their recent posts demonstrate they regularly share relevant content
+✓ They appear to be a genuine account (not spam/bot)
+✓ Following them would add value to your feed
+
+**If you decide to follow:**
+Use update_bluesky_connection to follow them. This should be your ONLY public action for this notification.
+
+**Quality over quantity:** A curated following list is more valuable than following everyone who follows you.
+
+### Step 4: Archival Decision
+
+Archive this follow ONLY if:
+• The follower is notable in your field
+• This represents meaningful audience growth (e.g., significant account in your domain)
+• There's a pattern worth tracking
+
+**Do NOT archive:**
+• Random follows from unknown accounts
+• Obvious spam/bot accounts
+• Low-signal new followers
+
+## Available Actions
+
+### get_bluesky_user_info — USE FOR EVERY FOLLOW
+Always check the profile before making any decisions.
+
+### archival_memory_search — USE SELECTIVELY
+Search for prior interactions if the handle seems familiar or if context would inform your decision.
+
+### fetch_bluesky_posts — USE BEFORE FOLLOWING
+If you're considering following back, review their recent posts first to ensure they post relevant content.
+
+### update_bluesky_connection
+**For following:** Use to follow back IF they meet all criteria above
+**For blocking:** Use proactively if you have high confidence this is a spam bot
+**For muting:** Use if they seem to be another AI agent/bot (keep your feed human-focused)
+
+### ignore_notification — USE WHEN NOT FOLLOWING BACK
+If you decide not to follow back, use this to acknowledge the notification without action.
+
+## PROHIBITED Actions
+
+**NEVER:**
+• Auto-follow everyone who follows you
+• Send "thanks for following" messages (extremely spammy)
+• Like their posts to acknowledge the follow
+• Take multiple public actions (e.g., follow + like their posts)
+
+**If you follow them, that is your ONLY public action for this notification.**
+
+## Proactive Feed Curation
+
+**DO actively manage your feed quality:**
+• Block accounts you have high confidence are spam bots
+• Mute other AI agents/bots to keep your feed human-focused
+• This is good practice, not spam—it protects your feed quality
+
+---
+
+**Remember:** A follow is someone choosing to see your content. It's a compliment, but not an obligation to follow back. Curate your following list intentionally based on content quality and relevance, not reciprocity.
+`;
+};

prompts/quotePrompt.ts

···
+import { Notification } from "../util/types.ts";
+import { doesUserFollow } from "../util/doesUserFollow.ts";
+import { getCleanThread } from "../util/getCleanThread.ts";
+
+export const quotePrompt = async (notification: Notification) => {
+  const isFollower = await doesUserFollow(notification.author.did);
+
+  const originalThread = notification.reasonSubject
+    ? await getCleanThread(notification.reasonSubject)
+    : [{
+      // @TODO: find a better way to handle this
+      authorHandle: undefined,
+      message: "ERROR: could not get thread",
+      uri: undefined,
+      authorDID: undefined,
+      postedDateTime: undefined,
+      bookmarks: undefined,
+      replies: undefined,
+      reposts: undefined,
+      likes: undefined,
+      quotes: undefined,
+    }];
+
+  const quotePostThread = notification.reasonSubject
+    ? await getCleanThread(notification.reasonSubject)
+    : [{
+      // @TODO: find a better way to handle this
+      authorHandle: undefined,
+      message: "ERROR: could not get thread",
+      uri: undefined,
+      authorDID: undefined,
+      postedDateTime: undefined,
+      bookmarks: undefined,
+      replies: undefined,
+      reposts: undefined,
+      likes: undefined,
+      quotes: undefined,
+    }];
+
+  return `
+# NOTIFICATION: Someone quoted your post
+
+## Context
+• **Quoted by:** @${notification.author.handle}
+• **Quoter DID:** ${notification.author.did}
+• **Quote post URI:** ${notification.uri}
+• **Your original post URI:** ${notification.reasonSubject}
+• **Timestamp:** ${notification.record.createdAt}
+
+${isFollower}
+
+## Your Original Post
+\`\`\`
+${originalThread[originalThread.length - 1].message}
+\`\`\`
+
+## The Quote Post from @${notification.author.handle}
+\`\`\`
+${quotePostThread[quotePostThread.length - 1].message}
+\`\`\`
+
+## Quote Post Engagement
+• **Likes:** ${quotePostThread[quotePostThread.length - 1].likes}
+• **Replies:** ${quotePostThread[quotePostThread.length - 1].replies}
+• **Reposts:** ${quotePostThread[quotePostThread.length - 1].reposts}
+• **Quotes:** ${quotePostThread[quotePostThread.length - 1].quotes}
+
+${
+    originalThread
+      ? `
+## The thread from YOUR ORIGINAL post
+\`\`\`
+${JSON.stringify(originalThread, null, 2)}
+\`\`\`
+`
+      : ""
+  }
+
+  ${
+    quotePostThread
+      ? `
+  ## The new branching thread WHERE THE QUOTE EXISTS
+  \`\`\`
+  ${JSON.stringify(quotePostThread, null, 2)}
+  \`\`\`
+  `
+      : ""
+  }
+
+## Your Task: Assess and Decide
+
+**Your default action is to NOT respond.**
+
+### Critical Context to Understand
+
+**Quotes are different from replies.** When someone quotes you, they are addressing THEIR followers, not you. They used your post as a reference point to make their own point or discuss a tangent with their audience. Most quotes do not warrant your response because they weren't directed at you.
+
+Engagement metrics help you assess if there's active discussion happening. High replies suggest conversation is occurring in their thread.
+
+### Step 1: Determine the Quote's Nature
+
+**Is this quote:**
+• **Supportive/amplifying:** They're sharing your content positively with their audience
+• **Critical engagement:** They're disagreeing or offering counterpoint
+• **Misrepresentation:** They're mischaracterizing your position
+• **Direct question:** They're explicitly asking you something in the quote
+
+### Step 2: Decide If Response Is Warranted
+
+**Most quotes do NOT warrant response.** Only consider responding if:
+
+✓ The quote misrepresents your position AND has significant engagement (clarification may be needed)
+✓ They ask you a direct question in the quote
+✓ High reply count indicates active discussion where your input would add genuine value
+✓ You have substantive contribution that would benefit the conversation
+
+**Do NOT respond to:**
+• Supportive quotes (responding looks needy)
+• Simple amplification of your content
+• Quotes where you have nothing substantive to add
+• Quotes where your presence would be intrusive
+
+**When in doubt, don't respond.** They were talking to their audience, not to you.
+
+### Step 3: Consider Context (If Needed)
+
+**Before responding, you MAY:**
+Search archival_memory for \`@${notification.author.handle}\` or their DID \`${notification.author.did}\` if prior context seems relevant
+Use get_bluesky_user_info to understand who this person is if that matters to your decision
+Consider the engagement metrics—high replies might indicate valuable discussion
+
+Do NOT automatically search for every quote. Only gather context if it would meaningfully inform your decision.
+
+### Step 4: If You Choose to Respond
+
+**Use create_bluesky_post to reply to their quote post.**
+
+**DO NOT quote their quote back.** This creates confusing nested quotes and is almost always inappropriate. If you respond, reply to join THEIR conversation.
+
+Guidelines:
+• Single post (200 characters max) is usually sufficient
+• Only thread if genuinely necessary for extended explanation
+• Consider whether your response is welcome or intrusive
+• You're entering THEIR conversation with THEIR audience—be respectful of that dynamic
+
+## Archival Decision
+
+Archive this quote ONLY if:
+• The quote represents meaningful engagement with your ideas (critical analysis, thoughtful discussion)
+• It reveals how your content is being received or interpreted
+• The quoter is notable in your domain
+• There's significant discussion in the replies worth tracking
+
+**Do NOT archive:**
+• Simple supportive quotes
+• Low-engagement quotes
+• Quotes that don't add substantive commentary
+
+## Available Actions
+
+### ignore_notification — YOUR DEFAULT ACTION
+**This is your most common response.** Most quotes don't need your involvement.
+
+### archival_memory_search — USE SELECTIVELY
+Only search if prior interactions with this person would meaningfully inform your decision.
+
+### get_bluesky_user_info — USE IF NEEDED
+Check who quoted you if that context matters for your decision.
+
+### create_bluesky_post — USE VERY RARELY
+Only after determining a response is genuinely warranted.
+
+Guidelines:
+• Reply to their quote (do NOT quote back)
+• Single post default
+• Consider if your presence is welcome
+
+## PROHIBITED Actions
+
+**NEVER:**
+• Quote their quote back (creates nested quotes)
+• Respond to supportive quotes (looks needy)
+• Reply when you have nothing substantive to add
+• Use quote_bluesky_post in response (almost always wrong)
+• Like or repost their quote as acknowledgment
+• Thank them for quoting you
+
+---
+
+**Remember:** A quote is someone having a conversation with THEIR audience using your post as a reference. Most quotes aren't directed at you and don't need your response. Only engage when you have genuine value to add to THEIR discussion.
+`;
+};

prompts/replyPrompt.ts

···
+import { Notification } from "../util/types.ts";
+import { doesUserFollow } from "../util/doesUserFollow.ts";
+import { getCleanThread } from "../util/getCleanThread.ts";
+
+export const replyPrompt = async (notification: Notification) => {
+  const isFollower = await doesUserFollow(notification.author.did);
+  const thread = notification.reasonSubject
+    ? await getCleanThread(notification.reasonSubject)
+    : [{
+      // @TODO: find a better way to handle this
+      authorHandle: undefined,
+      message: "ERROR: could not get thread",
+      uri: undefined,
+      authorDID: undefined,
+      postedDateTime: undefined,
+      bookmarks: undefined,
+      replies: undefined,
+      reposts: undefined,
+      likes: undefined,
+      quotes: undefined,
+    }];
+
+  return `
+# NOTIFICATION: Someone replied to your post
+
+## Context
+• **Replied by:** @${notification.author.handle}
+• **Replier DID:** ${notification.author.did}
+• **Reply post URI:** ${notification.uri}
+• **Your original post URI:** ${notification.reasonSubject}
+• **Timestamp:** ${notification.record.createdAt}
+
+${isFollower}
+
+## Your Original Post (what the user responded to)
+\`\`\`
+${thread[thread.length - 1].message}
+\`\`\`
+
+## Post Reply from @${notification.author.handle} (what they said to you and what you may respond to now)
+\`\`\`
+${notification.record.text}
+\`\`\`
+
+## Full Thread Context
+Below is the complete conversation thread. Each post includes message text, timestamp, author information, and engagement metrics.
+
+${
+    thread
+      ? `
+## The full thread context in chronological order
+\`\`\`
+${JSON.stringify(thread, null, 2)}
+\`\`\`
+`
+      : ""
+  }
+
+## Your Task: Assess and Decide
+
+**Replies carry higher expectation of response than mentions, but you still shouldn't respond to everything.**
+
+Replies are direct responses to your content. Unlike quotes (which address the quoter's audience), replies are directed at you and often expect engagement. However, not all replies warrant responses.
+
+### Step 1: Assess the Reply's Nature
+
+**Is this reply:**
+• **Substantive engagement:** Question, request, meaningful addition to conversation
+• **Good-faith critical engagement:** Disagreement or counterpoint worth addressing
+• **Low-effort:** Single emoji, "lol", "this", minimal content
+• **Spam or harassment:** Bad faith, off-topic, or abusive
+• **Simple appreciation:** "Thanks!", "Great post!", brief positive acknowledgment
+
+### Step 2: Decide If Response Is Warranted
+
+**Do NOT respond to:**
+• Low-effort replies ("lol", "this", single emoji)
+• Spam or harassment
+• Simple appreciation that doesn't invite further discussion (e.g., just "thanks")
+• Replies where you have nothing substantive to add
+
+**Consider responding when:**
+✓ Genuine questions or requests for engagement
+✓ Substantive continuation of conversation
+✓ Good-faith critical engagement where dialogue would be valuable
+✓ The reply invites or clearly expects a response
+✓ You have meaningful value to add to the conversation
+
+**Alternative: Like instead of reply**
+Sometimes a reply warrants acknowledgment but not a full response. You MAY use like_bluesky_post to signal "I saw this and appreciate it" without replying. Use this sparingly for:
+• Simple appreciation you want to acknowledge
+• Minor points that don't need discussion
+• Supportive replies that don't invite further conversation
+
+### Step 3: Gather Context
+
+**ALWAYS search archival_memory for previous interactions with \`@${notification.author.handle}\` or their DID \`${notification.author.did}\`.**
+
+Replies are part of ongoing dialogue. Historical context matters significantly:
+• Have you had conversations with this person before?
+• Is this a continuation of a previous discussion?
+• What's the relationship history?
+
+Review the full thread context to understand the conversation flow and your original post's context.
+
+### Step 4: If You Choose to Respond
+
+**Use create_bluesky_post to reply.**
+
+Guidelines:
+• Default to single post (200 characters max)
+• Only thread if response genuinely requires extended explanation OR you're explicitly asked for detail
+• Maintain conversation momentum if there's genuine dialogue
+• Be substantive—avoid generic responses like "Thanks!" or "Great point!"
+
+**Error handling:** If an individual post in a thread fails, only recreate that specific post. Do not regenerate the entire thread.
+
+### Step 5: Archival Decision
+
+After responding (or deciding not to respond), archive the interaction if it meets ANY of these criteria:
+• Contains specific argument, opinion, or question relevant to your domain
+• Is the user's second or subsequent message in this thread (captures ongoing dialogue)
+• References external sources (articles, studies, people, events)
+• Represents meaningful engagement worth tracking
+
+**Do NOT archive:**
+• Low-effort replies
+• Spam
+• Single-interaction appreciations with no substance
+
+**Archival entry must include:**
+• User handle
+• Post/thread URI
+• Concise summary of the exchange
+• Conceptual tags for retrieval
+• Key context for future interactions
+
+After archiving, update any other relevant memory blocks as needed.
+
+## Available Actions
+
+### archival_memory_search — ALWAYS USE FOR REPLIES
+**Required action.** Always check for previous interactions with this user before responding. Replies are dialogues, and context matters.
+
+### ignore_notification — USE FOR LOW-VALUE REPLIES
+Use for low-effort replies, spam, or when you have nothing to add.
+
+### like_bluesky_post — ALTERNATIVE TO RESPONDING
+Use sparingly to acknowledge replies that don't warrant full responses. Better than ignoring when simple acknowledgment is appropriate, but don't overuse.
+
+### create_bluesky_post — USE WHEN RESPONSE WARRANTED
+Only after determining the reply deserves a substantive response.
+
+Guidelines:
+• Single post default
+• Thread only when necessary
+• Be substantive and conversational
+
+## PROHIBITED Actions
+
+**NEVER:**
+• Reply to spam or harassment
+• Give generic, low-effort responses ("Thanks!", "Great point!")
+• Respond just to respond (add value or don't engage)
+• Reply + like the same post (pick one action)
+• Reply + follow the person (separate these actions)
+
+**Maximum public actions per reply notification:** 1 (either reply OR like, not both)
+
+---
+
+**Remember:** Replies are directed at you and often warrant responses, but not always. Prioritize substantive engagement over volume. It's better to have fewer meaningful conversations than many shallow acknowledgments. Always check conversation history before responding.
+`;
+};

prompts/repostPrompt.ts

···
+import { Notification } from "../util/types.ts";
+import { doesUserFollow } from "../util/doesUserFollow.ts";
+import { getCleanThread } from "../util/getCleanThread.ts";
+
+export const repostPrompt = async (
+  notification: Notification,
+) => {
+  const isFollower = await doesUserFollow(notification.author.did);
+  const thread = notification.reasonSubject
+    ? await getCleanThread(notification.reasonSubject)
+    : [{
+      // @TODO: find a better way to handle this
+      authorHandle: undefined,
+      message: "ERROR: could not get thread",
+      uri: undefined,
+      authorDID: undefined,
+      postedDateTime: undefined,
+      bookmarks: undefined,
+      replies: undefined,
+      reposts: undefined,
+      likes: undefined,
+      quotes: undefined,
+    }];
+
+  return `
+# NOTIFICATION: Someone reposted your content
+
+## Context
+• **Reposted by:** @${notification.author.handle}
+• **Reposter DID:** ${notification.author.did}
+• **Post URI:** ${notification.reasonSubject}
+• **Timestamp:** ${notification.record.createdAt}
+
+${isFollower}
+
+${
+    thread
+      ? `
+## your post that was reposted by @${notification.author.did}
+\`\`\`
+${thread[thread.length - 1].message}
+\`\`\`
+`
+      : ""
+  }
+
+${
+    thread
+      ? `
+## the full thread your post was in
+\`\`\`
+${JSON.stringify(thread, null, 2)}
+\`\`\`
+`
+      : ""
+  }
+
+## Your Task: Observe Only
+
+**REQUIRED ACTION: Take no public action.**
+
+This is a passive signal for audience understanding and content reach. A repost means someone is amplifying your content to their followers—not requesting your attention or response.
+
+### What to Consider (Silently)
+
+**Who is amplifying your content?**
+You MAY search archival_memory for \`@${notification.author.handle}\` or \`${notification.author.did}\` if you suspect there might be relevant interaction history. Only search if you have reason to believe prior context exists. Don't search for every repost.
+
+Consider:
+• Is this someone in your network or reaching a new audience?
+• Are they significant in your domain?
+• Is there a pattern of reposts from this user (indicates alignment)?
+
+**What does this reveal about content reach?**
+• What topic was this post about?
+• Does this indicate your content reaching new or important audiences?
+• Is this part of broader engagement patterns worth tracking?
+
+### Archival Decision
+
+Archive this repost ONLY if it meets one of these criteria:
+• The reposter is significant in your domain
+• The repost indicates your content reaching a new or important audience segment
+• Pattern of reposts from the same user (indicates strong alignment with your content)
+
+**Do NOT archive:**
+• Random or isolated reposts
+• Reposts from casual followers
+• Low-signal amplification
+
+**If archiving, keep it minimal:**
+• User handle and why they're notable
+• What this reveals about content reach
+• Date for temporal tracking
+
+## Available Actions
+
+### ignore_notification — YOUR ONLY PUBLIC ACTION
+Use this to acknowledge the notification without taking any visible action. This is the correct response.
+
+### archival_memory_search — USE VERY SELECTIVELY
+Only search if you have specific reason to believe prior context with this user exists and matters.
+
+Do NOT search for every repost notification.
+
+## PROHIBITED Actions
+
+**NEVER:**
+• Reply to reposts
+• Repost their content back as reciprocation
+• Follow them because they reposted your content
+• Thank them in any way (comes across as needy and bot-like)
+• Take any public-facing action in response to a repost
+
+---
+
+**Remember:** A repost is someone sharing your content with their audience. It's a compliment, not a call to action. Observe and note patterns, but do not treat reposts as events requiring response.
+`;
+};

util/processNotification.ts

···
 import { session } from "./session.ts";
 import { messageAgent } from "./messageAgent.ts";
 
-import {
-  createLikePrompt,
-  createMentionPrompt,
-  createNewFollowerPrompt,
-  createQuotePrompt,
-  createReplyPrompt,
-  createRepostPrompt,
-} from "./promptsAndLogs.ts";
+import { likePrompt } from "../prompts/likePrompt.ts";
+import { mentionPrompt } from "../prompts/mentionPrompt.ts";
+import { newFollowerPrompt } from "../prompts/newFollowerPrompt.ts";
+import { quotePrompt } from "../prompts/quotePrompt.ts";
+import { replyPrompt } from "../prompts/replyPrompt.ts";
+import { repostPrompt } from "../prompts/repostPrompt.ts";
 
 export const processNotification = async (notification: Notification) => {
   const agentProject = Deno.env.get("LETTA_PROJECT_NAME");
   const kind = notification.reason;
   console.log(`pausing notif checks, received ${kind} notification…`);
-  // const referencePostThread = await getCleanThread(notification.uri);
-  // console.log(referencePostThread[0]);
 
   if (kind == "like") {
     session.likeCount++;
 
-    const prompt = await createLikePrompt(notification);
+    const prompt = await likePrompt(notification);
     await messageAgent(prompt);
     console.log(
       `sent ${kind} notification to ${agentProject}, waiting for response…`,
···
   } else if (kind == "repost") {
     session.repostCount++;
 
-    const prompt = await createRepostPrompt(notification);
+    const prompt = await repostPrompt(notification);
     await messageAgent(prompt);
     console.log(
       `sent ${kind} notification to ${agentProject}, waiting for response…`,
···
   } else if (kind == "follow") {
     session.followCount++;
 
-    const prompt = createNewFollowerPrompt(notification);
+    const prompt = newFollowerPrompt(notification);
     await messageAgent(prompt);
     console.log(
       `sent ${kind} notification to ${agentProject}, waiting for response…`,
     );
   } else if (kind == "mention") {
-    const prompt = await createMentionPrompt(notification);
+    const prompt = await mentionPrompt(notification);
 
     await messageAgent(prompt);
     console.log(
···
   } else if (kind == "reply") {
     session.replyCount++;
 
-    const prompt = await createReplyPrompt(notification);
+    const prompt = await replyPrompt(notification);
     await messageAgent(prompt);
     console.log(
       `sent ${kind} notification to ${agentProject}, waiting for response…`,
···
   } else if (kind == "quote") {
     session.quoteCount++;
 
-    const prompt = await createQuotePrompt(notification);
+    const prompt = await quotePrompt(notification);
     await messageAgent(prompt);
     console.log(
       `sent ${kind} notification to ${agentProject}, waiting for response…`,