omnius 1.0.387 → 1.0.389

package/dist/index.js

@@ -25024,7 +25024,7 @@ var init_list_directory = __esm({
     ListDirectoryTool = class {
       name = "list_directory";
       aliases = ["ls", "dir"];
-      description = "List files and directories at a given path. Shows file sizes and types. Output includes full relative paths you can use directly in subsequent tool calls.";
+      description = "List files and directories at a given path. Shows file sizes and types. Output includes full relative paths.";
       parameters = {
         type: "object",
         properties: {
@@ -25075,20 +25075,12 @@ var init_list_directory = __esm({
           }
           if (dirs.length > 0 || files.length > 0) {
             lines.push("");
-            lines.push("Next steps — use these exact paths:");
+            lines.push("Discovered child paths (data only):");
             if (dirs.length > 0) {
-              for (const d2 of dirs.slice(0, 8)) {
-                lines.push(`  list_directory("${d2}")`);
-              }
-              if (dirs.length > 8)
-                lines.push(`  ... and ${dirs.length - 8} more directories`);
+              lines.push(`  directories: ${dirs.slice(0, 8).join(", ")}${dirs.length > 8 ? ` (+${dirs.length - 8} more)` : ""}`);
             }
             if (files.length > 0) {
-              for (const f2 of files.slice(0, 5)) {
-                lines.push(`  file_read("${f2}")`);
-              }
-              if (files.length > 5)
-                lines.push(`  ... and ${files.length - 5} more files`);
+              lines.push(`  files: ${files.slice(0, 8).join(", ")}${files.length > 8 ? ` (+${files.length - 8} more)` : ""}`);
             }
           }
           return {
@@ -25126,7 +25118,7 @@ var init_list_directory = __esm({
         const remaining = entries.filter((entry) => !kgSummaries.includes(entry));
         const syntheticLines = [
           `g  ${dirPath}/kg-summary-*.md  ${kgSummaries.length} generated summaries collapsed, ${totalBytes} bytes`,
-          `   latest generated summary: file_read("${latestPath}")`
+          `   latest generated summary path: ${latestPath}`
         ];
         return { entries: remaining, syntheticLines };
       }
@@ -572467,11 +572459,86 @@ function computeEffectiveThink(params) {
   return params.defaultThink;
 }
 function sanitizeHistoryThink(messages2) {
-  return messages2.map((m2) => {
+  const referencedToolCallIds = /* @__PURE__ */ new Set();
+  for (const message2 of messages2) {
+    if (message2.role === "tool" && message2.tool_call_id) {
+      referencedToolCallIds.add(message2.tool_call_id);
+    }
+  }
+  const stripped = messages2.map((m2) => {
     if (m2.role !== "assistant" || typeof m2.content !== "string")
       return m2;
     return { ...m2, content: stripThinkBlocks(m2.content) };
   });
+  const sanitized = [];
+  for (let i2 = 0; i2 < stripped.length; i2++) {
+    const current = stripped[i2];
+    const next = stripped[i2 + 1];
+    if (isOrphanDuplicateAssistantToolAnchor(current, next, referencedToolCallIds)) {
+      continue;
+    }
+    sanitized.push(current);
+  }
+  return sanitized;
+}
+function isOrphanDuplicateAssistantToolAnchor(current, next, referencedToolCallIds) {
+  if (!next)
+    return false;
+  if (current.role !== "assistant" || next.role !== "assistant")
+    return false;
+  if (!Array.isArray(current.tool_calls) || !Array.isArray(next.tool_calls)) {
+    return false;
+  }
+  if (current.tool_calls.length === 0 || next.tool_calls.length === 0) {
+    return false;
+  }
+  if (assistantVisibleText(current).length > 0)
+    return false;
+  if (toolCallsFingerprint(current.tool_calls) !== toolCallsFingerprint(next.tool_calls)) {
+    return false;
+  }
+  const currentIds = current.tool_calls.map((call) => call.id).filter(Boolean);
+  const nextIds = next.tool_calls.map((call) => call.id).filter(Boolean);
+  const currentReferenced = currentIds.some((id) => referencedToolCallIds.has(id));
+  const nextReferenced = nextIds.some((id) => referencedToolCallIds.has(id));
+  return !currentReferenced && (nextReferenced || currentIds.length > 0);
+}
+function assistantVisibleText(message2) {
+  if (typeof message2.content === "string")
+    return message2.content.trim();
+  if (!Array.isArray(message2.content))
+    return "";
+  return message2.content.map((part) => part.type === "text" ? part.text ?? "" : "").join("").trim();
+}
+function toolCallsFingerprint(calls) {
+  return calls.map((call) => {
+    const args = normalizeToolCallArgumentString(call.function.arguments);
+    return `${call.function.name}:${args}`;
+  }).join("|");
+}
+function normalizeToolCallArgumentString(args) {
+  try {
+    return JSON.stringify(JSON.parse(args));
+  } catch {
+    return args.replace(/\s+/g, " ").trim();
+  }
+}
+function normalizeEditComparable(text2) {
+  return text2.replace(/\r\n/g, "\n").trim();
+}
+function previewInline(text2, max = 140) {
+  const normalized = text2.replace(/\s+/g, " ").trim();
+  if (normalized.length <= max)
+    return JSON.stringify(normalized);
+  return JSON.stringify(`${normalized.slice(0, max - 18)}...#${quickTextHash(normalized)}`);
+}
+function quickTextHash(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index++) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
 }
 function applyMemoryPrefixToMessages(messages2, memoryPrefix) {
   const prefix = memoryPrefix?.trim();
@@ -572946,6 +573013,8 @@ var init_agenticRunner = __esm({
       _completionCaveat = null;
       _completionLedger = null;
       _staleEditFamilies = /* @__PURE__ */ new Map();
+      _lastReadTurnByPathKey = /* @__PURE__ */ new Map();
+      _recentSuccessfulReplacements = [];
       // ── WO-AM-01/04/10: Associative memory stores ──
       // Episode store: every tool call → persistent episode with importance + decay
       // Temporal KG: entities + relations with temporal validity (valid_from/valid_until)
@@ -573194,7 +573263,7 @@ var init_agenticRunner = __esm({
         if (this.options.subAgent || this.options.recursionDepth > 0)
           return [];
         const normalizedGoal = goal.replace(/\s+/g, " ").trim();
-        if (normalizedGoal.length < 120)
+        if (normalizedGoal.length < 120 && !this._isContinuationResumeGoal(normalizedGoal))
           return [];
         return [
           {
@@ -573258,6 +573327,44 @@ var init_agenticRunner = __esm({
           }
         ];
       }
+      _isContinuationResumeGoal(goal) {
+        const tokens = goal.toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
+        if (tokens.length === 0 || tokens.length > 14)
+          return false;
+        const continuationTerms = /* @__PURE__ */ new Set([
+          "again",
+          "and",
+          "back",
+          "carry",
+          "complete",
+          "continue",
+          "finish",
+          "from",
+          "last",
+          "latest",
+          "left",
+          "my",
+          "off",
+          "please",
+          "previous",
+          "prior",
+          "proceed",
+          "request",
+          "resume",
+          "task",
+          "that",
+          "the",
+          "this",
+          "to",
+          "try",
+          "work"
+        ]);
+        const hasResumeVerb = tokens.some((token) => token === "continue" || token === "resume" || token === "proceed" || token === "complete" || token === "finish");
+        if (!hasResumeVerb)
+          return false;
+        const continuationTokenCount = tokens.filter((token) => continuationTerms.has(token)).length;
+        return continuationTokenCount / tokens.length >= 0.7;
+      }
       /**
        * Build a compact workboard context string for injection into the
        * system prompt. Returns null when no active board exists or when
@@ -578763,6 +578870,8 @@ Respond with your assessment, then take action.`;
         this._completionLedger = null;
         this._focusTerminalLedgerRecorded = false;
         this._staleEditFamilies.clear();
+        this._lastReadTurnByPathKey.clear();
+        this._recentSuccessfulReplacements = [];
         this._lastWorldStateTurn = -1;
         this._fileWritesSinceLastWorldState = 0;
         this._resetVisualEvidenceState();
@@ -581153,7 +581262,7 @@ ${memoryLines.join("\n")}`
           this.proactivePrune(compacted, turn);
           this.microcompact(compacted, recentToolResults);
           this._insertContextFrame(compacted, await this._buildTurnContextFrame(turn, compacted, recentToolResults, environmentBlock));
-          let requestMessages = compacted;
+          let requestMessages = sanitizeHistoryThink(compacted);
           {
             const _limits = this.contextLimits();
             const ceInput = {
@@ -581189,6 +581298,7 @@ ${memoryLines.join("\n")}`
             }
           }
           const { maxOutputTokens: effectiveMaxTokens } = this.contextLimits();
+          requestMessages = sanitizeHistoryThink(requestMessages);
           const chatRequest = {
             messages: requestMessages,
             tools: toolDefs,
@@ -582148,6 +582258,69 @@ Use the saved fact to continue the promised synthesis or next concrete step, or
                   systemGuidance: staleRewriteOutput
                 };
               }
+              const editReversalBlock = this.editReversalPreflightBlock(tc.name, tc.arguments ?? {}, turn);
+              if (editReversalBlock) {
+                const focusDecision2 = this._focusSupervisor?.evaluateProposedCall({
+                  turn,
+                  toolName: tc.name,
+                  args: tc.arguments ?? {},
+                  fingerprint: toolFingerprint,
+                  isReadLike: false,
+                  stalePreflightMessage: editReversalBlock,
+                  context: this._buildFocusContextSnapshot()
+                });
+                const reversalOutput = focusDecision2?.kind === "block_tool_call" ? focusDecision2.message : editReversalBlock;
+                if (focusDecision2 && focusDecision2.kind !== "pass") {
+                  this._emitFocusSupervisorEvent({
+                    decision: focusDecision2.kind,
+                    state: focusDecision2.state,
+                    directiveId: focusDecision2.directive.id,
+                    reason: focusDecision2.directive.reason,
+                    requiredNextAction: focusDecision2.directive.requiredNextAction,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                  this._maybeMarkFocusTerminalIncomplete({
+                    decision: focusDecision2,
+                    blockedTool: tc.name,
+                    turn
+                  });
+                }
+                this.emit({
+                  type: "tool_call",
+                  toolName: tc.name,
+                  toolArgs: tc.arguments,
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this.emit({
+                  type: "tool_result",
+                  toolName: tc.name,
+                  success: false,
+                  content: reversalOutput.slice(0, 120),
+                  turn,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+                this._tagSyntheticFailure({
+                  mode: "step_repetition",
+                  rationale: "edit attempted to reverse a recent successful replacement without fresh evidence"
+                });
+                if (this._completionLedger) {
+                  this._completionLedger = recordToolEvidence(this._completionLedger, {
+                    name: tc.name,
+                    success: false,
+                    outputPreview: reversalOutput.slice(0, 500),
+                    argsKey: tc.arguments ? JSON.stringify(tc.arguments).slice(0, 300) : ""
+                  });
+                  this._saveCompletionLedgerSafe();
+                }
+                return {
+                  tc,
+                  output: reversalOutput,
+                  success: false,
+                  systemGuidance: reversalOutput
+                };
+              }
               const baseIsReadLike = ![
                 "file_write",
                 "file_edit",
@@ -583782,6 +583955,7 @@ Evidence: ${evidencePreview}`.slice(0, 500);
               const filePath = typeof tc.arguments?.path === "string" ? tc.arguments.path : "";
               recordToolExecution(this._appState, tc.name, performance.now() - toolStart, result.success, filePath || void 0);
               this.noteStaleEditGuardOutcome(tc.name, tc.arguments ?? {}, result, turn);
+              this.noteEditReversalOutcome(tc.name, tc.arguments ?? {}, result, turn);
               {
                 const beforeDirective = this._focusSupervisor?.snapshot().directive?.id ?? null;
                 this._focusSupervisor?.observeToolResult({
@@ -584846,8 +585020,9 @@ ${this.options.maxTurns && this.options.maxTurns > 0 ? `You have ${this.options.
               }
             }
             this._insertContextFrame(compactedMsgs, await this._buildTurnContextFrame(turn, compactedMsgs, void 0, bfEnvironmentBlock));
+            const modelFacingMessages = sanitizeHistoryThink(compactedMsgs);
             const chatRequest = {
-              messages: compactedMsgs,
+              messages: modelFacingMessages,
               tools: toolDefs,
               temperature: this.options.temperature,
               maxTokens: this.options.maxTokens,
@@ -586431,6 +586606,94 @@ ${marker}` : marker);
           `Stale target preview: ${active.preview}`
         ].join("\n");
       }
+      editReversalPreflightBlock(toolName, args, turn) {
+        if (process.env["OMNIUS_ALLOW_BLIND_EDIT_REVERSAL"] === "1")
+          return null;
+        const replacements = this.extractReplacementEdits(toolName, args);
+        if (replacements.length === 0)
+          return null;
+        for (const replacement of replacements) {
+          const prior = [...this._recentSuccessfulReplacements].reverse().find((entry) => entry.pathKey === replacement.pathKey && entry.oldHash === replacement.newHash && entry.newHash === replacement.oldHash && turn - entry.turn <= 8);
+          if (!prior)
+            continue;
+          const lastReadTurn = this._lastReadTurnByPathKey.get(replacement.pathKey) ?? -1;
+          if (lastReadTurn > prior.turn)
+            continue;
+          return [
+            `[EDIT REVERSAL BLOCKED] ${toolName} would exactly reverse a recent successful edit on ${replacement.path}.`,
+            `Prior edit at turn ${prior.turn}: ${previewInline(prior.oldText)} -> ${previewInline(prior.newText)}.`,
+            `Proposed edit: ${previewInline(replacement.oldText)} -> ${previewInline(replacement.newText)}.`,
+            ``,
+            `Do not toggle a target back and forth after verification fails. First file_read the authoritative current file once, then choose one:`,
+            `1. make a different edit based on the fresh file and the latest failure output,`,
+            `2. run a verification command if the current file is already correct, or`,
+            `3. report incomplete/blocked with the concrete failing evidence.`
+          ].join("\n");
+        }
+        return null;
+      }
+      noteEditReversalOutcome(toolName, args, result, turn) {
+        const path12 = this.extractPrimaryToolPath(args);
+        if (toolName === "file_read" && path12 && result.success) {
+          this._lastReadTurnByPathKey.set(this.staleEditPathKey(path12), turn);
+          return;
+        }
+        if (!result.success || result.mutated === false)
+          return;
+        const replacements = this.extractReplacementEdits(toolName, args);
+        if (replacements.length === 0)
+          return;
+        for (const replacement of replacements) {
+          this._recentSuccessfulReplacements.push({
+            ...replacement,
+            tool: toolName,
+            turn
+          });
+        }
+        if (this._recentSuccessfulReplacements.length > 40) {
+          this._recentSuccessfulReplacements = this._recentSuccessfulReplacements.slice(-40);
+        }
+      }
+      extractReplacementEdits(toolName, args) {
+        if (!args)
+          return [];
+        const out = [];
+        const add3 = (path12, oldText, newText) => {
+          if (typeof path12 !== "string" || !path12.trim())
+            return;
+          if (typeof oldText !== "string" || typeof newText !== "string")
+            return;
+          const normalizedOld = normalizeEditComparable(oldText);
+          const normalizedNew = normalizeEditComparable(newText);
+          if (!normalizedOld || !normalizedNew || normalizedOld === normalizedNew)
+            return;
+          out.push({
+            path: path12.trim(),
+            pathKey: this.staleEditPathKey(path12),
+            oldText: normalizedOld,
+            newText: normalizedNew,
+            oldHash: this.quickHash(normalizedOld),
+            newHash: this.quickHash(normalizedNew)
+          });
+        };
+        if (toolName === "file_edit") {
+          add3(this.extractPrimaryToolPath(args), args["old_string"] ?? args["oldString"] ?? args["oldText"], args["new_string"] ?? args["newString"] ?? args["newText"]);
+          return out;
+        }
+        if (toolName === "batch_edit") {
+          const fallbackPath = this.extractPrimaryToolPath(args);
+          const edits = args["edits"];
+          if (!Array.isArray(edits))
+            return out;
+          for (const edit of edits) {
+            if (!edit || typeof edit !== "object")
+              continue;
+            const rec = edit;
+            add3(rec["path"] ?? rec["file"] ?? rec["filePath"] ?? rec["file_path"] ?? fallbackPath, rec["old_string"] ?? rec["oldString"] ?? rec["oldText"], rec["new_string"] ?? rec["newString"] ?? rec["newText"]);
+          }
+        }
+        return out;
+      }
       noteStaleEditGuardOutcome(toolName, args, result, turn) {
         const path12 = this.extractPrimaryToolPath(args);
         const pathKey = path12 ? this.staleEditPathKey(path12) : "";
@@ -614782,6 +615045,129 @@ function loadSessionContext(repoRoot) {
     return null;
   }
 }
+function readJsonOrNull(filePath) {
+  try {
+    if (!existsSync113(filePath)) return null;
+    return JSON.parse(readFileSync90(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isManualSessionEntry(entry) {
+  const task = cleanPromptForDiary(entry.task).toLowerCase();
+  const summary = normalizeSessionText(entry.summary || entry.assistantResponse, 160).toLowerCase();
+  return entry.source === "manual" || task === "(manual save)" || entry.toolCalls === 0 && summary.startsWith("manual context save");
+}
+function isDeicticContinuationGoal(goal) {
+  const tokens = normalizeSessionText(cleanPromptForDiary(goal), 180).toLowerCase().replace(/[^a-z0-9]+/g, " ").split(/\s+/).filter(Boolean);
+  if (tokens.length === 0 || tokens.length > 14) return false;
+  const hasResumeVerb = tokens.some(
+    (token) => token === "continue" || token === "resume" || token === "proceed" || token === "complete" || token === "finish"
+  );
+  if (!hasResumeVerb) return false;
+  const deicticCount = tokens.filter((token) => DEICTIC_CONTINUATION_TERMS.has(token)).length;
+  return deicticCount / tokens.length >= 0.7;
+}
+function readRestoreWorkboard(repoRoot, runId) {
+  if (!runId) return null;
+  return readJsonOrNull(
+    join127(repoRoot, OMNIUS_DIR, "workboards", runId, "active.json")
+  );
+}
+function scoreRestoreLedger(ledger, workboard) {
+  const status = ledger.status || "open";
+  if (status === "approved") return -1e3;
+  const evidence = ledger.evidence ?? [];
+  const unresolvedCount = ledger.unresolved?.length ?? 0;
+  const activeCards = (workboard?.cards ?? []).filter(
+    (card) => card.status === "open" || card.status === "in_progress" || card.status === "needs_changes" || card.status === "blocked"
+  ).length;
+  const mutationTools = /* @__PURE__ */ new Set(["file_edit", "file_patch", "batch_edit", "file_write"]);
+  const mutationEvidence = evidence.filter((item) => mutationTools.has(item.toolName || "")).length;
+  const failedMutationEvidence = evidence.filter(
+    (item) => mutationTools.has(item.toolName || "") && item.success === false
+  ).length;
+  const targetPathEvidence = evidence.filter((item) => (item.targetPaths?.length ?? 0) > 0).length;
+  const blockedEvidence = evidence.filter((item) => {
+    const summary = String(item.summary ?? "").toLowerCase();
+    return summary.includes("[focus supervisor block]") || summary.includes("stale") || summary.includes("blocked");
+  }).length;
+  let score = 0;
+  if (status === "open") score += 10;
+  else if (status === "incomplete_verification") score += 18;
+  else if (status === "request_changes" || status === "blocked") score += 16;
+  else score += 4;
+  score += Math.min(evidence.length, 20);
+  score += Math.min(unresolvedCount, 10) * 4;
+  score += Math.min(activeCards, 8) * 3;
+  score += Math.min(mutationEvidence, 8) * 5;
+  score += Math.min(failedMutationEvidence, 8) * 3;
+  score += Math.min(targetPathEvidence, 6) * 2;
+  score += Math.min(blockedEvidence, 6) * 2;
+  const goal = normalizeSessionText(ledger.goal, 260);
+  if (goal.length >= 80) score += 5;
+  if (isDeicticContinuationGoal(goal) && mutationEvidence === 0 && unresolvedCount === 0 && activeCards === 0) {
+    score -= 25;
+  }
+  return score;
+}
+function selectActiveTaskAnchor(repoRoot) {
+  const ledgerDir = join127(repoRoot, OMNIUS_DIR, "completion-ledgers");
+  try {
+    if (!existsSync113(ledgerDir)) return null;
+    const candidates = readdirSync39(ledgerDir).filter((name10) => name10.endsWith(".json")).map((name10) => {
+      const filePath = join127(ledgerDir, name10);
+      const ledger = readJsonOrNull(filePath);
+      if (!ledger || !ledger.goal) return null;
+      const runId = ledger.runId || name10.replace(/\.json$/, "");
+      const workboard = readRestoreWorkboard(repoRoot, runId);
+      const score = scoreRestoreLedger(ledger, workboard);
+      const mtimeMs = statSync42(filePath).mtimeMs;
+      return { ledger: { ...ledger, runId }, workboard, score, mtimeMs };
+    }).filter((item) => Boolean(item));
+    candidates.sort((a2, b) => b.score - a2.score || b.mtimeMs - a2.mtimeMs);
+    const selected = candidates.find((candidate) => candidate.score >= 18);
+    return selected ?? null;
+  } catch {
+    return null;
+  }
+}
+function buildActiveTaskAnchor(repoRoot) {
+  const selected = selectActiveTaskAnchor(repoRoot);
+  if (!selected) return null;
+  const ledger = selected.ledger;
+  const evidence = ledger.evidence ?? [];
+  const selectedEvidence = [...evidence.slice(0, 2), ...evidence.slice(-4)];
+  const seenEvidence = /* @__PURE__ */ new Set();
+  const evidenceLines = selectedEvidence.flatMap((item) => {
+    const summary = normalizeSessionText(item.summary, 240);
+    if (!summary || seenEvidence.has(summary)) return [];
+    seenEvidence.add(summary);
+    const status = item.success === false ? "failed" : item.success === true ? "ok" : "observed";
+    const tool = item.toolName || "evidence";
+    return [`- ${tool} ${status}: ${summary}`];
+  });
+  const unresolvedLines = (ledger.unresolved ?? []).slice(0, 4).map((item) => `- ${normalizeSessionText(item.text, 180)}`).filter((line) => line !== "- ");
+  const boardCards = (selected.workboard?.cards ?? []).filter((card) => card.status !== "completed" && card.status !== "verified").slice(0, 5).map((card) => {
+    const title = normalizeSessionText(card.title || card.id, 120);
+    const status = card.status || "open";
+    const lane = card.lane ? `/${card.lane}` : "";
+    const evidenceCount = Array.isArray(card.evidence) ? card.evidence.length : 0;
+    return `- ${title} (${status}${lane}, evidence=${evidenceCount})`;
+  });
+  return `<active-task-anchor>
+Source: completion ledger ${ledger.runId || "(unknown run)"}; status=${ledger.status || "open"}
+Goal: ${normalizeSessionText(ledger.goal, 420)}
+Recorded evidence: ${evidence.length}; unresolved items: ${ledger.unresolved?.length ?? 0}
+` + (evidenceLines.length > 0 ? `Material evidence:
+${evidenceLines.join("\n")}
+` : "") + (unresolvedLines.length > 0 ? `Unresolved:
+${unresolvedLines.join("\n")}
+` : "") + (boardCards.length > 0 ? `Active workboard cards:
+${boardCards.join("\n")}
+` : "") + `Continuation rule: when the user asks to continue, resume this active task unless the new prompt names a different target.
+</active-task-anchor>`;
+}
 function formatSessionHistoryDisplay(ctx3) {
   return buildSessionHistoryBoxLines(
     sessionContextToHistoryBoxData(ctx3),
@@ -614810,18 +615196,23 @@ function sessionContextToHistoryBoxData(ctx3, title = "Session History") {
 function buildContextRestorePrompt(repoRoot) {
   const ctx3 = loadSessionContext(repoRoot);
   const handoffPrompt = buildHandoffPrompt(repoRoot);
+  const activeTaskAnchor = buildActiveTaskAnchor(repoRoot);
   if (handoffPrompt) {
+    const usefulEntries2 = (ctx3?.entries ?? []).filter((entry) => !isManualSessionEntry(entry));
     const baseCtx = ctx3 && ctx3.entries.length > 0 ? `
 
 <session-recap>
-Recent tasks: ${ctx3.entries.slice(-3).map(
+Recent tasks: ${(usefulEntries2.length > 0 ? usefulEntries2 : ctx3.entries).slice(-3).map(
       (e2) => `[${e2.completed ? "done" : "partial"}] ${normalizeSessionText(e2.summary || e2.task, 80)}`
     ).join(", ")}
 </session-recap>` : "";
-    return handoffPrompt + baseCtx;
+    return handoffPrompt + (activeTaskAnchor ? `
+
+${activeTaskAnchor}` : "") + baseCtx;
   }
-  if (!ctx3 || ctx3.entries.length === 0) return null;
-  const recent = ctx3.entries.slice(-5);
+  if (!ctx3 || ctx3.entries.length === 0) return activeTaskAnchor;
+  const usefulEntries = ctx3.entries.filter((entry) => !isManualSessionEntry(entry));
+  const recent = (usefulEntries.length > 0 ? usefulEntries : ctx3.entries).slice(-5);
   const chronology = recent.map((e2) => {
     const status = e2.completed ? "done" : "partial";
     const summary = normalizeSessionText(e2.assistantResponse || e2.summary || e2.task, 140);
@@ -614829,8 +615220,8 @@ Recent tasks: ${ctx3.entries.slice(-3).map(
     const files = e2.filesModified && e2.filesModified.length > 0 ? ` | files: ${e2.filesModified.slice(0, 3).join(", ")}` : "";
     return `[${status}] ${summary}${tools}${files}`;
   });
-  const last2 = ctx3.entries[ctx3.entries.length - 1];
-  const lastCompleted = [...ctx3.entries].reverse().find((entry) => entry.completed);
+  const last2 = recent[recent.length - 1] ?? ctx3.entries[ctx3.entries.length - 1];
+  const lastCompleted = [...usefulEntries].reverse().find((entry) => entry.completed);
   const latestCompleted = lastCompleted ? `Latest completed task: ${normalizeSessionText(lastCompleted.assistantResponse || lastCompleted.summary || lastCompleted.task, 180)}` : "";
   const recentDialogue = recent.slice(-3).map((entry) => {
     const assistant = normalizeSessionText(entry.assistantResponse || entry.summary, 320) || "(no assistant reply captured)";
@@ -614843,15 +615234,18 @@ Provenance: ${last2.provenance} (file_read to expand)` : "";
   const kg = `
 KG summary: .omnius/context/kg-summary/latest.md (file_read to expand; legacy pointer: .omnius/context/kg-summary-latest.md)`;
   return `<session-recap>
-Project chronology (older to newer):
+` + (activeTaskAnchor ? `${activeTaskAnchor}
+
+` : "") + `Project chronology (older to newer):
 ${chronology.join("\n")}
 ` + (latestCompleted ? `
 ${latestCompleted}
 ` : "\n") + `
 Most recent exchanges (older to newer):
 ${recentDialogue}
-Continue from the latest exchange and do not repeat completed work.${prov}${kg}
-</session-recap>`;
+` + (activeTaskAnchor ? `For continuation prompts, resume the active task anchor above; use chronology only to avoid repeating completed work.${prov}${kg}
+` : `Continue from the latest exchange and do not repeat completed work.${prov}${kg}
+`) + `</session-recap>`;
 }
 function getLastTaskSummary(repoRoot) {
   const ctx3 = loadSessionContext(repoRoot);
@@ -615174,7 +615568,7 @@ function deleteUsageRecord(kind, value2, repoRoot) {
     remove(join127(repoRoot, OMNIUS_DIR, USAGE_HISTORY_FILE));
   }
 }
-var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, SESSIONS_DIR, SESSIONS_INDEX, SKIP_DIRS3, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
+var OMNIUS_DIR, LEGACY_DIRS, SUBDIRS, gitignoreWatchers, gitignoreRetryTimers, CONTEXT_FILES, PENDING_TASK_FILE, HANDOFF_FILE, CONTEXT_SAVE_FILE, CONTEXT_LEDGER_FILE, MAX_CONTEXT_ENTRIES, MAX_SESSION_DIARY_ENTRIES, MAX_SESSION_DIARY_DETAILED_ENTRIES, MAX_CONTEXT_LEDGER_LINES, MAX_CONTEXT_LEDGER_BYTES, SAME_TASK_REPLACE_WINDOW_MS, LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_RETRY_MAX, DEICTIC_CONTINUATION_TERMS, SESSIONS_DIR, SESSIONS_INDEX, SKIP_DIRS3, HOME_SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
 var init_omnius_directory = __esm({
   "packages/cli/src/tui/omnius-directory.ts"() {
     "use strict";
@@ -615207,6 +615601,34 @@ var init_omnius_directory = __esm({
     LOCK_TIMEOUT_MS = 5e3;
     LOCK_RETRY_MS = 50;
     LOCK_RETRY_MAX = 100;
+    DEICTIC_CONTINUATION_TERMS = /* @__PURE__ */ new Set([
+      "again",
+      "and",
+      "back",
+      "carry",
+      "complete",
+      "continue",
+      "finish",
+      "from",
+      "last",
+      "latest",
+      "left",
+      "my",
+      "off",
+      "please",
+      "previous",
+      "prior",
+      "proceed",
+      "request",
+      "resume",
+      "task",
+      "that",
+      "the",
+      "this",
+      "to",
+      "try",
+      "work"
+    ]);
     SESSIONS_DIR = "sessions";
     SESSIONS_INDEX = "sessions-index.json";
     SKIP_DIRS3 = /* @__PURE__ */ new Set([

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.387",
+  "version": "1.0.389",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.387",
+      "version": "1.0.389",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.387",
+  "version": "1.0.389",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",