omnius 1.0.570 → 1.0.571

package/dist/index.js

@@ -327301,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);
@@ -505227,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,
@@ -508521,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();
               },
@@ -571564,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({
@@ -571711,10 +571718,10 @@ var init_phase_skill_guidance = __esm({
     "use strict";
     init_dist5();
     PHASE_FOCUS = {
-      explore: "repository discovery requirements analysis source inspection provenance",
-      plan: "requirements planning architecture design acceptance criteria risk analysis",
+      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 release documentation consistency",
+      verify: "verification validation acceptance tests evidence receipts release documentation consistency",
       mixed: "implementation verification testing code review evidence"
     };
   }
@@ -571725,6 +571732,9 @@ 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();
@@ -571770,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}'.` });
@@ -571801,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}'.` });
@@ -571854,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)));
@@ -571884,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 {
@@ -571916,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.",
@@ -571924,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";
@@ -571966,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([]),
@@ -571980,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)
     });
   }
@@ -593567,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() {
@@ -593608,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()
         };
@@ -594362,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: [{
@@ -594405,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 } : {},
@@ -600229,7 +600354,8 @@ ${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(),
@@ -602029,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;
         }
@@ -602485,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."
@@ -602598,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
@@ -602619,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,
@@ -602637,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,
@@ -602705,7 +602831,7 @@ ${suffix}`.slice(0, outputBudgetChars);
         }
         this._branchEvidenceCache.set(cacheKey, {
           output,
-          path: canonicalPath,
+          path: canonicalPath2,
           contentHash: fullHash,
           sourceBytes: stat9.size,
           createdAt: Date.now(),
@@ -602720,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,
@@ -602730,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()
             });
@@ -602765,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,
@@ -604531,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;
@@ -604579,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 = "";
@@ -604591,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) {
@@ -614544,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) {
@@ -614565,7 +614719,7 @@ ${telegramPersonaHead}` : stripped
 ${content}
 </recovered-file>`
                 });
-                alreadyVisiblePaths.add(canonicalPath);
+                alreadyVisiblePaths.add(canonicalPath2);
                 recoveredFiles.push(filePath);
                 recoveredTokens += sourceTokens;
                 continue;
@@ -614585,7 +614739,7 @@ ${branchNode.output}
                 });
                 recoveredFiles.push(filePath);
                 recoveredTokens += nodeTokens;
-                alreadyVisiblePaths.add(canonicalPath);
+                alreadyVisiblePaths.add(canonicalPath2);
                 continue;
               }
               if (branchNode && !branchNode.contractComplete) {
@@ -614594,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;
@@ -614613,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;
                 }
@@ -614977,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.570",
+  "version": "1.0.571",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.570",
+      "version": "1.0.571",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.570",
+  "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