spora 0.7.7 → 0.7.8

package/dist/chunk-TTM54LQR.js

@@ -1,2769 +0,0 @@
-import {
-  getXClient
-} from "./chunk-5R4AJZHN.js";
-import {
-  addToQueue
-} from "./chunk-ZLSDFYBR.js";
-import {
-  buildOpportunityPortfolioMessage,
-  buildPersonaConstraintLines,
-  buildSystemPrompt,
-  compilePersonaActionProfile,
-  getPersonaConstraints,
-  personaConstraintHandles
-} from "./chunk-JIMONWKO.js";
-import {
-  listIntents,
-  loadStrategy,
-  recordIntentExecution
-} from "./chunk-OTZNHIXT.js";
-import {
-  getActiveTrackedPosts,
-  retireOldPosts,
-  updatePostMetrics
-} from "./chunk-CP6JWCLY.js";
-import {
-  loadIdentity,
-  saveIdentity
-} from "./chunk-IULO3GRE.js";
-import {
-  loadCredentials
-} from "./chunk-SXNZVKLJ.js";
-import {
-  generateResponse
-} from "./chunk-342ZX72W.js";
-import {
-  logger
-} from "./chunk-RSNEVBEI.js";
-import {
-  addLearning,
-  getRecentInteractions,
-  loadRelationships,
-  logInteraction
-} from "./chunk-BBXHECZ5.js";
-import {
-  paths
-} from "./chunk-ZWKTKWS6.js";
-
-// src/runtime/decision-engine.ts
-async function executeAction(action) {
-  const { action: type } = action;
-  try {
-    switch (type) {
-      case "post": {
-        if (!action.content) return { action: type, success: false, error: "No content provided" };
-        if (action.content.length > 280) {
-          return { action: type, success: false, error: `Tweet too long: ${action.content.length} chars (max 280)` };
-        }
-        const client = await getXClient();
-        const result = await client.postTweet(action.content);
-        if (result.success) logger.info(`Posted: "${action.content.slice(0, 50)}..."`);
-        return { action: type, success: result.success, detail: result.tweetId, error: result.error };
-      }
-      case "reply": {
-        if (!action.tweetId || !action.content) {
-          return { action: type, success: false, error: "Missing tweetId or content" };
-        }
-        const client = await getXClient();
-        const result = await client.replyToTweet(action.tweetId, action.content);
-        if (result.success) logger.info(`Replied to ${action.tweetId}: "${action.content.slice(0, 50)}..."`);
-        return { action: type, success: result.success, detail: result.tweetId, error: result.error };
-      }
-      case "like": {
-        if (!action.tweetId) return { action: type, success: false, error: "Missing tweetId" };
-        const client = await getXClient();
-        const result = await client.likeTweet(action.tweetId);
-        return { action: type, success: result.success, error: result.error };
-      }
-      case "retweet": {
-        if (!action.tweetId) return { action: type, success: false, error: "Missing tweetId" };
-        const client = await getXClient();
-        const result = await client.retweet(action.tweetId);
-        return { action: type, success: result.success, error: result.error };
-      }
-      case "follow": {
-        if (!action.handle) return { action: type, success: false, error: "Missing handle" };
-        const client = await getXClient();
-        const result = await client.followUser(action.handle);
-        if (!result.success) {
-          logInteraction({
-            id: `int-${Date.now()}`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-            type: "follow",
-            targetHandle: action.handle.replace(/^@/, ""),
-            creditsUsed: 0,
-            success: false,
-            error: result.error
-          });
-        }
-        return { action: type, success: result.success, error: result.error };
-      }
-      case "schedule": {
-        if (!action.content) return { action: type, success: false, error: "No content" };
-        const entry = addToQueue(action.content);
-        logger.info(`Scheduled: "${action.content.slice(0, 50)}..." for ${entry.scheduledFor}`);
-        return { action: type, success: true, detail: `Scheduled for ${entry.scheduledFor}` };
-      }
-      case "learn": {
-        if (!action.content) return { action: type, success: false, error: "No content" };
-        addLearning(action.content, "agent", action.tags ?? ["heartbeat"]);
-        logger.info(`Learned: "${action.content.slice(0, 50)}..."`);
-        return { action: type, success: true };
-      }
-      case "reflect": {
-        if (!action.content) return { action: type, success: false, error: "No content" };
-        const identity = loadIdentity();
-        identity.evolutionJournal.push({
-          date: (/* @__PURE__ */ new Date()).toISOString(),
-          reflection: action.content
-        });
-        saveIdentity(identity);
-        logger.info(`Reflected: "${action.content.slice(0, 50)}..."`);
-        return { action: type, success: true };
-      }
-      case "skip": {
-        logger.info(`Skipping: ${action.reason ?? action.reasoning ?? "no reason given"}`);
-        return { action: type, success: true, detail: action.reason ?? action.reasoning };
-      }
-      default:
-        logger.warn(`Unknown action: ${type}`);
-        return { action: type, success: false, error: `Unknown action: ${type}` };
-    }
-  } catch (error) {
-    const msg = error.message;
-    logger.error(`Action ${type} failed: ${msg}`);
-    return { action: type, success: false, error: msg };
-  }
-}
-
-// src/runtime/policy.ts
-function normalize(text) {
-  return text.toLowerCase().replace(/https?:\/\/\S+/g, "").replace(/[@#]\w+/g, "").replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function tokenSet(text) {
-  const tokens = normalize(text).split(" ").filter(Boolean);
-  return new Set(tokens);
-}
-function jaccardSimilarity(a, b) {
-  const aSet = tokenSet(a);
-  const bSet = tokenSet(b);
-  if (aSet.size === 0 || bSet.size === 0) return 0;
-  let overlap = 0;
-  for (const token of aSet) {
-    if (bSet.has(token)) overlap += 1;
-  }
-  const union = aSet.size + bSet.size - overlap;
-  return union === 0 ? 0 : overlap / union;
-}
-function firstWords(text, n) {
-  return normalize(text).split(" ").filter(Boolean).slice(0, n).join(" ");
-}
-function hasAllCapsEnding(text) {
-  const ending = text.split(/[.!?]/).map((s) => s.trim()).filter(Boolean).slice(-1)[0] ?? "";
-  const words = ending.split(/\s+/).filter(Boolean);
-  if (words.length < 3) return false;
-  return words.every((word) => /^[A-Z0-9]+$/.test(word));
-}
-function wordCount(text) {
-  return normalize(text).split(" ").filter(Boolean).length;
-}
-function sentenceCount(text) {
-  return text.split(/[.!?]/).map((part) => part.trim()).filter(Boolean).length;
-}
-function explanatoryMarkerHits(text) {
-  const lower = text.toLowerCase();
-  const markers = [
-    "the real issue",
-    "the core issue",
-    "in other words",
-    "the point is",
-    "what this means",
-    "the lesson",
-    "therefore",
-    "ultimately",
-    "meanwhile",
-    "this reveals",
-    "this proves"
-  ];
-  return markers.reduce((hits, marker) => hits + (lower.includes(marker) ? 1 : 0), 0);
-}
-function soundsLikeLecture(content) {
-  const words = wordCount(content);
-  const commas = (content.match(/,/g) ?? []).length;
-  const semicolons = (content.match(/;/g) ?? []).length;
-  const hasQuestion = content.includes("?");
-  const markerHits = explanatoryMarkerHits(content);
-  if (words > 58) return true;
-  if (words > 42 && commas + semicolons >= 3 && !hasQuestion) return true;
-  if (markerHits >= 2) return true;
-  return false;
-}
-function soundsTooHedgedForPersona(content) {
-  try {
-    const identity = loadIdentity();
-    const assertive = identity.traits.confidence >= 0.72 || identity.traits.aggression >= 0.62 || identity.conflictStyle === "clap-back" || identity.conflictStyle === "debate";
-    if (!assertive) return false;
-    const lower = content.toLowerCase();
-    const hedges = [
-      "you're both right",
-      "both can be true",
-      "on one hand",
-      "on the other hand",
-      "it depends",
-      "it's complicated",
-      "nuance",
-      "fair point from both"
-    ];
-    return hedges.some((phrase) => lower.includes(phrase));
-  } catch {
-    return false;
-  }
-}
-function allowsPhilosopherCadence() {
-  try {
-    const identity = loadIdentity();
-    if (identity.framework === "philosopher") return true;
-    if (identity.framework === "truthseeker") return false;
-    return false;
-  } catch {
-    return false;
-  }
-}
-function philosophicalPatternHits(content) {
-  const lower = content.toLowerCase();
-  const markers = [
-    "the real question",
-    "the deeper question",
-    "what becomes possible",
-    "is just the start",
-    "the future isn't about",
-    "the future is not about",
-    "when intelligence becomes",
-    "protocols are infrastructure",
-    "the core future",
-    "the true question",
-    "value might emerge",
-    "isn't about",
-    "is not about",
-    "it's about",
-    "just the start"
-  ];
-  return markers.reduce((hits, marker) => hits + (lower.includes(marker) ? 1 : 0), 0);
-}
-function abstractWordCount(content) {
-  const words = normalize(content).split(" ").filter(Boolean);
-  const abstractWords = /* @__PURE__ */ new Set([
-    "infrastructure",
-    "protocol",
-    "protocols",
-    "architecture",
-    "architectures",
-    "consciousness",
-    "economy",
-    "economics",
-    "currency",
-    "systems",
-    "system",
-    "future",
-    "intelligence",
-    "optimization",
-    "abstraction",
-    "paradigm",
-    "emerge",
-    "emergence",
-    "governs",
-    "governance"
-  ]);
-  return words.filter((word) => abstractWords.has(word)).length;
-}
-function usesManifestoPunctuation(content) {
-  return content.includes(":") || content.includes(";") || content.includes("\u2014");
-}
-var OVERLAP_STOPWORDS = /* @__PURE__ */ new Set([
-  "this",
-  "that",
-  "with",
-  "from",
-  "have",
-  "what",
-  "when",
-  "where",
-  "which",
-  "your",
-  "youre",
-  "they",
-  "them",
-  "about",
-  "into",
-  "over",
-  "under",
-  "while",
-  "just",
-  "like",
-  "really",
-  "there",
-  "their",
-  "then",
-  "than",
-  "because",
-  "would",
-  "could",
-  "should",
-  "being",
-  "been",
-  "it's",
-  "its",
-  "the",
-  "and",
-  "for",
-  "are",
-  "was",
-  "were",
-  "will",
-  "not",
-  "but",
-  "you",
-  "our",
-  "out",
-  "all",
-  "too",
-  "can",
-  "get",
-  "got",
-  "any"
-]);
-function meaningfulTokenSet(text) {
-  const tokens = normalize(text).split(" ").filter((token) => token.length >= 4 && !OVERLAP_STOPWORDS.has(token));
-  return new Set(tokens);
-}
-function hasMeaningfulContextOverlap(content, targetText) {
-  const a = meaningfulTokenSet(content);
-  const b = meaningfulTokenSet(targetText);
-  if (a.size === 0 || b.size === 0) return false;
-  for (const token of a) {
-    if (b.has(token)) return true;
-  }
-  return false;
-}
-function recentWrittenContent() {
-  const recent = getRecentInteractions(40);
-  return recent.filter((i) => i.type === "post" || i.type === "reply").map((i) => i.content ?? "").filter((content) => content.length > 0);
-}
-var REPETITION_STOPWORDS = /* @__PURE__ */ new Set([
-  "about",
-  "after",
-  "again",
-  "against",
-  "almost",
-  "always",
-  "among",
-  "because",
-  "being",
-  "between",
-  "could",
-  "every",
-  "first",
-  "found",
-  "from",
-  "going",
-  "great",
-  "have",
-  "having",
-  "here",
-  "into",
-  "just",
-  "like",
-  "make",
-  "more",
-  "most",
-  "much",
-  "only",
-  "other",
-  "over",
-  "really",
-  "same",
-  "some",
-  "such",
-  "than",
-  "that",
-  "their",
-  "there",
-  "these",
-  "they",
-  "this",
-  "those",
-  "through",
-  "time",
-  "very",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "with",
-  "would",
-  "your",
-  "youre",
-  "dont",
-  "cant",
-  "will",
-  "shall",
-  "should",
-  "also",
-  "tweet",
-  "tweets",
-  "thread",
-  "threads",
-  "future",
-  "human",
-  "humans",
-  "technology",
-  "tech",
-  "build",
-  "building",
-  "system",
-  "systems",
-  "agent",
-  "agents"
-]);
-function informativeTokens(text) {
-  return normalize(text).split(" ").filter((token) => token.length >= 5 && !REPETITION_STOPWORDS.has(token));
-}
-function findOverusedAnchor(content, recent) {
-  const recentWindow = recent.slice(0, 12);
-  if (recentWindow.length < 5) return null;
-  const tokenCounts = /* @__PURE__ */ new Map();
-  const bigramCounts = /* @__PURE__ */ new Map();
-  for (const sample of recentWindow) {
-    const tokens = informativeTokens(sample);
-    const uniqueTokens = new Set(tokens);
-    for (const token of uniqueTokens) {
-      tokenCounts.set(token, (tokenCounts.get(token) ?? 0) + 1);
-    }
-    for (let i = 0; i < tokens.length - 1; i += 1) {
-      const bigram = `${tokens[i]} ${tokens[i + 1]}`;
-      bigramCounts.set(bigram, (bigramCounts.get(bigram) ?? 0) + 1);
-    }
-  }
-  const contentTokens = informativeTokens(content);
-  const contentTokenSet = new Set(contentTokens);
-  for (const token of contentTokenSet) {
-    const count = tokenCounts.get(token) ?? 0;
-    if (count >= 4) return token;
-  }
-  for (let i = 0; i < contentTokens.length - 1; i += 1) {
-    const bigram = `${contentTokens[i]} ${contentTokens[i + 1]}`;
-    const count = bigramCounts.get(bigram) ?? 0;
-    if (count >= 3) return bigram;
-  }
-  return null;
-}
-function openingFragment(text, words = 4) {
-  return normalize(text).split(" ").filter(Boolean).slice(0, words).join(" ");
-}
-function findOverusedOpening(content, recent) {
-  const opening = openingFragment(content, 4);
-  if (!opening || opening.split(" ").length < 3) return null;
-  let matches = 0;
-  for (const sample of recent.slice(0, 12)) {
-    if (openingFragment(sample, 4) === opening) {
-      matches += 1;
-    }
-  }
-  return matches >= 2 ? opening : null;
-}
-function vocabularyNoveltyRatio(content, recent) {
-  const current = new Set(informativeTokens(content));
-  if (current.size === 0) return 1;
-  const seen = /* @__PURE__ */ new Set();
-  for (const sample of recent.slice(0, 14)) {
-    for (const token of informativeTokens(sample)) {
-      seen.add(token);
-    }
-  }
-  let fresh = 0;
-  for (const token of current) {
-    if (!seen.has(token)) fresh += 1;
-  }
-  return fresh / current.size;
-}
-function looksOverAbstractWithoutAnchor(content) {
-  const abstractCount = abstractWordCount(content);
-  if (abstractCount < 4) return false;
-  const words = wordCount(content);
-  const density = abstractCount / Math.max(1, words);
-  if (density < 0.2) return false;
-  const lower = content.toLowerCase();
-  const hasHandle = /@\w+/.test(content);
-  const hasNumber = /\b\d+(\.\d+)?\b/.test(content);
-  const hasQuote = /["“”']/.test(content);
-  const hasSpecificFigure = /\b(musk|elon|zuck|altman|openai|tesla|spacex|meta|google|apple)\b/.test(lower);
-  const hasQuestion = content.includes("?");
-  return !(hasHandle || hasNumber || hasQuote || hasSpecificFigure || hasQuestion);
-}
-function hasStrongConversationOpportunity(timeline, mentions) {
-  if (mentions.length > 0) return true;
-  return timeline.some((tweet) => (tweet.replyCount ?? 0) > 0 || tweet.text.includes("?"));
-}
-function wasInteractionAction(action) {
-  return ["reply", "like", "retweet", "follow"].includes(action.action);
-}
-function isWritingAction(action) {
-  return ["post", "reply", "schedule"].includes(action.action);
-}
-function normalizeHandle(handle) {
-  return (handle ?? "").replace(/^@/, "").trim().toLowerCase();
-}
-function resolveActionTargetHandle(action, tweetById) {
-  if (action.handle) return normalizeHandle(action.handle);
-  if (action.targetHandle) return normalizeHandle(action.targetHandle);
-  if (action.tweetId) return normalizeHandle(tweetById.get(action.tweetId)?.authorHandle);
-  return "";
-}
-function executedWrittenContent(executedActions) {
-  return executedActions.filter((a) => isWritingAction(a) && typeof a.content === "string").map((a) => a.content?.trim() ?? "").filter((content) => content.length > 0);
-}
-function nearExactDuplicate(content, recent) {
-  const normalized = normalize(content);
-  if (!normalized) return false;
-  return recent.some((r) => {
-    const candidate = normalize(r);
-    if (!candidate) return false;
-    if (candidate === normalized) return true;
-    return jaccardSimilarity(content, r) >= 0.88;
-  });
-}
-function isDuplicateTarget(action, executedActions) {
-  if (!action.tweetId) return false;
-  return executedActions.some((a) => a.tweetId === action.tweetId && a.action === action.action);
-}
-function repeatedTemplate(content, recent) {
-  const prefix = firstWords(content, 7);
-  if (!prefix) return false;
-  return recent.some((r) => {
-    const sameStart = firstWords(r, 7) === prefix;
-    const similar = jaccardSimilarity(content, r) >= 0.62;
-    return sameStart || similar;
-  });
-}
-function overusingAllCapsCadence(content, recentEntries) {
-  if (!hasAllCapsEnding(content)) return false;
-  const recentCaps = recentEntries.filter((i) => i.type === "post" && i.content).slice(0, 8).filter((i) => hasAllCapsEnding(i.content ?? ""));
-  return recentCaps.length >= 2;
-}
-function hasRecentlyRepliedToTweet(tweetId) {
-  const recent = getRecentInteractions(200);
-  const nowMs = Date.now();
-  const cooldownMs = 24 * 60 * 60 * 1e3;
-  return recent.some((entry) => {
-    if (entry.type !== "reply") return false;
-    if (entry.inReplyTo !== tweetId) return false;
-    const ts = Date.parse(entry.timestamp);
-    if (Number.isNaN(ts)) return true;
-    return nowMs - ts < cooldownMs;
-  });
-}
-function hasRecentlyFollowedHandle(handle) {
-  const clean = normalizeHandle(handle);
-  if (!clean) return false;
-  const recent = getRecentInteractions(300);
-  const nowMs = Date.now();
-  const cooldownMs = 7 * 24 * 60 * 60 * 1e3;
-  return recent.some((entry) => {
-    if (entry.type !== "follow") return false;
-    if (normalizeHandle(entry.targetHandle) !== clean) return false;
-    const ts = Date.parse(entry.timestamp);
-    if (Number.isNaN(ts)) return true;
-    return nowMs - ts < cooldownMs;
-  });
-}
-function evaluateActionPolicy(context) {
-  const {
-    action,
-    step,
-    timeline,
-    mentions,
-    executedActions,
-    observedTweetIds,
-    observedTweets,
-    selfHandle,
-    selfUserId
-  } = context;
-  const self = normalizeHandle(selfHandle);
-  const selfId = (selfUserId ?? "").trim();
-  const knownTweets = observedTweets ?? [...timeline, ...mentions];
-  const tweetById = new Map(knownTweets.map((tweet) => [tweet.id, tweet]));
-  const constraints = getPersonaConstraints();
-  const strictReplyHandles = new Set(constraints.onlyReplyToHandles.map((handle) => normalizeHandle(handle)));
-  const strictInteractHandles = new Set(personaConstraintHandles(constraints).map((handle) => normalizeHandle(handle)));
-  const targetHandle = resolveActionTargetHandle(action, tweetById);
-  if (constraints.replyOnlyMode && !["reply", "skip", "learn", "reflect"].includes(action.action)) {
-    return {
-      allowed: false,
-      reason: "Persona is in reply-only mode. Use reply actions only."
-    };
-  }
-  if (constraints.noOriginalPosts && (action.action === "post" || action.action === "schedule")) {
-    return {
-      allowed: false,
-      reason: "Persona forbids standalone original posts."
-    };
-  }
-  if (strictReplyHandles.size > 0) {
-    if (action.action !== "reply") {
-      return {
-        allowed: false,
-        reason: `Persona requires replying only to specific target(s): @${[...strictReplyHandles].join(", @")}.`
-      };
-    }
-    if (!targetHandle || !strictReplyHandles.has(targetHandle)) {
-      return {
-        allowed: false,
-        reason: `Reply target must be one of @${[...strictReplyHandles].join(", @")}.`
-      };
-    }
-  }
-  if (strictInteractHandles.size > 0 && ["reply", "like", "retweet", "follow"].includes(action.action)) {
-    if (!targetHandle || !strictInteractHandles.has(targetHandle)) {
-      return {
-        allowed: false,
-        reason: `Interaction target must be one of @${[...strictInteractHandles].join(", @")}.`
-      };
-    }
-  }
-  if (isDuplicateTarget(action, executedActions)) {
-    return { allowed: false, reason: `Action ${action.action} already executed for tweet ${action.tweetId} this heartbeat.` };
-  }
-  if (action.content && isWritingAction(action)) {
-    if (action.content.length > 280) {
-      return {
-        allowed: false,
-        reason: `Content is too long (${action.content.length}/280). Keep it tighter and more conversational.`
-      };
-    }
-    if (action.action === "reply" && wordCount(action.content) > 45 && !action.content.includes("?")) {
-      return {
-        allowed: false,
-        reason: "Reply is too monologue-like. Keep it shorter or ask a direct question."
-      };
-    }
-    if (soundsLikeLecture(action.content)) {
-      return {
-        allowed: false,
-        reason: "Rejected lecture-like writing style. Use a more human, reactive, conversational tone."
-      };
-    }
-    if (soundsTooHedgedForPersona(action.content)) {
-      return {
-        allowed: false,
-        reason: "Rejected hedged consensus phrasing. Your persona should be more decisive and opinionated."
-      };
-    }
-    if (!allowsPhilosopherCadence()) {
-      const phiHits = philosophicalPatternHits(action.content);
-      const abstractCount = abstractWordCount(action.content);
-      const hasQuestion = action.content.includes("?");
-      if (phiHits >= 1 || abstractCount >= 5 && hasQuestion) {
-        return {
-          allowed: false,
-          reason: "Rejected abstract philosopher cadence. Use concrete, contextual language tied to the actual tweet."
-        };
-      }
-      const words = wordCount(action.content);
-      const sentences = sentenceCount(action.content);
-      if (action.action === "reply" && (words > 34 || sentences > 2)) {
-        return {
-          allowed: false,
-          reason: "Reply is too long/explanatory for this persona. Keep it short and direct."
-        };
-      }
-      if (action.action === "post" && (words > 42 || sentences > 3)) {
-        return {
-          allowed: false,
-          reason: "Post is drifting into manifesto style. Keep it more concrete and human."
-        };
-      }
-      if ((action.action === "reply" || action.action === "post") && usesManifestoPunctuation(action.content) && words > 16) {
-        return {
-          allowed: false,
-          reason: "Rejected manifesto punctuation style. Avoid colon/semicolon/em-dash framing."
-        };
-      }
-    }
-    const existingInHeartbeat = executedWrittenContent(executedActions);
-    if (nearExactDuplicate(action.content, existingInHeartbeat)) {
-      return {
-        allowed: false,
-        reason: "Rejected duplicate wording in this heartbeat. Write a distinct message before posting/replying again."
-      };
-    }
-    const recent = recentWrittenContent();
-    const overusedAnchor = findOverusedAnchor(action.content, recent);
-    if (overusedAnchor) {
-      return {
-        allowed: false,
-        reason: `Rejected repetitive anchor phrase/term "${overusedAnchor}". Use a different framing and vocabulary.`
-      };
-    }
-    const overusedOpening = findOverusedOpening(action.content, recent);
-    if (overusedOpening) {
-      return {
-        allowed: false,
-        reason: `Rejected repetitive opening phrase "${overusedOpening}". Start from a fresh angle.`
-      };
-    }
-    if (recent.length >= 6 && wordCount(action.content) >= 10) {
-      const novelty = vocabularyNoveltyRatio(action.content, recent);
-      if (novelty < 0.34) {
-        return {
-          allowed: false,
-          reason: "Rejected low-novelty vocabulary loop. Use fresher words, examples, or a different conversational angle."
-        };
-      }
-    }
-    if (!allowsPhilosopherCadence() && looksOverAbstractWithoutAnchor(action.content)) {
-      return {
-        allowed: false,
-        reason: "Rejected abstract wording without concrete anchor. Reference a specific person, event, quote, or question."
-      };
-    }
-  }
-  const hasConversationOpportunity = hasStrongConversationOpportunity(timeline, mentions);
-  const interactedAlready = executedActions.some(wasInteractionAction);
-  const observedCount = observedTweetIds && observedTweetIds.length > 0 ? observedTweetIds.length : timeline.length + mentions.length;
-  if ((action.action === "reply" || action.action === "like" || action.action === "retweet") && observedCount === 0) {
-    return {
-      allowed: false,
-      reason: "No tweets observed in current context. Avoid blind interactions; gather timeline/search context first."
-    };
-  }
-  if (action.action === "post" && hasConversationOpportunity && !interactedAlready && step < 2) {
-    return {
-      allowed: false,
-      reason: "Engage first: reply/like/follow when mentions or active conversations are available before posting an original tweet."
-    };
-  }
-  if (isWritingAction(action) && action.content) {
-    const recent = recentWrittenContent();
-    if (nearExactDuplicate(action.content, recent)) {
-      return {
-        allowed: false,
-        reason: "Rejected near-duplicate content from recent history. Tailor this message to the specific context."
-      };
-    }
-    if (repeatedTemplate(action.content, recent)) {
-      return {
-        allowed: false,
-        reason: "Rejected repetitive content pattern. Use a more novel structure or engage directly with timeline context."
-      };
-    }
-  }
-  if ((action.action === "post" || action.action === "schedule") && action.content) {
-    const recentInteractions = getRecentInteractions(20);
-    if (overusingAllCapsCadence(action.content, recentInteractions)) {
-      return {
-        allowed: false,
-        reason: "Rejected repetitive all-caps slogan cadence. Vary style and reduce monologue formatting."
-      };
-    }
-  }
-  if ((action.action === "reply" || action.action === "like" || action.action === "retweet") && action.tweetId) {
-    const known = new Set(observedTweetIds ?? [...timeline, ...mentions].map((tweet) => tweet.id));
-    if (!known.has(action.tweetId)) {
-      return {
-        allowed: false,
-        reason: `Tweet ${action.tweetId} is not in current observations. Choose a visible timeline/mention tweet for grounded engagement.`
-      };
-    }
-    const targetTweet = tweetById.get(action.tweetId);
-    if (targetTweet && (self && normalizeHandle(targetTweet.authorHandle) === self || selfId && targetTweet.authorId === selfId)) {
-      return {
-        allowed: false,
-        reason: "Rejected self-interaction. Do not reply/like/retweet your own tweets."
-      };
-    }
-  }
-  if (action.action === "reply" && action.tweetId) {
-    const inStrictTargetMode = strictReplyHandles.size > 0 || strictInteractHandles.size > 0;
-    const repliesThisHeartbeat = executedActions.filter((a) => a.action === "reply").length;
-    if (repliesThisHeartbeat >= 2 && !inStrictTargetMode) {
-      return {
-        allowed: false,
-        reason: "Reply cap reached for this heartbeat. Use another tool action."
-      };
-    }
-    const currentAuthor = normalizeHandle(tweetById.get(action.tweetId)?.authorHandle);
-    if (currentAuthor) {
-      const repliedAuthors = new Set(
-        executedActions.filter((a) => a.action === "reply" && a.tweetId).map((a) => normalizeHandle(tweetById.get(a.tweetId)?.authorHandle)).filter(Boolean)
-      );
-      if (repliedAuthors.has(currentAuthor) && !inStrictTargetMode) {
-        return {
-          allowed: false,
-          reason: `Already replied to @${currentAuthor} this heartbeat. Diversify interactions.`
-        };
-      }
-    }
-    if (hasRecentlyRepliedToTweet(action.tweetId)) {
-      return {
-        allowed: false,
-        reason: `Already replied to tweet ${action.tweetId} recently. Engage a different conversation.`
-      };
-    }
-    if (action.content) {
-      const targetTweet = tweetById.get(action.tweetId);
-      if (targetTweet && !hasMeaningfulContextOverlap(action.content, targetTweet.text)) {
-        const phiHits = philosophicalPatternHits(action.content);
-        if (wordCount(action.content) > 9 || phiHits > 0 || abstractWordCount(action.content) >= 4) {
-          return {
-            allowed: false,
-            reason: "Reply is not grounded in the target tweet context. Reference concrete details from their actual post."
-          };
-        }
-      }
-    }
-  }
-  if (action.action === "follow" && action.handle) {
-    const target = normalizeHandle(action.handle);
-    if (!target) {
-      return { allowed: false, reason: "Follow target is empty." };
-    }
-    if (self && target === self) {
-      return {
-        allowed: false,
-        reason: "Rejected self-follow. Do not follow your own account."
-      };
-    }
-    if (hasRecentlyFollowedHandle(target)) {
-      return {
-        allowed: false,
-        reason: `Already followed @${target} recently. Choose a different action.`
-      };
-    }
-  }
-  return { allowed: true };
-}
-
-// src/memory/agent-network.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
-var SEED_HANDLES = ["sporaai"];
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function normalizeHandle2(handle) {
-  return handle.replace(/^@/, "").trim().toLowerCase();
-}
-function canonicalAgentHandle(handle) {
-  const clean = normalizeHandle2(handle);
-  if (clean === "spora") return "sporaai";
-  return clean;
-}
-function likelyNetworkAgentHandle(handle) {
-  const clean = canonicalAgentHandle(handle);
-  if (!clean) return false;
-  if (clean === "sporaai") return true;
-  if (clean.includes("spora")) return true;
-  if (clean.endsWith("_ai")) return true;
-  if (clean.startsWith("giga")) return true;
-  return false;
-}
-function defaultData() {
-  const now = nowIso();
-  return {
-    version: 1,
-    updatedAt: now,
-    agents: SEED_HANDLES.map((handle) => ({
-      handle,
-      source: "seed",
-      addedAt: now,
-      lastSeenAt: now,
-      seenCount: 1,
-      active: true,
-      notes: ["default seed"]
-    }))
-  };
-}
-function loadData() {
-  if (!existsSync(paths.agentNetwork)) return defaultData();
-  try {
-    const parsed = JSON.parse(readFileSync(paths.agentNetwork, "utf-8"));
-    const agents = Array.isArray(parsed.agents) ? parsed.agents : [];
-    return {
-      version: typeof parsed.version === "number" ? parsed.version : 1,
-      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : nowIso(),
-      agents: agents.map((entry) => {
-        const handle = canonicalAgentHandle(String(entry.handle ?? ""));
-        if (!handle) return null;
-        return {
-          handle,
-          source: entry.source ?? "observed",
-          addedAt: typeof entry.addedAt === "string" ? entry.addedAt : nowIso(),
-          lastSeenAt: typeof entry.lastSeenAt === "string" ? entry.lastSeenAt : nowIso(),
-          seenCount: typeof entry.seenCount === "number" ? Math.max(1, entry.seenCount) : 1,
-          active: entry.active !== false,
-          notes: Array.isArray(entry.notes) ? entry.notes.map((note) => String(note)) : []
-        };
-      }).filter((entry) => Boolean(entry))
-    };
-  } catch {
-    return defaultData();
-  }
-}
-function saveData(data) {
-  const now = nowIso();
-  const byHandle = /* @__PURE__ */ new Map();
-  for (const entry of data.agents) {
-    const handle = canonicalAgentHandle(entry.handle);
-    if (!handle) continue;
-    const existing = byHandle.get(handle);
-    if (!existing) {
-      byHandle.set(handle, {
-        ...entry,
-        handle
-      });
-      continue;
-    }
-    const addedAt = Date.parse(existing.addedAt) <= Date.parse(entry.addedAt) ? existing.addedAt : entry.addedAt;
-    const lastSeenAt = Date.parse(existing.lastSeenAt) >= Date.parse(entry.lastSeenAt) ? existing.lastSeenAt : entry.lastSeenAt;
-    byHandle.set(handle, {
-      handle,
-      source: existing.source === "seed" ? "seed" : entry.source,
-      addedAt,
-      lastSeenAt,
-      seenCount: Math.max(existing.seenCount, entry.seenCount),
-      active: existing.active || entry.active,
-      notes: [.../* @__PURE__ */ new Set([...existing.notes, ...entry.notes])].slice(-8)
-    });
-  }
-  if (!byHandle.has("sporaai")) {
-    byHandle.set("sporaai", {
-      handle: "sporaai",
-      source: "seed",
-      addedAt: now,
-      lastSeenAt: now,
-      seenCount: 1,
-      active: true,
-      notes: ["default seed"]
-    });
-  }
-  const agents = [...byHandle.values()].filter((entry) => entry.active).sort((a, b) => {
-    if (a.handle === "sporaai") return -1;
-    if (b.handle === "sporaai") return 1;
-    const bySeen = Date.parse(b.lastSeenAt) - Date.parse(a.lastSeenAt);
-    if (!Number.isNaN(bySeen) && bySeen !== 0) return bySeen;
-    return b.seenCount - a.seenCount;
-  }).slice(0, 200);
-  const next = {
-    version: 1,
-    updatedAt: now,
-    agents
-  };
-  writeFileSync(paths.agentNetwork, JSON.stringify(next, null, 2));
-}
-function upsertHandleInternal(data, handle, source, note) {
-  const clean = canonicalAgentHandle(handle);
-  if (!clean) return false;
-  if (!likelyNetworkAgentHandle(clean) && source !== "seed" && source !== "manual") return false;
-  const now = nowIso();
-  const existing = data.agents.find((entry) => canonicalAgentHandle(entry.handle) === clean);
-  if (!existing) {
-    data.agents.push({
-      handle: clean,
-      source,
-      addedAt: now,
-      lastSeenAt: now,
-      seenCount: 1,
-      active: true,
-      notes: note ? [note] : []
-    });
-    return true;
-  }
-  existing.lastSeenAt = now;
-  existing.seenCount += 1;
-  existing.active = true;
-  if (existing.source !== "seed") {
-    existing.source = source;
-  }
-  if (note) {
-    existing.notes = [.../* @__PURE__ */ new Set([...existing.notes, note])].slice(-8);
-  }
-  return false;
-}
-function upsertAgentHandle(handle, source, note) {
-  const data = loadData();
-  upsertHandleInternal(data, handle, source, note);
-  saveData(data);
-}
-function upsertAgentHandles(handles, source, note) {
-  if (handles.length === 0) return;
-  const data = loadData();
-  for (const handle of handles) {
-    upsertHandleInternal(data, handle, source, note);
-  }
-  saveData(data);
-}
-function listAgentNetworkHandles(limit = 20) {
-  const data = loadData();
-  saveData(data);
-  return data.agents.filter((entry) => entry.active).slice(0, limit).map((entry) => canonicalAgentHandle(entry.handle));
-}
-
-// src/runtime/research.ts
-var handleToIdCache = /* @__PURE__ */ new Map();
-var topicQueryHistory = [];
-var peopleMonitorHistory = [];
-function shuffle(items) {
-  const arr = [...items];
-  for (let i = arr.length - 1; i > 0; i -= 1) {
-    const j = Math.floor(Math.random() * (i + 1));
-    const tmp = arr[i];
-    arr[i] = arr[j];
-    arr[j] = tmp;
-  }
-  return arr;
-}
-function clampInt(value, min, max) {
-  return Math.max(min, Math.min(max, Math.round(value)));
-}
-function buildTopicQueryVariants(topic) {
-  const trimmed = topic.trim();
-  if (!trimmed) return [];
-  return [
-    trimmed,
-    `${trimmed} take`,
-    `${trimmed} question`,
-    `${trimmed} experience`,
-    `"${trimmed}" lang:en -is:retweet`
-  ];
-}
-function splitTopicSignal(signal) {
-  const normalized = signal.trim().toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim();
-  if (!normalized) return [];
-  const words = normalized.split(" ");
-  if (words.length <= 6) return [normalized];
-  const compact = words.slice(0, 5).join(" ");
-  const keywords = words.filter((word) => word.length >= 5).slice(0, 3);
-  return [compact, ...keywords];
-}
-function buildTargetedPersonQueries(handles, heartbeatCount, budget) {
-  if (handles.length === 0 || budget <= 0) return [];
-  const start = heartbeatCount % handles.length;
-  const selected = [];
-  for (let i = 0; i < Math.min(budget, handles.length); i += 1) {
-    const handle = handles[(start + i) % handles.length];
-    selected.push(`from:${handle} -is:retweet`);
-  }
-  return selected;
-}
-function isLikelySyntheticHandle(handle) {
-  const clean = canonicalAgentHandle(handle);
-  return clean.endsWith("_ai") || clean.endsWith("bot");
-}
-function extractMentionHandles(text) {
-  return [...text.matchAll(/@([a-zA-Z0-9_]{1,15})/g)].map((match) => canonicalAgentHandle(match[1])).filter(Boolean);
-}
-var STOPWORDS = /* @__PURE__ */ new Set([
-  "about",
-  "after",
-  "again",
-  "against",
-  "among",
-  "because",
-  "being",
-  "between",
-  "could",
-  "every",
-  "first",
-  "found",
-  "from",
-  "going",
-  "have",
-  "having",
-  "here",
-  "into",
-  "just",
-  "like",
-  "make",
-  "more",
-  "most",
-  "much",
-  "only",
-  "other",
-  "over",
-  "really",
-  "same",
-  "some",
-  "such",
-  "than",
-  "that",
-  "their",
-  "there",
-  "these",
-  "they",
-  "this",
-  "those",
-  "through",
-  "time",
-  "very",
-  "what",
-  "when",
-  "where",
-  "which",
-  "while",
-  "with",
-  "would",
-  "your",
-  "youre",
-  "im",
-  "its",
-  "cant",
-  "dont",
-  "will",
-  "shall",
-  "should",
-  "also",
-  "twitter",
-  "tweet",
-  "tweets",
-  "thread",
-  "threads",
-  "http",
-  "https",
-  "retweet"
-]);
-function discoverQueriesFromTweets(tweets, budget) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const tweet of tweets) {
-    const tokens = tweet.text.toLowerCase().replace(/https?:\/\/\S+/g, " ").replace(/[@#]\w+/g, " ").replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
-    for (const token of tokens) {
-      if (token.length < 5) continue;
-      if (/^\d+$/.test(token)) continue;
-      if (STOPWORDS.has(token)) continue;
-      counts.set(token, (counts.get(token) ?? 0) + 1);
-    }
-  }
-  return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, budget).map(([token]) => `"${token}" lang:en -is:retweet`);
-}
-function discoverPeopleFromTweets(tweets, selfHandle, budget) {
-  const scores = /* @__PURE__ */ new Map();
-  for (const tweet of tweets) {
-    const handle = tweet.authorHandle.replace(/^@/, "").toLowerCase();
-    if (!handle || handle === "unknown" || handle === selfHandle) continue;
-    let score = 1;
-    score += Math.min((tweet.replyCount ?? 0) / 15, 1.2);
-    score += Math.min((tweet.likeCount ?? 0) / 220, 0.9);
-    score += Math.min((tweet.retweetCount ?? 0) / 120, 0.8);
-    if (tweet.text.includes("?")) score += 0.25;
-    const existing = scores.get(handle) ?? 0;
-    if (score > existing) scores.set(handle, score);
-  }
-  return [...scores.entries()].sort((a, b) => b[1] - a[1]).slice(0, budget).map(([handle]) => handle);
-}
-function pickTopicQueries(allTopics, budget) {
-  const recent = new Set(topicQueryHistory.slice(-10));
-  const candidates = shuffle(allTopics.flatMap(buildTopicQueryVariants));
-  const picked = [];
-  for (const query of candidates) {
-    const normalized = query.toLowerCase();
-    if (recent.has(normalized)) continue;
-    picked.push(query);
-    if (picked.length >= budget) break;
-  }
-  if (picked.length < budget) {
-    for (const query of candidates) {
-      picked.push(query);
-      if (picked.length >= budget) break;
-    }
-  }
-  for (const query of picked) {
-    topicQueryHistory.push(query.toLowerCase());
-  }
-  if (topicQueryHistory.length > 100) {
-    topicQueryHistory.splice(0, topicQueryHistory.length - 100);
-  }
-  return picked;
-}
-function pickDirectQueries(queries, budget) {
-  const recent = new Set(topicQueryHistory.slice(-10));
-  const candidates = shuffle(queries);
-  const picked = [];
-  for (const query of candidates) {
-    const normalized = query.toLowerCase();
-    if (recent.has(normalized)) continue;
-    picked.push(query);
-    if (picked.length >= budget) break;
-  }
-  if (picked.length < budget) {
-    for (const query of candidates) {
-      if (picked.includes(query)) continue;
-      picked.push(query);
-      if (picked.length >= budget) break;
-    }
-  }
-  for (const query of picked) {
-    topicQueryHistory.push(query.toLowerCase());
-  }
-  if (topicQueryHistory.length > 100) {
-    topicQueryHistory.splice(0, topicQueryHistory.length - 100);
-  }
-  return picked;
-}
-async function resolveHandleToId(client, handle) {
-  const clean = handle.replace(/^@/, "");
-  if (handleToIdCache.has(clean)) {
-    return handleToIdCache.get(clean);
-  }
-  try {
-    const profile = await client.getProfile(clean);
-    handleToIdCache.set(clean, profile.id);
-    return profile.id;
-  } catch {
-    logger.warn(`Could not resolve handle @${clean} to user ID`);
-    return null;
-  }
-}
-async function runResearchPhase(client, heartbeatCount) {
-  const context = {
-    timeline: [],
-    mentions: [],
-    topicSearchResults: [],
-    peopleActivity: [],
-    ownPostPerformance: []
-  };
-  const [timeline, mentions] = await Promise.all([
-    client.getTimeline({ count: 20 }).catch(() => []),
-    client.getMentions({ count: 10 }).catch(() => [])
-  ]);
-  context.timeline = timeline;
-  context.mentions = mentions;
-  context.topicSearchResults = await runTopicSearch(client, heartbeatCount, [...timeline, ...mentions]);
-  context.peopleActivity = await runPeopleMonitoring(client, heartbeatCount, [...timeline, ...mentions]);
-  if (heartbeatCount % 2 === 0) {
-    context.ownPostPerformance = refreshOwnPostPerformance();
-  }
-  return context;
-}
-async function runTopicSearch(client, heartbeatCount, seedTweets) {
-  try {
-    const identity = loadIdentity();
-    const constraints = getPersonaConstraints(identity);
-    const strictHandles = personaConstraintHandles(constraints).filter(Boolean);
-    const strategy = loadStrategy();
-    const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
-    const selfHandle = canonicalAgentHandle(identity.handle);
-    const topicSearchBias = personaProfile.sourceBias.topic_search;
-    const peopleWatchBias = personaProfile.sourceBias.people_watch;
-    const allTopics = [
-      ...personaProfile.priorityTopics,
-      ...identity.topics ?? [],
-      ...strategy.currentFocus
-    ].flatMap(splitTopicSignal).filter(Boolean);
-    const discoveredBudget = clampInt(1 + Math.max(0, topicSearchBias), 1, 3);
-    const discovered = discoverQueriesFromTweets(seedTweets, discoveredBudget);
-    const targetHandles = [.../* @__PURE__ */ new Set([
-      ...strategy.peopleToEngage.filter((person) => person.priority === "high" || person.priority === "medium").map((person) => person.handle.replace(/^@/, "").toLowerCase()),
-      ...(identity.heroes ?? []).map((handle) => handle.replace(/^@/, "").toLowerCase())
-    ])].filter((handle) => handle && handle !== selfHandle);
-    const strictQueries = buildTargetedPersonQueries(
-      strictHandles.filter((handle) => handle !== selfHandle),
-      heartbeatCount,
-      clampInt(2 + Math.max(0, topicSearchBias), 1, 4)
-    );
-    const personQueries = buildTargetedPersonQueries(
-      targetHandles,
-      heartbeatCount,
-      clampInt(1 + Math.max(0, peopleWatchBias), 0, 3)
-    );
-    const topicBudget = clampInt(3 + topicSearchBias, 1, 5);
-    const topicQueries = allTopics.length > 0 ? pickTopicQueries(allTopics, Math.min(topicBudget, Math.max(1, allTopics.length))) : [];
-    const discoveredQueries = discovered.length > 0 ? pickDirectQueries(discovered, Math.min(discoveredBudget, discovered.length)) : [];
-    const topicsToSearch = strictQueries.length > 0 ? [...new Set(strictQueries)] : [.../* @__PURE__ */ new Set([...topicQueries, ...discoveredQueries, ...personQueries])];
-    if (topicsToSearch.length === 0) return [];
-    const results = [];
-    for (const topicQuery of topicsToSearch) {
-      try {
-        const tweets = (await client.searchTweets(topicQuery, { count: 10 })).filter(
-          (tweet) => tweet.authorHandle.replace(/^@/, "").toLowerCase() !== selfHandle
-        );
-        if (tweets.length > 0) {
-          results.push({ query: topicQuery, tweets });
-          logger.info(`Topic search "${topicQuery}": found ${tweets.length} tweets`);
-        }
-      } catch {
-      }
-    }
-    return results;
-  } catch {
-    return [];
-  }
-}
-async function runPeopleMonitoring(client, heartbeatCount, seedTweets) {
-  try {
-    const strategy = loadStrategy();
-    const identity = loadIdentity();
-    const constraints = getPersonaConstraints(identity);
-    const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
-    const strictHandles = personaConstraintHandles(constraints).map((handle) => canonicalAgentHandle(handle)).filter((handle) => handle.length > 0);
-    const selfHandle = identity.handle.replace(/^@/, "").toLowerCase();
-    const relationships = loadRelationships();
-    const networkHandles = listAgentNetworkHandles(20);
-    const networkHandleSet = new Set(networkHandles);
-    if (strictHandles.length > 0) {
-      const strictResults = [];
-      for (const handle of strictHandles) {
-        if (handle === selfHandle) continue;
-        const userId = await resolveHandleToId(client, handle);
-        if (!userId) continue;
-        try {
-          const tweets = await client.getUserTweets(userId, { count: 8 });
-          if (tweets.length === 0) continue;
-          strictResults.push({
-            handle,
-            userId,
-            reason: "persona hard constraint",
-            tweets
-          });
-          upsertAgentHandle(handle, "observed", "people check (strict persona target)");
-          logger.info(`People check @${handle}: ${tweets.length} recent tweets (strict target mode)`);
-        } catch {
-        }
-      }
-      return strictResults;
-    }
-    const people = [];
-    const seen = /* @__PURE__ */ new Set();
-    const highPriorityHandles = new Set(
-      strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => person.handle.replace(/^@/, "").toLowerCase())
-    );
-    const protectedHandles = /* @__PURE__ */ new Set([
-      ...highPriorityHandles,
-      ...(identity.heroes ?? []).map((handle) => handle.replace(/^@/, "").toLowerCase()),
-      ...networkHandleSet
-    ]);
-    const addPerson = (handle, reason, pinned2 = false) => {
-      const clean = canonicalAgentHandle(handle);
-      if (seen.has(clean)) return;
-      if (clean === selfHandle) return;
-      if (isLikelySyntheticHandle(clean) && !protectedHandles.has(clean)) return;
-      seen.add(clean);
-      people.push({ handle: clean, reason, pinned: pinned2 });
-    };
-    for (const p of strategy.peopleToEngage.filter((p2) => p2.priority === "high")) {
-      addPerson(p.handle, p.reason, true);
-    }
-    const sporaPinInterval = personaProfile.sourceBias.people_watch >= 0.6 ? 4 : 8;
-    for (const handle of networkHandles) {
-      if (handle === "sporaai") {
-        const pinSpora = heartbeatCount % sporaPinInterval === 0;
-        addPerson(handle, "core Spora profile", pinSpora);
-      } else {
-        addPerson(handle, "spora agent network");
-      }
-    }
-    for (const hero of identity.heroes ?? []) {
-      addPerson(hero, "hero/inspiration");
-    }
-    const sporeRels = Object.values(relationships.accounts).filter((rel) => rel.isSpore).sort((a, b) => b.interactionCount - a.interactionCount).slice(0, 5);
-    for (const rel of sporeRels) {
-      addPerson(rel.handle, "spora relationship");
-      upsertAgentHandle(rel.handle, "relationship", "relationship marked isSpore");
-    }
-    const topRels = Object.values(relationships.accounts).sort((a, b) => b.interactionCount - a.interactionCount).slice(0, 5);
-    for (const r of topRels) {
-      addPerson(r.handle, "frequent interactor");
-    }
-    for (const p of strategy.peopleToEngage.filter((p2) => p2.priority === "medium")) {
-      addPerson(p.handle, p.reason);
-    }
-    for (const handle of discoverPeopleFromTweets(seedTweets, selfHandle, 6)) {
-      addPerson(handle, "active voice in current conversations");
-    }
-    if (people.length === 0) return [];
-    const monitoringBudget = clampInt(3 + personaProfile.sourceBias.people_watch, 2, 5);
-    const budget = Math.min(monitoringBudget, people.length);
-    const selected = [];
-    const selectedHandles = /* @__PURE__ */ new Set();
-    const pinned = people.filter((person) => person.pinned);
-    for (const person of pinned) {
-      if (selected.length >= budget) break;
-      selected.push(person);
-      selectedHandles.add(person.handle);
-    }
-    if (selected.length < budget) {
-      const rest = people.filter((person) => !selectedHandles.has(person.handle));
-      if (rest.length > 0) {
-        const startIdx = heartbeatCount * 2 % rest.length;
-        const rotated = [...rest.slice(startIdx), ...rest.slice(0, startIdx)];
-        const recentlyChecked = new Set(peopleMonitorHistory.slice(-8));
-        const preferred = rotated.filter((person) => !recentlyChecked.has(person.handle));
-        const pool = preferred.length >= budget - selected.length ? preferred : rotated;
-        for (const person of pool) {
-          if (selected.length >= budget) break;
-          selected.push(person);
-        }
-      }
-    }
-    for (const person of selected) {
-      peopleMonitorHistory.push(person.handle);
-    }
-    if (peopleMonitorHistory.length > 120) {
-      peopleMonitorHistory.splice(0, peopleMonitorHistory.length - 120);
-    }
-    const results = [];
-    const discoveredHandles = /* @__PURE__ */ new Set();
-    for (const person of selected) {
-      const userId = await resolveHandleToId(client, person.handle);
-      if (!userId) continue;
-      try {
-        const tweets = await client.getUserTweets(userId, { count: 5 });
-        if (tweets.length > 0) {
-          results.push({
-            handle: person.handle,
-            userId,
-            reason: person.reason,
-            tweets
-          });
-          upsertAgentHandle(person.handle, "observed", "people check");
-          discoveredHandles.add(canonicalAgentHandle(person.handle));
-          for (const tweet of tweets) {
-            for (const mentionHandle of extractMentionHandles(tweet.text)) {
-              discoveredHandles.add(canonicalAgentHandle(mentionHandle));
-            }
-          }
-          logger.info(`People check @${person.handle}: ${tweets.length} recent tweets`);
-        }
-      } catch {
-      }
-    }
-    if (discoveredHandles.size > 0) {
-      upsertAgentHandles([...discoveredHandles], "observed", "discovered via people monitoring");
-    }
-    return results;
-  } catch {
-    return [];
-  }
-}
-function refreshOwnPostPerformance() {
-  try {
-    retireOldPosts();
-    return getActiveTrackedPosts().slice(-5);
-  } catch {
-    return [];
-  }
-}
-
-// src/runtime/opportunity-engine.ts
-function normalizeHandle3(handle) {
-  return (handle ?? "").replace(/^@/, "").trim().toLowerCase();
-}
-function isLikelySyntheticHandle2(handle) {
-  const clean = normalizeHandle3(handle);
-  return clean === "spora" || clean.endsWith("_ai") || clean.endsWith("bot");
-}
-function normalizeText(text) {
-  return text.toLowerCase().replace(/https?:\/\/\S+/g, " ").replace(/[@#]\w+/g, " ").replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function clip(text, max = 190) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 3)}...`;
-}
-function splitKeywords(text) {
-  const normalized = normalizeText(text);
-  if (!normalized) return [];
-  const words = normalized.split(" ");
-  if (words.length <= 6) return [normalized];
-  const concise = words.filter((word) => word.length >= 4).slice(0, 6);
-  return concise.length > 0 ? concise : [words.slice(0, 6).join(" ")];
-}
-function unique(values) {
-  return [...new Set(values)];
-}
-function buildPersonaContext() {
-  const identity = loadIdentity();
-  const constraints = getPersonaConstraints(identity);
-  const strategy = loadStrategy();
-  const actionProfile = compilePersonaActionProfile({ identity, strategy, constraints });
-  const focusKeywords = unique(
-    [
-      ...identity.topics,
-      ...identity.coreValues,
-      ...identity.goals,
-      ...strategy.currentFocus,
-      ...strategy.shortTermGoals
-    ].flatMap(splitKeywords).map((keyword) => keyword.trim()).filter((keyword) => keyword.length >= 3).slice(0, 40)
-  );
-  const avoidKeywords = unique(
-    identity.avoidTopics.flatMap(splitKeywords).map((keyword) => keyword.trim()).filter((keyword) => keyword.length >= 3).slice(0, 20)
-  );
-  const priorityHandles = new Set(
-    strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => normalizeHandle3(person.handle)).filter(Boolean)
-  );
-  for (const handle of personaConstraintHandles(constraints)) {
-    priorityHandles.add(normalizeHandle3(handle));
-  }
-  const heroHandles = new Set(
-    (identity.heroes ?? []).map((handle) => normalizeHandle3(handle)).filter(Boolean)
-  );
-  const networkHandles = new Set(listAgentNetworkHandles(60).map((handle) => normalizeHandle3(handle)).filter(Boolean));
-  return { focusKeywords, avoidKeywords, priorityHandles, heroHandles, networkHandles, actionProfile };
-}
-function personaActionDelta(actionType, source, profile) {
-  return profile.actionBias[actionType] * 0.9 + profile.sourceBias[source] * 0.55;
-}
-function isActionStronglySuppressed(actionType, profile) {
-  return profile.actionBias[actionType] <= -1.35;
-}
-function matchesPersonaGeneratedProfile(actionType, source, profile) {
-  const actionBias = profile.actionBias[actionType];
-  const sourceBias = profile.sourceBias[source];
-  const combined = personaActionDelta(actionType, source, profile);
-  if (actionBias <= -0.55) return false;
-  if (sourceBias <= -1.05) return false;
-  if (combined <= -0.3) return false;
-  return true;
-}
-function phraseMatchScore(text, keywords) {
-  if (keywords.length === 0) return 0;
-  const normalized = normalizeText(text);
-  if (!normalized) return 0;
-  let score = 0;
-  for (const keyword of keywords) {
-    const needle = normalizeText(keyword);
-    if (!needle) continue;
-    if (!normalized.includes(needle)) continue;
-    const wordCount2 = needle.split(" ").length;
-    score += wordCount2 >= 2 ? 0.7 : 0.35;
-  }
-  return Math.min(score, 2.4);
-}
-function recencyPenalty(lastTouchedAt) {
-  if (!lastTouchedAt) return 0;
-  const ageHours = (Date.now() - lastTouchedAt) / (1e3 * 60 * 60);
-  if (ageHours < 1) return 2;
-  if (ageHours < 4) return 1.1;
-  if (ageHours < 12) return 0.55;
-  return 0;
-}
-function buildRecentIndexes(recent) {
-  const repliedTweetIds = /* @__PURE__ */ new Set();
-  const likedTweetIds = /* @__PURE__ */ new Set();
-  const retweetedTweetIds = /* @__PURE__ */ new Set();
-  const followedHandles = /* @__PURE__ */ new Set();
-  const authorTouchCount = /* @__PURE__ */ new Map();
-  const authorLastTouchedAt = /* @__PURE__ */ new Map();
-  for (const entry of recent) {
-    if (entry.type === "reply" && entry.inReplyTo) {
-      repliedTweetIds.add(entry.inReplyTo);
-    }
-    if (entry.type === "like" && entry.tweetId) {
-      likedTweetIds.add(entry.tweetId);
-    }
-    if (entry.type === "retweet" && entry.tweetId) {
-      retweetedTweetIds.add(entry.tweetId);
-    }
-    if (entry.type === "follow" && entry.targetHandle) {
-      followedHandles.add(normalizeHandle3(entry.targetHandle));
-    }
-    if (entry.targetHandle) {
-      const handle = normalizeHandle3(entry.targetHandle);
-      if (!handle) continue;
-      authorTouchCount.set(handle, (authorTouchCount.get(handle) ?? 0) + 1);
-      const ts = Date.parse(entry.timestamp);
-      if (!Number.isNaN(ts)) {
-        const existing = authorLastTouchedAt.get(handle) ?? 0;
-        if (ts > existing) authorLastTouchedAt.set(handle, ts);
-      }
-    }
-  }
-  return {
-    repliedTweetIds,
-    likedTweetIds,
-    retweetedTweetIds,
-    followedHandles,
-    authorTouchCount,
-    authorLastTouchedAt
-  };
-}
-function sourceWeight(source) {
-  if (source === "mention") return 3.2;
-  if (source === "people_watch") return 2.4;
-  if (source === "topic_search") return 2;
-  if (source === "timeline") return 1.5;
-  return 1;
-}
-function armKey(actionType, source) {
-  return `${actionType}:${source}`;
-}
-function scoreTweetOpportunity(source, tweet, authorTouchCount, authorLastTouchedAt, recentlyReplied, persona) {
-  const handle = normalizeHandle3(tweet.authorHandle);
-  const priorTouches = authorTouchCount.get(handle) ?? 0;
-  const focusMatch = phraseMatchScore(tweet.text, persona.focusKeywords);
-  const avoidMatch = phraseMatchScore(tweet.text, persona.avoidKeywords);
-  const targetBoost = persona.priorityHandles.has(handle) ? 2.4 : persona.heroHandles.has(handle) ? 1.4 : persona.networkHandles.has(handle) ? 0.9 : 0;
-  const alignment = focusMatch + targetBoost - avoidMatch * 1.2;
-  let score = sourceWeight(source);
-  score += Math.min((tweet.replyCount ?? 0) / 12, 1.2);
-  score += Math.min((tweet.likeCount ?? 0) / 180, 1);
-  score += tweet.text.includes("?") ? 0.75 : 0;
-  score += alignment;
-  score += priorTouches === 0 ? 0.8 : Math.max(0.05, 0.55 - priorTouches * 0.14);
-  score -= recencyPenalty(authorLastTouchedAt.get(handle));
-  score -= recentlyReplied ? 3.5 : 0;
-  if (priorTouches >= 5) score -= 0.8;
-  if (avoidMatch > 0.6) score -= 1.2;
-  if (isLikelySyntheticHandle2(handle) && !persona.priorityHandles.has(handle) && !persona.heroHandles.has(handle) && !persona.networkHandles.has(handle)) {
-    score -= 2.4;
-  }
-  return { score, alignment };
-}
-function buildActionOpportunities(input) {
-  const { research } = input;
-  const maxCandidates = input.maxCandidates ?? 28;
-  const selfHandle = normalizeHandle3(input.selfHandle);
-  const selfUserId = (input.selfUserId ?? "").trim();
-  const constraints = getPersonaConstraints();
-  const onlyReplyHandles = new Set(constraints.onlyReplyToHandles.map((h) => normalizeHandle3(h)));
-  const onlyInteractHandles = new Set(constraints.onlyInteractWithHandles.map((h) => normalizeHandle3(h)));
-  const persona = buildPersonaContext();
-  const actionProfile = persona.actionProfile;
-  const recent = getRecentInteractions(300);
-  const {
-    repliedTweetIds,
-    likedTweetIds,
-    retweetedTweetIds,
-    followedHandles,
-    authorTouchCount,
-    authorLastTouchedAt
-  } = buildRecentIndexes(recent);
-  const candidateTweets = [];
-  for (const tweet of research.mentions) candidateTweets.push({ tweet, source: "mention" });
-  for (const tweet of research.timeline) candidateTweets.push({ tweet, source: "timeline" });
-  for (const result of research.topicSearchResults) {
-    for (const tweet of result.tweets) candidateTweets.push({ tweet, source: "topic_search" });
-  }
-  for (const person of research.peopleActivity) {
-    for (const tweet of person.tweets) candidateTweets.push({ tweet, source: "people_watch" });
-  }
-  const dedupedByTweetId = /* @__PURE__ */ new Map();
-  for (const candidate of candidateTweets) {
-    const handle = normalizeHandle3(candidate.tweet.authorHandle);
-    if (!candidate.tweet.id || !handle || handle === selfHandle) continue;
-    if (selfUserId && candidate.tweet.authorId === selfUserId) continue;
-    if (onlyInteractHandles.size > 0 && !onlyInteractHandles.has(handle)) continue;
-    const existing = dedupedByTweetId.get(candidate.tweet.id);
-    if (!existing || sourceWeight(candidate.source) > sourceWeight(existing.source)) {
-      dedupedByTweetId.set(candidate.tweet.id, candidate);
-    }
-  }
-  const followOpportunityByHandle = /* @__PURE__ */ new Set();
-  const opportunities = [];
-  let counter = 0;
-  const nextId = () => {
-    counter += 1;
-    return `opp-${counter}`;
-  };
-  for (const { tweet, source } of dedupedByTweetId.values()) {
-    const handle = normalizeHandle3(tweet.authorHandle);
-    const { score: baseScore, alignment } = scoreTweetOpportunity(
-      source,
-      tweet,
-      authorTouchCount,
-      authorLastTouchedAt,
-      repliedTweetIds.has(tweet.id),
-      persona
-    );
-    const shortTweet = clip(tweet.text, 170);
-    const replyScore = baseScore + 0.7 + personaActionDelta("reply", source, actionProfile);
-    const likeScore = baseScore + 0.2 + personaActionDelta("like", source, actionProfile);
-    const retweetScore = baseScore - 0.1 + personaActionDelta("retweet", source, actionProfile);
-    const followScore = baseScore - 0.2 + personaActionDelta("follow", source, actionProfile);
-    if (!isActionStronglySuppressed("reply", actionProfile) && matchesPersonaGeneratedProfile("reply", source, actionProfile)) {
-      opportunities.push({
-        id: nextId(),
-        armKey: armKey("reply", source),
-        actionType: "reply",
-        source,
-        score: replyScore,
-        summary: `Reply to @${handle} from ${source}`,
-        authorHandle: handle,
-        tweetId: tweet.id,
-        requiresContent: true,
-        template: { action: "reply", tweetId: tweet.id, source, targetHandle: `@${handle}` },
-        context: `@${handle}: "${shortTweet}"`
-      });
-    }
-    const stronglyRelevant = alignment >= 0.35 || source === "mention" || source === "people_watch" || persona.priorityHandles.has(handle);
-    if (onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("like", actionProfile) && matchesPersonaGeneratedProfile("like", source, actionProfile) && !likedTweetIds.has(tweet.id) && likeScore >= 1.8 && stronglyRelevant) {
-      opportunities.push({
-        id: nextId(),
-        armKey: armKey("like", source),
-        actionType: "like",
-        source,
-        score: likeScore,
-        summary: `Like @${handle} from ${source}`,
-        authorHandle: handle,
-        tweetId: tweet.id,
-        requiresContent: false,
-        template: { action: "like", tweetId: tweet.id, source, targetHandle: `@${handle}` },
-        context: `@${handle}: "${shortTweet}"`
-      });
-    }
-    if (onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("retweet", actionProfile) && matchesPersonaGeneratedProfile("retweet", source, actionProfile) && !retweetedTweetIds.has(tweet.id) && retweetScore >= 2.6 && alignment >= 0.15) {
-      opportunities.push({
-        id: nextId(),
-        armKey: armKey("retweet", source),
-        actionType: "retweet",
-        source,
-        score: retweetScore,
-        summary: `Retweet @${handle} from ${source}`,
-        authorHandle: handle,
-        tweetId: tweet.id,
-        requiresContent: false,
-        template: { action: "retweet", tweetId: tweet.id, source, targetHandle: `@${handle}` },
-        context: `@${handle}: "${shortTweet}"`
-      });
-    }
-    const shouldConsiderFollow = onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("follow", actionProfile) && matchesPersonaGeneratedProfile("follow", source, actionProfile) && !followedHandles.has(handle) && !followOpportunityByHandle.has(handle) && !isLikelySyntheticHandle2(handle) && followScore >= 3 && (persona.priorityHandles.has(handle) || persona.heroHandles.has(handle) || source === "mention" || alignment >= 0.8);
-    if (shouldConsiderFollow) {
-      followOpportunityByHandle.add(handle);
-      opportunities.push({
-        id: nextId(),
-        armKey: armKey("follow", source),
-        actionType: "follow",
-        source,
-        score: followScore,
-        summary: `Follow @${handle}`,
-        authorHandle: handle,
-        requiresContent: false,
-        template: { action: "follow", handle: `@${handle}`, source, targetHandle: `@${handle}` },
-        context: `Account @${handle} is producing conversation-relevant content.`
-      });
-    }
-  }
-  const queryList = research.topicSearchResults.map((r) => r.query).filter(Boolean);
-  if (queryList.length > 0 && !constraints.noOriginalPosts && !constraints.replyOnlyMode && !isActionStronglySuppressed("post", actionProfile) && matchesPersonaGeneratedProfile("post", "synthesis", actionProfile) && onlyInteractHandles.size === 0 && onlyReplyHandles.size === 0) {
-    const synthesisScore = 2.25 + personaActionDelta("post", "synthesis", actionProfile);
-    const priorityTopicHint = actionProfile.priorityTopics.slice(0, 3).join(", ");
-    opportunities.push({
-      id: nextId(),
-      armKey: armKey("post", "synthesis"),
-      actionType: "post",
-      source: "synthesis",
-      score: synthesisScore,
-      summary: "Post an original thought synthesized from active conversations",
-      requiresContent: true,
-      template: { action: "post", source: "synthesis" },
-      context: `Weave a fresh take from active topics: ${queryList.slice(0, 4).join(", ")}${priorityTopicHint ? `. Persona-priority topics: ${priorityTopicHint}` : ""}`
-    });
-  }
-  opportunities.sort((a, b) => b.score - a.score);
-  return opportunities.slice(0, maxCandidates);
-}
-
-// src/runtime/portfolio-planner.ts
-function parseSelections(responseText) {
-  const codeBlockMatch = responseText.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-  const candidatesToTry = [];
-  if (codeBlockMatch?.[1]) candidatesToTry.push(codeBlockMatch[1].trim());
-  candidatesToTry.push(responseText.trim());
-  for (const raw of candidatesToTry) {
-    try {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed.selections)) return parsed.selections;
-    } catch {
-    }
-  }
-  const arrayMatch = responseText.match(/\[\s*\{[\s\S]*\}\s*\]/);
-  if (arrayMatch) {
-    try {
-      const parsed = JSON.parse(arrayMatch[0]);
-      if (Array.isArray(parsed)) return parsed;
-    } catch {
-    }
-  }
-  return [];
-}
-function materializeSelections(selections, opportunities, maxActions) {
-  const byId = new Map(opportunities.map((opportunity) => [opportunity.id, opportunity]));
-  const actions = [];
-  const used = /* @__PURE__ */ new Set();
-  for (const selection of selections) {
-    if (actions.length >= maxActions) break;
-    if (!selection.candidateId || used.has(selection.candidateId)) continue;
-    const opportunity = byId.get(selection.candidateId);
-    if (!opportunity) continue;
-    const action = {
-      ...opportunity.template,
-      banditArm: opportunity.armKey,
-      opportunityId: opportunity.id,
-      reasoning: selection.reasoning
-    };
-    if (opportunity.requiresContent) {
-      const content = (selection.content ?? "").trim();
-      if (!content) continue;
-      action.content = content;
-    }
-    used.add(selection.candidateId);
-    actions.push(action);
-  }
-  return actions;
-}
-async function planActionPortfolio(input) {
-  const { systemPrompt, opportunities, maxActions, policyFeedback, executedActions = [] } = input;
-  if (opportunities.length === 0 || maxActions <= 0) return [];
-  const prompt = buildOpportunityPortfolioMessage({
-    opportunities,
-    maxActions,
-    policyFeedback,
-    executedActions
-  });
-  const llmResponse = await generateResponse(systemPrompt, prompt);
-  const parsed = parseSelections(llmResponse.content);
-  const actions = materializeSelections(parsed, opportunities, maxActions);
-  if (actions.length === 0) {
-    logger.warn("Portfolio planner returned no valid selections.");
-  }
-  return actions;
-}
-
-// src/runtime/mission-director.ts
-function normalizeHandle4(handle) {
-  return handle.replace(/^@/, "").trim().toLowerCase();
-}
-function unique2(values) {
-  return [...new Set(values)];
-}
-function isAction(value) {
-  return ["reply", "like", "retweet", "follow", "post"].includes(value);
-}
-function sanitizeActions(raw, fallback) {
-  if (!Array.isArray(raw) || raw.length === 0) return fallback;
-  const cleaned = raw.map((item) => String(item).trim().toLowerCase()).filter((item) => isAction(item));
-  return cleaned.length > 0 ? unique2(cleaned) : fallback;
-}
-function parseJsonObject(text) {
-  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
-  const candidates = [fenced, text].filter((v) => Boolean(v)).map((v) => v.trim());
-  for (const candidate of candidates) {
-    try {
-      return JSON.parse(candidate);
-    } catch {
-    }
-    const obj = candidate.match(/\{[\s\S]*\}/);
-    if (!obj) continue;
-    try {
-      return JSON.parse(obj[0]);
-    } catch {
-    }
-  }
-  return null;
-}
-function buildPersonaAllowedActions(profile, noOriginalPosts) {
-  const byBias = profile.prioritizedActions.filter((action) => profile.actionBias[action] > -1.1);
-  const withFallback = byBias.length > 0 ? byBias : ["reply", "like", "retweet", "follow", "post"];
-  const filtered = noOriginalPosts ? withFallback.filter((action) => action !== "post") : withFallback;
-  return unique2(filtered).slice(0, 5);
-}
-function buildDeterministicMission(research, profile) {
-  const identity = loadIdentity();
-  const strategy = loadStrategy();
-  const constraints = getPersonaConstraints(identity);
-  const constraintTargets = personaConstraintHandles(constraints).map(normalizeHandle4).filter(Boolean);
-  const focusTopics = unique2(
-    [
-      ...profile.priorityTopics,
-      ...identity.topics ?? [],
-      ...strategy.currentFocus,
-      ...strategy.shortTermGoals
-    ].map((topic) => String(topic).trim()).filter(Boolean).slice(0, 10)
-  );
-  const strictReply = constraints.onlyReplyToHandles.length > 0 || constraints.replyOnlyMode;
-  if (strictReply) {
-    const strictTargets = constraints.onlyReplyToHandles.length > 0 ? constraints.onlyReplyToHandles.map(normalizeHandle4) : constraintTargets;
-    return {
-      mode: "strict_target_reply",
-      objective: strictTargets.length > 0 ? `Reply only to @${strictTargets.join(", @")} while staying fully in character.` : "Reply-only mode. Stay in character and do not perform non-reply actions.",
-      allowedActions: ["reply"],
-      targetHandles: strictTargets,
-      focusTopics,
-      rationale: "Hard persona constraint detected in identity goals/boundaries/bio."
-    };
-  }
-  if (constraintTargets.length > 0) {
-    return {
-      mode: "strict_target_interaction",
-      objective: `Interact only with @${constraintTargets.join(", @")} in persona voice.`,
-      allowedActions: constraints.noOriginalPosts ? ["reply", "like", "retweet", "follow"] : ["reply", "like", "retweet", "follow", "post"],
-      targetHandles: constraintTargets,
-      focusTopics,
-      rationale: "Hard persona interaction target detected."
-    };
-  }
-  const preferredActions = buildPersonaAllowedActions(profile, constraints.noOriginalPosts);
-  const primaryActionHint = preferredActions.length > 0 ? preferredActions.slice(0, 2).join(" + ") : "context-aware interactions";
-  return {
-    mode: "persona_balanced",
-    objective: `Advance ${identity.name}'s mission through ${primaryActionHint} while staying in strict persona voice.`,
-    allowedActions: preferredActions,
-    targetHandles: [],
-    focusTopics,
-    rationale: `No strict target lock; persona profile drives soft action/source priorities (${profile.rationale.slice(0, 2).join("; ")}).`
-  };
-}
-function buildMissionPrompt(research, fallback, profile) {
-  const identity = loadIdentity();
-  const constraints = getPersonaConstraints(identity);
-  const topTimeline = research.timeline.slice(0, 5);
-  const topMentions = research.mentions.slice(0, 5);
-  const topicQueries = research.topicSearchResults.map((r) => r.query).filter(Boolean).slice(0, 6);
-  const people = research.peopleActivity.map((p) => p.handle).filter(Boolean).slice(0, 6);
-  const lines = [];
-  lines.push("Create one heartbeat mission JSON for this agent.");
-  lines.push("Hard rule: Persona constraints override everything.");
-  lines.push("");
-  lines.push(`Agent: ${identity.name} (@${identity.handle})`);
-  lines.push(`Bio: ${identity.bio}`);
-  lines.push(`Tone: ${identity.tone}`);
-  lines.push(`Goals: ${(identity.goals ?? []).join(" | ")}`);
-  lines.push(`Boundaries: ${(identity.boundaries ?? []).join(" | ")}`);
-  lines.push(`Framework: ${identity.framework}`);
-  lines.push(`Existing strict constraints: ${JSON.stringify(constraints)}`);
-  lines.push(`Persona action priors: ${JSON.stringify({
-    prioritizedActions: profile.prioritizedActions.slice(0, 5),
-    priorityTopics: profile.priorityTopics.slice(0, 8),
-    actionBias: profile.actionBias,
-    sourceBias: profile.sourceBias,
-    rationale: profile.rationale.slice(0, 5)
-  })}`);
-  lines.push("");
-  lines.push(`Fallback mission if unsure: ${JSON.stringify(fallback)}`);
-  lines.push("");
-  lines.push(`Observed timeline sample (${topTimeline.length}):`);
-  for (const tweet of topTimeline) {
-    lines.push(`- @${tweet.authorHandle}: ${tweet.text.slice(0, 180)}`);
-  }
-  lines.push(`Observed mentions sample (${topMentions.length}):`);
-  for (const tweet of topMentions) {
-    lines.push(`- @${tweet.authorHandle}: ${tweet.text.slice(0, 180)}`);
-  }
-  lines.push(`Topic queries: ${topicQueries.join(" | ") || "none"}`);
-  lines.push(`People watched: ${people.map((h) => `@${h}`).join(", ") || "none"}`);
-  lines.push("");
-  lines.push("Return JSON only with this shape:");
-  lines.push("{");
-  lines.push('  "mode": "strict_target_reply|strict_target_interaction|persona_balanced",');
-  lines.push('  "objective": "one-sentence mission",');
-  lines.push('  "allowedActions": ["reply","like","retweet","follow","post"],');
-  lines.push('  "targetHandles": ["grok"],');
-  lines.push('  "focusTopics": ["topic a","topic b"],');
-  lines.push('  "rationale": "short why"');
-  lines.push("}");
-  return lines.join("\n");
-}
-function mergeMission(fallback, parsed) {
-  if (!parsed) return fallback;
-  const mode = parsed.mode === "strict_target_reply" || parsed.mode === "strict_target_interaction" || parsed.mode === "persona_balanced" ? parsed.mode : fallback.mode;
-  const objective = typeof parsed.objective === "string" && parsed.objective.trim().length > 0 ? parsed.objective.trim() : fallback.objective;
-  const rationale = typeof parsed.rationale === "string" && parsed.rationale.trim().length > 0 ? parsed.rationale.trim() : fallback.rationale;
-  const focusTopics = Array.isArray(parsed.focusTopics) ? unique2(
-    parsed.focusTopics.map((topic) => String(topic).trim()).filter(Boolean).slice(0, 10)
-  ) : fallback.focusTopics;
-  const targetHandles = Array.isArray(parsed.targetHandles) ? unique2(
-    parsed.targetHandles.map((handle) => normalizeHandle4(String(handle))).filter(Boolean)
-  ) : fallback.targetHandles;
-  let allowedActions = sanitizeActions(parsed.allowedActions, fallback.allowedActions);
-  const mustReplyOnly = mode === "strict_target_reply";
-  if (mustReplyOnly) {
-    allowedActions = ["reply"];
-  }
-  const hasStrictTargets = fallback.targetHandles.length > 0;
-  if (hasStrictTargets) {
-    return {
-      ...fallback,
-      mode: mustReplyOnly ? "strict_target_reply" : mode,
-      objective,
-      rationale,
-      focusTopics,
-      allowedActions,
-      targetHandles: fallback.targetHandles
-    };
-  }
-  return {
-    mode,
-    objective,
-    rationale,
-    focusTopics,
-    allowedActions,
-    targetHandles
-  };
-}
-async function createHeartbeatMission(research) {
-  const identity = loadIdentity();
-  const strategy = loadStrategy();
-  const constraints = getPersonaConstraints(identity);
-  const profile = compilePersonaActionProfile({ identity, strategy, constraints });
-  const fallback = buildDeterministicMission(research, profile);
-  if (fallback.mode !== "persona_balanced") {
-    return fallback;
-  }
-  const system = [
-    "You are a mission director for an autonomous X agent.",
-    "Your output must be strict JSON only.",
-    "Prioritize persona fidelity over engagement.",
-    "Never violate explicit persona constraints."
-  ].join(" ");
-  try {
-    const prompt = buildMissionPrompt(research, fallback, profile);
-    const response = await generateResponse(system, prompt);
-    const parsed = parseJsonObject(response.content);
-    return mergeMission(fallback, parsed);
-  } catch {
-    return fallback;
-  }
-}
-
-// src/runtime/bandit.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-var DEFAULT_EXPLORATION_BUDGET = 0.25;
-function defaultState() {
-  return {
-    totalPulls: 0,
-    explorationBudget: DEFAULT_EXPLORATION_BUDGET,
-    arms: {},
-    pending: []
-  };
-}
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-function loadState() {
-  if (!existsSync2(paths.bandit)) return defaultState();
-  try {
-    const parsed = JSON.parse(readFileSync2(paths.bandit, "utf-8"));
-    const state = {
-      totalPulls: Math.max(0, parsed.totalPulls ?? 0),
-      explorationBudget: clamp(parsed.explorationBudget ?? DEFAULT_EXPLORATION_BUDGET, 0.1, 0.45),
-      arms: parsed.arms ?? {},
-      pending: Array.isArray(parsed.pending) ? parsed.pending : []
-    };
-    return state;
-  } catch {
-    return defaultState();
-  }
-}
-function saveState(state) {
-  state.explorationBudget = clamp(state.explorationBudget, 0.1, 0.45);
-  state.pending = state.pending.filter((entry) => {
-    if (!entry.resolved) return true;
-    const resolvedAtMs = Date.parse(entry.resolveAt);
-    if (Number.isNaN(resolvedAtMs)) return false;
-    return Date.now() - resolvedAtMs < 7 * 24 * 60 * 60 * 1e3;
-  }).slice(-1200);
-  writeFileSync2(paths.bandit, JSON.stringify(state, null, 2));
-}
-function ensureArm(state, armKey2) {
-  const existing = state.arms[armKey2];
-  if (existing) return existing;
-  const arm = {
-    key: armKey2,
-    pulls: 0,
-    rewardSum: 0,
-    lastReward: 0,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  state.arms[armKey2] = arm;
-  return arm;
-}
-function averageReward(arm) {
-  if (arm.pulls <= 0) return 0;
-  return arm.rewardSum / arm.pulls;
-}
-function ucbBonus(totalPulls, armPulls) {
-  const t = Math.max(1, totalPulls);
-  return Math.sqrt(2 * Math.log(t + 1) / (armPulls + 1));
-}
-function computeImmediateReward(result) {
-  if (result.success) return 0.12;
-  const error = (result.error ?? "").toLowerCase();
-  if (error.includes("duplicate content")) return -0.95;
-  if (error.includes("rate limit")) return -0.5;
-  if (error.includes("forbidden") || error.includes("403")) return -0.55;
-  return -0.35;
-}
-function resolveDelayedReward(metrics) {
-  if (!metrics) return -0.05;
-  const reward = Math.min(metrics.likeCount * 0.03, 0.9) + Math.min(metrics.replyCount * 0.12, 0.9) + Math.min(metrics.retweetCount * 0.08, 0.8);
-  if (metrics.likeCount === 0 && metrics.replyCount === 0 && metrics.retweetCount === 0) {
-    return -0.15;
-  }
-  return Math.min(reward, 1.8);
-}
-function armKeyFromAction(action) {
-  if (action.banditArm && action.banditArm.trim().length > 0) return action.banditArm;
-  const source = action.source ?? "unknown";
-  return `${action.action}:${source}`;
-}
-function extractTweetId(action, result) {
-  if (result.detail && /^\d+$/.test(result.detail)) return result.detail;
-  if (action.action !== "reply" && action.tweetId) return action.tweetId;
-  return void 0;
-}
-function selectBanditOpportunityPool(opportunities, maxPoolSize = 24) {
-  if (opportunities.length <= maxPoolSize) return opportunities;
-  const state = loadState();
-  const totalPulls = Math.max(1, state.totalPulls);
-  const scored = opportunities.map((opportunity) => {
-    const arm = ensureArm(state, opportunity.armKey);
-    const mean = averageReward(arm);
-    const bonus = ucbBonus(totalPulls, arm.pulls);
-    const coldStartBoost = arm.pulls === 0 ? 0.25 : 0;
-    const adjustedScore = opportunity.score + mean * 1.5 + bonus * 0.35 + coldStartBoost;
-    return {
-      opportunity: {
-        ...opportunity,
-        score: adjustedScore
-      },
-      adjustedScore,
-      pulls: arm.pulls
-    };
-  });
-  const explorationBudget = clamp(state.explorationBudget, 0.1, 0.45);
-  const exploreCount = Math.max(1, Math.floor(maxPoolSize * explorationBudget));
-  const exploitCount = Math.max(1, maxPoolSize - exploreCount);
-  const exploit = [...scored].sort((a, b) => b.adjustedScore - a.adjustedScore).slice(0, exploitCount);
-  const selected = /* @__PURE__ */ new Map();
-  for (const row of exploit) {
-    selected.set(row.opportunity.id, row.opportunity);
-  }
-  const remaining = scored.filter((row) => !selected.has(row.opportunity.id)).sort((a, b) => {
-    if (a.pulls !== b.pulls) return a.pulls - b.pulls;
-    return b.adjustedScore - a.adjustedScore;
-  });
-  while (selected.size < maxPoolSize && remaining.length > 0) {
-    const window = remaining.splice(0, Math.min(5, remaining.length));
-    const pick = window[Math.floor(Math.random() * window.length)];
-    if (!selected.has(pick.opportunity.id)) {
-      selected.set(pick.opportunity.id, pick.opportunity);
-    }
-    for (const row of window) {
-      if (row.opportunity.id !== pick.opportunity.id) {
-        remaining.push(row);
-      }
-    }
-    remaining.sort((a, b) => {
-      if (a.pulls !== b.pulls) return a.pulls - b.pulls;
-      return b.adjustedScore - a.adjustedScore;
-    });
-  }
-  const picked = [...selected.values()].sort((a, b) => b.score - a.score).slice(0, maxPoolSize);
-  saveState(state);
-  return picked;
-}
-function recordBanditActionResults(actions, results) {
-  if (actions.length === 0 || results.length === 0) return;
-  const state = loadState();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  for (let i = 0; i < Math.min(actions.length, results.length); i += 1) {
-    const action = actions[i];
-    const result = results[i];
-    const armKey2 = armKeyFromAction(action);
-    const arm = ensureArm(state, armKey2);
-    const immediateReward = computeImmediateReward(result);
-    arm.pulls += 1;
-    arm.rewardSum += immediateReward;
-    arm.lastReward = immediateReward;
-    arm.updatedAt = now;
-    state.totalPulls += 1;
-    const tweetId = extractTweetId(action, result);
-    if (result.success && tweetId && (action.action === "post" || action.action === "reply")) {
-      const delayMs = action.action === "reply" ? 20 * 60 * 1e3 : 45 * 60 * 1e3;
-      state.pending.push({
-        id: `pending-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-        armKey: armKey2,
-        actionType: action.action,
-        tweetId,
-        createdAt: now,
-        resolveAt: new Date(Date.now() + delayMs).toISOString(),
-        resolved: false
-      });
-    }
-  }
-  saveState(state);
-}
-async function collectDelayedOutcomes(client) {
-  const state = loadState();
-  const now = Date.now();
-  const pendingDue = state.pending.filter((entry) => !entry.resolved && Date.parse(entry.resolveAt) <= now).slice(0, 8);
-  if (pendingDue.length === 0) {
-    return { processed: 0, resolved: 0, rewardAdded: 0 };
-  }
-  let rewardAdded = 0;
-  let resolved = 0;
-  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-  for (const pending of pendingDue) {
-    const arm = ensureArm(state, pending.armKey);
-    let metrics = null;
-    if (pending.tweetId) {
-      metrics = await client.getTweetMetrics(pending.tweetId);
-      if (metrics) {
-        updatePostMetrics(pending.tweetId, {
-          checkedAt,
-          likes: metrics.likeCount,
-          retweets: metrics.retweetCount,
-          replies: metrics.replyCount
-        });
-      }
-    }
-    const reward = resolveDelayedReward(
-      metrics ? {
-        likeCount: metrics.likeCount,
-        retweetCount: metrics.retweetCount,
-        replyCount: metrics.replyCount
-      } : null
-    );
-    arm.rewardSum += reward;
-    arm.lastReward = reward;
-    arm.updatedAt = checkedAt;
-    rewardAdded += reward;
-    pending.resolved = true;
-    resolved += 1;
-  }
-  saveState(state);
-  logger.info(
-    `Bandit delayed outcomes processed=${pendingDue.length}, resolved=${resolved}, rewardDelta=${rewardAdded.toFixed(2)}`
-  );
-  return {
-    processed: pendingDue.length,
-    resolved,
-    rewardAdded
-  };
-}
-
-// src/runtime/autonomy.ts
-function recentReplyTargets(hours = 24) {
-  const cutoffMs = Date.now() - hours * 60 * 60 * 1e3;
-  const recent = getRecentInteractions(300);
-  const targets = /* @__PURE__ */ new Set();
-  for (const entry of recent) {
-    if (entry.type !== "reply") continue;
-    if (!entry.inReplyTo) continue;
-    const ts = Date.parse(entry.timestamp);
-    if (!Number.isNaN(ts) && ts < cutoffMs) continue;
-    targets.add(entry.inReplyTo);
-  }
-  return targets;
-}
-function selfUserIdFromCredentials() {
-  try {
-    const creds = loadCredentials();
-    const accessToken = creds.accessToken;
-    if (!accessToken) return null;
-    const dashIdx = accessToken.indexOf("-");
-    if (dashIdx <= 0) return null;
-    const candidate = accessToken.substring(0, dashIdx);
-    return /^\d+$/.test(candidate) ? candidate : null;
-  } catch {
-    return null;
-  }
-}
-function normalizeHandle5(handle) {
-  return (handle ?? "").replace(/^@/, "").trim().toLowerCase();
-}
-function roughWordCount(text) {
-  return text.trim().split(/\s+/).filter(Boolean).length;
-}
-function inferStyleMode(text) {
-  const lower = text.toLowerCase();
-  if (text.includes("?")) return "curious_question";
-  if (/\b(lol|lmao|haha|wild|fr|ngl)\b/i.test(text)) return "playful_line";
-  if (/\b(not|isn'?t|wrong|nah|nope|doesn'?t)\b/i.test(lower)) return "friendly_pushback";
-  if (roughWordCount(text) <= 9) return "quick_reaction";
-  return "plain_observation";
-}
-function chooseRewriteStyleMode(recentTexts, targetTweetText) {
-  const counts = {
-    quick_reaction: 0,
-    curious_question: 0,
-    friendly_pushback: 0,
-    plain_observation: 0,
-    playful_line: 0
-  };
-  for (const text of (recentTexts ?? []).slice(0, 10)) {
-    counts[inferStyleMode(text)] += 1;
-  }
-  if ((targetTweetText ?? "").includes("?") && counts.curious_question <= 2) {
-    return "curious_question";
-  }
-  return Object.entries(counts).sort((a, b) => a[1] - b[1])[0]?.[0] ?? "plain_observation";
-}
-function rewriteStyleModeInstructions(mode) {
-  if (mode === "quick_reaction") {
-    return [
-      "- style mode: quick reaction",
-      "- 6-14 words, one short sentence",
-      "- immediate reaction tone, no thesis statement"
-    ];
-  }
-  if (mode === "curious_question") {
-    return [
-      "- style mode: curious question",
-      "- include exactly one direct question",
-      "- ask about a specific detail from the target tweet"
-    ];
-  }
-  if (mode === "friendly_pushback") {
-    return [
-      "- style mode: friendly pushback",
-      "- politely disagree in plain words",
-      "- no lecture or abstract framing"
-    ];
-  }
-  if (mode === "playful_line") {
-    return [
-      "- style mode: playful line",
-      "- keep it light and witty, not sarcastic essay mode",
-      "- avoid internet clich\xE9s and overused slogans"
-    ];
-  }
-  return [
-    "- style mode: plain observation",
-    "- write like a natural human thought said out loud",
-    "- concrete detail first, no broad generalization"
-  ];
-}
-function shouldAttemptStyleRewrite(action, reason) {
-  if (!action.content || action.action !== "reply" && action.action !== "post") return false;
-  const lower = reason.toLowerCase();
-  return lower.includes("lecture-like") || lower.includes("abstract philosopher cadence") || lower.includes("manifesto") || lower.includes("too long/explanatory") || lower.includes("grounded in the target tweet context") || lower.includes("hedged consensus phrasing") || lower.includes("repetitive anchor phrase/term") || lower.includes("repetitive opening phrase") || lower.includes("low-novelty vocabulary loop") || lower.includes("abstract wording without concrete anchor");
-}
-function personaAdjustedOpportunityScore(opportunity, profile) {
-  const actionType = opportunity.actionType;
-  const source = opportunity.source;
-  const actionBias = profile.actionBias[actionType] ?? 0;
-  const sourceBias = profile.sourceBias[source] ?? 0;
-  return opportunity.score + actionBias * 0.9 + sourceBias * 0.55;
-}
-function buildPersonaGeneratedPool(opportunities, maxSize, profile) {
-  if (opportunities.length <= 1) return opportunities.slice(0, maxSize);
-  const maxPool = Math.max(1, Math.min(maxSize, opportunities.length));
-  const byAction = /* @__PURE__ */ new Map();
-  for (const action of ["reply", "like", "retweet", "follow", "post"]) {
-    byAction.set(action, []);
-  }
-  for (const opportunity of opportunities) {
-    const action = opportunity.actionType;
-    byAction.get(action)?.push(opportunity);
-  }
-  for (const [action, rows] of byAction.entries()) {
-    rows.sort((a, b) => personaAdjustedOpportunityScore(b, profile) - personaAdjustedOpportunityScore(a, profile));
-    byAction.set(action, rows);
-  }
-  const actionOrder = profile.prioritizedActions.filter((action) => (byAction.get(action)?.length ?? 0) > 0);
-  const weightedActions = actionOrder.map((action) => ({
-    action,
-    weight: Math.max(0.2, profile.actionBias[action] + 1.25)
-  })).filter((row) => row.weight > 0);
-  const selected = /* @__PURE__ */ new Map();
-  if (weightedActions.length > 0) {
-    const totalWeight = weightedActions.reduce((sum, row) => sum + row.weight, 0);
-    const quotas = /* @__PURE__ */ new Map();
-    for (const row of weightedActions) {
-      quotas.set(row.action, Math.max(0, Math.floor(row.weight / totalWeight * maxPool)));
-    }
-    for (const topAction of actionOrder.slice(0, 2)) {
-      const rows = byAction.get(topAction) ?? [];
-      if (rows.length === 0) continue;
-      quotas.set(topAction, Math.max(1, quotas.get(topAction) ?? 0));
-    }
-    for (const row of weightedActions) {
-      const rows = byAction.get(row.action) ?? [];
-      const limit = quotas.get(row.action) ?? 0;
-      for (const candidate of rows.slice(0, limit)) {
-        if (selected.size >= maxPool) break;
-        selected.set(candidate.id, candidate);
-      }
-      if (selected.size >= maxPool) break;
-    }
-  }
-  const globalSorted = [...opportunities].sort(
-    (a, b) => personaAdjustedOpportunityScore(b, profile) - personaAdjustedOpportunityScore(a, profile)
-  );
-  for (const candidate of globalSorted) {
-    if (selected.size >= maxPool) break;
-    selected.set(candidate.id, candidate);
-  }
-  return [...selected.values()].slice(0, maxPool);
-}
-function cleanRewriteOutput(text) {
-  const cleaned = text.replace(/```[\s\S]*?```/g, "").replace(/^["'`]+|["'`]+$/g, "").trim();
-  const firstLine = cleaned.split("\n").map((line) => line.trim()).filter(Boolean)[0] ?? cleaned;
-  return firstLine.trim();
-}
-async function rewriteDraftForHumanVoice(input) {
-  if (!input.action.content) return null;
-  const identity = loadIdentity();
-  const maxChars = input.action.action === "reply" ? 100 : 130;
-  const minChars = input.action.action === "reply" ? 18 : 24;
-  const styleMode = chooseRewriteStyleMode(input.recentTexts, input.targetTweetText);
-  const system = [
-    `You rewrite X/Twitter drafts into ${identity.name}'s natural voice.`,
-    "Output must feel human, direct, and contextual.",
-    "Never write abstract philosophy or explanatory manifesto style.",
-    "Return ONLY rewritten tweet text, no commentary."
-  ].join(" ");
-  const promptParts = [];
-  promptParts.push(`Current draft: ${input.action.content}`);
-  promptParts.push(`Rejected because: ${input.reason}`);
-  if (input.targetTweetText) {
-    promptParts.push(`Target tweet context: ${input.targetTweetText}`);
-  }
-  promptParts.push(`Constraints:`);
-  promptParts.push(`- ${minChars}-${maxChars} characters`);
-  promptParts.push("- 1-2 short sentences max");
-  promptParts.push("- no 'the real question' / 'the deeper question' framing");
-  promptParts.push("- no colon, semicolon, or em dash");
-  promptParts.push("- specific and concrete, not abstract");
-  promptParts.push("- keep the same core stance");
-  promptParts.push("- use natural spoken phrasing and contractions when it fits");
-  for (const line of rewriteStyleModeInstructions(styleMode)) {
-    promptParts.push(line);
-  }
-  if (input.recentTexts && input.recentTexts.length > 0) {
-    promptParts.push("- avoid vocabulary anchors from these recent outputs:");
-    for (const text of input.recentTexts.slice(0, 5)) {
-      promptParts.push(`  - ${text.slice(0, 120)}`);
-    }
-  }
-  try {
-    const rewrite = await generateResponse(system, promptParts.join("\n"));
-    const candidate = cleanRewriteOutput(rewrite.content);
-    if (!candidate) return null;
-    return candidate;
-  } catch {
-    return null;
-  }
-}
-async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
-  const client = await getXClient();
-  const identity = loadIdentity();
-  const strategy = loadStrategy();
-  const constraints = getPersonaConstraints();
-  const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
-  const strictReplyOnly = constraints.replyOnlyMode || constraints.onlyReplyToHandles.length > 0;
-  const interactionActions = /* @__PURE__ */ new Set(["reply", "like", "retweet", "follow"]);
-  const constraintLines = buildPersonaConstraintLines(constraints);
-  if (constraintLines.length > 0) {
-    logger.info(`Persona constraints active: ${constraintLines.join(" | ")}`);
-  }
-  logger.info(
-    `Persona action profile: actions=${personaProfile.prioritizedActions.slice(0, 4).join(" > ")}, sources=${Object.entries(personaProfile.sourceBias).sort((a, b) => b[1] - a[1]).map(([source]) => source).slice(0, 3).join(" > ")}`
-  );
-  try {
-    const delayed = await collectDelayedOutcomes(client);
-    if (delayed.processed > 0) {
-      logger.info(
-        `Delayed outcomes: processed=${delayed.processed}, resolved=${delayed.resolved}, rewardDelta=${delayed.rewardAdded.toFixed(2)}`
-      );
-    }
-  } catch (error) {
-    logger.warn(`Delayed outcome collection failed: ${error.message}`);
-  }
-  const selfHandle = identity.handle.replace(/^@/, "").toLowerCase();
-  const selfUserId = selfUserIdFromCredentials();
-  const isSelfTweet = (tweet) => tweet.authorHandle.replace(/^@/, "").toLowerCase() === selfHandle || selfUserId !== null && tweet.authorId === selfUserId;
-  const research = await runResearchPhase(client, heartbeatCount);
-  const timeline = research.timeline.filter((tweet) => !isSelfTweet(tweet));
-  const mentions = research.mentions.filter((tweet) => !isSelfTweet(tweet));
-  const recentReplyTargetIds = recentReplyTargets(24);
-  const filteredTimeline = timeline.filter((tweet) => !recentReplyTargetIds.has(tweet.id));
-  const filteredMentions = mentions.filter((tweet) => !recentReplyTargetIds.has(tweet.id));
-  const filteredTopicSearchResults = research.topicSearchResults.map((result) => ({
-    ...result,
-    tweets: result.tweets.filter((tweet) => !recentReplyTargetIds.has(tweet.id) && !isSelfTweet(tweet))
-  })).filter((result) => result.tweets.length > 0);
-  const filteredPeopleActivity = research.peopleActivity.map((person) => ({
-    ...person,
-    tweets: person.tweets.filter((tweet) => !recentReplyTargetIds.has(tweet.id) && !isSelfTweet(tweet))
-  })).filter((person) => person.tweets.length > 0);
-  const observedTweetIds = [
-    ...filteredTimeline.map((tweet) => tweet.id),
-    ...filteredMentions.map((tweet) => tweet.id),
-    ...filteredTopicSearchResults.flatMap((result) => result.tweets.map((tweet) => tweet.id)),
-    ...filteredPeopleActivity.flatMap((person) => person.tweets.map((tweet) => tweet.id))
-  ];
-  const observedTweets = [
-    ...filteredTimeline,
-    ...filteredMentions,
-    ...filteredTopicSearchResults.flatMap((result) => result.tweets),
-    ...filteredPeopleActivity.flatMap((person) => person.tweets)
-  ];
-  const mission = await createHeartbeatMission({
-    ...research,
-    timeline: filteredTimeline,
-    mentions: filteredMentions,
-    topicSearchResults: filteredTopicSearchResults,
-    peopleActivity: filteredPeopleActivity
-  });
-  logger.info(
-    `Mission: mode=${mission.mode}, objective="${mission.objective}", allowed=${mission.allowedActions.join(",")}, targets=${mission.targetHandles.length > 0 ? mission.targetHandles.map((h) => `@${h}`).join(",") : "none"}`
-  );
-  logger.info(
-    `Autonomy context: timeline=${filteredTimeline.length}, mentions=${filteredMentions.length}, topicTweets=${filteredTopicSearchResults.reduce((sum, r) => sum + r.tweets.length, 0)}, peopleTweets=${filteredPeopleActivity.reduce((sum, p) => sum + p.tweets.length, 0)}`
-  );
-  const systemPrompt = buildSystemPrompt();
-  const actions = [];
-  const results = [];
-  const policyFeedback = [
-    `Heartbeat mission: ${mission.objective}`,
-    `Mission mode: ${mission.mode}`
-  ];
-  const blockedTweetIds = new Set(recentReplyTargetIds);
-  const allowedActionSet = new Set(mission.allowedActions);
-  const disallowedActions = new Set(
-    ["reply", "like", "retweet", "follow", "post"].filter((action) => !allowedActionSet.has(action))
-  );
-  if (mission.targetHandles.length > 0) {
-    policyFeedback.push(`Mission targets: ${mission.targetHandles.map((handle) => `@${handle}`).join(", ")}`);
-  }
-  if (mission.focusTopics.length > 0) {
-    policyFeedback.push(`Mission focus: ${mission.focusTopics.slice(0, 5).join(", ")}`);
-  }
-  policyFeedback.push(`Mission rationale: ${mission.rationale}`);
-  const missionTargetSet = new Set(mission.targetHandles.map((handle) => normalizeHandle5(handle)).filter(Boolean));
-  let replyRejectionCount = 0;
-  const opportunities = buildActionOpportunities({
-    research: {
-      ...research,
-      timeline: filteredTimeline,
-      mentions: filteredMentions,
-      topicSearchResults: filteredTopicSearchResults,
-      peopleActivity: filteredPeopleActivity
-    },
-    selfHandle,
-    selfUserId,
-    maxCandidates: 30
-  });
-  const personaSeedPool = buildPersonaGeneratedPool(opportunities, 30, personaProfile);
-  const banditPool = selectBanditOpportunityPool(personaSeedPool, 24);
-  const planningPool = buildPersonaGeneratedPool(banditPool, 24, personaProfile);
-  const byType = planningPool.reduce((acc, opportunity) => {
-    acc[opportunity.actionType] = (acc[opportunity.actionType] ?? 0) + 1;
-    return acc;
-  }, {});
-  logger.info(`Opportunities selected: total=${planningPool.length}, byType=${JSON.stringify(byType)}`);
-  const activeIntents = listIntents();
-  const intentTargetHandles = new Set(
-    activeIntents.flatMap((intent) => intent.targetHandles.map((handle) => normalizeHandle5(handle)))
-  );
-  const priorityHandles = /* @__PURE__ */ new Set(
-    [
-      ...strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => normalizeHandle5(person.handle)).filter(Boolean),
-      ...intentTargetHandles
-    ]
-  );
-  const authorByTweetId = /* @__PURE__ */ new Map();
-  for (const opportunity of planningPool) {
-    if (opportunity.tweetId && opportunity.authorHandle) {
-      authorByTweetId.set(opportunity.tweetId, normalizeHandle5(opportunity.authorHandle));
-    }
-  }
-  getRecentInteractions(20);
-  const getPlanningOpportunities = () => {
-    return planningPool.filter((opportunity) => {
-      if (disallowedActions.has(opportunity.actionType)) return false;
-      if (opportunity.tweetId && blockedTweetIds.has(opportunity.tweetId)) return false;
-      if (missionTargetSet.size > 0 && interactionActions.has(opportunity.actionType)) {
-        const author = normalizeHandle5(opportunity.authorHandle);
-        if (!author || !missionTargetSet.has(author)) return false;
-      }
-      return true;
-    });
-  };
-  for (let planningRound = 0; planningRound < 2 && actions.length < maxActions; planningRound += 1) {
-    const candidates = getPlanningOpportunities();
-    if (candidates.length === 0) {
-      logger.info("No viable opportunities after filtering.");
-      break;
-    }
-    let plannedActions = await planActionPortfolio({
-      systemPrompt,
-      opportunities: candidates,
-      maxActions: maxActions - actions.length,
-      policyFeedback,
-      executedActions: actions
-    });
-    if (!strictReplyOnly && plannedActions.length > 1 && plannedActions.every((a) => a.action === "reply")) {
-      const nonReplyCandidate = candidates.find(
-        (opportunity) => opportunity.actionType !== "reply" && !opportunity.requiresContent
-      );
-      if (nonReplyCandidate) {
-        plannedActions = [
-          { ...nonReplyCandidate.template, reasoning: "diversity pivot" },
-          ...plannedActions.slice(0, Math.max(0, maxActions - actions.length - 1))
-        ];
-      }
-    }
-    if (priorityHandles.size > 0) {
-      const authorByTweetId2 = /* @__PURE__ */ new Map();
-      for (const opportunity of candidates) {
-        if (opportunity.tweetId && opportunity.authorHandle) {
-          authorByTweetId2.set(opportunity.tweetId, normalizeHandle5(opportunity.authorHandle));
-        }
-      }
-      const touchesPriorityTarget = plannedActions.some((action) => {
-        if (action.handle && priorityHandles.has(normalizeHandle5(action.handle))) return true;
-        if (action.targetHandle && priorityHandles.has(normalizeHandle5(action.targetHandle))) return true;
-        if (action.tweetId && priorityHandles.has(authorByTweetId2.get(action.tweetId) ?? "")) return true;
-        return false;
-      });
-      if (!touchesPriorityTarget) {
-        const priorityCandidate = candidates.find(
-          (opportunity) => Boolean(opportunity.authorHandle) && priorityHandles.has(normalizeHandle5(opportunity.authorHandle)) && (!strictReplyOnly ? !opportunity.requiresContent : opportunity.actionType === "reply")
-        );
-        if (priorityCandidate) {
-          plannedActions = [
-            { ...priorityCandidate.template, reasoning: "priority-target focus" },
-            ...plannedActions
-          ].slice(0, Math.max(0, maxActions - actions.length));
-          logger.info(`Priority target injection: @${priorityCandidate.authorHandle}`);
-        }
-      }
-    }
-    if (plannedActions.length === 0) {
-      logger.info("Portfolio planner returned no actionable selections.");
-      break;
-    }
-    let acceptedInRound = 0;
-    for (const proposedAction of plannedActions) {
-      let candidateAction = proposedAction;
-      if (actions.length >= maxActions) break;
-      if (disallowedActions.has(candidateAction.action)) {
-        const reason = `Action ${candidateAction.action} is temporarily disallowed this heartbeat.`;
-        policyFeedback.push(reason);
-        logger.info(`Policy rejected action ${candidateAction.action}: ${reason}`);
-        continue;
-      }
-      if (candidateAction.tweetId && blockedTweetIds.has(candidateAction.tweetId)) {
-        const reason = `Tweet ${candidateAction.tweetId} is blocked for this heartbeat.`;
-        policyFeedback.push(reason);
-        logger.info(`Policy rejected action ${candidateAction.action}: ${reason}`);
-        continue;
-      }
-      let policy = evaluateActionPolicy({
-        action: candidateAction,
-        step: actions.length,
-        timeline: filteredTimeline,
-        mentions: filteredMentions,
-        executedActions: actions,
-        observedTweetIds,
-        observedTweets,
-        selfHandle,
-        selfUserId
-      });
-      if (!policy.allowed && shouldAttemptStyleRewrite(candidateAction, policy.reason ?? "")) {
-        const recentTexts = getRecentInteractions(10).filter((entry) => entry.type === "post" || entry.type === "reply").map((entry) => entry.content ?? "").filter(Boolean);
-        const rewritten = await rewriteDraftForHumanVoice({
-          action: candidateAction,
-          reason: policy.reason ?? "policy rejected",
-          targetTweetText: candidateAction.tweetId ? observedTweets.find((t) => t.id === candidateAction.tweetId)?.text : void 0,
-          recentTexts
-        });
-        if (rewritten && rewritten !== candidateAction.content) {
-          candidateAction = {
-            ...candidateAction,
-            content: rewritten,
-            reasoning: `${candidateAction.reasoning ?? "rewritten"} | style rewrite`
-          };
-          policy = evaluateActionPolicy({
-            action: candidateAction,
-            step: actions.length,
-            timeline: filteredTimeline,
-            mentions: filteredMentions,
-            executedActions: actions,
-            observedTweetIds,
-            observedTweets,
-            selfHandle,
-            selfUserId
-          });
-        }
-      }
-      if (!policy.allowed) {
-        const reason = policy.reason ?? "Policy rejected action";
-        policyFeedback.push(reason);
-        logger.info(`Policy rejected action ${candidateAction.action}: ${reason}`);
-        if (candidateAction.tweetId) {
-          blockedTweetIds.add(candidateAction.tweetId);
-        }
-        if (candidateAction.action === "reply") {
-          replyRejectionCount += 1;
-          if (replyRejectionCount >= 2 && !strictReplyOnly) {
-            disallowedActions.add("reply");
-            const pivot = "Reply opportunities exhausted this heartbeat. Pivot to like/retweet/follow/post.";
-            policyFeedback.push(pivot);
-            logger.info(`Policy adjustment: ${pivot}`);
-          }
-        }
-        continue;
-      }
-      acceptedInRound += 1;
-      const result = await executeAction(candidateAction);
-      actions.push(candidateAction);
-      results.push(result);
-      if (activeIntents.length > 0) {
-        const touchedHandle = normalizeHandle5(
-          candidateAction.targetHandle ?? candidateAction.handle ?? (candidateAction.tweetId ? authorByTweetId.get(candidateAction.tweetId) : void 0)
-        );
-        const loweredContent = (candidateAction.content ?? "").toLowerCase();
-        for (const intent of activeIntents) {
-          const handleMatch = touchedHandle.length > 0 && intent.targetHandles.some((handle) => normalizeHandle5(handle) === touchedHandle);
-          const topicMatch = loweredContent.length > 0 && intent.focusTopics.some((topic) => loweredContent.includes(topic.toLowerCase()));
-          if (!handleMatch && !topicMatch) continue;
-          recordIntentExecution(intent.id, {
-            success: result.success,
-            note: `${candidateAction.action}${touchedHandle ? ` @${touchedHandle}` : ""}`
-          });
-        }
-      }
-      if (!result.success) {
-        const err = result.error ?? "";
-        if (candidateAction.tweetId) {
-          blockedTweetIds.add(candidateAction.tweetId);
-        }
-        if (candidateAction.action === "reply" && /duplicate content/i.test(err)) {
-          if (!strictReplyOnly) {
-            disallowedActions.add("reply");
-            const reason = "Reply failed with duplicate-content error. Switch to non-reply actions.";
-            policyFeedback.push(reason);
-            logger.info(`Policy adjustment: ${reason}`);
-          } else {
-            const reason = "Reply failed with duplicate-content error. Keep reply mode but use a new angle/target.";
-            policyFeedback.push(reason);
-            logger.info(`Policy adjustment: ${reason}`);
-          }
-        }
-        if ((candidateAction.action === "post" || candidateAction.action === "schedule") && /duplicate content/i.test(err)) {
-          const reason = "Write-path duplicate-content failure. Change framing and try a different angle.";
-          policyFeedback.push(reason);
-          logger.info(`Policy adjustment: ${reason}`);
-        }
-      }
-    }
-    if (acceptedInRound === 0) {
-      logger.info("Planner round produced no policy-approved actions.");
-      continue;
-    }
-  }
-  recordBanditActionResults(actions, results);
-  return {
-    timeline,
-    mentions,
-    actions,
-    results,
-    policyFeedback
-  };
-}
-
-export {
-  runAutonomyCycle
-};
-//# sourceMappingURL=chunk-TTM54LQR.js.map