harness-everything 0.36.1 → 0.36.2

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.36.1",
+      "version": "0.36.2",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.36.2](https://github.com/dyphn1/Harness-everything/compare/v0.36.1...v0.36.2) (2026-10-20)
+
+### Bug Fixes
+
+* **doc-lifecycle:** honor poisoned shared destinations inside metadata ([2c69247](https://github.com/dyphn1/Harness-everything/commit/2c69247c3a2e108df945fc91c68fb060ac04e058)), closes [#340](https://github.com/dyphn1/Harness-everything/issues/340)
+* **doc-lifecycle:** keep rejected destination snapshots single-read ([f49b253](https://github.com/dyphn1/Harness-everything/commit/f49b25318f4022d241d91051e1daa51ef61cdff2)), closes [#340](https://github.com/dyphn1/Harness-everything/issues/340)
+* **doc-lifecycle:** single-read the whole-baseline and destination digests ([063a00b](https://github.com/dyphn1/Harness-everything/commit/063a00b4f97c147299a63d7b9b82fc2cbae87bc0)), closes [#340](https://github.com/dyphn1/Harness-everything/issues/340)
+
 ## [0.36.1](https://github.com/dyphn1/Harness-everything/compare/v0.36.0...v0.36.1) (2026-10-20)
 
 ### Bug Fixes
@@ -66,10 +74,12 @@ All notable changes to this project are documented in this file.
 * **doc-evidence:** defer the candidate-inventory prototype check to applicable baseline-only obligations and treat a throwing prototype trap as unknown inventory, so unrelated obligations are never aborted
 * **doc-evidence:** bind baseline-annotated mixed scopes and rename destinations to the captured candidate snapshot for evidence binding, the audit identity, and stale diagnostics, so a later-throwing or later-changing digest accessor cannot disagree with the digest that bound evidence
 * **doc-evidence:** carry the metadata-validated rename destination digest and baseline-path source-absence proof through capture and binding, so a candidate inventory that answers consistently during validation is never re-inspected and cannot abort the check or drift the audit key
+* **doc-evidence:** keep rejected rename destination snapshots single-read, so a throwing or unusable destination digest getter is never re-read and its later values never reach the capture or audit identity, including shared destinations where a poisoned destination is honored inside metadata validation and wins in the audit
 * **doc-evidence:** restrict the validated source-absence audit shortcut to applicable obligations and require every accepted entry sharing a rename destination to agree on the validated own digest, so inapplicable audit identity keeps the legacy read and contradictory shared-destination snapshots fail closed
 * **doc-evidence:** gate the rename destination snapshot on applicability and guard baselinePaths entry inspection, so inapplicable audit identity reports the first legacy digest value and a throwing entry getter or descriptor trap fails the entry closed instead of escaping the checker
 * **doc-evidence:** capture the validated per-path baseline digest during metadata and drive the audit mirror, stale-baseline diagnostics, and binding from that snapshot, so a stateful baseline getter cannot bind a record against a value it started returning only after validation and a throwing inspection is a metadata error instead of an escape
 * **doc-evidence:** key the baseline audit mirror by the metadata-validated path snapshot instead of re-reading `baselinePaths[].path`, so a stateful path accessor read during validation can never make a passing result describe a different baseline identity
+* **doc-evidence:** read the whole-baseline `baseline.digest` and the rename destination's own digest exactly once and validate that captured scalar, so a stateful getter cannot pass validation as one value while evidence binds its later value; identity and destination inspection failures fail closed as structured metadata errors instead of escaping the checker
 
 ## [0.34.0](https://github.com/dyphn1/Harness-everything/compare/v0.33.0...v0.34.0) (2026-10-17)
 

package/ci/mechanism-335-baseline-evidence.test.js

@@ -1877,7 +1877,9 @@ checkCase('335 P3 the metadata-validated rename destination digest is carried wi
   for (const target of [modules, packageModules]) {
     const label = target === modules ? 'canonical' : 'packaged';
     const ctx = prepare('rename', target);
-    const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 3, later: 'throw' });
+    // P3(r4321077631): the destination snapshot reads its own digest exactly once, so a getter
+    // that throws after that single valid read is never reached and the captured B still binds.
+    const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 1, later: 'throw' });
     const artifacts = { ...ctx.artifacts, [RENAME_TO]: counted.entry };
     const record = execRecord(ctx, 'pair-run', 'doc-change:doc-lint', {
       paths: [RENAME_FROM, RENAME_TO], candidatePaths: [], baselinePaths: [RENAME_FROM],
@@ -1892,12 +1894,74 @@ checkCase('335 P3 the metadata-validated rename destination digest is carried wi
     if (!result.artifactDigest.includes(`${RENAME_TO}=${RENAME_CAPTURED}`)) {
       failures.push(`${label}: audit=${result.artifactDigest}`);
     }
-    if (counted.reads() !== 3) failures.push(`${label}: destination reads=${counted.reads()}`);
+    if (counted.reads() !== 1) failures.push(`${label}: destination reads=${counted.reads()}`);
   }
   assert.deepStrictEqual(failures, [],
     `the validated destination digest must be carried: ${failures.join('; ')}`);
 });
 
+// #342 review P3: a destination snapshot rejected during metadata (throwing or unusable own
+// digest) is still a visited snapshot. The capture and audit lanes must never re-read it: the
+// single metadata read stays the only digest read, and a stateful getter cannot ship a later
+// value into the audit identity even though its entry failed.
+checkCase('#342 P3 a rejected destination snapshot is read exactly once even when its digest getter throws', () => {
+  const failures = [];
+  for (const target of [modules, packageModules]) {
+    const label = target === modules ? 'canonical' : 'packaged';
+    const ctx = prepare('rename', target);
+    const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 0, later: 'throw' });
+    const artifacts = { ...ctx.artifacts, [RENAME_TO]: counted.entry };
+    const record = execRecord(ctx, 'move-run', 'doc-change:doc-lint', {
+      paths: [RENAME_FROM, RENAME_TO], candidatePaths: [RENAME_TO], baselinePaths: [RENAME_FROM]
+    });
+    let out;
+    try {
+      out = runDocLint(ctx, target, { artifacts, records: [record] });
+    } catch (error) { failures.push(`${label}: escaped: ${error.message}`); continue; }
+    const result = resultOf(out, 'doc-change:doc-lint');
+    if (result.outcome !== 'none') failures.push(`${label}: outcome=${result.outcome}`);
+    if (!diagnosticCodes(out).includes('candidate-artifacts-invalid')) {
+      failures.push(`${label}: diagnostics=${diagnosticCodes(out)}`);
+    }
+    if (counted.reads() !== 1) failures.push(`${label}: destination reads=${counted.reads()}`);
+    if (!result.artifactDigest.includes(`${RENAME_TO}=missing`)) {
+      failures.push(`${label}: audit=${result.artifactDigest}`);
+    }
+  }
+  assert.deepStrictEqual(failures, [],
+    `a rejected throwing destination must be read once and never again: ${failures.join('; ')}`);
+});
+
+checkCase('#342 P3 an unusable first destination read never ships a later non-empty value into the audit', () => {
+  const failures = [];
+  for (const target of [modules, packageModules]) {
+    const label = target === modules ? 'canonical' : 'packaged';
+    const ctx = prepare('rename', target);
+    // First read: unusable ''. Any later read (which must not happen) returns non-empty
+    // RENAME_LATER, so the audit would describe it if the rejected snapshot were re-read.
+    const counted = countingDigestEntry('', { validReads: 1, later: 'value', laterValue: RENAME_LATER });
+    const artifacts = { ...ctx.artifacts, [RENAME_TO]: counted.entry };
+    const record = execRecord(ctx, 'move-run', 'doc-change:doc-lint', {
+      paths: [RENAME_FROM, RENAME_TO], candidatePaths: [RENAME_TO], baselinePaths: [RENAME_FROM]
+    });
+    let out;
+    try {
+      out = runDocLint(ctx, target, { artifacts, records: [record] });
+    } catch (error) { failures.push(`${label}: escaped: ${error.message}`); continue; }
+    const result = resultOf(out, 'doc-change:doc-lint');
+    if (result.outcome !== 'none') failures.push(`${label}: outcome=${result.outcome}`);
+    if (counted.reads() !== 1) failures.push(`${label}: destination reads=${counted.reads()}`);
+    if (result.artifactDigest.includes(RENAME_LATER)) {
+      failures.push(`${label}: audit describes a later value: ${result.artifactDigest}`);
+    }
+    if (!result.artifactDigest.includes(`${RENAME_TO}=missing`)) {
+      failures.push(`${label}: audit=${result.artifactDigest}`);
+    }
+  }
+  assert.deepStrictEqual(failures, [],
+    `an unusable destination read must stay single-read and 'missing': ${failures.join('; ')}`);
+});
+
 checkCase('335 P3 a stale pair plus a destination-only record stays none under descriptor patience', () => {
   const failures = [];
   for (const target of [modules, packageModules]) {
@@ -2116,10 +2180,12 @@ checkCase('335 P3 two accepted entries sharing a rename destination must agree o
       }
     }
 
-    // Dynamic shared destination: D1 for the first entry's metadata, D2 for the second.
+    // Dynamic shared destination: D1 for the first entry's single-read snapshot, D2 for the
+    // second (the per-entry read advances the getter). P3(r4321077631) made each entry's read
+    // exactly one, so the fixture flips after one valid read.
     {
       const { ctx } = sharedDestinationContext(target);
-      const dynamic = countingDigestEntry(RENAME_CAPTURED, { validReads: 3, later: 'value', laterValue: RENAME_LATER });
+      const dynamic = countingDigestEntry(RENAME_CAPTURED, { validReads: 1, later: 'value', laterValue: RENAME_LATER });
       const artifacts = { ...ctx.artifacts, [RENAME_TO]: dynamic.entry };
       const out = run(artifacts, [
         sharedPairRecord(ctx, 'pair-run', RENAME_CAPTURED),
@@ -2177,6 +2243,69 @@ checkCase('335 P3 two accepted entries sharing a rename destination must agree o
     `shared rename destinations must agree on the validated digest: ${failures.join('; ')}`);
 });
 
+// #342 review P3: a shared rename destination whose snapshot is rejected must stay honored.
+// invalid→valid: the first declaring entry fails its own snapshot; a later declaring entry must
+// fail closed without reading the destination again (one read total, audit 'missing').
+// valid→throw: the first entry carries a validated success; the second declaration's read
+// throws, and the poisoned visited state wins in the audit over the previously seeded success
+// (one read per declaring entry, two total).
+checkCase('#342 P3 a rejected shared destination is never read again and keeps audit precedence', () => {
+  const failures = [];
+  for (const target of [modules, packageModules]) {
+    const label = target === modules ? 'canonical' : 'packaged';
+
+    // invalid→valid: first own read unusable, later reads (which must not happen) valid.
+    {
+      const { ctx, obligations, baseline } = sharedDestinationContext(target);
+      const counted = countingDigestEntry('', { validReads: 1, later: 'value', laterValue: RENAME_CAPTURED });
+      // Read counts are scoped to the obligation under test; unrelated obligations keep the
+      // designed legacy candidate read, exactly as runDocLint's single-obligation runs do.
+      const out = target.checkDocObligations({
+        obligations: obligations.filter(item => item.id === 'doc-change:doc-lint'),
+        artifacts: { ...ctx.artifacts, [RENAME_TO]: counted.entry }, baseline,
+        executionRecords: [sharedPairRecord(ctx, 'pair-run', RENAME_CAPTURED)], reviewRecords: []
+      });
+      const result = resultOf(out, 'doc-change:doc-lint');
+      if (result.outcome !== 'none') failures.push(`${label}/invalid-to-valid: outcome=${result.outcome}`);
+      if (!diagnosticCodes(out).includes('baseline-path-invalid')) {
+        failures.push(`${label}/invalid-to-valid: diagnostics=${diagnosticCodes(out)}`);
+      }
+      if (counted.reads() !== 1) failures.push(`${label}/invalid-to-valid: destination reads=${counted.reads()}`);
+      if (result.artifactDigest.includes(RENAME_CAPTURED)) {
+        failures.push(`${label}/invalid-to-valid: audit describes a later value: ${result.artifactDigest}`);
+      }
+      if (!result.artifactDigest.includes(`${RENAME_TO}=missing`)) {
+        failures.push(`${label}/invalid-to-valid: audit=${result.artifactDigest}`);
+      }
+    }
+
+    // valid→throw: successful first snapshot, then a throwing own read on the second entry.
+    {
+      const { ctx, obligations, baseline } = sharedDestinationContext(target);
+      const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 1, later: 'throw' });
+      const out = target.checkDocObligations({
+        obligations: obligations.filter(item => item.id === 'doc-change:doc-lint'),
+        artifacts: { ...ctx.artifacts, [RENAME_TO]: counted.entry }, baseline,
+        executionRecords: [sharedPairRecord(ctx, 'pair-run', RENAME_CAPTURED)], reviewRecords: []
+      });
+      const result = resultOf(out, 'doc-change:doc-lint');
+      if (result.outcome !== 'none') failures.push(`${label}/valid-to-throw: outcome=${result.outcome}`);
+      if (!diagnosticCodes(out).includes('candidate-artifacts-invalid')) {
+        failures.push(`${label}/valid-to-throw: diagnostics=${diagnosticCodes(out)}`);
+      }
+      if (counted.reads() !== 2) failures.push(`${label}/valid-to-throw: destination reads=${counted.reads()}`);
+      if (result.artifactDigest.includes(RENAME_CAPTURED)) {
+        failures.push(`${label}/valid-to-throw: audit describes a rejected-state value: ${result.artifactDigest}`);
+      }
+      if (!result.artifactDigest.includes(`${RENAME_TO}=missing`)) {
+        failures.push(`${label}/valid-to-throw: audit=${result.artifactDigest}`);
+      }
+    }
+  }
+  assert.deepStrictEqual(failures, [],
+    `a rejected shared destination must stay single-read and audited as 'missing': ${failures.join('; ')}`);
+});
+
 // ---------------------------------------------------------------------------
 // P2 applicability-gated destination snapshot (review r4318520818 at 56f3094):
 // N/A and unknown obligations never bind evidence, so their destination digest
@@ -2220,10 +2349,11 @@ checkCase('335 P2 an inapplicable rename never consumes the destination snapshot
     }
 
     // Positive control: the applicable obligation still captures the destination snapshot
-    // once during metadata and binds against it.
+    // once during metadata and binds against it. P3(r4321077631) made that capture a
+    // single guarded read, so the getter is never consumed beyond its first valid read.
     {
       const ctx = prepare('rename', target);
-      const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 3, later: 'value', laterValue: RENAME_LATER });
+      const counted = countingDigestEntry(RENAME_CAPTURED, { validReads: 1, later: 'throw' });
       const artifacts = { ...ctx.artifacts, [RENAME_TO]: counted.entry };
       const record = {
         ...execRecord(ctx, 'pair-run', 'doc-change:doc-lint', {
@@ -2235,7 +2365,7 @@ checkCase('335 P2 an inapplicable rename never consumes the destination snapshot
       const out = checkArtifacts(ctx, artifacts, { obligations: [obligation], executionRecords: [record] }, target);
       const result = resultOf(out, 'doc-change:doc-lint');
       if (result.outcome !== 'pass') failures.push(`${label}/applicable: outcome=${result.outcome}`);
-      if (counted.reads() !== 3) failures.push(`${label}/applicable: destination getter reads=${counted.reads()}`);
+      if (counted.reads() !== 1) failures.push(`${label}/applicable: destination getter reads=${counted.reads()}`);
     }
   }
   assert.deepStrictEqual(failures, [],
@@ -2687,4 +2817,222 @@ checkCase('335 P2 the audit mirror reports the metadata-validated path snapshot,
     `the audit mirror must use the validated path snapshot: ${failures.join('; ')}`);
 });
 
+//----------------------------------------------------------------------------
+// P2(r4321077631/r4321077638) at 7217b3a: whole-baseline identity and rename
+// destination digests must each be read exactly once — the same scalar is
+// validated and captured, so a stateful getter cannot pass validation as one
+// value while evidence binds its later value.
+//----------------------------------------------------------------------------
+
+const RENAME_OLD = 'docs/adr/old.md';
+const RENAME_NEW = 'docs/adr/new.md';
+const RENAME_BASELINE_DIGEST = sha256('rename whole baseline');
+const RENAME_OLD_BASELINE = sha256('old document baseline content');
+const RENAME_DEST_B = sha256('destination content B');
+const RENAME_DEST_C = sha256('destination content C');
+
+checkCase('335 P2 the whole-baseline digest is validated and captured from one read', () => {
+  const failures = [];
+  for (const target of [modules, packageModules]) {
+    const label = target === modules ? 'canonical' : 'packaged';
+    const PATH = BASELINE_EXAMPLE;
+
+    function runWith(baseline, recordBaseDigest) {
+      return target.checkDocObligations({
+        obligations: [{
+          id: 'doc-change:doc-lint',
+          capability: 'doc-lint',
+          level: 'MUST',
+          applicability: 'applicable',
+          scope: { paths: [PATH], baselinePaths: [{ path: PATH, reason: 'deleted' }] }
+        }],
+        artifacts: {},
+        baseline,
+        executionRecords: [{
+          id: 'tomb-run',
+          obligationId: 'doc-change:doc-lint',
+          command: 'node ci/mechanism-335-baseline-evidence.test.js # tomb-run',
+          exitCode: 0,
+          provenance: 'baseline identity snapshot regression',
+          baseDigest: recordBaseDigest,
+          paths: [PATH],
+          artifactDigests: {},
+          baselineArtifacts: { [PATH]: BASELINE_EXAMPLE_VALUE }
+        }],
+        reviewRecords: []
+      });
+    }
+
+    // Stateful identity getter: validation must use the first read; a record attesting to the
+    // later value cannot pass.
+    {
+      let identityReads = 0;
+      const baseline = {
+        get digest() {
+          identityReads += 1;
+          return identityReads === 1 ? 'baseline-A' : 'baseline-B';
+        },
+        artifacts: { [PATH]: BASELINE_EXAMPLE_VALUE }
+      };
+      let out;
+      try {
+        out = runWith(baseline, 'baseline-B');
+      } catch (error) {
+        failures.push(`${label}/stateful: escaped: ${error.message}`);
+        continue;
+      }
+      const result = out.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (identityReads !== 1) failures.push(`${label}/stateful: identity getter reads=${identityReads}`);
+      if (result.outcome === 'pass') failures.push(`${label}/stateful: a record bound to the later value passed`);
+      if (!out.diagnostics.some(item => item.code === 'stale-base-digest')
+        && !out.diagnostics.some(item => item.code === 'baseline-identity-missing')) {
+        failures.push(`${label}/stateful: diagnostics=${out.diagnostics.map(item => item.code)}`);
+      }
+    }
+
+    // Stable controls: the validated identity binds; a different identity does not.
+    {
+      const passing = runWith(
+        { digest: 'baseline-A', artifacts: { [PATH]: BASELINE_EXAMPLE_VALUE } }, 'baseline-A');
+      if (passing.results.find(item => item.obligationId === 'doc-change:doc-lint').outcome !== 'pass') {
+        failures.push(`${label}/stable: the validated identity did not pass`);
+      }
+      const stale = runWith(
+        { digest: 'baseline-B', artifacts: { [PATH]: BASELINE_EXAMPLE_VALUE } }, 'baseline-A');
+      const staleResult = stale.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (staleResult.outcome !== 'none') failures.push(`${label}/stable: outcome=${staleResult.outcome}`);
+      if (!stale.diagnostics.some(item => item.code === 'stale-base-digest')) {
+        failures.push(`${label}/stable: diagnostics=${stale.diagnostics.map(item => item.code)}`);
+      }
+    }
+
+    // A throwing identity getter fails closed as a metadata error instead of escaping.
+    {
+      const baseline = {
+        get digest() {
+          throw new Error('baseline identity getter');
+        },
+        artifacts: { [PATH]: BASELINE_EXAMPLE_VALUE }
+      };
+      let out;
+      try {
+        out = runWith(baseline, 'baseline-A');
+      } catch (error) {
+        failures.push(`${label}/throwing: escaped: ${error.message}`);
+        continue;
+      }
+      const result = out.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (result.outcome === 'pass') failures.push(`${label}/throwing: a throwing identity produced a pass`);
+      if (!out.diagnostics.some(item => item.code === 'baseline-identity-missing')) {
+        failures.push(`${label}/throwing: diagnostics=${out.diagnostics.map(item => item.code)}`);
+      }
+    }
+  }
+  assert.deepStrictEqual(failures, [],
+    `the whole-baseline identity must be captured once: ${failures.join('; ')}`);
+});
+
+checkCase('335 P2 the rename destination digest is validated and captured from one read', () => {
+  const failures = [];
+  for (const target of [modules, packageModules]) {
+    const label = target === modules ? 'canonical' : 'packaged';
+    const obligation = {
+      id: 'doc-change:doc-lint',
+      capability: 'doc-lint',
+      level: 'MUST',
+      applicability: 'applicable',
+      scope: {
+        paths: [RENAME_OLD, RENAME_NEW],
+        baselinePaths: [{ path: RENAME_OLD, reason: 'rename-from', renameTo: RENAME_NEW }]
+      }
+    };
+    const baseline = {
+      digest: RENAME_BASELINE_DIGEST,
+      artifacts: { [RENAME_OLD]: RENAME_OLD_BASELINE }
+    };
+
+    function runWith(destinationEntry, recordDestinationDigest) {
+      return target.checkDocObligations({
+        obligations: [obligation],
+        artifacts: { [RENAME_NEW]: destinationEntry },
+        baseline,
+        executionRecords: [{
+          id: 'rename-run',
+          obligationId: 'doc-change:doc-lint',
+          command: 'node ci/mechanism-335-baseline-evidence.test.js # rename-run',
+          exitCode: 0,
+          provenance: 'rename destination snapshot regression',
+          baseDigest: RENAME_BASELINE_DIGEST,
+          paths: [RENAME_OLD, RENAME_NEW],
+          artifactDigests: { [RENAME_NEW]: recordDestinationDigest },
+          baselineArtifacts: { [RENAME_OLD]: RENAME_OLD_BASELINE }
+        }],
+        reviewRecords: []
+      });
+    }
+
+    // Stateful destination digest getter: validation must use the first read B; a record
+    // carrying only the later C cannot pass.
+    {
+      let destinationReads = 0;
+      const statefulDestination = {
+        get digest() {
+          destinationReads += 1;
+          return destinationReads === 1 ? RENAME_DEST_B : RENAME_DEST_C;
+        }
+      };
+      let out;
+      try {
+        out = runWith(statefulDestination, RENAME_DEST_C);
+      } catch (error) {
+        failures.push(`${label}/stateful: escaped: ${error.message}`);
+        continue;
+      }
+      const result = out.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (destinationReads !== 1) failures.push(`${label}/stateful: destination digest reads=${destinationReads}`);
+      if (result.outcome === 'pass') failures.push(`${label}/stateful: a record bound to the later value passed`);
+      if (!out.diagnostics.some(item => item.code === 'stale-artifact-digest')) {
+        failures.push(`${label}/stateful: diagnostics=${out.diagnostics.map(item => item.code)}`);
+      }
+    }
+
+    // Stable controls: the validated destination binds its own value; a different value is stale.
+    {
+      const passing = runWith({ digest: RENAME_DEST_B }, RENAME_DEST_B);
+      if (passing.results.find(item => item.obligationId === 'doc-change:doc-lint').outcome !== 'pass') {
+        failures.push(`${label}/stable: the validated destination did not pass; diagnostics=${passing.diagnostics.map(item => item.code)}`);
+      }
+      const stale = runWith({ digest: RENAME_DEST_B }, RENAME_DEST_C);
+      const staleResult = stale.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (staleResult.outcome !== 'none') failures.push(`${label}/stable: outcome=${staleResult.outcome}`);
+      if (!stale.diagnostics.some(item => item.code === 'stale-artifact-digest')) {
+        failures.push(`${label}/stable: diagnostics=${stale.diagnostics.map(item => item.code)}`);
+      }
+    }
+
+    // A throwing destination digest getter fails closed instead of escaping.
+    {
+      const throwingDestination = {
+        get digest() {
+          throw new Error('destination digest getter');
+        }
+      };
+      let out;
+      try {
+        out = runWith(throwingDestination, RENAME_DEST_B);
+      } catch (error) {
+        failures.push(`${label}/throwing: escaped: ${error.message}`);
+        continue;
+      }
+      const result = out.results.find(item => item.obligationId === 'doc-change:doc-lint');
+      if (result.outcome === 'pass') failures.push(`${label}/throwing: a throwing destination produced a pass`);
+      if (!out.diagnostics.some(item => item.code === 'candidate-artifacts-invalid')) {
+        failures.push(`${label}/throwing: diagnostics=${out.diagnostics.map(item => item.code)}`);
+      }
+    }
+  }
+  assert.deepStrictEqual(failures, [],
+    `the rename destination digest must be captured once: ${failures.join('; ')}`);
+});
+
 helper.finish();

package/docs/doc-evidence-baseline-binding.md

@@ -82,10 +82,16 @@ after validation, cannot mute the stale-baseline diagnostic, and cannot drift th
 Its first read must therefore be the value every consumer sees; a getter that starts returning a
 different or unusable value later is factored out entirely. A baseline per-path inspection that
 throws during validation is a `baseline-artifact-invalid` metadata error and fails the path
-closed. The audit mirror is likewise keyed by the **validated** path snapshot rather than a
-re-read of `baselinePaths[].path`, so a stateful `path` accessor is read exactly once and a
-passing result always describes the baseline identity that validated and bound the evidence.
-closed instead of escaping the checker.
+closed instead of escaping the checker. The audit mirror is likewise keyed by the **validated**
+path snapshot rather than a re-read of `baselinePaths[].path`, so a stateful `path` accessor is
+read exactly once and a passing result always describes the baseline identity that validated and
+bound the evidence.
+
+The whole-baseline identity `baseline.digest` follows the same discipline: it is read exactly
+once and that same scalar is validated, so a stateful value cannot be inspected as A while every
+evidence comparison uses B. The rename destination's own digest is also read exactly once during
+its validated snapshot, and the captured value drives the metadata cache, binding, the stale
+diagnostics, and the audit identity.
 
 Per-path evidence must be carried explicitly. Inherited properties in `baseline.artifacts` or a
 record's `baselineArtifacts` are not own-key evidence and never satisfy a path; the trusted
@@ -110,6 +116,11 @@ candidate digest — the same one used by ordinary candidate binding, the audit
 stale diagnostics. The destination is therefore never read again through the candidate map during
 capture or binding: a nested `digest` that throws or changes after validation cannot make a stale
 destination pair bind while the audit/stale verdicts still describe the captured value. The same
+read-once guarantee extends to rejected destination snapshots: when the destination's own digest
+read throws or returns an unusable value, that failed snapshot ('') is recorded and all later
+reads for that destination path are suppressed as well — the entry's single metadata read remains
+its only digest read, and the failed path contributes `path=missing` to `artifactDigest` instead
+of a later, different value. The same
 record can cover both endpoints. Destination-only evidence, source-only tombstones, split endpoint
 records, and stale destination digests do not satisfy the source. A deletion tombstone therefore
 cannot stand in for a known rename. This destination validation and the snapshot it produces are
@@ -129,14 +140,24 @@ obligations. `N/A` and `unknown` obligations never bind evidence and keep the le
 for their audit identity (so a candidate `get` that supplies a digest is still reflected there);
 they remain `outcome: 'none'` and do not emit `candidate-artifacts-invalid` from this applicability-gated check.
 
+When several `rename-from` entries declare one shared destination, the read-once promise is scoped
+**per declaring entry**: each entry's metadata validation reads the shared destination once (their
+agreement of validated values is what detects a contradictory shared-destination snapshot). A
+poisoned destination — one whose snapshot was rejected — is honored inside the metadata loop: a
+later declaring entry fails closed without reading the destination again, and the failed snapshot
+wins in the audit, overriding any previously validated successful snapshot that an earlier entry
+carried, rather than silently describing a value the getter shipped after the failure.
+
 A rename destination's validated own digest is carried too. When more than one accepted
 `rename-from` entry shares one `renameTo`, every entry's validated own digest must agree; a
 conflicting validated digest is a contradictory shared-destination snapshot and fails the whole
 obligation closed (metadata error, `outcome: 'none'`) before any binding. The carried digest must
 be a non-empty string: a stateful `digest` accessor whose value is not a usable string is not
-carried or seeded. Only **applicable** obligations validate and carry this destination snapshot;
-`N/A` and `unknown` obligations keep the legacy candidate read for their audit identity and do not
-consume the destination getter during metadata validation.
+carried or seeded — instead the destination path is recorded as a visited failure, and neither the
+capture loop nor the audit identity reads the destination again. Only **applicable** obligations
+validate and carry this destination snapshot; `N/A` and `unknown` obligations keep the legacy
+candidate read for their audit identity and do not consume the destination getter during metadata
+validation.
 
 The binding applies to execution and review records alike. Existing review approval, waiver,
 failing-command, requirement-sync authority, and applicability rules are unchanged. A correctly

package/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.36.1
+  version: 0.36.2
 ---
 
 # Harness Everything

package/harness-everything/scripts/doc-evidence.js

@@ -72,8 +72,18 @@ function artifact(entry) {
 
 // #335 P2: a baseline-bound rename destination must declare its own digest. An inherited
 // `digest` (for example Object.create({ digest })) is not explicit candidate evidence.
-function ownArtifactDigest(entry) {
-  return isPlainObject(entry) && hasOwnEntry(entry, 'digest') ? artifact(entry) : '';
+// P2(r4321077631): reads the own digest exactly once. `artifact()` inspects `entry.digest` up
+// to three times (typeof, length, value), so a stateful accessor could validate one value and
+// have the captured destination snapshot carry another. Only the applicable rename-destination
+// snapshot uses this helper; non-baseline and inapplicable lanes keep the legacy `artifact()`
+// reads for their audit identity. A throwing digest getter propagates to the caller's guarded
+// block and fails the inspection closed there. This is the single authoritative own-digest
+// helper; nothing else in this module reads a destination's own digest.
+function ownDigestOnce(entry) {
+  if (!isPlainObject(entry)) return '';
+  if (!hasOwnEntry(entry, 'digest')) return '';
+  const digest = entry.digest;
+  return typeof digest === 'string' && digest.length > 0 ? digest : '';
 }
 
 function provenanceText(record) {
@@ -142,7 +152,20 @@ function checkDocObligations({ obligations, artifacts, baseline, executionRecord
     }
     return candidateInventoryKnown;
   };
-  const baselineDigest = isPlainObject(baseline) && nonEmptyString(baseline.digest) ? baseline.digest : '';
+  // P2(r4321077638): the whole-baseline identity is read exactly once and that same scalar is
+  // validated, so a stateful getter cannot pass validation as A and have every later comparison
+  // use B. A baseline identity whose inspection throws is unusable input: the captured digest
+  // stays '', so baseline-bound evaluations fail closed through `baseline-identity-missing`
+  // instead of escaping the checker, and non-baseline callers keep the legacy '' shape.
+  let baselineDigest = '';
+  if (isPlainObject(baseline)) {
+    try {
+      const declaredBaselineDigest = baseline.digest;
+      if (nonEmptyString(declaredBaselineDigest)) baselineDigest = declaredBaselineDigest;
+    } catch {
+      baselineDigest = '';
+    }
+  }
   const executionList = Array.isArray(executionRecords) ? executionRecords.filter(isRecord) : [];
   const reviewList = Array.isArray(reviewRecords) ? reviewRecords.filter(isRecord) : [];
 
@@ -184,6 +207,16 @@ function evaluateObligation(obligation, context) {
   // #340: every accepted entry sharing a rename destination must validate the same own digest,
   // or the shared-destination snapshot is contradictory and the obligation fails closed.
   const validatedDestinationDigestMap = new Map();
+  // #342 P3: a rename destination whose own-digest read throws or returns an unusable value is
+  // still a visited snapshot. Its captured ('') value is recorded here so the ordinary capture
+  // and the audit identity never re-read that destination entry: the single metadata read stays
+  // the only digest read for that declaring entry, and a stateful getter cannot ship a later
+  // non-empty value into the audit key even though its entry was rejected. A poisoned
+  // destination is honored inside the metadata loop (a later declaring entry fails closed
+  // without reading it) and keeps precedence over a previously seeded successful snapshot;
+  // multiple accepted entries still read the destination once each by design, because their
+  // agreement check detects shared-destination contradictions.
+  const failedDestinationDigests = new Map();
   // #340 P2(r4320818749): the validated per-path baseline digest is captured once during
   // metadata validation. The audit mirror, the stale-baseline diagnostics, and baselineBound()
   // reuse that captured value instead of re-reading the caller map, so a stateful own getter
@@ -289,19 +322,38 @@ function evaluateObligation(obligation, context) {
           // keeps the un-gated legacy candidate read; only applicable obligations capture and
           // validate the destination snapshot.
           if (applicability === 'applicable') {
+            // #342 review P3: a destination poisoned by an earlier entry's failed snapshot is
+            // honored inside the metadata loop; the failed visited snapshot is never read again
+            // and this entry fails closed with it, so a stateful getter's later successful
+            // value cannot repair a shared destination or enter the audit.
+            if (failedDestinationDigests.has(entryRenameTo)) {
+              invalid(entryPath, `its rename destination ${JSON.stringify(entryRenameTo)} failed an earlier snapshot validation for this obligation; the failed destination is not read again and this entry fails closed with it`);
+              continue;
+            }
             let destinationDigest = '';
             try {
               if (hasOwnEntry(artifactMap, entryRenameTo)) {
-                destinationDigest = ownArtifactDigest(artifactMap[entryRenameTo]);
+                // P2(r4321077631): read the destination's own digest exactly once; the captured
+                // value is the one validated below and the one that flows to the metadata cache,
+                // binding, the stale diagnostics, and the audit identity. A stateful destination
+                // getter cannot be validated as B while a record carrying only its later C passes.
+                destinationDigest = ownDigestOnce(artifactMap[entryRenameTo]);
               }
             } catch {
               candidateInventoryInspectionFailed = true;
+              // #342 P3: the destination is a visited snapshot even when its digest read threw;
+              // record it so the capture and audit lanes never re-read it.
+              failedDestinationDigests.set(entryRenameTo, '');
               continue;
             }
-            // #340: the captured own value must be a usable non-empty string; `artifact()` can read
-            // a stateful accessor three times, so a non-string result is not carried or seeded.
+            // #340: the captured own value must be a usable non-empty string; an unusable result
+            // is not carried or seeded.
             if (!nonEmptyString(destinationDigest)) {
               invalid(entryPath, `its rename destination ${JSON.stringify(entryRenameTo)} has no candidate artifact`);
+              // #342 P3: the destination is a visited snapshot even when its own digest is
+              // unusable; record it so the capture and audit lanes never re-read it and cannot
+              // describe a stateful getter's later non-empty value.
+              failedDestinationDigests.set(entryRenameTo, '');
               continue;
             }
             // #340: entries that share one rename destination must agree on the validated own
@@ -377,7 +429,9 @@ function evaluateObligation(obligation, context) {
     // its own digest during metadata. Seed the captured snapshot from that validated value and
     // never read the destination through the raw candidate map again, so a destination accessor
     // that throws or changes after validation cannot make capture/binding/audit disagree. The
-    // seeded value is the validated own digest, never a caller-asserted rawEntry field.
+    // seeded value is the validated own digest, never a caller-asserted rawEntry field. A
+    // rejected destination is still visited: its failed capture (see failedDestinationDigests)
+    // suppresses the ordinary read below, so no destination entry is ever read twice.
     for (const entry of baselineEntries.values()) {
       if (entry.reason === 'rename-from' && nonEmptyString(entry.renameDestinationDigest)
         && !candidateDigestCache.has(entry.renameTo)) {
@@ -385,7 +439,8 @@ function evaluateObligation(obligation, context) {
       }
     }
     for (const path of scopePaths) {
-      if (baselineEntries.has(path) || candidateDigestCache.has(path)) continue;
+      if (baselineEntries.has(path) || candidateDigestCache.has(path)
+        || failedDestinationDigests.has(path)) continue;
       try {
         candidateDigestCache.set(path, artifact(artifactMap[path]));
       } catch {
@@ -428,6 +483,11 @@ function evaluateObligation(obligation, context) {
   // stale verdict disagree with the digest that actually bound evidence. Untouched paths and
   // unannotated callers keep the legacy read.
   const candidateDigestOf = (path) => {
+    // #342 P3: poisoned state takes precedence over the capture cache. A rejected rename
+    // destination keeps its visited '' capture even when an earlier accepted entry seeded a
+    // successful value, so the audit never describes a value the getter shipped after a failed
+    // snapshot made the obligation fail closed; the caller map is never read for it again.
+    if (failedDestinationDigests.has(path)) return '';
     if (candidateDigestCache.has(path)) return candidateDigestCache.get(path);
     // #340: only an applicable baseline-annotated obligation validated the source absence as
     // part of its captured snapshot. `N/A` and `unknown` obligations never bind evidence, so they
@@ -509,7 +569,7 @@ function evaluateObligation(obligation, context) {
       // candidate lane, the audit identity, and the stale diagnostics use, so a stateful nested
       // accessor cannot make binding disagree with them. Metadata validation already required the
       // destination to be an own-key candidate inventory entry carrying its own digest
-      // (ownArtifactDigest), so a non-empty captured digest is required here and the accessor is
+      // (ownDigestOnce), so a non-empty captured digest is required here and the accessor is
       // never re-read; a missing destination skips capture and lands on this guard.
       const capturedDestination = candidateDigestCache.get(entry.renameTo);
       if (!nonEmptyString(capturedDestination)) return false;

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.36.1",
+  "version": "0.36.2",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/skills/harness-everything/SKILL.md

@@ -4,7 +4,7 @@ description: "Route software/project work through Harness: classify tier/topolog
 license: Apache-2.0
 metadata:
   author: Miya Daniel
-  version: 0.36.1
+  version: 0.36.2
 ---
 
 # Harness Everything

package/plugins/harness-everything/skills/harness-everything/scripts/doc-evidence.js

@@ -72,8 +72,18 @@ function artifact(entry) {
 
 // #335 P2: a baseline-bound rename destination must declare its own digest. An inherited
 // `digest` (for example Object.create({ digest })) is not explicit candidate evidence.
-function ownArtifactDigest(entry) {
-  return isPlainObject(entry) && hasOwnEntry(entry, 'digest') ? artifact(entry) : '';
+// P2(r4321077631): reads the own digest exactly once. `artifact()` inspects `entry.digest` up
+// to three times (typeof, length, value), so a stateful accessor could validate one value and
+// have the captured destination snapshot carry another. Only the applicable rename-destination
+// snapshot uses this helper; non-baseline and inapplicable lanes keep the legacy `artifact()`
+// reads for their audit identity. A throwing digest getter propagates to the caller's guarded
+// block and fails the inspection closed there. This is the single authoritative own-digest
+// helper; nothing else in this module reads a destination's own digest.
+function ownDigestOnce(entry) {
+  if (!isPlainObject(entry)) return '';
+  if (!hasOwnEntry(entry, 'digest')) return '';
+  const digest = entry.digest;
+  return typeof digest === 'string' && digest.length > 0 ? digest : '';
 }
 
 function provenanceText(record) {
@@ -142,7 +152,20 @@ function checkDocObligations({ obligations, artifacts, baseline, executionRecord
     }
     return candidateInventoryKnown;
   };
-  const baselineDigest = isPlainObject(baseline) && nonEmptyString(baseline.digest) ? baseline.digest : '';
+  // P2(r4321077638): the whole-baseline identity is read exactly once and that same scalar is
+  // validated, so a stateful getter cannot pass validation as A and have every later comparison
+  // use B. A baseline identity whose inspection throws is unusable input: the captured digest
+  // stays '', so baseline-bound evaluations fail closed through `baseline-identity-missing`
+  // instead of escaping the checker, and non-baseline callers keep the legacy '' shape.
+  let baselineDigest = '';
+  if (isPlainObject(baseline)) {
+    try {
+      const declaredBaselineDigest = baseline.digest;
+      if (nonEmptyString(declaredBaselineDigest)) baselineDigest = declaredBaselineDigest;
+    } catch {
+      baselineDigest = '';
+    }
+  }
   const executionList = Array.isArray(executionRecords) ? executionRecords.filter(isRecord) : [];
   const reviewList = Array.isArray(reviewRecords) ? reviewRecords.filter(isRecord) : [];
 
@@ -184,6 +207,16 @@ function evaluateObligation(obligation, context) {
   // #340: every accepted entry sharing a rename destination must validate the same own digest,
   // or the shared-destination snapshot is contradictory and the obligation fails closed.
   const validatedDestinationDigestMap = new Map();
+  // #342 P3: a rename destination whose own-digest read throws or returns an unusable value is
+  // still a visited snapshot. Its captured ('') value is recorded here so the ordinary capture
+  // and the audit identity never re-read that destination entry: the single metadata read stays
+  // the only digest read for that declaring entry, and a stateful getter cannot ship a later
+  // non-empty value into the audit key even though its entry was rejected. A poisoned
+  // destination is honored inside the metadata loop (a later declaring entry fails closed
+  // without reading it) and keeps precedence over a previously seeded successful snapshot;
+  // multiple accepted entries still read the destination once each by design, because their
+  // agreement check detects shared-destination contradictions.
+  const failedDestinationDigests = new Map();
   // #340 P2(r4320818749): the validated per-path baseline digest is captured once during
   // metadata validation. The audit mirror, the stale-baseline diagnostics, and baselineBound()
   // reuse that captured value instead of re-reading the caller map, so a stateful own getter
@@ -289,19 +322,38 @@ function evaluateObligation(obligation, context) {
           // keeps the un-gated legacy candidate read; only applicable obligations capture and
           // validate the destination snapshot.
           if (applicability === 'applicable') {
+            // #342 review P3: a destination poisoned by an earlier entry's failed snapshot is
+            // honored inside the metadata loop; the failed visited snapshot is never read again
+            // and this entry fails closed with it, so a stateful getter's later successful
+            // value cannot repair a shared destination or enter the audit.
+            if (failedDestinationDigests.has(entryRenameTo)) {
+              invalid(entryPath, `its rename destination ${JSON.stringify(entryRenameTo)} failed an earlier snapshot validation for this obligation; the failed destination is not read again and this entry fails closed with it`);
+              continue;
+            }
             let destinationDigest = '';
             try {
               if (hasOwnEntry(artifactMap, entryRenameTo)) {
-                destinationDigest = ownArtifactDigest(artifactMap[entryRenameTo]);
+                // P2(r4321077631): read the destination's own digest exactly once; the captured
+                // value is the one validated below and the one that flows to the metadata cache,
+                // binding, the stale diagnostics, and the audit identity. A stateful destination
+                // getter cannot be validated as B while a record carrying only its later C passes.
+                destinationDigest = ownDigestOnce(artifactMap[entryRenameTo]);
               }
             } catch {
               candidateInventoryInspectionFailed = true;
+              // #342 P3: the destination is a visited snapshot even when its digest read threw;
+              // record it so the capture and audit lanes never re-read it.
+              failedDestinationDigests.set(entryRenameTo, '');
               continue;
             }
-            // #340: the captured own value must be a usable non-empty string; `artifact()` can read
-            // a stateful accessor three times, so a non-string result is not carried or seeded.
+            // #340: the captured own value must be a usable non-empty string; an unusable result
+            // is not carried or seeded.
             if (!nonEmptyString(destinationDigest)) {
               invalid(entryPath, `its rename destination ${JSON.stringify(entryRenameTo)} has no candidate artifact`);
+              // #342 P3: the destination is a visited snapshot even when its own digest is
+              // unusable; record it so the capture and audit lanes never re-read it and cannot
+              // describe a stateful getter's later non-empty value.
+              failedDestinationDigests.set(entryRenameTo, '');
               continue;
             }
             // #340: entries that share one rename destination must agree on the validated own
@@ -377,7 +429,9 @@ function evaluateObligation(obligation, context) {
     // its own digest during metadata. Seed the captured snapshot from that validated value and
     // never read the destination through the raw candidate map again, so a destination accessor
     // that throws or changes after validation cannot make capture/binding/audit disagree. The
-    // seeded value is the validated own digest, never a caller-asserted rawEntry field.
+    // seeded value is the validated own digest, never a caller-asserted rawEntry field. A
+    // rejected destination is still visited: its failed capture (see failedDestinationDigests)
+    // suppresses the ordinary read below, so no destination entry is ever read twice.
     for (const entry of baselineEntries.values()) {
       if (entry.reason === 'rename-from' && nonEmptyString(entry.renameDestinationDigest)
         && !candidateDigestCache.has(entry.renameTo)) {
@@ -385,7 +439,8 @@ function evaluateObligation(obligation, context) {
       }
     }
     for (const path of scopePaths) {
-      if (baselineEntries.has(path) || candidateDigestCache.has(path)) continue;
+      if (baselineEntries.has(path) || candidateDigestCache.has(path)
+        || failedDestinationDigests.has(path)) continue;
       try {
         candidateDigestCache.set(path, artifact(artifactMap[path]));
       } catch {
@@ -428,6 +483,11 @@ function evaluateObligation(obligation, context) {
   // stale verdict disagree with the digest that actually bound evidence. Untouched paths and
   // unannotated callers keep the legacy read.
   const candidateDigestOf = (path) => {
+    // #342 P3: poisoned state takes precedence over the capture cache. A rejected rename
+    // destination keeps its visited '' capture even when an earlier accepted entry seeded a
+    // successful value, so the audit never describes a value the getter shipped after a failed
+    // snapshot made the obligation fail closed; the caller map is never read for it again.
+    if (failedDestinationDigests.has(path)) return '';
     if (candidateDigestCache.has(path)) return candidateDigestCache.get(path);
     // #340: only an applicable baseline-annotated obligation validated the source absence as
     // part of its captured snapshot. `N/A` and `unknown` obligations never bind evidence, so they
@@ -509,7 +569,7 @@ function evaluateObligation(obligation, context) {
       // candidate lane, the audit identity, and the stale diagnostics use, so a stateful nested
       // accessor cannot make binding disagree with them. Metadata validation already required the
       // destination to be an own-key candidate inventory entry carrying its own digest
-      // (ownArtifactDigest), so a non-empty captured digest is required here and the accessor is
+      // (ownDigestOnce), so a non-empty captured digest is required here and the accessor is
       // never re-read; a missing destination skips capture and lands on this guard.
       const capturedDestination = candidateDigestCache.get(entry.renameTo);
       if (!nonEmptyString(capturedDestination)) return false;

package/sbom.cdx.json

@@ -2,23 +2,23 @@
   "$schema": "https://cyclonedx.org/schema/bom-1.7.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.7",
-  "serialNumber": "urn:uuid:74100c9d-ebbb-559a-8ab0-a9ac5fd581c6",
+  "serialNumber": "urn:uuid:d784e4c6-dc73-508d-9e04-a38908e96486",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-10-20T03:51:47.041Z",
+    "timestamp": "2026-10-20T05:31:16.491Z",
     "tools": [
       {
         "vendor": "Harness Everything",
         "name": "generate-sbom.js",
-        "version": "0.36.1"
+        "version": "0.36.2"
       }
     ],
     "component": {
       "type": "application",
-      "bom-ref": "pkg:npm/harness-everything@0.36.1",
+      "bom-ref": "pkg:npm/harness-everything@0.36.2",
       "name": "harness-everything",
-      "version": "0.36.1",
-      "purl": "pkg:npm/harness-everything@0.36.1"
+      "version": "0.36.2",
+      "purl": "pkg:npm/harness-everything@0.36.2"
     }
   },
   "components": [
@@ -1999,7 +1999,7 @@
       ]
     },
     {
-      "ref": "pkg:npm/harness-everything@0.36.1",
+      "ref": "pkg:npm/harness-everything@0.36.2",
       "dependsOn": [
         "pkg:npm/%40commitlint/cli@19.8.1",
         "pkg:npm/%40commitlint/config-conventional@19.8.1",