spora 0.7.9 → 0.7.11

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

@@ -1,6 +1,6 @@
 import {
   runAutonomyCycle
-} from "./chunk-TTDQZI5W.js";
+} from "./chunk-3S44SIUP.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-ZVXD2OP2.js.map

package/dist/{chunk-TTDQZI5W.js → chunk-3S44SIUP.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;
 }
@@ -1083,6 +1114,45 @@ async function rewriteDraftForHumanVoice(input) {
     return null;
   }
 }
+async function composeHeartbeatPostDraft(input) {
+  const system = [
+    `You write one original X post for ${input.identityName} (@${input.identityHandle}).`,
+    "Write like a real person: natural, concise, specific.",
+    "No manifesto voice, no generic AI lecture style.",
+    "Return ONLY the post text."
+  ].join(" ");
+  const promptParts = [];
+  promptParts.push(`Tone: ${input.tone || "natural"}`);
+  promptParts.push(`Goals: ${input.goals.slice(0, 4).join(" | ") || "none"}`);
+  promptParts.push(`Boundaries: ${input.boundaries.slice(0, 4).join(" | ") || "none"}`);
+  promptParts.push("Constraints:");
+  promptParts.push("- 18-180 characters");
+  promptParts.push("- 1-2 short sentences");
+  promptParts.push("- concrete and human sounding");
+  promptParts.push("- don't start with @ unless absolutely needed");
+  promptParts.push("- avoid abstract 'the real question' framing");
+  if (input.contextTweets.length > 0) {
+    promptParts.push("Current timeline context:");
+    for (const tweet of input.contextTweets.slice(0, 6)) {
+      promptParts.push(`- @${tweet.authorHandle}: ${tweet.text.slice(0, 160)}`);
+    }
+  }
+  if (input.recentSamples.length > 0) {
+    promptParts.push("Avoid repeating these recent lines:");
+    for (const sample of input.recentSamples.slice(0, 5)) {
+      promptParts.push(`- ${sample.slice(0, 120)}`);
+    }
+  }
+  try {
+    const response = await generateResponse(system, promptParts.join("\n"));
+    const candidate = cleanRewriteOutput(response.content);
+    if (!candidate) return null;
+    if (candidate.length < 18 || candidate.length > 220) return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
 function loopClampInt(value, min, max) {
   return Math.max(min, Math.min(max, Math.round(value)));
 }
@@ -1259,6 +1329,10 @@ function buildToolLoopPrompt(input) {
     for (const line of input.constraintLines) lines.push(line);
     lines.push("");
   }
+  if (input.heartbeatDirective) {
+    lines.push(`Heartbeat directive: ${input.heartbeatDirective}`);
+    lines.push("");
+  }
   if (input.recentMemory.length > 0) {
     lines.push("Recent memory:");
     for (const row of input.recentMemory.slice(0, 8)) {
@@ -1270,6 +1344,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 +1405,8 @@ 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("- keep timeline presence alive: post an original thought regularly, not only replies");
   lines.push("");
   lines.push("Writing constraints:");
   lines.push("- sound human and specific, no manifesto language");
@@ -1374,6 +1465,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 +1527,99 @@ 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 recentPostCount = recentInteractions.filter((entry) => entry.type === "post").slice(0, 30).length;
+  const recentReplyCount = recentInteractions.filter((entry) => entry.type === "reply").slice(0, 30).length;
+  const postStarved = recentPostCount === 0 || recentReplyCount >= recentPostCount * 3 + 2;
+  const postFirstMode = !constraints.noOriginalPosts && !constraints.replyOnlyMode && (postStarved || heartbeatCount % 4 === 0);
+  const minPostsThisHeartbeat = postFirstMode ? 1 : 0;
+  if (postFirstMode) {
+    policyFeedback.push("Heartbeat objective: publish one original post first, then engage.");
+  }
+  const usedReplyTargets = /* @__PURE__ */ new Set();
+  const blockedReplyTargets = /* @__PURE__ */ new Set();
+  const writtenThisHeartbeat = [];
+  let blockedReplyStreak = 0;
+  let forcePostNextStep = false;
   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 makeForcedPostDecision = async (reason, contextTweets) => {
+    if (constraints.noOriginalPosts || constraints.replyOnlyMode || strictReplyHandles.size > 0) {
+      return null;
+    }
+    const forcedDraft = await composeHeartbeatPostDraft({
+      identityName: identity.name,
+      identityHandle: identity.handle,
+      tone: identity.tone,
+      goals: identity.goals ?? [],
+      boundaries: identity.boundaries ?? [],
+      contextTweets: contextTweets.slice(0, 8),
+      recentSamples: [...writtenThisHeartbeat, ...recentWrittenSamples].slice(0, 8)
+    });
+    if (!forcedDraft) return null;
+    return {
+      tool: "post",
+      args: { content: forcedDraft },
+      reasoning: reason
+    };
+  };
+  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);
+    });
+  };
+  const onBlockedReplyDecision = (reason, tweetId) => {
+    policyFeedback.push(reason);
+    logger.info(`Planner loop guard: ${reason}`);
+    if (tweetId) blockedReplyTargets.add(tweetId);
+    blockedReplyStreak += 1;
+    if (blockedReplyStreak >= 2) {
+      if (!constraints.noOriginalPosts && !constraints.replyOnlyMode && strictReplyHandles.size === 0) {
+        forcePostNextStep = true;
+        blockedReplyStreak = 0;
+        policyFeedback.push("Reply lane is saturated; forcing one original post next.");
+        logger.info("Planner loop guard: reply lane saturated, forcing post pivot.");
+        return false;
+      }
+      policyFeedback.push("Ending loop after repeated blocked reply targets this heartbeat.");
+      logger.info("Planner loop ended after repeated blocked reply targets.");
+      return true;
+    }
+    return false;
+  };
+  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 +1642,11 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       policyFeedback,
       toolHistory,
       recentMemory,
+      usedReplyTargets: [...usedReplyTargets],
+      recentReplyTargets: [...recentReplyTargets],
+      blockedReplyTargets: [...blockedReplyTargets],
+      recentWrittenSamples: [...writtenThisHeartbeat, ...recentWrittenSamples].slice(0, 8),
+      heartbeatDirective: postFirstMode && actions.length === 0 ? "Start with an original post this cycle." : void 0,
       heartbeatCount
     });
     let decision = fallbackPlannerDecision(step, candidates.length);
@@ -1471,6 +1661,35 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
     } catch (error) {
       policyFeedback.push(`Planner call failed: ${error.message}`);
     }
+    if (forcePostNextStep && decision.tool !== "post") {
+      const forced = await makeForcedPostDecision("reply-lane saturation pivot", candidates);
+      if (forced) {
+        decision = forced;
+        forcePostNextStep = false;
+        policyFeedback.push("Planner adjusted: switched to an original post after reply loop saturation.");
+      }
+    }
+    if (step === 0 && actions.length === 0 && postFirstMode && decision.tool !== "post") {
+      const forced = await makeForcedPostDecision("post-first heartbeat mode", candidates);
+      if (forced) {
+        decision = forced;
+        policyFeedback.push("Planner adjusted: posting first this heartbeat to keep timeline presence.");
+      }
+    }
+    if (decision.tool !== "post") {
+      const postsSoFar = actions.filter((a) => a.action === "post").length;
+      const repliesSoFar = actions.filter((a) => a.action === "reply").length;
+      const postsRemaining = Math.max(0, minPostsThisHeartbeat - postsSoFar);
+      const remainingSlots = actionBudget - actions.length;
+      const shouldShiftToPost = postsRemaining > 0 && (remainingSlots <= postsRemaining || postFirstMode && postsSoFar === 0 && repliesSoFar >= 1);
+      if (shouldShiftToPost) {
+        const forced = await makeForcedPostDecision("post-balance safeguard", candidates);
+        if (forced) {
+          decision = forced;
+          policyFeedback.push("Planner adjusted: balancing heartbeat mix with an original post.");
+        }
+      }
+    }
     logger.info(`Tool loop step ${step + 1}: ${decision.tool}`);
     let stepProgress = false;
     if (decision.tool === "observe_timeline") {
@@ -1488,7 +1707,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 +1725,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 +1753,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 +1784,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 +1799,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 +1810,71 @@ 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.`;
+        if (onBlockedReplyDecision(reason, candidateAction.tweetId)) break;
+        if (markNoProgress()) break;
+        continue;
+      }
+      if (usedReplyTargets.has(candidateAction.tweetId)) {
+        const reason = `Reply target ${candidateAction.tweetId} already used this heartbeat. Pick a different tweet.`;
+        if (onBlockedReplyDecision(reason, candidateAction.tweetId)) break;
+        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.`;
+        if (onBlockedReplyDecision(reason, candidateAction.tweetId)) break;
+        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,12 +1916,28 @@ 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);
+    blockedReplyStreak = 0;
     staleSteps = 0;
     stepProgress = true;
     toolHistory.push({
@@ -1667,6 +1965,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 +1974,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 +1991,4 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
 export {
   runAutonomyCycle
 };
-//# sourceMappingURL=chunk-TTDQZI5W.js.map
+//# sourceMappingURL=chunk-3S44SIUP.js.map