omnius 1.0.569 → 1.0.571

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,
@@ -327294,9 +327301,9 @@ ${lanes.join("\n")}
         }
         return flatten2(results);
         function visitDirectory(path22, absolutePath, depth2) {
-          const canonicalPath = toCanonical(realpath(absolutePath));
-          if (visited.has(canonicalPath)) return;
-          visited.set(canonicalPath, true);
+          const canonicalPath2 = toCanonical(realpath(absolutePath));
+          if (visited.has(canonicalPath2)) return;
+          visited.set(canonicalPath2, true);
           const { files, directories } = getFileSystemEntries(path22);
           for (const current of toSorted(files, compareStringsCaseSensitive)) {
             const name10 = combinePaths(path22, current);
@@ -505220,13 +505227,13 @@ ${options2.prefix}` : "\n" : options2.prefix
           if (!this.typingWatchers) this.typingWatchers = /* @__PURE__ */ new Map();
           this.typingWatchers.isInvoked = false;
           const createProjectWatcher = (path16, typingsWatcherType) => {
-            const canonicalPath = this.toPath(path16);
-            toRemove.delete(canonicalPath);
-            if (!this.typingWatchers.has(canonicalPath)) {
+            const canonicalPath2 = this.toPath(path16);
+            toRemove.delete(canonicalPath2);
+            if (!this.typingWatchers.has(canonicalPath2)) {
               const watchType = typingsWatcherType === "FileWatcher" ? WatchType.TypingInstallerLocationFile : WatchType.TypingInstallerLocationDirectory;
               this.typingWatchers.set(
-                canonicalPath,
-                canWatchDirectoryOrFilePath(canonicalPath) ? typingsWatcherType === "FileWatcher" ? this.projectService.watchFactory.watchFile(
+                canonicalPath2,
+                canWatchDirectoryOrFilePath(canonicalPath2) ? typingsWatcherType === "FileWatcher" ? this.projectService.watchFactory.watchFile(
                   path16,
                   () => !this.typingWatchers.isInvoked ? this.onTypingInstallerWatchInvoke() : this.writeLog(`TypingWatchers already invoked`),
                   2e3,
@@ -508514,8 +508521,8 @@ ${options2.prefix}` : "\n" : options2.prefix
                 var _a22;
                 cleanExtendedConfigCache(this.extendedConfigCache, extendedConfigFilePath, (fileName) => this.toPath(fileName));
                 let ensureProjectsForOpenFiles = false;
-                (_a22 = this.sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a22.projects.forEach((canonicalPath) => {
-                  ensureProjectsForOpenFiles = this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalPath, `Change in extended config file ${extendedConfigFileName} detected`) || ensureProjectsForOpenFiles;
+                (_a22 = this.sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a22.projects.forEach((canonicalPath2) => {
+                  ensureProjectsForOpenFiles = this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalPath2, `Change in extended config file ${extendedConfigFileName} detected`) || ensureProjectsForOpenFiles;
                 });
                 if (ensureProjectsForOpenFiles) this.delayEnsureProjectForOpenFiles();
               },
@@ -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;
@@ -571548,6 +571564,13 @@ function buildReferenceContractBundle(input) {
       });
     }
   }
+  if (input.includeDeliverySurface && !candidates.some((candidate) => candidate.id === "delivery_surface")) {
+    candidates.push({
+      id: "delivery_surface",
+      phase: input.phase,
+      reason: "workspace_delivery_coverage_manifest"
+    });
+  }
   if (input.includeExplicit !== false) {
     for (const id2 of explicitContractIds(input.explicitModules)) {
       candidates.push({
@@ -571665,11 +571688,53 @@ 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 capability boundary falsification",
+      plan: "requirements planning architecture design acceptance criteria claim evidence risk analysis",
+      implement: "implementation code change editing debugging tests integration safety",
+      verify: "verification validation acceptance tests evidence receipts 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";
 import { join as join102 } from "node:path";
 import { z as z17 } from "zod";
+function canonicalPath(path16) {
+  return String(path16 ?? "").trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+}
 function duplicates(values) {
   const seen = /* @__PURE__ */ new Set();
   const out = /* @__PURE__ */ new Set();
@@ -571715,17 +571780,25 @@ function normalizeEvidence2(availableEvidence) {
   }
   return evidence;
 }
-function evaluateDeliveryCoverage(manifest, availableEvidenceIds = []) {
+function evaluateDeliveryCoverage(manifest, availableEvidenceIds = [], sourceObservations = []) {
   const gaps = [];
   const sourceById = new Map(manifest.sources.map((item) => [item.id, item]));
   const contractById = new Map(manifest.contracts.map((item) => [item.id, item]));
   const acceptanceById = new Map(manifest.acceptance.map((item) => [item.id, item]));
+  const inspectionById = new Map(manifest.inspections.map((item) => [item.id, item]));
+  const contradictionById = new Map(manifest.contradictionChecks.map((item) => [item.id, item]));
   const availableEvidence = normalizeEvidence2(availableEvidenceIds);
   const available = new Set(availableEvidence.map((item) => item.id));
+  const observations = [...sourceObservations].map((item) => ({
+    ...item,
+    path: canonicalPath(item.path)
+  }));
   for (const id2 of duplicates([
     ...manifest.sources.map((item) => item.id),
     ...manifest.contracts.map((item) => item.id),
     ...manifest.acceptance.map((item) => item.id),
+    ...manifest.inspections.map((item) => item.id),
+    ...manifest.contradictionChecks.map((item) => item.id),
     ...manifest.claims.map((item) => item.id)
   ])) {
     gaps.push({ claimId: id2, code: "duplicate_id", detail: `Duplicate manifest id '${id2}'.` });
@@ -571746,6 +571819,7 @@ function evaluateDeliveryCoverage(manifest, availableEvidenceIds = []) {
     }
   }
   const claimStates = manifest.claims.map((claim) => {
+    const gapsBeforeClaim = gaps.length;
     for (const sourceId of claim.sourceIds) {
       if (!sourceById.has(sourceId)) {
         gaps.push({ claimId: claim.id, code: "unknown_source", detail: `Claim references unknown source '${sourceId}'.` });
@@ -571799,6 +571873,57 @@ function evaluateDeliveryCoverage(manifest, availableEvidenceIds = []) {
     if (claim.state === "blocked" && !claim.blockedReason) {
       gaps.push({ claimId: claim.id, code: "blocked_reason_required", detail: "Blocked claims require a concrete blockedReason." });
     }
+    if (manifest.schemaVersion >= 2 && claim.state !== "blocked" && (claim.requiredInspectionIds.length === 0 || claim.requiredContradictionCheckIds.length === 0)) {
+      gaps.push({
+        claimId: claim.id,
+        code: "missing_inspection_contract",
+        detail: "V2 non-blocked claims must name source inspections and contradiction checks."
+      });
+    }
+    const missingInspectionIds = [];
+    for (const inspectionId of claim.requiredInspectionIds) {
+      const inspection = inspectionById.get(inspectionId);
+      if (!inspection) {
+        missingInspectionIds.push(inspectionId);
+        gaps.push({ claimId: claim.id, code: "unknown_inspection", detail: `Claim references unknown inspection '${inspectionId}'.` });
+        continue;
+      }
+      const unsatisfiedPaths = inspection.targetPaths.filter((path16) => {
+        const normalizedPath = canonicalPath(path16);
+        return !observations.some((observation) => observation.path === normalizedPath && observation.stale !== true && observation.fidelity === "full" && Boolean(observation.contentHash));
+      });
+      if (unsatisfiedPaths.length > 0) {
+        missingInspectionIds.push(inspectionId);
+        const observedButUnusable = unsatisfiedPaths.some((path16) => observations.some((observation) => observation.path === canonicalPath(path16)));
+        gaps.push({
+          claimId: claim.id,
+          code: observedButUnusable ? "stale_inspection" : "missing_inspection",
+          detail: `${inspection.boundary} inspection '${inspectionId}' needs fresh full hashed read(s): ${unsatisfiedPaths.join(", ")}.`
+        });
+      }
+    }
+    const missingContradictionCheckIds = [];
+    for (const checkId of claim.requiredContradictionCheckIds) {
+      const check = contradictionById.get(checkId);
+      if (!check) {
+        missingContradictionCheckIds.push(checkId);
+        gaps.push({ claimId: claim.id, code: "unknown_contradiction_check", detail: `Claim references unknown contradiction check '${checkId}'.` });
+        continue;
+      }
+      const unresolvedInspectionIds = check.inspectionIds.filter((id2) => {
+        if (!claim.requiredInspectionIds.includes(id2))
+          return true;
+        return missingInspectionIds.includes(id2);
+      });
+      if (unresolvedInspectionIds.length > 0) {
+        missingContradictionCheckIds.push(checkId);
+        gaps.push({
+          claimId: claim.id,
+          code: "missing_contradiction_check",
+          detail: `Contradiction check '${checkId}' (${check.question}) lacks fresh inspection evidence: ${unresolvedInspectionIds.join(", ")}.`
+        });
+      }
+    }
     const required = requiredLayers(claim.state);
     const selected = claim.requiredAcceptanceIds.map((id2) => acceptanceById.get(id2)).filter((item) => Boolean(item));
     const missingAcceptanceIds = required.filter((layer) => !selected.some((item) => item.layer === layer && item.requiredFor.includes(claim.state)));
@@ -571829,11 +571954,16 @@ function evaluateDeliveryCoverage(manifest, availableEvidenceIds = []) {
         gaps.push({ claimId: claim.id, code: "missing_evidence", detail: `Evidence receipt(s) are not present in this run: ${missingEvidence.join(", ")}.` });
       }
     }
+    const claimHasGap = gaps.slice(gapsBeforeClaim).some((gap) => gap.claimId === claim.id);
+    const attainedState = claim.state === "blocked" ? "blocked" : claimHasGap ? "unproven" : claim.state;
     return {
       id: claim.id,
       state: claim.state,
+      attainedState,
       evidenceIds: claim.evidenceIds,
-      missingAcceptanceIds
+      missingAcceptanceIds,
+      missingInspectionIds,
+      missingContradictionCheckIds
     };
   });
   return {
@@ -571861,7 +571991,7 @@ function renderDeliveryCoverageState(evaluation, sourcePath) {
     `sha256=${evaluation.manifestHash}`,
     `completion_ready=${evaluation.completionReady}`,
     "claims:",
-    ...evaluation.claimStates.slice(0, 12).map((claim) => `- id=${claim.id} state=${claim.state} evidence=${claim.evidenceIds.join(",") || "none"} missing_acceptance=${claim.missingAcceptanceIds.join(",") || "none"}`),
+    ...evaluation.claimStates.slice(0, 12).map((claim) => `- id=${claim.id} state=${claim.state} attained=${claim.attainedState} evidence=${claim.evidenceIds.join(",") || "none"} missing_inspection=${claim.missingInspectionIds.join(",") || "none"} missing_contradiction=${claim.missingContradictionCheckIds.join(",") || "none"} missing_acceptance=${claim.missingAcceptanceIds.join(",") || "none"}`),
     "gaps:",
     ...evaluation.gaps.length > 0 ? evaluation.gaps.slice(0, 12).map((gap) => `- [${gap.code}] ${gap.claimId}: ${gap.detail}`) : ["- none"],
     "Treat this as delivery truth, not a recovery directive. A blocked or simulation-only claim must remain labeled at that state.",
@@ -571869,7 +571999,7 @@ function renderDeliveryCoverageState(evaluation, sourcePath) {
   ];
   return lines.join("\n");
 }
-var deliveryRealityStates, acceptanceLayers, sourceSchema, contractSchema, acceptanceSchema, subjectSchema, claimSchema, deliveryCoverageManifestSchema;
+var deliveryRealityStates, acceptanceLayers, sourceSchema, contractSchema, acceptanceSchema, inspectionSchema, contradictionCheckSchema, subjectSchema, claimSchema, deliveryCoverageManifestSchema;
 var init_deliveryCoverage = __esm({
   "packages/orchestrator/dist/deliveryCoverage.js"() {
     "use strict";
@@ -571911,6 +572041,17 @@ var init_deliveryCoverage = __esm({
       verificationCommands: z17.array(z17.string().min(1)).min(1),
       safetyInterlock: z17.string().min(1).optional()
     });
+    inspectionSchema = z17.object({
+      id: z17.string().min(1),
+      boundary: z17.string().min(1),
+      targetPaths: z17.array(z17.string().min(1)).min(1),
+      proves: z17.string().min(1)
+    });
+    contradictionCheckSchema = z17.object({
+      id: z17.string().min(1),
+      question: z17.string().min(1),
+      inspectionIds: z17.array(z17.string().min(1)).min(1)
+    });
     subjectSchema = z17.object({
       productSeries: z17.string().min(1),
       commands: z17.array(z17.string().min(1)).default([]),
@@ -571925,13 +572066,21 @@ var init_deliveryCoverage = __esm({
       sourceIds: z17.array(z17.string().min(1)).min(1),
       evidenceIds: z17.array(z17.string().min(1)).default([]),
       requiredAcceptanceIds: z17.array(z17.string().min(1)).default([]),
+      /** Source boundaries that must be freshly read before this claim is true. */
+      requiredInspectionIds: z17.array(z17.string().min(1)).default([]),
+      /** Falsification checks that must be grounded in those source inspections. */
+      requiredContradictionCheckIds: z17.array(z17.string().min(1)).default([]),
       blockedReason: z17.string().min(1).optional()
     });
     deliveryCoverageManifestSchema = z17.object({
-      schemaVersion: z17.literal(1),
+      // Version 1 remains readable for existing workspaces. Version 2 activates
+      // claim-driven source inspection and falsification gates.
+      schemaVersion: z17.union([z17.literal(1), z17.literal(2)]),
       sources: z17.array(sourceSchema),
       contracts: z17.array(contractSchema),
       acceptance: z17.array(acceptanceSchema),
+      inspections: z17.array(inspectionSchema).default([]),
+      contradictionChecks: z17.array(contradictionCheckSchema).default([]),
       claims: z17.array(claimSchema)
     });
   }
@@ -575540,6 +575689,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 +576413,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 +591636,7 @@ var init_agenticRunner = __esm({
     init_personality();
     init_promptLoader();
     init_reference_contracts();
+    init_phase_skill_guidance();
     init_deliveryCoverage();
     init_critic();
     init_reflection();
@@ -592143,6 +592295,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 +593134,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 +593196,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)))
@@ -593476,16 +593661,29 @@ evidence=${record.evidenceIds.join(",") || "none"}`
         const loaded = loadDeliveryCoverageManifest(this.authoritativeWorkingDirectory());
         if (!loaded)
           return null;
+        for (const entry of this._evidenceLedger.snapshot(200)) {
+          this._evidenceLedger.validateFreshness(entry.path, _pathResolve(this.authoritativeWorkingDirectory(), entry.path));
+        }
         const evidence = this._completionLedger?.evidence.map((entry) => ({
           id: entry.id,
           success: entry.success,
           receipt: entry.receipt
         })) ?? [];
-        const evaluated = evaluateDeliveryCoverage(loaded.manifest, evidence);
+        const sourceObservations = this._evidenceLedger.snapshot(200).map((entry) => ({
+          path: entry.path,
+          contentHash: entry.contentHash,
+          fidelity: entry.fidelity,
+          stale: entry.stale
+        }));
+        const evaluated = evaluateDeliveryCoverage(loaded.manifest, evidence, sourceObservations);
+        const firstInspectionGap = evaluated.gaps.find((gap) => gap.code === "missing_inspection" || gap.code === "stale_inspection" || gap.code === "missing_contradiction_check");
         return {
           rendered: renderDeliveryCoverageState(evaluated, loaded.path),
           gaps: evaluated.gaps.map((gap) => `[${gap.code}] ${gap.claimId}: ${gap.detail}`),
-          completionReady: evaluated.completionReady
+          completionReady: evaluated.completionReady,
+          ...firstInspectionGap ? { nextInspection: firstInspectionGap.detail } : {},
+          sourcePath: loaded.path,
+          evaluation: evaluated
         };
       }
       _modelCapabilityProfile() {
@@ -593517,6 +593715,24 @@ evidence=${record.evidenceIds.join(",") || "none"}`
         this._completionLedger = {
           ...this._completionLedger,
           unresolved: [...retained, ...unresolved],
+          deliveryCoverage: {
+            manifestHash: coverage.evaluation.manifestHash,
+            sourcePath: coverage.sourcePath,
+            evaluatedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+            claims: coverage.evaluation.claimStates.map((claim) => ({
+              id: claim.id,
+              state: claim.state,
+              attainedState: claim.attainedState,
+              missingInspectionIds: [...claim.missingInspectionIds],
+              missingContradictionCheckIds: [...claim.missingContradictionCheckIds],
+              missingAcceptanceIds: [...claim.missingAcceptanceIds]
+            })),
+            gaps: coverage.evaluation.gaps.map((gap) => ({
+              claimId: gap.claimId,
+              code: gap.code,
+              detail: gap.detail
+            }))
+          },
           status: coverage.completionReady && unresolved.length === 0 ? this._completionLedger.status : "incomplete_verification",
           updatedAtIso: (/* @__PURE__ */ new Date()).toISOString()
         };
@@ -594271,10 +594487,10 @@ ${read3.content}`;
             if (!branchDerived && !partialMaterialization && path16) {
               try {
                 const canonicalBody = input.result.output || input.output;
-                const canonicalPath = this._normalizeEvidencePath(path16);
+                const canonicalPath2 = this._normalizeEvidencePath(path16);
                 const sourceRevision = typeof input.result.beforeHash === "string" ? input.result.beforeHash : _createHash("sha256").update(canonicalBody).digest("hex");
                 const stored = this._artifactStore().put({
-                  path: canonicalPath,
+                  path: canonicalPath2,
                   revision: sourceRevision,
                   content: canonicalBody,
                   ranges: [{
@@ -594314,13 +594530,13 @@ ${read3.content}`;
             ledger.linkDependency({ sourceRecordId: artifact.id, targetRecordId: result.id, relation: "derived_from", requiredForActiveWork: true });
             ledger.linkDependency({ sourceRecordId: action.id, targetRecordId: artifact.id, relation: "requires", requiredForActiveWork: true });
             if (!branchDerived && !partialMaterialization && path16) {
-              const canonicalPath = this._normalizeEvidencePath(path16);
-              const previous = this._contextMemoryArtifactByPath.get(canonicalPath);
+              const canonicalPath2 = this._normalizeEvidencePath(path16);
+              const previous = this._contextMemoryArtifactByPath.get(canonicalPath2);
               const currentHash = typeof input.result.beforeHash === "string" ? input.result.beforeHash : void 0;
               if (previous && previous.epoch === epoch && previous.contentHash && currentHash && previous.contentHash !== currentHash) {
                 ledger.supersedeArtifact(previous.recordId, artifact.id);
               }
-              this._contextMemoryArtifactByPath.set(canonicalPath, {
+              this._contextMemoryArtifactByPath.set(canonicalPath2, {
                 recordId: artifact.id,
                 contentHash: currentHash,
                 ...canonicalArtifactReference ? { artifactReference: canonicalArtifactReference } : {},
@@ -600124,7 +600340,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";
@@ -600133,7 +600354,15 @@ ${String(concreteGoal).replace(/\s+/g, " ").trim().slice(0, 1200)}` : null
           tier: this.options.modelTier ?? "large",
           includeCore: false,
           includePhase: true,
-          includeExplicit: false
+          includeExplicit: false,
+          includeDeliverySurface: Boolean(deliveryCoverageBlock)
+        });
+        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,
@@ -600242,6 +600471,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 +600652,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 +601946,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) {
@@ -601911,12 +602155,12 @@ ${notice}`;
           this._emitSteeringLifecycle(record, gatesOldPlan ? `admitted at turn ${turn}; old-plan actions are gated pending structured reconciliation` : `admitted at turn ${turn}; awaiting structured reconciliation`);
         }
       }
-      _canonicalReadEvidencePayload(canonicalPath, contentHash2) {
-        const evidence = this._evidenceLedger.get(canonicalPath);
+      _canonicalReadEvidencePayload(canonicalPath2, contentHash2) {
+        const evidence = this._evidenceLedger.get(canonicalPath2);
         if (evidence && !evidence.stale && evidence.contentHash === contentHash2 && evidence.fidelity === "full" && this._mustHonorExplicitFullFileRead(Buffer.byteLength(evidence.content, "utf8"), evidence.content.split("\n").length, this._branchRoutingContextWindow())) {
           return evidence.content;
         }
-        const branch = this._branchEvidenceByPath.get(canonicalPath);
+        const branch = this._branchEvidenceByPath.get(canonicalPath2);
         if (branch && branch.contentHash === contentHash2 && branch.taskEpoch === this._taskEpoch && branch.contractComplete) {
           return branch.output;
         }
@@ -602367,17 +602611,17 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
         }
       }
       _evictInlineReadArtifacts(messages2, path16, contentHash2, reason) {
-        const canonicalPath = this._normalizeEvidencePath(path16);
+        const canonicalPath2 = this._normalizeEvidencePath(path16);
         let evicted = 0;
         for (const [callId, artifact] of this._inlineReadArtifacts) {
-          if (artifact.path !== canonicalPath || artifact.contentHash !== contentHash2) {
+          if (artifact.path !== canonicalPath2 || artifact.contentHash !== contentHash2) {
             continue;
           }
           const message2 = messages2.find((candidate) => candidate.role === "tool" && candidate.tool_call_id === artifact.callId);
           if (message2) {
             message2.content = [
               "[FULL_FILE_READ_EVICTED]",
-              `path=${canonicalPath}`,
+              `path=${canonicalPath2}`,
               `sha256=${contentHash2}`,
               `reason=${reason}`,
               "The full body was deliberately removed after a verified evidence extraction. Use the newer anchored extraction result; re-read only if the file changes or a distinct range is required."
@@ -602480,15 +602724,15 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
           purpose: typeof input.args["purpose"] === "string" ? input.args["purpose"] : void 0
         });
         const contractFingerprint = _createHash("sha256").update(JSON.stringify(branchBrief.discoveryContract ?? branchBrief)).digest("hex").slice(0, 20);
-        const canonicalPath = this._normalizeEvidencePath(rawPath);
-        const branchRequestId = `branch:${this._taskEpoch}:${_createHash("sha256").update(`${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`).digest("hex").slice(0, 20)}`;
-        const cacheKey = `${this._taskEpoch}|${canonicalPath}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
+        const canonicalPath2 = this._normalizeEvidencePath(rawPath);
+        const branchRequestId = `branch:${this._taskEpoch}:${_createHash("sha256").update(`${canonicalPath2}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`).digest("hex").slice(0, 20)}`;
+        const cacheKey = `${this._taskEpoch}|${canonicalPath2}|${fullHash}|${offset ?? 0}:${limit ?? "EOF"}|${contractFingerprint}`;
         const cached2 = this._branchEvidenceCache.get(cacheKey);
         if (cached2?.contractComplete) {
           const fingerprint2 = this._buildToolFingerprint(input.toolName, input.args);
           const rehydrated = this._rehydrateResolvedReadEvidence({
             fingerprint: fingerprint2,
-            canonicalPath,
+            canonicalPath: canonicalPath2,
             contentHash: fullHash,
             payload: cached2.output,
             turn: input.turn
@@ -602501,7 +602745,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
           if (explicitExtraction) {
-            this._evictInlineReadArtifacts(input.messages, canonicalPath, fullHash, "verified_branch_extract_cache");
+            this._evictInlineReadArtifacts(input.messages, canonicalPath2, fullHash, "verified_branch_extract_cache");
           }
           return {
             success: true,
@@ -602519,7 +602763,7 @@ The steering reconciliation was emitted this turn. Wait for the next model decis
               schema: "omnius.branch-evidence.v1",
               requestId: cached2.requestId,
               taskEpoch: this._taskEpoch,
-              path: canonicalPath,
+              path: canonicalPath2,
               contentHash: fullHash,
               sourceRange: {
                 startLine: startIndex + 1,
@@ -602587,7 +602831,7 @@ ${suffix}`.slice(0, outputBudgetChars);
         }
         this._branchEvidenceCache.set(cacheKey, {
           output,
-          path: canonicalPath,
+          path: canonicalPath2,
           contentHash: fullHash,
           sourceBytes: stat9.size,
           createdAt: Date.now(),
@@ -602602,7 +602846,7 @@ ${suffix}`.slice(0, outputBudgetChars);
             searchRounds: ev.provenance.searchRounds.length
           }
         });
-        this._branchEvidenceByPath.set(canonicalPath, {
+        this._branchEvidenceByPath.set(canonicalPath2, {
           output,
           contentHash: fullHash,
           mtimeMs: stat9.mtimeMs,
@@ -602612,12 +602856,12 @@ ${suffix}`.slice(0, outputBudgetChars);
           unresolvedRecoveries: ev.requirementCoverage.filter((coverage) => coverage.status === "unresolved").map((coverage) => `${coverage.id}: ${coverage.recovery ?? "narrow recovery required"}`)
         });
         if (explicitExtraction) {
-          const evicted = this._evictInlineReadArtifacts(input.messages, canonicalPath, fullHash, "verified_branch_extract");
+          const evicted = this._evictInlineReadArtifacts(input.messages, canonicalPath2, fullHash, "verified_branch_extract");
           if (evicted > 0) {
             this.emit({
               type: "status",
               toolName: input.toolName,
-              content: `Full read context evicted after verified branch extraction: ${canonicalPath} sha256=${fullHash.slice(0, 12)} artifacts=${evicted}`,
+              content: `Full read context evicted after verified branch extraction: ${canonicalPath2} sha256=${fullHash.slice(0, 12)} artifacts=${evicted}`,
               turn: input.turn,
               timestamp: (/* @__PURE__ */ new Date()).toISOString()
             });
@@ -602647,7 +602891,7 @@ ${suffix}`.slice(0, outputBudgetChars);
             schema: "omnius.branch-evidence.v1",
             requestId: branchRequestId,
             taskEpoch: this._taskEpoch,
-            path: canonicalPath,
+            path: canonicalPath2,
             contentHash: fullHash,
             sourceRange: {
               startLine: startIndex + 1,
@@ -603489,6 +603733,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 +603940,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);
@@ -604411,6 +604657,34 @@ ${dynamicProjectContext}`
           messages2.push({ role: "system", content: feedback });
           return true;
         };
+        const holdDeliveryCoverageTaskComplete = (turn) => {
+          const coverage = this._deliveryCoverageState();
+          if (!coverage || coverage.completionReady)
+            return false;
+          this._reconcileDeliveryCoverageForCompletion();
+          this._saveCompletionLedgerSafe();
+          const gaps = coverage.gaps.slice(0, 6);
+          const feedback = [
+            "[COMPLETION BLOCKED — delivery claim evidence incomplete]",
+            "A declared delivery claim cannot be promoted beyond its current evidence state.",
+            "Open claim deltas:",
+            ...gaps.length > 0 ? gaps.map((gap) => `  - ${gap}`) : ["  - delivery coverage is not completion-ready"],
+            "",
+            coverage.nextInspection ? `Smallest next observation: ${coverage.nextInspection}` : "Run the missing canonical acceptance command or mark the claim blocked with its real prerequisite.",
+            "Do not replace a missing source inspection with a grep/listing, partial read, or prose summary."
+          ].join("\n");
+          lastCompletionGateReason = gaps.join("; ") || "delivery claim evidence incomplete";
+          lastCompletionGateFeedback = feedback;
+          lastCompletionGateCode = "delivery_coverage";
+          messages2.push({ role: "system", content: feedback });
+          this.emit({
+            type: "status",
+            content: `task_complete held by delivery coverage gate: ${lastCompletionGateReason.slice(0, 360)}`,
+            turn,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          return true;
+        };
         const completionHoldEscapeMax = (() => {
           const raw = Number(process.env["OMNIUS_COMPLETION_HOLD_MAX"]);
           return Number.isFinite(raw) && raw >= 1 ? Math.floor(raw) : 3;
@@ -604459,7 +604733,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
             lastCompletionGateCode = "";
             return true;
           }
-          const held = holdCompileFixLoopTaskComplete(turn) || holdUnresolvedVerificationTaskComplete(turn) || holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn);
+          const held = holdDeliveryCoverageTaskComplete(turn) || holdCompileFixLoopTaskComplete(turn) || holdUnresolvedVerificationTaskComplete(turn) || holdNoProgressTaskComplete(args, turn) || holdProvenanceTaskComplete(args, turn);
           if (!held) {
             this._completionHoldState.count = 0;
             this._completionHoldState.lastKey = "";
@@ -604471,7 +604745,7 @@ ${lastCompletionGateFeedback.trim().slice(0, 4e3)}` : ""
           this._focusSupervisor?.markCompletionBlocked({
             turn,
             reason: lastCompletionGateReason || "completion requested before required evidence was present",
-            requiredNextAction: lastCompletionGateCode === "compile_error_fix_loop" ? "run_verification" : lastCompletionGateCode === "todo_verification" ? "run_verification" : "update_todos"
+            requiredNextAction: lastCompletionGateCode === "delivery_coverage" ? "read_authoritative_target" : lastCompletionGateCode === "compile_error_fix_loop" ? "run_verification" : lastCompletionGateCode === "todo_verification" ? "run_verification" : "update_todos"
           });
           const focusDirective = this._focusSupervisor?.snapshot().directive;
           if (focusDirective) {
@@ -605314,8 +605588,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 +605752,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 +605900,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 +607974,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 +610335,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`,
@@ -614395,15 +614698,15 @@ ${telegramPersonaHead}` : stripped
           }).slice(0, maxRecoverFiles);
           let recoveredTokens = 0;
           for (const [filePath, entry] of entries) {
-            const canonicalPath = this._normalizeEvidencePath(filePath);
-            if (alreadyVisiblePaths.has(canonicalPath))
+            const canonicalPath2 = this._normalizeEvidencePath(filePath);
+            if (alreadyVisiblePaths.has(canonicalPath2))
               continue;
             try {
               const { readFileSync: readFileSync147 } = await import("node:fs");
               const absolutePath = this._absoluteToolPath(filePath);
               const content = readFileSync147(absolutePath, "utf8");
               const tokenEst = Math.ceil(content.length / 4);
-              const branchNode = this._branchEvidenceByPath.get(canonicalPath);
+              const branchNode = this._branchEvidenceByPath.get(canonicalPath2);
               const currentMtime = this._statMtimeMsForToolPath(filePath) ?? 0;
               const smallCompleteSource = this._mustHonorExplicitFullFileRead(Buffer.byteLength(content, "utf8"), content.split("\n").length, this._branchRoutingContextWindow());
               if (smallCompleteSource) {
@@ -614416,7 +614719,7 @@ ${telegramPersonaHead}` : stripped
 ${content}
 </recovered-file>`
                 });
-                alreadyVisiblePaths.add(canonicalPath);
+                alreadyVisiblePaths.add(canonicalPath2);
                 recoveredFiles.push(filePath);
                 recoveredTokens += sourceTokens;
                 continue;
@@ -614436,7 +614739,7 @@ ${branchNode.output}
                 });
                 recoveredFiles.push(filePath);
                 recoveredTokens += nodeTokens;
-                alreadyVisiblePaths.add(canonicalPath);
+                alreadyVisiblePaths.add(canonicalPath2);
                 continue;
               }
               if (branchNode && !branchNode.contractComplete) {
@@ -614445,7 +614748,7 @@ ${branchNode.output}
                 if (recoveredTokens + referenceTokens > fileRecoveryBudget)
                   continue;
                 result.push({ role: "system", content: partialReference });
-                alreadyVisiblePaths.add(canonicalPath);
+                alreadyVisiblePaths.add(canonicalPath2);
                 recoveredFiles.push(filePath);
                 recoveredTokens += referenceTokens;
                 continue;
@@ -614464,7 +614767,7 @@ ${branchNode.output}
                 const referenceTokens = Math.ceil(reference.length / 4);
                 if (recoveredTokens + referenceTokens <= fileRecoveryBudget) {
                   result.push({ role: "system", content: reference });
-                  alreadyVisiblePaths.add(canonicalPath);
+                  alreadyVisiblePaths.add(canonicalPath2);
                   recoveredFiles.push(filePath);
                   recoveredTokens += referenceTokens;
                 }
@@ -614828,6 +615131,7 @@ ${trimmedNew}`;
             ...coverage?.gaps.slice(0, 3) ?? []
           ].filter(Boolean).join(" | ") || "none"}`,
           `surviving_blockers=${[...blockedTodos, ...coverage?.gaps.slice(0, 3) ?? []].join(" | ") || "none"}`,
+          `next_claim_inspection=${coverage?.nextInspection?.replace(/\s+/g, " ").slice(0, 420) || "none"}`,
           `evidence_handles=${evidenceHandles.join(",") || "none"}`
         ];
         const tier = this.options.modelTier ?? "large";

package/npm-shrinkwrap.json

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

package/package.json

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

package/prompts/reference-contracts/34_delivery_surface_and_claims.md

@@ -50,7 +50,13 @@ correctness, transport routing, CAN fragmentation, or actuator behavior.
 ## Product and provenance coverage
 
 If `.omnius/delivery-coverage.json` is present, it is the structured claim
-contract. Read its gaps and keep final wording within the declared state.
+contract. Read its gaps and keep final wording within the declared state. For
+schema version 2, each non-blocked claim must name fresh, full, content-hashed
+source inspections for every relevant boundary and at least one named
+contradiction check grounded in those inspections. A grep result, directory
+listing, partial read, stale read, or a summary of source does not satisfy an
+inspection. Treat the first missing inspection as the next discovery action;
+this is a state delta, not a standing recovery instruction.
 Every product series, command, parameter, and model format claimed as
 supported must map to exactly one source-backed contract and provenance record.
 Each selected acceptance layer must also name its canonical verification