spora 0.7.5 → 0.7.7

package/dist/{chunk-HXI2EH5C.js → chunk-TTM54LQR.js}

@@ -6,8 +6,12 @@ import {
 } from "./chunk-ZLSDFYBR.js";
 import {
   buildOpportunityPortfolioMessage,
-  buildSystemPrompt
-} from "./chunk-A2XTKC7B.js";
+  buildPersonaConstraintLines,
+  buildSystemPrompt,
+  compilePersonaActionProfile,
+  getPersonaConstraints,
+  personaConstraintHandles
+} from "./chunk-JIMONWKO.js";
 import {
   listIntents,
   loadStrategy,
@@ -510,6 +514,12 @@ function isWritingAction(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);
 }
@@ -583,6 +593,44 @@ function evaluateActionPolicy(context) {
   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.` };
   }
@@ -736,8 +784,9 @@ function evaluateActionPolicy(context) {
     }
   }
   if (action.action === "reply" && action.tweetId) {
+    const inStrictTargetMode = strictReplyHandles.size > 0 || strictInteractHandles.size > 0;
     const repliesThisHeartbeat = executedActions.filter((a) => a.action === "reply").length;
-    if (repliesThisHeartbeat >= 2) {
+    if (repliesThisHeartbeat >= 2 && !inStrictTargetMode) {
       return {
         allowed: false,
         reason: "Reply cap reached for this heartbeat. Use another tool action."
@@ -748,7 +797,7 @@ function evaluateActionPolicy(context) {
       const repliedAuthors = new Set(
         executedActions.filter((a) => a.action === "reply" && a.tweetId).map((a) => normalizeHandle(tweetById.get(a.tweetId)?.authorHandle)).filter(Boolean)
       );
-      if (repliedAuthors.has(currentAuthor)) {
+      if (repliedAuthors.has(currentAuthor) && !inStrictTargetMode) {
         return {
           allowed: false,
           reason: `Already replied to @${currentAuthor} this heartbeat. Diversify interactions.`
@@ -973,6 +1022,9 @@ function shuffle(items) {
   }
   return arr;
 }
+function clampInt(value, min, max) {
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
 function buildTopicQueryVariants(topic) {
   const trimmed = topic.trim();
   if (!trimmed) return [];
@@ -1194,21 +1246,38 @@ async function runResearchPhase(client, heartbeatCount) {
 async function runTopicSearch(client, heartbeatCount, seedTweets) {
   try {
     const identity = loadIdentity();
+    const constraints = getPersonaConstraints(identity);
+    const strictHandles = personaConstraintHandles(constraints).filter(Boolean);
     const strategy = loadStrategy();
+    const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
     const selfHandle = canonicalAgentHandle(identity.handle);
+    const topicSearchBias = personaProfile.sourceBias.topic_search;
+    const peopleWatchBias = personaProfile.sourceBias.people_watch;
     const allTopics = [
+      ...personaProfile.priorityTopics,
       ...identity.topics ?? [],
       ...strategy.currentFocus
     ].flatMap(splitTopicSignal).filter(Boolean);
-    const discovered = discoverQueriesFromTweets(seedTweets, 3);
+    const discoveredBudget = clampInt(1 + Math.max(0, topicSearchBias), 1, 3);
+    const discovered = discoverQueriesFromTweets(seedTweets, discoveredBudget);
     const targetHandles = [.../* @__PURE__ */ new Set([
       ...strategy.peopleToEngage.filter((person) => person.priority === "high" || person.priority === "medium").map((person) => person.handle.replace(/^@/, "").toLowerCase()),
       ...(identity.heroes ?? []).map((handle) => handle.replace(/^@/, "").toLowerCase())
     ])].filter((handle) => handle && handle !== selfHandle);
-    const personQueries = buildTargetedPersonQueries(targetHandles, heartbeatCount, 2);
-    const topicQueries = allTopics.length > 0 ? pickTopicQueries(allTopics, Math.min(3, Math.max(2, allTopics.length))) : [];
-    const discoveredQueries = discovered.length > 0 ? pickDirectQueries(discovered, Math.min(2, discovered.length)) : [];
-    const topicsToSearch = [.../* @__PURE__ */ new Set([...topicQueries, ...discoveredQueries, ...personQueries])];
+    const strictQueries = buildTargetedPersonQueries(
+      strictHandles.filter((handle) => handle !== selfHandle),
+      heartbeatCount,
+      clampInt(2 + Math.max(0, topicSearchBias), 1, 4)
+    );
+    const personQueries = buildTargetedPersonQueries(
+      targetHandles,
+      heartbeatCount,
+      clampInt(1 + Math.max(0, peopleWatchBias), 0, 3)
+    );
+    const topicBudget = clampInt(3 + topicSearchBias, 1, 5);
+    const topicQueries = allTopics.length > 0 ? pickTopicQueries(allTopics, Math.min(topicBudget, Math.max(1, allTopics.length))) : [];
+    const discoveredQueries = discovered.length > 0 ? pickDirectQueries(discovered, Math.min(discoveredBudget, discovered.length)) : [];
+    const topicsToSearch = strictQueries.length > 0 ? [...new Set(strictQueries)] : [.../* @__PURE__ */ new Set([...topicQueries, ...discoveredQueries, ...personQueries])];
     if (topicsToSearch.length === 0) return [];
     const results = [];
     for (const topicQuery of topicsToSearch) {
@@ -1232,10 +1301,35 @@ async function runPeopleMonitoring(client, heartbeatCount, seedTweets) {
   try {
     const strategy = loadStrategy();
     const identity = loadIdentity();
+    const constraints = getPersonaConstraints(identity);
+    const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
+    const strictHandles = personaConstraintHandles(constraints).map((handle) => canonicalAgentHandle(handle)).filter((handle) => handle.length > 0);
     const selfHandle = identity.handle.replace(/^@/, "").toLowerCase();
     const relationships = loadRelationships();
     const networkHandles = listAgentNetworkHandles(20);
     const networkHandleSet = new Set(networkHandles);
+    if (strictHandles.length > 0) {
+      const strictResults = [];
+      for (const handle of strictHandles) {
+        if (handle === selfHandle) continue;
+        const userId = await resolveHandleToId(client, handle);
+        if (!userId) continue;
+        try {
+          const tweets = await client.getUserTweets(userId, { count: 8 });
+          if (tweets.length === 0) continue;
+          strictResults.push({
+            handle,
+            userId,
+            reason: "persona hard constraint",
+            tweets
+          });
+          upsertAgentHandle(handle, "observed", "people check (strict persona target)");
+          logger.info(`People check @${handle}: ${tweets.length} recent tweets (strict target mode)`);
+        } catch {
+        }
+      }
+      return strictResults;
+    }
     const people = [];
     const seen = /* @__PURE__ */ new Set();
     const highPriorityHandles = new Set(
@@ -1257,9 +1351,10 @@ async function runPeopleMonitoring(client, heartbeatCount, seedTweets) {
     for (const p of strategy.peopleToEngage.filter((p2) => p2.priority === "high")) {
       addPerson(p.handle, p.reason, true);
     }
+    const sporaPinInterval = personaProfile.sourceBias.people_watch >= 0.6 ? 4 : 8;
     for (const handle of networkHandles) {
       if (handle === "sporaai") {
-        const pinSpora = heartbeatCount % 4 === 0;
+        const pinSpora = heartbeatCount % sporaPinInterval === 0;
         addPerson(handle, "core Spora profile", pinSpora);
       } else {
         addPerson(handle, "spora agent network");
@@ -1284,7 +1379,8 @@ async function runPeopleMonitoring(client, heartbeatCount, seedTweets) {
       addPerson(handle, "active voice in current conversations");
     }
     if (people.length === 0) return [];
-    const budget = Math.min(3, people.length);
+    const monitoringBudget = clampInt(3 + personaProfile.sourceBias.people_watch, 2, 5);
+    const budget = Math.min(monitoringBudget, people.length);
     const selected = [];
     const selectedHandles = /* @__PURE__ */ new Set();
     const pinned = people.filter((person) => person.pinned);
@@ -1384,7 +1480,9 @@ function unique(values) {
 }
 function buildPersonaContext() {
   const identity = loadIdentity();
+  const constraints = getPersonaConstraints(identity);
   const strategy = loadStrategy();
+  const actionProfile = compilePersonaActionProfile({ identity, strategy, constraints });
   const focusKeywords = unique(
     [
       ...identity.topics,
@@ -1400,11 +1498,29 @@ function buildPersonaContext() {
   const priorityHandles = new Set(
     strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => normalizeHandle3(person.handle)).filter(Boolean)
   );
+  for (const handle of personaConstraintHandles(constraints)) {
+    priorityHandles.add(normalizeHandle3(handle));
+  }
   const heroHandles = new Set(
     (identity.heroes ?? []).map((handle) => normalizeHandle3(handle)).filter(Boolean)
   );
   const networkHandles = new Set(listAgentNetworkHandles(60).map((handle) => normalizeHandle3(handle)).filter(Boolean));
-  return { focusKeywords, avoidKeywords, priorityHandles, heroHandles, networkHandles };
+  return { focusKeywords, avoidKeywords, priorityHandles, heroHandles, networkHandles, actionProfile };
+}
+function personaActionDelta(actionType, source, profile) {
+  return profile.actionBias[actionType] * 0.9 + profile.sourceBias[source] * 0.55;
+}
+function isActionStronglySuppressed(actionType, profile) {
+  return profile.actionBias[actionType] <= -1.35;
+}
+function matchesPersonaGeneratedProfile(actionType, source, profile) {
+  const actionBias = profile.actionBias[actionType];
+  const sourceBias = profile.sourceBias[source];
+  const combined = personaActionDelta(actionType, source, profile);
+  if (actionBias <= -0.55) return false;
+  if (sourceBias <= -1.05) return false;
+  if (combined <= -0.3) return false;
+  return true;
 }
 function phraseMatchScore(text, keywords) {
   if (keywords.length === 0) return 0;
@@ -1505,7 +1621,11 @@ function buildActionOpportunities(input) {
   const maxCandidates = input.maxCandidates ?? 28;
   const selfHandle = normalizeHandle3(input.selfHandle);
   const selfUserId = (input.selfUserId ?? "").trim();
+  const constraints = getPersonaConstraints();
+  const onlyReplyHandles = new Set(constraints.onlyReplyToHandles.map((h) => normalizeHandle3(h)));
+  const onlyInteractHandles = new Set(constraints.onlyInteractWithHandles.map((h) => normalizeHandle3(h)));
   const persona = buildPersonaContext();
+  const actionProfile = persona.actionProfile;
   const recent = getRecentInteractions(300);
   const {
     repliedTweetIds,
@@ -1529,6 +1649,7 @@ function buildActionOpportunities(input) {
     const handle = normalizeHandle3(candidate.tweet.authorHandle);
     if (!candidate.tweet.id || !handle || handle === selfHandle) continue;
     if (selfUserId && candidate.tweet.authorId === selfUserId) continue;
+    if (onlyInteractHandles.size > 0 && !onlyInteractHandles.has(handle)) continue;
     const existing = dedupedByTweetId.get(candidate.tweet.id);
     if (!existing || sourceWeight(candidate.source) > sourceWeight(existing.source)) {
       dedupedByTweetId.set(candidate.tweet.id, candidate);
@@ -1552,27 +1673,33 @@ function buildActionOpportunities(input) {
       persona
     );
     const shortTweet = clip(tweet.text, 170);
-    opportunities.push({
-      id: nextId(),
-      armKey: armKey("reply", source),
-      actionType: "reply",
-      source,
-      score: baseScore + 0.7,
-      summary: `Reply to @${handle} from ${source}`,
-      authorHandle: handle,
-      tweetId: tweet.id,
-      requiresContent: true,
-      template: { action: "reply", tweetId: tweet.id, source, targetHandle: `@${handle}` },
-      context: `@${handle}: "${shortTweet}"`
-    });
+    const replyScore = baseScore + 0.7 + personaActionDelta("reply", source, actionProfile);
+    const likeScore = baseScore + 0.2 + personaActionDelta("like", source, actionProfile);
+    const retweetScore = baseScore - 0.1 + personaActionDelta("retweet", source, actionProfile);
+    const followScore = baseScore - 0.2 + personaActionDelta("follow", source, actionProfile);
+    if (!isActionStronglySuppressed("reply", actionProfile) && matchesPersonaGeneratedProfile("reply", source, actionProfile)) {
+      opportunities.push({
+        id: nextId(),
+        armKey: armKey("reply", source),
+        actionType: "reply",
+        source,
+        score: replyScore,
+        summary: `Reply to @${handle} from ${source}`,
+        authorHandle: handle,
+        tweetId: tweet.id,
+        requiresContent: true,
+        template: { action: "reply", tweetId: tweet.id, source, targetHandle: `@${handle}` },
+        context: `@${handle}: "${shortTweet}"`
+      });
+    }
     const stronglyRelevant = alignment >= 0.35 || source === "mention" || source === "people_watch" || persona.priorityHandles.has(handle);
-    if (!likedTweetIds.has(tweet.id) && baseScore >= 1.8 && stronglyRelevant) {
+    if (onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("like", actionProfile) && matchesPersonaGeneratedProfile("like", source, actionProfile) && !likedTweetIds.has(tweet.id) && likeScore >= 1.8 && stronglyRelevant) {
       opportunities.push({
         id: nextId(),
         armKey: armKey("like", source),
         actionType: "like",
         source,
-        score: baseScore + 0.2,
+        score: likeScore,
         summary: `Like @${handle} from ${source}`,
         authorHandle: handle,
         tweetId: tweet.id,
@@ -1581,13 +1708,13 @@ function buildActionOpportunities(input) {
         context: `@${handle}: "${shortTweet}"`
       });
     }
-    if (!retweetedTweetIds.has(tweet.id) && baseScore >= 2.6 && alignment >= 0.15) {
+    if (onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("retweet", actionProfile) && matchesPersonaGeneratedProfile("retweet", source, actionProfile) && !retweetedTweetIds.has(tweet.id) && retweetScore >= 2.6 && alignment >= 0.15) {
       opportunities.push({
         id: nextId(),
         armKey: armKey("retweet", source),
         actionType: "retweet",
         source,
-        score: baseScore - 0.1,
+        score: retweetScore,
         summary: `Retweet @${handle} from ${source}`,
         authorHandle: handle,
         tweetId: tweet.id,
@@ -1596,7 +1723,7 @@ function buildActionOpportunities(input) {
         context: `@${handle}: "${shortTweet}"`
       });
     }
-    const shouldConsiderFollow = !followedHandles.has(handle) && !followOpportunityByHandle.has(handle) && !isLikelySyntheticHandle2(handle) && baseScore >= 3 && (persona.priorityHandles.has(handle) || persona.heroHandles.has(handle) || source === "mention" || alignment >= 0.8);
+    const shouldConsiderFollow = onlyReplyHandles.size === 0 && !constraints.replyOnlyMode && !isActionStronglySuppressed("follow", actionProfile) && matchesPersonaGeneratedProfile("follow", source, actionProfile) && !followedHandles.has(handle) && !followOpportunityByHandle.has(handle) && !isLikelySyntheticHandle2(handle) && followScore >= 3 && (persona.priorityHandles.has(handle) || persona.heroHandles.has(handle) || source === "mention" || alignment >= 0.8);
     if (shouldConsiderFollow) {
       followOpportunityByHandle.add(handle);
       opportunities.push({
@@ -1604,7 +1731,7 @@ function buildActionOpportunities(input) {
         armKey: armKey("follow", source),
         actionType: "follow",
         source,
-        score: baseScore - 0.2,
+        score: followScore,
         summary: `Follow @${handle}`,
         authorHandle: handle,
         requiresContent: false,
@@ -1614,17 +1741,19 @@ function buildActionOpportunities(input) {
     }
   }
   const queryList = research.topicSearchResults.map((r) => r.query).filter(Boolean);
-  if (queryList.length > 0) {
+  if (queryList.length > 0 && !constraints.noOriginalPosts && !constraints.replyOnlyMode && !isActionStronglySuppressed("post", actionProfile) && matchesPersonaGeneratedProfile("post", "synthesis", actionProfile) && onlyInteractHandles.size === 0 && onlyReplyHandles.size === 0) {
+    const synthesisScore = 2.25 + personaActionDelta("post", "synthesis", actionProfile);
+    const priorityTopicHint = actionProfile.priorityTopics.slice(0, 3).join(", ");
     opportunities.push({
       id: nextId(),
       armKey: armKey("post", "synthesis"),
       actionType: "post",
       source: "synthesis",
-      score: 2.25,
+      score: synthesisScore,
       summary: "Post an original thought synthesized from active conversations",
       requiresContent: true,
       template: { action: "post", source: "synthesis" },
-      context: `Weave a fresh take from active topics: ${queryList.slice(0, 4).join(", ")}`
+      context: `Weave a fresh take from active topics: ${queryList.slice(0, 4).join(", ")}${priorityTopicHint ? `. Persona-priority topics: ${priorityTopicHint}` : ""}`
     });
   }
   opportunities.sort((a, b) => b.score - a.score);
@@ -1697,6 +1826,202 @@ async function planActionPortfolio(input) {
   return actions;
 }
 
+// src/runtime/mission-director.ts
+function normalizeHandle4(handle) {
+  return handle.replace(/^@/, "").trim().toLowerCase();
+}
+function unique2(values) {
+  return [...new Set(values)];
+}
+function isAction(value) {
+  return ["reply", "like", "retweet", "follow", "post"].includes(value);
+}
+function sanitizeActions(raw, fallback) {
+  if (!Array.isArray(raw) || raw.length === 0) return fallback;
+  const cleaned = raw.map((item) => String(item).trim().toLowerCase()).filter((item) => isAction(item));
+  return cleaned.length > 0 ? unique2(cleaned) : fallback;
+}
+function parseJsonObject(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1];
+  const candidates = [fenced, text].filter((v) => Boolean(v)).map((v) => v.trim());
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+    const obj = candidate.match(/\{[\s\S]*\}/);
+    if (!obj) continue;
+    try {
+      return JSON.parse(obj[0]);
+    } catch {
+    }
+  }
+  return null;
+}
+function buildPersonaAllowedActions(profile, noOriginalPosts) {
+  const byBias = profile.prioritizedActions.filter((action) => profile.actionBias[action] > -1.1);
+  const withFallback = byBias.length > 0 ? byBias : ["reply", "like", "retweet", "follow", "post"];
+  const filtered = noOriginalPosts ? withFallback.filter((action) => action !== "post") : withFallback;
+  return unique2(filtered).slice(0, 5);
+}
+function buildDeterministicMission(research, profile) {
+  const identity = loadIdentity();
+  const strategy = loadStrategy();
+  const constraints = getPersonaConstraints(identity);
+  const constraintTargets = personaConstraintHandles(constraints).map(normalizeHandle4).filter(Boolean);
+  const focusTopics = unique2(
+    [
+      ...profile.priorityTopics,
+      ...identity.topics ?? [],
+      ...strategy.currentFocus,
+      ...strategy.shortTermGoals
+    ].map((topic) => String(topic).trim()).filter(Boolean).slice(0, 10)
+  );
+  const strictReply = constraints.onlyReplyToHandles.length > 0 || constraints.replyOnlyMode;
+  if (strictReply) {
+    const strictTargets = constraints.onlyReplyToHandles.length > 0 ? constraints.onlyReplyToHandles.map(normalizeHandle4) : constraintTargets;
+    return {
+      mode: "strict_target_reply",
+      objective: strictTargets.length > 0 ? `Reply only to @${strictTargets.join(", @")} while staying fully in character.` : "Reply-only mode. Stay in character and do not perform non-reply actions.",
+      allowedActions: ["reply"],
+      targetHandles: strictTargets,
+      focusTopics,
+      rationale: "Hard persona constraint detected in identity goals/boundaries/bio."
+    };
+  }
+  if (constraintTargets.length > 0) {
+    return {
+      mode: "strict_target_interaction",
+      objective: `Interact only with @${constraintTargets.join(", @")} in persona voice.`,
+      allowedActions: constraints.noOriginalPosts ? ["reply", "like", "retweet", "follow"] : ["reply", "like", "retweet", "follow", "post"],
+      targetHandles: constraintTargets,
+      focusTopics,
+      rationale: "Hard persona interaction target detected."
+    };
+  }
+  const preferredActions = buildPersonaAllowedActions(profile, constraints.noOriginalPosts);
+  const primaryActionHint = preferredActions.length > 0 ? preferredActions.slice(0, 2).join(" + ") : "context-aware interactions";
+  return {
+    mode: "persona_balanced",
+    objective: `Advance ${identity.name}'s mission through ${primaryActionHint} while staying in strict persona voice.`,
+    allowedActions: preferredActions,
+    targetHandles: [],
+    focusTopics,
+    rationale: `No strict target lock; persona profile drives soft action/source priorities (${profile.rationale.slice(0, 2).join("; ")}).`
+  };
+}
+function buildMissionPrompt(research, fallback, profile) {
+  const identity = loadIdentity();
+  const constraints = getPersonaConstraints(identity);
+  const topTimeline = research.timeline.slice(0, 5);
+  const topMentions = research.mentions.slice(0, 5);
+  const topicQueries = research.topicSearchResults.map((r) => r.query).filter(Boolean).slice(0, 6);
+  const people = research.peopleActivity.map((p) => p.handle).filter(Boolean).slice(0, 6);
+  const lines = [];
+  lines.push("Create one heartbeat mission JSON for this agent.");
+  lines.push("Hard rule: Persona constraints override everything.");
+  lines.push("");
+  lines.push(`Agent: ${identity.name} (@${identity.handle})`);
+  lines.push(`Bio: ${identity.bio}`);
+  lines.push(`Tone: ${identity.tone}`);
+  lines.push(`Goals: ${(identity.goals ?? []).join(" | ")}`);
+  lines.push(`Boundaries: ${(identity.boundaries ?? []).join(" | ")}`);
+  lines.push(`Framework: ${identity.framework}`);
+  lines.push(`Existing strict constraints: ${JSON.stringify(constraints)}`);
+  lines.push(`Persona action priors: ${JSON.stringify({
+    prioritizedActions: profile.prioritizedActions.slice(0, 5),
+    priorityTopics: profile.priorityTopics.slice(0, 8),
+    actionBias: profile.actionBias,
+    sourceBias: profile.sourceBias,
+    rationale: profile.rationale.slice(0, 5)
+  })}`);
+  lines.push("");
+  lines.push(`Fallback mission if unsure: ${JSON.stringify(fallback)}`);
+  lines.push("");
+  lines.push(`Observed timeline sample (${topTimeline.length}):`);
+  for (const tweet of topTimeline) {
+    lines.push(`- @${tweet.authorHandle}: ${tweet.text.slice(0, 180)}`);
+  }
+  lines.push(`Observed mentions sample (${topMentions.length}):`);
+  for (const tweet of topMentions) {
+    lines.push(`- @${tweet.authorHandle}: ${tweet.text.slice(0, 180)}`);
+  }
+  lines.push(`Topic queries: ${topicQueries.join(" | ") || "none"}`);
+  lines.push(`People watched: ${people.map((h) => `@${h}`).join(", ") || "none"}`);
+  lines.push("");
+  lines.push("Return JSON only with this shape:");
+  lines.push("{");
+  lines.push('  "mode": "strict_target_reply|strict_target_interaction|persona_balanced",');
+  lines.push('  "objective": "one-sentence mission",');
+  lines.push('  "allowedActions": ["reply","like","retweet","follow","post"],');
+  lines.push('  "targetHandles": ["grok"],');
+  lines.push('  "focusTopics": ["topic a","topic b"],');
+  lines.push('  "rationale": "short why"');
+  lines.push("}");
+  return lines.join("\n");
+}
+function mergeMission(fallback, parsed) {
+  if (!parsed) return fallback;
+  const mode = parsed.mode === "strict_target_reply" || parsed.mode === "strict_target_interaction" || parsed.mode === "persona_balanced" ? parsed.mode : fallback.mode;
+  const objective = typeof parsed.objective === "string" && parsed.objective.trim().length > 0 ? parsed.objective.trim() : fallback.objective;
+  const rationale = typeof parsed.rationale === "string" && parsed.rationale.trim().length > 0 ? parsed.rationale.trim() : fallback.rationale;
+  const focusTopics = Array.isArray(parsed.focusTopics) ? unique2(
+    parsed.focusTopics.map((topic) => String(topic).trim()).filter(Boolean).slice(0, 10)
+  ) : fallback.focusTopics;
+  const targetHandles = Array.isArray(parsed.targetHandles) ? unique2(
+    parsed.targetHandles.map((handle) => normalizeHandle4(String(handle))).filter(Boolean)
+  ) : fallback.targetHandles;
+  let allowedActions = sanitizeActions(parsed.allowedActions, fallback.allowedActions);
+  const mustReplyOnly = mode === "strict_target_reply";
+  if (mustReplyOnly) {
+    allowedActions = ["reply"];
+  }
+  const hasStrictTargets = fallback.targetHandles.length > 0;
+  if (hasStrictTargets) {
+    return {
+      ...fallback,
+      mode: mustReplyOnly ? "strict_target_reply" : mode,
+      objective,
+      rationale,
+      focusTopics,
+      allowedActions,
+      targetHandles: fallback.targetHandles
+    };
+  }
+  return {
+    mode,
+    objective,
+    rationale,
+    focusTopics,
+    allowedActions,
+    targetHandles
+  };
+}
+async function createHeartbeatMission(research) {
+  const identity = loadIdentity();
+  const strategy = loadStrategy();
+  const constraints = getPersonaConstraints(identity);
+  const profile = compilePersonaActionProfile({ identity, strategy, constraints });
+  const fallback = buildDeterministicMission(research, profile);
+  if (fallback.mode !== "persona_balanced") {
+    return fallback;
+  }
+  const system = [
+    "You are a mission director for an autonomous X agent.",
+    "Your output must be strict JSON only.",
+    "Prioritize persona fidelity over engagement.",
+    "Never violate explicit persona constraints."
+  ].join(" ");
+  try {
+    const prompt = buildMissionPrompt(research, fallback, profile);
+    const response = await generateResponse(system, prompt);
+    const parsed = parseJsonObject(response.content);
+    return mergeMission(fallback, parsed);
+  } catch {
+    return fallback;
+  }
+}
+
 // src/runtime/bandit.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 var DEFAULT_EXPLORATION_BUDGET = 0.25;
@@ -1941,7 +2266,7 @@ function selfUserIdFromCredentials() {
     return null;
   }
 }
-function normalizeHandle4(handle) {
+function normalizeHandle5(handle) {
   return (handle ?? "").replace(/^@/, "").trim().toLowerCase();
 }
 function roughWordCount(text) {
@@ -2011,6 +2336,64 @@ function shouldAttemptStyleRewrite(action, reason) {
   const lower = reason.toLowerCase();
   return lower.includes("lecture-like") || lower.includes("abstract philosopher cadence") || lower.includes("manifesto") || lower.includes("too long/explanatory") || lower.includes("grounded in the target tweet context") || lower.includes("hedged consensus phrasing") || lower.includes("repetitive anchor phrase/term") || lower.includes("repetitive opening phrase") || lower.includes("low-novelty vocabulary loop") || lower.includes("abstract wording without concrete anchor");
 }
+function personaAdjustedOpportunityScore(opportunity, profile) {
+  const actionType = opportunity.actionType;
+  const source = opportunity.source;
+  const actionBias = profile.actionBias[actionType] ?? 0;
+  const sourceBias = profile.sourceBias[source] ?? 0;
+  return opportunity.score + actionBias * 0.9 + sourceBias * 0.55;
+}
+function buildPersonaGeneratedPool(opportunities, maxSize, profile) {
+  if (opportunities.length <= 1) return opportunities.slice(0, maxSize);
+  const maxPool = Math.max(1, Math.min(maxSize, opportunities.length));
+  const byAction = /* @__PURE__ */ new Map();
+  for (const action of ["reply", "like", "retweet", "follow", "post"]) {
+    byAction.set(action, []);
+  }
+  for (const opportunity of opportunities) {
+    const action = opportunity.actionType;
+    byAction.get(action)?.push(opportunity);
+  }
+  for (const [action, rows] of byAction.entries()) {
+    rows.sort((a, b) => personaAdjustedOpportunityScore(b, profile) - personaAdjustedOpportunityScore(a, profile));
+    byAction.set(action, rows);
+  }
+  const actionOrder = profile.prioritizedActions.filter((action) => (byAction.get(action)?.length ?? 0) > 0);
+  const weightedActions = actionOrder.map((action) => ({
+    action,
+    weight: Math.max(0.2, profile.actionBias[action] + 1.25)
+  })).filter((row) => row.weight > 0);
+  const selected = /* @__PURE__ */ new Map();
+  if (weightedActions.length > 0) {
+    const totalWeight = weightedActions.reduce((sum, row) => sum + row.weight, 0);
+    const quotas = /* @__PURE__ */ new Map();
+    for (const row of weightedActions) {
+      quotas.set(row.action, Math.max(0, Math.floor(row.weight / totalWeight * maxPool)));
+    }
+    for (const topAction of actionOrder.slice(0, 2)) {
+      const rows = byAction.get(topAction) ?? [];
+      if (rows.length === 0) continue;
+      quotas.set(topAction, Math.max(1, quotas.get(topAction) ?? 0));
+    }
+    for (const row of weightedActions) {
+      const rows = byAction.get(row.action) ?? [];
+      const limit = quotas.get(row.action) ?? 0;
+      for (const candidate of rows.slice(0, limit)) {
+        if (selected.size >= maxPool) break;
+        selected.set(candidate.id, candidate);
+      }
+      if (selected.size >= maxPool) break;
+    }
+  }
+  const globalSorted = [...opportunities].sort(
+    (a, b) => personaAdjustedOpportunityScore(b, profile) - personaAdjustedOpportunityScore(a, profile)
+  );
+  for (const candidate of globalSorted) {
+    if (selected.size >= maxPool) break;
+    selected.set(candidate.id, candidate);
+  }
+  return [...selected.values()].slice(0, maxPool);
+}
 function cleanRewriteOutput(text) {
   const cleaned = text.replace(/```[\s\S]*?```/g, "").replace(/^["'`]+|["'`]+$/g, "").trim();
   const firstLine = cleaned.split("\n").map((line) => line.trim()).filter(Boolean)[0] ?? cleaned;
@@ -2062,6 +2445,19 @@ async function rewriteDraftForHumanVoice(input) {
 }
 async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
   const client = await getXClient();
+  const identity = loadIdentity();
+  const strategy = loadStrategy();
+  const constraints = getPersonaConstraints();
+  const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
+  const strictReplyOnly = constraints.replyOnlyMode || constraints.onlyReplyToHandles.length > 0;
+  const interactionActions = /* @__PURE__ */ new Set(["reply", "like", "retweet", "follow"]);
+  const constraintLines = buildPersonaConstraintLines(constraints);
+  if (constraintLines.length > 0) {
+    logger.info(`Persona constraints active: ${constraintLines.join(" | ")}`);
+  }
+  logger.info(
+    `Persona action profile: actions=${personaProfile.prioritizedActions.slice(0, 4).join(" > ")}, sources=${Object.entries(personaProfile.sourceBias).sort((a, b) => b[1] - a[1]).map(([source]) => source).slice(0, 3).join(" > ")}`
+  );
   try {
     const delayed = await collectDelayedOutcomes(client);
     if (delayed.processed > 0) {
@@ -2072,7 +2468,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
   } catch (error) {
     logger.warn(`Delayed outcome collection failed: ${error.message}`);
   }
-  const selfHandle = loadIdentity().handle.replace(/^@/, "").toLowerCase();
+  const selfHandle = identity.handle.replace(/^@/, "").toLowerCase();
   const selfUserId = selfUserIdFromCredentials();
   const isSelfTweet = (tweet) => tweet.authorHandle.replace(/^@/, "").toLowerCase() === selfHandle || selfUserId !== null && tweet.authorId === selfUserId;
   const research = await runResearchPhase(client, heartbeatCount);
@@ -2101,15 +2497,39 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
     ...filteredTopicSearchResults.flatMap((result) => result.tweets),
     ...filteredPeopleActivity.flatMap((person) => person.tweets)
   ];
+  const mission = await createHeartbeatMission({
+    ...research,
+    timeline: filteredTimeline,
+    mentions: filteredMentions,
+    topicSearchResults: filteredTopicSearchResults,
+    peopleActivity: filteredPeopleActivity
+  });
+  logger.info(
+    `Mission: mode=${mission.mode}, objective="${mission.objective}", allowed=${mission.allowedActions.join(",")}, targets=${mission.targetHandles.length > 0 ? mission.targetHandles.map((h) => `@${h}`).join(",") : "none"}`
+  );
   logger.info(
     `Autonomy context: timeline=${filteredTimeline.length}, mentions=${filteredMentions.length}, topicTweets=${filteredTopicSearchResults.reduce((sum, r) => sum + r.tweets.length, 0)}, peopleTweets=${filteredPeopleActivity.reduce((sum, p) => sum + p.tweets.length, 0)}`
   );
   const systemPrompt = buildSystemPrompt();
   const actions = [];
   const results = [];
-  const policyFeedback = [];
+  const policyFeedback = [
+    `Heartbeat mission: ${mission.objective}`,
+    `Mission mode: ${mission.mode}`
+  ];
   const blockedTweetIds = new Set(recentReplyTargetIds);
-  const disallowedActions = /* @__PURE__ */ new Set();
+  const allowedActionSet = new Set(mission.allowedActions);
+  const disallowedActions = new Set(
+    ["reply", "like", "retweet", "follow", "post"].filter((action) => !allowedActionSet.has(action))
+  );
+  if (mission.targetHandles.length > 0) {
+    policyFeedback.push(`Mission targets: ${mission.targetHandles.map((handle) => `@${handle}`).join(", ")}`);
+  }
+  if (mission.focusTopics.length > 0) {
+    policyFeedback.push(`Mission focus: ${mission.focusTopics.slice(0, 5).join(", ")}`);
+  }
+  policyFeedback.push(`Mission rationale: ${mission.rationale}`);
+  const missionTargetSet = new Set(mission.targetHandles.map((handle) => normalizeHandle5(handle)).filter(Boolean));
   let replyRejectionCount = 0;
   const opportunities = buildActionOpportunities({
     research: {
@@ -2123,27 +2543,28 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
     selfUserId,
     maxCandidates: 30
   });
-  const planningPool = selectBanditOpportunityPool(opportunities, 24);
+  const personaSeedPool = buildPersonaGeneratedPool(opportunities, 30, personaProfile);
+  const banditPool = selectBanditOpportunityPool(personaSeedPool, 24);
+  const planningPool = buildPersonaGeneratedPool(banditPool, 24, personaProfile);
   const byType = planningPool.reduce((acc, opportunity) => {
     acc[opportunity.actionType] = (acc[opportunity.actionType] ?? 0) + 1;
     return acc;
   }, {});
   logger.info(`Opportunities selected: total=${planningPool.length}, byType=${JSON.stringify(byType)}`);
-  const strategy = loadStrategy();
   const activeIntents = listIntents();
   const intentTargetHandles = new Set(
-    activeIntents.flatMap((intent) => intent.targetHandles.map((handle) => normalizeHandle4(handle)))
+    activeIntents.flatMap((intent) => intent.targetHandles.map((handle) => normalizeHandle5(handle)))
   );
   const priorityHandles = /* @__PURE__ */ new Set(
     [
-      ...strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => normalizeHandle4(person.handle)).filter(Boolean),
+      ...strategy.peopleToEngage.filter((person) => person.priority === "high").map((person) => normalizeHandle5(person.handle)).filter(Boolean),
       ...intentTargetHandles
     ]
   );
   const authorByTweetId = /* @__PURE__ */ new Map();
   for (const opportunity of planningPool) {
     if (opportunity.tweetId && opportunity.authorHandle) {
-      authorByTweetId.set(opportunity.tweetId, normalizeHandle4(opportunity.authorHandle));
+      authorByTweetId.set(opportunity.tweetId, normalizeHandle5(opportunity.authorHandle));
     }
   }
   getRecentInteractions(20);
@@ -2151,6 +2572,10 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
     return planningPool.filter((opportunity) => {
       if (disallowedActions.has(opportunity.actionType)) return false;
       if (opportunity.tweetId && blockedTweetIds.has(opportunity.tweetId)) return false;
+      if (missionTargetSet.size > 0 && interactionActions.has(opportunity.actionType)) {
+        const author = normalizeHandle5(opportunity.authorHandle);
+        if (!author || !missionTargetSet.has(author)) return false;
+      }
       return true;
     });
   };
@@ -2167,7 +2592,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       policyFeedback,
       executedActions: actions
     });
-    if (plannedActions.length > 1 && plannedActions.every((a) => a.action === "reply")) {
+    if (!strictReplyOnly && plannedActions.length > 1 && plannedActions.every((a) => a.action === "reply")) {
       const nonReplyCandidate = candidates.find(
         (opportunity) => opportunity.actionType !== "reply" && !opportunity.requiresContent
       );
@@ -2182,18 +2607,18 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       const authorByTweetId2 = /* @__PURE__ */ new Map();
       for (const opportunity of candidates) {
         if (opportunity.tweetId && opportunity.authorHandle) {
-          authorByTweetId2.set(opportunity.tweetId, normalizeHandle4(opportunity.authorHandle));
+          authorByTweetId2.set(opportunity.tweetId, normalizeHandle5(opportunity.authorHandle));
         }
       }
       const touchesPriorityTarget = plannedActions.some((action) => {
-        if (action.handle && priorityHandles.has(normalizeHandle4(action.handle))) return true;
-        if (action.targetHandle && priorityHandles.has(normalizeHandle4(action.targetHandle))) return true;
+        if (action.handle && priorityHandles.has(normalizeHandle5(action.handle))) return true;
+        if (action.targetHandle && priorityHandles.has(normalizeHandle5(action.targetHandle))) return true;
         if (action.tweetId && priorityHandles.has(authorByTweetId2.get(action.tweetId) ?? "")) return true;
         return false;
       });
       if (!touchesPriorityTarget) {
         const priorityCandidate = candidates.find(
-          (opportunity) => Boolean(opportunity.authorHandle) && priorityHandles.has(normalizeHandle4(opportunity.authorHandle)) && !opportunity.requiresContent
+          (opportunity) => Boolean(opportunity.authorHandle) && priorityHandles.has(normalizeHandle5(opportunity.authorHandle)) && (!strictReplyOnly ? !opportunity.requiresContent : opportunity.actionType === "reply")
         );
         if (priorityCandidate) {
           plannedActions = [
@@ -2271,7 +2696,7 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
         }
         if (candidateAction.action === "reply") {
           replyRejectionCount += 1;
-          if (replyRejectionCount >= 2) {
+          if (replyRejectionCount >= 2 && !strictReplyOnly) {
             disallowedActions.add("reply");
             const pivot = "Reply opportunities exhausted this heartbeat. Pivot to like/retweet/follow/post.";
             policyFeedback.push(pivot);
@@ -2285,12 +2710,12 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
       actions.push(candidateAction);
       results.push(result);
       if (activeIntents.length > 0) {
-        const touchedHandle = normalizeHandle4(
+        const touchedHandle = normalizeHandle5(
           candidateAction.targetHandle ?? candidateAction.handle ?? (candidateAction.tweetId ? authorByTweetId.get(candidateAction.tweetId) : void 0)
         );
         const loweredContent = (candidateAction.content ?? "").toLowerCase();
         for (const intent of activeIntents) {
-          const handleMatch = touchedHandle.length > 0 && intent.targetHandles.some((handle) => normalizeHandle4(handle) === touchedHandle);
+          const handleMatch = touchedHandle.length > 0 && intent.targetHandles.some((handle) => normalizeHandle5(handle) === touchedHandle);
           const topicMatch = loweredContent.length > 0 && intent.focusTopics.some((topic) => loweredContent.includes(topic.toLowerCase()));
           if (!handleMatch && !topicMatch) continue;
           recordIntentExecution(intent.id, {
@@ -2305,10 +2730,16 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
           blockedTweetIds.add(candidateAction.tweetId);
         }
         if (candidateAction.action === "reply" && /duplicate content/i.test(err)) {
-          disallowedActions.add("reply");
-          const reason = "Reply failed with duplicate-content error. Switch to non-reply actions.";
-          policyFeedback.push(reason);
-          logger.info(`Policy adjustment: ${reason}`);
+          if (!strictReplyOnly) {
+            disallowedActions.add("reply");
+            const reason = "Reply failed with duplicate-content error. Switch to non-reply actions.";
+            policyFeedback.push(reason);
+            logger.info(`Policy adjustment: ${reason}`);
+          } else {
+            const reason = "Reply failed with duplicate-content error. Keep reply mode but use a new angle/target.";
+            policyFeedback.push(reason);
+            logger.info(`Policy adjustment: ${reason}`);
+          }
         }
         if ((candidateAction.action === "post" || candidateAction.action === "schedule") && /duplicate content/i.test(err)) {
           const reason = "Write-path duplicate-content failure. Change framing and try a different angle.";
@@ -2335,4 +2766,4 @@ async function runAutonomyCycle(maxActions, heartbeatCount = 0) {
 export {
   runAutonomyCycle
 };
-//# sourceMappingURL=chunk-HXI2EH5C.js.map
+//# sourceMappingURL=chunk-TTM54LQR.js.map