spora 0.7.7 → 0.7.8

package/dist/chunk-TTDQZI5W.js

@@ -0,0 +1,1699 @@
+import {
+  getXClient
+} from "./chunk-TKGB5LIN.js";
+import {
+  addToQueue
+} from "./chunk-AIGSCHZK.js";
+import {
+  buildPersonaConstraintLines,
+  buildSystemPrompt,
+  getPersonaConstraints,
+  personaConstraintHandles
+} from "./chunk-73CWOI44.js";
+import {
+  listIntents,
+  recordIntentExecution
+} from "./chunk-OTZNHIXT.js";
+import {
+  updatePostMetrics
+} from "./chunk-ER6TILYZ.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,
+  logInteraction
+} from "./chunk-6WBIVXOY.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 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) {
+    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."
+      };
+    }
+  }
+  return { allowed: true };
+}
+
+// src/runtime/bandit.ts
+import { existsSync, readFileSync, writeFileSync } 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 (!existsSync(paths.bandit)) return defaultState();
+  try {
+    const parsed = JSON.parse(readFileSync(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);
+  writeFileSync(paths.bandit, JSON.stringify(state, null, 2));
+}
+function ensureArm(state, armKey) {
+  const existing = state.arms[armKey];
+  if (existing) return existing;
+  const arm = {
+    key: armKey,
+    pulls: 0,
+    rewardSum: 0,
+    lastReward: 0,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state.arms[armKey] = arm;
+  return arm;
+}
+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 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 armKey = armKeyFromAction(action);
+    const arm = ensureArm(state, armKey);
+    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,
+        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 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 normalizeHandle2(handle) {
+  return (handle ?? "").replace(/^@/, "").trim().toLowerCase();
+}
+function canonicalPlannerHandle(handle) {
+  const clean = normalizeHandle2(handle);
+  const aliasMap = {
+    gork: "grok",
+    spora: "sporaai",
+    spora_ai: "sporaai"
+  };
+  return aliasMap[clean] ?? clean;
+}
+function canonicalizePlannerQuery(rawQuery) {
+  return rawQuery.replace(/from:([a-zA-Z0-9_]{1,15})/gi, (_match, handle) => `from:${canonicalPlannerHandle(handle)}`);
+}
+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 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;
+  }
+}
+function loopClampInt(value, min, max) {
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+function parseJsonObjectFromText(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 {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      if (Array.isArray(parsed) && parsed.length > 0 && parsed[0] && typeof parsed[0] === "object") {
+        return parsed[0];
+      }
+    } catch {
+    }
+    const obj = candidate.match(/\{[\s\S]*\}/);
+    if (!obj) continue;
+    try {
+      const parsed = JSON.parse(obj[0]);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function mapPlannerTool(raw) {
+  const clean = (raw ?? "").trim().toLowerCase();
+  if (!clean) return null;
+  if (clean === "observe_timeline" || clean === "read_timeline" || clean === "timeline") return "observe_timeline";
+  if (clean === "observe_mentions" || clean === "read_mentions" || clean === "mentions") return "observe_mentions";
+  if (clean === "search_tweets" || clean === "search" || clean === "topic_search") return "search_tweets";
+  if (clean === "check_profile" || clean === "check_person" || clean === "people_check" || clean === "profile_check") return "check_profile";
+  if (clean === "reply") return "reply";
+  if (clean === "like") return "like";
+  if (clean === "retweet") return "retweet";
+  if (clean === "follow") return "follow";
+  if (clean === "post" || clean === "tweet") return "post";
+  if (clean === "skip" || clean === "noop" || clean === "no_action") return "skip";
+  return null;
+}
+function parsePlannerDecision(text) {
+  const parsed = parseJsonObjectFromText(text);
+  if (!parsed) return null;
+  const rawTool = typeof parsed.tool === "string" ? parsed.tool : typeof parsed.action === "string" ? parsed.action : void 0;
+  const tool = mapPlannerTool(rawTool);
+  if (!tool) return null;
+  const rawArgs = parsed.args;
+  const args = rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs) ? { ...rawArgs } : {};
+  for (const key of ["tweetId", "content", "handle", "query", "count", "reason"]) {
+    if (args[key] !== void 0) continue;
+    if (parsed[key] !== void 0) args[key] = parsed[key];
+  }
+  const reasoning = typeof parsed.reasoning === "string" ? parsed.reasoning.trim() : void 0;
+  return { tool, args, reasoning };
+}
+function argString(args, key) {
+  const value = args[key];
+  if (typeof value !== "string") return void 0;
+  const clean = value.trim();
+  return clean.length > 0 ? clean : void 0;
+}
+function argCount(args, fallback, min, max) {
+  const raw = args.count;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return loopClampInt(raw, min, max);
+  }
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    const parsed = Number(raw);
+    if (Number.isFinite(parsed)) return loopClampInt(parsed, min, max);
+  }
+  return loopClampInt(fallback, min, max);
+}
+function tweetTimestamp(tweet) {
+  const ts = Date.parse(tweet.createdAt);
+  return Number.isNaN(ts) ? 0 : ts;
+}
+function mergeTweetList(current, incoming) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const tweet of current) byId.set(tweet.id, tweet);
+  let added = 0;
+  for (const tweet of incoming) {
+    if (!tweet.id) continue;
+    if (!byId.has(tweet.id)) added += 1;
+    byId.set(tweet.id, tweet);
+  }
+  const tweets = [...byId.values()].sort((a, b) => tweetTimestamp(b) - tweetTimestamp(a));
+  return { tweets, added };
+}
+function mergeTopicResult(current, query, incoming) {
+  const idx = current.findIndex((item) => item.query.toLowerCase() === query.toLowerCase());
+  if (idx < 0) {
+    const merged2 = mergeTweetList([], incoming);
+    return {
+      next: [...current, { query, tweets: merged2.tweets }],
+      added: merged2.added
+    };
+  }
+  const merged = mergeTweetList(current[idx].tweets, incoming);
+  const next = [...current];
+  next[idx] = { ...next[idx], tweets: merged.tweets };
+  return { next, added: merged.added };
+}
+function mergePeopleActivity(current, incoming) {
+  const handle = normalizeHandle2(incoming.handle);
+  const idx = current.findIndex((item) => normalizeHandle2(item.handle) === handle);
+  if (idx < 0) {
+    const merged2 = mergeTweetList([], incoming.tweets);
+    return {
+      next: [...current, { ...incoming, handle, tweets: merged2.tweets }],
+      added: merged2.added
+    };
+  }
+  const merged = mergeTweetList(current[idx].tweets, incoming.tweets);
+  const next = [...current];
+  next[idx] = {
+    ...next[idx],
+    userId: incoming.userId || next[idx].userId,
+    reason: incoming.reason || next[idx].reason,
+    tweets: merged.tweets
+  };
+  return { next, added: merged.added };
+}
+function collectObserved(state) {
+  const tweets = [
+    ...state.timeline,
+    ...state.mentions,
+    ...state.topicSearchResults.flatMap((item) => item.tweets),
+    ...state.peopleActivity.flatMap((item) => item.tweets)
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const tweet of tweets) {
+    if (!tweet.id || byId.has(tweet.id)) continue;
+    byId.set(tweet.id, tweet);
+  }
+  return {
+    ids: [...byId.keys()],
+    tweets: [...byId.values()],
+    byId
+  };
+}
+function buildPlannerCandidates(state) {
+  const ordered = [
+    ...state.mentions,
+    ...state.timeline,
+    ...state.topicSearchResults.flatMap((item) => item.tweets),
+    ...state.peopleActivity.flatMap((item) => item.tweets)
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const tweet of ordered) {
+    if (!tweet.id) continue;
+    if (!byId.has(tweet.id)) byId.set(tweet.id, tweet);
+  }
+  return [...byId.values()].slice(0, 24);
+}
+function buildToolLoopPrompt(input) {
+  const lines = [];
+  lines.push("Choose exactly ONE tool call in strict JSON.");
+  lines.push("You are the autonomous planner. No fixed research sequence is required.");
+  lines.push("Act based on persona + live context, not templates.");
+  lines.push("");
+  lines.push(`Heartbeat: #${input.heartbeatCount}`);
+  lines.push(`Agent: ${input.identity.name} (@${input.identity.handle})`);
+  lines.push(`Bio: ${input.identity.bio}`);
+  lines.push(`Tone: ${input.identity.tone}`);
+  lines.push(`Goals: ${input.identity.goals.join(" | ") || "none"}`);
+  lines.push(`Boundaries: ${input.identity.boundaries.join(" | ") || "none"}`);
+  lines.push("");
+  if (input.constraintLines.length > 0) {
+    lines.push("Hard persona constraints:");
+    for (const line of input.constraintLines) lines.push(line);
+    lines.push("");
+  }
+  if (input.recentMemory.length > 0) {
+    lines.push("Recent memory:");
+    for (const row of input.recentMemory.slice(0, 8)) {
+      lines.push(`- ${row}`);
+    }
+    lines.push("");
+  }
+  lines.push(`Executed actions this heartbeat: ${input.actions.length}`);
+  lines.push(
+    `Current context counts: timeline=${input.state.timeline.length}, mentions=${input.state.mentions.length}, topicTweets=${input.state.topicSearchResults.reduce((sum, item) => sum + item.tweets.length, 0)}, peopleTweets=${input.state.peopleActivity.reduce((sum, item) => sum + item.tweets.length, 0)}`
+  );
+  lines.push("");
+  if (input.toolHistory.length > 0) {
+    lines.push("Recent tool steps:");
+    for (const row of input.toolHistory.slice(-6)) {
+      lines.push(`- Step ${row.step}: ${row.tool} -> ${row.summary}`);
+    }
+    lines.push("");
+  }
+  if (input.policyFeedback.length > 0) {
+    lines.push("Recent policy feedback:");
+    for (const note of input.policyFeedback.slice(-8)) {
+      lines.push(`- ${note}`);
+    }
+    lines.push("");
+  }
+  if (input.candidates.length > 0) {
+    lines.push(`Top candidate tweets (${input.candidates.length}):`);
+    for (const tweet of input.candidates.slice(0, 16)) {
+      lines.push(
+        `- [${tweet.id}] @${tweet.authorHandle}: ${tweet.text.slice(0, 190)} (${tweet.likeCount ?? 0} likes, ${tweet.replyCount ?? 0} replies)`
+      );
+    }
+    lines.push("");
+  } else {
+    lines.push("No candidate tweets currently in context.");
+    lines.push("");
+  }
+  lines.push("Tool options:");
+  lines.push('- observe_timeline: { "count": 8-30 }');
+  lines.push('- observe_mentions: { "count": 8-30 }');
+  lines.push('- search_tweets: { "query": "x api search query", "count": 3-20 }');
+  lines.push('- check_profile: { "handle": "@username", "count": 3-12 }');
+  lines.push('- reply: { "tweetId": "id", "content": "reply under 220 chars" }');
+  lines.push('- like: { "tweetId": "id" }');
+  lines.push('- retweet: { "tweetId": "id" }');
+  lines.push('- follow: { "handle": "@username" }');
+  lines.push('- post: { "content": "post under 220 chars" }');
+  lines.push('- skip: { "reason": "short reason" }');
+  lines.push("");
+  lines.push("Output JSON object only:");
+  lines.push('{ "tool": "reply", "args": { "tweetId": "...", "content": "..." }, "reasoning": "short why" }');
+  lines.push("");
+  lines.push("Planning rules:");
+  lines.push("- if timeline/mentions already have viable tweets, prefer acting over more research");
+  lines.push("- use search/profile checks only when you have a clear reason");
+  lines.push("- avoid repeating the same query/target unless context changed");
+  lines.push("");
+  lines.push("Writing constraints:");
+  lines.push("- sound human and specific, no manifesto language");
+  lines.push("- avoid 'the real question' / 'the deeper question' phrasing");
+  lines.push("- no repetitive anchor terms from recent outputs");
+  lines.push("- match the persona tone strictly");
+  return lines.join("\n");
+}
+function fallbackPlannerDecision(step, observedCount) {
+  if (observedCount === 0) {
+    return {
+      tool: step % 2 === 0 ? "observe_timeline" : "observe_mentions",
+      args: { count: 20 },
+      reasoning: "fallback context bootstrap"
+    };
+  }
+  return {
+    tool: "skip",
+    args: { reason: "planner parse fallback; preserve current context" },
+    reasoning: "fallback no-op"
+  };
+}
+function decisionToAgentAction(decision) {
+  if (decision.tool === "reply") {
+    const tweetId = argString(decision.args, "tweetId");
+    const content = argString(decision.args, "content");
+    if (!tweetId || !content) return null;
+    return { action: "reply", tweetId, content, reasoning: decision.reasoning };
+  }
+  if (decision.tool === "like") {
+    const tweetId = argString(decision.args, "tweetId");
+    if (!tweetId) return null;
+    return { action: "like", tweetId, reasoning: decision.reasoning };
+  }
+  if (decision.tool === "retweet") {
+    const tweetId = argString(decision.args, "tweetId");
+    if (!tweetId) return null;
+    return { action: "retweet", tweetId, reasoning: decision.reasoning };
+  }
+  if (decision.tool === "follow") {
+    const handle = argString(decision.args, "handle");
+    if (!handle) return null;
+    return { action: "follow", handle, targetHandle: handle, reasoning: decision.reasoning };
+  }
+  if (decision.tool === "post") {
+    const content = argString(decision.args, "content");
+    if (!content) return null;
+    return { action: "post", content, reasoning: decision.reasoning };
+  }
+  if (decision.tool === "skip") {
+    return { action: "skip", reason: argString(decision.args, "reason"), reasoning: decision.reasoning };
+  }
+  return null;
+}
+async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
+  const client = await getXClient();
+  const identity = loadIdentity();
+  const constraints = getPersonaConstraints();
+  const constraintLines = buildPersonaConstraintLines(constraints);
+  if (constraintLines.length > 0) {
+    logger.info(`Persona constraints active: ${constraintLines.join(" | ")}`);
+  }
+  logger.info(`Autonomy runtime v2 active: planner-primary, persona+memory driven.`);
+  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 state = {
+    timeline: [],
+    mentions: [],
+    topicSearchResults: [],
+    peopleActivity: []
+  };
+  try {
+    const timeline = (await client.getTimeline({ count: 30 })).filter((tweet) => !isSelfTweet(tweet));
+    state.timeline = mergeTweetList(state.timeline, timeline).tweets;
+  } catch (error) {
+    logger.warn(`Seed timeline read failed: ${error.message}`);
+  }
+  try {
+    const mentions = (await client.getMentions({ count: 30 })).filter((tweet) => !isSelfTweet(tweet));
+    state.mentions = mergeTweetList(state.mentions, mentions).tweets;
+  } catch (error) {
+    logger.warn(`Seed mentions read failed: ${error.message}`);
+  }
+  logger.info(
+    `Autonomy context: timeline=${state.timeline.length}, mentions=${state.mentions.length}, topicTweets=${state.topicSearchResults.reduce((sum, item) => sum + item.tweets.length, 0)}, peopleTweets=${state.peopleActivity.reduce((sum, item) => sum + item.tweets.length, 0)}`
+  );
+  const actions = [];
+  const results = [];
+  const toolHistory = [];
+  const policyFeedback = [
+    `Persona: ${identity.name} (@${identity.handle})`,
+    `Tone: ${identity.tone}`,
+    `Goals: ${(identity.goals ?? []).slice(0, 4).join(" | ") || "none"}`
+  ];
+  const systemPrompt = buildSystemPrompt();
+  const toolSystemPrompt = [
+    systemPrompt,
+    "TOOL LOOP MODE: You must choose exactly one tool call each step using strict JSON.",
+    "Planner-first mode: there is no pre-defined research flow.",
+    "Everything must be persona-driven, memory-aware, and context-grounded.",
+    "Do not fall into repetitive searches or repetitive targets."
+  ].join("\n\n");
+  const activeIntents = listIntents();
+  let staleSteps = 0;
+  let attemptedActions = 0;
+  const maxToolSteps = Math.max(12, maxActions * 6);
+  getRecentInteractions(20);
+  for (let step = 0; step < maxToolSteps && actions.length < maxActions; step += 1) {
+    const candidates = buildPlannerCandidates(state);
+    const recentMemory = getRecentInteractions(24).slice(0, 12).map((entry) => {
+      const text = (entry.content ?? "").replace(/\s+/g, " ").trim().slice(0, 120);
+      const target = entry.targetHandle ? ` @${entry.targetHandle}` : "";
+      return `${entry.type}${target}${text ? `: ${text}` : ""}`;
+    });
+    const prompt = buildToolLoopPrompt({
+      identity: {
+        name: identity.name,
+        handle: identity.handle,
+        bio: identity.bio,
+        tone: identity.tone,
+        goals: identity.goals ?? [],
+        boundaries: identity.boundaries ?? []
+      },
+      constraintLines,
+      candidates,
+      state,
+      actions,
+      policyFeedback,
+      toolHistory,
+      recentMemory,
+      heartbeatCount
+    });
+    let decision = fallbackPlannerDecision(step, candidates.length);
+    try {
+      const response = await generateResponse(toolSystemPrompt, prompt);
+      const parsed = parsePlannerDecision(response.content);
+      if (parsed) {
+        decision = parsed;
+      } else {
+        policyFeedback.push("Planner returned invalid JSON decision. Using fallback tool.");
+      }
+    } catch (error) {
+      policyFeedback.push(`Planner call failed: ${error.message}`);
+    }
+    logger.info(`Tool loop step ${step + 1}: ${decision.tool}`);
+    let stepProgress = false;
+    if (decision.tool === "observe_timeline") {
+      const count = argCount(decision.args, 16, 8, 30);
+      try {
+        const incoming = (await client.getTimeline({ count })).filter((tweet) => !isSelfTweet(tweet));
+        const merged = mergeTweetList(state.timeline, incoming);
+        state.timeline = merged.tweets;
+        stepProgress = merged.added > 0;
+        toolHistory.push({
+          step: step + 1,
+          tool: decision.tool,
+          summary: `fetched ${incoming.length}, added ${merged.added}`
+        });
+      } catch (error) {
+        policyFeedback.push(`observe_timeline failed: ${error.message}`);
+      }
+      if (!stepProgress) policyFeedback.push("observe_timeline found no new tweets.");
+      continue;
+    }
+    if (decision.tool === "observe_mentions") {
+      const count = argCount(decision.args, 16, 8, 30);
+      try {
+        const incoming = (await client.getMentions({ count })).filter((tweet) => !isSelfTweet(tweet));
+        const merged = mergeTweetList(state.mentions, incoming);
+        state.mentions = merged.tweets;
+        stepProgress = merged.added > 0;
+        toolHistory.push({
+          step: step + 1,
+          tool: decision.tool,
+          summary: `fetched ${incoming.length}, added ${merged.added}`
+        });
+      } catch (error) {
+        policyFeedback.push(`observe_mentions failed: ${error.message}`);
+      }
+      if (!stepProgress) policyFeedback.push("observe_mentions found no new tweets.");
+      continue;
+    }
+    if (decision.tool === "search_tweets") {
+      const rawQuery = argString(decision.args, "query");
+      if (!rawQuery) {
+        policyFeedback.push("search_tweets rejected: missing query.");
+        continue;
+      }
+      const query = canonicalizePlannerQuery(rawQuery);
+      if (query !== rawQuery) {
+        policyFeedback.push(`search_tweets normalized handle query: "${rawQuery}" -> "${query}"`);
+      }
+      const count = argCount(decision.args, 10, 3, 20);
+      try {
+        const incoming = (await client.searchTweets(query, { count })).filter((tweet) => !isSelfTweet(tweet));
+        const merged = mergeTopicResult(state.topicSearchResults, query, incoming);
+        state.topicSearchResults = merged.next;
+        stepProgress = merged.added > 0;
+        toolHistory.push({
+          step: step + 1,
+          tool: decision.tool,
+          summary: `"${query}" fetched ${incoming.length}, added ${merged.added}`
+        });
+        logger.info(`Tool search "${query}": found ${incoming.length} tweets`);
+      } catch (error) {
+        policyFeedback.push(`search_tweets failed for "${query}": ${error.message}`);
+      }
+      if (!stepProgress) policyFeedback.push(`search_tweets "${query}" found no new tweets.`);
+      continue;
+    }
+    if (decision.tool === "check_profile") {
+      const handleInput = argString(decision.args, "handle");
+      const handle = handleInput ? canonicalPlannerHandle(handleInput) : "";
+      if (!handle) {
+        policyFeedback.push("check_profile rejected: missing handle.");
+        continue;
+      }
+      const count = argCount(decision.args, 6, 3, 12);
+      try {
+        const profile = await client.getProfile(handle);
+        const tweets = (await client.getUserTweets(profile.id, { count })).filter((tweet) => !isSelfTweet(tweet));
+        const merged = mergePeopleActivity(state.peopleActivity, {
+          handle,
+          userId: profile.id,
+          reason: "tool-loop check",
+          tweets
+        });
+        state.peopleActivity = merged.next;
+        stepProgress = merged.added > 0;
+        toolHistory.push({
+          step: step + 1,
+          tool: decision.tool,
+          summary: `@${handle} fetched ${tweets.length}, added ${merged.added}`
+        });
+        logger.info(`People check @${handle}: ${tweets.length} recent tweets`);
+      } catch (error) {
+        policyFeedback.push(`check_profile failed for @${handle}: ${error.message}`);
+      }
+      if (!stepProgress) policyFeedback.push(`check_profile @${handle} found no new tweets.`);
+      continue;
+    }
+    const observed = collectObserved(state);
+    let candidateAction = decisionToAgentAction(decision);
+    if (!candidateAction) {
+      policyFeedback.push(`Tool decision ${decision.tool} rejected: invalid arguments.`);
+      staleSteps += 1;
+      continue;
+    }
+    if (candidateAction.tweetId && observed.byId.has(candidateAction.tweetId)) {
+      const author = normalizeHandle2(observed.byId.get(candidateAction.tweetId)?.authorHandle);
+      if (author && !candidateAction.targetHandle) {
+        candidateAction.targetHandle = `@${author}`;
+      }
+    }
+    if (candidateAction.action === "skip") {
+      const reason = candidateAction.reason ?? candidateAction.reasoning ?? "planner skip";
+      policyFeedback.push(`Planner chose skip: ${reason}`);
+      toolHistory.push({
+        step: step + 1,
+        tool: decision.tool,
+        summary: reason
+      });
+      staleSteps += 1;
+      if (staleSteps >= 4) break;
+      continue;
+    }
+    attemptedActions += 1;
+    let policy = evaluateActionPolicy({
+      action: candidateAction,
+      step: attemptedActions,
+      timeline: state.timeline,
+      mentions: state.mentions,
+      executedActions: actions,
+      observedTweetIds: observed.ids,
+      observedTweets: observed.tweets,
+      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 ? observed.byId.get(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: attemptedActions,
+          timeline: state.timeline,
+          mentions: state.mentions,
+          executedActions: actions,
+          observedTweetIds: observed.ids,
+          observedTweets: observed.tweets,
+          selfHandle,
+          selfUserId
+        });
+      }
+    }
+    if (!policy.allowed) {
+      const reason = policy.reason ?? "Policy rejected action";
+      policyFeedback.push(`Policy advisory (not blocking): ${reason}`);
+      logger.info(`Policy advisory for ${candidateAction.action}: ${reason}`);
+    }
+    const result = await executeAction(candidateAction);
+    actions.push(candidateAction);
+    results.push(result);
+    staleSteps = 0;
+    stepProgress = true;
+    toolHistory.push({
+      step: step + 1,
+      tool: decision.tool,
+      summary: `${candidateAction.action}${result.success ? " success" : " failed"}`
+    });
+    if (activeIntents.length > 0) {
+      const touchedHandle = normalizeHandle2(
+        candidateAction.targetHandle ?? candidateAction.handle ?? (candidateAction.tweetId ? observed.byId.get(candidateAction.tweetId)?.authorHandle : void 0)
+      );
+      const loweredContent = (candidateAction.content ?? "").toLowerCase();
+      for (const intent of activeIntents) {
+        const handleMatch = touchedHandle.length > 0 && intent.targetHandles.some((handle) => normalizeHandle2(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.action === "reply" && /duplicate content/i.test(err)) {
+        const reason = "Reply failed with duplicate-content error. Planner should choose a different wording/target.";
+        policyFeedback.push(reason);
+        logger.info(`Policy adjustment: ${reason}`);
+      }
+      if (candidateAction.action === "post" && /duplicate content/i.test(err)) {
+        const reason = "Post failed with duplicate-content error. Change framing and try a different angle.";
+        policyFeedback.push(reason);
+        logger.info(`Policy adjustment: ${reason}`);
+      }
+    }
+    if (!stepProgress) {
+      staleSteps += 1;
+    }
+    if (staleSteps >= 5) {
+      logger.info("Tool loop stopped after repeated no-progress steps.");
+      break;
+    }
+  }
+  recordBanditActionResults(actions, results);
+  return {
+    timeline: state.timeline,
+    mentions: state.mentions,
+    actions,
+    results,
+    policyFeedback
+  };
+}
+
+export {
+  runAutonomyCycle
+};
+//# sourceMappingURL=chunk-TTDQZI5W.js.map