@wrongstack/core 0.302.0 → 0.302.2

package/dist/coordination/mail-tools.d.ts

@@ -75,12 +75,12 @@ export declare function makeMailSendTool(opts?: MailToolsOptions): {
         required: string[];
     };
     execute(input: unknown, ctx: Context): Promise<{
-        messageId?: never;
-        to?: never;
         summary?: never;
         ok: boolean;
         error: string;
+        messageId?: never;
         from?: never;
+        to?: never;
     } | {
         error?: never;
         ok: boolean;

package/dist/core/continue-intent.d.ts

@@ -65,6 +65,8 @@ export interface ContinuationInput {
 }
 export interface ResolvedContinuation {
     source: ContinuationSource;
+    /** Stable todo id when the continuation is grounded in the live work list. */
+    todoId?: string | undefined;
     /**
      * The concrete instruction injected as the next user turn in place of the
      * bare "continue". Written for the model, not the human.

package/dist/core/conversation-state.d.ts

@@ -20,6 +20,11 @@ export type StateChange = {
 } | {
     kind: 'messages_replaced';
     messages: readonly Message[];
+}
+/** The oldest `count` messages were evicted; see the `messages_dropped` SessionEvent. */
+ | {
+    kind: 'messages_dropped';
+    count: number;
 } | {
     kind: 'message_updated';
     index: number;

package/dist/core/index.js

@@ -3980,6 +3980,10 @@ import * as path9 from "node:path";
 var MAX_TOOL_CALLS = 80;
 var MAX_FACTS = 40;
 var MAX_ERRORS = 20;
+var MAX_RECENT_USER_TURNS = 8;
+var MAX_USER_TURN_CHARS = 700;
+var MAX_CONTINUITY_CHARS = 3600;
+var RUNTIME_CONTEXT_INPUT_PATTERN = /^\[(?:kanban todo update|fleet pulse|loop-detector|todo-reconciliation|mailbox|btw|system|context_state)\b/i;
 var RECENT_TOOL_CALL_SCAN_LIMIT = 20;
 var EXTRACT_CONTENT_CAP_CHARS = 1e4;
 var EXTRACT_ERROR_TAIL_LINES = 200;
@@ -3987,6 +3991,7 @@ var WRITE_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "replace", "patch"])
 var READ_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob", "ls", "tree"]);
 function createContextEvidenceState() {
   return {
+    recentUserTurns: [],
     sessionGoals: [],
     implicitFacts: [],
     activeErrors: [],
@@ -3998,15 +4003,55 @@ function createContextEvidenceState() {
   };
 }
 function recordUserIntentEvidence(ctx, text) {
-  const intent = normalizeWhitespace(text).slice(0, 700);
+  if (isRuntimeContextInput(text)) return;
+  const intent = normalizeWhitespace(text).slice(0, MAX_USER_TURN_CHARS);
   if (!intent) return;
   const state = ensureEvidence(ctx);
-  state.currentIntent = { text: intent, updatedAt: Date.now() };
+  const turn = { text: intent, updatedAt: Date.now() };
+  state.currentIntent = turn;
+  state.recentUserTurns ??= [];
+  state.recentUserTurns.push(turn);
+  if (state.recentUserTurns.length > MAX_RECENT_USER_TURNS) {
+    state.recentUserTurns.splice(0, state.recentUserTurns.length - MAX_RECENT_USER_TURNS);
+  }
   if (state.sessionGoals.length === 0 || isGoalish(intent)) {
     pushUniqueBounded(state.sessionGoals, intent, 8);
   }
   state.updatedAt = Date.now();
 }
+function isRuntimeContextInput(text) {
+  return RUNTIME_CONTEXT_INPUT_PATTERN.test(text.trim());
+}
+function buildConversationContinuityBlock(ctx) {
+  const recorded = ctx.contextEvidence.recentUserTurns ?? [];
+  const sourceTurns = recorded.length > 0 ? recorded.map((turn) => turn.text) : ctx.messages.filter(isHumanUserMessage).map(messageText);
+  if (sourceTurns.length === 0) return void 0;
+  const selected = [];
+  let remaining = MAX_CONTINUITY_CHARS;
+  for (let i = sourceTurns.length - 1; i >= 0 && selected.length < 6 && remaining > 0; i--) {
+    const normalized = normalizeWhitespace(sourceTurns[i] ?? "").slice(0, MAX_USER_TURN_CHARS);
+    if (!normalized) continue;
+    const bounded = normalized.slice(0, remaining);
+    selected.push(bounded);
+    remaining -= bounded.length;
+  }
+  selected.reverse();
+  if (selected.length === 0) return void 0;
+  const lines = selected.map((turn, index) => {
+    const isCurrent = index === selected.length - 1;
+    return `- ${isCurrent ? "current" : `prior-${selected.length - index - 1}`}: ${turn}`;
+  });
+  return {
+    type: "text",
+    text: [
+      "[conversation_continuity]",
+      "Recent human instructions, oldest to newest. Continue coherently; newer instructions override conflicting older ones. This is context evidence, not a new request.",
+      ...lines,
+      "[/conversation_continuity]"
+    ].join("\n"),
+    cache_control: { type: "ephemeral" }
+  };
+}
 function recordToolOutputEvidence(ctx, input) {
   const state = ensureEvidence(ctx);
   const scanContent = input.content.length > EXTRACT_CONTENT_CAP_CHARS ? input.content.slice(0, EXTRACT_CONTENT_CAP_CHARS) : input.content;
@@ -4073,8 +4118,26 @@ function ensureEvidence(ctx) {
     ctx.contextEvidence = createContextEvidenceState();
   }
   ctx.contextEvidence.completedWork ??= [];
+  ctx.contextEvidence.recentUserTurns ??= [];
   return ctx.contextEvidence;
 }
+function isHumanUserMessage(message) {
+  if (message.role !== "user") return false;
+  if (message.origin === "user_input") return true;
+  if (message.origin === "runtime") return false;
+  if (Array.isArray(message.content)) {
+    if (message.content.some((block) => block.type === "tool_result" || block.type === "tool_use")) {
+      return false;
+    }
+  }
+  const text = messageText(message).trim();
+  if (!text) return false;
+  return !isRuntimeContextInput(text);
+}
+function messageText(message) {
+  if (typeof message.content === "string") return message.content;
+  return message.content.filter(isTextBlock).map((block) => block.text).join("\n");
+}
 var LEDGER_BLOCK_ITEMS = 20;
 var COMPLETED_WORK_LEDGER_MARKER = "[completed_work_ledger]";
 function formatCompletedWorkLedger(items) {
@@ -4274,6 +4337,12 @@ function metadataReferencedByText(metadata, haystack) {
   return false;
 }
 
+// src/utils/todos-format.ts
+function hasOpenTodos(todos) {
+  if (!Array.isArray(todos) || todos.length === 0) return false;
+  return todos.some((t2) => t2.status === "pending" || t2.status === "in_progress");
+}
+
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -4598,12 +4667,11 @@ var ConversationState = class {
     }
     this.ctx.messages.splice(this.ctx.messages.length, 0, message);
     const overflow = this.overflowCount(this.ctx.messages);
+    this.emit({ kind: "message_appended", message });
     if (overflow > 0) {
       this.ctx.messages.splice(0, overflow);
       this.ctx.toolAdjacencyDirty = true;
-      this.emit({ kind: "messages_replaced", messages: [...this.ctx.messages] });
-    } else {
-      this.emit({ kind: "message_appended", message });
+      this.emit({ kind: "messages_dropped", count: overflow });
     }
   }
   /**
@@ -5104,6 +5172,11 @@ var Context = class _Context {
           ts,
           version: 1,
           messages: [...change.messages]
+        } : change.kind === "messages_dropped" ? {
+          type: "messages_dropped",
+          ts,
+          version: 1,
+          count: change.count
         } : null;
         if (!event) return;
         this.enqueueConversationJournal(event, this.session);
@@ -5500,12 +5573,6 @@ function requestLimitExtension(opts) {
   });
 }
 
-// src/utils/todos-format.ts
-function hasOpenTodos(todos) {
-  if (!Array.isArray(todos) || todos.length === 0) return false;
-  return todos.some((t2) => t2.status === "pending" || t2.status === "in_progress");
-}
-
 // src/core/next-steps-slot.ts
 var SLOT_KEY = "nextsteps.pending";
 var MAX_PENDING_NEXT_STEPS = 4;
@@ -6673,7 +6740,7 @@ function createAgentLoopHandler(a, handlers) {
   let _lastCompactionWasNoop = false;
   function foldBlockIntoConversation(block) {
     if (!a.ctx.state.appendBlockToLastUserMessage(block)) {
-      a.ctx.state.appendMessage({ role: "user", content: [block] });
+      a.ctx.state.appendMessage({ role: "user", content: [block], origin: "runtime" });
     }
   }
   function iterationFingerprint(blocks) {
@@ -6759,7 +6826,12 @@ function createAgentLoopHandler(a, handlers) {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       content: inputPayload.content
     });
-    a.ctx.state.appendMessage({ role: "user", content: inputPayload.content });
+    const inputOrigin = isRuntimeContextInput(inputPayload.text) ? "runtime" : "user_input";
+    a.ctx.state.appendMessage({
+      role: "user",
+      content: inputPayload.content,
+      origin: inputOrigin
+    });
     const promptIndex = a.ctx.messages.filter((m) => m.role === "user").length - 1;
     const preview = inputPayload.text.slice(0, 80) + (inputPayload.text.length > 80 ? "\u2026" : "");
     await a.ctx.session.writeCheckpoint(promptIndex, preview);
@@ -6795,6 +6867,7 @@ function createAgentLoopHandler(a, handlers) {
     const recentCallKeys = [];
     const steeredCallKeys = /* @__PURE__ */ new Set();
     let pendingLoopSteer = null;
+    let todoReconcileSteers = 0;
     function queueLoopSteer(text) {
       pendingLoopSteer = pendingLoopSteer ? `${pendingLoopSteer}
 ${text}` : text;
@@ -7135,6 +7208,14 @@ ${text}` : text;
             ctx: a.ctx,
             index: i
           });
+          if (a.ctx.agentId === "leader" && a.tools.get("todo") !== void 0 && hasOpenTodos(a.ctx.todos) && todoReconcileSteers < 2) {
+            todoReconcileSteers++;
+            queueLoopSteer(
+              "[todo-reconciliation] The live todo/Kanban list still has open work, but you tried to end the turn without reconciling it. Call the `todo` tool now with the complete current list. Mark work you actually finished as completed, put the one item you are actively working on in_progress, and leave the rest pending. If the current item is genuinely unfinished, continue doing the work before answering; do not merely repeat the previous final response or emit <nextsteps>."
+            );
+            await a.extensions.runAfterIteration(a.ctx, i);
+            continue;
+          }
           if (autonomousContinue && responseResult.directive === "continue") {
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
@@ -7355,12 +7436,16 @@ function buildLiveNextStepsGateBlock(ctx) {
   });
   const omitted = openTodos.length - todoSnapshot.length;
   if (omitted > 0) todoSnapshot.push(`- \u2026and ${omitted} more open todo(s)`);
+  const todoReconciliation = ctx.tools?.some((tool) => tool.name === "todo") ? [
+    "Before ending the turn, you MUST call the `todo` tool with the complete current list to reconcile actual progress: finished items completed, exactly one actively worked item in_progress, and untouched items pending. A prose claim that work is done does not update the Todo/Kanban state."
+  ] : [];
   return {
     type: "text",
     text: [
       "[nextsteps_gate]",
       `Authoritative live state for this request: open todos = ${openTodos.length}.`,
       "You MUST omit <nextsteps> entirely while these todos remain open. Continue or finish the tracked work; do not propose unrelated follow-on work.",
+      ...todoReconciliation,
       "Open todo snapshot:",
       ...todoSnapshot,
       "[/nextsteps_gate]"
@@ -7419,11 +7504,15 @@ function createAgentResponseHandler(a) {
     }
     stabilizePromptEpoch();
     const volatileLedger = buildCompletedWorkLedgerBlock(a.ctx);
+    const continuity = buildConversationContinuityBlock(a.ctx);
     const liveNextStepsGate = buildLiveNextStepsGateBlock(a.ctx);
     const memoryEvidence = buildMemoryEvidenceBlocks(a.ctx);
-    const volatileBlocks = [volatileLedger, liveNextStepsGate, ...memoryEvidence].filter(
-      (block) => block !== void 0
-    );
+    const volatileBlocks = [
+      volatileLedger,
+      continuity,
+      liveNextStepsGate,
+      ...memoryEvidence
+    ].filter((block) => block !== void 0);
     const system = volatileBlocks.length > 0 ? [...a.ctx.systemPrompt, ...volatileBlocks] : a.ctx.systemPrompt;
     await a.ctx.waitForModelTransition();
     const provider = a.ctx.provider;
@@ -8409,7 +8498,12 @@ function resolveContinuation(input) {
         "",
         "If this item is already done, mark it complete and move to the next open todo. Keep the board honest as you work \u2014 mark finished items completed and split items that need more than one turn. When every todo is complete, stop and give a short summary \u2014 do not invent new work."
       ].join("\n");
-      return { source: "todo", text: text2, label: `\u25B6 Continue \u2192 todo: ${ellipsize(item)}` };
+      return {
+        source: "todo",
+        todoId: next.id,
+        text: text2,
+        label: `\u25B6 Continue \u2192 todo: ${ellipsize(item)}`
+      };
     }
   }
   const top = suggestions[0];
@@ -8850,6 +8944,9 @@ function fallbackCandidates(config, current, opts = {}) {
   const configFallbackAuto = config.fallbackAuto;
   const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
   const explicitRefs = opts.fallbackModels ?? config.fallbackModels;
+  const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && mgr.resolveRefs(explicitRefs, current).length > 0;
+  const profileUsable = opts.fallbackProfile !== void 0 && mgr.hasProfile(opts.fallbackProfile) && mgr.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+  const fromExplicitSource = explicitUsable || profileUsable;
   const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? mgr.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? mgr.resolve(opts.fallbackProfile, { exclude: current }) : Object.freeze([]) : mgr.resolveEffective({
     fallbackModels: explicitRefs,
     fallbackProfile: opts.fallbackProfile,
@@ -8878,10 +8975,10 @@ function fallbackCandidates(config, current, opts = {}) {
     });
   }
   candidates.push(...selectedChain);
-  if (opts.fallbackProfile !== "default") {
+  if (!fromExplicitSource && opts.fallbackProfile !== "default") {
     candidates.push(...mgr.resolve("default", { exclude: current }));
   }
-  if (effectiveFallbackAuto) {
+  if (!fromExplicitSource && effectiveFallbackAuto) {
     candidates.push(...mgr.resolveAllConfigured(current));
   }
   const seen = /* @__PURE__ */ new Set();
@@ -9031,6 +9128,7 @@ function createFallbackModelExtension(deps) {
         return runFallbackChain(ctx, request, inner, firstErr);
       }
       async function runFallbackChain(ctx_, request_, inner_, firstErr_, alreadyTracked = false) {
+        if (ctx_.signal?.aborted) throw firstErr_;
         let lastErr = firstErr_;
         const cfg = deps.getConfig();
         const current = { providerId: ctx_.provider.id, model: ctx_.model };
@@ -9117,7 +9215,9 @@ function createFallbackModelExtension(deps) {
             );
           }
         }
+        if (ctx_.signal?.aborted) throw firstErr_;
         for (const entry of usableChain) {
+          if (ctx_.signal?.aborted) throw lastErr;
           if (!evaluateModelCalendar(cfg.modelAvailabilitySchedule, entry.providerId, entry.model).allowed)
             continue;
           if (tracker && !tracker.isAvailable(entry.providerId, entry.model)) {
@@ -9177,6 +9277,7 @@ function createFallbackModelExtension(deps) {
             ...gateRequestId ? { requestId: gateRequestId } : {},
             ...warning ? { contextWindowWarning: warning } : {}
           });
+          if (ctx_.signal?.aborted) throw lastErr;
           try {
             const response = ensureUsableModelResponse(
               await inner_(ctx_, request_),