liteagents 2.22.1 → 2.24.0

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/refactor.md

@@ -1,12 +1,80 @@
 ---
 name: refactor
 description: Refactor [code]
-usage: /refactor <code-section>
-argument-hint: [file-or-function]
-allowed-tools: Read, Edit, Grep, Glob, Bash(npm test:*), Bash(npx jest:*), Bash(npx vitest:*), Bash(pnpm test:*), Bash(yarn test:*), Bash(pytest:*), Bash(python:*), Bash(go test:*), Bash(cargo test:*), Bash(make test:*), Bash(git diff:*)
+usage: /refactor <code-section> | /refactor (no args = fix-ledger mode)
+argument-hint: [file-or-function, or empty for the fix ledger]
+allowed-tools: Read, Edit, Grep, Glob, Bash(npm test:*), Bash(npx jest:*), Bash(npx vitest:*), Bash(pnpm test:*), Bash(yarn test:*), Bash(pytest:*), Bash(python:*), Bash(go test:*), Bash(cargo test:*), Bash(make test:*), Bash(git diff:*), Bash(git grep:*), Bash(git status:*), Bash(git rev-parse:*), Bash(git switch:*)
 ---
 Refactor $ARGUMENTS.
 
+## Guardrails
+- **Spawn a worker and explicitly select your tool's mid tier.** State the
+  tier on the spawn — do not omit it and rely on a default. An omitted tier
+  inherits the *parent's* tier, which is not the same thing as the balanced
+  one. Pick the judgment-capable tier that is cheaper and faster than your top
+  reasoning tier. **Not the cheapest/fastest tier**: on judgment work it
+  measurably degrades (misclassification rates several times higher). Choose by
+  tier, not by a vendor model name copied from this file — names drift, and
+  this command ships to several tools. Fall back to running inline if your tool
+  has no subagent mechanism.
+- **Escalate, never assume.** Anything you cannot decide, cannot verify, or
+  that this spec does not cover → **stop and report it to the orchestrator**
+  (the main session). Never improvise, never widen scope, never fix a side
+  issue you noticed along the way.
+- **The worker does the work itself — no delegation.** The fixer must **not**
+  spawn subagents of its own. Every edit it reports, and every test run it
+  cites, has to be one it made or ran with its own tool calls: a relayed "I
+  fixed it and the suite is green" from a sub-worker is hearsay, and this
+  command's whole output is the claim that a change landed and the tests still
+  pass. A fix that delegates its work is a report about a report.
+- **The HITL gates below belong to the orchestrator, not the worker.** A
+  subagent cannot hold a conversation with the user, so it cannot run a gate
+  that ends in *stop and ask*. When one trips — a failing test, a crossed
+  public API boundary, a change bigger than the bullet asked for — the worker
+  **stops there and hands the situation back**, with the options and its
+  reasoning but no choice made. The orchestrator asks. A worker that picks
+  revert / patch / update-test on the user's behalf has answered a question it
+  was never allowed to ask.
+- **Edit only what a surviving bullet names.** Ledger mode's scope is the
+  bullets that survive revalidation, one change per bullet — not the
+  neighbouring code, not the formatting, not a second finding noticed on the
+  way past. Anything else goes back to the orchestrator to become a new
+  bullet.
+- **Prove the blast radius with two checks, because neither sees what the
+  other does.** `git status --porcelain` at exit must list only files a
+  surviving bullet named — that is this command's scope guarantee, and unlike
+  `/branch-review` it is not expected to be empty. It cannot police the
+  memory directory: `.claude/` is normally gitignored, so porcelain stays
+  empty whether you deleted a fixed bullet, wrote nothing, or overwrote
+  `MEMORY.md`. So also take `md5sum .claude/remember/*` before you start and
+  again before you report, and show the comparison: only `fix-ledger.md` may
+  differ. `last-review.md` in particular is `/branch-review`'s to write —
+  a fixer that touches it forges the gate that judges its own work.
+
+## Ledger mode — `$ARGUMENTS` empty
+Work through `.claude/remember/fix-ledger.md`, the non-blocking findings
+`/branch-review` has accumulated. Everything below (goals, constraints,
+verification, HITL gates) still applies; this section only says what to
+refactor and how to close each item.
+
+1. **Tree must be clean and not on `main`.** The orchestrator runs this check
+   before spawning the worker, so a dirty tree costs no worker; the worker
+   then re-runs it as its own first act. `git status --porcelain` non-empty
+   → stop, say what is uncommitted. On `main` → `git switch -c chore/fix-ledger`.
+2. **Ledger missing or has zero bullets** → say so and stop. Nothing to do.
+3. **Revalidate every bullet first, fix nothing yet.** For each: `git grep -F
+   "<snippet>" -- <path>`. **No hit → delete the bullet** and list it as
+   "cleaned by other work". Hit → re-read the surrounding code; if the finding
+   no longer holds, delete the bullet with a one-line reason. What survives is
+   the work list.
+4. **Fix the survivors, one bullet per change**, under the constraints below.
+   Delete each bullet as its fix lands. A fix that turns out to need a
+   behaviour change is not a refactor — leave the bullet, note it in the report.
+5. Run the tests as described below. Then report: **fixed / dropped / left**
+   with the reason per left item, and the remaining bullet count.
+6. Say plainly: **commit, then run `/branch-review`** on this branch — ledger
+   mode is a fixer, not a review, and its diff gets the ordinary gate.
+
 ## Goals
 - Reduce complexity
 - Improve readability

package/packages/claude/commands/release.md

@@ -56,20 +56,48 @@ separate command that must have run first.
 A review must have run on this branch **at the current HEAD SHA**.
 
 **Compare the SHAs yourself; do not settle for an answer.** Run `git rev-parse
-HEAD` and compare it against the SHA the review recorded — `/branch-review`
-ends with `Reviewed at HEAD <sha>`. Asking the orchestrator "did a review run?"
-puts the question to the one party with an incentive to say yes, so its word is
-not evidence: obtain the review's own recorded SHA and match the two strings.
-**No recorded SHA to compare = no review**, never a pass.
+HEAD` and compare it against the `sha:` line in
+`.claude/remember/last-review.md`, which `/branch-review` writes. Asking the
+orchestrator "did a review run?" puts the question to the one party with an
+incentive to say yes, so its word is not evidence — and neither is a SHA
+quoted from a chat message, which is the same claim in another costume and is
+gone after a compaction or a handover. Read the file; match the two strings.
+**No such file, or no `sha:` line in it = no review**, never a pass. A review
+that predates this file's introduction has no record, so it does not count.
 
 - **No review**, or no recorded SHA obtainable → **stop**: "No review at
   `<sha>`. Run `/branch-review medium` (or `/code-review medium`) first."
 - **Stale** — recorded SHA ≠ `git rev-parse HEAD`, i.e. commits landed after
   the review (including fix commits) → **stop** and ask for a re-review. This
   is what makes "all findings fixed" checkable instead of promised.
+  **No exceptions — including the fix ledger.** It is normally gitignored, so
+  appending to it moves nothing and this never comes up. A repo that tracks
+  `.claude/` instead will see a ledger commit land after the review and make
+  it stale. That is the rule working, not a case to carve out: re-review, or
+  leave the ledger uncommitted until after the release.
+- **`coverage:` naming any stage `NOT RUN`** → **stop**. A `ready` from a run
+  that skipped the security stage is not the same fact as one that did not,
+  and this line is the only place the difference is visible to you.
+- **`verdict: blocked` in the record** → **stop**, even when the SHA matches.
+  Read that line as mechanically as the `sha:` one. A matching SHA proves a
+  review ran here; it says nothing about what the review concluded, and
+  leaving the conclusion to the orchestrator's recollection restores exactly
+  the unverified claim this file replaced. Only `verdict: ready` with a
+  matching SHA is a pass.
 - **Reviewed at this SHA with findings outstanding** → **stop**. Findings are
   resolved before a release is cut.
 
+This phase runs **before** `/release` writes anything, so the docs-and-bump
+commit it makes later cannot invalidate the review it just checked. That
+If Phase 2's docs sweep happens to correct a line that a fix-ledger bullet
+also names, that is ordinary sweep work — the doc changed with the feature,
+so it was already yours to update. **Do not delete the bullet.** `/refactor`
+is the only deleter, and its revalidation will drop that bullet on its next
+run when it finds the finding no longer holds. Deleting it here would make
+`/release` a second writer on state that has exactly one owner, and the whole
+value of the ledger's one-append-one-delete split is that it stays readable
+as a log.
+
 Report the comparison you actually ran: recorded `<sha>` vs HEAD `<sha>`,
 match yes/no.
 
@@ -141,15 +169,27 @@ orchestrator can run them on the user's named go:
 > Ready when you are:
 > 1. `git push -u origin <branch>`
 > 2. `gh pr create` into `main`
-> 3. `gh pr merge --admin --squash --delete-branch` (main is PR-protected;
+> 3. `gh pr checks <pr> --watch` — **merge only on green.** Every gate before
+>    this one ran on the same machine; CI is the only differently-configured
+>    instrument in the chain, and this is the first time it sees the branch.
+>    A test that passes locally because of a path, a fixture, or a tool that
+>    exists only on your box fails here and nowhere earlier. Read the exit
+>    code off the bare command. Red → stop, fix, re-review, and start again.
+> 4. `gh pr merge --admin --squash --delete-branch` (main is PR-protected;
 >    owner-authorized admin merge on a solo repo). **Keep `--squash`** — `gh`
 >    requires an explicit merge-method flag (`--squash` / `--merge` /
 >    `--rebase`); drop it and the command will not squash-merge.
-> 4. `git tag vX.Y.Z` on `main` and push the tag
-> 5. Publish **if this project has a publish path** (e.g.
+> 5. `git tag vX.Y.Z` on `main` and push the tag
+> 6. Publish **if this project has a publish path** (e.g.
 >    `gh workflow run publish.yml`) — manual by design
-> 6. Verify it is actually live (`npm view <pkg> version`, and the published
+> 7. Verify it is actually live (`npm view <pkg> version`, and the published
 >    tarball's contents), not the working tree
 
+**Every exit code in this sequence is read off the bare command, including
+the ones you type yourself.** `/ship`'s rule is not just for the worker: a
+pipeline reports its last element's status, so `gh run watch --exit-status |
+tail -2; echo $?` prints `0` for a failed run. That has already turned a red
+CI into a green reading in a real release.
+
 Final line: **Cut ✅ (vX.Y.Z — ready to push)** or **Blocked 🛑** with the
 specific reason.

package/packages/claude/commands/remember/AGENT_RULES.md

@@ -105,11 +105,14 @@ Before adding any external dependency, all of these must be true:
 
 - **Open-source only.** Always use open-source solutions. No vendor lock-in
 - **Lightweight over complex.** If two solutions solve the same problem, use the one with fewer moving parts, fewer dependencies, and less configuration
-- **Every line must have a purpose.** No speculative code, no "might need this later", no abstractions for one use case
+- **Every line earns its place.** If you can't say what breaks when it's deleted, delete it. No speculative code, no "might need this later", no abstractions for one use case. One function, one concern, one owner — small blocks beat spaghetti
 - **Simple > clever.** Readable code that a junior can follow beats elegant code that requires a PhD to debug
+- **One writer per piece of state.** One function assigns each field; everything else calls it. Grep who writes it before you write it. Ownership says *where*, not *when* — if a write can land from a callback, thread, or lifecycle, the reader must tell stale from fresh
+- **Split the decision from the machinery.** A branch whose outcome matters, tangled with a framework, IO, or UI object, moves into a pure function; the framework class applies the result. Extract to pin a branch, not to raise coverage — a one-line delegation in its own file buys a test that cannot fail
+- **Claims in comments must be checkable.** "The only place that writes X" is a claim — run the grep first, and expect the next reader to re-run it. A name search proves an edge exists, never that one doesn't
 - **Containerize only when necessary.** Start with a virtualenv or bare metal. Docker adds value for deployment parity and isolation — not for running a script
 - **Responsive web UI is mandatory in dev projects.** Any web UI must be usable on mobile by default — fluid layouts, viewport meta tag, breakpoints for narrow screens, no horizontal scroll. Test in DevTools device emulation before declaring a UI task done. POCs are exempt (validate the idea first), but the moment a POC graduates to a real project this becomes a hard requirement
-- **Surgical changes only.** Touch what the task requires; nothing else. Don't "improve" adjacent code, comments, or formatting. Match existing style even if you'd do it differently. Only clean up orphans your own change created — leave pre-existing dead code alone unless asked. Every changed line should trace directly to the request
+- **Surgical changes only.** Touch what the task requires; nothing else. Don't "improve" adjacent code, comments, or formatting. Match existing style even if you'd do it differently. Only clean up orphans your own change created. Dead code, nits, bugs you pass on the way: if it's inside or affects the code you're already changing, and the fix changes no behavior, fix it and say so. Otherwise report it — say what it costs to leave it. "It would be nicer" is not a cost. Every changed line traces to the request or to a fix you named
 
 ### Red Flags — Stop and Flag These
 - Over-engineering simple problems
@@ -121,6 +124,8 @@ Before adding any external dependency, all of these must be true:
 - Authoring a fixture/corpus that *guarantees* the result (a test that can't return the negative), or trusting a degenerate-looking number without auditing the harness for confounds — use real uncrafted data; the test must be able to fail
 - Fitting a POC to pass (narrowed input, moved threshold, shrunk scope) instead of reporting the failure; starting module N+1 while module N is unproven
 
+A problem you see and don't fix goes in the report, never in a comment. Comments are where findings go to be forgotten.
+
 ---
 
 ## Testing Standards
@@ -291,7 +296,11 @@ Copy this to any project's CLAUDE.md. These are mandatory rules, not suggestions
 
 **Lightweight over complex.** Fewer moving parts, fewer deps, less config. Express over NestJS, Flask over Django, unless the project genuinely needs the framework. Simple > clever. Readable > elegant.
 
-**Open-source only.** No vendor lock-in. Every line of code must have a purpose — no speculative code, no premature abstractions.
+**Open-source only.** No vendor lock-in. Every line of code earns its place — if you can't say what breaks when it's deleted, delete it. No speculative code, no premature abstractions.
+
+**One writer per piece of state.** One function assigns each field; everything else calls it. Grep who writes it before you write it — and if a write can land from a callback, thread, or lifecycle, the reader must tell stale from fresh.
+
+**Surgical changes only.** Touch what the task requires. Dead code, nits, bugs you pass: if it's inside or affects the code you're already changing and the fix changes no behavior, fix it and say so — otherwise report it and say what it costs to leave it. A problem you don't fix goes in the report, never in a comment.
 
 **Responsive web UI is mandatory.** Any web UI must work on mobile by default — fluid layouts, viewport meta, breakpoints, no horizontal scroll. Verify in DevTools device emulation before claiming a UI task is done. POCs exempt; real projects are not.
 

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/commands/remember.md

@@ -133,6 +133,14 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      Re-processing a stash whose episode is already filed must not create a near-duplicate
      pair. Every older episode is **folded, then deleted**: its lesson becomes a fact (handed
      to the rewrite above); the narrative is removed. No archive — git has the history.
+     **Specify the operation once.** The keep-10 rule is the rule; the set to remove is
+     *derived* from it, never supplied alongside it as a second list. Given both, an agent
+     applies both and removes their union — observed in the field: a run told to keep 10 and
+     handed a 5-entry delete list removed 7, and the 2 extras were never folded, so one
+     lesson left memory with nothing carrying it. **No episode is removed whose lesson has
+     not been folded into a fact first**, and the two sets must match: state the count
+     before, the count after, and name each episode removed. Removed-but-not-folded is a
+     defect to report, not a tidy-up.
    - **Antigens section**: only update from friction output (step 4)
    - Write merged result to `.claude/remember/MEMORY.md` in the format under step 5.
 
@@ -276,7 +284,11 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
        recurrence; a single occurrence has none to track yet. Friction re-scans every
        session log every run, so a later run matches it back to 2+ sessions and seeds it
        then — this does not change matching against an EXISTING entry, which is recurrence
-       regardless of the matching cluster's own session count.
+       regardless of the matching cluster's own session count. **A match is not an
+       increment.** Whether it counts as a new conversation is decided in 4c by
+       `friction.cjs count`, which is a no-op when that session hash is already stored — so
+       several matches against one entry routinely produce zero increments, and that is
+       correct, not a miscount.
      - For `new:<theme>` groups with no ledger match: distinct conversations = distinct
        cluster indices in the group (within one classify batch, no two cluster indices
        share a session hash). `sessions < 2` → writes nothing. `sessions >= 2` → new entry,
@@ -346,18 +358,39 @@ Reads all raw material (`.claude/stash/*.md` + `.claude/remember/friction/antige
      inline duplication is needed
    - If `.claude/remember/AGENT_RULES.md` exists (bootstrapped in step 1), compose a second,
      independent section between `<!-- AGENT_RULES:START -->` and `<!-- AGENT_RULES:END -->`
-     markers. Unlike MEMORY.md above, this is a **plain path pointer, never `@`-referenced**
-     — an `@`-reference hot-loads the whole file into every session, and this is a standards
-     guide to consult when designing/building something new, not hot context:
+     markers. Unlike MEMORY.md above, the file itself is **never `@`-referenced** — an
+     `@`-reference hot-loads all ~300 lines into every session, and it is a standards guide
+     to consult when designing/building something new, not hot context. The section carries
+     a path pointer plus exactly two inline rules: the ones that change what you TYPE, which
+     you cannot look up because you do not know you need them. Everything else stays behind
+     the pointer. Write the section verbatim, rules first:
      ```
      <!-- AGENT_RULES:START -->
+     **One writer per piece of state.** One function assigns each field; everything else
+     calls it. Grep who writes it before you write it — and if a write can land from a
+     callback, thread, or lifecycle, the reader must tell stale from fresh.
+
+     **Surgical changes only.** Touch what the task requires. Dead code, nits, bugs you
+     pass: if it's inside or affects the code you're already changing and the fix changes
+     no behavior, fix it and say so — otherwise report it and say what it costs to leave
+     it. A problem you don't fix goes in the report, never in a comment.
+
      Standards guide (read when designing/building something new, not hot context):
      .claude/remember/AGENT_RULES.md
      <!-- AGENT_RULES:END -->
      ```
-   - Each marker pair is independent: if CLAUDE.md already has a given pair, replace the
-     section between them; if not, append it at the end; if no CLAUDE.md exists, create one
-     containing whichever section(s) apply
+   - Each marker pair is independent: if CLAUDE.md lacks a given pair, append it at the
+     end; if a given pair already exists, replace its content in place; if no CLAUDE.md
+     exists, create one containing whichever section(s) apply.
+   - **An existing AGENT_RULES pair is left alone — bootstrap once, never overwrite.** The
+     block above is what to write when creating it, not a template to re-impose every run.
+     Users trim this section deliberately (a pointer-only variant is common), and rewriting
+     it silently re-adds text they removed, on every single run, forever. Observed in the
+     field: a run restored the inline rules into a CLAUDE.md whose owner had cut them, and
+     the edit had to be reverted by hand. This matches how `AGENT_RULES.md` itself is
+     handled — bootstrapped once, never overwritten after.
+   - If an existing pair is present but its **path pointer** is missing or wrong, that is
+     load-bearing: **report it and stop**, do not silently rewrite the section around it.
 
    ```markdown
    # Project Memory

package/packages/claude/commands/ship.md

@@ -20,6 +20,22 @@ its exit code**. A check you did not run is a **fail**, never a pass. **N/A
 requires a stated reason** ("no build script in `package.json`") — N/A must
 never stand in for "didn't get to it."
 
+**Capture the exit code of the command itself, never of a pipeline.** Run the
+bare command, then read `$?` on the next line:
+
+```
+node "$f" > /tmp/out 2>&1; e=$?
+```
+
+`$?` after a pipe is the *last element's* status, so the common shape
+`out=$(cmd 2>&1 | tail -1); echo "exit=$?"` reports `tail`'s success — `0` —
+for a suite that exited `2`. Reproduced: a check printing "exit 2:
+prerequisites missing" was recorded as a pass by exactly that loop. Nor does
+`${PIPESTATUS[0]}` rescue it inside a command substitution; it is empty by
+the time you read it. This is the rule the whole gate rests on, and the
+piped form is the natural way to write a multi-suite loop, so it fails
+silently and in the unsafe direction.
+
 ## Checklist
 - [ ] **Tests pass** — run the project's real test command (`npm test`,
       `pytest`, `go test ./...`, `cargo test`, `make test`).

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"
       },