liteagents 2.22.1 → 2.24.0

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),

package/packages/opencode/command/remember.md

@@ -133,6 +133,14 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/remember/friction/an
      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 `.opencode/remember/MEMORY.md` in the format under step 5.
 
@@ -276,7 +284,11 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/remember/friction/an
        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 (`.opencode/stash/*.md` + `.opencode/remember/friction/an
      inline duplication is needed
    - If `.opencode/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):
      .opencode/remember/AGENT_RULES.md
      <!-- AGENT_RULES:END -->
      ```
-   - Each marker pair is independent: if AGENTS.md already has a given pair, replace the
-     section between them; if not, append it at the end; if no AGENTS.md exists, create one
-     containing whichever section(s) apply
+   - Each marker pair is independent: if AGENTS.md lacks a given pair, append it at the
+     end; if a given pair already exists, replace its content in place; if no AGENTS.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 AGENTS.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/opencode/command/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`).