liteagents 2.12.0 → 2.14.1

package/packages/opencode/command/{friction → remember}/friction.js

@@ -6,7 +6,7 @@
  *     node friction.js <sessions-directory>
  *     node friction.js ~/.claude/projects/-home-hamr-PycharmProjects-liteagents/
  *
- * Outputs (all in .opencode/friction/):
+ * Outputs (all in .opencode/remember/friction/):
  *     friction_analysis.json   - Per-session analysis
  *     friction_summary.json    - Aggregate stats
  *     friction_raw.jsonl       - Raw signals
@@ -1483,7 +1483,7 @@ function analyzeMain(sessionsDir) {
   }
 
   // Create output dir
-  const outputDir = '.opencode/friction';
+  const outputDir = '.opencode/remember/friction';
   fs.mkdirSync(outputDir, { recursive: true });
 
   // Process each session
@@ -1641,12 +1641,12 @@ function analyzeMain(sessionsDir) {
 
   // Output files
   console.log('Outputs:');
-  console.log('  \uD83D\uDCCA .opencode/friction/report.md (detailed analysis)');
-  console.log('  \uD83D\uDCCB .opencode/friction/antigen_review.md (clustered failure patterns)');
-  console.log(`  \uD83D\uDCC1 .opencode/friction/*.json (raw data: ${allSignals.length} signals, ${analyses.length} sessions)`);
+  console.log('  \uD83D\uDCCA .opencode/remember/friction/report.md (detailed analysis)');
+  console.log('  \uD83D\uDCCB .opencode/remember/friction/antigen_review.md (clustered failure patterns)');
+  console.log(`  \uD83D\uDCC1 .opencode/remember/friction/*.json (raw data: ${allSignals.length} signals, ${analyses.length} sessions)`);
   console.log();
 
-  console.log('Next: Review .opencode/friction/report.md');
+  console.log('Next: Review .opencode/remember/friction/report.md');
   console.log('='.repeat(60));
 
   if (errors.length > 0) {
@@ -2196,9 +2196,9 @@ function clusterCandidates(allCandidates) {
 
 function extractMain(sessionsDir) {
   // Load friction analysis
-  const analysisFile = '.opencode/friction/friction_analysis.json';
+  const analysisFile = '.opencode/remember/friction/friction_analysis.json';
   if (!fs.existsSync(analysisFile)) {
-    console.log('Error: Run friction analysis first to generate .opencode/friction/friction_analysis.json');
+    console.log('Error: Run friction analysis first to generate .opencode/remember/friction/friction_analysis.json');
     return 1;
   }
 
@@ -2211,7 +2211,7 @@ function extractMain(sessionsDir) {
   }
 
   // Load raw signals
-  const rawFile = '.opencode/friction/friction_raw.jsonl';
+  const rawFile = '.opencode/remember/friction/friction_raw.jsonl';
   let signals = [];
   if (fs.existsSync(rawFile)) {
     const rawContent = fs.readFileSync(rawFile, 'utf-8');
@@ -2266,7 +2266,7 @@ function extractMain(sessionsDir) {
   console.log();
 
   // Save outputs
-  const outputDir = '.opencode/friction';
+  const outputDir = '.opencode/remember/friction';
   fs.mkdirSync(outputDir, { recursive: true });
 
   // Raw candidates (kept for debugging)
@@ -2340,7 +2340,7 @@ function extractMain(sessionsDir) {
   });
 
   fs.writeFileSync(path.join(outputDir, 'antigen_review.md'), reviewLines.join(''));
-  console.log('Output: .opencode/friction/antigen_review.md\n');
+  console.log('Output: .opencode/remember/friction/antigen_review.md\n');
 
   return 0;
 }
@@ -2358,7 +2358,7 @@ Usage:
     node friction.js <sessions-directory>
     node friction.js ~/.claude/projects/-home-hamr-PycharmProjects-liteagents/
 
-Outputs (all in .opencode/friction/):
+Outputs (all in .opencode/remember/friction/):
     friction_analysis.json   - Per-session analysis
     friction_summary.json    - Aggregate stats
     friction_raw.jsonl       - Raw signals
@@ -2385,7 +2385,7 @@ Outputs (all in .opencode/friction/):
   analyzeMain(sessionsDir);
 
   // Check if analysis produced output
-  const analysisFile = '.opencode/friction/friction_analysis.json';
+  const analysisFile = '.opencode/remember/friction/friction_analysis.json';
   if (!fs.existsSync(analysisFile)) {
     console.log('\nNo analysis output. Check session directory.');
     return 1;
@@ -2401,7 +2401,7 @@ Outputs (all in .opencode/friction/):
   console.log(' DONE');
   console.log('='.repeat(60));
 
-  const reviewFile = '.opencode/friction/antigen_review.md';
+  const reviewFile = '.opencode/remember/friction/antigen_review.md';
   if (fs.existsSync(reviewFile)) {
     console.log('\nReview your antigens:');
     console.log(`  cat ${reviewFile}`);

package/packages/opencode/command/remember.md

@@ -10,10 +10,17 @@ Run friction analysis, then consolidate session stashes + friction antigens into
 - Favor straightforward, minimal implementations first and add complexity only when requested or clearly required.
 - Keep changes tightly scoped to the requested outcome.
 - **Precision over recall for hot memory.** A false antigen loaded into `@MEMORY.md` steers every future session. When unsure, record as a low-confidence episode — do not promote.
+- **Mid-tier model, not hardcoded.** Steps 2/3/4a delegate to a mid-tier model — capable of
+  semantic judgment, cheaper/faster than your top reasoning tier (e.g. Claude's Sonnet vs
+  Opus). Use whatever your tool designates as that balanced default; never hardcode a
+  vendor-specific model name.
+- **Batch independent subagent calls.** Step 2's per-stash extractions are independent of
+  each other — spawn them concurrently (parallel/background subagent calls in one turn)
+  where your tool supports it, instead of processing stashes one at a time.
 
 **What it does**
 
-Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clusters.json`), extracts durable facts, episodes, and behavioral antigens into a single `.opencode/memory/MEMORY.md`, then injects a managed memory section into `AGENTS.md`.
+Reads all raw material (`.opencode/stash/*.md` + `.opencode/remember/friction/antigen_clusters.json`), extracts durable facts, episodes, and behavioral antigens into a single `.opencode/remember/MEMORY.md`, then injects a managed memory section into `AGENTS.md`.
 
 **Steps**
 
@@ -23,7 +30,7 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
    project are behavioral lessons worth keeping everywhere. So point it at the tool's
    **global sessions root** (all projects), not a per-project directory.
 
-   - **Locate `friction.js`** — it is bundled next to this command at `friction/friction.js`
+   - **Locate `friction.js`** — it is bundled next to this command at `remember/friction.js`
      (the same directory as `remember.md`, whether installed or run from the package). If it
      exists nowhere, skip to step 1 (stash-only) and tell the user friction.js is missing.
    - **Resolve the global sessions root** — probe this list top-to-bottom, use the first that
@@ -41,7 +48,7 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
      > will resolve but yield no signals until friction learns their formats — open an issue
      > to request one: https://github.com/hamr0/liteagents/issues
    - **Run** `node <friction.js> "<resolved-root>"`. friction writes its output to
-     `.opencode/friction/` in the current project.
+     `.opencode/remember/friction/` in the current project.
    - **On any miss — loud, never silent.** If no root resolves, or friction errors, or it
      finds no usable sessions, print this and continue with stash-only consolidation:
      > ⚠️ Friction didn't run — no sessions found. To enable it, open this command file
@@ -49,27 +56,41 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
      > list in step 0, then re-run `/remember`. Consolidating stashes only this time.
 
 1. **Gather sources**
+   - **Legacy layout migration (one-time, loud).** Older versions used `.opencode/memory/` and
+     `.opencode/friction/`. If either exists: move the pipeline files
+     `.opencode/memory/{MEMORY.md,ledger.json,.processed}` → `.opencode/remember/`, and **discard**
+     the old `.opencode/friction/` contents entirely — friction regenerates all of its output
+     fresh every run (step 0 has already rebuilt it in `.opencode/remember/friction/` by the time
+     migration runs; stale copies carry no unique information and moving them would overwrite
+     fresh output). **Move only those pipeline files** — anything else in `.opencode/memory/`
+     (e.g. user-owned rule files) stays where it is. Remove the old dirs only if empty, update the managed MEMORY section in AGENTS.md to
+     the new reference (step 5), and tell the user exactly what moved.
+   - **Bootstrap `AGENT_RULES.md` (one-time, silent-if-present).** If
+     `.opencode/remember/AGENT_RULES.md` does not exist, copy it from the bundled template next
+     to this command (`remember/AGENT_RULES.md`, same directory as `friction.js`). If it
+     already exists, leave it untouched — never overwrite, even if the bundled template
+     changes in a later version; it becomes user-owned the moment it lands in the project.
    - Read all `.opencode/stash/*.md` files in the current project
-   - Read friction output written in step 0: `.opencode/friction/antigen_clusters.json` (preferred) or `.opencode/friction/antigen_review.md` (fallback)
-   - Read existing `.opencode/memory/MEMORY.md` if it exists — create dir if missing
-   - Read processed manifest at `.opencode/memory/.processed` — skip already-processed stashes
+   - Read friction output written in step 0: `.opencode/remember/friction/antigen_clusters.json` (preferred) or `.opencode/remember/friction/antigen_review.md` (fallback)
+   - Read existing `.opencode/remember/MEMORY.md` if it exists — create dir if missing
+   - Read processed manifest at `.opencode/remember/.processed` — skip already-processed stashes
    - If no unprocessed stashes AND friction produced no new antigens, report "nothing to consolidate" and stop
 
-2. **Extract from unprocessed stashes** (use Task tool with sonnet model for each)
-   - For each unprocessed stash, call sonnet to extract:
+2. **Extract from unprocessed stashes** (spawn one subagent per stash, in parallel — see Guardrails)
+   - For each unprocessed stash, call the mid-tier model (see Guardrails) to extract:
      - **FACTS** (atomic, one-line): stable preferences, decisions, corrections, explicit "remember this"
      - **EPISODE** (3-5 bullet narrative): what was the goal, what was tried, outcome, lesson
      - **SKIP**: code details, file paths, errors, mechanical steps, LLM responses
    - Collect all new facts and episodes
 
 3. **Merge into MEMORY.md**
-   - Read existing `.opencode/memory/MEMORY.md` and parse its sections (## Facts, ## Episodes, ## Antigens)
-   - **Facts section**: call sonnet with existing facts + newly extracted facts
+   - Read existing `.opencode/remember/MEMORY.md` and parse its sections (## Facts, ## Episodes, ## Antigens)
+   - **Facts section**: call the mid-tier model with existing facts + newly extracted facts
      - Rules: new updates replace old, contradictions keep new version, duplicates dropped
      - Keep facts atomic, one line each
    - **Episodes section**: append new episode entries (append-only, timestamped, no dedup)
    - **Antigens section**: only update from friction output (step 4)
-   - Write merged result to `.opencode/memory/MEMORY.md` in the format under step 6.
+   - Write merged result to `.opencode/remember/MEMORY.md` in the format under step 6.
 
 4. **Distill friction into antigens** (only if friction output exists)
 
@@ -83,9 +104,9 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
    > *themselves*). **You work from these short quotes — never re-read the session
    > logs.** Friction's lexical grouping and flags are hints, not the verdict.
 
-   - Read `.opencode/friction/antigen_clusters.json`.
+   - Read `.opencode/remember/friction/antigen_clusters.json`.
    - **4a. Classify target, then semantically consolidate** (the parts lexical matching can't do).
-     Call sonnet with the cluster quotes + their `preceding`/`projects`/`sessions`/`self_suspect`
+     Call the mid-tier model with the cluster quotes + their `preceding`/`projects`/`sessions`/`self_suspect`
      (NOT the logs), and have it:
      1. **Decide the target of each reaction — agent or self.** Drop *self/context*
         corrections where the user redirected themselves ("wrong project", "wrong window",
@@ -114,21 +135,80 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
        - **High** (5+ sessions) → loaded hot via `@MEMORY.md`
        - **Medium** (3-4 sessions) → recorded under Antigens, *not* loaded hot
        - **Low** (<3 sessions) → keep as Episode only
+   - **Recurrence tiers bind everything, including LLM-merged groups:** merging consolidates
+     evidence, it never elevates it — a merged group's tier comes from its combined
+     distinct-session count (e.g. a 2-session merged group is still Low → Episode + ledger
+     `observing`, not an antigen entry in MEMORY.md).
    - **Never auto-promote.** Only High-confidence (5+ sessions) antigens load hot. A
      single dramatic correction is an Episode, not an antigen.
    - Update the Antigens section in MEMORY.md (promote/demote based on new recurrence).
+   - **4c. Update the antigen ledger** (`.opencode/remember/ledger.json`) — the evidence trail
+     linking each rule to the mistake it targets and whether it is working. Create it as
+     `{"version": 1, "entries": []}` if missing. It is JSON for exact matching — bookkeeping
+     only, never injected into context as guidance (MEMORY.md is what gets read; the ledger
+     is what gets checked).
 
-5. **Inject memory reference into AGENTS.md**
+     Entry shape:
+     ```json
+     { "id": "ag-001", "class": "claimed-done-not-verified",
+       "class_hints": ["says pushed but", "none got it"],
+       "status": "observing|hot|rejected|escalated",
+       "rule": "<current phrasing>",
+       "attempts": [{ "n": 1, "rule": "<phrasing>", "adopted": "YYYY-MM-DD", "outcome": "active|failed" }],
+       "evidence": { "sessions": 0, "projects": [], "quotes": [], "last_seen": "YYYY-MM-DD" },
+       "recurred_while_hot": 0,
+       "history": [{ "date": "YYYY-MM-DD", "event": "<transition>" }] }
+     ```
+
+     For each surviving antigen from 4a/4b, match against existing entries by `class_hints`
+     (the mistake class, not the rule wording — rules change, the class doesn't):
+     - **No match** → new entry, `status: "observing"`, attempt 1, history "candidate (N sessions)".
+     - **Match, `observing`** → merge evidence (sessions, quotes, projects, last_seen).
+       Crosses the 4b hot threshold → `status: "hot"`, history "promoted to hot (N sessions)".
+     - **Match, `hot`** → the mistake happened *while its rule was loaded*:
+       `recurred_while_hot += 1`, merge evidence, history "recurred while hot (count)".
+       - At `recurred_while_hot >= 2`: the phrasing failed. Mark the current attempt
+         `outcome: "failed"`, draft attempt n+1 — it must differ from **every** prior
+         attempt's text in this entry (failed attempts are the rejected-edit buffer: never
+         re-propose one verbatim) — replace `rule`, update MEMORY.md's Antigens section,
+         reset `recurred_while_hot` to 0.
+       - If 2 attempts have already failed and the antigen persists → `status: "escalated"`:
+         remove the rule from MEMORY.md's hot section, record a Fact instead ("persistent
+         failure mode: <class> — no phrasing reduces it"), and flag it in the step-7 report.
+         **Flag, don't act** — the user decides: enforcement (a hook, where the tool has
+         them) or accepted limit.
+     - **Match, `escalated`/`rejected`** (rejected = user veto) → merge evidence only; never re-propose.
+
+     Consistency: MEMORY.md's Antigens section is the render; the ledger is the record —
+     after 4c every hot antigen in MEMORY.md has a matching `hot` ledger entry. Mutations
+     are append-friendly: merge evidence and change status, never delete entries or history
+     lines. If ledger.json is malformed, say so loudly, move it aside as
+     `ledger.json.bad-<date>`, and start fresh — never silently overwrite.
+
+5. **Inject memory + rules references into AGENTS.md**
    - Compose the section between `<!-- MEMORY:START -->` and `<!-- MEMORY:END -->` markers:
      ```
      <!-- MEMORY:START -->
-     @MEMORY.md
+     @.opencode/remember/MEMORY.md
      <!-- MEMORY:END -->
      ```
-   - The `@MEMORY.md` reference points to `.opencode/memory/MEMORY.md` — Claude loads the full file directly, so no inline duplication is needed
-   - If AGENTS.md already has MEMORY markers, replace the section between them
-   - If AGENTS.md has no MEMORY markers, append the section at the end
-   - If no AGENTS.md exists, create one with just the memory section
+   - The reference is an **explicit path** (`@.opencode/remember/MEMORY.md`) — `@`-references
+     resolve relative to the file containing them, so a bare `@MEMORY.md` in the project root
+     would point at a nonexistent root-level file. Claude loads the full file directly, so no
+     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:
+     ```
+     <!-- AGENT_RULES:START -->
+     Consult when building something new or adding a feature — a standards guide, not hot
+     context like MEMORY.md above:
+     @.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
 
    ```markdown
    # Project Memory
@@ -153,19 +233,31 @@ Reads all raw material (`.opencode/stash/*.md` + `.opencode/friction/antigen_clu
    ```
 
 6. **Update processed manifest**
-   - Append paths of newly processed stashes to `.opencode/memory/.processed`
+   - Append paths of newly processed stashes to `.opencode/remember/.processed`
 
-7. **Report to user**
+7. **Report to user** — print it AND write the same content to `.opencode/remember/report.md`
+   (overwritten each run; the ledger keeps history — the report is just the latest snapshot)
    - Number of stashes processed
    - Facts count (total, new)
    - Episodes count (total, new)
    - Antigens count by confidence tier, with how many newly promoted to hot
+   - Ledger lines — one per non-observing entry: id, short rule, status, recurrences since
+     adoption. Highlight rephrased (RECURRED) and ESCALATED entries; escalations need a
+     user decision, e.g.:
+     ```
+     ledger: ag-001 "verify live after publish"  hot, 0 recurrences since 2026-07-10
+     ledger: ag-003 "don't commit per change"    RECURRED while hot (2/2) → rephrased, attempt 2
+     ledger: ag-002 "literal scoped ask"         ESCALATED → Fact; 2 phrasings failed. Hook or accept?
+     ```
+   - If AGENT_RULES.md was bootstrapped this run, say so (one line)
    - Confirm MEMORY.md and AGENTS.md updated
 
-**File locations (all project-local)**
-- Memory file: `.opencode/memory/MEMORY.md` (single source of truth, referenced as @MEMORY.md)
+**File locations (all project-local — two dirs: `/stash` owns `.opencode/stash/`, `/remember` owns `.opencode/remember/`)**
 - Stash files: `.opencode/stash/*.md`
-- Friction output: `.opencode/friction/antigen_clusters.json` (observed-reaction clusters: theme, suggested_artifact, confidence, severity, sessions, projects, contexts)
-- Friction fallback: `.opencode/friction/antigen_review.md` (human-readable clusters)
-- Processed manifest: `.opencode/memory/.processed`
-- Output: `AGENTS.md` (managed MEMORY section with @MEMORY.md reference)
+- Memory file: `.opencode/remember/MEMORY.md` (single source of truth, referenced as `@.opencode/remember/MEMORY.md`)
+- Rules template: `.opencode/remember/AGENT_RULES.md` (bootstrapped once from the bundled package template on first `/remember` run, never overwritten again — user-owned after that; referenced as `@.opencode/remember/AGENT_RULES.md`)
+- Antigen ledger: `.opencode/remember/ledger.json` (per-rule evidence trail: class, status, attempts/rejected-buffer, recurrence-while-hot)
+- Consolidation report: `.opencode/remember/report.md` (latest step-7 report, overwritten each run)
+- Processed manifest: `.opencode/remember/.processed`
+- Friction output (transient, regenerated each run): `.opencode/remember/friction/` — `antigen_clusters.json` (preferred input), `antigen_review.md` (fallback), plus raw analysis files
+- Output: `AGENTS.md` (managed MEMORY section, plus an AGENT_RULES section once bootstrapped)

package/packages/opencode/command/stash.md

@@ -18,7 +18,7 @@ Save session context for compaction recovery or handoffs.
 4. Creates stash file in `.opencode/stash/`
 5. Enables context restoration after compaction
 6. **Consolidation nudge** — after saving, count the unprocessed backlog:
-   `unprocessed = (files in .opencode/stash/*.md) − (entries in .opencode/memory/.processed)`
+   `unprocessed = (files in .opencode/stash/*.md) − (entries in .opencode/remember/.processed)`
    (a missing `.processed` manifest means 0 processed). If `unprocessed >= 5`, end with one line:
    > 📝 N stashes since last consolidation — run `/remember` to fold them into memory.
 

package/packages/subagentic-manual.md

@@ -161,10 +161,17 @@ and wiring the memory into your agent config file.
    stored; running `/remember` clears the backlog.
 2. **`/remember`** - Runs friction analysis first (best-effort — scores sessions across *all* your
    projects from the tool's global sessions root, clusters failures into antigens), then
-   consolidates stashes + antigens into `…/memory/MEMORY.md` and injects `@MEMORY.md` into the
+   consolidates stashes + antigens into `…/remember/MEMORY.md` and injects `@MEMORY.md` into the
    **per-tool agent config — `CLAUDE.md` (Claude Code), `AGENTS.md` (Droid / OpenCode), or
    `AGENT.md` (Ampcode)** — so every future session loads it. Each package writes to its own
-   tool's config file; the global probe list only governs which logs friction *reads*.
+   tool's config file; the global probe list only governs which logs friction *reads*. Per-stash
+   extraction runs as concurrent subagent calls on a mid-tier model — no vendor-specific model
+   name hardcoded, so it works with whatever your tool has configured.
+3. **`AGENT_RULES.md` bootstrap** - On first `/remember` run, if `…/remember/AGENT_RULES.md`
+   doesn't exist, it's copied from a bundled standards-guide template — never overwritten again
+   after that, so local edits persist — and injected into the agent config via its own
+   independent marker pair. It's a guide to consult when building something new, separate from
+   the MEMORY.md hot-context block above.
 
 **Result:** Project-local memory that accumulates across sessions — no external dependencies, no databases, just markdown.