spora 0.7.5 → 0.7.7

package/dist/{autonomy-DFPA3OK6.js → autonomy-NNFTM5NW.js}

@@ -1,9 +1,9 @@
 import {
   runAutonomyCycle
-} from "./chunk-HXI2EH5C.js";
+} from "./chunk-TTM54LQR.js";
 import "./chunk-5R4AJZHN.js";
 import "./chunk-ZLSDFYBR.js";
-import "./chunk-A2XTKC7B.js";
+import "./chunk-JIMONWKO.js";
 import "./chunk-OTZNHIXT.js";
 import "./chunk-CAWWG3MD.js";
 import "./chunk-CP6JWCLY.js";
@@ -17,4 +17,4 @@ import "./chunk-ZWKTKWS6.js";
 export {
   runAutonomyCycle
 };
-//# sourceMappingURL=autonomy-DFPA3OK6.js.map
+//# sourceMappingURL=autonomy-NNFTM5NW.js.map

package/dist/{chunk-A2XTKC7B.js → chunk-JIMONWKO.js}

@@ -23,6 +23,446 @@ import {
   loadRelationships
 } from "./chunk-BBXHECZ5.js";
 
+// src/runtime/persona-constraints.ts
+function normalizeHandle(handle) {
+  return handle.replace(/^@/, "").trim().toLowerCase();
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function extractHandles(text) {
+  const fromMentions = [...text.matchAll(/@([a-zA-Z0-9_]{1,15})/g)].map((m) => m[1]);
+  const fromUrls = [...text.matchAll(/x\.com\/([a-zA-Z0-9_]{1,15})/gi)].map((m) => m[1]);
+  return unique(
+    [...fromMentions, ...fromUrls].map(normalizeHandle).filter((handle) => handle.length > 0)
+  );
+}
+var BARE_HANDLE_STOPWORDS = /* @__PURE__ */ new Set([
+  "him",
+  "her",
+  "them",
+  "someone",
+  "anyone",
+  "everyone",
+  "anybody",
+  "everybody",
+  "people",
+  "person",
+  "users",
+  "user",
+  "others",
+  "other",
+  "my",
+  "me",
+  "you",
+  "to",
+  "with",
+  "for",
+  "only",
+  "just",
+  "reply",
+  "respond",
+  "interact",
+  "engage"
+]);
+var NAME_TO_HANDLE = [
+  [/\bgrok\b/i, "grok"],
+  [/\belon musk\b/i, "elonmusk"],
+  [/\belon\b/i, "elonmusk"],
+  [/\bmark zuckerberg\b/i, "zuck"],
+  [/\bzuck\b/i, "zuck"],
+  [/\bspora\s*ai\b/i, "sporaai"],
+  [/\bsporaai\b/i, "sporaai"]
+];
+function extractBareConstraintTargets(text) {
+  const found = /* @__PURE__ */ new Set();
+  const candidates = [
+    ...text.matchAll(/\bonly\s+(?:reply|respond|interact|engage|talk|speak)(?:\s+\w+){0,3}\s+(?:to|with)\s+@?([a-zA-Z0-9_]{2,15})\b/gi),
+    ...text.matchAll(/\b(?:reply|respond|interact|engage|talk|speak)\s+only(?:\s+\w+){0,3}\s+(?:to|with)\s+@?([a-zA-Z0-9_]{2,15})\b/gi)
+  ];
+  for (const match of candidates) {
+    const raw = String(match[1] ?? "").replace(/'s$/i, "");
+    const handle = normalizeHandle(raw);
+    if (!handle) continue;
+    if (!/^[a-z0-9_]{2,15}$/.test(handle)) continue;
+    if (BARE_HANDLE_STOPWORDS.has(handle)) continue;
+    found.add(handle);
+  }
+  for (const [pattern, handle] of NAME_TO_HANDLE) {
+    if (pattern.test(text)) found.add(handle);
+  }
+  return [...found];
+}
+function includesOnlyQualifier(text) {
+  return /\b(only|just|exclusively|strictly)\b/i.test(text);
+}
+function includesReplyIntent(text) {
+  return /\b(reply|respond|response|replying)\b/i.test(text);
+}
+function includesInteractionIntent(text) {
+  return /\b(interact|engage|talk|chat|speak|communicate|message)\b/i.test(text);
+}
+function impliesNoOriginalPosts(text) {
+  const lower = text.toLowerCase();
+  if (/\bonly\s+repl(?:y|ies)\b/.test(lower)) return true;
+  if (/\brepl(?:y|ies)\s+only\b/.test(lower)) return true;
+  if (/\breply-?only\b/.test(lower)) return true;
+  if (/\b(no|never|don['’]?t|dont|avoid)\s+(?:do\s+)?(?:original\s+)?posts?\b/.test(lower)) return true;
+  if (/\bno\s+tweets?\b/.test(lower)) return true;
+  return false;
+}
+function getPersonaConstraints(identityArg) {
+  const identity = identityArg ?? loadIdentity();
+  const strictReplyHandles = /* @__PURE__ */ new Set();
+  const strictInteractionHandles = /* @__PURE__ */ new Set();
+  const lines = [
+    ...identity.goals ?? [],
+    ...identity.boundaries ?? [],
+    identity.bio ?? "",
+    identity.originStory ?? "",
+    identity.worldview ?? "",
+    identity.tone ?? ""
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  let replyOnlyMode = false;
+  let noOriginalPosts = false;
+  for (const line of lines) {
+    const handles = unique([
+      ...extractHandles(line),
+      ...extractBareConstraintTargets(line)
+    ]);
+    const hasOnly = includesOnlyQualifier(line);
+    const hasReply = includesReplyIntent(line);
+    const hasInteract = includesInteractionIntent(line);
+    if (impliesNoOriginalPosts(line)) {
+      replyOnlyMode = true;
+      noOriginalPosts = true;
+    }
+    if (hasOnly && hasReply) {
+      replyOnlyMode = true;
+      noOriginalPosts = true;
+      for (const handle of handles) {
+        strictReplyHandles.add(handle);
+        strictInteractionHandles.add(handle);
+      }
+      continue;
+    }
+    if (hasOnly && hasInteract) {
+      noOriginalPosts = true;
+      for (const handle of handles) {
+        strictInteractionHandles.add(handle);
+      }
+    }
+  }
+  if (strictReplyHandles.size > 0) {
+    replyOnlyMode = true;
+    noOriginalPosts = true;
+  }
+  if (strictInteractionHandles.size > 0) {
+    noOriginalPosts = true;
+  }
+  return {
+    onlyReplyToHandles: [...strictReplyHandles],
+    onlyInteractWithHandles: [...strictInteractionHandles],
+    noOriginalPosts,
+    replyOnlyMode
+  };
+}
+function personaConstraintHandles(constraints) {
+  return unique([
+    ...constraints.onlyReplyToHandles.map(normalizeHandle),
+    ...constraints.onlyInteractWithHandles.map(normalizeHandle)
+  ]).filter(Boolean);
+}
+function buildPersonaConstraintLines(constraints) {
+  const lines = [];
+  if (constraints.onlyReplyToHandles.length > 0) {
+    lines.push(`- Hard constraint: only reply to @${constraints.onlyReplyToHandles.join(", @")}`);
+  } else if (constraints.replyOnlyMode) {
+    lines.push("- Hard constraint: reply-only mode (no like/retweet/follow/post actions).");
+  }
+  const onlyInteract = constraints.onlyInteractWithHandles.filter(
+    (handle) => !constraints.onlyReplyToHandles.includes(handle)
+  );
+  if (onlyInteract.length > 0) {
+    lines.push(`- Hard constraint: only interact with @${onlyInteract.join(", @")}`);
+  }
+  if (constraints.noOriginalPosts) {
+    lines.push("- Hard constraint: do not create standalone original posts.");
+  }
+  return lines;
+}
+
+// src/runtime/persona-action-profile.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function unique2(values) {
+  return [...new Set(values)];
+}
+function normalizeText(text) {
+  return text.toLowerCase().trim();
+}
+function hasAny(text, terms) {
+  const lower = normalizeText(text);
+  return terms.some((term) => lower.includes(term));
+}
+function applyGoalBias(actionBias, sourceBias, goals, rationale) {
+  for (const goal of goals) {
+    if (hasAny(goal, ["grow followers", "go viral", "audience", "reach"])) {
+      actionBias.reply += 0.35;
+      actionBias.post += 0.45;
+      sourceBias.mention += 0.2;
+      rationale.push("growth goals favor reply+post mix");
+    }
+    if (hasAny(goal, ["build community", "community", "connect", "relationships"])) {
+      actionBias.reply += 0.4;
+      actionBias.like += 0.3;
+      actionBias.follow += 0.45;
+      sourceBias.people_watch += 0.35;
+      rationale.push("community goals favor social interaction actions");
+    }
+    if (hasAny(goal, ["debate", "challenge", "argue", "provoc"])) {
+      actionBias.reply += 0.5;
+      sourceBias.mention += 0.25;
+      rationale.push("debate goals bias toward replies in active conversations");
+    }
+    if (hasAny(goal, ["curate", "signal", "filter"])) {
+      actionBias.retweet += 0.8;
+      actionBias.like += 0.2;
+      sourceBias.topic_search += 0.35;
+      rationale.push("curation goals bias toward retweet/like actions");
+    }
+    if (hasAny(goal, ["seek truth", "research", "facts", "evidence"])) {
+      actionBias.reply += 0.25;
+      actionBias.post += 0.2;
+      sourceBias.topic_search += 0.45;
+      rationale.push("truth-seeking goals bias toward topic-search grounded actions");
+    }
+  }
+}
+function compilePersonaActionProfile(input) {
+  const { identity, strategy, constraints } = input;
+  const rationale = [];
+  const actionBias = {
+    reply: 0,
+    like: 0,
+    retweet: 0,
+    follow: 0,
+    post: 0
+  };
+  const sourceBias = {
+    mention: 0,
+    timeline: 0,
+    topic_search: 0,
+    people_watch: 0,
+    synthesis: 0
+  };
+  const mix = identity.engagementStrategy.contentMix;
+  actionBias.post += (mix.originalPosts - 25) / 25;
+  actionBias.reply += (mix.replies - 30) / 25;
+  actionBias.retweet += (mix.retweets - 15) / 20;
+  actionBias.like += (mix.likes - 15) / 20;
+  rationale.push("contentMix translated into action priors");
+  if (identity.engagementStrategy.replyStyle === "strategic") {
+    actionBias.reply += 0.3;
+    sourceBias.people_watch += 0.35;
+    sourceBias.topic_search += 0.25;
+    sourceBias.timeline -= 0.15;
+    rationale.push("strategic replyStyle favors selective people/topic opportunities");
+  } else if (identity.engagementStrategy.replyStyle === "reactive") {
+    actionBias.reply += 0.4;
+    sourceBias.mention += 0.45;
+    sourceBias.timeline += 0.2;
+    rationale.push("reactive replyStyle favors mentions/timeline");
+  } else if (identity.engagementStrategy.replyStyle === "generous") {
+    actionBias.reply += 0.25;
+    actionBias.like += 0.25;
+    sourceBias.mention += 0.25;
+    sourceBias.timeline += 0.2;
+    rationale.push("generous replyStyle favors broader conversation participation");
+  } else if (identity.engagementStrategy.replyStyle === "selective") {
+    sourceBias.people_watch += 0.25;
+    sourceBias.topic_search += 0.2;
+    sourceBias.timeline -= 0.2;
+    rationale.push("selective replyStyle favors quality-filtered contexts");
+  }
+  if (identity.engagementStrategy.followStrategy === "aggressive") {
+    actionBias.follow += 0.7;
+    rationale.push("aggressive followStrategy boosts follow actions");
+  } else if (identity.engagementStrategy.followStrategy === "none") {
+    actionBias.follow -= 2;
+    rationale.push("followStrategy=none suppresses follow actions");
+  } else if (identity.engagementStrategy.followStrategy === "curated") {
+    actionBias.follow -= 0.25;
+    sourceBias.people_watch += 0.15;
+    rationale.push("curated followStrategy slightly restricts follow actions");
+  }
+  const traits = identity.traits;
+  if (traits.curiosity >= 0.65) {
+    actionBias.reply += 0.35;
+    sourceBias.mention += 0.2;
+    sourceBias.people_watch += 0.2;
+    rationale.push("high curiosity increases reply preference");
+  }
+  if (traits.empathy >= 0.65) {
+    actionBias.like += 0.35;
+    actionBias.follow += 0.25;
+    rationale.push("high empathy increases supportive actions");
+  }
+  if (traits.confidence >= 0.7 || traits.aggression >= 0.65) {
+    actionBias.reply += 0.25;
+    actionBias.post += 0.15;
+    actionBias.like -= 0.15;
+    rationale.push("assertive traits increase reply/post decisiveness");
+  }
+  if (traits.originality >= 0.7) {
+    actionBias.post += 0.25;
+    actionBias.reply += 0.1;
+    sourceBias.synthesis += 0.25;
+    rationale.push("high originality favors fresh synthesis posts");
+  }
+  if (traits.humor >= 0.7) {
+    actionBias.reply += 0.15;
+    actionBias.post += 0.15;
+    sourceBias.timeline += 0.15;
+    rationale.push("high humor increases conversational/timeline engagement");
+  }
+  if (identity.vocabularyStyle === "casual" || identity.vocabularyStyle === "internet-native") {
+    actionBias.reply += 0.2;
+    actionBias.like += 0.1;
+    sourceBias.timeline += 0.2;
+    sourceBias.synthesis -= 0.15;
+    rationale.push("casual/internet-native vocabulary favors timeline-native interactions");
+  }
+  if (identity.tweetStyle === "one-liners" || identity.tweetStyle === "short-form") {
+    actionBias.reply += 0.25;
+    actionBias.like += 0.15;
+    actionBias.post -= 0.15;
+    sourceBias.timeline += 0.2;
+    rationale.push("short tweet style favors reactive conversational actions");
+  } else if (identity.tweetStyle === "threads") {
+    actionBias.post += 0.25;
+    sourceBias.synthesis += 0.2;
+    rationale.push("thread style favors synthesis-driven posting");
+  }
+  if (identity.framework !== "philosopher") {
+    sourceBias.synthesis -= 0.1;
+    rationale.push("non-philosopher frameworks slightly downweight abstract synthesis");
+  }
+  switch (identity.framework) {
+    case "conqueror":
+      actionBias.post += 0.45;
+      actionBias.reply += 0.35;
+      actionBias.follow += 0.25;
+      actionBias.like -= 0.2;
+      sourceBias.mention += 0.15;
+      rationale.push("conqueror framework favors decisive high-visibility actions");
+      break;
+    case "authentic":
+      actionBias.reply += 0.45;
+      actionBias.like += 0.4;
+      actionBias.follow += 0.2;
+      actionBias.post += 0.1;
+      sourceBias.mention += 0.25;
+      sourceBias.timeline += 0.2;
+      sourceBias.synthesis -= 0.15;
+      rationale.push("authentic framework favors relational and grounded conversation");
+      break;
+    case "curator":
+      actionBias.retweet += 0.8;
+      actionBias.like += 0.3;
+      actionBias.post -= 0.2;
+      rationale.push("curator framework favors retweets/likes");
+      break;
+    case "community-builder":
+      actionBias.reply += 0.35;
+      actionBias.like += 0.3;
+      actionBias.follow += 0.35;
+      rationale.push("community-builder framework favors relationship actions");
+      break;
+    case "growth-hacker":
+      actionBias.post += 0.3;
+      actionBias.reply += 0.25;
+      rationale.push("growth-hacker framework favors visible output + replies");
+      break;
+    case "truthseeker":
+      actionBias.reply += 0.25;
+      actionBias.post += 0.2;
+      sourceBias.topic_search += 0.3;
+      rationale.push("truthseeker framework favors research-grounded conversation");
+      break;
+    case "philosopher":
+      actionBias.post += 0.35;
+      actionBias.reply += 0.1;
+      sourceBias.synthesis += 0.25;
+      rationale.push("philosopher framework leans toward original perspective posts");
+      break;
+    case "provocateur":
+      actionBias.reply += 0.55;
+      actionBias.post += 0.35;
+      actionBias.like -= 0.15;
+      sourceBias.mention += 0.25;
+      sourceBias.timeline += 0.15;
+      rationale.push("provocateur framework favors sharp, conversational confrontation");
+      break;
+    case "shitposter":
+      actionBias.post += 0.45;
+      actionBias.reply += 0.25;
+      sourceBias.timeline += 0.2;
+      rationale.push("shitposter framework favors high-frequency social expression");
+      break;
+    default:
+      break;
+  }
+  applyGoalBias(actionBias, sourceBias, identity.goals ?? [], rationale);
+  if ((strategy.currentFocus ?? []).length > 0 || (strategy.shortTermGoals ?? []).length > 0) {
+    sourceBias.topic_search += 0.2;
+    sourceBias.people_watch += 0.15;
+    rationale.push("active strategy focus boosts targeted discovery sources");
+  }
+  if (constraints.noOriginalPosts) {
+    actionBias.post -= 2;
+    rationale.push("hard constraint suppresses original posts");
+  }
+  if (constraints.replyOnlyMode) {
+    actionBias.reply += 1.5;
+    actionBias.like -= 1.2;
+    actionBias.retweet -= 1.2;
+    actionBias.follow -= 1.2;
+    actionBias.post -= 2;
+    rationale.push("reply-only hard constraint dominates action policy");
+  }
+  const clampedActionBias = {
+    reply: clamp(actionBias.reply, -2.5, 2.5),
+    like: clamp(actionBias.like, -2.5, 2.5),
+    retweet: clamp(actionBias.retweet, -2.5, 2.5),
+    follow: clamp(actionBias.follow, -2.5, 2.5),
+    post: clamp(actionBias.post, -2.5, 2.5)
+  };
+  const clampedSourceBias = {
+    mention: clamp(sourceBias.mention, -1.5, 1.5),
+    timeline: clamp(sourceBias.timeline, -1.5, 1.5),
+    topic_search: clamp(sourceBias.topic_search, -1.5, 1.5),
+    people_watch: clamp(sourceBias.people_watch, -1.5, 1.5),
+    synthesis: clamp(sourceBias.synthesis, -1.5, 1.5)
+  };
+  const prioritizedActions = Object.entries(clampedActionBias).sort((a, b) => b[1] - a[1]).map(([action]) => action);
+  const priorityTopics = unique2(
+    [
+      ...identity.topics ?? [],
+      ...strategy.currentFocus ?? [],
+      ...strategy.shortTermGoals ?? []
+    ].map((topic) => String(topic).trim()).filter(Boolean).slice(0, 12)
+  );
+  return {
+    actionBias: clampedActionBias,
+    sourceBias: clampedSourceBias,
+    prioritizedActions,
+    priorityTopics,
+    rationale: unique2(rationale).slice(0, 12)
+  };
+}
+
 // src/runtime/prompt-builder.ts
 var PROMPT_TOKEN_STOPWORDS = /* @__PURE__ */ new Set([
   "about",
@@ -145,6 +585,7 @@ function buildVoiceLockLines(identity) {
 }
 function buildSystemPrompt() {
   const identity = loadIdentity();
+  const constraints = getPersonaConstraints(identity);
   const config = loadConfig();
   const identityDoc = renderIdentityDocument(identity);
   const sections = [];
@@ -154,6 +595,13 @@ function buildSystemPrompt() {
   for (const line of buildVoiceLockLines(identity)) {
     sections.push(line);
   }
+  const constraintLines = buildPersonaConstraintLines(constraints);
+  if (constraintLines.length > 0) {
+    sections.push("- Operational constraints override all other behavior:");
+    for (const line of constraintLines) {
+      sections.push(`  ${line}`);
+    }
+  }
   sections.push("");
   sections.push("## Your Identity");
   sections.push(identityDoc);
@@ -442,7 +890,9 @@ function buildToolDecisionMessage(input) {
 }
 function buildOpportunityPortfolioMessage(input) {
   const identity = loadIdentity();
+  const constraints = getPersonaConstraints(identity);
   const strategy = loadStrategy();
+  const personaProfile = compilePersonaActionProfile({ identity, strategy, constraints });
   const recentWritten = recentWrittenTextsForPrompt(12);
   const overusedOpenings = findOverusedOpenings(recentWritten);
   const overusedTokens = findOverusedTokens(recentWritten);
@@ -467,6 +917,21 @@ function buildOpportunityPortfolioMessage(input) {
   for (const line of buildVoiceLockLines(identity)) {
     parts.push(line);
   }
+  const constraintLines = buildPersonaConstraintLines(constraints);
+  if (constraintLines.length > 0) {
+    parts.push("Operational constraints (hard):");
+    for (const line of constraintLines) {
+      parts.push(line);
+    }
+  }
+  parts.push("Persona action priors (soft):");
+  parts.push(`- Preferred actions this heartbeat: ${personaProfile.prioritizedActions.slice(0, 4).join(", ")}`);
+  parts.push(
+    `- Preferred sources: ${Object.entries(personaProfile.sourceBias).sort((a, b) => b[1] - a[1]).map(([source]) => source).slice(0, 3).join(", ")}`
+  );
+  if (personaProfile.priorityTopics.length > 0) {
+    parts.push(`- Priority topics: ${personaProfile.priorityTopics.slice(0, 6).join(", ")}`);
+  }
   parts.push("");
   parts.push("Human style rotation:");
   parts.push("- For each `reply`/`post`, pick one lane: quick reaction, curious question, friendly pushback, playful line, plain observation.");
@@ -735,6 +1200,10 @@ function buildReflectionPrompt(actionResults) {
 }
 
 export {
+  getPersonaConstraints,
+  personaConstraintHandles,
+  buildPersonaConstraintLines,
+  compilePersonaActionProfile,
   buildSystemPrompt,
   buildHeartbeatUserMessage,
   buildToolDecisionMessage,
@@ -743,4 +1212,4 @@ export {
   buildTrainingChatPrompt,
   buildReflectionPrompt
 };
-//# sourceMappingURL=chunk-A2XTKC7B.js.map
+//# sourceMappingURL=chunk-JIMONWKO.js.map