spora 0.7.9 → 0.7.10

package/dist/{autonomy-ZMFZRXDZ.js → autonomy-YBWBP6QJ.js}

@@ -1,6 +1,6 @@
 import {
   runAutonomyCycle
-} from "./chunk-TTDQZI5W.js";
+} from "./chunk-245JDXK4.js";
 import "./chunk-TKGB5LIN.js";
 import "./chunk-AIGSCHZK.js";
 import "./chunk-73CWOI44.js";
@@ -17,4 +17,4 @@ import "./chunk-ZWKTKWS6.js";
 export {
   runAutonomyCycle
 };
-//# sourceMappingURL=autonomy-ZMFZRXDZ.js.map
+//# sourceMappingURL=autonomy-YBWBP6QJ.js.map

package/dist/{chunk-TTDQZI5W.js → chunk-245JDXK4.js}

@@ -967,6 +967,37 @@ function canonicalPlannerHandle(handle) {
 function canonicalizePlannerQuery(rawQuery) {
   return rawQuery.replace(/from:([a-zA-Z0-9_]{1,15})/gi, (_match, handle) => `from:${canonicalPlannerHandle(handle)}`);
 }
+var REPLY_TARGET_COOLDOWN_MS = 6 * 60 * 60 * 1e3;
+function normalizeDraftText(text) {
+  return text.toLowerCase().replace(/https?:\/\/\S+/g, "").replace(/[@#][a-z0-9_]+/g, "").replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenJaccard(a, b) {
+  const aTokens = new Set(normalizeDraftText(a).split(" ").filter(Boolean));
+  const bTokens = new Set(normalizeDraftText(b).split(" ").filter(Boolean));
+  if (aTokens.size === 0 || bTokens.size === 0) return 0;
+  let overlap = 0;
+  for (const token of aTokens) {
+    if (bTokens.has(token)) overlap += 1;
+  }
+  const union = aTokens.size + bTokens.size - overlap;
+  return union > 0 ? overlap / union : 0;
+}
+function nearDuplicateDraft(content, previous) {
+  const normalized = normalizeDraftText(content);
+  if (!normalized) return false;
+  return previous.some((sample) => {
+    const candidate = normalizeDraftText(sample);
+    if (!candidate) return false;
+    if (candidate === normalized) return true;
+    const sameOpening = normalized.split(" ").slice(0, 7).join(" ") === candidate.split(" ").slice(0, 7).join(" ");
+    if (sameOpening) return true;
+    return tokenJaccard(normalized, candidate) >= 0.86;
+  });
+}
+function shouldHardBlockPolicyReason(reason) {
+  const lower = reason.toLowerCase();
+  return lower.includes("already executed for tweet") || lower.includes("rejected self-interaction") || lower.includes("self-follow") || lower.includes("requires replying only") || lower.includes("reply target must be one of") || lower.includes("interaction target must be one of") || lower.includes("forbids standalone original posts") || lower.includes("reply-only mode");
+}
 function roughWordCount(text) {
   return text.trim().split(/\s+/).filter(Boolean).length;
 }
@@ -1270,6 +1301,21 @@ function buildToolLoopPrompt(input) {
   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)}`
   );
+  if (input.usedReplyTargets.length > 0) {
+    lines.push(`Reply targets already used this heartbeat: ${input.usedReplyTargets.slice(-8).join(", ")}`);
+  }
+  if (input.recentReplyTargets.length > 0) {
+    lines.push(`Recently replied targets (cooldown): ${input.recentReplyTargets.slice(0, 8).join(", ")}`);
+  }
+  if (input.blockedReplyTargets.length > 0) {
+    lines.push(`Temporarily blocked reply targets this heartbeat: ${input.blockedReplyTargets.slice(0, 8).join(", ")}`);
+  }
+  if (input.recentWrittenSamples.length > 0) {
+    lines.push("Recent writing to avoid repeating:");
+    for (const sample of input.recentWrittenSamples.slice(0, 4)) {
+      lines.push(`- ${sample.slice(0, 100)}`);
+    }
+  }
   lines.push("");
   if (input.toolHistory.length > 0) {
     lines.push("Recent tool steps:");
@@ -1316,6 +1362,7 @@ function buildToolLoopPrompt(input) {
   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("- one reply per target tweet per heartbeat, always choose a new tweet next");
   lines.push("");
   lines.push("Writing constraints:");
   lines.push("- sound human and specific, no manifesto language");
@@ -1374,6 +1421,10 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
   const client = await getXClient();
   const identity = loadIdentity();
   const constraints = getPersonaConstraints();
+  const strictReplyHandles = new Set(constraints.onlyReplyToHandles.map((handle) => normalizeHandle2(handle)));
+  const strictInteractHandles = new Set(
+    [...constraints.onlyReplyToHandles, ...constraints.onlyInteractWithHandles].map((handle) => normalizeHandle2(handle))
+  );
   const constraintLines = buildPersonaConstraintLines(constraints);
   if (constraintLines.length > 0) {
     logger.info(`Persona constraints active: ${constraintLines.join(" | ")}`);
@@ -1432,9 +1483,50 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
   const activeIntents = listIntents();
   let staleSteps = 0;
   let attemptedActions = 0;
-  const maxToolSteps = Math.max(12, maxActions * 6);
+  const maxConfiguredActions = Math.max(1, maxActions);
+  let actionBudget = maxConfiguredActions;
+  if (constraints.replyOnlyMode || strictReplyHandles.size > 0) {
+    actionBudget = 1;
+  } else {
+    const upper = Math.min(maxConfiguredActions, 3);
+    actionBudget = Math.max(1, Math.floor(Math.random() * upper) + 1);
+  }
+  const maxToolSteps = Math.max(8, actionBudget * 5);
+  const recentInteractions = getRecentInteractions(220);
+  const now = Date.now();
+  const recentReplyTargets = new Set(
+    recentInteractions.filter((entry) => entry.type === "reply" && typeof entry.inReplyTo === "string").filter((entry) => {
+      const ts = Date.parse(entry.timestamp);
+      return Number.isNaN(ts) || now - ts <= REPLY_TARGET_COOLDOWN_MS;
+    }).map((entry) => entry.inReplyTo)
+  );
+  const recentWrittenSamples = recentInteractions.filter((entry) => (entry.type === "post" || entry.type === "reply") && typeof entry.content === "string").map((entry) => entry.content.trim()).filter(Boolean).slice(0, 16);
+  const usedReplyTargets = /* @__PURE__ */ new Set();
+  const blockedReplyTargets = /* @__PURE__ */ new Set();
+  const writtenThisHeartbeat = [];
   getRecentInteractions(20);
-  for (let step = 0; step < maxToolSteps && actions.length < maxActions; step += 1) {
+  const markNoProgress = (note) => {
+    if (note) policyFeedback.push(note);
+    staleSteps += 1;
+    if (staleSteps >= 5) {
+      logger.info("Tool loop stopped after repeated blocked/no-progress steps.");
+      return true;
+    }
+    return false;
+  };
+  const hasEligibleStrictReplyTarget = () => {
+    const observed = collectObserved(state);
+    return observed.tweets.some((tweet) => {
+      const handle = normalizeHandle2(tweet.authorHandle);
+      return strictReplyHandles.has(handle) && !usedReplyTargets.has(tweet.id) && !recentReplyTargets.has(tweet.id) && !blockedReplyTargets.has(tweet.id);
+    });
+  };
+  for (let step = 0; step < maxToolSteps && actions.length < actionBudget; step += 1) {
+    if (strictReplyHandles.size > 0 && !hasEligibleStrictReplyTarget()) {
+      policyFeedback.push("No eligible fresh target tweets remain for strict reply mode this heartbeat.");
+      logger.info("Planner loop ended: no eligible strict-reply targets left.");
+      break;
+    }
     const candidates = buildPlannerCandidates(state);
     const recentMemory = getRecentInteractions(24).slice(0, 12).map((entry) => {
       const text = (entry.content ?? "").replace(/\s+/g, " ").trim().slice(0, 120);
@@ -1457,6 +1549,10 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       policyFeedback,
       toolHistory,
       recentMemory,
+      usedReplyTargets: [...usedReplyTargets],
+      recentReplyTargets: [...recentReplyTargets],
+      blockedReplyTargets: [...blockedReplyTargets],
+      recentWrittenSamples: [...writtenThisHeartbeat, ...recentWrittenSamples].slice(0, 8),
       heartbeatCount
     });
     let decision = fallbackPlannerDecision(step, candidates.length);
@@ -1488,7 +1584,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       } catch (error) {
         policyFeedback.push(`observe_timeline failed: ${error.message}`);
       }
-      if (!stepProgress) policyFeedback.push("observe_timeline found no new tweets.");
+      if (!stepProgress && markNoProgress("observe_timeline found no new tweets.")) break;
       continue;
     }
     if (decision.tool === "observe_mentions") {
@@ -1506,13 +1602,13 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       } catch (error) {
         policyFeedback.push(`observe_mentions failed: ${error.message}`);
       }
-      if (!stepProgress) policyFeedback.push("observe_mentions found no new tweets.");
+      if (!stepProgress && markNoProgress("observe_mentions found no new tweets.")) break;
       continue;
     }
     if (decision.tool === "search_tweets") {
       const rawQuery = argString(decision.args, "query");
       if (!rawQuery) {
-        policyFeedback.push("search_tweets rejected: missing query.");
+        if (markNoProgress("search_tweets rejected: missing query.")) break;
         continue;
       }
       const query = canonicalizePlannerQuery(rawQuery);
@@ -1534,14 +1630,14 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       } catch (error) {
         policyFeedback.push(`search_tweets failed for "${query}": ${error.message}`);
       }
-      if (!stepProgress) policyFeedback.push(`search_tweets "${query}" found no new tweets.`);
+      if (!stepProgress && markNoProgress(`search_tweets "${query}" found no new tweets.`)) break;
       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.");
+        if (markNoProgress("check_profile rejected: missing handle.")) break;
         continue;
       }
       const count = argCount(decision.args, 6, 3, 12);
@@ -1565,14 +1661,13 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       } catch (error) {
         policyFeedback.push(`check_profile failed for @${handle}: ${error.message}`);
       }
-      if (!stepProgress) policyFeedback.push(`check_profile @${handle} found no new tweets.`);
+      if (!stepProgress && markNoProgress(`check_profile @${handle} found no new tweets.`)) break;
       continue;
     }
     const observed = collectObserved(state);
     let candidateAction = decisionToAgentAction(decision);
     if (!candidateAction) {
-      policyFeedback.push(`Tool decision ${decision.tool} rejected: invalid arguments.`);
-      staleSteps += 1;
+      if (markNoProgress(`Tool decision ${decision.tool} rejected: invalid arguments.`)) break;
       continue;
     }
     if (candidateAction.tweetId && observed.byId.has(candidateAction.tweetId)) {
@@ -1581,6 +1676,9 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
         candidateAction.targetHandle = `@${author}`;
       }
     }
+    const actionTargetHandle = normalizeHandle2(
+      candidateAction.targetHandle ?? candidateAction.handle ?? (candidateAction.tweetId ? observed.byId.get(candidateAction.tweetId)?.authorHandle : void 0)
+    );
     if (candidateAction.action === "skip") {
       const reason = candidateAction.reason ?? candidateAction.reasoning ?? "planner skip";
       policyFeedback.push(`Planner chose skip: ${reason}`);
@@ -1589,10 +1687,76 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
         tool: decision.tool,
         summary: reason
       });
-      staleSteps += 1;
-      if (staleSteps >= 4) break;
+      if (markNoProgress()) break;
+      continue;
+    }
+    if (constraints.noOriginalPosts && (candidateAction.action === "post" || candidateAction.action === "schedule")) {
+      const reason = "Original posts are disabled by persona constraints.";
+      policyFeedback.push(reason);
+      logger.info(`Policy blocked action ${candidateAction.action}: ${reason}`);
+      if (markNoProgress()) break;
       continue;
     }
+    if (strictReplyHandles.size > 0) {
+      if (candidateAction.action !== "reply") {
+        const reason = `Only reply actions are allowed for this persona target: @${[...strictReplyHandles].join(", @")}.`;
+        policyFeedback.push(reason);
+        logger.info(`Policy blocked action ${candidateAction.action}: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
+      if (!actionTargetHandle || !strictReplyHandles.has(actionTargetHandle)) {
+        const reason = `Reply target must be one of @${[...strictReplyHandles].join(", @")}.`;
+        policyFeedback.push(reason);
+        logger.info(`Policy blocked action ${candidateAction.action}: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
+    }
+    if (strictInteractHandles.size > 0 && ["reply", "like", "retweet", "follow"].includes(candidateAction.action)) {
+      if (!actionTargetHandle || !strictInteractHandles.has(actionTargetHandle)) {
+        const reason = `Interaction target must be one of @${[...strictInteractHandles].join(", @")}.`;
+        policyFeedback.push(reason);
+        logger.info(`Policy blocked action ${candidateAction.action}: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
+    }
+    if (candidateAction.action === "reply" && candidateAction.tweetId) {
+      if (blockedReplyTargets.has(candidateAction.tweetId)) {
+        const reason = `Reply target ${candidateAction.tweetId} is temporarily blocked this heartbeat. Pick a different tweet.`;
+        policyFeedback.push(reason);
+        logger.info(`Planner loop guard: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
+      if (usedReplyTargets.has(candidateAction.tweetId)) {
+        const reason = `Reply target ${candidateAction.tweetId} already used this heartbeat. Pick a different tweet.`;
+        policyFeedback.push(reason);
+        logger.info(`Planner loop guard: ${reason}`);
+        blockedReplyTargets.add(candidateAction.tweetId);
+        if (markNoProgress()) break;
+        continue;
+      }
+      if (recentReplyTargets.has(candidateAction.tweetId)) {
+        const reason = `Reply target ${candidateAction.tweetId} is in cooldown from recent history. Pick a fresher target.`;
+        policyFeedback.push(reason);
+        logger.info(`Planner loop guard: ${reason}`);
+        blockedReplyTargets.add(candidateAction.tweetId);
+        if (markNoProgress()) break;
+        continue;
+      }
+    }
+    if ((candidateAction.action === "reply" || candidateAction.action === "post") && candidateAction.content) {
+      const seenDrafts = [...writtenThisHeartbeat, ...recentWrittenSamples].slice(0, 18);
+      if (nearDuplicateDraft(candidateAction.content, seenDrafts)) {
+        const reason = "Draft is too similar to recent writing. Try a new angle before posting.";
+        policyFeedback.push(reason);
+        logger.info(`Planner loop guard: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
+    }
     attemptedActions += 1;
     let policy = evaluateActionPolicy({
       action: candidateAction,
@@ -1634,9 +1798,24 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
     }
     if (!policy.allowed) {
       const reason = policy.reason ?? "Policy rejected action";
+      if (shouldHardBlockPolicyReason(reason)) {
+        policyFeedback.push(`Policy blocked action: ${reason}`);
+        logger.info(`Policy blocked ${candidateAction.action}: ${reason}`);
+        if (markNoProgress()) break;
+        continue;
+      }
       policyFeedback.push(`Policy advisory (not blocking): ${reason}`);
       logger.info(`Policy advisory for ${candidateAction.action}: ${reason}`);
     }
+    if (candidateAction.action === "reply" && candidateAction.tweetId) {
+      usedReplyTargets.add(candidateAction.tweetId);
+    }
+    if ((candidateAction.action === "reply" || candidateAction.action === "post") && candidateAction.content) {
+      writtenThisHeartbeat.unshift(candidateAction.content.trim());
+      if (writtenThisHeartbeat.length > 16) {
+        writtenThisHeartbeat.length = 16;
+      }
+    }
     const result = await executeAction(candidateAction);
     actions.push(candidateAction);
     results.push(result);
@@ -1667,6 +1846,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       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);
+        if (candidateAction.tweetId) blockedReplyTargets.add(candidateAction.tweetId);
         logger.info(`Policy adjustment: ${reason}`);
       }
       if (candidateAction.action === "post" && /duplicate content/i.test(err)) {
@@ -1675,11 +1855,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
         logger.info(`Policy adjustment: ${reason}`);
       }
     }
-    if (!stepProgress) {
-      staleSteps += 1;
-    }
-    if (staleSteps >= 5) {
-      logger.info("Tool loop stopped after repeated no-progress steps.");
+    if (!stepProgress && markNoProgress()) {
       break;
     }
   }
@@ -1696,4 +1872,4 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
 export {
   runAutonomyCycle
 };
-//# sourceMappingURL=chunk-TTDQZI5W.js.map
+//# sourceMappingURL=chunk-245JDXK4.js.map