liteagents 2.23.0 → 2.24.1

package/CHANGELOG.md

@@ -7,6 +7,93 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [2.24.1] - 2026-09-03
+
+### Changed
+- **The file-referent ledger half is SHELVED — no demonstrated problem.** The v2.24.0
+  entry below says shipping the ledger side is "gated on a future exact-label-agreement
+  measurement," which implied the work was justified and merely queued. That premise was
+  never checked, and it is wrong. The harm this channel prevents — a false match
+  inflating an entry's count until a `hot` entry hits `recurred_while_hot >= 2` and has
+  its rule rewritten — has never occurred: `ag-001` is the only `hot` entry, its
+  `recurred_while_hot` is 1 against a threshold of 2, and its two `attempts` are a
+  deliberate August rephrasing rather than a false-match rewrite. A POC also established
+  the naive ledger design would not have worked: cluster-level unions collide at 1.8%,
+  but entry-level unions collide at **38%**, because an entry accumulates paths across
+  every session it matches and inevitably collects `README.md` / `CLAUDE.md`. A
+  document-frequency filter repairs it (9.5% at df<=2), but repairing a fix for a problem
+  that is not occurring is not a reason to ship. **The incoming half is kept** — it costs
+  nothing, adds no LLM step, and accumulates evidence for free.
+- **The un-shelve trigger is now checkable rather than a judgement call:** a false match
+  observed under a sonnet-class classifier, OR `ag-001` reaching `recurred_while_hot = 2`
+  on evidence that is not about validation.
+- **And that trigger must NOT be exact-label agreement.** A fourth POC arm with the
+  user's quotes stripped from both sides scored best on every stability measure (0.900
+  exact agreement, 3/20 unstable) and is plainly the worst arm: it unanimously dropped
+  three clusters (`ag-012`, `ag-007`, `ag-001`) that all nine quote-carrying runs matched
+  unanimously, and named antigens after session hashes. It wins by having nothing to go
+  on and defaulting to `drop`. High agreement on "I don't know" is not quality — the same
+  degenerate shape as the severity axis that was seeded and rated on the same signal. A
+  re-attempt needs a human-labelled gold set.
+
+### Added
+- `poc/friction-file-referents/` — the corpus, all four arm prompts, raw labels from 12
+  runs, and `score.py`, which reproduces every table above. Kept so a re-attempt starts
+  from the numbers. Outside `package.json`'s `files` allowlist; not published.
+
+---
+
+## [2.24.0] - 2026-09-03
+
+### Added
+- **Friction clusters carry file referents through as a second matching signature.**
+  `friction.cjs` already computed a `files` list per candidate (74/101 populated on a
+  frozen 34-cluster / 101-candidate corpus) but silently dropped it at clustering, so no
+  cluster ever saw it. It is now unioned per cluster and capped at 8 sorted paths. Measured
+  before building: `preceding` (tool-name sequence + result) gave 13 distinct signatures
+  over 34 clusters at 19.3% collision, `tool_sequence` gave 10 at 25.8% — both close to the
+  coin flip the existing quote channel already is. File basenames gave 28 at 3.7% on a
+  per-candidate join; the per-cluster union does better still: 30 distinct signatures over
+  34 clusters at 1.8% collision, 29/34 populated, a 10× reduction against `preceding`. A
+  prediction from the design notes turned out wrong in the favourable direction: paths are
+  real strings, not a distillation, so the channel needed no LLM judgement step to add.
+  **This channel is carried on the incoming side only.** No ledger entry stores `files` and
+  step 4a is not shown it, so ledger matching still runs on the single quote channel it
+  always has — shipping that half is gated on a future exact-label-agreement measurement,
+  documented in `docs/product/antigen-gate-prd.md` §13 and
+  `docs/product/remember-README.md` §6.
+
+### Fixed
+- **Friction's `preceding.result` read the wrong signal — text-matched `'Exit code 0'`
+  instead of the `is_error` boolean.** The text match hit 1 of 2623 sampled result blocks;
+  `is_error` is present on 2065 of 2624. Before the fix, `preceding.result` was `unknown`
+  on 31 of 34 clusters; after, 18 claimed-success, 4 error, 12 unknown. Cluster hashes are
+  unchanged — this only corrects a field that was already there.
+- **`docs-builder`'s cleanup output named counts ambiguously.** The advisory now says "N
+  file(s) with link rewrites" and the restore step says "restored N inbound reference(s)" —
+  the advisory counts files touched, the restore counts the references inside them, and the
+  two numbers are not the same unit.
+- **`docs-builder` inbound references follow the core page back out of the archive.**
+  `cleanup-apply` archives the source, then relocates the core page back to its original
+  path. The archive step had already rewritten every inbound reference to point at
+  `docs/archive/` — correct at that moment, since the archive was briefly the only copy —
+  but nothing walked them back once the core page reoccupied the original path, leaving the
+  corpus telling readers the doc lived in the archive while the live page sat unreferenced.
+  A third restore step now walks them back. What must *not* be restored is the point of the
+  design rather than an edge case: the split's own pages cite the original by line number,
+  so their `sources:` and citations stay pinned to the frozen archive copy. Field-reported
+  from a real PRD split (33 references across 15 files), reproduced failing-first.
+
+### Security
+- **`fast-uri` bumped 3.1.5 → 3.1.7 and `qs` bumped 6.15.2 → 6.16.0** in the
+  live-canvas-channel plugin lockfile (Dependabot #43/#44, folded into one commit since
+  both edit the same lockfile). `fast-uri` 3.1.7 closes five high-severity advisories:
+  authority injection via an unvalidated port in `serialize()` (GHSA-qw65-cvwx-89v3), host
+  confusion via unbalanced IP-literal brackets (GHSA-58mr-gqgx-xq4g) and skipped IDN
+  canonicalization (GHSA-5jgf-p345-68v8), and SSRF via repeated hostname percent-decoding
+  (GHSA-fph4-wmhf-6fwf) and malformed IPv6 normalization (GHSA-f65p-4m7j-42xc). Both
+  packages are transitive dependencies of `@modelcontextprotocol/sdk`.
+
 ## [2.23.0] - 2026-09-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "liteagents",
-  "version": "2.23.0",
+  "version": "2.24.1",
   "description": "AI development toolkit with 11 specialized agents and 18 commands including live-canvas UI design with click-to-annotate feedback. Simple one-question installer for Claude, Opencode, Ampcode, and Droid.",
   "main": "index.js",
   "bin": {

package/packages/ampcode/commands/docs-builder/docs-builder.cjs

@@ -1085,10 +1085,17 @@ const LINK_SKIP = /(^|\/)(CHANGELOG\.md|log\.md)$/;
 // moves is already covered by the resident check the instant its own git mv lands, before
 // rewriteLinks ever runs for it.
 let plannedArchiveSrc = new Set();
+// Set only for the duration of cleanup-apply's restore pass (see cleanupApply below), which
+// walks inbound references back from the archived copy to the relocated core page. That pass
+// must skip the split's own pages: they cite the original BY LINE NUMBER, so their `sources:`
+// and citations belong on the frozen archive copy, not on the shortened core page. A
+// predicate rather than a Set because the exemption is a directory prefix plus one file.
+let linkRestoreExempt = null;
 // One predicate, called from the one place rewriteLinks() loops over candidate files, so the
 // exemption can never desync across callers the way moveDoc's follow-ups almost did.
 function isRewriteExempt(f) {
-  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f);
+  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f)
+    || (linkRestoreExempt !== null && linkRestoreExempt(f));
 }
 
 // A real corpus (astral-sh/uv) cross-links its docs with RELATIVE paths — `../concepts/x.md`,
@@ -1301,8 +1308,12 @@ function flushCommitAdvisory() {
     const outsideDocs = Array.from(new Set(outsideFiles.map(f => f.split('/')[0]))).sort();
     console.log(`\n${moveSet.length} rename(s) this run (git mv stages these automatically; `
       + 'the copy+unlink fallback used outside a git repo does not)');
+    // Unit, stated: linkSet holds FILE paths, so this is a file count. cleanup-apply's
+    // restore pass just below reports OCCURRENCES, and a real run printed "33" here next to
+    // "restored 38" — same-sounding nouns, two different units, and the reader has no way to
+    // tell they are not a discrepancy. Name the unit in both places.
     console.log(linkSet.length
-      ? `${linkSet.length} link rewrite(s) UNSTAGED` + (outsideFiles.length
+      ? `${linkSet.length} file(s) with link rewrites UNSTAGED` + (outsideFiles.length
         ? `, ${outsideFiles.length} outside docs/: ${outsideDocs.join(', ')}`
         : ' (all inside docs/)')
       : 'no inbound-link rewrites this run.');
@@ -2352,6 +2363,40 @@ function cleanupApply(file, outlineF, labelsF) {
         for (const m of r.artifactNotes) console.log(`    ${m}`);
         if (r.failures.length) console.error(`  WARN core page relocated, but ${r.failures.join('; ')}`);
         noteMoved(r.rel); noteLinks(r.linkFiles.map(x => x.file));
+
+        // FIELD BUG (real, reproduced): archiveOrThrow above rewrote EVERY inbound reference
+        // to point at docs/archive/, because at that moment the archive genuinely was the
+        // only copy. The relocation on the line above then put a live page back at the
+        // original path — so the corpus now tells readers that "the PRD" lives in the
+        // archive while the live page sits unreferenced. On a real split that was 33
+        // references across 15 files outside docs/, and it is precisely the backwards
+        // outcome this command exists to prevent. Walk them back.
+        //
+        // The ordering itself cannot be swapped: the original must vacate the path before
+        // the core page can occupy it, and rewriting links to a path nothing occupies yet
+        // would be worse. So the restore is a third step, not a reordering.
+        //
+        // EXEMPT, and this is the point of the pass rather than an edge case: the split's
+        // own pages cite the original BY LINE NUMBER, so their `sources:` and citations
+        // must stay on the frozen archive copy — as must the relocated core page's own.
+        // Rewriting those back would be a new bug wearing the old one's clothes.
+        const archivedRel = path.posix.join(REORG_DEST.archive, path.basename(file));
+        const pagesPrefix = pages.replace(/\/*$/, '') + '/';
+        linkRestoreExempt = f => f === r.rel || f.startsWith(pagesPrefix);
+        let restored;
+        try { restored = rewriteLinks(archivedRel, r.rel); }
+        finally { linkRestoreExempt = null; }
+        if (restored.skipped) {
+          console.log(`  ${restored.skipped}`);
+        } else if (restored.total) {
+          console.log(`  restored ${restored.total} inbound reference(s) from ${archivedRel} `
+            + `back to ${r.rel} (the archive step had aimed them at the frozen copy; `
+            + `${pagesPrefix} pages keep theirs, their citations are line-numbered)`);
+          for (const { file: lf, n } of restored.files) console.log(`    ${lf}: ${n}`);
+          noteLinks(restored.files.map(x => x.file));
+        } else {
+          console.log(`  no inbound references to ${archivedRel} needed restoring.`);
+        }
       } catch (e) {
         console.error(`  WARN could not relocate the core page from ${from} to ${to}: `
           + `${e.message} — it remains at ${from}.`);

package/packages/ampcode/commands/remember/friction.cjs

@@ -1765,8 +1765,26 @@ function extractToolsFromTurn(event) {
           const toolName = block.name || 'unknown';
           tools.push({ tool: toolName, action: 'call' });
         } else if (block.type === 'tool_result') {
-          const result = String(block.content || '');
-          if (result.includes('Exit code 0')) {
+          // The transcript marks a failed tool call with `is_error`; a success
+          // carries no sentinel in the result text. Reading the text for
+          // 'Exit code 0' matched 1 block in 2623 sampled from the real
+          // corpus, so `result` was 'unknown' on 31 of 34 clusters — and the
+          // case this field exists for is a CLAIMED success the user is
+          // contradicting, which is the one that never fired. Content is also
+          // sometimes an array of blocks (403/2623), which String() turned
+          // into "[object Object]" so no pattern could match it.
+          //
+          // A block with no `is_error` stays unknown on purpose: those are
+          // harness meta-results (skill/agent launches, question answers —
+          // 560/2624 sampled) and calling them success would inflate the very
+          // signal this field is here to detect.
+          const raw = block.content;
+          const result = Array.isArray(raw)
+            ? raw.map(b => (b && typeof b === 'object' ? (b.text || '') : String(b || ''))).join('\n')
+            : String(raw || '');
+          if (block.is_error === true) {
+            tools.push({ tool: 'result', action: 'error' });
+          } else if (typeof block.is_error === 'boolean') {
             tools.push({ tool: 'result', action: 'success' });
           } else if (/Exit code [1-9]|Traceback|Error/.test(result)) {
             tools.push({ tool: 'result', action: 'error' });
@@ -2142,6 +2160,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       errors: b.errors,
       peak: b.peak,
       texts: b.texts,
+      files: [...b.files],
       preceding: b.preceding,
       anySelf: b.selfVotes > 0,                        // at least one self-correction → warn, LLM confirms target
     };
@@ -2166,7 +2185,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     if (best) {
       cl = best;
     } else {
-      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null };
+      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null, files: new Set() };
       clusters.push(cl);
     }
     for (const s of ss.sig) { cl.sig.add(s); cl.shCount.set(s, (cl.shCount.get(s) || 0) + 1); }
@@ -2178,6 +2197,15 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     cl.peaks.push(ss.peak);
     if (ss.anySelf) cl.anySelf = true;
     if (ss.preceding && (!cl.preceding || (ss.preceding.action !== 'none' || ss.preceding.error))) cl.preceding = ss.preceding;
+    // The file referents a cluster's sessions touched. Measured on a 34-cluster real
+    // corpus as the one channel that actually separates clusters: file basenames gave 28
+    // distinct signatures at a 3.7% collision rate, against 13 / 19.3% for the preceding
+    // action+result pair and 10 / 25.8% for tool_sequence. Matching an incoming cluster
+    // to a ledger entry otherwise runs on class_hints alone, and those ARE fragments of
+    // the entry's own evidence quotes — one channel, where identity and proof are the
+    // same strings. These paths are mechanical, so carrying them adds a second channel
+    // without reintroducing an LLM distillation step.
+    for (const f of ss.files) cl.files.add(f);
   }
 
   const out = clusters.map(cl => {
@@ -2251,6 +2279,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       max_peak: peaks[peaks.length - 1],
       contexts: cl.contexts,
       errors: cl.errors,
+      files: [...cl.files].sort().slice(0, 8),  // referents: the discriminative match channel (see merge above)
       preceding: cl.preceding,          // #4: agent action + result just before the reaction
       self_suspect: allSelf || cl.anySelf,  // #3: a self-correction is present — LLM confirms target (advisory)
       top_keywords: topSh.slice(0, 10),

package/packages/claude/commands/docs-builder/docs-builder.cjs

@@ -1085,10 +1085,17 @@ const LINK_SKIP = /(^|\/)(CHANGELOG\.md|log\.md)$/;
 // moves is already covered by the resident check the instant its own git mv lands, before
 // rewriteLinks ever runs for it.
 let plannedArchiveSrc = new Set();
+// Set only for the duration of cleanup-apply's restore pass (see cleanupApply below), which
+// walks inbound references back from the archived copy to the relocated core page. That pass
+// must skip the split's own pages: they cite the original BY LINE NUMBER, so their `sources:`
+// and citations belong on the frozen archive copy, not on the shortened core page. A
+// predicate rather than a Set because the exemption is a directory prefix plus one file.
+let linkRestoreExempt = null;
 // One predicate, called from the one place rewriteLinks() loops over candidate files, so the
 // exemption can never desync across callers the way moveDoc's follow-ups almost did.
 function isRewriteExempt(f) {
-  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f);
+  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f)
+    || (linkRestoreExempt !== null && linkRestoreExempt(f));
 }
 
 // A real corpus (astral-sh/uv) cross-links its docs with RELATIVE paths — `../concepts/x.md`,
@@ -1301,8 +1308,12 @@ function flushCommitAdvisory() {
     const outsideDocs = Array.from(new Set(outsideFiles.map(f => f.split('/')[0]))).sort();
     console.log(`\n${moveSet.length} rename(s) this run (git mv stages these automatically; `
       + 'the copy+unlink fallback used outside a git repo does not)');
+    // Unit, stated: linkSet holds FILE paths, so this is a file count. cleanup-apply's
+    // restore pass just below reports OCCURRENCES, and a real run printed "33" here next to
+    // "restored 38" — same-sounding nouns, two different units, and the reader has no way to
+    // tell they are not a discrepancy. Name the unit in both places.
     console.log(linkSet.length
-      ? `${linkSet.length} link rewrite(s) UNSTAGED` + (outsideFiles.length
+      ? `${linkSet.length} file(s) with link rewrites UNSTAGED` + (outsideFiles.length
         ? `, ${outsideFiles.length} outside docs/: ${outsideDocs.join(', ')}`
         : ' (all inside docs/)')
       : 'no inbound-link rewrites this run.');
@@ -2352,6 +2363,40 @@ function cleanupApply(file, outlineF, labelsF) {
         for (const m of r.artifactNotes) console.log(`    ${m}`);
         if (r.failures.length) console.error(`  WARN core page relocated, but ${r.failures.join('; ')}`);
         noteMoved(r.rel); noteLinks(r.linkFiles.map(x => x.file));
+
+        // FIELD BUG (real, reproduced): archiveOrThrow above rewrote EVERY inbound reference
+        // to point at docs/archive/, because at that moment the archive genuinely was the
+        // only copy. The relocation on the line above then put a live page back at the
+        // original path — so the corpus now tells readers that "the PRD" lives in the
+        // archive while the live page sits unreferenced. On a real split that was 33
+        // references across 15 files outside docs/, and it is precisely the backwards
+        // outcome this command exists to prevent. Walk them back.
+        //
+        // The ordering itself cannot be swapped: the original must vacate the path before
+        // the core page can occupy it, and rewriting links to a path nothing occupies yet
+        // would be worse. So the restore is a third step, not a reordering.
+        //
+        // EXEMPT, and this is the point of the pass rather than an edge case: the split's
+        // own pages cite the original BY LINE NUMBER, so their `sources:` and citations
+        // must stay on the frozen archive copy — as must the relocated core page's own.
+        // Rewriting those back would be a new bug wearing the old one's clothes.
+        const archivedRel = path.posix.join(REORG_DEST.archive, path.basename(file));
+        const pagesPrefix = pages.replace(/\/*$/, '') + '/';
+        linkRestoreExempt = f => f === r.rel || f.startsWith(pagesPrefix);
+        let restored;
+        try { restored = rewriteLinks(archivedRel, r.rel); }
+        finally { linkRestoreExempt = null; }
+        if (restored.skipped) {
+          console.log(`  ${restored.skipped}`);
+        } else if (restored.total) {
+          console.log(`  restored ${restored.total} inbound reference(s) from ${archivedRel} `
+            + `back to ${r.rel} (the archive step had aimed them at the frozen copy; `
+            + `${pagesPrefix} pages keep theirs, their citations are line-numbered)`);
+          for (const { file: lf, n } of restored.files) console.log(`    ${lf}: ${n}`);
+          noteLinks(restored.files.map(x => x.file));
+        } else {
+          console.log(`  no inbound references to ${archivedRel} needed restoring.`);
+        }
       } catch (e) {
         console.error(`  WARN could not relocate the core page from ${from} to ${to}: `
           + `${e.message} — it remains at ${from}.`);

package/packages/claude/commands/remember/friction.cjs

@@ -1765,8 +1765,26 @@ function extractToolsFromTurn(event) {
           const toolName = block.name || 'unknown';
           tools.push({ tool: toolName, action: 'call' });
         } else if (block.type === 'tool_result') {
-          const result = String(block.content || '');
-          if (result.includes('Exit code 0')) {
+          // The transcript marks a failed tool call with `is_error`; a success
+          // carries no sentinel in the result text. Reading the text for
+          // 'Exit code 0' matched 1 block in 2623 sampled from the real
+          // corpus, so `result` was 'unknown' on 31 of 34 clusters — and the
+          // case this field exists for is a CLAIMED success the user is
+          // contradicting, which is the one that never fired. Content is also
+          // sometimes an array of blocks (403/2623), which String() turned
+          // into "[object Object]" so no pattern could match it.
+          //
+          // A block with no `is_error` stays unknown on purpose: those are
+          // harness meta-results (skill/agent launches, question answers —
+          // 560/2624 sampled) and calling them success would inflate the very
+          // signal this field is here to detect.
+          const raw = block.content;
+          const result = Array.isArray(raw)
+            ? raw.map(b => (b && typeof b === 'object' ? (b.text || '') : String(b || ''))).join('\n')
+            : String(raw || '');
+          if (block.is_error === true) {
+            tools.push({ tool: 'result', action: 'error' });
+          } else if (typeof block.is_error === 'boolean') {
             tools.push({ tool: 'result', action: 'success' });
           } else if (/Exit code [1-9]|Traceback|Error/.test(result)) {
             tools.push({ tool: 'result', action: 'error' });
@@ -2142,6 +2160,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       errors: b.errors,
       peak: b.peak,
       texts: b.texts,
+      files: [...b.files],
       preceding: b.preceding,
       anySelf: b.selfVotes > 0,                        // at least one self-correction → warn, LLM confirms target
     };
@@ -2166,7 +2185,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     if (best) {
       cl = best;
     } else {
-      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null };
+      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null, files: new Set() };
       clusters.push(cl);
     }
     for (const s of ss.sig) { cl.sig.add(s); cl.shCount.set(s, (cl.shCount.get(s) || 0) + 1); }
@@ -2178,6 +2197,15 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     cl.peaks.push(ss.peak);
     if (ss.anySelf) cl.anySelf = true;
     if (ss.preceding && (!cl.preceding || (ss.preceding.action !== 'none' || ss.preceding.error))) cl.preceding = ss.preceding;
+    // The file referents a cluster's sessions touched. Measured on a 34-cluster real
+    // corpus as the one channel that actually separates clusters: file basenames gave 28
+    // distinct signatures at a 3.7% collision rate, against 13 / 19.3% for the preceding
+    // action+result pair and 10 / 25.8% for tool_sequence. Matching an incoming cluster
+    // to a ledger entry otherwise runs on class_hints alone, and those ARE fragments of
+    // the entry's own evidence quotes — one channel, where identity and proof are the
+    // same strings. These paths are mechanical, so carrying them adds a second channel
+    // without reintroducing an LLM distillation step.
+    for (const f of ss.files) cl.files.add(f);
   }
 
   const out = clusters.map(cl => {
@@ -2251,6 +2279,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       max_peak: peaks[peaks.length - 1],
       contexts: cl.contexts,
       errors: cl.errors,
+      files: [...cl.files].sort().slice(0, 8),  // referents: the discriminative match channel (see merge above)
       preceding: cl.preceding,          // #4: agent action + result just before the reaction
       self_suspect: allSelf || cl.anySelf,  // #3: a self-correction is present — LLM confirms target (advisory)
       top_keywords: topSh.slice(0, 10),

package/packages/claude/plugins/live-canvas-marketplace/plugins/live-canvas-channel/package-lock.json

@@ -333,9 +333,9 @@
       }
     },
     "node_modules/es-object-atoms": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
-      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0"
@@ -448,9 +448,9 @@
       "license": "MIT"
     },
     "node_modules/fast-uri": {
-      "version": "3.1.5",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.5.tgz",
-      "integrity": "sha512-gHwA1O9LDIcKunMKhObS/HimwtehO1nPUECKAu5TpKgaO19fcWEl4bliWe1jWxVFvIXztJjjQ4L8XQ1EU9f7Jw==",
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.7.tgz",
+      "integrity": "sha512-dOvZVzjdZdz7phd9v6jCbwxrBW3fK6n8Rc0CtdmM4bumzMnxywBYhuph6J819RRw/ku+rLbelwfMunktuzVVHg==",
       "funding": [
         {
           "type": "github",
@@ -573,9 +573,9 @@
       }
     },
     "node_modules/hasown": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.3.tgz",
-      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
       "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
@@ -849,12 +849,13 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.15.2",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz",
-      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
+      "version": "6.16.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.16.0.tgz",
+      "integrity": "sha512-h6fhOIaRrID2CbEY2fqs+7t+UXZo+MLAnU5gRIq85uFtdiUPCdsApMlHhXogKVM4HM2DVbIjGNTTYH2OcmP1vA==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.1.0"
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
       },
       "engines": {
         "node": ">=0.6"
@@ -991,14 +992,14 @@
       }
     },
     "node_modules/side-channel": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
         "side-channel-map": "^1.0.1",
         "side-channel-weakmap": "^1.0.2"
       },

package/packages/droid/commands/docs-builder/docs-builder.cjs

@@ -1085,10 +1085,17 @@ const LINK_SKIP = /(^|\/)(CHANGELOG\.md|log\.md)$/;
 // moves is already covered by the resident check the instant its own git mv lands, before
 // rewriteLinks ever runs for it.
 let plannedArchiveSrc = new Set();
+// Set only for the duration of cleanup-apply's restore pass (see cleanupApply below), which
+// walks inbound references back from the archived copy to the relocated core page. That pass
+// must skip the split's own pages: they cite the original BY LINE NUMBER, so their `sources:`
+// and citations belong on the frozen archive copy, not on the shortened core page. A
+// predicate rather than a Set because the exemption is a directory prefix plus one file.
+let linkRestoreExempt = null;
 // One predicate, called from the one place rewriteLinks() loops over candidate files, so the
 // exemption can never desync across callers the way moveDoc's follow-ups almost did.
 function isRewriteExempt(f) {
-  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f);
+  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f)
+    || (linkRestoreExempt !== null && linkRestoreExempt(f));
 }
 
 // A real corpus (astral-sh/uv) cross-links its docs with RELATIVE paths — `../concepts/x.md`,
@@ -1301,8 +1308,12 @@ function flushCommitAdvisory() {
     const outsideDocs = Array.from(new Set(outsideFiles.map(f => f.split('/')[0]))).sort();
     console.log(`\n${moveSet.length} rename(s) this run (git mv stages these automatically; `
       + 'the copy+unlink fallback used outside a git repo does not)');
+    // Unit, stated: linkSet holds FILE paths, so this is a file count. cleanup-apply's
+    // restore pass just below reports OCCURRENCES, and a real run printed "33" here next to
+    // "restored 38" — same-sounding nouns, two different units, and the reader has no way to
+    // tell they are not a discrepancy. Name the unit in both places.
     console.log(linkSet.length
-      ? `${linkSet.length} link rewrite(s) UNSTAGED` + (outsideFiles.length
+      ? `${linkSet.length} file(s) with link rewrites UNSTAGED` + (outsideFiles.length
         ? `, ${outsideFiles.length} outside docs/: ${outsideDocs.join(', ')}`
         : ' (all inside docs/)')
       : 'no inbound-link rewrites this run.');
@@ -2352,6 +2363,40 @@ function cleanupApply(file, outlineF, labelsF) {
         for (const m of r.artifactNotes) console.log(`    ${m}`);
         if (r.failures.length) console.error(`  WARN core page relocated, but ${r.failures.join('; ')}`);
         noteMoved(r.rel); noteLinks(r.linkFiles.map(x => x.file));
+
+        // FIELD BUG (real, reproduced): archiveOrThrow above rewrote EVERY inbound reference
+        // to point at docs/archive/, because at that moment the archive genuinely was the
+        // only copy. The relocation on the line above then put a live page back at the
+        // original path — so the corpus now tells readers that "the PRD" lives in the
+        // archive while the live page sits unreferenced. On a real split that was 33
+        // references across 15 files outside docs/, and it is precisely the backwards
+        // outcome this command exists to prevent. Walk them back.
+        //
+        // The ordering itself cannot be swapped: the original must vacate the path before
+        // the core page can occupy it, and rewriting links to a path nothing occupies yet
+        // would be worse. So the restore is a third step, not a reordering.
+        //
+        // EXEMPT, and this is the point of the pass rather than an edge case: the split's
+        // own pages cite the original BY LINE NUMBER, so their `sources:` and citations
+        // must stay on the frozen archive copy — as must the relocated core page's own.
+        // Rewriting those back would be a new bug wearing the old one's clothes.
+        const archivedRel = path.posix.join(REORG_DEST.archive, path.basename(file));
+        const pagesPrefix = pages.replace(/\/*$/, '') + '/';
+        linkRestoreExempt = f => f === r.rel || f.startsWith(pagesPrefix);
+        let restored;
+        try { restored = rewriteLinks(archivedRel, r.rel); }
+        finally { linkRestoreExempt = null; }
+        if (restored.skipped) {
+          console.log(`  ${restored.skipped}`);
+        } else if (restored.total) {
+          console.log(`  restored ${restored.total} inbound reference(s) from ${archivedRel} `
+            + `back to ${r.rel} (the archive step had aimed them at the frozen copy; `
+            + `${pagesPrefix} pages keep theirs, their citations are line-numbered)`);
+          for (const { file: lf, n } of restored.files) console.log(`    ${lf}: ${n}`);
+          noteLinks(restored.files.map(x => x.file));
+        } else {
+          console.log(`  no inbound references to ${archivedRel} needed restoring.`);
+        }
       } catch (e) {
         console.error(`  WARN could not relocate the core page from ${from} to ${to}: `
           + `${e.message} — it remains at ${from}.`);

package/packages/droid/commands/remember/friction.cjs

@@ -1765,8 +1765,26 @@ function extractToolsFromTurn(event) {
           const toolName = block.name || 'unknown';
           tools.push({ tool: toolName, action: 'call' });
         } else if (block.type === 'tool_result') {
-          const result = String(block.content || '');
-          if (result.includes('Exit code 0')) {
+          // The transcript marks a failed tool call with `is_error`; a success
+          // carries no sentinel in the result text. Reading the text for
+          // 'Exit code 0' matched 1 block in 2623 sampled from the real
+          // corpus, so `result` was 'unknown' on 31 of 34 clusters — and the
+          // case this field exists for is a CLAIMED success the user is
+          // contradicting, which is the one that never fired. Content is also
+          // sometimes an array of blocks (403/2623), which String() turned
+          // into "[object Object]" so no pattern could match it.
+          //
+          // A block with no `is_error` stays unknown on purpose: those are
+          // harness meta-results (skill/agent launches, question answers —
+          // 560/2624 sampled) and calling them success would inflate the very
+          // signal this field is here to detect.
+          const raw = block.content;
+          const result = Array.isArray(raw)
+            ? raw.map(b => (b && typeof b === 'object' ? (b.text || '') : String(b || ''))).join('\n')
+            : String(raw || '');
+          if (block.is_error === true) {
+            tools.push({ tool: 'result', action: 'error' });
+          } else if (typeof block.is_error === 'boolean') {
             tools.push({ tool: 'result', action: 'success' });
           } else if (/Exit code [1-9]|Traceback|Error/.test(result)) {
             tools.push({ tool: 'result', action: 'error' });
@@ -2142,6 +2160,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       errors: b.errors,
       peak: b.peak,
       texts: b.texts,
+      files: [...b.files],
       preceding: b.preceding,
       anySelf: b.selfVotes > 0,                        // at least one self-correction → warn, LLM confirms target
     };
@@ -2166,7 +2185,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     if (best) {
       cl = best;
     } else {
-      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null };
+      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null, files: new Set() };
       clusters.push(cl);
     }
     for (const s of ss.sig) { cl.sig.add(s); cl.shCount.set(s, (cl.shCount.get(s) || 0) + 1); }
@@ -2178,6 +2197,15 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     cl.peaks.push(ss.peak);
     if (ss.anySelf) cl.anySelf = true;
     if (ss.preceding && (!cl.preceding || (ss.preceding.action !== 'none' || ss.preceding.error))) cl.preceding = ss.preceding;
+    // The file referents a cluster's sessions touched. Measured on a 34-cluster real
+    // corpus as the one channel that actually separates clusters: file basenames gave 28
+    // distinct signatures at a 3.7% collision rate, against 13 / 19.3% for the preceding
+    // action+result pair and 10 / 25.8% for tool_sequence. Matching an incoming cluster
+    // to a ledger entry otherwise runs on class_hints alone, and those ARE fragments of
+    // the entry's own evidence quotes — one channel, where identity and proof are the
+    // same strings. These paths are mechanical, so carrying them adds a second channel
+    // without reintroducing an LLM distillation step.
+    for (const f of ss.files) cl.files.add(f);
   }
 
   const out = clusters.map(cl => {
@@ -2251,6 +2279,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       max_peak: peaks[peaks.length - 1],
       contexts: cl.contexts,
       errors: cl.errors,
+      files: [...cl.files].sort().slice(0, 8),  // referents: the discriminative match channel (see merge above)
       preceding: cl.preceding,          // #4: agent action + result just before the reaction
       self_suspect: allSelf || cl.anySelf,  // #3: a self-correction is present — LLM confirms target (advisory)
       top_keywords: topSh.slice(0, 10),

package/packages/opencode/command/docs-builder/docs-builder.cjs

@@ -1085,10 +1085,17 @@ const LINK_SKIP = /(^|\/)(CHANGELOG\.md|log\.md)$/;
 // moves is already covered by the resident check the instant its own git mv lands, before
 // rewriteLinks ever runs for it.
 let plannedArchiveSrc = new Set();
+// Set only for the duration of cleanup-apply's restore pass (see cleanupApply below), which
+// walks inbound references back from the archived copy to the relocated core page. That pass
+// must skip the split's own pages: they cite the original BY LINE NUMBER, so their `sources:`
+// and citations belong on the frozen archive copy, not on the shortened core page. A
+// predicate rather than a Set because the exemption is a directory prefix plus one file.
+let linkRestoreExempt = null;
 // One predicate, called from the one place rewriteLinks() loops over candidate files, so the
 // exemption can never desync across callers the way moveDoc's follow-ups almost did.
 function isRewriteExempt(f) {
-  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f);
+  return LINK_SKIP.test(f) || f.startsWith(REORG_DEST.archive + '/') || plannedArchiveSrc.has(f)
+    || (linkRestoreExempt !== null && linkRestoreExempt(f));
 }
 
 // A real corpus (astral-sh/uv) cross-links its docs with RELATIVE paths — `../concepts/x.md`,
@@ -1301,8 +1308,12 @@ function flushCommitAdvisory() {
     const outsideDocs = Array.from(new Set(outsideFiles.map(f => f.split('/')[0]))).sort();
     console.log(`\n${moveSet.length} rename(s) this run (git mv stages these automatically; `
       + 'the copy+unlink fallback used outside a git repo does not)');
+    // Unit, stated: linkSet holds FILE paths, so this is a file count. cleanup-apply's
+    // restore pass just below reports OCCURRENCES, and a real run printed "33" here next to
+    // "restored 38" — same-sounding nouns, two different units, and the reader has no way to
+    // tell they are not a discrepancy. Name the unit in both places.
     console.log(linkSet.length
-      ? `${linkSet.length} link rewrite(s) UNSTAGED` + (outsideFiles.length
+      ? `${linkSet.length} file(s) with link rewrites UNSTAGED` + (outsideFiles.length
         ? `, ${outsideFiles.length} outside docs/: ${outsideDocs.join(', ')}`
         : ' (all inside docs/)')
       : 'no inbound-link rewrites this run.');
@@ -2352,6 +2363,40 @@ function cleanupApply(file, outlineF, labelsF) {
         for (const m of r.artifactNotes) console.log(`    ${m}`);
         if (r.failures.length) console.error(`  WARN core page relocated, but ${r.failures.join('; ')}`);
         noteMoved(r.rel); noteLinks(r.linkFiles.map(x => x.file));
+
+        // FIELD BUG (real, reproduced): archiveOrThrow above rewrote EVERY inbound reference
+        // to point at docs/archive/, because at that moment the archive genuinely was the
+        // only copy. The relocation on the line above then put a live page back at the
+        // original path — so the corpus now tells readers that "the PRD" lives in the
+        // archive while the live page sits unreferenced. On a real split that was 33
+        // references across 15 files outside docs/, and it is precisely the backwards
+        // outcome this command exists to prevent. Walk them back.
+        //
+        // The ordering itself cannot be swapped: the original must vacate the path before
+        // the core page can occupy it, and rewriting links to a path nothing occupies yet
+        // would be worse. So the restore is a third step, not a reordering.
+        //
+        // EXEMPT, and this is the point of the pass rather than an edge case: the split's
+        // own pages cite the original BY LINE NUMBER, so their `sources:` and citations
+        // must stay on the frozen archive copy — as must the relocated core page's own.
+        // Rewriting those back would be a new bug wearing the old one's clothes.
+        const archivedRel = path.posix.join(REORG_DEST.archive, path.basename(file));
+        const pagesPrefix = pages.replace(/\/*$/, '') + '/';
+        linkRestoreExempt = f => f === r.rel || f.startsWith(pagesPrefix);
+        let restored;
+        try { restored = rewriteLinks(archivedRel, r.rel); }
+        finally { linkRestoreExempt = null; }
+        if (restored.skipped) {
+          console.log(`  ${restored.skipped}`);
+        } else if (restored.total) {
+          console.log(`  restored ${restored.total} inbound reference(s) from ${archivedRel} `
+            + `back to ${r.rel} (the archive step had aimed them at the frozen copy; `
+            + `${pagesPrefix} pages keep theirs, their citations are line-numbered)`);
+          for (const { file: lf, n } of restored.files) console.log(`    ${lf}: ${n}`);
+          noteLinks(restored.files.map(x => x.file));
+        } else {
+          console.log(`  no inbound references to ${archivedRel} needed restoring.`);
+        }
       } catch (e) {
         console.error(`  WARN could not relocate the core page from ${from} to ${to}: `
           + `${e.message} — it remains at ${from}.`);

package/packages/opencode/command/remember/friction.cjs

@@ -1765,8 +1765,26 @@ function extractToolsFromTurn(event) {
           const toolName = block.name || 'unknown';
           tools.push({ tool: toolName, action: 'call' });
         } else if (block.type === 'tool_result') {
-          const result = String(block.content || '');
-          if (result.includes('Exit code 0')) {
+          // The transcript marks a failed tool call with `is_error`; a success
+          // carries no sentinel in the result text. Reading the text for
+          // 'Exit code 0' matched 1 block in 2623 sampled from the real
+          // corpus, so `result` was 'unknown' on 31 of 34 clusters — and the
+          // case this field exists for is a CLAIMED success the user is
+          // contradicting, which is the one that never fired. Content is also
+          // sometimes an array of blocks (403/2623), which String() turned
+          // into "[object Object]" so no pattern could match it.
+          //
+          // A block with no `is_error` stays unknown on purpose: those are
+          // harness meta-results (skill/agent launches, question answers —
+          // 560/2624 sampled) and calling them success would inflate the very
+          // signal this field is here to detect.
+          const raw = block.content;
+          const result = Array.isArray(raw)
+            ? raw.map(b => (b && typeof b === 'object' ? (b.text || '') : String(b || ''))).join('\n')
+            : String(raw || '');
+          if (block.is_error === true) {
+            tools.push({ tool: 'result', action: 'error' });
+          } else if (typeof block.is_error === 'boolean') {
             tools.push({ tool: 'result', action: 'success' });
           } else if (/Exit code [1-9]|Traceback|Error/.test(result)) {
             tools.push({ tool: 'result', action: 'error' });
@@ -2142,6 +2160,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       errors: b.errors,
       peak: b.peak,
       texts: b.texts,
+      files: [...b.files],
       preceding: b.preceding,
       anySelf: b.selfVotes > 0,                        // at least one self-correction → warn, LLM confirms target
     };
@@ -2166,7 +2185,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     if (best) {
       cl = best;
     } else {
-      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null };
+      cl = { sig: new Set(), seedSig: new Set(ss.sig), shCount: new Map(), sessions: {}, signals: {}, contexts: [], errors: [], peaks: [], anySelf: false, preceding: null, files: new Set() };
       clusters.push(cl);
     }
     for (const s of ss.sig) { cl.sig.add(s); cl.shCount.set(s, (cl.shCount.get(s) || 0) + 1); }
@@ -2178,6 +2197,15 @@ function clusterCandidates(allCandidates, canonicalGroups) {
     cl.peaks.push(ss.peak);
     if (ss.anySelf) cl.anySelf = true;
     if (ss.preceding && (!cl.preceding || (ss.preceding.action !== 'none' || ss.preceding.error))) cl.preceding = ss.preceding;
+    // The file referents a cluster's sessions touched. Measured on a 34-cluster real
+    // corpus as the one channel that actually separates clusters: file basenames gave 28
+    // distinct signatures at a 3.7% collision rate, against 13 / 19.3% for the preceding
+    // action+result pair and 10 / 25.8% for tool_sequence. Matching an incoming cluster
+    // to a ledger entry otherwise runs on class_hints alone, and those ARE fragments of
+    // the entry's own evidence quotes — one channel, where identity and proof are the
+    // same strings. These paths are mechanical, so carrying them adds a second channel
+    // without reintroducing an LLM distillation step.
+    for (const f of ss.files) cl.files.add(f);
   }
 
   const out = clusters.map(cl => {
@@ -2251,6 +2279,7 @@ function clusterCandidates(allCandidates, canonicalGroups) {
       max_peak: peaks[peaks.length - 1],
       contexts: cl.contexts,
       errors: cl.errors,
+      files: [...cl.files].sort().slice(0, 8),  // referents: the discriminative match channel (see merge above)
       preceding: cl.preceding,          // #4: agent action + result just before the reaction
       self_suspect: allSelf || cl.anySelf,  // #3: a self-correction is present — LLM confirms target (advisory)
       top_keywords: topSh.slice(0, 10),