omnius 1.0.569 → 1.0.570

package/dist/index.js

@@ -43773,20 +43773,27 @@ function scoreSkill(skill, terms2) {
   const hay = skillHaystack(skill);
   const matched = [];
   let score = 0;
+  let capabilityMatches = 0;
   for (const term of terms2) {
     if (!hay.includes(term))
       continue;
+    const nameMatch = skill.name.toLowerCase().includes(term);
+    const triggerMatch = skill.triggers.some((trigger) => trigger.toLowerCase().includes(term));
+    const descriptionMatch = skill.description.toLowerCase().includes(term);
+    if (!nameMatch && !triggerMatch && !descriptionMatch)
+      continue;
     matched.push(term);
-    if (skill.name.toLowerCase().includes(term))
+    capabilityMatches++;
+    if (nameMatch)
       score += 5;
-    if (skill.triggers.some((trigger) => trigger.toLowerCase().includes(term)))
+    if (triggerMatch)
       score += 3;
-    if (skill.description.toLowerCase().includes(term))
+    if (descriptionMatch)
       score += 2;
     if (skill.source.toLowerCase().includes(term))
       score += 1;
   }
-  if (score <= 0)
+  if (score <= 0 || capabilityMatches === 0)
     return null;
   return {
     skill,
@@ -568049,7 +568056,8 @@ function recordCompletionEvidence(ledger, evidence) {
     ...evidence.family ? { family: cleanText(evidence.family, 120) } : {},
     ...evidence.verificationImpact ? { verificationImpact: evidence.verificationImpact } : {},
     ...evidence.metrics ? { metrics: evidence.metrics } : {},
-    ...evidence.receipt ? { receipt: evidence.receipt } : {}
+    ...evidence.receipt ? { receipt: evidence.receipt } : {},
+    ...evidence.progressClass ? { progressClass: evidence.progressClass } : {}
   };
   return {
     ...ledger,
@@ -568075,7 +568083,8 @@ function recordToolEvidence(ledger, input) {
     family: input.family,
     verificationImpact: input.verificationImpact,
     metrics: input.metrics,
-    receipt: input.receipt
+    receipt: input.receipt,
+    progressClass: input.progressClass
   });
 }
 function addCompletionClaims(ledger, claims) {
@@ -568199,6 +568208,9 @@ function classifyCompletionProgress(entry) {
   if (entry.kind === "file_change" || entry.role === "mutation") {
     return "work_product";
   }
+  if (/^(file_write|file_edit|file_patch|batch_edit)$/.test(entry.toolName ?? "")) {
+    return "work_product";
+  }
   return "observation";
 }
 function isMutationEvidence(entry) {
@@ -568233,7 +568245,11 @@ function isVerificationInvalidatingMutation(entry) {
   return entry.verificationImpact !== "neutral";
 }
 function isSuccessfulVerificationEvidence(entry) {
-  return entry.role === "verification" && entry.success === true;
+  if (entry.role !== "verification" || entry.success !== true)
+    return false;
+  if (!entry.receipt)
+    return true;
+  return entry.receipt.schema === "omnius.command-evidence-receipt.v1" && Boolean(entry.receipt.canonicalCommand.trim()) && Boolean(entry.receipt.cwd.trim()) && entry.receipt.exitCode === 0 && !entry.receipt.timedOut;
 }
 function isFailedVerificationEvidence(entry) {
   return entry.role === "verification" && entry.success === false;
@@ -571665,6 +571681,45 @@ var init_reference_contracts = __esm({
   }
 });
 
+// packages/orchestrator/dist/phase-skill-guidance.js
+function buildPhaseSkillGuidance(input) {
+  const query = [
+    `Active lifecycle phase: ${input.phase}.`,
+    `Phase focus: ${PHASE_FOCUS[input.phase]}.`,
+    `Current user goal: ${input.goal}`,
+    input.currentStep ? `Current work item: ${input.currentStep}` : ""
+  ].filter(Boolean).join("\n");
+  const pack = buildEphemeralSkillPack(input.skills ?? discoverSkills(input.repoRoot), {
+    task: query,
+    modelTier: input.modelTier,
+    // Phase support must leave the evidence and current task dominant.
+    limit: input.modelTier === "small" ? 2 : 3
+  });
+  if (!pack)
+    return "";
+  return [
+    "[PHASE SKILL GUIDANCE]",
+    `phase=${input.phase}`,
+    "This is a live manifest selected from installed/project skills for the current phase. Load targeted guidance only when it materially helps the next action.",
+    pack,
+    "[/PHASE SKILL GUIDANCE]"
+  ].join("\n");
+}
+var PHASE_FOCUS;
+var init_phase_skill_guidance = __esm({
+  "packages/orchestrator/dist/phase-skill-guidance.js"() {
+    "use strict";
+    init_dist5();
+    PHASE_FOCUS = {
+      explore: "repository discovery requirements analysis source inspection provenance",
+      plan: "requirements planning architecture design acceptance criteria risk analysis",
+      implement: "implementation code change editing debugging tests integration safety",
+      verify: "verification validation acceptance tests release documentation consistency",
+      mixed: "implementation verification testing code review evidence"
+    };
+  }
+});
+
 // packages/orchestrator/dist/deliveryCoverage.js
 import { createHash as createHash30 } from "node:crypto";
 import { existsSync as existsSync90, readFileSync as readFileSync70 } from "node:fs";
@@ -575540,6 +575595,8 @@ function buildTrajectoryCheckpoint(input) {
   } else if (focus) {
     assessment = "recovery_required";
     const focusDiagnostic = extractFocusNextAction(focus);
+    if (focusDiagnostic)
+      nextAction = focusDiagnostic;
     successEvidence = focusDiagnostic ? `Active controller directive remains unresolved: ${focusDiagnostic}` : "An active controller directive is unresolved; its evidence is recorded separately.";
   } else if (hasRecentFailure && !fullWriteRecoveredByMutation) {
     assessment = "recovery_required";
@@ -576262,7 +576319,7 @@ function extractAnchorsFromMessages(messages2, turn, workspaceRoot) {
       continue;
     if (msg.role === "tool" || msg.role === "assistant") {
       const matches = content.match(FILE_PATH_RE) ?? [];
-      const distinctPaths = Array.from(new Set(matches.filter((p2) => isFileAnchorCandidate(p2, workspaceRoot)))).slice(0, 5);
+      const distinctPaths = Array.from(new Set(matches.map((p2) => p2.trim().replace(/^['"`]+|['"`,.;:)\]]+$/g, "")).filter((p2) => isFileAnchorCandidate(p2, workspaceRoot)))).slice(0, 5);
       for (const p2 of distinctPaths) {
         const summary = `file: ${p2}`;
         if (seenSummaries.has(summary))
@@ -591485,6 +591542,7 @@ var init_agenticRunner = __esm({
     init_personality();
     init_promptLoader();
     init_reference_contracts();
+    init_phase_skill_guidance();
     init_deliveryCoverage();
     init_critic();
     init_reflection();
@@ -592143,6 +592201,10 @@ var init_agenticRunner = __esm({
       _toolLastUsedTurn = /* @__PURE__ */ new Map();
       _ephemeralSkillPackContext = "";
       _stickyDynamicContext = "";
+      // Successful PFV/SSMA analyses are controller facts, not prompt fragments.
+      // Keep one expiring delta so a capable model sees the current diagnosis and
+      // evidence handle without inheriting an archive of REG directives.
+      _recoveryControllerDelta = null;
       // Phase 1 — Context Tree. Tracks current phase + per-phase anchors so
       // compactMessages can summarize-by-phase and Phase 6 can surface anchors
       // by keyword. Initialized lazily in run() because the system-prompt hash
@@ -592978,6 +593040,17 @@ ${parts.join("\n")}
           lines.push(`declared_next_action=${ts.nextAction.replace(/\s+/g, " ").slice(0, 220)}`);
         }
         lines.push(`progress_anchor=completed_steps:${ts.completedSteps.length} failed_approaches:${ts.failedApproaches.length} modified_files:${ts.modifiedFiles.size} tool_calls:${ts.toolCallCount}`);
+        const recoveryDelta = this._recoveryControllerDelta;
+        if (recoveryDelta && recoveryDelta.expiresAtTurn >= turn) {
+          lines.push(`recovery_delta=${recoveryDelta.source} evidence=${recoveryDelta.evidenceHandle}`);
+          lines.push(`recovery_diagnosis=${recoveryDelta.diagnosis}`);
+          lines.push(`recovery_next_action=${recoveryDelta.nextAction}`);
+          if (recoveryDelta.verification) {
+            lines.push(`recovery_exit_evidence=${recoveryDelta.verification}`);
+          }
+        } else if (recoveryDelta) {
+          this._recoveryControllerDelta = null;
+        }
         if (ts.completedSteps.length > 0) {
           lines.push(`recent_completed=${ts.completedSteps.slice(-3).join(" | ").replace(/\s+/g, " ").slice(0, 420)}`);
         }
@@ -593029,6 +593102,24 @@ ${parts.join("\n")}
         lines.push(this._todoWriteAvailable() ? "not_progress=repeat unchanged todo_write; repeat broad discovery already represented in this frame; keep discovery active after a real mutation" : "not_progress=repeat broad discovery already represented in this frame; keep discovery active after a real mutation");
         return lines.join("\n");
       }
+      _recordRecoveryControllerDelta(input) {
+        const diagnosis = String(input.diagnosis ?? "").replace(/\s+/g, " ").trim().slice(0, 320);
+        const nextAction = String(input.nextAction ?? "").replace(/\s+/g, " ").trim().slice(0, 320);
+        if (!diagnosis || !nextAction)
+          return;
+        this._recoveryControllerDelta = {
+          source: input.source,
+          evidenceHandle: `${input.source}@turn-${input.turn}`,
+          diagnosis,
+          nextAction,
+          verification: String(input.verification ?? "").replace(/\s+/g, " ").trim().slice(0, 260),
+          expectedTool: input.expectedTool,
+          // A delta is a live controller state, not an instruction archive. It
+          // naturally expires unless the proposed action is attempted first.
+          expiresAtTurn: input.turn + 4
+        };
+        this._trajectoryDirtyCauses.add(`recovery_${input.source}`);
+      }
       _workboardTodoCardForPaths(snapshot, paths) {
         const targets = [
           ...new Set(paths.map((path16) => this._normalizeEvidencePath(path16)))
@@ -600124,7 +600215,12 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
         const gitBlock = this._renderGitProgressBlock(turn);
         const failureBlock = null;
         const churnBlock = null;
-        const focusBlock = null;
+        const focusDirective = this._focusSupervisor?.snapshot().directive;
+        const focusBlock = focusDirective ? [
+          `required_next_action=${focusDirective.requiredNextAction}`,
+          `reason=${focusDirective.reason}`,
+          `state=${focusDirective.state}`
+        ].join("\n") : null;
         const actionContractBlock = this._renderNextActionContract(turn);
         const deliveryCoverageBlock = this._deliveryCoverageState()?.rendered ?? null;
         const referenceContractPhase = this._contextTree?.getCurrentPhase() ?? "mixed";
@@ -600135,6 +600231,13 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
           includePhase: true,
           includeExplicit: false
         });
+        const phaseSkillGuidance = buildPhaseSkillGuidance({
+          repoRoot: this.authoritativeWorkingDirectory(),
+          phase: referenceContractPhase,
+          goal: concreteGoal,
+          currentStep: this._taskState.currentStep,
+          modelTier: this.options.modelTier ?? "large"
+        });
         const trajectoryCheckpoint = await this._refreshTrajectoryCheckpoint(turn, focusBlock, [
           workspaceTreeBlock,
           filesystemBlock,
@@ -600242,6 +600345,15 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
               contractIds: phaseContracts.contracts.map((contract) => contract.id)
             }
           }),
+          signalFromBlock("runtime_guidance", "turn.phase-skills", phaseSkillGuidance, {
+            id: "phase-skills",
+            dedupeKey: "turn.phase-skills",
+            semanticKey: "context.phase-skills",
+            priority: PRIORITY.RUNTIME_GUIDANCE - 1,
+            createdTurn: turn,
+            ttlTurns: 1,
+            metadata: { phase: referenceContractPhase }
+          }),
           signalFromBlock("task_state", "turn.todos", todoBlock, {
             id: "todo-state",
             dedupeKey: "turn.todos",
@@ -600414,6 +600526,10 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
        * transition (so the primary loop can reset per-phase tool budgets) or null.
        */
       _advanceContextTreeOnToolCall(toolName, argsKey, turn, messages2) {
+        if (this._recoveryControllerDelta?.expectedTool === toolName) {
+          this._recoveryControllerDelta = null;
+          this._trajectoryDirtyCauses.add("recovery_action_attempted");
+        }
         if (!this._contextTree)
           return null;
         this._contextTree.observeToolCall(toolName, argsKey, turn);
@@ -601704,14 +601820,16 @@ ${notice}`;
        * protocol correctness; only stale assistant-visible planning prose changes.
        */
       _retireLinkedAssistantReadIntents(messages2) {
-        if (!this._legacyModelVisibleCompactionAllowed())
-          return;
         const resolvedToolCallIds = new Set(messages2.filter((message2) => message2.role === "tool" && message2.tool_call_id).map((message2) => message2.tool_call_id));
         for (const message2 of messages2) {
           if (message2.role !== "assistant" || typeof message2.content !== "string" || !Array.isArray(message2.tool_calls) || !message2.tool_calls.some((call) => resolvedToolCallIds.has(call.id)) || !/\b(?:i|we)\s+(?:need|will|should|have)\s+to\s+(?:read|inspect|open)\b/i.test(message2.content)) {
             continue;
           }
-          message2.content = "[assistant read intent retired: the linked tool result is present below; decide from that evidence rather than planning the same read]";
+          const index = messages2.indexOf(message2);
+          messages2[index] = {
+            ...message2,
+            content: ASSISTANT_READ_INTENT_RETIRED_MARKER
+          };
         }
       }
       _emitSteeringLifecycle(record, reason) {
@@ -603489,6 +603607,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._toolLastUsedTurn.clear();
         this._ephemeralSkillPackContext = "";
         this._stickyDynamicContext = "";
+        this._recoveryControllerDelta = null;
         this._stableReferenceContracts = [];
         this._referenceContractSelections = [];
         this._referenceContractPhase = "mixed";
@@ -603695,6 +603814,7 @@ Respond with the assessment and take the selected evidence-backed action.`;
         this._memexArchive.clear();
         this._todoOutputLedger.clear();
         this._sessionId = this.options.sessionId && String(this.options.sessionId) || process.env["OMNIUS_SESSION_ID"] && String(process.env["OMNIUS_SESSION_ID"]) || `session-${Date.now()}`;
+        setTodoSessionId(this._sessionId);
         const continuesPriorTask = this._allowImplicitContinuation || this._isContinuationResumeGoal(persistentTaskGoal);
         if (!continuesPriorTask) {
           this._hidePriorSessionTodosForFreshTask(persistentTaskGoal);
@@ -605314,8 +605434,15 @@ Respond with EXACTLY this structure before your next tool call:
                       },
                       callable: _smaCallable
                     }).then((_smaResult) => {
-                      if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        void _smaResult.injection;
+                      if (!_smaResult.directive.parseFallback) {
+                        this._recordRecoveryControllerDelta({
+                          source: "stuck_meta",
+                          turn,
+                          diagnosis: _smaResult.directive.diagnosis,
+                          nextAction: `${_smaResult.directive.next_action.tool}: ${_smaResult.directive.next_action.rationale}`,
+                          verification: _smaResult.directive.verification,
+                          expectedTool: _smaResult.directive.next_action.tool
+                        });
                         this.emit({
                           type: "status",
                           content: `REG-49 stuck-meta-analyzer fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -605471,8 +605598,15 @@ Respond with EXACTLY this structure before your next tool call:
                       },
                       callable: _smaCallable50
                     }).then((_smaResult) => {
-                      if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                        void _smaResult.injection;
+                      if (!_smaResult.directive.parseFallback) {
+                        this._recordRecoveryControllerDelta({
+                          source: "stuck_meta",
+                          turn,
+                          diagnosis: _smaResult.directive.diagnosis,
+                          nextAction: `${_smaResult.directive.next_action.tool}: ${_smaResult.directive.next_action.rationale}`,
+                          verification: _smaResult.directive.verification,
+                          expectedTool: _smaResult.directive.next_action.tool
+                        });
                         this.emit({
                           type: "status",
                           content: `REG-50 → SSMA fired at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,
@@ -605612,8 +605746,15 @@ Respond with EXACTLY this structure before your next tool call:
                   },
                   callable: _pfvCallable
                 }).then((_pfvResult) => {
-                  if (_pfvResult.injection && !_pfvResult.verdict.parseFallback && _pfvResult.verdict.verdict !== "continue") {
-                    void _pfvResult.injection;
+                  if (!_pfvResult.verdict.parseFallback && _pfvResult.verdict.verdict !== "continue") {
+                    const frame = _pfvResult.verdict.recommended_frame;
+                    this._recordRecoveryControllerDelta({
+                      source: "problem_frame",
+                      turn,
+                      diagnosis: `${_pfvResult.verdict.verdict}: ${_pfvResult.verdict.rationale}`,
+                      nextAction: frame?.new_subtask || _pfvResult.verdict.blocker_summary || "Re-evaluate the active task frame against current evidence.",
+                      verification: frame?.success_criterion || "Record new evidence for the selected frame."
+                    });
                     this.emit({
                       type: "status",
                       content: `REG-51 PFV fired at turn ${turn} — verdict=${_pfvResult.verdict.verdict}, trigger=${_pfvTriggerReason}, ssmaCount=${this._ssmaFiredCount}, ${_pfvResult.durationMs}ms`,
@@ -607679,7 +607820,8 @@ ${cachedResult}`,
                           const normalizedDispatchName = resolvedTool?.name ?? tc.name;
                           let branchEvidenceResult = null;
                           if (normalizedDispatchName === "file_read" && this._fileReadMode(tc.arguments) !== "extract") {
-                            const exactReadKey = this._buildToolFingerprint("file_read", tc.arguments);
+                            const exactReadFingerprint = this._buildToolFingerprint("file_read", tc.arguments);
+                            const exactReadKey = this._resolveReadCoverageFingerprint("file_read", tc.arguments, exactReadFingerprint);
                             const priorRead = exactFileReadObservations.get(exactReadKey);
                             if (priorRead) {
                               const currentRead = this._fileReadDiskIdentity(tc.arguments);
@@ -610039,8 +610181,15 @@ Only call task_complete when the task is actually complete and the evidence is f
                     },
                     callable: _smaCallable
                   }).then((_smaResult) => {
-                    if (_smaResult.injection && !_smaResult.directive.parseFallback) {
-                      void _smaResult.injection;
+                    if (!_smaResult.directive.parseFallback) {
+                      this._recordRecoveryControllerDelta({
+                        source: "stuck_meta",
+                        turn,
+                        diagnosis: _smaResult.directive.diagnosis,
+                        nextAction: `${_smaResult.directive.next_action.tool}: ${_smaResult.directive.next_action.rationale}`,
+                        verification: _smaResult.directive.verification,
+                        expectedTool: _smaResult.directive.next_action.tool
+                      });
                       this.emit({
                         type: "status",
                         content: `REG-49 stuck-meta-analyzer fired (loop-intervention path) at turn ${turn} — diagnosis="${_smaResult.directive.diagnosis.slice(0, 80)}", next=${_smaResult.directive.next_action.tool}, ${_smaResult.durationMs}ms`,

package/npm-shrinkwrap.json

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

package/package.json

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