omnius 1.0.572 → 1.0.573

package/dist/index.js

@@ -468840,7 +468840,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             }
           }
           return result;
-          function escapeRegExp3(str) {
+          function escapeRegExp4(str) {
             return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
           }
           function getTodoCommentsRegExp() {
@@ -468848,7 +468848,7 @@ ${newComment.split("\n").map((c9) => ` * ${c9}`).join("\n")}
             const multiLineCommentStart = /(?:\/\*+\s*)/.source;
             const anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
             const preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
-            const literals = "(?:" + map2(descriptors, (d2) => "(" + escapeRegExp3(d2.text) + ")").join("|") + ")";
+            const literals = "(?:" + map2(descriptors, (d2) => "(" + escapeRegExp4(d2.text) + ")").join("|") + ")";
             const endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
             const messageRemainder = /(?:.*?)/.source;
             const messagePortion = "(" + literals + messageRemainder + ")";
@@ -568001,6 +568001,9 @@ function setClaimDiscoveryState(ledger, state) {
 function claimDiscoveryStateFromSurvey(input) {
   const normalizedInventory = input.boundedInventory;
   const paths = [...new Set((Array.isArray(input.candidatePaths) ? input.candidatePaths : []).map((value2) => normalizeEvidencePath(value2)).filter(Boolean).slice(0, 16))];
+  const requestedRequiredPaths = input.requiredArtifactPaths === void 0 ? paths : input.requiredArtifactPaths;
+  const requiredPathSet = new Set((Array.isArray(requestedRequiredPaths) ? requestedRequiredPaths : []).map((value2) => normalizeEvidencePath(value2)).filter((path16) => paths.includes(path16)));
+  const requiredArtifactPaths = paths.filter((path16) => requiredPathSet.has(path16));
   const reasons = /* @__PURE__ */ Object.create(null);
   for (const [rawPath, rawReason] of Object.entries(input.pathReasons ?? {})) {
     const path16 = normalizeEvidencePath(rawPath);
@@ -568008,7 +568011,7 @@ function claimDiscoveryStateFromSurvey(input) {
     if (path16)
       reasons[path16] = reason || "candidate selected from bounded workspace inventory";
   }
-  const openDeltas = paths.map((path16) => ({
+  const openDeltas = requiredArtifactPaths.map((path16) => ({
     path: path16,
     reason: reasons[path16] || "candidate selected from bounded workspace inventory"
   }));
@@ -568016,7 +568019,7 @@ function claimDiscoveryStateFromSurvey(input) {
   const blockers = Array.isArray(input.survivingBlockers) ? input.survivingBlockers.map((item) => cleanText(item, 220)).filter(Boolean) : [];
   const hasBlockers = blockers.length > 0;
   const hasQuestions = unresolved.length > 0;
-  const resolvedStatus = paths.length === 0 ? hasBlockers || hasQuestions ? "blocked" : "skipped" : hasBlockers || hasQuestions ? "blocked" : "active";
+  const resolvedStatus = requiredArtifactPaths.length === 0 ? hasBlockers || hasQuestions ? "blocked" : "skipped" : hasBlockers || hasQuestions ? "blocked" : "active";
   return {
     status: resolvedStatus,
     generatedAtIso: nowIso3(),
@@ -568024,13 +568027,14 @@ function claimDiscoveryStateFromSurvey(input) {
     context: cleanText(input.context, 480),
     boundedInventory: normalizedInventory,
     candidatePaths: paths,
+    requiredArtifactPaths,
     pathReasons: reasons,
     unresolvedQuestions: unresolved.slice(0, 10),
     openDeltas,
     survivingBlockers: blockers.slice(0, 8),
-    evidenceHandles: [...new Set(paths.map((path16) => `workspace:${path16}`))],
+    evidenceHandles: [...new Set(requiredArtifactPaths.map((path16) => `workspace:${path16}`))],
     resolvedEvidenceHandles: [],
-    requiresEvidence: typeof input.requiresEvidence === "boolean" ? input.requiresEvidence : true
+    requiresEvidence: typeof input.requiresEvidence === "boolean" ? input.requiresEvidence : requiredArtifactPaths.length > 0
   };
 }
 function nowIso3(now2 = /* @__PURE__ */ new Date()) {
@@ -568240,6 +568244,9 @@ function claimDiscoveryControllerSignals(stage2) {
   const unresolvedQuestions = stage2.unresolvedQuestions ?? [];
   const boundedInventory = stage2.boundedInventory;
   const boundedDirs = boundedInventory?.dirs ?? [];
+  const requiredArtifactPaths = stage2.requiredArtifactPaths ?? stage2.candidatePaths ?? [];
+  const requiredSet = new Set(requiredArtifactPaths);
+  const exploratoryPaths = (stage2.candidatePaths ?? []).filter((path16) => !requiredSet.has(path16));
   const resolvedCount = Math.min(evidenceHandles.length, new Set(resolvedEvidenceHandles).size);
   const unresolvedEvidenceCount = Math.max(evidenceHandles.length - resolvedCount, 0);
   return [
@@ -568247,7 +568254,8 @@ function claimDiscoveryControllerSignals(stage2) {
     `status=${stage2.status ?? "skipped"} generated_at=${stage2.generatedAtIso ?? ""}`,
     `requires_evidence=${stage2.requiresEvidence ? "true" : "false"}`,
     `bounded_inventory=${boundedInventory ? `${boundedInventory.root}|files=${boundedInventory.files.length}|dirs=${boundedDirs.length}|truncated=${Boolean(boundedInventory.truncated)}` : "none"}`,
-    `candidate_paths=${(stage2.candidatePaths ?? []).join(",") || "none"}`,
+    `required_artifact_paths=${requiredArtifactPaths.join(",") || "none"}`,
+    `exploratory_paths=${exploratoryPaths.join(",") || "none"}`,
     `open_deltas=${openDeltas.map((delta) => `${delta.path} :: ${delta.reason}`.replace(/\s+/g, " ")).join(" | ") || "none"}`,
     `open_delta_count=${openDeltas.length} unresolved_evidence_count=${unresolvedEvidenceCount}`,
     `surviving_blockers=${survivingBlockers.join(" | ") || "none"}`,
@@ -568438,7 +568446,10 @@ function buildCriticPacketFromLedger(ledger) {
     lines.push("Claim Discovery:");
     lines.push(`  status=${ledger.claimDiscovery.status}`);
     lines.push(`  generated_at=${ledger.claimDiscovery.generatedAtIso}`);
-    lines.push(`  candidate_paths=${ledger.claimDiscovery.candidatePaths.join(",") || "none"}`);
+    const requiredArtifactPaths = ledger.claimDiscovery.requiredArtifactPaths ?? ledger.claimDiscovery.candidatePaths;
+    const exploratoryPaths = ledger.claimDiscovery.candidatePaths.filter((path16) => !requiredArtifactPaths.includes(path16));
+    lines.push(`  exploratory_paths=${exploratoryPaths.join(",") || "none"}`);
+    lines.push(`  required_artifact_paths=${requiredArtifactPaths.join(",") || "none"}`);
     lines.push(`  open_deltas=${ledger.claimDiscovery.openDeltas.map((delta) => `${delta.path} :: ${delta.reason}`).slice(0, 10).join(" | ") || "none"}`);
     lines.push(`  surviving_blockers=${ledger.claimDiscovery.survivingBlockers.join(" | ") || "none"}`);
     lines.push(`  unresolved_questions=${ledger.claimDiscovery.unresolvedQuestions.join(" | ") || "none"}`);
@@ -568558,7 +568569,7 @@ function claimDiscoveryResolvedHandles(ledger, state) {
   if (!state)
     return [];
   const inspected = /* @__PURE__ */ new Set();
-  const candidatePaths = [...state.candidatePaths].map((value2) => normalizeEvidencePath(value2)).filter(Boolean).map((path16) => path16.replace(/^\/+/, ""));
+  const candidatePaths = [...state.requiredArtifactPaths ?? state.candidatePaths].map((value2) => normalizeEvidencePath(value2)).filter(Boolean).map((path16) => path16.replace(/^\/+/, ""));
   for (const entry of ledger.evidence) {
     if (entry.success !== true)
       continue;
@@ -569145,6 +569156,10 @@ import { createHash as createHash28 } from "node:crypto";
 function clean3(value2, max) {
   return String(value2 ?? "").replace(/\s+/g, " ").trim().slice(0, max);
 }
+function isValidObservationReceipt(entry) {
+  const receipt = entry.receipt;
+  return entry.success === true && entry.role === "observation" && receipt?.schema === "omnius.command-evidence-receipt.v1" && Boolean(receipt.canonicalCommand.trim()) && Boolean(receipt.cwd.trim()) && receipt.exitCode === 0 && receipt.timedOut === false;
+}
 function selectedEvidence(ledger) {
   if (!ledger) {
     return {
@@ -569153,7 +569168,7 @@ function selectedEvidence(ledger) {
       artifactHashes: []
     };
   }
-  const candidates = ledger.evidence.filter((entry) => entry.success === true && (entry.role === "verification" || entry.role === "mutation")).slice(-16);
+  const candidates = ledger.evidence.filter((entry) => entry.success === true && (entry.role === "verification" || entry.role === "mutation" || isValidObservationReceipt(entry))).slice(-16);
   const artifacts = /* @__PURE__ */ new Map();
   const commandReceipts = [];
   for (const entry of candidates) {
@@ -569174,6 +569189,7 @@ function selectedEvidence(ledger) {
         timedOut: Boolean(receipt.timedOut),
         startedAtIso: receipt.startedAtIso ?? "",
         finishedAtIso: receipt.finishedAtIso ?? "",
+        observedPaths: receipt.observedPaths ?? [],
         artifactHashes: entry.receipt.artifactHashes?.length ? entry.receipt.artifactHashes : []
       });
     }
@@ -590943,6 +590959,25 @@ function chunkHasSymbolMatch(token, text2) {
   const tokens = haystack.split(" ").filter(Boolean);
   return tokens.includes(token);
 }
+function escapeRegExp3(value2) {
+  return value2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function shellCommandLooksLikeInspection(command) {
+  const outsideQuotes = stripShellQuotedSegments(command);
+  return /\b(?:cat|sed|head|tail|less|more|awk|grep|rg|file|stat|wc|sha(?:1|224|256|384|512)sum|md5sum|git\s+(?:show|diff))\b/i.test(outsideQuotes);
+}
+function shellCommandReferencesExactPath(command, path16, workspaceRoot) {
+  const normalized = path16.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+  if (!normalized || normalized.includes(".."))
+    return false;
+  const absolute = _pathResolve(workspaceRoot, normalized).replace(/\\/g, "/");
+  const candidates = [normalized, `./${normalized}`, absolute];
+  return candidates.some((candidate) => {
+    const escaped = escapeRegExp3(candidate);
+    const matcher = new RegExp(`(?:^|[\\s"'\`=:(])${escaped}(?=$|[\\s"'\`;|)&,])`);
+    return matcher.test(command);
+  });
+}
 function isCompilerLikeVerifierCommand(command) {
   const normalized = command.toLowerCase();
   return /\b(?:pio|platformio|tsc|gcc|g\+\+|clang\+\+?|clang|cargo\s+(?:build|check)|go\s+(?:build|test)|javac|gradle|mvn|msbuild|dotnet\s+build|python(?:3)?\s+-m\s+(?:py_compile|compileall)|mypy|pyright)\b/.test(normalized);
@@ -597291,11 +597326,17 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           return;
         const realFileMutation = input.realFileMutation ?? this._isRealProjectMutation(input.toolName, input.result);
         const attemptedTargetPaths = this._extractToolTargetPaths(input.toolName, input.args, input.result);
+        const explicitInspectionPaths = this._successfulShellInspectionAnchorPaths(input.toolName, input.result);
+        const evidenceTargetPaths2 = [
+          .../* @__PURE__ */ new Set([...attemptedTargetPaths, ...explicitInspectionPaths])
+        ];
         const realMutationPaths = input.realMutationPaths ?? (realFileMutation ? attemptedTargetPaths : []);
         const receipt = input.result.executionReceipt ? {
           ...input.result.executionReceipt,
+          ...explicitInspectionPaths.length > 0 ? { observedPaths: explicitInspectionPaths } : {},
           artifactHashes: this._completionArtifactHashes([
             ...attemptedTargetPaths,
+            ...explicitInspectionPaths,
             ...realMutationPaths
           ])
         } : void 0;
@@ -597312,8 +597353,8 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           success: input.result.success,
           outputPreview: (input.outputPreview ?? this._toolEvidencePreview(input.result, void 0, 1200, input.toolName)).toString().slice(0, input.toolName === "audio_analyze" || input.toolName === "video_understand" ? 1200 : 500),
           argsKey: input.argsKey.slice(0, 300),
-          targetPaths: attemptedTargetPaths,
-          role: input.result.completionEvidenceRole ?? (input.result.alreadyApplied === true ? "mutation" : realFileMutation ? "mutation" : input.result.runtimeAuthored === true && !shellVerification ? "blocker" : shellVerification ? "verification" : void 0),
+          targetPaths: evidenceTargetPaths2,
+          role: input.result.completionEvidenceRole ?? (input.result.alreadyApplied === true ? "mutation" : realFileMutation ? "mutation" : input.result.runtimeAuthored === true && !shellVerification ? "blocker" : shellVerification ? "verification" : input.result.success === true ? "observation" : void 0),
           family: input.result.completionEvidenceFamily ?? (input.result.runtimeAuthored === true && !shellVerification ? "runtime_control" : shellVerification ? shellVerificationFamily : void 0),
           verificationImpact: input.result.completionVerificationImpact ?? (input.result.alreadyApplied === true ? "neutral" : realFileMutation ? "invalidates" : void 0),
           metrics: input.result.completionEvidenceMetrics,
@@ -597338,14 +597379,38 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
         }
         this._saveCompletionLedgerSafe();
       }
+      /**
+       * Credit a shell read only when it has a trusted successful local receipt
+       * and mentions one of the user's explicit, inventory-resolved artifact
+       * anchors.  This prevents filename/token guesses, echoed path strings, and
+       * arbitrary shell output from becoming discovery evidence.
+       */
+      _successfulShellInspectionAnchorPaths(toolName, result) {
+        if (toolName !== "shell" || result.success !== true)
+          return [];
+        const receipt = result.executionReceipt;
+        if (!receipt || receipt.schema !== "omnius.command-evidence-receipt.v1" || receipt.exitCode !== 0 || receipt.timedOut || !receipt.command.trim() || !receipt.canonicalCommand.trim() || !receipt.cwd.trim()) {
+          return [];
+        }
+        const command = receipt.command;
+        if (!shellCommandLooksLikeInspection(command))
+          return [];
+        const anchors = this._completionLedger?.claimDiscovery?.requiredArtifactPaths ?? [];
+        if (anchors.length === 0)
+          return [];
+        const root = this.authoritativeWorkingDirectory();
+        return anchors.filter((path16) => shellCommandReferencesExactPath(command, path16, root)).slice(0, 16);
+      }
       _refreshClaimDiscoveryStateFromEvidence() {
         if (!this._completionLedger?.claimDiscovery)
           return;
         const state = this._completionLedger.claimDiscovery;
-        const evidenceHandles = state.evidenceHandles ?? [];
+        const legacyUnclassifiedCandidates = !Array.isArray(state.requiredArtifactPaths);
+        const requiredArtifactPaths = legacyUnclassifiedCandidates ? [] : state.requiredArtifactPaths;
+        const evidenceHandles = legacyUnclassifiedCandidates ? [] : state.evidenceHandles ?? [];
         const survivingBlockers = state.survivingBlockers ?? [];
         const unresolvedQuestions = state.unresolvedQuestions ?? [];
-        const openDeltas = state.openDeltas ?? [];
+        const openDeltas = legacyUnclassifiedCandidates ? [] : state.openDeltas ?? [];
         const resolved = claimDiscoveryResolvedHandles(this._completionLedger, state);
         const unresolvedEvidence = evidenceHandles.filter((handle2) => !resolved.includes(handle2));
         const unresolvedHandleSet = new Set(unresolvedEvidence);
@@ -597355,11 +597420,11 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           return unresolvedHandleSet.has(handle2);
         });
         const hasBlockers = survivingBlockers.length > 0;
-        const hasCandidates = state.candidatePaths.length > 0;
+        const hasRequiredAnchors = evidenceHandles.length > 0;
         const hasOpenQuestions = unresolvedQuestions.length > 0;
         const hasOpenEvidence = unresolvedEvidence.length > 0;
         let status;
-        if (!hasCandidates) {
+        if (!hasRequiredAnchors) {
           status = hasBlockers || hasOpenQuestions ? "blocked" : "skipped";
         } else if (hasOpenEvidence || hasOpenQuestions || hasBlockers) {
           status = hasOpenQuestions || hasBlockers ? "blocked" : "active";
@@ -597370,12 +597435,14 @@ ${modelVisible}` : modelVisible || result.error || displayOutput || "";
           ...this._completionLedger,
           claimDiscovery: {
             ...state,
+            requiredArtifactPaths,
             openDeltas: unresolvedOpenDeltas,
             resolvedEvidenceHandles: resolved,
             evidenceHandles,
             survivingBlockers,
             unresolvedQuestions,
-            status
+            status,
+            requiresEvidence: legacyUnclassifiedCandidates ? false : state.requiresEvidence
           }
         };
         this._completionLedger = updated;
@@ -603687,11 +603754,13 @@ ${rawTask}`;
         const survivingBlockers = unmatchedHints.size > 0 ? [
           `Unmatched explicit task hints: ${[...unmatchedHints].slice(0, 3).join(", ")}`
         ] : [];
-        const shouldRequireEvidence = finalCandidatePaths.length > 0 && (explicitPathHints.length > 0 || rankedCandidates.length > 0);
+        const requiredArtifactPaths = [...new Set(explicitCandidates)].slice(0, 8);
+        const shouldRequireEvidence = requiredArtifactPaths.length > 0 || unmatchedHints.size > 0;
         return claimDiscoveryStateFromSurvey({
           request: task,
           boundedInventory,
           candidatePaths: finalCandidatePaths,
+          requiredArtifactPaths,
           pathReasons,
           unresolvedQuestions,
           survivingBlockers,
@@ -634466,7 +634535,11 @@ function mapExecutionToolResult(result) {
     partial: result.partial,
     beforeHash: result.beforeHash,
     afterHash: result.afterHash,
-    evidenceEvents: result.evidenceEvents
+    evidenceEvents: result.evidenceEvents,
+    // Preserve process facts separately from display text.  The orchestrator
+    // uses this receipt for completion evidence; reconstructing it from a
+    // truncated/streamed transcript would be unsound.
+    executionReceipt: result.executionReceipt
   };
 }
 function adaptExecutionTool(tool, options2 = {}) {

package/npm-shrinkwrap.json

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

package/package.json

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