chore(release): prepare v1.5.2

Merge branch 'feat/deprecate-safety-critical'
chore(release): prepare v1.5.1
2026-07-17 12:56:42 +02:00 · 2026-05-01 16:00:44 +08:00 · 2026-04-30 19:54:50 +08:00 · 2026-04-30 19:54:24 +08:00 · 2026-04-30 18:38:29 +08:00 · 2026-04-30 18:06:28 +08:00
58 changed files with 1782 additions and 7147 deletions
@@ -5,94 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## [1.6.0] - 2026-05-08
-
-### Added
-
- Numbered compaction memory references (`[M1]`, `[M2]`, ...) for existing rendered workspace memories.
- Compaction memory commands: `REINFORCE [M#]` for retention reinforcement and `REPLACE [M#] [type] text` for protected replacement.
- `CompactionMemoryRef` session-state snapshots with optional compaction IDs for overlap detection.
- Evidence events for numbered memory command outcomes: `memory_reinforced`, `memory_replaced_numbered_ref`, and `memory_reverted_numbered_ref`.
- Public `memory-diag commands` report for command counts, outcomes, rejection reasons, protected replacement blocks, malformed commands, and latest command events.
- Public dry-run-first `memory-diag revert` command for manually reverting successful numbered replacements by replacement memory ID or evidence event ID.
- Hard quality rejection reasons for unresolved questions, transient bug/debug state, and deployment snapshots.
- Soft `terse_label` diagnostic for very short label-like candidates.
- Regression tests for command parsing, REINFORCE, protected REPLACE, revert behavior, compaction ref validation, overlap protection, and fallback behavior when the model omits the compaction snapshot ID.
-
-### Changed
-
- Compaction prompts now include numbered memory refs and concise memory-operation rules instead of asking the model to reuse existing wording exactly.
- Compaction no longer duplicates hot session state inside the compaction prompt; hot state remains available in normal prompt context.
- Duplicate maintenance now prefers explicit REINFORCE or protected REPLACE evidence over silent duplicate restatement.
- Rendered decision memory cap increased from 10 to 12 while keeping the global rendered cap at 28.
- Rejected memory command evidence now uses neutral `target` relations instead of lifecycle-mutating `reinforced` or `superseded` relation roles.
- `memory-diag` public command metadata now includes `commands` and `revert` alongside `status`, `rejected`, `missing`, and `explain`.
-
-### Fixed
-
- Overlapping same-session compactions can no longer silently apply numbered commands against the wrong snapshot when the snapshot ID is present.
- Numbered command resolution now rejects stale refs whose memory ID, status, or exact key no longer match the current workspace memory entry.
- Protected replacements are surfaced as first-class diagnostics instead of being buried in generic rejection counts.
-
-### Recovery note
-
-Successful numbered replacements supersede the original memory and add a replacement. To inspect or recover one, run `memory-diag commands --verbose`, then dry-run `memory-diag revert --memory <replacement-memory-id>` or `memory-diag revert --event <event-id>` before adding `--apply`.
-
-## [1.5.5] - 2026-05-05
-
-### Added
-
- Section-aware greedy line accumulator for hot session state rendering that fits whole lines instead of truncating mid-line.
- `accountHotSessionStateRender()` accounting function returning prompt text, omitted items, and char budget for v2 evidence extension.
- Exported types for render accounting diagnostics: `HotStateSection`, `HotStateOmissionReason`, `HotStateOmittedItem`, `HotSessionStateRenderAccounting`.
- 9 direct unit tests for hot session state rendering covering empty state, ranking, section caps, char budget, boundary conditions, header suppression, wrapper parity, and newline counting.
- Two-layer omission model: section caps first (`section_cap`), then char budget (`char_budget`), with clear per-item omission reasons.
-
-### Changed
-
- Hot session state rendering no longer uses blunt `.slice(0, maxRenderedChars)` prompt truncation.
- Header-only sections are suppressed: a section is only rendered if at least one entry line fits the char budget.
- `renderHotSessionState()` is now a delegation wrapper to `accountHotSessionStateRender().prompt`, preserving backward compatibility.
- Fixed `docs/configuration.md` active-file ranking formula: was `count * action_weight * recency_decay` with weights 4/3/2/1, now correctly `ACTION_WEIGHT[action] + count * 3` with weights edit 50, write 45, grep 30, read 20, tie-break by `lastSeen` descending.
- Clarified `README.md` system prompt injection order: workspace memory and hot state index positions depend on whether workspace memory state is available.
-
-### Fixed
-
- Hot session state prompt could be truncated mid-line under the old `.slice()` budget enforcement.
-
-## [1.5.4] - 2026-05-02
-
-### Changed
-
- Centralized the supported `memory-diag` command metadata for the official public commands: `status`, `rejected`, `missing`, and `explain`.
- Removed pre-public legacy aliases so unsupported spellings now use the standard unknown-subcommand path instead of carrying v2.0 compatibility debt.
- Kept `coverage` and `audit` as hidden maintainer diagnostics with neutral maintainer-only notices.
- Removed public npm script exposure for the internal workspace cleanup tool while keeping the development tool in the repository.
-
-### Fixed
-
- Moved missing-memory disappearance detail formatting into the official `missing` formatter before deleting legacy disappearance formatter code.
-
-## [1.5.3] - 2026-05-02
-
-### Added
-
- Published the read-only `memory-diag` package binary for package-qualified `npx --package opencode-working-memory memory-diag` usage.
- Added user-facing diagnostics commands for concise status, rejected memory review, missing memory review, and per-memory explanation.
-
-### Changed
-
- Reworked the diagnostics CLI into focused command, model, formatter, and utility modules while preserving legacy aliases and maintainer diagnostics.
- Updated README and configuration docs to document the supported `memory-diag` CLI workflow and package-qualified `npx` usage.
- Raised the Node.js requirement to `>=22.6.0` for the TypeScript diagnostics CLI runtime.
-
-### Fixed
-
- Avoided repeated workspace snapshot construction in status diagnostics.
- Replaced per-memory evidence summary lookups with grouped evidence processing to avoid N+1 diagnostics work.
- Added top-level CLI error handling for cleaner user-facing failures.
- Removed a diagnostics model circular dependency by extracting evidence grouping helpers to a neutral module.
-
 ## [1.5.1] - 2026-04-30

 ### Added
@@ -29,7 +29,6 @@ Use it when you want your agent to remember things like:
 - **Hot session state** — active files, open errors, and current working context for the current session.
 - **Explicit memory triggers** — users can say “remember this”, “記住”, “覚えて”, or “기억해” to save durable facts.
 - **Compaction-based extraction** — memory extraction piggybacks on OpenCode’s existing compaction flow.
- **Numbered memory refs** — compaction can `REINFORCE [M#]` useful memories or safely `REPLACE [M#]` obsolete compaction memories.
 - **No manual tools** — memory is injected automatically into the system prompt.
 - **Quality guards** — filters noisy memories, temporary progress snapshots, stack traces, raw errors, and credentials.
 - **Retention decay** — keeps the strongest memories in prompt context while older or weaker memories fade out naturally; important and reinforced memories decay more slowly.
@@ -86,13 +85,11 @@ OpenCode Working Memory adds durable memory without making extra LLM/API calls.
                   ▼
 ┌──────────────────────────────────────┐
 │ ⚡ Prompt Context                     │
-│ system[1]*: frozen workspace memory  │
-│ system[2+]*: hot session state       │
+│ system[1]: frozen workspace memory   │
+│ system[2+]: hot session state        │
 └──────────────────────────────────────┘
 ```

-\* Conceptually, workspace memory is pushed first when it is non-empty, and hot session state is pushed after workspace memory. If workspace memory is empty, hot state may be the first plugin-added system message. Actual `system[]` indices also depend on OpenCode and other plugins, so `system[1]` / `system[2+]` is a simplified model.
-
 **Zero extra API calls:** OpenCode Working Memory does not call the model on its own. Memory extraction is folded into OpenCode's built-in compaction request.

 **Cache-friendly layout:** durable workspace memory is rendered as a stable frozen snapshot for the session, while fast-changing hot session state is appended separately. Compaction starts a new cache epoch, refreshing the workspace snapshot after pending memories are promoted.
@@ -203,57 +200,30 @@ The goal is to remember durable facts, not every detail.

 Historical cleanup is intentionally conservative: extraction-time filtering may reject more aggressively, but one-time migration cleanup only supersedes high-confidence garbage patterns. This protects existing durable memories written in declarative style, such as "API endpoint is X" or "Product branding is Y".

-### Numbered Memory Refs
-
-During compaction, existing workspace memories may be shown as numbered refs such as `[M1]` or `[M2]`. The model can use these refs to maintain memory without duplicating it:
-
-```md
-REINFORCE [M1]
-REPLACE [M2] project Updated durable project fact.
-```
-
- `REINFORCE [M#]` strengthens an existing memory's retention signal without changing its text.
- `REPLACE [M#] [type] text` supersedes a safe compaction-sourced memory and adds a replacement.
- Manual, explicit, and already-reinforced memories are protected from automatic replacement.
- Stale or mismatched numbered refs are rejected instead of mutating the wrong memory.
-
-Use `memory-diag commands` to inspect command outcomes and `memory-diag revert` to dry-run and apply manual recovery for successful numbered replacements.
-
-### Memory Diagnostics CLI
-
-Use the read-only diagnostics CLI when you want to understand what memory is doing for the current workspace.
-
-| Question | Command |
-|---|---|
-| Is memory healthy? | `npx --package opencode-working-memory memory-diag` or `npx --package opencode-working-memory memory-diag status` |
-| Why was something rejected? | `npx --package opencode-working-memory memory-diag rejected` |
-| Where did my memory go? | `npx --package opencode-working-memory memory-diag missing` |
-| Why is this memory shown or hidden? | `npx --package opencode-working-memory memory-diag explain <memory-id>` |
-| How are numbered memory commands behaving? | `npx --package opencode-working-memory memory-diag commands` |
-| Revert a numbered replacement? | `npx --package opencode-working-memory memory-diag revert --memory <replacement-memory-id>` |
-
-Global options:
-
- `--workspace <path>` — inspect another workspace; defaults to the current directory.
- `--verbose` — show detailed diagnostics.
- `--json` — print machine-readable output where supported.
-
-Examples:
+For local development cleanup, use:

 ```bash
-npx --package opencode-working-memory memory-diag status
-npx --package opencode-working-memory memory-diag rejected --verbose
-npx --package opencode-working-memory memory-diag missing --workspace /path/to/project
-npx --package opencode-working-memory memory-diag status --json
-npx --package opencode-working-memory memory-diag commands --verbose
-npx --package opencode-working-memory memory-diag revert --memory <replacement-memory-id>
+npm run cleanup:workspaces -- --dry-run
+npm run cleanup:workspaces -- --quarantine
 ```

-`memory-diag revert` is dry-run by default. Add `--apply` only after reviewing the planned original/replacement status changes.
+The cleanup command only quarantines definite temp/test workspace residues by default. It does not delete unknown missing-root workspaces.

-The npm package is opencode-working-memory; the installed bin is memory-diag, so package-qualified npx avoids resolving a different package named memory-diag.
+### Local Inspection CLI

-Maintainer-only diagnostics and cleanup commands are intentionally not documented here. Future work: move those internal commands to `docs/development.md`.
+Maintainers can run read-only inspection surfaces without telemetry or mutation. Human output redacts absolute paths and credentials by default; pass `--raw` only when you intentionally need local paths.
+
+```bash
+bun scripts/memory-diag.ts quality --workspace /path/to/repo
+bun scripts/memory-diag.ts coverage --workspace /path/to/repo --include-historical
+bun scripts/memory-diag.ts disappearances --workspace /path/to/repo --explain
+bun scripts/memory-diag.ts rejections --quality --reason bad_decision --unique
+```
+
+- `quality` summarizes store caps, retention clocks, evidence coverage, disappearances, and rejection scoping.
+- `coverage` classifies per-memory evidence lifecycle coverage, optionally including historical evidence-only memory IDs.
+- `disappearances --explain` reports evidence memory IDs absent from the current store with terminal capacity, promotion, supersession, or render-omission context when available.
+- `rejections --quality` groups rejection records by scope, reason distribution, and heuristic possible false-positive buckets.

 ## Configuration

@@ -274,7 +244,7 @@ See [Configuration](docs/configuration.md) for customization options.
 Current focus:

 - Add explicit delete tombstones so removed memories do not get re-extracted.
- Monitor numbered refs and protected replacements with `memory-diag commands` before tightening automatic replacement policy further.
+- Enforce explicit `supersedes` chains for safer replacement of obsolete memories.
 - Explore tiered hot/warm/cold storage after the retention model has more real-world data.

 ## Documentation
@@ -291,12 +261,13 @@ cd opencode-working-memory
 npm install
 npm test
 npm run typecheck
+npm run cleanup:workspaces -- --dry-run
 ```

 ## Requirements

 - OpenCode plugin API `>=1.2.0 <2.0.0`
- Node.js >= 22.6.0 (for `memory-diag` CLI, which runs TypeScript with `--experimental-strip-types`)
+- Node.js >= 18.0.0

 ## Limitations

@@ -1,199 +1,5 @@
 # Release Notes

-## 1.6.0 (2026-05-08)
-
-### Numbered Memory Refs
-
-This release turns compaction from a one-way memory extractor into a memory maintenance loop. The model now sees numbered references for existing workspace memories and can explicitly reinforce a still-useful memory or propose a protected replacement when compaction reveals that old memory is obsolete.
-
-The goal is not to make memory more aggressive. It is to make memory more accountable: old facts should be strengthened when they keep proving useful, replaced only when the target is safe, and diagnosable when the model tries something risky.
-
-> **Good memory is selective memory.**
-> v1.6 lets memory say “this still matters” without copying it again — and lets obsolete compaction memories fade behind a safer replacement trail.
-
-```text
-  compaction summary
-        │
-        ▼
-  Memory candidates:
-    Memory ref snapshot id: <uuid>
-    [M1] decision · reinforced=2 · source=explicit
-    [M2] project  · reinforced=0 · source=compaction
-        │
-        ├─ REINFORCE [M1]
-        │     ↑ slows decay, no text mutation
-        │
-        └─ REPLACE [M2] project Updated durable fact
-              ↑ only allowed for safe compaction targets
-```
-
-### What Changed
-
- **Numbered memory refs**: compaction prompts now render existing workspace memories as `[M1]`, `[M2]`, ... references so the model can target a known memory instead of restating it as a duplicate candidate.
- **REINFORCE commands**: `REINFORCE [M#]` increments the target memory's reinforcement count and updates its retention clock without changing its text.
- **Protected REPLACE commands**: `REPLACE [M#] [type] text` supersedes the old memory and appends a replacement only when the target is safe: active, compaction-sourced, and not already reinforced.
- **Reinforce + append workflow**: when a memory is mostly right but needs more context, compaction can reinforce the old memory and emit a new candidate for the new durable fact instead of mutating history.
- **Compaction prompt restructure**: verbose type definitions and the old “reuse existing wording exactly” instruction were replaced with shorter command rules, categorization guidance, and concrete memory-operation examples.
- **Hot state removed from compaction context**: active files, current errors, and pending session state remain in normal prompt context but are no longer duplicated inside the compaction prompt, saving budget and reducing accidental promotion of transient state.
- **New hard quality gates**: unresolved questions, transient bug/debug state, and deployment snapshots are rejected as durable memory candidates.
- **Soft terse-label diagnostic**: very short label-like candidates are reported for tuning without being hard-rejected in v1.6.
- **Decision cap raised**: rendered decision memories now have a per-type cap of 12 instead of 10, while the global rendered cap remains 28.
- **Overlap guard for compaction refs**: memory ref snapshots are tagged with a compaction ID when available, so overlapping same-session compactions cannot silently apply commands against the wrong numbered snapshot.
- **Safer evidence semantics**: rejected memory command events use a neutral `target` relation role instead of lifecycle roles such as `reinforced` or `superseded`.
-
-### Why This Helps
-
- Useful memories can become stronger through real reuse instead of duplicate extraction.
- Obsolete compaction-sourced memories can be replaced with an explicit evidence trail rather than left to drift.
- Manual, explicit, and already-reinforced memories are protected from automatic replacement.
- Compaction prompt budget is spent on durable memory maintenance, not on duplicated hot session state.
- Command outcomes are visible enough to tune the feature after release instead of guessing from reinforcement counts alone.
-
-### Diagnostics
-
-Inspect command behavior with:
-
-```bash
-npx --package opencode-working-memory memory-diag commands
-npx --package opencode-working-memory memory-diag commands --verbose
-npx --package opencode-working-memory memory-diag commands --json
-```
-
-The command report includes:
-
- compactions with command evidence
- REINFORCE and REPLACE counts
- reinforced, superseded, rejected, and blocked outcomes
- invalid or malformed command counts
- same-type vs cross-type replacements
- protected REPLACE blocks, split by reinforced target and protected source
- latest command events in verbose mode
-
-If a numbered replacement needs manual recovery, use the dry-run-first revert command:
-
-```bash
-npx --package opencode-working-memory memory-diag revert --memory <replacement-memory-id>
-npx --package opencode-working-memory memory-diag revert --memory <replacement-memory-id> --apply
-```
-
-You can also target a replacement evidence event directly:
-
-```bash
-npx --package opencode-working-memory memory-diag revert --event <event-id>
-```
-
-### Safety Model
-
- REINFORCE never edits memory text.
- REPLACE is rejected for manual or explicit memories.
- REPLACE is rejected for already reinforced targets.
- REPLACE is rejected if the numbered ref no longer matches the current memory ID, status, and exact key.
- If a compaction snapshot ID is present and mismatched, all numbered commands from that summary are rejected with `missing_memory_ref_snapshot`.
- If the model omits the snapshot ID, v1.6 falls back to exact memory ref validation for compatibility and command effectiveness.
-
-### Upgrade Notes
-
- No configuration changes required.
- Existing workspace memory files remain compatible.
- Existing session state remains compatible; old sessions without compaction ref snapshots fall back safely.
- Existing evidence logs remain compatible; new command events are appended only after v1.6 runs.
- `memory-diag` now exposes two additional public commands: `commands` and `revert`.
-
-### Validation
-
- `npm run typecheck` — `TYPECHECK_PASS`
- `npm test` — 405 tests passing, `TEST_PASS`
-
---
-
-## 1.5.5 (2026-05-05)
-
-### Hot State Rendering Health
-
-This release replaces blunt prompt truncation with a section-aware greedy renderer that fits whole lines and suppresses empty sections, plus render accounting types for future diagnostics.
-
-> **Good rendering is selective too.** If a section doesn't fit, omit it — don't cut it in half.
-
-### What Changed
-
- **Whole-line rendering**: the hot session state prompt no longer truncates mid-line with `.slice(0, maxRenderedChars)`. A greedy line accumulator fits complete lines and stops when the next line would exceed the 700-char budget.
- **Header-only sections suppressed**: a section heading is only rendered if at least one entry fits alongside it. No more orphaned `active_files:` headers with no content underneath.
- **Render accounting**: `accountHotSessionStateRender()` now returns `prompt`, `omitted[]`, and `maxRenderedChars` so future v2 diagnostics can surface which items fell out and why.
- **Two-layer omission model**: section caps (`section_cap`) trim per-type overflow first, then the char budget (`char_budget`) trims anything that doesn't fit. Each omitted item carries its reason and section.
- **Backward-compatible wrapper**: `renderHotSessionState()` delegates to the accounting function and returns just the prompt string, preserving existing plugin behavior.
-
-### Docs Fixes
-
- **Active-file ranking formula corrected**: `docs/configuration.md` now matches the actual implementation — `ACTION_WEIGHT[action] + count * 3` with weights edit 50, write 45, grep 30, read 20, tie-break by `lastSeen` descending. The old docs claimed `count * action_weight * recency_decay` with weights 4/3/2/1.
- **Injection order clarified**: README now explains that workspace memory and hot state system-prompt positions depend on whether workspace memory state is available.
-
-### Not Included Yet
-
- Evidence events for omitted items are deferred to v2, pending a `memory-diag` consumer to avoid unused storage litter.
-
-### Upgrade Notes
-
- No configuration changes required.
- Existing workspace memory files remain compatible.
- Hot session state rendering behavior is intentionally different (cleaner output, no mid-line cuts), but the same information is presented when it fits within the budget.
-
-### Validation
-
- `npm run typecheck` — `TYPECHECK_PASS`
- `npm test` — 356 tests passing, `TEST_PASS`
-
---
-
-## 1.5.4 (2026-05-02)
-
-### Memory Diagnostics Surface Cleanup
-
-This cleanup release keeps the newly published `memory-diag` CLI small before legacy spellings become compatibility debt.
-
-### What Changed
-
- **Official commands only**: the public CLI surface is `status`, `rejected`, `missing`, and `explain`.
- **Pre-public aliases removed**: old spellings such as `health`, `quality`, `rejections`, `disappearances`, and `trace` are no longer recognized.
- **Maintainer diagnostics clarified**: hidden `coverage` and `audit` commands remain available as maintainer-only diagnostics and stay out of public usage output.
- **Cleaner internals**: current command metadata now has one source of truth, and legacy command/formatter wrappers were removed.
- **Internal cleanup script hidden**: the workspace cleanup helper is no longer exposed as an npm script; the underlying development tool remains in `scripts/dev/`.
-
-### Validation
-
- `npm run typecheck` — `TYPECHECK_PASS`
- `npm test` — 347 tests passing, `TEST_PASS`
-
---
-
-## 1.5.3 (2026-05-02)
-
-### Published Memory Diagnostics CLI
-
-This release makes the read-only workspace memory diagnostics CLI available as the package binary `memory-diag`, with user-facing commands for checking memory health and understanding why memories are rejected, missing, shown, or hidden.
-
-> Good memory is selective memory — and diagnostics should explain the selection.
-
-### What Changed
-
- **Published CLI bin**: run diagnostics with `npx --package opencode-working-memory memory-diag` or `memory-diag status`.
- **User-facing commands**: `status`, `rejected`, `missing`, and `explain <memory-id>` are documented as the supported public workflow.
- **Legacy compatibility**: existing maintainer and legacy commands remain accepted with deprecation notices where applicable.
- **Cleaner CLI architecture**: the former monolithic diagnostics script is now split into focused command, model, formatter, and utility modules.
- **Faster diagnostics**: evidence grouping avoids repeated per-memory evidence queries in snapshot diagnostics.
- **Cleaner failures**: top-level CLI error handling now reports usage and unexpected command errors without noisy stack traces.
- **Docs alignment**: README and configuration docs now use package-qualified `npx` commands to avoid resolving an unrelated package named `memory-diag`.
-
-### Requirements
-
- Node.js `>=22.6.0` is now required because the published diagnostics binary runs TypeScript through Node's `--experimental-strip-types` support.
-
-### Validation
-
- `npm run typecheck` — `TYPECHECK_PASS`
- `npm test` — 358 tests passing, `TEST_PASS`
-
---
-
 ## 1.5.1 (2026-04-30)

 ### Evidence Loop and Explainability
@@ -87,33 +87,16 @@ const HOT_STATE_LIMITS = {

 ## Active File Scoring

-Files are ranked by action type plus repeated access count:
+Files are ranked by action type:

 | Action | Weight | Description |
 |--------|--------|-------------|
-| `edit` | 50 | File modified |
-| `write` | 45 | File created/overwritten |
-| `grep` | 30 | Grep searched in file |
-| `read` | 20 | File read |
+| `write` | 4 | File created/overwritten |
+| `edit` | 3 | File modified |
+| `read` | 2 | File read |
+| `grep` | 1 | Grep searched in file |

-Score formula: `ACTION_WEIGHT[action] + count * 3`
-
-When scores tie, the most recent `lastSeen` timestamp sorts first. There is no recency decay factor in the score itself.
-
-## Hot Session State Truncation
-
-Hot state rendering applies section caps before the character budget:
-
-| Section | Rendered cap |
-|---------|--------------|
-| `active_files` | 8 |
-| `open_errors` | 3 |
-| `recent_decisions` | 8 |
-| `pending_memories` | 6 |
-
-After section caps, the renderer applies the 700-character budget with whole-line inclusion only. The prefix line is counted against the budget, and a section heading is emitted only when at least one entry from that section fits; header-only sections are suppressed.
-
-`accountHotSessionStateRender()` returns prompt and omission accounting for future diagnostics. Evidence event integration for hot-state render omissions is planned for v2.
+Score formula: `count * action_weight * recency_decay`

 ## Error Categories

@@ -221,21 +204,13 @@ cat ~/.local/share/opencode-working-memory/workspaces/*/sessions/*.json | jq

 ### Inspect Retention Health

-Use the diagnostics CLI to check memory health for the current workspace:
+From a source checkout, maintainers can inspect stored vs rendered memory behavior:

 ```bash
-npx --package opencode-working-memory memory-diag status
-# or from a source checkout:
-npm run diag -- status
+bun scripts/memory-diag.ts health
 ```

-For detailed diagnostics, use `--verbose`:
-
-```bash
-npx --package opencode-working-memory memory-diag status --verbose
-```
-
-The status output includes overall health (OK/WARNING/DEGRADED), key metrics, and suggested next steps when attention is needed.
+The health output includes stored active memories, rendered candidates, type caps, global cap overflow, dormancy status, retention monitoring alerts, and strength-ranked top/weakest entries.

 ### Clear Workspace Memory

@@ -1,29 +1,23 @@
 {
  "name": "opencode-working-memory",
-  "version": "1.6.0",
+  "version": "1.5.2",
  "description": "Three-layer memory architecture for OpenCode with workspace memory and hot session state",
  "type": "module",
  "main": "index.ts",
  "exports": {
    ".": "./index.ts"
  },
-  "bin": {
-    "memory-diag": "./scripts/memory-diag-bin.cjs"
-  },
  "files": [
    "index.ts",
    "src/",
-    "scripts/memory-diag.ts",
-    "scripts/memory-diag/",
-    "scripts/memory-diag-bin.cjs",
    "README.md",
    "LICENSE"
  ],
  "scripts": {
    "build": "node -e \"console.log('No build step required: OpenCode loads index.ts directly')\"",
-    "diag": "node --experimental-strip-types scripts/memory-diag.ts",
    "typecheck": "tsc --noEmit && node -e \"console.log('TYPECHECK_PASS')\"",
    "test": "node --import ./tests/setup-xdg-data-home.ts --test --experimental-strip-types tests/*.test.ts && node -e \"console.log('TEST_PASS')\"",
+    "cleanup:workspaces": "node --experimental-strip-types scripts/dev/cleanup-workspaces.ts",
    "check:compat": "npm install --no-save @opencode-ai/plugin@latest && npm run typecheck && npm test"
  },
  "keywords": [
@@ -53,6 +47,6 @@
    "typescript": "^5.9.2"
  },
  "engines": {
-    "node": ">=22.6.0"
+    "node": ">=18.0.0"
  }
 }
@@ -1,368 +0,0 @@
-#!/usr/bin/env node
-/**
- * Read-only baseline report for workspace-memory exact/identity key collisions.
- *
- * This script reads workspace-memory.json files from the local workspace memory
- * data directory. It never writes to workspace memory stores; the only optional
- * write is the explicit --json report path.
- */
-
-import { existsSync } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
-import { workspaceMemoryExactKey, workspaceMemoryIdentityKey } from "../../src/workspace-memory.ts";
-import type { LongTermMemoryEntry, LongTermSource, LongTermType } from "../../src/types.ts";
-
-type CliOptions = {
-  workspacesDir: string;
-  jsonPath?: string;
-};
-
-type ReinforcementCountStatistics = {
-  min: number;
-  max: number;
-  mean: number;
-  gtZero: number;
-};
-
-type MemorySummary = {
-  id: string;
-  type: LongTermType;
-  source: LongTermSource;
-  text: string;
-  reinforcementCount: number;
-};
-
-type WorkspaceSummary = {
-  dirName: string;
-  dirPath: string;
-  key: string;
-  root: string;
-};
-
-type CollisionGroup = {
-  kind: "exact" | "identity";
-  workspace: WorkspaceSummary;
-  key: string;
-  classification: "unclassified";
-  memories: MemorySummary[];
-};
-
-type ValidationReport = {
-  summary: {
-    workspaces: number;
-    activeMemories: number;
-    exactCollisionGroups: number;
-    identityCollisionGroups: number;
-    reinforcementCountStatistics: ReinforcementCountStatistics;
-  };
-  groups: CollisionGroup[];
-};
-
-type ScannedMemory = {
-  entry: LongTermMemoryEntry;
-  exactKey: string;
-  identityKey: string;
-  reinforcementCount: number;
-};
-
-const DEFAULT_WORKSPACES_DIR = join(homedir(), ".local", "share", "opencode-working-memory", "workspaces");
-const WORKSPACES_DIR_ENV_KEYS = [
-  "OPENCODE_WORKING_MEMORY_WORKSPACES_DIR",
-  "WORKSPACE_MEMORY_WORKSPACES_DIR",
-];
-
-function usage(): string {
-  return `Usage:
-  node --experimental-strip-types scripts/dev/validate-identity-keys.ts [workspaces-dir] [--json <path>]
-  node --experimental-strip-types scripts/dev/validate-identity-keys.ts --data-path <workspaces-dir> [--json <path>]
-
-Defaults:
-  workspaces-dir defaults to ${DEFAULT_WORKSPACES_DIR}
-  env override: ${WORKSPACES_DIR_ENV_KEYS.join(" or ")}
-`;
-}
-
-function die(message: string): never {
-  console.error(message);
-  console.error(usage());
-  process.exit(1);
-}
-
-function envWorkspacesDir(): string | undefined {
-  for (const key of WORKSPACES_DIR_ENV_KEYS) {
-    const value = process.env[key];
-    if (value) return value;
-  }
-  return undefined;
-}
-
-function expandHome(path: string): string {
-  if (path === "~") return homedir();
-  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
-  return path;
-}
-
-function parseArgs(argv: string[]): CliOptions {
-  let workspacesDir: string | undefined;
-  let jsonPath: string | undefined;
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === "--help" || arg === "-h") {
-      console.log(usage());
-      process.exit(0);
-    }
-    if (arg === "--json") {
-      const value = argv[++i];
-      if (!value) die("--json requires a path");
-      jsonPath = expandHome(value);
-      continue;
-    }
-    if (arg === "--data-path" || arg === "--workspaces-dir") {
-      const value = argv[++i];
-      if (!value) die(`${arg} requires a path`);
-      if (workspacesDir) die("Only one workspaces directory may be provided");
-      workspacesDir = expandHome(value);
-      continue;
-    }
-    if (arg.startsWith("--")) die(`Unknown option: ${arg}`);
-    if (workspacesDir) die("Only one workspaces directory may be provided");
-    workspacesDir = expandHome(arg);
-  }
-
-  return {
-    workspacesDir: resolve(workspacesDir ?? expandHome(envWorkspacesDir() ?? DEFAULT_WORKSPACES_DIR)),
-    jsonPath: jsonPath ? resolve(jsonPath) : undefined,
-  };
-}
-
-function isLongTermType(value: unknown): value is LongTermType {
-  return value === "feedback" || value === "project" || value === "decision" || value === "reference";
-}
-
-function isLongTermSource(value: unknown): value is LongTermSource {
-  return value === "explicit" || value === "compaction" || value === "manual";
-}
-
-function isMemoryEntry(value: unknown): value is LongTermMemoryEntry {
-  if (!value || typeof value !== "object") return false;
-  const entry = value as Partial<LongTermMemoryEntry>;
-  return typeof entry.id === "string"
-    && isLongTermType(entry.type)
-    && typeof entry.text === "string"
-    && isLongTermSource(entry.source);
-}
-
-function reinforcementCount(entry: LongTermMemoryEntry): number {
-  const count = entry.reinforcementCount ?? 0;
-  return Number.isFinite(count) && count > 0 ? count : 0;
-}
-
-function summarizeMemory(memory: ScannedMemory): MemorySummary {
-  return {
-    id: memory.entry.id,
-    type: memory.entry.type,
-    source: memory.entry.source,
-    text: memory.entry.text,
-    reinforcementCount: memory.reinforcementCount,
-  };
-}
-
-function addToGroupMap(map: Map<string, ScannedMemory[]>, key: string, memory: ScannedMemory): void {
-  const group = map.get(key);
-  if (group) {
-    group.push(memory);
-  } else {
-    map.set(key, [memory]);
-  }
-}
-
-function computeReinforcementStatistics(counts: number[]): ReinforcementCountStatistics {
-  if (counts.length === 0) {
-    return { min: 0, max: 0, mean: 0, gtZero: 0 };
-  }
-
-  const sum = counts.reduce((total, count) => total + count, 0);
-  return {
-    min: Math.min(...counts),
-    max: Math.max(...counts),
-    mean: sum / counts.length,
-    gtZero: counts.filter(count => count > 0).length,
-  };
-}
-
-async function readWorkspaceMemory(workspaceDir: string): Promise<unknown | undefined> {
-  const path = join(workspaceDir, "workspace-memory.json");
-  if (!existsSync(path)) return undefined;
-  try {
-    const raw = await readFile(path, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
-    if (code === "ENOENT" || code === "EISDIR") return undefined;
-    throw error;
-  }
-}
-
-async function scanWorkspaces(workspacesDir: string): Promise<ValidationReport> {
-  const dirents = await readdir(workspacesDir, { withFileTypes: true });
-  const workspaceDirs = dirents
-    .filter(dirent => dirent.isDirectory())
-    .map(dirent => dirent.name)
-    .sort((a, b) => a.localeCompare(b));
-
-  const collisionGroups: CollisionGroup[] = [];
-  const reinforcementCounts: number[] = [];
-  let workspaces = 0;
-  let activeMemories = 0;
-
-  for (const dirName of workspaceDirs) {
-    const dirPath = join(workspacesDir, dirName);
-    const store = await readWorkspaceMemory(dirPath);
-    if (!store || typeof store !== "object") continue;
-
-    const storeObject = store as {
-      workspace?: { key?: unknown; root?: unknown };
-      entries?: unknown;
-    };
-    const rawEntries = Array.isArray(storeObject.entries) ? storeObject.entries : [];
-    const workspace: WorkspaceSummary = {
-      dirName,
-      dirPath,
-      key: typeof storeObject.workspace?.key === "string" ? storeObject.workspace.key : dirName,
-      root: typeof storeObject.workspace?.root === "string" ? storeObject.workspace.root : "<unknown>",
-    };
-
-    workspaces += 1;
-
-    const exactGroups = new Map<string, ScannedMemory[]>();
-    const identityGroups = new Map<string, ScannedMemory[]>();
-
-    for (const rawEntry of rawEntries) {
-      if (!isMemoryEntry(rawEntry)) continue;
-      if (rawEntry.status === "superseded") continue;
-
-      const scanned: ScannedMemory = {
-        entry: rawEntry,
-        exactKey: workspaceMemoryExactKey(rawEntry),
-        identityKey: workspaceMemoryIdentityKey(rawEntry),
-        reinforcementCount: reinforcementCount(rawEntry),
-      };
-      activeMemories += 1;
-      reinforcementCounts.push(scanned.reinforcementCount);
-      addToGroupMap(exactGroups, scanned.exactKey, scanned);
-      addToGroupMap(identityGroups, scanned.identityKey, scanned);
-    }
-
-    for (const [key, memories] of exactGroups.entries()) {
-      if (memories.length < 2) continue;
-      collisionGroups.push({
-        kind: "exact",
-        workspace,
-        key,
-        classification: "unclassified",
-        memories: memories.map(summarizeMemory),
-      });
-    }
-
-    for (const [key, memories] of identityGroups.entries()) {
-      if (memories.length < 2) continue;
-      collisionGroups.push({
-        kind: "identity",
-        workspace,
-        key,
-        classification: "unclassified",
-        memories: memories.map(summarizeMemory),
-      });
-    }
-  }
-
-  const exactCollisionGroups = collisionGroups.filter(group => group.kind === "exact").length;
-  const identityCollisionGroups = collisionGroups.filter(group => group.kind === "identity").length;
-
-  return {
-    summary: {
-      workspaces,
-      activeMemories,
-      exactCollisionGroups,
-      identityCollisionGroups,
-      reinforcementCountStatistics: computeReinforcementStatistics(reinforcementCounts),
-    },
-    groups: collisionGroups,
-  };
-}
-
-function oneLine(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-function renderHumanReport(report: ValidationReport, workspacesDir: string): string {
-  const stats = report.summary.reinforcementCountStatistics;
-  const lines: string[] = [];
-  lines.push("Workspace memory identity key validation baseline");
-  lines.push(`Data path: ${workspacesDir}`);
-  lines.push("");
-  lines.push("Summary:");
-  lines.push(`- Workspaces scanned: ${report.summary.workspaces}`);
-  lines.push(`- Active memories: ${report.summary.activeMemories}`);
-  lines.push(`- Exact collision groups: ${report.summary.exactCollisionGroups}`);
-  lines.push(`- Identity collision groups: ${report.summary.identityCollisionGroups}`);
-  lines.push(`- Reinforcement counts: min=${stats.min} max=${stats.max} mean=${stats.mean.toFixed(2)} gtZero=${stats.gtZero}`);
-
-  if (report.groups.length === 0) {
-    lines.push("");
-    lines.push("Collision breakdown: none");
-    return lines.join("\n");
-  }
-
-  const groupsByWorkspace = new Map<string, CollisionGroup[]>();
-  for (const group of report.groups) {
-    const key = group.workspace.key;
-    const existing = groupsByWorkspace.get(key);
-    if (existing) existing.push(group);
-    else groupsByWorkspace.set(key, [group]);
-  }
-
-  lines.push("");
-  lines.push("Collision breakdown:");
-  for (const [workspaceKey, groups] of [...groupsByWorkspace.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-    const workspace = groups[0].workspace;
-    const exactCount = groups.filter(group => group.kind === "exact").length;
-    const identityCount = groups.filter(group => group.kind === "identity").length;
-    lines.push(`- Workspace ${workspaceKey}`);
-    lines.push(`  root: ${workspace.root}`);
-    lines.push(`  dir: ${workspace.dirPath}`);
-    lines.push(`  exactCollisionGroups=${exactCount} identityCollisionGroups=${identityCount}`);
-
-    for (const group of groups.sort((a, b) => a.kind.localeCompare(b.kind) || a.key.localeCompare(b.key))) {
-      lines.push(`  - ${group.kind} key: ${group.key}`);
-      lines.push(`    classification: ${group.classification}`);
-      for (const memory of group.memories) {
-        lines.push(`    - id=${memory.id} type=${memory.type} source=${memory.source} reinforcementCount=${memory.reinforcementCount}`);
-        lines.push(`      text: ${oneLine(memory.text)}`);
-      }
-    }
-  }
-
-  return lines.join("\n");
-}
-
-async function writeJsonReport(path: string, report: ValidationReport): Promise<void> {
-  if (basename(path) === "workspace-memory.json") {
-    die("Refusing to write JSON output to a workspace-memory.json file");
-  }
-
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(report, null, 2)}\n`, "utf8");
-}
-
-const options = parseArgs(process.argv.slice(2));
-const report = await scanWorkspaces(options.workspacesDir);
-console.log(renderHumanReport(report, options.workspacesDir));
-
-if (options.jsonPath) {
-  await writeJsonReport(options.jsonPath, report);
-  console.log(`\nJSON report written to: ${options.jsonPath}`);
-}
@@ -1,24 +0,0 @@
-#!/usr/bin/env node
-const { execFileSync } = require("child_process");
-const path = require("path");
-
-function isSupportedNodeVersion(version) {
-  const [major = 0, minor = 0, patch = 0] = version.split(".").map(part => Number(part));
-  void patch;
-  return major > 22 || (major === 22 && minor >= 6);
-}
-
-if (!isSupportedNodeVersion(process.versions.node)) {
-  process.stderr.write(`memory-diag requires Node >=22.6.0 because it runs TypeScript with --experimental-strip-types. Current Node: v${process.versions.node}.\n`);
-  process.exit(1);
-}
-
-const binDir = __dirname;
-const tsScript = path.join(binDir, "memory-diag.ts");
-const args = ["--experimental-strip-types", tsScript, ...process.argv.slice(2)];
-try {
-  execFileSync(process.execPath, args, { stdio: "inherit" });
-  process.exit(0);
-} catch (e) {
-  process.exit(e.status || 1);
-}
@@ -1,137 +0,0 @@
-import { HIDDEN_COMMAND_NOTICES, isCommand } from "./command-metadata.ts";
-import type { CliOptions, Command, ParsedArgs } from "./types.ts";
-
-export type { ParsedArgs } from "./types.ts";
-
-export function usage(): string {
-  return `Usage:
-  memory-diag [status] [--workspace <path>] [--verbose] [--json]
-  memory-diag rejected [--workspace <path>] [--verbose] [--json]
-  memory-diag missing [--workspace <path>] [--verbose] [--json]
-  memory-diag explain [memory-id] [--workspace <path>] [--raw]
-  memory-diag commands [--workspace <path>] [--verbose] [--json]
-  memory-diag revert (--memory <replacement-id> | --event <event-id>) [--workspace <path>] [--apply]
-
-Global options:
-  --workspace <path>  Workspace path (default: current directory)
-  --verbose           Show detailed diagnostics
-  --json              Print machine-readable JSON where supported
-  --no-emoji          Disable emoji in human output
-`;
-}
-
-function error(message: string): ParsedArgs {
-  return { ok: false, message, usage: usage(), exitCode: 1 };
-}
-
-function isValidSince(rawSince: string): boolean {
-  if (/^(\d+)([dhm])$/i.test(rawSince)) return true;
-  return !Number.isNaN(new Date(rawSince).getTime());
-}
-
-export function parseArgs(argv: string[]): ParsedArgs {
-  const [first, ...tail] = argv;
-  if (first === "--help" || first === "-h") {
-    return { ok: true, help: true, usage: usage() };
-  }
-
-  let command: Command = "status";
-  let deprecationNotice: string | undefined;
-  let rest = argv;
-  if (first && !first.startsWith("--")) {
-    rest = tail;
-    if (isCommand(first)) {
-      command = first;
-      deprecationNotice = HIDDEN_COMMAND_NOTICES[first];
-    } else {
-      return error(`Unknown subcommand: ${first}`);
-    }
-  }
-
-  const options: CliOptions = { raw: false, positional: [] };
-  for (let i = 0; i < rest.length; i += 1) {
-    const arg = rest[i];
-    if (arg === "--raw") options.raw = true;
-    else if (arg === "--json") options.json = true;
-    else if (arg === "--verbose") options.verbose = true;
-    else if (arg === "--no-emoji") options.noEmoji = true;
-    else if (arg === "--all") options.all = true;
-    else if (arg === "--soft-only") options.softOnly = true;
-    else if (arg === "--trigger-only") options.triggerOnly = true;
-    else if (arg === "--include-historical") options.includeHistorical = true;
-    else if (arg === "--explain") options.explain = true;
-    else if (arg === "--apply") options.apply = true;
-    else if (arg === "--workspace") {
-      const value = rest[++i];
-      if (!value) return error("--workspace requires a path");
-      options.workspace = value;
-    } else if (arg === "--since") {
-      const value = rest[++i];
-      if (!value) return error("--since requires a duration or ISO timestamp");
-      options.since = value;
-    } else if (arg === "--reason") {
-      const value = rest[++i];
-      if (!value) return error("--reason requires a reason code");
-      options.reason = value;
-    } else if (arg === "--migration") {
-      const value = rest[++i];
-      if (!value) return error("--migration requires an id");
-      options.migration = value;
-    } else if (arg === "--memory") {
-      const value = rest[++i];
-      if (!value) return error("--memory requires an id");
-      options.memory = value;
-    } else if (arg === "--event") {
-      const value = rest[++i];
-      if (!value) return error("--event requires an id");
-      options.event = value;
-    } else if (!arg.startsWith("--") && command === "explain") {
-      options.positional?.push(arg);
-    } else {
-      return error(`Unknown option: ${arg}`);
-    }
-  }
-
-  if (command === "explain") {
-    const positional = options.positional ?? [];
-    if (positional.length > 1) return error("explain accepts at most one memory id");
-    if (positional.length === 1 && options.memory) return error("Use either explain <memory-id> or --memory, not both");
-    if (positional.length === 1) options.memory = positional[0];
-  } else if ((options.positional ?? []).length > 0) {
-    return error(`Unknown option: ${options.positional?.[0]}`);
-  }
-
-  if (command === "status") {
-    if (options.all) return error(`${command} does not accept --all`);
-  } else if (command === "rejected" || command === "missing" || command === "coverage" || command === "explain" || command === "commands" || command === "revert") {
-    if (options.all) return error(`${command} does not accept --all`);
-  } else {
-    if (options.all || options.workspace) return error(`${command} does not accept --all or --workspace`);
-  }
-  if (options.json && command !== "status" && command !== "rejected" && command !== "missing" && command !== "coverage" && command !== "commands") {
-    return error(`${command} does not accept --json`);
-  }
-  if (command !== "rejected" && (options.softOnly || options.triggerOnly || options.since)) {
-    return error(`${command} does not accept rejection filters`);
-  }
-  if (command !== "coverage" && options.includeHistorical) return error(`${command} does not accept --include-historical`);
-  if (command !== "rejected" && options.reason) return error(`${command} does not accept rejection filters`);
-  if (command !== "missing" && options.explain) return error(`${command} does not accept --explain`);
-  if (command !== "audit" && options.migration) {
-    return error(`${command} does not accept --migration`);
-  }
-  if (command !== "explain" && command !== "revert" && options.memory) {
-    return error(`${command} does not accept --memory`);
-  }
-  if (command !== "revert" && options.event) return error(`${command} does not accept --event`);
-  if (command !== "revert" && options.apply) return error(`${command} does not accept --apply`);
-  if (command === "revert") {
-    if (!options.memory && !options.event) return error("revert requires --memory or --event");
-    if (options.memory && options.event) return error("Use either --memory or --event, not both");
-  }
-  if (command === "rejected" && options.since && !isValidSince(options.since)) {
-    return error(`Invalid --since value: ${options.since}`);
-  }
-
-  return { ok: true, command, options, deprecationNotice };
-}
@@ -1,16 +0,0 @@
-export const VISIBLE_COMMANDS = ["status", "rejected", "missing", "explain", "commands", "revert"] as const;
-export const HIDDEN_COMMANDS = ["coverage", "audit"] as const;
-
-export type VisibleCommand = typeof VISIBLE_COMMANDS[number];
-export type HiddenCommand = typeof HIDDEN_COMMANDS[number];
-export type Command = VisibleCommand | HiddenCommand;
-
-export const HIDDEN_COMMAND_NOTICES: Partial<Record<Command, string>> = {
-  coverage: "Note: 'coverage' is a maintainer-only diagnostic and is not part of the public CLI surface.",
-  audit: "Note: 'audit' is a maintainer-only diagnostic and is not part of the public CLI surface.",
-};
-
-export function isCommand(value: string | undefined): value is Command {
-  return value !== undefined
-    && ([...VISIBLE_COMMANDS, ...HIDDEN_COMMANDS] as readonly string[]).includes(value);
-}
@@ -1,22 +0,0 @@
-import { runAudit } from "./commands/audit.ts";
-import { runCommands } from "./commands/commands.ts";
-import { runCoverage } from "./commands/coverage.ts";
-import { runExplain } from "./commands/explain.ts";
-import { runMissing } from "./commands/missing.ts";
-import { runRejected } from "./commands/rejected.ts";
-import { runRevert } from "./commands/revert.ts";
-import { runStatus } from "./commands/status.ts";
-import type { CliOptions, Command, CommandResult } from "./types.ts";
-
-export async function dispatch(command: Command, options: CliOptions): Promise<CommandResult> {
-  switch (command) {
-    case "status": return runStatus(options);
-    case "rejected": return runRejected(options);
-    case "missing": return runMissing(options);
-    case "coverage": return runCoverage(options);
-    case "audit": return runAudit(options);
-    case "explain": return runExplain(options);
-    case "commands": return runCommands(options);
-    case "revert": return runRevert(options);
-  }
-}
@@ -1,24 +0,0 @@
-import { HARD_QUALITY_REASONS } from "../../../src/memory-quality.ts";
-import { formatMigrationAudit, type MigrationAuditReport } from "../formatters/audit.ts";
-import { readJSONLFile } from "../io.ts";
-import { migrationIdFromPath, migrationLogPaths, riskySupersedeReasons } from "../migrations-model.ts";
-import type { CliOptions, CommandResult, MigrationLogRecord } from "../types.ts";
-
-export async function runAudit(options: CliOptions): Promise<CommandResult> {
-  const paths = await migrationLogPaths(options);
-  const reports: MigrationAuditReport[] = [];
-  for (const path of paths) {
-    const migrationId = options.migration ?? migrationIdFromPath(path);
-    const { records, invalidLines } = await readJSONLFile<MigrationLogRecord>(path);
-    const superseded = records.filter(record => !record.afterStatus || record.afterStatus === "superseded");
-    const hardReasons = superseded.flatMap(record => {
-      if (Array.isArray(record.hardReasons)) return record.hardReasons;
-      return Array.isArray(record.reasons) ? record.reasons.filter(reason => HARD_QUALITY_REASONS.has(reason)) : [];
-    });
-    const risky = superseded
-      .map(record => ({ record, reasons: riskySupersedeReasons(record) }))
-      .filter(item => item.reasons.length > 0);
-    reports.push({ migrationId, path, invalidLines, superseded, hardReasons, risky });
-  }
-  return { stdout: formatMigrationAudit(reports, { raw: options.raw }) };
-}
@@ -1,187 +0,0 @@
-import { queryEvidenceEvents, type EvidenceEventV1, type EvidenceOutcome } from "../../../src/evidence-log.ts";
-import { objectFromCounts, sortedCounts } from "../text.ts";
-import type { CliOptions, CommandResult } from "../types.ts";
-
-type CommandKind = "reinforce" | "replace";
-
-type MemoryCommandSummary = {
-  version: 1;
-  generatedAt: string;
-  compactionsWithCommandEvidence: number;
-  commands: Record<CommandKind, number>;
-  outcomes: Record<"reinforced" | "superseded" | "rejected" | "blocked", number>;
-  invalidMalformedCommands: number;
-  replacements: {
-    sameType: number;
-    crossType: number;
-  };
-  protectedReplacements: {
-    total: number;
-    protectedReinforcedTarget: number;
-    protectedMemorySource: number;
-  };
-  rejectionReasons: Record<string, number>;
-  latestEvents: Array<{
-    eventId: string;
-    createdAt: string;
-    type: string;
-    outcome: EvidenceOutcome;
-    ref?: string;
-    memoryId?: string;
-    reasonCodes: string[];
-    textPreview?: string;
-  }>;
-};
-
-const INVALID_COMMAND_REASONS = new Set([
-  "invalid_memory_command",
-  "invalid_memory_ref",
-  "invalid_memory_type",
-  "empty_replacement_text",
-]);
-
-function hasReason(event: EvidenceEventV1, reason: string): boolean {
-  return event.reasonCodes.includes(reason);
-}
-
-function isInvalidMalformedCommandEvent(event: EvidenceEventV1): boolean {
-  return event.type === "extraction_candidate_rejected"
-    && event.reasonCodes.some(reason => INVALID_COMMAND_REASONS.has(reason));
-}
-
-function isParsedCommandEvent(event: EvidenceEventV1): boolean {
-  return event.type === "memory_reinforced" || event.type === "memory_replaced_numbered_ref";
-}
-
-function isManualRevertEvent(event: EvidenceEventV1): boolean {
-  return event.type === "memory_reverted_numbered_ref";
-}
-
-function isCommandEvidenceEvent(event: EvidenceEventV1): boolean {
-  return isParsedCommandEvent(event) || isInvalidMalformedCommandEvent(event) || isManualRevertEvent(event);
-}
-
-function refFromEvent(event: EvidenceEventV1): string | undefined {
-  const ref = event.details?.ref;
-  return typeof ref === "string" ? ref : undefined;
-}
-
-function latestEventJSON(event: EvidenceEventV1): MemoryCommandSummary["latestEvents"][number] {
-  return {
-    eventId: event.eventId,
-    createdAt: event.createdAt,
-    type: event.type,
-    outcome: event.outcome,
-    ref: refFromEvent(event),
-    memoryId: event.memory?.memoryId,
-    reasonCodes: event.reasonCodes,
-    textPreview: event.textPreview,
-  };
-}
-
-export function buildMemoryCommandSummary(events: EvidenceEventV1[], generatedAt = new Date().toISOString()): MemoryCommandSummary {
-  const commandEvents = events.filter(isCommandEvidenceEvent);
-  const compactionCommandEvents = commandEvents.filter(event => !isManualRevertEvent(event));
-  const parsedEvents = compactionCommandEvents.filter(isParsedCommandEvent);
-  const invalidEvents = compactionCommandEvents.filter(isInvalidMalformedCommandEvent);
-  const sessions = new Set(compactionCommandEvents.map(event => event.sessionHash).filter((value): value is string => typeof value === "string" && value.length > 0));
-  const replacementSuccesses = parsedEvents.filter(event => event.type === "memory_replaced_numbered_ref" && event.outcome === "superseded");
-  const rejectedCommandEvents = commandEvents.filter(event => event.outcome === "rejected");
-  const rejectionReasonCounts = new Map<string, number>();
-
-  for (const event of rejectedCommandEvents) {
-    for (const reason of event.reasonCodes) {
-      rejectionReasonCounts.set(reason, (rejectionReasonCounts.get(reason) ?? 0) + 1);
-    }
-  }
-
-  const protectedReinforcedTarget = parsedEvents.filter(event => event.type === "memory_replaced_numbered_ref" && hasReason(event, "protected_reinforced_target")).length;
-  const protectedMemorySource = parsedEvents.filter(event => event.type === "memory_replaced_numbered_ref" && hasReason(event, "protected_memory_source")).length;
-  const parsedRejected = parsedEvents.filter(event => event.outcome === "rejected").length;
-
-  return {
-    version: 1,
-    generatedAt,
-    compactionsWithCommandEvidence: sessions.size > 0 ? sessions.size : compactionCommandEvents.length > 0 ? 1 : 0,
-    commands: {
-      reinforce: parsedEvents.filter(event => event.type === "memory_reinforced").length,
-      replace: parsedEvents.filter(event => event.type === "memory_replaced_numbered_ref").length,
-    },
-    outcomes: {
-      reinforced: parsedEvents.filter(event => event.outcome === "reinforced").length,
-      superseded: parsedEvents.filter(event => event.outcome === "superseded").length,
-      rejected: parsedRejected,
-      blocked: parsedRejected,
-    },
-    invalidMalformedCommands: invalidEvents.length,
-    replacements: {
-      sameType: replacementSuccesses.filter(event => hasReason(event, "same_type_replace")).length,
-      crossType: replacementSuccesses.filter(event => hasReason(event, "cross_type_replace")).length,
-    },
-    protectedReplacements: {
-      total: parsedEvents.filter(event => event.type === "memory_replaced_numbered_ref" && (hasReason(event, "protected_reinforced_target") || hasReason(event, "protected_memory_source"))).length,
-      protectedReinforcedTarget,
-      protectedMemorySource,
-    },
-    rejectionReasons: objectFromCounts(rejectionReasonCounts),
-    latestEvents: commandEvents.slice(-10).reverse().map(latestEventJSON),
-  };
-}
-
-function formatReasonCounts(rejectionReasons: Record<string, number>): string[] {
-  const counts = new Map(Object.entries(rejectionReasons));
-  const rows = sortedCounts(counts);
-  if (rows.length === 0) return ["  (none)"];
-  return rows.map(([reason, count]) => `  - ${reason}: ${count}`);
-}
-
-function formatLatestEvents(events: MemoryCommandSummary["latestEvents"]): string[] {
-  if (events.length === 0) return ["  (none)"];
-  return events.map(event => {
-    const ref = event.ref ? ` ref=${event.ref}` : "";
-    const memoryId = event.memoryId ? ` memory=${event.memoryId}` : "";
-    const textPreview = event.textPreview ? ` text=${JSON.stringify(event.textPreview)}` : "";
-    return `  - ${event.createdAt} ${event.type} ${event.outcome}${ref}${memoryId} reasons=${event.reasonCodes.join(",") || "none"}${textPreview}`;
-  });
-}
-
-export function formatMemoryCommandSummary(summary: MemoryCommandSummary, options: Pick<CliOptions, "verbose" | "noEmoji"> = {}): string {
-  const warning = options.noEmoji ? "!" : "⚠";
-  const lines = [
-    "Memory command diagnostics",
-    "",
-    "Key metrics:",
-    `  - compactions with command evidence: ${summary.compactionsWithCommandEvidence}`,
-    `  - reinforce: ${summary.commands.reinforce}`,
-    `  - replace: ${summary.commands.replace}`,
-    `  - reinforced: ${summary.outcomes.reinforced}`,
-    `  - superseded: ${summary.outcomes.superseded}`,
-    `  - rejected: ${summary.outcomes.rejected}`,
-    `  - blocked: ${summary.outcomes.blocked}`,
-    `  - invalid/malformed commands: ${summary.invalidMalformedCommands}`,
-    `  - same-type replacements: ${summary.replacements.sameType}`,
-    `  - cross-type replacements: ${summary.replacements.crossType}`,
-    `  - ${warning} Protected REPLACE blocked: ${summary.protectedReplacements.total} (reinforced: ${summary.protectedReplacements.protectedReinforcedTarget}, source: ${summary.protectedReplacements.protectedMemorySource})`,
-    "",
-    "Rejection reasons:",
-    ...formatReasonCounts(summary.rejectionReasons),
-  ];
-
-  if (options.verbose) {
-    lines.push("", "Latest command events:", ...formatLatestEvents(summary.latestEvents));
-  }
-
-  return lines.join("\n");
-}
-
-export async function runCommands(options: CliOptions): Promise<CommandResult> {
-  const root = options.workspace ?? process.cwd();
-  const events = await queryEvidenceEvents(root);
-  const summary = buildMemoryCommandSummary(events);
-
-  if (options.json) {
-    return { stdout: JSON.stringify(summary, null, 2) };
-  }
-
-  return { stdout: formatMemoryCommandSummary(summary, options) };
-}
@@ -1,14 +0,0 @@
-import { buildInspectionReadModel, coverageRows } from "../inspection-model.ts";
-import { buildCoverageJSON, formatCoverage } from "../formatters/coverage.ts";
-import type { CliOptions, CommandResult } from "../types.ts";
-
-export async function runCoverage(options: CliOptions): Promise<CommandResult> {
-  const model = await buildInspectionReadModel(options);
-  const rows = coverageRows(model, options.includeHistorical === true);
-
-  if (options.json) {
-    return { stdout: JSON.stringify(buildCoverageJSON(rows), null, 2) };
-  }
-
-  return { stdout: formatCoverage(rows) };
-}
@@ -1,19 +0,0 @@
-import { traceMemoryLifecycle } from "../../../src/evidence-log.ts";
-import { formatExplain } from "../formatters/explain.ts";
-import { formatTrace } from "../formatters/trace.ts";
-import { snapshotForOptions } from "../workspace-snapshot.ts";
-import type { CliOptions, CommandResult } from "../types.ts";
-
-export async function runExplain(options: CliOptions): Promise<CommandResult> {
-  if (options.memory) {
-    const root = options.workspace ?? process.cwd();
-    const [snapshot, trace] = await Promise.all([
-      snapshotForOptions(options),
-      traceMemoryLifecycle(root, { memoryId: options.memory }),
-    ]);
-    return { stdout: formatTrace(options.memory, snapshot, trace) };
-  }
-
-  const snapshot = await snapshotForOptions(options);
-  return { stdout: formatExplain(snapshot) };
-}
@@ -1,14 +0,0 @@
-import { buildInspectionReadModel, disappearanceRows } from "../inspection-model.ts";
-import { buildMissingJSON, formatMissing } from "../formatters/missing.ts";
-import type { CliOptions, CommandResult } from "../types.ts";
-
-export async function runMissing(options: CliOptions): Promise<CommandResult> {
-  const model = await buildInspectionReadModel(options);
-  const rows = disappearanceRows(model);
-
-  if (options.json) {
-    return { stdout: JSON.stringify(buildMissingJSON(rows, { explain: options.explain }), null, 2) };
-  }
-
-  return { stdout: formatMissing(rows, { verbose: options.verbose, explain: options.explain }) };
-}
@@ -1,25 +0,0 @@
-import { buildRejectedJSON, formatRejected } from "../formatters/rejected.ts";
-import { loadRejectionRecords, rejectionFalsePositiveRisk, rejectionQualitySummary } from "../rejections-model.ts";
-import type { CliOptions, CommandResult } from "../types.ts";
-
-export async function runRejected(options: CliOptions): Promise<CommandResult> {
-  const { path, invalidLines, records } = await loadRejectionRecords(options);
-  const summary = rejectionQualitySummary(records);
-  const falsePositiveRisk = rejectionFalsePositiveRisk(summary);
-
-  if (options.json) {
-    return { stdout: JSON.stringify(buildRejectedJSON({ summary, falsePositiveRisk }), null, 2) };
-  }
-
-  return {
-    stdout: formatRejected({
-      path,
-      invalidLines,
-      records,
-      summary,
-      falsePositiveRisk,
-      raw: options.raw,
-      verbose: options.verbose,
-    }),
-  };
-}
@@ -1,193 +0,0 @@
-import { appendEvidenceEvents, queryEvidenceEvents, type EvidenceEventInput, type EvidenceEventV1, type MemoryEvidenceRef } from "../../../src/evidence-log.ts";
-import { workspaceMemoryPath } from "../../../src/paths.ts";
-import type { LongTermMemoryEntry, WorkspaceMemoryStore } from "../../../src/types.ts";
-import { updateWorkspaceMemoryWithAccounting } from "../../../src/workspace-memory.ts";
-import { readJSONFile } from "../io.ts";
-import { cleanText, truncate } from "../text.ts";
-import { CliInputError, type CliOptions, type CommandResult } from "../types.ts";
-
-type ReplacementLink = {
-  event: EvidenceEventV1;
-  originalId: string;
-  replacementId: string;
-};
-
-type RevertPlan = ReplacementLink & {
-  original: LongTermMemoryEntry;
-  replacement: LongTermMemoryEntry;
-};
-
-function reject(message: string): never {
-  throw new CliInputError(`revert rejected: ${message}`);
-}
-
-function memoryRef(memory: LongTermMemoryEntry, status: LongTermMemoryEntry["status"] = memory.status): MemoryEvidenceRef {
-  return {
-    memoryId: memory.id,
-    type: memory.type,
-    source: memory.source,
-    status,
-  };
-}
-
-function replacementIdFromEvent(event: EvidenceEventV1): string | undefined {
-  return event.relations?.find(relation => relation.role === "superseded_by")?.memory?.memoryId;
-}
-
-function originalIdFromEvent(event: EvidenceEventV1): string | undefined {
-  return event.memory?.memoryId
-    ?? event.relations?.find(relation => relation.role === "superseded")?.memory?.memoryId;
-}
-
-function replacementLinkFromEvent(event: EvidenceEventV1): ReplacementLink {
-  if (event.type !== "memory_replaced_numbered_ref") {
-    reject(`event ${event.eventId} is not a memory_replaced_numbered_ref event`);
-  }
-  if (event.outcome !== "superseded") {
-    reject(`event ${event.eventId} is not a successful numbered replacement`);
-  }
-  if (!event.reasonCodes.includes("numbered_ref_replace")) {
-    reject(`event ${event.eventId} is not a numbered replacement`);
-  }
-
-  const originalId = originalIdFromEvent(event);
-  const replacementId = replacementIdFromEvent(event);
-  if (!originalId || !replacementId) {
-    reject(`event ${event.eventId} does not identify original and replacement memories`);
-  }
-
-  return { event, originalId, replacementId };
-}
-
-function selectReplacementLink(events: EvidenceEventV1[], options: CliOptions): ReplacementLink {
-  if (options.event) {
-    const event = events.find(item => item.eventId === options.event);
-    if (!event) reject(`event ${options.event} was not found`);
-    return replacementLinkFromEvent(event);
-  }
-
-  const memoryId = options.memory;
-  if (!memoryId) reject("missing --memory or --event selector");
-  const matches = events
-    .filter(event => event.type === "memory_replaced_numbered_ref")
-    .filter(event => replacementIdFromEvent(event) === memoryId);
-
-  if (matches.length === 0) {
-    reject(`replacement memory ${memoryId} was not created by memory_replaced_numbered_ref`);
-  }
-  if (matches.length > 1) {
-    reject(`replacement memory ${memoryId} has ${matches.length} replacement events; use --event`);
-  }
-
-  return replacementLinkFromEvent(matches[0]);
-}
-
-function validatePlan(link: ReplacementLink, store: WorkspaceMemoryStore): RevertPlan {
-  const byId = new Map(store.entries.map(entry => [entry.id, entry]));
-  const original = byId.get(link.originalId);
-  const replacement = byId.get(link.replacementId);
-
-  if (!original) reject(`original memory ${link.originalId} is missing`);
-  if (!replacement) reject(`replacement memory ${link.replacementId} is missing`);
-  if (original.status !== "superseded") reject(`original memory ${original.id} is not superseded`);
-  if (replacement.status !== "active") reject(`replacement memory ${replacement.id} is not active`);
-
-  const laterSuperseder = store.entries.find(entry =>
-    entry.status === "active"
-    && entry.id !== original.id
-    && entry.id !== replacement.id
-    && (entry.supersedes ?? []).includes(replacement.id)
-  );
-  if (laterSuperseder) {
-    reject(`replacement memory ${replacement.id} is superseded by active memory ${laterSuperseder.id}`);
-  }
-
-  return { ...link, original, replacement };
-}
-
-async function dryRunPlan(root: string, link: ReplacementLink): Promise<RevertPlan> {
-  const rawStore = await readJSONFile<WorkspaceMemoryStore>(await workspaceMemoryPath(root));
-  const store: WorkspaceMemoryStore = rawStore ?? {
-    version: 1,
-    workspace: { root, key: "" },
-    limits: { maxRenderedChars: 0, maxEntries: 0 },
-    entries: [],
-    migrations: [],
-    updatedAt: new Date(0).toISOString(),
-  };
-  return validatePlan(link, store);
-}
-
-function revertEvidence(plan: RevertPlan): EvidenceEventInput {
-  const replacement = { ...plan.replacement, status: "superseded" as const };
-  const original = { ...plan.original, status: "active" as const };
-  return {
-    type: "memory_reverted_numbered_ref",
-    phase: "storage",
-    outcome: "recovered",
-    memory: memoryRef(replacement, "superseded"),
-    relations: [
-      { role: "superseded", memory: memoryRef(replacement, "superseded") },
-      { role: "recovered", memory: memoryRef(original, "active") },
-    ],
-    reasonCodes: ["manual_revert_numbered_ref"],
-    details: {
-      replacementEventId: plan.event.eventId,
-      replacementMemoryId: plan.replacementId,
-      restoredMemoryId: plan.originalId,
-    },
-    textPreview: original.text,
-  };
-}
-
-async function applyPlan(root: string, link: ReplacementLink): Promise<RevertPlan> {
-  let applied: RevertPlan | undefined;
-  const updateResult = await updateWorkspaceMemoryWithAccounting(root, store => {
-    const plan = validatePlan(link, store);
-    const nowIso = new Date().toISOString();
-    applied = {
-      ...plan,
-      original: { ...plan.original, status: "active", updatedAt: nowIso },
-      replacement: { ...plan.replacement, status: "superseded", updatedAt: nowIso },
-    };
-
-    return {
-      ...store,
-      entries: store.entries.map(entry => {
-        if (entry.id === plan.originalId) return applied!.original;
-        if (entry.id === plan.replacementId) return applied!.replacement;
-        return entry;
-      }),
-      updatedAt: nowIso,
-      lastActivityAt: nowIso,
-    };
-  });
-
-  if (!applied) reject("unable to apply revert");
-  await appendEvidenceEvents(root, [...updateResult.evidence, revertEvidence(applied)]);
-  return applied;
-}
-
-function formatPlan(plan: RevertPlan, applied: boolean): string {
-  const heading = applied ? "Memory revert applied" : "Memory revert dry run";
-  const nextStep = applied ? "Changes applied." : "No changes applied. Re-run with --apply to mutate workspace memory.";
-  return [
-    heading,
-    "",
-    "Planned changes:",
-    `  - replacement: ${plan.replacementId} active -> superseded`,
-    `  - original: ${plan.originalId} superseded -> active`,
-    `  - replacement event: ${plan.event.eventId}`,
-    `  - restored text: ${truncate(cleanText(plan.original.text, false), 100)}`,
-    "",
-    nextStep,
-  ].join("\n");
-}
-
-export async function runRevert(options: CliOptions): Promise<CommandResult> {
-  const root = options.workspace ?? process.cwd();
-  const events = await queryEvidenceEvents(root);
-  const link = selectReplacementLink(events, options);
-  const plan = options.apply ? await applyPlan(root, link) : await dryRunPlan(root, link);
-  return { stdout: formatPlan(plan, options.apply === true) };
-}
@@ -1,112 +0,0 @@
-import { RETENTION_TYPE_MAX, WORKSPACE_DORMANT_AFTER_DAYS } from "../../../src/retention.ts";
-import { TYPES } from "../constants.ts";
-import { formatStatus, type StatusReadout } from "../formatters/status.ts";
-import { buildInspectionReadModel, disappearanceRows } from "../inspection-model.ts";
-import { retentionCandidatesForDiag, retentionClockSummary, daysSinceIso } from "../retention-model.ts";
-import { rejectionFalsePositiveRisk, rejectionQualitySummary } from "../rejections-model.ts";
-import { isWithinDays, memoryDiagJSONFromSnapshot } from "../workspace-snapshot.ts";
-import type { CliOptions, CommandResult, MemoryInspectionReadModel } from "../types.ts";
-
-export function buildStatusReadout(model: MemoryInspectionReadModel, now = Date.now()): StatusReadout {
-  const active = model.store.entries.filter(entry => entry.status !== "superseded");
-  const retention = retentionCandidatesForDiag(model.store, now);
-  const clocks = retentionClockSummary(active);
-  const disappearances = disappearanceRows(model);
-  const evidenceCovered = active.filter(entry => (model.evidenceByMemoryId.get(entry.id) ?? []).length > 0).length;
-  const rejectionSummary = rejectionQualitySummary(model.rejectionRecords);
-  const falsePositiveRisk = rejectionFalsePositiveRisk(rejectionSummary);
-  const typeCounts = Object.fromEntries(TYPES.map(type => [type, active.filter(entry => entry.type === type).length]));
-  const capsFull = active.length >= model.store.limits.maxEntries || TYPES.some(type => (typeCounts[type] ?? 0) >= RETENTION_TYPE_MAX[type]);
-  const unknownDisappearances = disappearances.filter(row => row.classification === "historical_absent_unknown_reason").length;
-  const status = unknownDisappearances > 0 || clocks.invalid > 0
-    ? "degraded"
-    : capsFull || rejectionSummary.legacyUnscopedCount > 0 || falsePositiveRisk === "high"
-      ? "warning"
-      : "ok";
-  const rejectedLast7Days = model.evidenceEvents.filter(event => event.outcome === "rejected" && isWithinDays(event.createdAt, 7, now)).length;
-  const evidenceCoveragePercent = active.length === 0 ? 100 : Math.round((evidenceCovered / active.length) * 100);
-  const needsAttention: string[] = [];
-  if (clocks.invalid > 0) needsAttention.push(`${clocks.invalid} invalid retention clocks`);
-  if (unknownDisappearances > 0) needsAttention.push(`${unknownDisappearances} memories disappeared without terminal evidence`);
-  if (capsFull) needsAttention.push("memory store is at or over retention caps");
-  if (rejectionSummary.legacyUnscopedCount > 0) needsAttention.push(`${rejectionSummary.legacyUnscopedCount} legacy unscoped rejection records`);
-  if (falsePositiveRisk === "high") needsAttention.push("possible rejection false-positive risk is high");
-  const suggestedNextSteps: string[] = [];
-  if (clocks.invalid > 0 || unknownDisappearances > 0) suggestedNextSteps.push("Run memory-diag missing --verbose to inspect missing-memory evidence.");
-  if (capsFull) suggestedNextSteps.push("Run memory-diag explain to see which memories are hidden by caps.");
-  if (rejectionSummary.legacyUnscopedCount > 0 || falsePositiveRisk === "high") suggestedNextSteps.push("Run memory-diag rejected --verbose to inspect rejection quality.");
-  const wallDaysSinceActivity = daysSinceIso(model.store.lastActivityAt, now);
-  const dormantDiscountActive = wallDaysSinceActivity !== null && wallDaysSinceActivity > WORKSPACE_DORMANT_AFTER_DAYS;
-  const dormantDaysPastGrace = wallDaysSinceActivity === null ? 0 : Math.max(0, wallDaysSinceActivity - WORKSPACE_DORMANT_AFTER_DAYS);
-
-  return {
-    status,
-    summaryText: `Summary: Workspace memory quality is ${status}: ${active.length} active memories, ${evidenceCovered}/${active.length} with evidence, ${disappearances.length} evidence-only disappearances (${unknownDisappearances} unknown), ${clocks.invalid} invalid retention clocks, and ${rejectionSummary.legacyUnscopedCount} legacy unscoped rejection records.`,
-    active: active.length,
-    rendered: retention.rendered.length,
-    pending: model.pending.entries.length,
-    rejectedLast7Days,
-    evidenceCoveragePercent,
-    needsAttention,
-    suggestedNextSteps,
-    caps: {
-      active: active.length,
-      maxEntries: model.store.limits.maxEntries,
-      rendered: retention.rendered.length,
-      typeCapped: retention.typeCapped.length,
-      globalCapped: retention.globalCapped.length,
-      typeCounts,
-      capsFull,
-    },
-    retention: clocks,
-    evidence: {
-      currentWithEvidence: evidenceCovered,
-      currentWithoutEvidence: active.length - evidenceCovered,
-      evidenceMemoryIds: model.evidenceByMemoryId.size,
-      disappearances: disappearances.length,
-      unknownDisappearances,
-      withTerminalReason: disappearances.length - unknownDisappearances,
-    },
-    rejections: { ...rejectionSummary, falsePositiveRisk },
-    dormant: {
-      lastActivityAt: model.store.lastActivityAt,
-      wallDaysSinceActivity,
-      dormantDiscountActive,
-      dormantDaysPastGrace,
-    },
-    topRendered: retention.rendered.slice(0, 5),
-    weakestActive: retention.sorted.slice(-5).reverse(),
-  };
-}
-
-export async function runStatus(options: CliOptions): Promise<CommandResult> {
-  const now = Date.now();
-  const model = await buildInspectionReadModel(options);
-  const readout = buildStatusReadout(model, now);
-
-  if (options.json) {
-    const root = options.workspace ?? process.cwd();
-    const diag = memoryDiagJSONFromSnapshot(root, model.snapshot);
-    return {
-      stdout: JSON.stringify({
-        ...diag,
-        summary: {
-          ...diag.summary,
-          status: readout.status,
-          evidenceCoveragePercent: readout.evidenceCoveragePercent,
-          needsAttention: readout.needsAttention,
-          suggestedNextSteps: readout.suggestedNextSteps,
-        },
-      }, null, 2),
-    };
-  }
-
-  return {
-    stdout: formatStatus(readout, model, {
-      verbose: options.verbose,
-      noEmoji: options.noEmoji,
-      isTty: process.stdout.isTTY === true,
-      raw: options.raw,
-    }),
-  };
-}
@@ -1,21 +0,0 @@
-import type { LongTermType } from "../../src/types.ts";
-import type { Origin } from "./types.ts";
-
-export const TYPES: LongTermType[] = ["feedback", "decision", "project", "reference"];
-
-export const SUSPICIOUS_REASONS = [
-  "progress_snapshot",
-  "active_file_snapshot",
-  "commit_or_ci_snapshot",
-  "temporary_status",
-  "raw_error",
-  "code_or_api_signature",
-] as const;
-
-export const ALLOWED_ORIGINS = new Set<Origin>([
-  "explicit_trigger",
-  "compaction_candidate",
-  "manual",
-  "migration_check",
-  "unknown",
-]);
@@ -1,21 +0,0 @@
-import type { EvidenceEventV1 } from "../../src/evidence-log.ts";
-import { uniqueStrings } from "./text.ts";
-
-export function eventMemoryIds(event: EvidenceEventV1): string[] {
-  return uniqueStrings([
-    event.memory?.memoryId ?? "",
-    ...(event.relations ?? []).map(relation => relation.memory?.memoryId ?? ""),
-  ]);
-}
-
-export function groupEvidenceByMemoryId(events: EvidenceEventV1[]): Map<string, EvidenceEventV1[]> {
-  const grouped = new Map<string, EvidenceEventV1[]>();
-  for (const event of events) {
-    for (const id of eventMemoryIds(event)) {
-      const bucket = grouped.get(id) ?? [];
-      bucket.push(event);
-      grouped.set(id, bucket);
-    }
-  }
-  return grouped;
-}
@@ -1,48 +0,0 @@
-import { cleanPath, cleanText, countBy, formatWorkspaceIdentity, sortedCounts, truncate } from "../text.ts";
-import type { MigrationLogRecord } from "../types.ts";
-
-export type MigrationAuditReport = {
-  migrationId: string;
-  path: string;
-  invalidLines: number;
-  superseded: MigrationLogRecord[];
-  hardReasons: string[];
-  risky: Array<{ record: MigrationLogRecord; reasons: string[] }>;
-};
-
-export function formatMigrationAudit(reports: MigrationAuditReport[], options: { raw: boolean }): string {
-  const lines: string[] = [];
-  lines.push("Migration audit report");
-  lines.push("");
-  if (reports.length === 0) {
-    lines.push("No migration logs found.");
-    return lines.join("\n");
-  }
-
-  for (let i = 0; i < reports.length; i += 1) {
-    const report = reports[i];
-    if (i > 0) lines.push("");
-    lines.push(`Migration: ${report.migrationId}`);
-    lines.push(`logPath=${cleanPath(report.path, options.raw)}`);
-    if (report.invalidLines > 0) lines.push(`Invalid JSONL lines skipped: ${report.invalidLines}`);
-    lines.push(`Superseded entries: ${report.superseded.length}`);
-    lines.push("");
-
-    lines.push("By hard reason:");
-    const byHardReason = sortedCounts(countBy(report.hardReasons));
-    if (byHardReason.length === 0) lines.push("  (none)");
-    else for (const [reason, count] of byHardReason) lines.push(`  ${reason.padEnd(24)} ${count}`);
-    lines.push("");
-
-    lines.push("Potentially risky supersedes:");
-    lines.push(`  ${report.risky.length}`);
-    for (const item of report.risky.slice(0, 10)) {
-      const record = item.record;
-      const hard = Array.isArray(record.hardReasons) ? record.hardReasons : [];
-      const identity = formatWorkspaceIdentity(record.workspaceKey, record.workspaceRoot, options.raw);
-      lines.push(`  - [${record.type ?? "unknown"}] hardReasons=${JSON.stringify(hard)} risk=${item.reasons.join(",")} ${JSON.stringify(truncate(cleanText(record.text ?? "", options.raw)))}`);
-      if (identity) lines.push(`    ${identity}`);
-    }
-  }
-  return lines.join("\n");
-}
@@ -1,34 +0,0 @@
-import type { coverageRows } from "../inspection-model.ts";
-import { countBy, objectFromCounts } from "../text.ts";
-import type { CoverageClass } from "../types.ts";
-
-export type CoverageRows = ReturnType<typeof coverageRows>;
-
-export function buildCoverageJSON(rows: CoverageRows, generatedAt = new Date().toISOString()): Record<string, unknown> {
-  const classCounts = objectFromCounts(countBy(rows.map(row => row.class)));
-  return {
-    version: 1,
-    generatedAt,
-    classCounts,
-    memories: rows,
-  };
-}
-
-export function formatCoverage(rows: CoverageRows): string {
-  const classCounts = objectFromCounts(countBy(rows.map(row => row.class)));
-  const lines: string[] = [];
-  lines.push("Memory evidence coverage");
-  lines.push("");
-  lines.push("Class counts:");
-  for (const cls of ["full_lifecycle", "render_only", "no_evidence", "historical_absent_with_reason", "historical_absent_unknown_reason"] as CoverageClass[]) {
-    lines.push(`  ${cls}: ${classCounts[cls] ?? 0}`);
-  }
-  lines.push("");
-  lines.push("Per-memory rows:");
-  if (rows.length === 0) lines.push("  (none)");
-  for (const row of rows) {
-    const phases = row.eventCounts.byPhase;
-    lines.push(`  ${row.id} ${row.class} current=${row.current ? "yes" : "no"} total=${row.eventCounts.total} extraction=${phases.extraction ?? 0} promotion=${phases.promotion ?? 0} render=${phases.render ?? 0} storage=${phases.storage ?? 0}`);
-  }
-  return lines.join("\n");
-}
@@ -1,42 +0,0 @@
-import type { EvidenceEventV1 } from "../../../src/evidence-log.ts";
-import { formatStrength } from "../retention-model.ts";
-import type { WorkspaceDiagSnapshot } from "../types.ts";
-
-export function formatEvidenceRefs(eventIds: string[], allEvents: EvidenceEventV1[]): string {
-  if (eventIds.length === 0) return "(none)";
-  const byId = new Map(allEvents.map(event => [event.eventId, event]));
-  return eventIds
-    .map(id => {
-      const event = byId.get(id);
-      return event ? `${event.eventId} ${event.type}` : id;
-    })
-    .join(", ");
-}
-
-export function formatExplain(snapshot: WorkspaceDiagSnapshot): string {
-  const lines: string[] = [];
-  lines.push("Workspace memory explainability");
-  lines.push("");
-
-  if (snapshot.memories.length === 0) {
-    lines.push("No memories found.");
-  }
-
-  for (const memory of snapshot.memories) {
-    lines.push(`Memory ${memory.id}: ${memory.status}`);
-    const strength = typeof memory.strength === "number" ? formatStrength(memory.strength) : "n/a";
-    lines.push(`- strength=${strength}, type=${memory.type}, source=${memory.source}`);
-    lines.push(`- reasons: ${memory.reasonCodes.length > 0 ? memory.reasonCodes.join(", ") : "(none)"}`);
-    lines.push(`- evidence: ${formatEvidenceRefs(memory.evidenceEventIds, snapshot.allEvents)}`);
-    lines.push("");
-  }
-
-  const quarantines = snapshot.recentEvents.filter(event => event.type === "storage_corrupt_json_quarantined");
-  if (quarantines.length > 0) {
-    lines.push("Quarantined stores:");
-    for (const event of quarantines) {
-      lines.push(`- quarantined_corrupt_store: ${event.eventId} ${event.type}; reasons=${event.reasonCodes.join(",")}`);
-    }
-  }
-  return lines.join("\n");
-}
@@ -1,102 +0,0 @@
-import type { disappearanceRows } from "../inspection-model.ts";
-import { eventCounts } from "../inspection-model.ts";
-import { formatDetails } from "../text.ts";
-
-export type DisappearanceRows = ReturnType<typeof disappearanceRows>;
-
-export type MissingSummary = {
-  total: number;
-  explained: number;
-  needsReview: number;
-};
-
-export function missingSummary(rows: DisappearanceRows): MissingSummary {
-  return {
-    total: rows.length,
-    explained: rows.filter(row => row.classification === "historical_absent_with_reason").length,
-    needsReview: rows.filter(row => row.classification === "historical_absent_unknown_reason").length,
-  };
-}
-
-export function buildMissingJSON(rows: DisappearanceRows, options: { explain?: boolean; generatedAt?: string } = {}): Record<string, unknown> {
-  return {
-    ...buildDisappearancesJSON(rows, options),
-    summary: missingSummary(rows),
-  };
-}
-
-function buildDisappearancesJSON(rows: DisappearanceRows, options: { explain?: boolean; generatedAt?: string } = {}): Record<string, unknown> {
-  return {
-    version: 1,
-    generatedAt: options.generatedAt ?? new Date().toISOString(),
-    disappearances: rows.map(row => ({
-      id: row.id,
-      classification: row.classification,
-      terminalType: row.terminalType,
-      reasonCodes: row.reasonCodes,
-      eventCounts: eventCounts(row.events),
-      details: options.explain ? row.event?.details : undefined,
-    })),
-  };
-}
-
-function formatDisappearances(rows: DisappearanceRows, options: { explain?: boolean } = {}): string {
-  const lines: string[] = [];
-  lines.push("Memory disappearances");
-  lines.push("");
-  if (rows.length === 0) {
-    lines.push("No evidence-only memories found.");
-    return lines.join("\n");
-  }
-  for (const row of rows) {
-    const reasons = row.reasonCodes.length > 0 ? row.reasonCodes.join(",") : "none";
-    lines.push(`Memory ${row.id}: ${row.classification} terminal=${row.terminalType} reasons=${reasons}`);
-    if (options.explain) {
-      lines.push(`  events: ${row.events.map(event => event.type).join(", ")}`);
-      if (row.event?.type === "memory_removed_capacity") {
-        lines.push(`  memory_removed_capacity details: ${formatDetails(row.event.details)}`);
-      }
-      const renderTypeCap = row.events.find(event => event.type === "render_omitted" && event.reasonCodes.includes("type_cap"));
-      if (renderTypeCap) {
-        lines.push(`  render_omitted type-cap observation: reasons=${renderTypeCap.reasonCodes.join(",")} details=${formatDetails(renderTypeCap.details)}`);
-      }
-    }
-  }
-  return lines.join("\n");
-}
-
-export function formatMissing(rows: DisappearanceRows, options: { verbose?: boolean; explain?: boolean } = {}): string {
-  const summary = missingSummary(rows);
-  const lines: string[] = [];
-  lines.push("Missing memory summary");
-  lines.push("");
-  if (rows.length === 0) {
-    lines.push("No missing memories found.");
-    return lines.join("\n");
-  }
-
-  lines.push(`Total missing: ${summary.total}`);
-  lines.push(`Explained: ${summary.explained}`);
-  lines.push(`Needs review: ${summary.needsReview}`);
-  lines.push("");
-
-  const unknownRows = rows
-    .filter(row => row.classification === "historical_absent_unknown_reason")
-    .slice(0, 5);
-  lines.push("Unknown disappearance samples:");
-  if (unknownRows.length === 0) {
-    lines.push("  (none)");
-  } else {
-    for (const row of unknownRows) {
-      const reasons = row.reasonCodes.length > 0 ? row.reasonCodes.join(",") : "none";
-      lines.push(`  - ${row.id} terminal=${row.terminalType} reasons=${reasons}`);
-    }
-  }
-
-  if (options.verbose || options.explain) {
-    lines.push("");
-    lines.push(formatDisappearances(rows, { explain: true }));
-  }
-
-  return lines.join("\n");
-}
@@ -1,93 +0,0 @@
-import { rejectionFalsePositiveRisk, rejectionQualitySummary } from "../rejections-model.ts";
-import { cleanPath, cleanText, countBy, sortedCounts, truncate } from "../text.ts";
-import type { NormalizedRejection } from "../types.ts";
-
-export type RejectedSummary = ReturnType<typeof rejectionQualitySummary>;
-export type RejectedFalsePositiveRisk = ReturnType<typeof rejectionFalsePositiveRisk>;
-
-export function buildRejectedJSON(input: {
-  summary: RejectedSummary;
-  falsePositiveRisk: RejectedFalsePositiveRisk;
-  generatedAt?: string;
-}): Record<string, unknown> {
-  return {
-    version: 1,
-    generatedAt: input.generatedAt ?? new Date().toISOString(),
-    ...input.summary,
-    falsePositiveRisk: input.falsePositiveRisk,
-  };
-}
-
-export function formatRejected(input: {
-  path: string;
-  invalidLines: number;
-  records: NormalizedRejection[];
-  summary: RejectedSummary;
-  falsePositiveRisk: RejectedFalsePositiveRisk;
-  raw: boolean;
-  verbose?: boolean;
-}): string {
-  const lines: string[] = [];
-  lines.push("Rejected memory summary");
-  lines.push("");
-  lines.push(`Total rejected: ${input.summary.totalRecords}`);
-  lines.push(`Unique texts: ${input.summary.uniqueTexts}`);
-  lines.push("");
-
-  lines.push("Top reasons:");
-  const byReason = sortedCounts(countBy(input.records.flatMap(record => record.reasons))).slice(0, 5);
-  if (byReason.length === 0) lines.push("  (none)");
-  else for (const [reason, count] of byReason) lines.push(`  ${reason.padEnd(36)} ${count}`);
-  lines.push("");
-
-  lines.push(`False-positive risk: ${input.falsePositiveRisk}`);
-  if (input.falsePositiveRisk === "high") {
-    lines.push("⚠️ Possible false positives detected. Use --verbose to inspect samples.");
-  }
-  lines.push("");
-
-  lines.push("Recent samples:");
-  const samples = [...input.records]
-    .sort((a, b) => (new Date(b.timestamp).getTime() || 0) - (new Date(a.timestamp).getTime() || 0))
-    .slice(0, 5);
-  if (samples.length === 0) {
-    lines.push("  (none)");
-  } else {
-    for (const record of samples) {
-      lines.push(`  - [${record.type}] ${truncate(cleanText(record.text, input.raw))}`);
-      lines.push(`    reasons: ${record.reasons.length > 0 ? record.reasons.join(",") : "none"}`);
-    }
-  }
-
-  if (!input.verbose) return lines.join("\n");
-
-  lines.push("");
-  lines.push("Possible false-positive grouping is heuristic, not deterministic truth.");
-  lines.push(`logPath=${cleanPath(input.path, input.raw)}`);
-  if (input.invalidLines > 0) lines.push(`Invalid JSONL lines skipped: ${input.invalidLines}`);
-  lines.push("");
-
-  lines.push("Reason distribution (raw records):");
-  for (const [reason, count] of Object.entries(input.summary.reasonDistribution)) lines.push(`  ${reason.padEnd(36)} ${count}`);
-  if (Object.keys(input.summary.reasonDistribution).length === 0) lines.push("  (none)");
-  lines.push("");
-
-  lines.push("Reason distribution (unique text):");
-  for (const [reason, count] of Object.entries(input.summary.uniqueReasonDistribution)) lines.push(`  ${reason.padEnd(36)} ${count}`);
-  if (Object.keys(input.summary.uniqueReasonDistribution).length === 0) lines.push("  (none)");
-  lines.push("");
-
-  lines.push("By origin:");
-  const byOrigin = sortedCounts(countBy(input.records.map(record => record.origin)));
-  if (byOrigin.length === 0) lines.push("  (none)");
-  else for (const [origin, count] of byOrigin) lines.push(`  ${origin.padEnd(36)} ${count}`);
-  lines.push("");
-
-  lines.push("Possible false-positive groups (heuristic, not deterministic):");
-  for (const [group, data] of Object.entries(input.summary.possibleFalsePositiveGroups)) {
-    lines.push(`  ${group}: ${data.count}`);
-    for (const sample of data.samples) lines.push(`    - ${JSON.stringify(cleanText(sample, input.raw))}`);
-  }
-
-  return lines.join("\n");
-}
@@ -1,155 +0,0 @@
-import {
-  DORMANT_DECAY_MULTIPLIER,
-  RETENTION_TYPE_MAX,
-} from "../../../src/retention.ts";
-import { TYPES } from "../constants.ts";
-import { daysSinceIso, formatStrength } from "../retention-model.ts";
-import { cleanText, truncate } from "../text.ts";
-import type { MemoryInspectionReadModel, RetentionDiagItem } from "../types.ts";
-
-export type MemoryStatusLevel = "ok" | "warning" | "degraded";
-
-export type StatusReadout = {
-  status: MemoryStatusLevel;
-  summaryText: string;
-  active: number;
-  rendered: number;
-  pending: number;
-  rejectedLast7Days: number;
-  evidenceCoveragePercent: number;
-  needsAttention: string[];
-  suggestedNextSteps: string[];
-  caps: {
-    active: number;
-    maxEntries: number;
-    rendered: number;
-    typeCapped: number;
-    globalCapped: number;
-    typeCounts: Record<string, number>;
-    capsFull: boolean;
-  };
-  retention: { present: number; missing: number; invalid: number };
-  evidence: {
-    currentWithEvidence: number;
-    currentWithoutEvidence: number;
-    evidenceMemoryIds: number;
-    disappearances: number;
-    unknownDisappearances: number;
-    withTerminalReason: number;
-  };
-  rejections: {
-    totalRecords: number;
-    workspaceScopedCount: number;
-    legacyUnscopedCount: number;
-    falsePositiveRisk: string;
-  };
-  dormant: {
-    lastActivityAt?: string;
-    wallDaysSinceActivity: number | null;
-    dormantDiscountActive: boolean;
-    dormantDaysPastGrace: number;
-  };
-  topRendered: RetentionDiagItem[];
-  weakestActive: RetentionDiagItem[];
-};
-
-export function formatStatus(readout: StatusReadout, model: MemoryInspectionReadModel, options: { verbose?: boolean; noEmoji?: boolean; isTty?: boolean; raw?: boolean } = {}): string {
-  if (options.verbose) return formatStatusVerbose(readout, model, options);
-
-  const lines: string[] = [];
-  const label = statusLabel(readout.status, options);
-  lines.push(`${label} Memory status`);
-  lines.push("");
-  lines.push("Key metrics:");
-  lines.push(`  active memories: ${readout.active}`);
-  lines.push(`  rendered: ${readout.rendered}`);
-  lines.push(`  pending: ${readout.pending}`);
-  lines.push(`  rejected 7d: ${readout.rejectedLast7Days}`);
-  lines.push(`  evidence coverage: ${readout.evidenceCoveragePercent}%`);
-
-  if (readout.needsAttention.length > 0) {
-    lines.push("");
-    lines.push("Needs attention:");
-    for (const item of readout.needsAttention) lines.push(`  - ${item}`);
-  }
-
-  if (readout.status !== "ok" && readout.suggestedNextSteps.length > 0) {
-    lines.push("");
-    lines.push("Suggested next steps:");
-    for (const item of readout.suggestedNextSteps) lines.push(`  - ${item}`);
-  }
-
-  return lines.join("\n");
-}
-
-function statusLabel(status: MemoryStatusLevel, options: { noEmoji?: boolean; isTty?: boolean }): string {
-  const text = status === "ok" ? "OK" : status === "warning" ? "WARNING" : "DEGRADED";
-  if (options.noEmoji || !options.isTty) return text;
-  const emoji = status === "ok" ? "🧠" : status === "warning" ? "⚠️" : "✖️";
-  return `${emoji} ${text}`;
-}
-
-function formatStatusVerbose(readout: StatusReadout, model: MemoryInspectionReadModel, options: { raw?: boolean } = {}): string {
-  const lines: string[] = [];
-  lines.push("Memory status inspection");
-  lines.push("");
-  lines.push(readout.summaryText);
-  lines.push("");
-  lines.push("Caps:");
-  lines.push(`  active: ${readout.caps.active} / ${readout.caps.maxEntries}`);
-  for (const type of TYPES) {
-    const count = readout.caps.typeCounts[type] ?? 0;
-    const limit = RETENTION_TYPE_MAX[type];
-    const marker = count >= limit ? " FULL" : "";
-    lines.push(`  ${type}: ${count} / ${limit}${marker}`);
-  }
-  lines.push(`  rendered: ${readout.caps.rendered}`);
-  lines.push(`  type-capped entries: ${readout.caps.typeCapped}`);
-  lines.push(`  global-cap overflow: ${readout.caps.globalCapped}`);
-  lines.push(`  caps full: ${readout.caps.capsFull ? "yes" : "no"}`);
-  lines.push("");
-  lines.push("Retention clocks:");
-  lines.push(`  present: ${readout.retention.present}`);
-  lines.push(`  missing: ${readout.retention.missing}`);
-  lines.push(`  invalid: ${readout.retention.invalid}`);
-  lines.push("");
-  lines.push("Evidence:");
-  lines.push(`  current with evidence: ${readout.evidence.currentWithEvidence}`);
-  lines.push(`  current without evidence: ${readout.evidence.currentWithoutEvidence}`);
-  lines.push(`  evidence memory ids: ${readout.evidence.evidenceMemoryIds}`);
-  lines.push(`  disappearances: ${readout.evidence.disappearances}`);
-  lines.push(`  unknown disappearances: ${readout.evidence.unknownDisappearances}`);
-  lines.push("");
-  lines.push("Rejection scoping:");
-  lines.push(`  total records: ${readout.rejections.totalRecords}`);
-  lines.push(`  workspace scoped: ${readout.rejections.workspaceScopedCount}`);
-  lines.push(`  legacy unscoped: ${readout.rejections.legacyUnscopedCount}`);
-  lines.push(`  false-positive risk: ${readout.rejections.falsePositiveRisk}`);
-  lines.push("");
-  lines.push("Dormancy:");
-  lines.push(`  lastActivityAt: ${readout.dormant.lastActivityAt ?? "(missing)"}`);
-  lines.push(`  wall days since activity: ${readout.dormant.wallDaysSinceActivity === null ? "unknown" : readout.dormant.wallDaysSinceActivity.toFixed(1)}`);
-  lines.push(`  dormant discount active: ${readout.dormant.dormantDiscountActive ? "yes" : "no"}`);
-  lines.push(`  dormant days past grace: ${readout.dormant.dormantDaysPastGrace.toFixed(1)}`);
-  lines.push(`  dormant multiplier: ${DORMANT_DECAY_MULTIPLIER}`);
-  lines.push("");
-  lines.push("Top rendered candidates:");
-  pushMemoryItems(lines, readout.topRendered, options.raw === true);
-  lines.push("");
-  lines.push("Weakest active memories:");
-  pushMemoryItems(lines, readout.weakestActive, options.raw === true);
-  lines.push("");
-  lines.push("Store:");
-  lines.push(`  superseded: ${model.store.entries.length - readout.active}`);
-  return lines.join("\n");
-}
-
-function pushMemoryItems(lines: string[], items: RetentionDiagItem[], raw: boolean): void {
-  if (items.length === 0) {
-    lines.push("  (none)");
-    return;
-  }
-  for (const item of items) {
-    lines.push(`  - strength=${formatStrength(item.strength)} [${item.entry.type}] ${truncate(cleanText(item.entry.text, raw))}`);
-  }
-}
@@ -1,36 +0,0 @@
-import type { EvidenceEventV1 } from "../../../src/evidence-log.ts";
-import { formatTraceEvent, relationMemoryIds, statusFromTraceEvent } from "../trace-model.ts";
-import type { WorkspaceDiagSnapshot } from "../types.ts";
-
-export function formatTrace(memoryId: string, snapshot: WorkspaceDiagSnapshot, trace: { events: EvidenceEventV1[] }): string {
-  const lines: string[] = [];
-  const memoryRow = snapshot.memories.find(memory => memory.id === memoryId);
-  const status = memoryRow?.status ?? statusFromTraceEvent(trace.events.at(-1));
-
-  lines.push(`Memory ${memoryId}: ${status}`);
-  lines.push("");
-  lines.push("Lifecycle:");
-  if (trace.events.length === 0) {
-    lines.push("(none)");
-    return lines.join("\n");
-  }
-
-  for (const event of trace.events) {
-    lines.push(formatTraceEvent(event));
-  }
-
-  const supersededBy = relationMemoryIds(trace.events, "superseded_by");
-  if (supersededBy.length > 0) {
-    lines.push("");
-    lines.push("Superseded by:");
-    for (const id of supersededBy) lines.push(`- ${id}`);
-  }
-
-  const reinforcedBy = relationMemoryIds(trace.events, "reinforced_by");
-  if (reinforcedBy.length > 0) {
-    lines.push("");
-    lines.push("Reinforced by:");
-    for (const id of reinforcedBy) lines.push(`- ${id}`);
-  }
-  return lines.join("\n");
-}
@@ -1,98 +0,0 @@
-import type { EvidenceEventV1 } from "../../src/evidence-log.ts";
-import type { LongTermType } from "../../src/types.ts";
-import { countBy, objectFromCounts, uniqueStrings } from "./text.ts";
-import { groupEvidenceByMemoryId } from "./evidence-model.ts";
-import { loadRejectionRecords } from "./rejections-model.ts";
-import { snapshotForOptions } from "./workspace-snapshot.ts";
-import type { CliOptions, CoverageClass, DisappearanceReason, MemoryInspectionReadModel } from "./types.ts";
-
-export async function buildInspectionReadModel(options: CliOptions): Promise<MemoryInspectionReadModel> {
-  const snapshot = await snapshotForOptions(options);
-  const rejections = await loadRejectionRecords(options);
-  return {
-    snapshot,
-    store: snapshot.store,
-    pending: snapshot.journal,
-    evidenceEvents: snapshot.allEvents,
-    rejectionRecords: rejections.records,
-    currentById: new Map(snapshot.store.entries.map(entry => [entry.id, entry])),
-    evidenceByMemoryId: groupEvidenceByMemoryId(snapshot.allEvents),
-  };
-}
-
-export function terminalDisappearanceReason(events: EvidenceEventV1[]): DisappearanceReason {
-  const terminal = [...events].reverse().find(event =>
-    event.type === "memory_removed_capacity"
-      || event.type === "promotion_absorbed_exact"
-      || event.type === "promotion_absorbed_identity"
-      || event.type === "promotion_superseded"
-  );
-  const renderOmission = [...events].reverse().find(event => event.type === "render_omitted");
-  const event = terminal ?? renderOmission;
-  if (!event) {
-    return { classification: "historical_absent_unknown_reason", terminalType: "unknown", reasonCodes: [] };
-  }
-  return {
-    classification: "historical_absent_with_reason",
-    terminalType: event.type,
-    reasonCodes: event.reasonCodes,
-    event,
-  };
-}
-
-export function coverageClassForMemory(id: string, model: MemoryInspectionReadModel): CoverageClass {
-  const events = model.evidenceByMemoryId.get(id) ?? [];
-  if (!model.currentById.has(id)) return terminalDisappearanceReason(events).classification;
-  if (events.length === 0) return "no_evidence";
-  if (events.every(event => event.phase === "render")) return "render_only";
-  return "full_lifecycle";
-}
-
-export function eventCounts(events: EvidenceEventV1[]): { total: number; byType: Record<string, number>; byPhase: Record<string, number> } {
-  return {
-    total: events.length,
-    byType: objectFromCounts(countBy(events.map(event => event.type))),
-    byPhase: objectFromCounts(countBy(events.map(event => event.phase))),
-  };
-}
-
-export function coverageRows(model: MemoryInspectionReadModel, includeHistorical: boolean): Array<{
-  id: string;
-  class: CoverageClass;
-  current: boolean;
-  type?: LongTermType;
-  eventCounts: ReturnType<typeof eventCounts>;
-}> {
-  const ids = new Set<string>(model.currentById.keys());
-  if (includeHistorical) {
-    for (const id of model.evidenceByMemoryId.keys()) ids.add(id);
-  }
-  return [...ids].sort().map(id => {
-    const entry = model.currentById.get(id);
-    const events = model.evidenceByMemoryId.get(id) ?? [];
-    return {
-      id,
-      class: coverageClassForMemory(id, model),
-      current: Boolean(entry),
-      type: entry?.type ?? events.find(event => event.memory?.memoryId === id)?.memory?.type,
-      eventCounts: eventCounts(events),
-    };
-  });
-}
-
-export function disappearanceRows(model: MemoryInspectionReadModel): Array<{
-  id: string;
-  classification: DisappearanceReason["classification"];
-  terminalType: DisappearanceReason["terminalType"];
-  reasonCodes: string[];
-  event?: EvidenceEventV1;
-  events: EvidenceEventV1[];
-}> {
-  const rows = [...model.evidenceByMemoryId.entries()]
-    .filter(([id]) => !model.currentById.has(id))
-    .map(([id, events]) => {
-      const reason = terminalDisappearanceReason(events);
-      return { id, ...reason, events };
-    });
-  return rows.sort((a, b) => a.classification.localeCompare(b.classification) || a.id.localeCompare(b.id));
-}
@@ -1,36 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-
-export async function readJSONFile<T>(path: string): Promise<T | null> {
-  try {
-    return JSON.parse(await readFile(path, "utf8")) as T;
-  } catch {
-    return null;
-  }
-}
-
-export async function readJSONLFile<T>(path: string): Promise<{ records: T[]; invalidLines: number }> {
-  let content = "";
-  try {
-    content = await readFile(path, "utf8");
-  } catch {
-    return { records: [], invalidLines: 0 };
-  }
-
-  const records: T[] = [];
-  let invalidLines = 0;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      records.push(JSON.parse(trimmed) as T);
-    } catch {
-      invalidLines += 1;
-    }
-  }
-  return { records, invalidLines };
-}
-
-export function pathExists(path: string): boolean {
-  return existsSync(path);
-}
@@ -1,42 +0,0 @@
-import { readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { dataHome, migrationLogPath } from "../../src/paths.ts";
-import type { CliOptions, MigrationLogRecord } from "./types.ts";
-
-export function migrationLogsRoot(): string {
-  return join(dataHome(), "opencode-working-memory", "migration-logs");
-}
-
-export async function migrationLogPaths(options: CliOptions): Promise<string[]> {
-  if (options.migration) return [migrationLogPath(options.migration)];
-  const root = migrationLogsRoot();
-  let entries: string[] = [];
-  try {
-    entries = await readdir(root);
-  } catch {
-    return [];
-  }
-  return entries.filter(entry => entry.endsWith(".jsonl")).sort().map(entry => join(root, entry));
-}
-
-export function migrationIdFromPath(path: string): string {
-  return path.split("/").pop()?.replace(/\.jsonl$/, "") ?? "unknown";
-}
-
-export function riskySupersedeReasons(record: MigrationLogRecord): string[] {
-  const reasons: string[] = [];
-  const hardReasonsMissing = !Array.isArray(record.hardReasons);
-  const hardReasons = Array.isArray(record.hardReasons) ? record.hardReasons : [];
-  const qualityReasons = Array.isArray(record.reasons) ? record.reasons : [];
-  const text = record.text ?? "";
-
-  if (hardReasonsMissing || hardReasons.length === 0) reasons.push("missing_or_empty_hardReasons");
-  if (qualityReasons.length > 0 && hardReasons.length === 0) reasons.push("soft_reasons_without_hardReasons");
-  if (/\b(?:User|user|prefers|requires|wants|insists)\b|用戶|使用者|偏好|要求|不要|不刪除/u.test(text)) reasons.push("user_preference_marker");
-  if (/\b(?:must|should|do not|never|is|are|follows)\b|必須|應該|採用|維持|需支援/iu.test(text)) reasons.push("durable_rule_marker");
-  if ((record.type === "feedback" || record.type === "decision") && hardReasons.length === 1 && hardReasons[0] === "path_heavy") {
-    reasons.push("feedback_or_decision_path_heavy_only");
-  }
-
-  return reasons;
-}
@@ -1,136 +0,0 @@
-import { extractionRejectionLogPath, workspaceKey } from "../../src/paths.ts";
-import { HARD_QUALITY_REASONS, isArchitectureLikeDecision } from "../../src/memory-quality.ts";
-import { ALLOWED_ORIGINS } from "./constants.ts";
-import { readJSONLFile } from "./io.ts";
-import { canonicalMemoryText, cleanText, countBy, objectFromCounts, truncate } from "./text.ts";
-import { CliInputError, type CliOptions, type NormalizedRejection, type Origin, type RejectionLogRecord } from "./types.ts";
-
-export { CliInputError } from "./types.ts";
-
-export function inferOrigin(record: RejectionLogRecord): Origin {
-  if (record.origin && ALLOWED_ORIGINS.has(record.origin as Origin)) return record.origin as Origin;
-  if (record.source === "compaction") return "compaction_candidate";
-  if (record.source === "explicit") return "explicit_trigger";
-  if (record.source === "manual") return "manual";
-  return "unknown";
-}
-
-export function normalizeRejection(record: RejectionLogRecord): NormalizedRejection | null {
-  if (!record.text || !Array.isArray(record.reasons)) return null;
-  const origin = inferOrigin(record);
-  return {
-    timestamp: record.timestamp ?? "",
-    workspaceKey: record.workspaceKey,
-    workspaceRoot: record.workspaceRoot,
-    workspaceRootHash: record.workspaceRootHash,
-    type: record.type ?? "project",
-    source: record.source,
-    origin,
-    fromTrigger: typeof record.fromTrigger === "boolean" ? record.fromTrigger : origin === "explicit_trigger",
-    text: record.text,
-    reasons: record.reasons,
-  };
-}
-
-export function sinceCutoff(rawSince: string | undefined, now = Date.now()): number | null {
-  if (!rawSince) return null;
-  const relative = rawSince.match(/^(\d+)([dhm])$/i);
-  if (relative) {
-    const amount = Number(relative[1]);
-    const unit = relative[2].toLowerCase();
-    const multiplier = unit === "d" ? 86_400_000 : unit === "h" ? 3_600_000 : 60_000;
-    return now - amount * multiplier;
-  }
-  const timestamp = new Date(rawSince).getTime();
-  if (Number.isNaN(timestamp)) throw new CliInputError(`Invalid --since value: ${rawSince}`);
-  return timestamp;
-}
-
-export function hasSoftReason(record: NormalizedRejection): boolean {
-  return record.reasons.some(reason => !HARD_QUALITY_REASONS.has(reason));
-}
-
-export function hasWorkspaceScope(record: NormalizedRejection): boolean {
-  return Boolean(record.workspaceKey || record.workspaceRoot || record.workspaceRootHash);
-}
-
-export async function workspaceKeyForOption(options: CliOptions): Promise<string | undefined> {
-  return options.workspace ? workspaceKey(options.workspace) : undefined;
-}
-
-export async function loadRejectionRecords(options: CliOptions): Promise<{ path: string; invalidLines: number; records: NormalizedRejection[] }> {
-  const path = extractionRejectionLogPath();
-  const { records, invalidLines } = await readJSONLFile<RejectionLogRecord>(path);
-  const cutoff = sinceCutoff(options.since);
-  const requestedWorkspaceKey = await workspaceKeyForOption(options);
-  let normalized = records.map(normalizeRejection).filter((record): record is NormalizedRejection => record !== null);
-
-  if (requestedWorkspaceKey) {
-    normalized = normalized.filter(record => !record.workspaceKey || record.workspaceKey === requestedWorkspaceKey);
-  }
-  if (cutoff !== null) {
-    normalized = normalized.filter(record => {
-      const timestamp = new Date(record.timestamp).getTime();
-      return !Number.isNaN(timestamp) && timestamp >= cutoff;
-    });
-  }
-  if (options.softOnly) normalized = normalized.filter(hasSoftReason);
-  if (options.triggerOnly) normalized = normalized.filter(record => record.fromTrigger || record.origin === "explicit_trigger");
-  if (options.reason) normalized = normalized.filter(record => record.reasons.includes(options.reason ?? ""));
-
-  return { path, invalidLines, records: normalized };
-}
-
-export function uniqueByCanonicalText(records: NormalizedRejection[]): NormalizedRejection[] {
-  const byText = new Map<string, NormalizedRejection>();
-  for (const record of records) {
-    const key = `${record.type}:${canonicalMemoryText(record.text)}`;
-    if (!byText.has(key)) byText.set(key, record);
-  }
-  return [...byText.values()];
-}
-
-export function rejectionQualitySummary(records: NormalizedRejection[]): {
-  totalRecords: number;
-  uniqueTexts: number;
-  workspaceScopedCount: number;
-  legacyUnscopedCount: number;
-  reasonDistribution: Record<string, number>;
-  uniqueReasonDistribution: Record<string, number>;
-  possibleFalsePositiveGroups: Record<string, { count: number; samples: string[] }>;
-} {
-  const uniqueRecords = uniqueByCanonicalText(records);
-  const badDecisionUnique = uniqueRecords.filter(record => record.reasons.includes("bad_decision"));
-  const groups: Record<string, { count: number; samples: string[] }> = {
-    architecture_like_possible_false_positive: { count: 0, samples: [] },
-    clearly_garbage: { count: 0, samples: [] },
-    ambiguous: { count: 0, samples: [] },
-  };
-
-  for (const record of badDecisionUnique) {
-    const hardReasons = record.reasons.filter(reason => HARD_QUALITY_REASONS.has(reason));
-    const statusLike = /\b(?:implemented|added|updated|fixed|completed|reviewed|tests?|CI|commit|wave|phase|task|session)\b/i.test(record.text);
-    const group = isArchitectureLikeDecision(record.text) && hardReasons.length === 0 && !statusLike
-      ? "architecture_like_possible_false_positive"
-      : hardReasons.length > 0 || statusLike
-        ? "clearly_garbage"
-        : "ambiguous";
-    groups[group].count += 1;
-    if (groups[group].samples.length < 5) groups[group].samples.push(truncate(cleanText(record.text, false), 120));
-  }
-
-  return {
-    totalRecords: records.length,
-    uniqueTexts: uniqueRecords.length,
-    workspaceScopedCount: records.filter(hasWorkspaceScope).length,
-    legacyUnscopedCount: records.filter(record => !hasWorkspaceScope(record)).length,
-    reasonDistribution: objectFromCounts(countBy(records.flatMap(record => record.reasons))),
-    uniqueReasonDistribution: objectFromCounts(countBy(uniqueRecords.flatMap(record => record.reasons))),
-    possibleFalsePositiveGroups: groups,
-  };
-}
-
-export function rejectionFalsePositiveRisk(summary: ReturnType<typeof rejectionQualitySummary>): "low" | "high" {
-  const possible = summary.possibleFalsePositiveGroups.architecture_like_possible_false_positive.count;
-  return possible >= 3 || (summary.uniqueTexts > 0 && possible / summary.uniqueTexts >= 0.5) ? "high" : "low";
-}
@@ -1,84 +0,0 @@
-import {
-  RETENTION_TYPE_MAX,
-  calculateRetentionStrength,
-} from "../../src/retention.ts";
-import type { LongTermMemoryEntry, LongTermSource, LongTermType, WorkspaceMemoryStore } from "../../src/types.ts";
-import { LONG_TERM_LIMITS, PROMOTION_RETRY_LIMITS } from "../../src/types.ts";
-import type { RetentionDiagItem } from "./types.ts";
-
-export function ageDays(entry: LongTermMemoryEntry, now = Date.now()): number | null {
-  const time = new Date(entry.createdAt).getTime();
-  if (Number.isNaN(time)) return null;
-  return Math.floor((now - time) / 86_400_000);
-}
-
-export function formatStrength(value: number): string {
-  return Number.isFinite(value) ? value.toFixed(3) : "0.000";
-}
-
-export function daysSinceIso(value: string | undefined, now = Date.now()): number | null {
-  if (!value) return null;
-  const ms = new Date(value).getTime();
-  if (!Number.isFinite(ms)) return null;
-  return Math.max(0, (now - ms) / 86_400_000);
-}
-
-export function isSafetyCriticalForDiag(entry: LongTermMemoryEntry): boolean {
-  return entry.safetyCritical === true;
-}
-
-export function retentionCandidatesForDiag(store: WorkspaceMemoryStore, now = Date.now()): {
-  sorted: RetentionDiagItem[];
-  rendered: RetentionDiagItem[];
-  typeCapped: RetentionDiagItem[];
-  globalCapped: RetentionDiagItem[];
-} {
-  const active = store.entries.filter(entry => entry.status !== "superseded");
-  const sorted = active
-    .map(entry => ({ entry, strength: calculateRetentionStrength(entry, now, store.lastActivityAt) }))
-    .sort((a, b) => b.strength - a.strength || a.entry.id.localeCompare(b.entry.id));
-
-  const rendered: RetentionDiagItem[] = [];
-  const typeCapped: RetentionDiagItem[] = [];
-  const globalCapped: RetentionDiagItem[] = [];
-  const typeCounts: Partial<Record<LongTermType, number>> = {};
-
-  for (const item of sorted) {
-    const count = typeCounts[item.entry.type] ?? 0;
-    const max = RETENTION_TYPE_MAX[item.entry.type] ?? Infinity;
-    if (count >= max) {
-      typeCapped.push(item);
-      continue;
-    }
-    typeCounts[item.entry.type] = count + 1;
-
-    if (rendered.length < LONG_TERM_LIMITS.maxEntries) {
-      rendered.push(item);
-    } else {
-      globalCapped.push(item);
-    }
-  }
-
-  return { sorted, rendered, typeCapped, globalCapped };
-}
-
-export function promotionLimit(source: LongTermSource): number {
-  if (source === "manual") return PROMOTION_RETRY_LIMITS.maxManualAttempts;
-  return PROMOTION_RETRY_LIMITS.maxExplicitAttempts;
-}
-
-export function retentionClockSummary(entries: LongTermMemoryEntry[]): { present: number; missing: number; invalid: number } {
-  let present = 0;
-  let missing = 0;
-  let invalid = 0;
-  for (const entry of entries) {
-    if (entry.retentionClock === undefined) {
-      missing += 1;
-    } else if (!Number.isFinite(entry.retentionClock) || entry.retentionClock <= 0) {
-      invalid += 1;
-    } else {
-      present += 1;
-    }
-  }
-  return { present, missing, invalid };
-}
@@ -1,69 +0,0 @@
-import { createHash } from "node:crypto";
-import type { EvidenceEventV1 } from "../../src/evidence-log.ts";
-import { redactCredentials } from "../../src/redaction.ts";
-
-export function countBy<T extends string>(items: T[]): Map<T, number> {
-  const counts = new Map<T, number>();
-  for (const item of items) counts.set(item, (counts.get(item) ?? 0) + 1);
-  return counts;
-}
-
-export function sortedCounts<T extends string>(counts: Map<T, number>): Array<[T, number]> {
-  return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
-}
-
-export function workspaceRootHash(root: string): string {
-  return createHash("sha256").update(root).digest("hex").slice(0, 16);
-}
-
-export function redactAbsolutePaths(text: string): string {
-  return text.replace(/(?:^|[\s"'`(=:\[])(\/(?:Users|home|private|tmp|var|opt|Volumes|[^\s"'`)\],;:]+)\/[^\s"'`)\],;:]*)/g, (match, path) => match.replace(path, "<path>"));
-}
-
-export function cleanText(text: string, raw: boolean): string {
-  if (raw) return text;
-  return redactAbsolutePaths(redactCredentials(text));
-}
-
-export function cleanPath(path: string, raw: boolean): string {
-  return raw ? path : "<path>";
-}
-
-export function formatWorkspaceIdentity(workspaceKeyValue: string | undefined, workspaceRoot: string | undefined, raw: boolean): string {
-  const parts: string[] = [];
-  if (workspaceKeyValue) parts.push(`workspaceKey=${workspaceKeyValue}`);
-  if (workspaceRoot) {
-    parts.push(raw ? `workspaceRoot=${workspaceRoot}` : `workspaceRootHash=${workspaceRootHash(workspaceRoot)}`);
-  }
-  return parts.join(" ");
-}
-
-export function truncate(text: string, max = 120): string {
-  const collapsed = text.replace(/\s+/g, " ").trim();
-  return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 1)}…`;
-}
-
-export function canonicalMemoryText(text: string): string {
-  return text
-    .normalize("NFKC")
-    .toLowerCase()
-    .replace(/[\s\p{P}]+/gu, " ")
-    .trim();
-}
-
-export function formatPercent(ratio: number): string {
-  return `${(ratio * 100).toFixed(1)}%`;
-}
-
-export function uniqueStrings(values: string[]): string[] {
-  return [...new Set(values.filter(Boolean))];
-}
-
-export function objectFromCounts<T extends string>(counts: Map<T, number>): Record<string, number> {
-  return Object.fromEntries(sortedCounts(counts));
-}
-
-export function formatDetails(details: EvidenceEventV1["details"]): string {
-  if (!details || Object.keys(details).length === 0) return "none";
-  return Object.entries(details).map(([key, value]) => `${key}=${Array.isArray(value) ? value.join("|") : String(value)}`).join(" ");
-}
@@ -1,30 +0,0 @@
-import type { EvidenceEventV1 } from "../../src/evidence-log.ts";
-import { uniqueStrings } from "./text.ts";
-import { statusFromOmissionReason } from "./workspace-snapshot.ts";
-
-export function statusFromTraceEvent(event: EvidenceEventV1 | undefined): string {
-  if (!event) return "unknown";
-  if (event.type === "render_selected") return "rendered";
-  if (event.type === "render_omitted") return statusFromOmissionReason(event.reasonCodes[0]);
-  if (event.type === "promotion_absorbed_exact" || event.type === "promotion_absorbed_identity") return "omitted_absorbed_duplicate";
-  if (event.type === "promotion_retry_scheduled") return "pending_retry";
-  if (event.type === "promotion_rejected_capacity" || event.type === "promotion_retry_exhausted") return "pending_rejected_capacity";
-  if (event.type === "storage_corrupt_json_quarantined") return "quarantined_corrupt_store";
-  if (event.outcome === "superseded") return "omitted_superseded";
-  return event.outcome;
-}
-
-export function formatTraceEvent(event: EvidenceEventV1): string {
-  const reasons = event.reasonCodes.length > 0 ? event.reasonCodes.join(",") : "none";
-  const relations = (event.relations ?? [])
-    .map(relation => relation.memory?.memoryId ? `${relation.role}=${relation.memory.memoryId}` : undefined)
-    .filter((value): value is string => Boolean(value));
-  const relationText = relations.length > 0 ? `; ${relations.join(", ")}` : "";
-  return `- ${event.eventId} ${event.type}: ${event.outcome}; reasons=${reasons}${relationText}`;
-}
-
-export function relationMemoryIds(events: EvidenceEventV1[], role: string): string[] {
-  return uniqueStrings(events.flatMap(event => (event.relations ?? [])
-    .filter(relation => relation.role === role)
-    .map(relation => relation.memory?.memoryId ?? "")));
-}
@@ -1,159 +0,0 @@
-import type { EvidenceEventType, EvidenceEventV1, EvidenceOutcome } from "../../src/evidence-log.ts";
-import type { LongTermMemoryEntry, LongTermSource, LongTermType, PendingMemoryJournalStore, WorkspaceMemoryStore } from "../../src/types.ts";
-import type { Command } from "./command-metadata.ts";
-
-export type { Command, HiddenCommand, VisibleCommand } from "./command-metadata.ts";
-
-export type MemoryRenderStatus =
-  | "rendered"
-  | "omitted_superseded"
-  | "omitted_type_cap"
-  | "omitted_global_cap"
-  | "omitted_char_budget"
-  | "omitted_absorbed_duplicate"
-  | "pending_retry"
-  | "pending_rejected_capacity"
-  | "quarantined_corrupt_store";
-
-export type MemoryDiagJSON = {
-  version: 1;
-  workspace: { rootHash: string; key: string };
-  generatedAt: string;
-  summary: {
-    storedActive: number;
-    rendered: number;
-    pending: number;
-    rejectedLast7Days: number;
-    corruptStoresQuarantinedLast30Days: number;
-    status?: "ok" | "warning" | "degraded";
-    evidenceCoveragePercent?: number;
-    needsAttention?: string[];
-    suggestedNextSteps?: string[];
-  };
-  memories: Array<{
-    id: string;
-    type: "feedback" | "project" | "decision" | "reference";
-    source: "explicit" | "compaction" | "manual";
-    status: MemoryRenderStatus;
-    strength?: number;
-    reasonCodes: string[];
-    textPreview?: string;
-    evidenceEventIds: string[];
-  }>;
-  recentEvents: Array<{
-    eventId: string;
-    type: EvidenceEventType;
-    outcome: EvidenceOutcome;
-    createdAt: string;
-    memoryId?: string;
-    reasonCodes: string[];
-  }>;
-};
-
-export type Origin = "explicit_trigger" | "compaction_candidate" | "manual" | "migration_check" | "unknown";
-
-export type CliOptions = {
-  raw: boolean;
-  json?: boolean;
-  verbose?: boolean;
-  noEmoji?: boolean;
-  workspace?: string;
-  all?: boolean;
-  softOnly?: boolean;
-  triggerOnly?: boolean;
-  includeHistorical?: boolean;
-  reason?: string;
-  explain?: boolean;
-  since?: string;
-  migration?: string;
-  memory?: string;
-  event?: string;
-  apply?: boolean;
-  positional?: string[];
-  auditMode?: "coverage" | "migrations";
-};
-
-export type ParsedArgs =
-  | { ok: true; command: Command; options: CliOptions; deprecationNotice?: string }
-  | { ok: true; help: true; usage: string }
-  | { ok: false; message: string; usage: string; exitCode: number };
-
-export type CommandResult = { stdout: string; stderr?: string; exitCode?: number };
-
-export class CliInputError extends Error {}
-
-export type RejectionLogRecord = {
-  timestamp?: string;
-  workspaceKey?: string;
-  workspaceRoot?: string;
-  workspaceRootHash?: string;
-  type?: LongTermType;
-  source?: LongTermSource | string;
-  origin?: string;
-  fromTrigger?: boolean;
-  text?: string;
-  reasons?: string[];
-};
-
-export type NormalizedRejection = Required<Pick<RejectionLogRecord, "timestamp" | "type" | "text" | "reasons">> & {
-  workspaceKey?: string;
-  workspaceRoot?: string;
-  workspaceRootHash?: string;
-  source?: string;
-  origin: Origin;
-  fromTrigger: boolean;
-};
-
-export type MigrationLogRecord = {
-  migrationId?: string;
-  timestamp?: string;
-  workspaceKey?: string;
-  workspaceRoot?: string;
-  entryId?: string;
-  type?: LongTermType;
-  source?: LongTermSource | string;
-  text?: string;
-  reasons?: string[];
-  hardReasons?: string[];
-  beforeStatus?: string;
-  afterStatus?: string;
-};
-
-export type RetentionDiagItem = {
-  entry: LongTermMemoryEntry;
-  strength: number;
-};
-
-export type WorkspaceDiagSnapshot = {
-  store: WorkspaceMemoryStore;
-  journal: PendingMemoryJournalStore;
-  retention: {
-    sorted: RetentionDiagItem[];
-    rendered: RetentionDiagItem[];
-    typeCapped: RetentionDiagItem[];
-    globalCapped: RetentionDiagItem[];
-  };
-  memories: MemoryDiagJSON["memories"];
-  recentEvents: MemoryDiagJSON["recentEvents"];
-  allEvents: EvidenceEventV1[];
-  summary: MemoryDiagJSON["summary"];
-};
-
-export type MemoryInspectionReadModel = {
-  snapshot: WorkspaceDiagSnapshot;
-  store: WorkspaceMemoryStore;
-  pending: PendingMemoryJournalStore;
-  evidenceEvents: EvidenceEventV1[];
-  rejectionRecords: NormalizedRejection[];
-  currentById: Map<string, LongTermMemoryEntry>;
-  evidenceByMemoryId: Map<string, EvidenceEventV1[]>;
-};
-
-export type CoverageClass = "full_lifecycle" | "render_only" | "no_evidence" | "historical_absent_with_reason" | "historical_absent_unknown_reason";
-
-export type DisappearanceReason = {
-  classification: "historical_absent_with_reason" | "historical_absent_unknown_reason";
-  terminalType: EvidenceEventType | "unknown";
-  reasonCodes: string[];
-  event?: EvidenceEventV1;
-};
@@ -1,236 +0,0 @@
-import { calculateRetentionStrength } from "../../src/retention.ts";
-import {
-  queryEvidenceEvents,
-  type EvidenceEventV1,
-} from "../../src/evidence-log.ts";
-import { workspaceKey, workspaceMemoryPath, workspacePendingJournalPath } from "../../src/paths.ts";
-import { accountWorkspaceMemoryRender } from "../../src/workspace-memory.ts";
-import type { LongTermMemoryEntry, PendingMemoryJournalStore, WorkspaceMemoryStore } from "../../src/types.ts";
-import { LONG_TERM_LIMITS } from "../../src/types.ts";
-import { readJSONFile } from "./io.ts";
-import { groupEvidenceByMemoryId } from "./evidence-model.ts";
-import { promotionLimit, retentionCandidatesForDiag } from "./retention-model.ts";
-import { cleanText, truncate, uniqueStrings, workspaceRootHash } from "./text.ts";
-import type { CliOptions, MemoryDiagJSON, MemoryRenderStatus, WorkspaceDiagSnapshot } from "./types.ts";
-
-export function emptyStore(root: string, key: string): WorkspaceMemoryStore {
-  return {
-    version: 1,
-    workspace: { root, key },
-    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries: [],
-    migrations: [],
-    updatedAt: new Date(0).toISOString(),
-  };
-}
-
-export function normalizedStore(store: WorkspaceMemoryStore | null, root: string, key: string): WorkspaceMemoryStore {
-  const fallback = emptyStore(root, key);
-  return {
-    ...fallback,
-    ...(store ?? {}),
-    workspace: store?.workspace ?? fallback.workspace,
-    limits: {
-      maxRenderedChars: store?.limits?.maxRenderedChars ?? fallback.limits.maxRenderedChars,
-      maxEntries: store?.limits?.maxEntries ?? fallback.limits.maxEntries,
-    },
-    entries: Array.isArray(store?.entries) ? store.entries : [],
-    migrations: Array.isArray(store?.migrations) ? store.migrations : [],
-  };
-}
-
-export function normalizedJournal(journal: PendingMemoryJournalStore | null): PendingMemoryJournalStore {
-  return {
-    version: 1,
-    workspace: journal?.workspace ?? { root: "", key: "" },
-    entries: Array.isArray(journal?.entries) ? journal.entries : [],
-    updatedAt: journal?.updatedAt ?? new Date(0).toISOString(),
-  };
-}
-
-export function eventMemoryId(event: EvidenceEventV1): string | undefined {
-  return event.memory?.memoryId
-    ?? event.relations?.map(relation => relation.memory?.memoryId).find((id): id is string => Boolean(id));
-}
-
-export function isWithinDays(iso: string, days: number, now = Date.now()): boolean {
-  const ms = new Date(iso).getTime();
-  return Number.isFinite(ms) && ms >= now - days * 86_400_000;
-}
-
-export function renderStatusReason(status: MemoryRenderStatus, fallback?: string): string[] {
-  switch (status) {
-    case "rendered": return ["within_caps", "within_char_budget"];
-    case "omitted_superseded": return ["superseded"];
-    case "omitted_type_cap": return ["type_cap"];
-    case "omitted_global_cap": return ["global_cap"];
-    case "omitted_char_budget": return [fallback === "empty_render_budget" ? "empty_render_budget" : "char_budget"];
-    case "omitted_absorbed_duplicate": return ["absorbed_duplicate"];
-    case "pending_retry": return ["retryable_capacity_rejection"];
-    case "pending_rejected_capacity": return ["capacity_rejected", "max_attempts_reached"];
-    case "quarantined_corrupt_store": return ["invalid_json"];
-  }
-}
-
-export function statusFromOmissionReason(reason: string | undefined): MemoryRenderStatus {
-  if (reason === "superseded") return "omitted_superseded";
-  if (reason === "type_cap") return "omitted_type_cap";
-  if (reason === "global_cap") return "omitted_global_cap";
-  return "omitted_char_budget";
-}
-
-export function pendingStatus(entry: LongTermMemoryEntry): MemoryRenderStatus {
-  const attempts = entry.promotionAttempts ?? 0;
-  return attempts >= promotionLimit(entry.source) ? "pending_rejected_capacity" : "pending_retry";
-}
-
-export function safeTextPreview(text: string): string {
-  return truncate(cleanText(text, false), 120);
-}
-
-function evidenceSummaryForMemory(grouped: Map<string, EvidenceEventV1[]>, memoryId: string): { eventIds: string[]; reasonCodes: string[] } {
-  const events = grouped.get(memoryId) ?? [];
-  const reasonCodes = new Set<string>();
-  for (const event of events) {
-    for (const reason of event.reasonCodes) reasonCodes.add(reason);
-  }
-  return {
-    eventIds: events.map(event => event.eventId),
-    reasonCodes: [...reasonCodes],
-  };
-}
-
-export async function buildWorkspaceDiagSnapshot(input: {
-  root: string;
-  key: string;
-  memoryPath: string;
-  pendingPath: string;
-}, now = Date.now()): Promise<WorkspaceDiagSnapshot> {
-  const rawStore = await readJSONFile<WorkspaceMemoryStore>(input.memoryPath);
-  const storeRoot = rawStore?.workspace?.root ?? input.root;
-  const storeKey = rawStore?.workspace?.key ?? input.key;
-  const store = normalizedStore(rawStore, storeRoot, storeKey);
-  const journal = normalizedJournal(await readJSONFile<PendingMemoryJournalStore>(input.pendingPath));
-  const retention = retentionCandidatesForDiag(store, now);
-  const renderAccounting = accountWorkspaceMemoryRender(store);
-  const renderedIds = new Set(renderAccounting.rendered.map(memory => memory.id));
-  const omittedById = new Map(renderAccounting.omitted.map(item => [item.memory.id, item.reason]));
-  const allEvents = await queryEvidenceEvents(input.root);
-  const evidenceByMemoryId = groupEvidenceByMemoryId(allEvents);
-  const recentEvidence = await queryEvidenceEvents(input.root, { newestFirst: true, limit: 50 });
-  const memoryRows: MemoryDiagJSON["memories"] = [];
-  const seenIds = new Set<string>();
-
-  for (const entry of store.entries) {
-    const omissionReason = omittedById.get(entry.id);
-    const status: MemoryRenderStatus = renderedIds.has(entry.id)
-      ? "rendered"
-      : statusFromOmissionReason(omissionReason ?? (entry.status === "superseded" ? "superseded" : undefined));
-    const summary = evidenceSummaryForMemory(evidenceByMemoryId, entry.id);
-    memoryRows.push({
-      id: entry.id,
-      type: entry.type,
-      source: entry.source,
-      status,
-      strength: calculateRetentionStrength(entry, now, store.lastActivityAt),
-      reasonCodes: uniqueStrings([...renderStatusReason(status, omissionReason), ...summary.reasonCodes]),
-      textPreview: safeTextPreview(entry.text),
-      evidenceEventIds: summary.eventIds,
-    });
-    seenIds.add(entry.id);
-  }
-
-  for (const entry of journal.entries) {
-    const status = pendingStatus(entry);
-    const summary = evidenceSummaryForMemory(evidenceByMemoryId, entry.id);
-    memoryRows.push({
-      id: entry.id,
-      type: entry.type,
-      source: entry.source,
-      status,
-      strength: calculateRetentionStrength(entry, now, store.lastActivityAt),
-      reasonCodes: uniqueStrings([...renderStatusReason(status), entry.lastPromotionFailureReason ?? "", ...summary.reasonCodes]),
-      textPreview: safeTextPreview(entry.text),
-      evidenceEventIds: summary.eventIds,
-    });
-    seenIds.add(entry.id);
-  }
-
-  for (const event of allEvents) {
-    if (event.outcome !== "absorbed") continue;
-    const memory = event.memory;
-    if (!memory?.memoryId || !memory.type || !memory.source || seenIds.has(memory.memoryId)) continue;
-    const summary = evidenceSummaryForMemory(evidenceByMemoryId, memory.memoryId);
-    memoryRows.push({
-      id: memory.memoryId,
-      type: memory.type,
-      source: memory.source,
-      status: "omitted_absorbed_duplicate",
-      reasonCodes: uniqueStrings([...renderStatusReason("omitted_absorbed_duplicate"), ...summary.reasonCodes]),
-      evidenceEventIds: summary.eventIds.length > 0 ? summary.eventIds : [event.eventId],
-    });
-    seenIds.add(memory.memoryId);
-  }
-
-  const recentEvents = recentEvidence.map(event => ({
-    eventId: event.eventId,
-    type: event.type,
-    outcome: event.outcome,
-    createdAt: event.createdAt,
-    memoryId: eventMemoryId(event),
-    reasonCodes: uniqueStrings([
-      ...event.reasonCodes,
-      ...(event.type === "storage_corrupt_json_quarantined" ? ["quarantined_corrupt_store"] : []),
-    ]),
-  }));
-
-  return {
-    store,
-    journal,
-    retention,
-    memories: memoryRows,
-    recentEvents,
-    allEvents,
-    summary: {
-      storedActive: store.entries.filter(entry => entry.status !== "superseded").length,
-      rendered: retention.rendered.length,
-      pending: journal.entries.length,
-      rejectedLast7Days: allEvents.filter(event => event.outcome === "rejected" && isWithinDays(event.createdAt, 7, now)).length,
-      corruptStoresQuarantinedLast30Days: allEvents.filter(event => event.type === "storage_corrupt_json_quarantined" && isWithinDays(event.createdAt, 30, now)).length,
-    },
-  };
-}
-
-export async function buildMemoryDiagJSON(root: string): Promise<MemoryDiagJSON> {
-  const key = await workspaceKey(root);
-  const snapshot = await buildWorkspaceDiagSnapshot({
-    root,
-    key,
-    memoryPath: await workspaceMemoryPath(root),
-    pendingPath: await workspacePendingJournalPath(root),
-  });
-
-  return memoryDiagJSONFromSnapshot(root, snapshot);
-}
-
-export function memoryDiagJSONFromSnapshot(root: string, snapshot: WorkspaceDiagSnapshot, generatedAt = new Date().toISOString()): MemoryDiagJSON {
-  return {
-    version: 1,
-    workspace: { rootHash: workspaceRootHash(snapshot.store.workspace.root || root), key: snapshot.store.workspace.key },
-    generatedAt,
-    summary: snapshot.summary,
-    memories: snapshot.memories,
-    recentEvents: snapshot.recentEvents,
-  };
-}
-
-export async function snapshotForOptions(options: CliOptions): Promise<WorkspaceDiagSnapshot> {
-  const root = options.workspace ?? process.cwd();
-  const key = await workspaceKey(root);
-  return buildWorkspaceDiagSnapshot({
-    root,
-    key,
-    memoryPath: await workspaceMemoryPath(root),
-    pendingPath: await workspacePendingJournalPath(root),
-  });
-}
@@ -20,9 +20,6 @@ export type EvidenceEventType =
  | "promotion_retry_scheduled"
  | "promotion_retry_exhausted"
  | "memory_reinforced"
-  | "memory_replaced_numbered_ref"
-  | "memory_reverted_numbered_ref"
-  | "memory_migration_superseded"
  | "render_selected"
  | "render_omitted"
  | "memory_removed_capacity"
@@ -73,12 +70,10 @@ export type EvidenceRelation = {
    | "promoted"
    | "retained"
    | "absorbed"
-    | "target"
    | "superseded"
    | "superseded_by"
    | "reinforced"
    | "reinforced_by"
-    | "recovered"
    | "rendered"
    | "omitted"
    | "removed";
@@ -52,14 +52,9 @@ export function extractExplicitMemories(text: string): LongTermMemoryEntry[] {

 export type WorkspaceMemoryParseResult = {
  entries: LongTermMemoryEntry[];
-  commands: WorkspaceMemoryCommand[];
  evidence: EvidenceEventInput[];
 };

-export type WorkspaceMemoryCommand =
-  | { kind: "REINFORCE"; ref: string }
-  | { kind: "REPLACE"; ref: string; type: LongTermType; text: string };
-
 function evidenceTextPreview(text: string, maxChars = 120): string {
  return redactCredentials(text).replace(/\s+/g, " ").trim().slice(0, maxChars);
 }
@@ -196,7 +191,7 @@ export function extractExplicitMemoriesWithEvidence(text: string): WorkspaceMemo
    }
  }

-  return { entries, commands: [], evidence };
+  return { entries, evidence };
 }

 function classifyExplicitMemory(text: string): LongTermType {
@@ -400,76 +395,6 @@ function shouldAcceptWorkspaceMemoryCandidate(
  return evaluateWorkspaceMemoryCandidate(entry, options).accepted;
 }

-function commandAttemptReason(line: string): string {
-  const normalized = line.replace(/^\s*-\s*/, "").trim();
-  const reinforceMatch = normalized.match(/^REINFORCE\s+(.+)$/i);
-  if (reinforceMatch) {
-    return /^\[M[1-9]\d*\]$/i.test(reinforceMatch[1]?.trim() ?? "")
-      ? "invalid_memory_command"
-      : "invalid_memory_ref";
-  }
-
-  const replaceMatch = normalized.match(/^REPLACE\s+(.*)$/i);
-  if (!replaceMatch) return "invalid_memory_command";
-
-  const rest = replaceMatch[1]?.trim() ?? "";
-  const refMatch = rest.match(/^(\[[^\]]+\]|\S+)(?:\s+(.*))?$/);
-  const ref = refMatch?.[1] ?? "";
-  if (!/^\[M[1-9]\d*\]$/i.test(ref)) return "invalid_memory_ref";
-
-  const afterRef = refMatch?.[2]?.trim() ?? "";
-  const typeMatch = afterRef.match(/^(\[[^\]]+\]|\S+)(?:\s+(.*))?$/);
-  const typeToken = typeMatch?.[1] ?? "";
-  if (!/^\[(feedback|project|decision|reference)\]$/i.test(typeToken)) {
-    return "invalid_memory_type";
-  }
-
-  const replacementText = typeMatch?.[2]?.trim() ?? "";
-  return replacementText ? "invalid_memory_command" : "empty_replacement_text";
-}
-
-function isCommandAttempt(line: string): boolean {
-  const normalized = line.replace(/^\s*-\s*/, "").trim();
-  return /^(REINFORCE|REPLACE)\b/i.test(normalized)
-    || /\b(REINFORCE|REPLACE)\b.*\[?\w+\]?/i.test(normalized);
-}
-
-function parseWorkspaceMemoryCommand(line: string): WorkspaceMemoryCommand | null {
-  const normalized = line.replace(/^\s*-\s*/, "").trim();
-  const reinforce = normalized.match(/^REINFORCE\s+\[(M[1-9]\d*)\]\s*$/i);
-  if (reinforce) {
-    return { kind: "REINFORCE", ref: reinforce[1].toUpperCase() };
-  }
-
-  const replace = normalized.match(/^REPLACE\s+\[(M[1-9]\d*)\]\s+\[(feedback|project|decision|reference)\]\s+(.+)$/i);
-  if (replace) {
-    const text = replace[3].trim();
-    if (!text) return null;
-    return {
-      kind: "REPLACE",
-      ref: replace[1].toUpperCase(),
-      type: replace[2].toLowerCase() as LongTermType,
-      text,
-    };
-  }
-
-  return null;
-}
-
-function parseCandidateLine(line: string): { type: LongTermType; body: string } | null {
-  const bracketed = line.trim().match(/^\s*-?\s*\[(feedback|project|decision|reference)\]\s+(.+)$/i);
-  if (bracketed) {
-    return { type: bracketed[1].toLowerCase() as LongTermType, body: bracketed[2] };
-  }
-
-  const bracketless = line.trim().match(/^-\s*(feedback|project|decision|reference)\b\s+(.+)$/i);
-  if (bracketless) {
-    return { type: bracketless[1].toLowerCase() as LongTermType, body: bracketless[2] };
-  }
-
-  return null;
-}
-
 /**
 * Extract candidate block from summary using multiple formats.
 * Supports: Plain text label, Markdown section, legacy XML.
@@ -506,39 +431,21 @@ export function parseWorkspaceMemoryCandidatesWithEvidence(
  options: WorkspaceMemoryCandidateParseOptions = {},
 ): WorkspaceMemoryParseResult {
  const block = extractCandidateBlock(summary);
-  if (!block) return { entries: [], commands: [], evidence: [] };
+  if (!block) return { entries: [], evidence: [] };

  const nowMs = Date.now();
  const now = new Date(nowMs).toISOString();
  const entries: LongTermMemoryEntry[] = [];
-  const commands: WorkspaceMemoryCommand[] = [];
  const evidence: EvidenceEventInput[] = [];

  for (const line of block.split("\n")) {
-    if (!line.trim() || /^\s*\(?none\)?\s*$/i.test(line)) continue;
-
-    const command = parseWorkspaceMemoryCommand(line);
-    if (command) {
-      commands.push(command);
-      continue;
-    }
-
    // Accept both "- [type] text" (bracketed) and "- type text" (bracketless)
-    const item = parseCandidateLine(line);
-    if (!item) {
-      if (isCommandAttempt(line)) {
-        evidence.push(extractionEvidence({
-          type: "extraction_candidate_rejected",
-          phase: "extraction",
-          outcome: "rejected",
-          reasonCodes: [commandAttemptReason(line)],
-          textPreview: evidenceTextPreview(line, 80),
-        }));
-      }
-      continue;
-    }
-    const type = item.type;
-    const normalizedBody = normalizeCandidateBody(item.body);
+    const item = line.trim().match(
+      /^-\s*(?:\[(feedback|project|decision|reference)\]|(feedback|project|decision|reference)\b)\s+(.+)$/i,
+    );
+    if (!item) continue;
+    const type = (item[1] ?? item[2]).toLowerCase() as LongTermType;
+    const normalizedBody = normalizeCandidateBody(item[3]);
    if (!normalizedBody) {
      evidence.push(extractionEvidence({
        type: "extraction_candidate_rejected",
@@ -546,7 +453,7 @@ export function parseWorkspaceMemoryCandidatesWithEvidence(
        outcome: "rejected",
        reasonCodes: ["negated_request"],
        memory: { type, source: "compaction" },
-        textPreview: evidenceTextPreview(item.body, 80),
+        textPreview: evidenceTextPreview(item[3], 80),
      }));
      continue;
    }
@@ -608,5 +515,5 @@ export function parseWorkspaceMemoryCandidatesWithEvidence(
    }));
  }

-  return { entries, commands, evidence };
+  return { entries, evidence };
 }
@@ -7,7 +7,6 @@ export type MemoryQualityInput = Pick<LongTermMemoryEntry, "type" | "text"> & {
 export type MemoryQualityResult = {
  accepted: boolean;
  reasons: string[];
-  diagnostics?: string[];
 };

 export const HARD_QUALITY_REASONS: ReadonlySet<string> = new Set([
@@ -19,9 +18,6 @@ export const HARD_QUALITY_REASONS: ReadonlySet<string> = new Set([
  "active_file_snapshot",
  "code_or_api_signature",
  "path_heavy",
-  "unresolved_question",
-  "transient_bug_state",
-  "deployment_snapshot",
 ]);

 export function isHardQualityReason(reason: string): boolean {
@@ -40,18 +36,10 @@ export function assessMemoryQuality(entry: MemoryQualityInput): MemoryQualityRes
  if (isTemporaryStatusViolation(text)) reasons.push("temporary_status");
  if (isActiveFileSnapshotViolation(text)) reasons.push("active_file_snapshot");
  if (isCodeOrApiSignatureViolation(text)) reasons.push("code_or_api_signature");
-  if (isUnresolvedQuestionViolation(text)) reasons.push("unresolved_question");
-  if (isTransientBugStateViolation(text)) reasons.push("transient_bug_state");
-  if (isDeploymentSnapshotViolation(text)) reasons.push("deployment_snapshot");
  if (entry.type === "feedback" && isFeedbackQualityViolation(text)) reasons.push("bad_feedback");
  if (entry.type === "decision" && isDecisionQualityViolation(text)) reasons.push("bad_decision");

-  const diagnostics = isTerseLabelDiagnostic(text) ? ["terse_label"] : [];
-  return {
-    accepted: reasons.length === 0,
-    reasons,
-    ...(diagnostics.length > 0 ? { diagnostics } : {}),
-  };
+  return { accepted: reasons.length === 0, reasons };
 }

 export function isProgressSnapshotViolation(text: string): boolean {
@@ -95,34 +83,6 @@ export function hasFutureRule(text: string): boolean {
    || /(?:使用|保持|避免|不要|必須|必须|應該|应该|選擇|选择)/u.test(text);
 }

-function textWithoutUrls(text: string): string {
-  return text.replace(/https?:\/\/[^\s`"'<>]+/gi, "");
-}
-
-function hasDurableRuleMarker(text: string): boolean {
-  return /\b(?:must|always|never|use|do\s+not|don't)\b/i.test(text)
-    || /\bshould\b(?!\s+we\b)/i.test(text)
-    || /(?:必須|必须|應該|应该|不要|使用|保持)/u.test(text);
-}
-
-function isUnresolvedQuestionViolation(text: string): boolean {
-  if (hasDurableRuleMarker(text)) return false;
-
-  const withoutUrls = textWithoutUrls(text).trim();
-  const startsUnresolved = /^(?:question:|open question\b|unresolved\b|pending question\b|todo:\s*decide\b|TBD\b|TODO\b|待確認|未決|待決定)/iu.test(withoutUrls);
-  if (startsUnresolved) return true;
-
-  if (/\b(?:need to decide|needs decision|not decided|whether to|should we|do we need)\b/i.test(withoutUrls)) return true;
-  if (/(?:尚未決定|需要決定|是否要|要不要)/u.test(withoutUrls)) return true;
-
-  if (/[?？]\s*$/.test(withoutUrls)) return true;
-
-  const hasQuestion = /[?？]/.test(withoutUrls);
-  const hasPlanningPhrase = /\b(?:we need|need to|next|later|follow up)\b/i.test(withoutUrls)
-    || /(?:確認|决定|決定)/u.test(withoutUrls);
-  return hasQuestion && hasPlanningPhrase;
-}
-
 export function isArchitectureLikeDecision(text: string): boolean {
  if (/\b(?:[A-Z][A-Z0-9]*_[A-Z0-9_]*|[A-Z][A-Z0-9]{3,})\b/.test(text)) return true;
  if (/\b(?:schema|model|scoring|retention|cap|evidence|normalization|root cause|architecture(?!\s+keywords?)|boundary|rule|memory system)\b/i.test(text)) return true;
@@ -177,34 +137,6 @@ function isTemporaryStatusViolation(text: string): boolean {
  return false;
 }

-function isTransientBugStateViolation(text: string): boolean {
-  return /\b(?:currently debugging|still failing|unresolved bug|temporary workaround|next step is to fix|tests are failing)\b/i.test(text)
-    || /(?:待修|暫時|暂时|目前正在)/u.test(text);
-}
-
-function isDeploymentSnapshotViolation(text: string): boolean {
-  const hasDeploymentContext = /\b(?:deployed|current|latest|active|revision|build|release)\b/i.test(text)
-    || /(?:部署|版本|修訂|修订)/u.test(text);
-  if (!hasDeploymentContext) return false;
-
-  const highEntropyId = /\b(?:rev|build|release|revision)[-_]?[A-Za-z0-9]{10,}\b/i.test(text)
-    || /\b[A-Za-z0-9]*[A-Z][A-Za-z0-9]*\d[A-Za-z0-9]*[A-Za-z0-9_-]{8,}\b/.test(text)
-    || /\b[A-Za-z0-9]*\d[A-Za-z0-9]*[A-Z][A-Za-z0-9]*[A-Za-z0-9_-]{8,}\b/.test(text);
-  return highEntropyId;
-}
-
-function isTerseLabelDiagnostic(text: string): boolean {
-  if (/[:：]/u.test(text)) return false;
-
-  const codePoints = [...text].length;
-  const tokens = text.split(/\s+/u).filter(Boolean);
-  if (codePoints >= 18 && tokens.length >= 4) return false;
-
-  const hasMarker = /\b(?:is|are|was|were|has|have|uses?|keeps?|requires?|prefers?|wants?|supports?|must|should|always|never|do\s+not|don't|because|for|with|when|after|before)\b/i.test(text)
-    || /(?:使用|保持|避免|不要|必須|必须|應該|应该|偏好|要求|支援|支持|因為|因为)/u.test(text);
-  return !hasMarker;
-}
-
 function isActiveFileSnapshotViolation(text: string): boolean {
  return /^(modified|created|deleted|renamed)\s+\S+\.\S+$/i.test(text);
 }
@@ -19,11 +19,11 @@
 * - Processes explicit memory from latest user text once per message id
 * - Injects frozen workspace memory and dynamic hot session state into system prompt
 * - Updates session state after tool execution
- * - Augments compaction context with numbered memory refs, todos, and instruction
+ * - Augments compaction context with memory, hot state, todos, and instruction
 * - Parses compaction summaries for memory candidates and merges them
 */

-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 import { realpath, rm } from "fs/promises";
 import type { Plugin } from "@opencode-ai/plugin";
 import {
@@ -31,17 +31,12 @@ import {
  extractActiveFiles,
  extractErrorsFromBash,
  parseWorkspaceMemoryCandidatesWithEvidence,
-  staleAfterDaysFor,
-  type WorkspaceMemoryCommand,
 } from "./extractors.ts";
-import { assessMemoryQuality } from "./memory-quality.ts";
 import {
  loadWorkspaceMemory,
  updateWorkspaceMemory,
  updateWorkspaceMemoryWithAccounting,
  accountWorkspaceMemoryRender,
-  accountWorkspaceMemoryCompactionRefs,
-  workspaceMemoryExactKey,
  workspaceMemoryIdentityKey,
 } from "./workspace-memory.ts";
 import { reinforceMemory } from "./retention.ts";
@@ -71,7 +66,7 @@ import {
 } from "./opencode.ts";
 import { accountPendingPromotions, promotionAccountingEvidenceEvents } from "./promotion-accounting.ts";
 import { appendEvidenceEvent, appendEvidenceEvents, type EvidenceEventInput, type MemoryEvidenceRef } from "./evidence-log.ts";
-import { type CompactionMemoryRef, type LongTermMemoryEntry, LONG_TERM_LIMITS, WORKSPACE_MEMORY_CACHE_LIMITS } from "./types.ts";
+import { type LongTermMemoryEntry, WORKSPACE_MEMORY_CACHE_LIMITS } from "./types.ts";

 /**
 * Build the complete compaction prompt.
@@ -81,14 +76,11 @@ import { type CompactionMemoryRef, type LongTermMemoryEntry, LONG_TERM_LIMITS, W
 * Our template uses only ## Markdown headings and explicitly forbids YAML frontmatter,
 * horizontal rules, and delimiter lines.
 *
- * @param privateContext - Background context (numbered workspace memory refs,
+ * @param privateContext - Background context (workspace memory, hot session state,
 *   pending todos) from our plugin and any other plugins. Shown to the model to
 *   inform the summary but not copied verbatim.
 */
-function buildCompactionPrompt(privateContext: string, compactionId?: string): string {
-  const snapshotInstruction = compactionId
-    ? `- If you emit any REINFORCE or REPLACE command, include \`Memory ref snapshot id: ${compactionId}\` as the first line under \"Memory candidates:\" so numbered refs match the correct compaction snapshot.`
-    : "";
+function buildCompactionPrompt(privateContext: string): string {
  return [
    "Provide a detailed summary for continuing our conversation above.",
    "Focus on information that would help another agent continue the work: the goal, user instructions, completed work, current state, decisions, relevant files, and next steps.",
@@ -103,7 +95,6 @@ function buildCompactionPrompt(privateContext: string, compactionId?: string): s
    "- Do not output horizontal rules.",
    "- Do not wrap the summary in delimiter lines such as ---.",
    "- Do not use code fences around the summary.",
-    ...(snapshotInstruction ? [snapshotInstruction] : []),
    "",
    "Use this structure:",
    "",
@@ -125,19 +116,16 @@ function buildCompactionPrompt(privateContext: string, compactionId?: string): s
    "",
    "CRITICAL MEMORY RULES:",
    "- Most compactions should produce ZERO memories. Empty is correct when nothing durable changed.",
-    "- Existing memories are numbered [M#]. If an existing memory is still accurate, emit at most 3 lines like `REINFORCE [M#]`; do not rephrase it.",
-    "- Use `REPLACE [M#] [type] text` only for eligible unreinforced compaction-sourced memories where the old text itself needs correction; this is rarely the right choice.",
-    "- To supplement or correct a memory, REINFORCE the existing [M#] if it is still accurate, and also emit a new complete [type] candidate with the addition or correction. Do not use REPLACE for additions; do not reinforce a memory that is now inaccurate.",
    "- NO completion or progress statements: do not extract completed work, passing tests, commits, PR status, wave/task/phase completion, or current state.",
    "- NO session-internal implementation notes: do not extract what files were edited, what bug was just fixed, what command just ran, or what the assistant reviewed.",
-    "- decision = future rule/architecture choice; reference = stable lookup fact; project = stable project fact; feedback = stable user preference.",
-    "- Do not use decision for service names, IDs, URLs, file paths, or one-off session status; use reference/project or skip.",
+    "- feedback ONLY means stable user preferences or user instructions, written in imperative/future-facing form.",
+    "- decision ONLY means rules that apply to FUTURE work, not decisions already implemented in this session.",
+    "- project/reference ONLY when the fact is stable across sessions and hard to rediscover from the repository.",
    "- If unsure, skip it.",
    "",
    "Good memory examples:",
-    "- REINFORCE [M1]",
    "- [feedback] User prefers architecture reviews in Traditional Chinese.",
-    "- [decision] Keep memory dedupe exact-only for decisions.",
+    "- [decision] Do not add semantic merge to memory dedupe.",
    "- [project] This repository is an OpenCode plugin using local JSON stores.",
    "- [reference] Workspace memory is rendered as frozen system[1]; pending memories remain in hot state until compaction.",
    "",
@@ -148,13 +136,11 @@ function buildCompactionPrompt(privateContext: string, compactionId?: string): s
    "- The assistant reviewed code reviewer feedback and updated the plan.",
    "- Commit a762e86 contains the owner scope fix.",
    "",
-    "Format when there ARE REINFORCE/REPLACE commands or durable new candidates:",
+    "Format when there ARE durable memories:",
    "Memory candidates:",
-    "REINFORCE [M#]",
-    "REPLACE [M#] [feedback|decision|project|reference] corrected durable fact",
-    "- [feedback|decision|project|reference] new future-facing durable fact",
+    "- [feedback|decision|project|reference] future-facing durable fact",
    "",
-    "Format when there are NO REINFORCE/REPLACE commands or durable candidates:",
+    "Format when there are NO durable memories:",
    "Memory candidates:",
    "(none)",
    "",
@@ -184,20 +170,6 @@ function safeErrorMessage(error: unknown): string {
  return message.replace(/\s+/g, " ").slice(0, 240);
 }

-type CompactionRefResolution =
-  | {
-      ok: true;
-      refSnapshot: CompactionMemoryRef;
-      target: LongTermMemoryEntry;
-      targetIndex: number;
-    }
-  | {
-      ok: false;
-      reason: "missing_memory_ref_snapshot" | "invalid_memory_ref" | "memory_ref_target_unavailable" | "memory_ref_target_changed";
-      refSnapshot?: CompactionMemoryRef;
-      target?: LongTermMemoryEntry;
-    };
-
 async function warnMemoryHook(scope: string, error: unknown, root?: string): Promise<void> {
  const message = safeErrorMessage(error);
  console.error(`[memory] ${scope} failed: ${message}`);
@@ -225,10 +197,6 @@ async function workspaceIdentity(root: string): Promise<{ workspaceKey: string;
  return { workspaceKey: workspaceKeyValue, workspaceRootHash: workspaceRootHashValue };
 }

-function compactionIdFromSummary(summary: string): string | undefined {
-  return summary.match(/Memory ref snapshot id:\s*([a-zA-Z0-9_-]+)/i)?.[1];
-}
-
 export const MemoryV2Plugin: Plugin = async (input) => {
  const { directory, client } = input;

@@ -288,227 +256,6 @@ export const MemoryV2Plugin: Plugin = async (input) => {
    };
  }

-  function memoryReinforcedEvidence(
-    memory: LongTermMemoryEntry | undefined,
-    ref: string,
-    outcome: "reinforced" | "rejected",
-    reasonCodes: string[],
-    details: EvidenceEventInput["details"] = {},
-  ): EvidenceEventInput {
-    const relationRole = outcome === "rejected" ? "target" : "reinforced";
-    return {
-      type: "memory_reinforced",
-      phase: "reinforcement",
-      outcome,
-      memory: memory ? memoryEvidenceRef(memory) : undefined,
-      relations: memory ? [{ role: relationRole, memory: memoryEvidenceRef(memory) }] : undefined,
-      reasonCodes,
-      details: {
-        ref,
-        ...details,
-      },
-      textPreview: memory?.text,
-    };
-  }
-
-  function replacementMemoryId(): string {
-    return `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  }
-
-  function memoryReplacedEvidence(
-    oldMemory: LongTermMemoryEntry | undefined,
-    newMemory: LongTermMemoryEntry | undefined,
-    ref: string,
-    outcome: "superseded" | "rejected",
-    reasonCodes: string[],
-    details: EvidenceEventInput["details"] = {},
-  ): EvidenceEventInput {
-    const relations = outcome === "rejected"
-      ? [
-        ...(oldMemory ? [{ role: "target" as const, memory: memoryEvidenceRef(oldMemory) }] : []),
-      ]
-      : [
-        ...(oldMemory ? [{ role: "superseded" as const, memory: memoryEvidenceRef(oldMemory) }] : []),
-        ...(newMemory ? [{ role: "superseded_by" as const, memory: memoryEvidenceRef(newMemory) }] : []),
-      ];
-    return {
-      type: "memory_replaced_numbered_ref",
-      phase: "storage",
-      outcome,
-      memory: oldMemory ? memoryEvidenceRef(oldMemory) : undefined,
-      relations: relations.length > 0 ? relations : undefined,
-      reasonCodes,
-      details: {
-        ref,
-        ...details,
-      },
-      textPreview: newMemory?.text ?? oldMemory?.text,
-    };
-  }
-
-  function compactionRefByLabel(refs: CompactionMemoryRef[]): Map<string, CompactionMemoryRef> {
-    return new Map(refs.map(ref => [ref.ref.toUpperCase(), ref]));
-  }
-
-  function compactionSnapshotStatus(
-    refs: CompactionMemoryRef[],
-    expectedCompactionId: string | undefined,
-  ): { ok: true } | { ok: false; storedCompactionId: string } {
-    if (refs.length === 0) return { ok: false, storedCompactionId: "none" };
-
-    const ids = new Set(refs.map(ref => ref.compactionId).filter((id): id is string => typeof id === "string" && id.length > 0));
-    if (!expectedCompactionId) return { ok: true };
-    if (ids.size === 1 && ids.has(expectedCompactionId)) return { ok: true };
-    if (ids.size === 0) return { ok: false, storedCompactionId: "none" };
-    if (ids.size === 1) return { ok: false, storedCompactionId: [...ids][0] };
-    return { ok: false, storedCompactionId: "mixed" };
-  }
-
-  function resolveCompactionMemoryRef(
-    refs: CompactionMemoryRef[],
-    refsByLabel: Map<string, CompactionMemoryRef>,
-    entries: LongTermMemoryEntry[],
-    ref: string,
-  ): CompactionRefResolution {
-    if (refs.length === 0) {
-      return { ok: false, reason: "missing_memory_ref_snapshot" };
-    }
-
-    const refSnapshot = refsByLabel.get(ref.toUpperCase());
-    if (!refSnapshot) {
-      return { ok: false, reason: "invalid_memory_ref" };
-    }
-
-    const targetIndex = entries.findIndex(entry => entry.id === refSnapshot.memoryId);
-    const target = targetIndex >= 0 ? entries[targetIndex] : undefined;
-    if (!target || target.status !== "active") {
-      return { ok: false, reason: "memory_ref_target_unavailable", refSnapshot, target };
-    }
-
-    if (workspaceMemoryExactKey(target) !== refSnapshot.exactKey) {
-      return { ok: false, reason: "memory_ref_target_changed", refSnapshot, target };
-    }
-
-    return { ok: true, refSnapshot, target, targetIndex };
-  }
-
-  async function applyCompactionMemoryCommands(
-    sessionID: string,
-    commands: WorkspaceMemoryCommand[],
-    compactionId: string | undefined,
-  ): Promise<void> {
-    if (commands.length === 0) return;
-
-    const sessionState = await loadSessionState(directory, sessionID);
-    const snapshotStatus = compactionSnapshotStatus(sessionState.compactionMemoryRefs, compactionId);
-    const refs = snapshotStatus.ok ? sessionState.compactionMemoryRefs : [];
-    const refsByLabel = compactionRefByLabel(refs);
-    const evidence: EvidenceEventInput[] = [];
-    const now = Date.now();
-    let snapshotMismatchDetails: EvidenceEventInput["details"] = {};
-    if ("storedCompactionId" in snapshotStatus) {
-      snapshotMismatchDetails = {
-        ...(compactionId ? { compactionId } : {}),
-        storedCompactionId: snapshotStatus.storedCompactionId,
-      };
-    }
-
-    const updateResult = await updateWorkspaceMemoryWithAccounting(directory, workspaceMemory => {
-      for (const command of commands) {
-        const resolution = resolveCompactionMemoryRef(refs, refsByLabel, workspaceMemory.entries, command.ref);
-        if (resolution.ok === false) {
-          const memoryId = resolution.refSnapshot?.memoryId;
-          const details = memoryId ? { ...snapshotMismatchDetails, memoryId } : snapshotMismatchDetails;
-          if (command.kind === "REINFORCE") {
-            evidence.push(memoryReinforcedEvidence(resolution.target, command.ref, "rejected", [resolution.reason], details));
-          } else {
-            evidence.push(memoryReplacedEvidence(resolution.target, undefined, command.ref, "rejected", [resolution.reason], details));
-          }
-          continue;
-        }
-
-        const { refSnapshot, target, targetIndex } = resolution;
-        if (command.kind === "REINFORCE") {
-          const reinforced = reinforceMemory(target, sessionID, now);
-          if (reinforced === target) {
-            evidence.push(memoryReinforcedEvidence(target, command.ref, "rejected", ["numbered_ref_reinforce", "reinforcement_window_blocked"], {
-              memoryId: refSnapshot.memoryId,
-            }));
-            continue;
-          }
-
-          workspaceMemory.entries[targetIndex] = reinforced;
-          evidence.push(memoryReinforcedEvidence(reinforced, command.ref, "reinforced", ["numbered_ref_reinforce", "reinforcement_window_allowed"], {
-            memoryId: refSnapshot.memoryId,
-          }));
-          continue;
-        }
-
-        if (target.source !== "compaction") {
-          evidence.push(memoryReplacedEvidence(target, undefined, command.ref, "rejected", ["protected_memory_source"], {
-            memoryId: refSnapshot.memoryId,
-            source: target.source,
-          }));
-          continue;
-        }
-
-        if ((target.reinforcementCount ?? 0) > 0) {
-          evidence.push(memoryReplacedEvidence(target, undefined, command.ref, "rejected", ["protected_reinforced_target"], {
-            memoryId: refSnapshot.memoryId,
-            reinforcementCount: target.reinforcementCount ?? 0,
-          }));
-          continue;
-        }
-
-        const quality = assessMemoryQuality({ type: command.type, text: command.text, source: "compaction" });
-        if (!quality.accepted) {
-          evidence.push(memoryReplacedEvidence(target, undefined, command.ref, "rejected", quality.reasons, {
-            memoryId: refSnapshot.memoryId,
-          }));
-          continue;
-        }
-
-        const supersededTarget: LongTermMemoryEntry = {
-          ...target,
-          status: "superseded",
-          updatedAt: new Date(now).toISOString(),
-        };
-        const replacement: LongTermMemoryEntry = {
-          id: replacementMemoryId(),
-          type: command.type,
-          text: command.text.slice(0, LONG_TERM_LIMITS.maxEntryTextChars),
-          source: "compaction",
-          confidence: 0.75,
-          status: "active",
-          createdAt: new Date(now).toISOString(),
-          updatedAt: new Date(now).toISOString(),
-          retentionClock: now,
-          staleAfterDays: staleAfterDaysFor(command.type),
-          supersedes: [target.id],
-        };
-
-        workspaceMemory.entries[targetIndex] = supersededTarget;
-        workspaceMemory.entries.push(replacement);
-        evidence.push(memoryReplacedEvidence(supersededTarget, replacement, command.ref, "superseded", [
-          "numbered_ref_replace",
-          command.type === target.type ? "same_type_replace" : "cross_type_replace",
-        ], {
-          oldMemoryId: target.id,
-          newMemoryId: replacement.id,
-          oldType: target.type,
-          newType: command.type,
-        }));
-      }
-
-      return workspaceMemory;
-    });
-
-    await appendEvidenceEvents(directory, [...updateResult.evidence, ...evidence].map(event => ({
-      ...event,
-      sessionHash: sessionID,
-    })));
-  }
-
  function pruneFrozenWorkspaceMemoryCache(now = Date.now()): void {
    for (const [sessionID, cached] of frozenWorkspaceMemoryCache) {
      if (now - cached.loadedAt > WORKSPACE_MEMORY_CACHE_LIMITS.frozenTtlMs) {
@@ -814,13 +561,6 @@ export const MemoryV2Plugin: Plugin = async (input) => {
    return props?.sessionID ?? props?.info?.id;
  }

-  async function clearCompactionMemoryRefs(sessionID: string): Promise<void> {
-    await updateSessionState(directory, sessionID, state => {
-      state.compactionMemoryRefs = [];
-      return state;
-    });
-  }
-
  return {
    // Inject workspace memory and hot session state into system prompt
    "experimental.chat.system.transform": async (hookInput, output) => {
@@ -949,27 +689,23 @@ export const MemoryV2Plugin: Plugin = async (input) => {
        // so we must explicitly carry forward any existing output.context.
        const otherContext = output.context.filter(Boolean).join("\n\n");

-        // Build our private context (numbered workspace memory refs, todos)
+        // Build our private context (workspace memory, hot state, todos)
        const contextParts: string[] = [];

-        // 1. Compaction-only numbered workspace memory snapshot
-        const compactionId = randomUUID();
-        const workspaceStore = await loadWorkspaceMemory(directory);
-        const compactionRefs = accountWorkspaceMemoryCompactionRefs(workspaceStore);
-        const refsWithCompactionId = compactionRefs.refs.map(ref => ({ ...ref, compactionId }));
-        await updateSessionState(directory, sessionID, state => {
-          state.compactionMemoryRefs = refsWithCompactionId;
-          return state;
-        });
-        await appendEvidenceEvents(directory, compactionRefs.evidence.map(event => ({
-          ...event,
-          sessionHash: sessionID,
-        })));
-        if (compactionRefs.prompt) {
-          contextParts.push(compactionRefs.prompt);
+      // 1. Frozen workspace memory snapshot
+        const workspaceSnapshot = await getFrozenWorkspaceMemorySnapshot(directory, sessionID);
+        if (workspaceSnapshot.renderedPrompt) {
+          contextParts.push(workspaceSnapshot.renderedPrompt);
        }

-        // 2. Pending todos from OpenCode
+        // 2. Hot session state
+        const sessionState = await loadSessionState(directory, sessionID);
+        const hotPrompt = renderHotSessionState(sessionState, directory);
+        if (hotPrompt) {
+          contextParts.push(hotPrompt);
+        }
+
+        // 3. Pending todos from OpenCode
        const todos = await pendingTodos(client, sessionID);
        const todosPrompt = renderTodosForCompaction(todos);
        if (todosPrompt) {
@@ -982,7 +718,7 @@ export const MemoryV2Plugin: Plugin = async (input) => {
          .join("\n\n");

        // Replace the default prompt entirely with our ---free template
-        output.prompt = buildCompactionPrompt(privateContext, compactionId);
+        output.prompt = buildCompactionPrompt(privateContext);

        // Clear context array since we consumed it into output.prompt.
        // Subsequent plugins that set output.prompt will also need to check
@@ -996,40 +732,33 @@ export const MemoryV2Plugin: Plugin = async (input) => {
    // Handle session events
    event: async ({ event }) => {
      if (event.type === "session.compacted") {
-        let sessionID: string | undefined;
        try {
-          sessionID = sessionIDFromEventProperties(event.properties);
+          const sessionID = sessionIDFromEventProperties(event.properties);
          if (!sessionID) return;

          // Sub-agents don't need post-compaction processing
          if (await isSubAgent(sessionID)) return;

-          try {
-            // Parse latest compaction summary for memory candidates, stage them into
-            // durable pending journal, then promote pending memories.
-            const summary = await latestCompactionSummary(client, sessionID);
-            const compactionId = summary ? compactionIdFromSummary(summary) : undefined;
-            const parseResult = summary
-              ? parseWorkspaceMemoryCandidatesWithEvidence(summary, await workspaceIdentity(directory))
-              : { entries: [], commands: [], evidence: [] };
-            await appendEvidenceEvents(directory, parseResult.evidence.map(event => ({
-              ...event,
+          // Parse latest compaction summary for memory candidates, stage them into
+          // durable pending journal, then promote pending memories.
+          const summary = await latestCompactionSummary(client, sessionID);
+          const parseResult = summary
+            ? parseWorkspaceMemoryCandidatesWithEvidence(summary, await workspaceIdentity(directory))
+            : { entries: [], evidence: [] };
+          await appendEvidenceEvents(directory, parseResult.evidence.map(event => ({
+            ...event,
+            sessionHash: sessionID,
+          })));
+          const candidates = parseResult.entries;
+          if (candidates.length > 0) {
+            await appendPendingMemories(directory, candidates);
+            await appendEvidenceEvents(directory, candidates.map(memory => ({
+              ...pendingAppendedEvidence(memory),
              sessionHash: sessionID,
            })));
-            await applyCompactionMemoryCommands(sessionID, parseResult.commands, compactionId);
-            const candidates = parseResult.entries;
-            if (candidates.length > 0) {
-              await appendPendingMemories(directory, candidates);
-              await appendEvidenceEvents(directory, candidates.map(memory => ({
-                ...pendingAppendedEvidence(memory),
-                sessionHash: sessionID,
-              })));
-            }
-
-            await promotePendingMemories(sessionID, { includeUnownedJournal: true });
-          } finally {
-            await clearCompactionMemoryRefs(sessionID);
          }
+
+          await promotePendingMemories(sessionID, { includeUnownedJournal: true });
        } catch (error) {
          // Keep pending memories in session/journal for retry on next event/session.
          await warnMemoryHook("event.session.compacted", error, directory);
@@ -30,7 +30,7 @@ export const USER_IMPORTANCE_FACTOR = {

 export const RETENTION_TYPE_MAX = {
  feedback: 10,
-  decision: 12,
+  decision: 10,
  project: 8,
  reference: 6,
 } as const;
@@ -1,14 +1,10 @@
 import { relative } from "path";
 import { sessionStatePath } from "./paths.ts";
 import { atomicWriteJSON, readJSON, updateJSON } from "./storage.ts";
-import type { ActiveFile, CompactionMemoryRef, LongTermMemoryEntry, OpenError, SessionDecision, SessionState } from "./types.ts";
-import { HOT_STATE_LIMITS, LONG_TERM_LIMITS } from "./types.ts";
+import type { ActiveFile, LongTermMemoryEntry, OpenError, SessionDecision, SessionState } from "./types.ts";
+import { HOT_STATE_LIMITS } from "./types.ts";
 import { memoryKey } from "./pending-journal.ts";

-type SessionStateInput = Omit<SessionState, "compactionMemoryRefs"> & {
-  compactionMemoryRefs?: unknown;
-};
-
 const ACTION_WEIGHT: Record<ActiveFile["action"], number> = {
  edit: 50,
  write: 45,
@@ -26,7 +22,6 @@ export function createEmptySessionState(sessionID: string): SessionState {
    openErrors: [],
    recentDecisions: [],
    pendingMemories: [],
-    compactionMemoryRefs: [],
  };
 }

@@ -38,11 +33,10 @@ export async function loadSessionState(root: string, sessionID: string): Promise
  loaded.openErrors = Array.isArray(loaded.openErrors) ? loaded.openErrors : [];
  loaded.recentDecisions = Array.isArray(loaded.recentDecisions) ? loaded.recentDecisions : [];
  loaded.pendingMemories = Array.isArray(loaded.pendingMemories) ? loaded.pendingMemories : [];
-  loaded.compactionMemoryRefs = normalizeCompactionMemoryRefs((loaded as SessionStateInput).compactionMemoryRefs);
  return loaded;
 }

-export async function saveSessionState(root: string, state: SessionState | SessionStateInput): Promise<void> {
+export async function saveSessionState(root: string, state: SessionState): Promise<void> {
  await atomicWriteJSON(await sessionStatePath(root, state.sessionID), normalizeSessionState(state));
 }

@@ -58,53 +52,18 @@ export async function updateSessionState(
    current.openErrors = Array.isArray(current.openErrors) ? current.openErrors : [];
    current.recentDecisions = Array.isArray(current.recentDecisions) ? current.recentDecisions : [];
    current.pendingMemories = Array.isArray(current.pendingMemories) ? current.pendingMemories : [];
-    current.compactionMemoryRefs = normalizeCompactionMemoryRefs((current as SessionStateInput).compactionMemoryRefs);
    return normalizeSessionState(await updater(current));
  });
 }

-function normalizeSessionState(state: SessionState | SessionStateInput): SessionState {
+function normalizeSessionState(state: SessionState): SessionState {
  state.updatedAt = new Date().toISOString();
  state.activeFiles = state.activeFiles.slice(0, HOT_STATE_LIMITS.maxActiveFilesStored);
  state.openErrors = state.openErrors.slice(0, HOT_STATE_LIMITS.maxOpenErrorsStored);
  state.recentDecisions = state.recentDecisions.slice(0, HOT_STATE_LIMITS.maxRecentDecisionsStored);
  state.pendingMemories = dedupePendingMemories(Array.isArray(state.pendingMemories) ? state.pendingMemories : [])
    .slice(-HOT_STATE_LIMITS.maxPendingMemoriesStored);
-  return {
-    ...state,
-    compactionMemoryRefs: normalizeCompactionMemoryRefs(state.compactionMemoryRefs),
-  };
-}
-
-function normalizeCompactionMemoryRefs(value: unknown): CompactionMemoryRef[] {
-  if (!Array.isArray(value)) return [];
-  if (value.some(item => !isCompactionMemoryRef(item))) return [];
-  return value.slice(0, LONG_TERM_LIMITS.maxEntries);
-}
-
-function isCompactionMemoryRef(value: unknown): value is CompactionMemoryRef {
-  if (!isRecord(value)) return false;
-  if (typeof value.ref !== "string" || !/^M[1-9]\d*$/.test(value.ref)) return false;
-  if (typeof value.memoryId !== "string" || value.memoryId.trim() === "") return false;
-  if (value.compactionId !== undefined && typeof value.compactionId !== "string") return false;
-  if (!isLongTermType(value.type)) return false;
-  if (!isLongTermSource(value.source)) return false;
-  if (typeof value.exactKey !== "string" || value.exactKey.trim() === "") return false;
-  if (typeof value.identityKey !== "string" || value.identityKey.trim() === "") return false;
-  if (typeof value.textPreview !== "string") return false;
-  return typeof value.capturedAt === "number" && Number.isFinite(value.capturedAt);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isLongTermType(value: unknown): value is CompactionMemoryRef["type"] {
-  return value === "feedback" || value === "project" || value === "decision" || value === "reference";
-}
-
-function isLongTermSource(value: unknown): value is CompactionMemoryRef["source"] {
-  return value === "explicit" || value === "compaction" || value === "manual";
+  return state;
 }

 function dedupePendingMemories(memories: LongTermMemoryEntry[]): LongTermMemoryEntry[] {
@@ -230,150 +189,49 @@ export function clearErrorsForSuccessfulCommand(state: SessionState, command: st
  state.updatedAt = new Date().toISOString();
 }

-export type HotStateSection = "active_files" | "open_errors" | "recent_decisions" | "pending_memories";
+export function renderHotSessionState(state: SessionState, workspaceRoot: string): string {
+  const activeFiles = rankActiveFiles(state.activeFiles).slice(0, HOT_STATE_LIMITS.maxActiveFilesRendered);
+  const openErrors = [...state.openErrors]
+    .sort((a, b) => b.lastSeen - a.lastSeen)
+    .slice(0, HOT_STATE_LIMITS.maxOpenErrorsRendered);
+  const decisions = state.recentDecisions.slice(-HOT_STATE_LIMITS.maxRecentDecisionsStored);
+  const pendingMemories = dedupePendingMemories(state.pendingMemories)
+    .slice(-HOT_STATE_LIMITS.maxPendingMemoriesRendered);

-export type HotStateOmissionReason = "section_cap" | "char_budget";
+  if (activeFiles.length === 0 && openErrors.length === 0 && decisions.length === 0 && pendingMemories.length === 0) return "";

-export type HotStateOmittedItem = {
-  section: HotStateSection;
-  reason: HotStateOmissionReason;
-  text: string;
-  memoryId?: string;
-};
+  const lines: string[] = ["Hot session state (current session):"];

-export type HotSessionStateRenderAccounting = {
-  prompt: string;
-  omitted: HotStateOmittedItem[];
-  maxRenderedChars: number;
-};
-
-type HotStateRenderItem = {
-  section: HotStateSection;
-  line: string;
-  memoryId?: string;
-};
-
-type HotStateRenderSection = {
-  heading: `${HotStateSection}:`;
-  items: HotStateRenderItem[];
-};
-
-const HOT_STATE_PREFIX = "Hot session state (current session):";
-
-export function accountHotSessionStateRender(state: SessionState, workspaceRoot: string): HotSessionStateRenderAccounting {
-  const maxRenderedChars = HOT_STATE_LIMITS.maxRenderedChars;
-  const omitted: HotStateOmittedItem[] = [];
-  const sections = buildHotStateRenderSections(state, workspaceRoot, omitted);
-
-  if (sections.every(section => section.items.length === 0)) {
-    return { prompt: "", omitted, maxRenderedChars };
-  }
-
-  const lines: string[] = [HOT_STATE_PREFIX];
-  let renderedEntryCount = 0;
-
-  for (const section of sections) {
-    let headingRendered = false;
-
-    for (const item of section.items) {
-      if (headingRendered) {
-        if (wouldFit(lines, item.line, maxRenderedChars)) {
-          lines.push(item.line);
-          renderedEntryCount += 1;
-        } else {
-          omitted.push(omitHotStateItem(item, "char_budget"));
-        }
-        continue;
-      }
-
-      if (wouldFit(lines, section.heading, maxRenderedChars)
-        && wouldFit([...lines, section.heading], item.line, maxRenderedChars)) {
-        lines.push(section.heading, item.line);
-        headingRendered = true;
-        renderedEntryCount += 1;
-      } else {
-        omitted.push(omitHotStateItem(item, "char_budget"));
-      }
+  if (activeFiles.length > 0) {
+    lines.push("active_files:");
+    for (const item of activeFiles) {
+      const viewPath = displayPath(workspaceRoot, item.path);
+      lines.push(`- ${viewPath} (${item.action}, ${item.count}x)`);
    }
  }

-  if (renderedEntryCount === 0) return { prompt: "", omitted, maxRenderedChars };
+  if (openErrors.length > 0) {
+    lines.push("open_errors:");
+    for (const err of openErrors) {
+      lines.push(`- [${err.category}] ${err.summary}`);
+    }
+  }

-  return { prompt: lines.join("\n"), omitted, maxRenderedChars };
-}
+  if (decisions.length > 0) {
+    lines.push("recent_decisions:");
+    for (const decision of decisions) {
+      lines.push(`- ${decision.text}`);
+    }
+  }

-export function renderHotSessionState(state: SessionState, workspaceRoot: string): string {
-  return accountHotSessionStateRender(state, workspaceRoot).prompt;
-}
+  if (pendingMemories.length > 0) {
+    lines.push("pending_memories:");
+    for (const memory of pendingMemories) {
+      lines.push(`- [${memory.type}] ${memory.text}`);
+    }
+  }

-function buildHotStateRenderSections(
-  state: SessionState,
-  workspaceRoot: string,
-  omitted: HotStateOmittedItem[],
-): HotStateRenderSection[] {
-  const activeFiles = rankActiveFiles(state.activeFiles).map(item => ({
-    section: "active_files" as const,
-    line: `- ${displayPath(workspaceRoot, item.path)} (${item.action}, ${item.count}x)`,
-  }));
-  const openErrors = [...state.openErrors]
-    .sort((a, b) => b.lastSeen - a.lastSeen)
-    .map(err => ({
-      section: "open_errors" as const,
-      line: `- [${err.category}] ${err.summary}`,
-    }));
-  const decisions = state.recentDecisions.map(item => ({
-    section: "recent_decisions" as const,
-    line: `- ${item.text}`,
-  }));
-  const pendingMemories = dedupePendingMemories(state.pendingMemories).map(item => ({
-    section: "pending_memories" as const,
-    line: `- [${item.type}] ${item.text}`,
-    memoryId: item.id,
-  }));
-
-  const renderedActiveFiles = capHotStateItems(activeFiles, HOT_STATE_LIMITS.maxActiveFilesRendered, "start", omitted);
-  const renderedOpenErrors = capHotStateItems(openErrors, HOT_STATE_LIMITS.maxOpenErrorsRendered, "start", omitted);
-  const renderedDecisions = capHotStateItems(decisions, HOT_STATE_LIMITS.maxRecentDecisionsStored, "end", omitted);
-  const renderedPendingMemories = capHotStateItems(
-    pendingMemories,
-    HOT_STATE_LIMITS.maxPendingMemoriesRendered,
-    "end",
-    omitted,
-  );
-
-  return [
-    { heading: "active_files:", items: renderedActiveFiles },
-    { heading: "open_errors:", items: renderedOpenErrors },
-    { heading: "recent_decisions:", items: renderedDecisions },
-    { heading: "pending_memories:", items: renderedPendingMemories },
-  ];
-}
-
-function capHotStateItems(
-  items: HotStateRenderItem[],
-  cap: number,
-  keep: "start" | "end",
-  omitted: HotStateOmittedItem[],
-): HotStateRenderItem[] {
-  if (items.length <= cap) return items;
-
-  const renderedItems = keep === "start" ? items.slice(0, cap) : items.slice(-cap);
-  const omittedItems = keep === "start" ? items.slice(cap) : items.slice(0, items.length - cap);
-  omitted.push(...omittedItems.map(item => omitHotStateItem(item, "section_cap")));
-  return renderedItems;
-}
-
-function omitHotStateItem(item: HotStateRenderItem, reason: HotStateOmissionReason): HotStateOmittedItem {
-  return {
-    section: item.section,
-    reason,
-    text: item.line,
-    ...(item.memoryId ? { memoryId: item.memoryId } : {}),
-  };
-}
-
-function wouldFit(lines: string[], nextLine: string, maxRenderedChars: number): boolean {
-  return [...lines, nextLine].join("\n").length <= maxRenderedChars;
+  return lines.join("\n").slice(0, HOT_STATE_LIMITS.maxRenderedChars);
 }

 function rankActiveFiles(activeFiles: ActiveFile[]): ActiveFile[] {
@@ -28,18 +28,6 @@ export type LongTermMemoryEntry = {
  safetyCritical?: boolean;
 };

-export type CompactionMemoryRef = {
-  ref: string;
-  compactionId?: string;
-  memoryId: string;
-  type: LongTermType;
-  source: LongTermSource;
-  exactKey: string;
-  identityKey: string;
-  textPreview: string;
-  capturedAt: number;
-};
-
 export type WorkspaceMemoryStore = {
  version: 1;
  workspace: {
@@ -104,7 +92,6 @@ export type SessionState = {
  openErrors: OpenError[];
  recentDecisions: SessionDecision[];
  pendingMemories: LongTermMemoryEntry[];
-  compactionMemoryRefs: CompactionMemoryRef[];
 };

 export const LONG_TERM_LIMITS = {
@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import type { CompactionMemoryRef, LongTermMemoryEntry, WorkspaceMemoryStore } from "./types.ts";
+import type { LongTermMemoryEntry, WorkspaceMemoryStore } from "./types.ts";
 import { LONG_TERM_LIMITS } from "./types.ts";
 import { migrationLogPath, workspaceKey, workspaceMemoryPath } from "./paths.ts";
 import { atomicWriteJSON, readJSON, updateJSON } from "./storage.ts";
@@ -12,7 +12,6 @@ import {
  reinforceMemory,
 } from "./retention.ts";
 import type { EvidenceEventInput, MemoryEvidenceRef } from "./evidence-log.ts";
-import { appendEvidenceEvents } from "./evidence-log.ts";

 // Minimum length for workspace_memory envelope: <workspace_memory>\n...\n</workspace_memory>
 const MIN_ENVELOPE_LENGTH = 80;
@@ -59,16 +58,6 @@ export type WorkspaceMemoryRenderAccounting = {
  prompt: string;
 };

-export type WorkspaceMemoryCompactionRefsAccounting = WorkspaceMemoryRenderAccounting & {
-  refs: CompactionMemoryRef[];
-};
-
-type WorkspaceMemoryRenderSelection = {
-  active: LongTermMemoryEntry[];
-  omitted: WorkspaceMemoryRenderAccounting["omitted"];
-  maxChars: number;
-};
-
 export type QualityCleanupMigrationLogEntry = {
  migrationId: string;
  timestamp: string;
@@ -84,17 +73,6 @@ export type QualityCleanupMigrationLogEntry = {
  afterStatus: "superseded";
 };

-export type P0CleanupMigrationResult = {
-  store: WorkspaceMemoryStore;
-  events: EvidenceEventInput[];
-};
-
-export type QualityCleanupMigrationResult = {
-  store: WorkspaceMemoryStore;
-  events: QualityCleanupMigrationLogEntry[];
-  evidence: EvidenceEventInput[];
-};
-
 export async function emptyWorkspaceMemory(root: string): Promise<WorkspaceMemoryStore> {
  const nowIso = new Date().toISOString();
  return {
@@ -136,14 +114,6 @@ export async function loadWorkspaceMemory(root: string): Promise<WorkspaceMemory
  // writes for ordering/capacity/timestamp-only normalization.
  if (hasSecurityOrMigrationChange(store, normalized.store)) {
    await atomicWriteJSON(path, normalized.store);
-
-    // loadWorkspaceMemory has a narrow migration side effect: when a first-load
-    // migration actually supersedes entries, append evidence for those storage
-    // changes. Migration IDs keep this idempotent on repeated loads.
-    const migrationEvidence = normalized.evidence.filter(event => event.type === "memory_migration_superseded");
-    if (migrationEvidence.length > 0) {
-      await appendEvidenceEvents(root, migrationEvidence);
-    }
  }

  return normalized.store;
@@ -189,15 +159,8 @@ export async function updateWorkspaceMemoryWithAccounting(
  const fallback = await emptyWorkspaceMemory(root);
  let finalResult: WorkspaceMemoryNormalizationResult | undefined;
  const store = await updateJSON(path, () => fallback, async current => {
-    const currentNormalization = await normalizeWorkspaceMemoryWithAccounting(root, current);
-    const currentMigrationEvidence = currentNormalization.evidence.filter(event => event.type === "memory_migration_superseded");
-    finalResult = await normalizeWorkspaceMemoryWithAccounting(root, await updater(currentNormalization.store));
-    if (currentMigrationEvidence.length > 0) {
-      finalResult = {
-        ...finalResult,
-        evidence: [...currentMigrationEvidence, ...finalResult.evidence],
-      };
-    }
+    const normalized = await normalizeWorkspaceMemory(root, current);
+    finalResult = await normalizeWorkspaceMemoryWithAccounting(root, await updater(normalized));
    return finalResult.store;
  });

@@ -261,12 +224,10 @@ export async function normalizeWorkspaceMemoryWithAccounting(
  const beforeQualityCleanup = result;
  const qualityCleanup = runMigrationQualityCleanup(result, nowIso);
  result = qualityCleanup.store;
-  let migrationEvidence: EvidenceEventInput[] = [];
  let skipRemainingMigrations = false;
  if (qualityCleanup.events.length > 0) {
    try {
      await appendQualityCleanupMigrationLog(qualityCleanup.events);
-      migrationEvidence = [...migrationEvidence, ...qualityCleanup.evidence];
    } catch (error) {
      console.error("[memory] failed to write quality cleanup migration log:", error);
      console.error("[memory] aborting migration to maintain audit trail integrity");
@@ -275,9 +236,7 @@ export async function normalizeWorkspaceMemoryWithAccounting(
    }
  }
  if (!skipRemainingMigrations) {
-    const p0Cleanup = runMigrationP0Cleanup(result, nowIso);
-    result = p0Cleanup.store;
-    migrationEvidence = [...migrationEvidence, ...p0Cleanup.events];
+    result = runMigrationP0Cleanup(result, nowIso);
  }

  result.entries = result.entries.map(entry => backfillRetentionClock(entry, nowMs));
@@ -310,7 +269,7 @@ export async function normalizeWorkspaceMemoryWithAccounting(
    dropped: accounting.dropped,
    absorbed: accounting.absorbed,
    superseded: accounting.superseded,
-    evidence: [...migrationEvidence, ...accounting.evidence],
+    evidence: accounting.evidence,
    events: [...accounting.dropped, ...accounting.absorbed, ...accounting.superseded],
  };
 }
@@ -336,38 +295,31 @@ function backfillRetentionClock(entry: LongTermMemoryEntry, nowMs: number): Long
 export function runMigrationP0Cleanup(
  store: WorkspaceMemoryStore,
  nowIso: string,
-): P0CleanupMigrationResult {
+): WorkspaceMemoryStore {
  if (store.migrations?.includes(MIGRATION_ID)) {
-    return { store, events: [] };
+    return store;
  }

-  const events: EvidenceEventInput[] = [];
  const entries = store.entries.map(entry => {
    if (entry.source !== "compaction") return entry;
    if (entry.type !== "project") return entry;
-    if (entry.status === "superseded") return entry;

    if (isProgressSnapshotViolation(entry.text)) {
-      const superseded = {
+      return {
        ...entry,
        status: "superseded" as const,
        updatedAt: nowIso,
      };
-      events.push(migrationSupersededEvidence(superseded, ["migration:p0_cleanup"], MIGRATION_ID));
-      return superseded;
    }

    return entry;
  });

  return {
-    store: {
-      ...store,
-      entries,
-      migrations: [...(store.migrations || []), MIGRATION_ID],
-      updatedAt: nowIso,
-    },
-    events,
+    ...store,
+    entries,
+    migrations: [...(store.migrations || []), MIGRATION_ID],
+    updatedAt: nowIso,
  };
 }

@@ -381,13 +333,12 @@ async function appendQualityCleanupMigrationLog(events: QualityCleanupMigrationL
 export function runMigrationQualityCleanup(
  store: WorkspaceMemoryStore,
  nowIso: string,
-): QualityCleanupMigrationResult {
+): { store: WorkspaceMemoryStore; events: QualityCleanupMigrationLogEntry[] } {
  if (store.migrations?.includes(QUALITY_CLEANUP_MIGRATION_ID)) {
-    return { store, events: [], evidence: [] };
+    return { store, events: [] };
  }

  const events: QualityCleanupMigrationLogEntry[] = [];
-  const evidence: EvidenceEventInput[] = [];
  let changed = false;
  const entries = store.entries.map(entry => {
    if (entry.source !== "compaction") return entry;
@@ -421,19 +372,12 @@ export function runMigrationQualityCleanup(
      ...hardReasons.map(reason => `quality:${reason}`),
    ]);

-    const superseded = {
+    return {
      ...entry,
      status: "superseded" as const,
      updatedAt: nowIso,
      tags: [...tags],
    };
-    evidence.push(migrationSupersededEvidence(
-      superseded,
-      ["migration:quality_cleanup", ...hardReasons.map(reason => `quality:${reason}`)],
-      QUALITY_CLEANUP_MIGRATION_ID,
-      { hardReasons },
-    ));
-    return superseded;
  });

  return {
@@ -444,7 +388,6 @@ export function runMigrationQualityCleanup(
      updatedAt: changed ? nowIso : store.updatedAt,
    },
    events,
-    evidence,
  };
 }

@@ -582,29 +525,6 @@ function capacityRemovalEvidence(
  };
 }

-function migrationSupersededEvidence(
-  memory: LongTermMemoryEntry,
-  reasonCodes: string[],
-  migrationId: string,
-  details: EvidenceEventInput["details"] = {},
-): EvidenceEventInput {
-  return {
-    type: "memory_migration_superseded",
-    phase: "storage",
-    outcome: "superseded",
-    memory: memoryEvidenceRef(memory),
-    relations: [{ role: "superseded", memory: memoryEvidenceRef(memory) }],
-    reasonCodes,
-    details: {
-      migrationId,
-      type: memory.type,
-      source: memory.source,
-      ...details,
-    },
-    textPreview: memory.text,
-  };
-}
-
 /** Choose better memory when identity/topic keys conflict */
 function chooseBetterMemory(
  a: LongTermMemoryEntry,
@@ -711,11 +631,6 @@ export function dedupeLongTermEntriesWithAccounting(entries: LongTermMemoryEntry
  const evidence: EvidenceEventInput[] = [];

  // For project/reference/feedback: dedupe by concrete identity or exact canonical text.
-  // Feedback is grouped with project/reference for entity dedupe, but
-  // workspaceMemoryIdentityKey() returns exact key for feedback (no concrete
-  // identity extraction). This means feedback absorbed_identity is currently
-  // impossible. When identity key extraction is extended to all types, feedback
-  // with matching concrete identifiers will correctly produce absorbed_identity.
  const projectRefEntries = entries.filter(e => e.type === "project" || e.type === "reference" || e.type === "feedback");

  // Build identity key dedup for project/reference/feedback.
@@ -759,7 +674,7 @@ export function dedupeLongTermEntriesWithAccounting(entries: LongTermMemoryEntry
      const dropped = retained === entry ? existing : entry;
      const reason = workspaceMemoryExactKey(entry) === workspaceMemoryExactKey(existing)
        ? "absorbed_exact" as const
-        : "superseded_existing" as const; // v1.5.4 placeholder: unreachable until numbered refs
+        : "superseded_existing" as const;
      const reinforced = reinforceMemory(
        retained,
        reinforcementSessionId(retained, dropped),
@@ -860,13 +775,14 @@ export function renderWorkspaceMemory(store: WorkspaceMemoryStore): string {
  return accountWorkspaceMemoryRender(store).prompt;
 }

-function selectWorkspaceMemoryForRender(store: WorkspaceMemoryStore): WorkspaceMemoryRenderSelection {
+export function accountWorkspaceMemoryRender(store: WorkspaceMemoryStore): WorkspaceMemoryRenderAccounting {
  const now = Date.now();
  const maxChars = Math.min(
    store.limits.maxRenderedChars,
    LONG_TERM_LIMITS.maxRenderedChars
  );
  const omitted: WorkspaceMemoryRenderAccounting["omitted"] = [];
+  const evidence: EvidenceEventInput[] = [];

  for (const entry of store.entries) {
    if (entry.status === "superseded") {
@@ -883,13 +799,6 @@ function selectWorkspaceMemoryForRender(store: WorkspaceMemoryStore): WorkspaceM
  const active = typeCapResult.kept.slice(0, LONG_TERM_LIMITS.maxEntries);
  for (const memory of typeCapResult.kept.slice(LONG_TERM_LIMITS.maxEntries)) omitted.push({ memory, reason: "global_cap" });

-  return { active, omitted, maxChars };
-}
-
-export function accountWorkspaceMemoryRender(store: WorkspaceMemoryStore): WorkspaceMemoryRenderAccounting {
-  const { active, omitted, maxChars } = selectWorkspaceMemoryForRender(store);
-  const evidence: EvidenceEventInput[] = [];
-
  if (active.length === 0) {
    for (const item of omitted) evidence.push(renderEvidence(item.memory, "omitted", item.reason));
    return { rendered: [], omitted, evidence, prompt: "" };
@@ -934,68 +843,6 @@ export function accountWorkspaceMemoryRender(store: WorkspaceMemoryStore): Works
  return { rendered, omitted, evidence, prompt: lines.join("\n") };
 }

-export function accountWorkspaceMemoryCompactionRefs(store: WorkspaceMemoryStore): WorkspaceMemoryCompactionRefsAccounting {
-  const { active, omitted, maxChars } = selectWorkspaceMemoryForRender(store);
-  const evidence: EvidenceEventInput[] = [];
-  const originalById = new Map(store.entries.map(entry => [entry.id, entry]));
-
-  if (active.length === 0) {
-    for (const item of omitted) evidence.push(renderEvidence(item.memory, "omitted", item.reason));
-    return { rendered: [], omitted, evidence, prompt: "", refs: [] };
-  }
-
-  const lines: string[] = [
-    "Existing workspace memories available for consolidation:",
-  ];
-  const rendered: LongTermMemoryEntry[] = [];
-  const refs: CompactionMemoryRef[] = [];
-  const capturedAt = Date.now();
-
-  for (const type of ["feedback", "project", "decision", "reference"] as const) {
-    const items = active.filter(entry => entry.type === type);
-    if (items.length === 0) continue;
-
-    const sectionLines: string[] = [`${type}:`];
-
-    for (const item of items) {
-      const ref = `M${refs.length + 1}`;
-      const line = `[${ref}] ${item.text}`;
-      if ([...lines, ...sectionLines, line].join("\n").length <= maxChars) {
-        const original = originalById.get(item.id) ?? item;
-        sectionLines.push(line);
-        rendered.push(item);
-        refs.push({
-          ref,
-          memoryId: item.id,
-          type: original.type,
-          source: original.source,
-          exactKey: workspaceMemoryExactKey(original),
-          identityKey: workspaceMemoryIdentityKey(original),
-          textPreview: item.text,
-          capturedAt,
-        });
-      } else {
-        omitted.push({ memory: item, reason: "char_budget" });
-      }
-    }
-
-    if (sectionLines.length > 1) {
-      lines.push(...sectionLines);
-    }
-  }
-
-  for (const memory of rendered) evidence.push(renderEvidence(memory, "rendered"));
-  for (const item of omitted) evidence.push(renderEvidence(item.memory, "omitted", item.reason));
-
-  return {
-    rendered,
-    omitted,
-    evidence,
-    prompt: rendered.length > 0 ? lines.join("\n") : "",
-    refs,
-  };
-}
-
 function renderEvidence(
  memory: LongTermMemoryEntry,
  outcome: "rendered" | "omitted",
@@ -174,74 +174,6 @@ test("memory_removed_capacity event round-trips through append and query", async
  }
 });

-test("memory_migration_superseded event round-trips through append and query", async () => {
-  const root = await tempRoot();
-  try {
-    await appendEvidenceEvent(root, eventInput({
-      type: "memory_migration_superseded",
-      phase: "storage",
-      outcome: "superseded",
-      reasonCodes: ["migration:quality_cleanup", "quality:progress_snapshot"],
-      memory: { memoryId: "migrated-memory", type: "project", source: "compaction", status: "superseded" },
-      relations: [{ role: "superseded", memory: { memoryId: "migrated-memory", type: "project", source: "compaction", status: "superseded" } }],
-      details: {
-        migrationId: "2026-04-28-quality-cleanup",
-        type: "project",
-        source: "compaction",
-      },
-    }));
-
-    const result = await queryEvidenceEvents(root, {
-      types: ["memory_migration_superseded"],
-      phases: ["storage"],
-      outcomes: ["superseded"],
-      memoryId: "migrated-memory",
-    });
-
-    assert.equal(result.length, 1);
-    assert.equal(result[0].type, "memory_migration_superseded");
-    assert.equal(result[0].phase, "storage");
-    assert.equal(result[0].outcome, "superseded");
-    assert.ok(result[0].reasonCodes.includes("migration:quality_cleanup"));
-    assert.equal(result[0].memory?.status, "superseded");
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory_reverted_numbered_ref event round-trips through append and query", async () => {
-  const root = await tempRoot();
-  try {
-    await appendEvidenceEvent(root, eventInput({
-      type: "memory_reverted_numbered_ref",
-      phase: "storage",
-      outcome: "recovered",
-      reasonCodes: ["manual_revert_numbered_ref"],
-      memory: { memoryId: "replacement-memory", type: "decision", source: "compaction", status: "superseded" },
-      relations: [
-        { role: "superseded", memory: { memoryId: "replacement-memory", type: "decision", source: "compaction", status: "superseded" } },
-        { role: "recovered", memory: { memoryId: "restored-memory", type: "decision", source: "compaction", status: "active" } },
-      ],
-    }));
-
-    const result = await queryEvidenceEvents(root, {
-      types: ["memory_reverted_numbered_ref"],
-      phases: ["storage"],
-      outcomes: ["recovered"],
-      memoryId: "restored-memory",
-    });
-
-    assert.equal(result.length, 1);
-    assert.equal(result[0].type, "memory_reverted_numbered_ref");
-    assert.equal(result[0].phase, "storage");
-    assert.equal(result[0].outcome, "recovered");
-    assert.ok(result[0].reasonCodes.includes("manual_revert_numbered_ref"));
-    assert.ok(result[0].relations?.some(relation => relation.role === "recovered" && relation.memory?.memoryId === "restored-memory"));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
 test("queryEvidenceEvents supports newestFirst and limit", async () => {
  const root = await tempRoot();
  try {
@@ -212,65 +212,6 @@ Memory candidates:
  assert.match(result.evidence[0].textPreview ?? "", /accounting evidence events/);
 });

-test("parseWorkspaceMemoryCandidatesWithEvidence returns mixed valid commands and entries", () => {
-  const summary = `
-Memory candidates:
-REINFORCE [M3]
-REPLACE [M4] [decision] Use numbered refs for safe memory consolidation.
- [feedback] User prefers concise implementation handoffs.
-`;
-
-  const result = parseWorkspaceMemoryCandidatesWithEvidence(summary);
-
-  assert.deepEqual(result.commands, [
-    { kind: "REINFORCE", ref: "M3" },
-    { kind: "REPLACE", ref: "M4", type: "decision", text: "Use numbered refs for safe memory consolidation." },
-  ]);
-  assert.equal(result.entries.length, 1);
-  assert.equal(result.entries[0].type, "feedback");
-  assert.equal(result.entries[0].text, "User prefers concise implementation handoffs.");
-});
-
-test("parseWorkspaceMemoryCandidatesWithEvidence rejects malformed command attempts", () => {
-  const summary = `
-Memory candidates:
-REINFORCE M3
-REINFORCE [X3]
-REPLACE [M3] text without type
-REPLACE [M3] [invalid] text
-REPLACE [M3] [decision]
-`;
-
-  const result = parseWorkspaceMemoryCandidatesWithEvidence(summary);
-  const rejections = result.evidence.filter(event => event.type === "extraction_candidate_rejected");
-
-  assert.equal(result.entries.length, 0);
-  assert.deepEqual(result.commands, []);
-  assert.equal(rejections.length, 5);
-  assert.ok(rejections.every(event => event.phase === "extraction"));
-  assert.ok(rejections.every(event => event.outcome === "rejected"));
-  assert.deepEqual(rejections.map(event => event.reasonCodes[0]), [
-    "invalid_memory_ref",
-    "invalid_memory_ref",
-    "invalid_memory_type",
-    "invalid_memory_type",
-    "empty_replacement_text",
-  ]);
-});
-
-test("parseWorkspaceMemoryCandidates accepts bracketed candidates without bullets", () => {
-  const summary = `
-Memory candidates:
-[project] This repository uses local JSON stores for workspace memory.
-`;
-
-  const items = parseWorkspaceMemoryCandidates(summary);
-
-  assert.equal(items.length, 1);
-  assert.equal(items[0].type, "project");
-  assert.equal(items[0].text, "This repository uses local JSON stores for workspace memory.");
-});
-
 test("compaction rejected candidate returns rejection evidence without secrets", () => {
  const summary = `
 Memory candidates:
@@ -1,135 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import type { EvidenceEventType, EvidenceEventV1, EvidenceOutcome, EvidencePhase } from "../src/evidence-log.ts";
-import type { LongTermMemoryEntry } from "../src/types.ts";
-import type { MemoryInspectionReadModel } from "../scripts/memory-diag/types.ts";
-import { CliInputError, normalizeRejection, rejectionQualitySummary, sinceCutoff } from "../scripts/memory-diag/rejections-model.ts";
-import { coverageRows, disappearanceRows } from "../scripts/memory-diag/inspection-model.ts";
-import { groupEvidenceByMemoryId } from "../scripts/memory-diag/evidence-model.ts";
-import { statusFromTraceEvent } from "../scripts/memory-diag/trace-model.ts";
-
-function entry(id: string, type: LongTermMemoryEntry["type"]): LongTermMemoryEntry {
-  const now = new Date("2026-01-01T00:00:00.000Z").toISOString();
-  return {
-    id,
-    type,
-    text: `${id} text`,
-    source: "compaction",
-    confidence: 0.75,
-    status: "active",
-    createdAt: now,
-    updatedAt: now,
-  };
-}
-
-function event(overrides: Partial<EvidenceEventV1> & { type: EvidenceEventType; phase: EvidencePhase; outcome: EvidenceOutcome }): EvidenceEventV1 {
-  return {
-    version: 1,
-    eventId: `evt-${overrides.type}-${Math.random()}`,
-    createdAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-    workspaceKey: "workspace-key",
-    workspaceRootHash: "workspace-root-hash",
-    reasonCodes: [],
-    ...overrides,
-  };
-}
-
-function model(entries: LongTermMemoryEntry[], events: EvidenceEventV1[]): MemoryInspectionReadModel {
-  return {
-    store: {
-      version: 1,
-      workspace: { root: "/tmp/workspace", key: "workspace-key" },
-      limits: { maxRenderedChars: 24_000, maxEntries: 28 },
-      entries,
-      migrations: [],
-      updatedAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-    },
-    pending: { version: 1, workspace: { root: "", key: "" }, entries: [], updatedAt: new Date(0).toISOString() },
-    evidenceEvents: events,
-    rejectionRecords: [],
-    currentById: new Map(entries.map(memory => [memory.id, memory])),
-    evidenceByMemoryId: groupEvidenceByMemoryId(events),
-  };
-}
-
-test("normalizeRejection infers origins from source", () => {
-  assert.equal(normalizeRejection({ source: "compaction", text: "a", reasons: ["bad_decision"] })?.origin, "compaction_candidate");
-  assert.equal(normalizeRejection({ source: "explicit", text: "a", reasons: ["bad_feedback"] })?.origin, "explicit_trigger");
-  assert.equal(normalizeRejection({ source: "manual", text: "a", reasons: ["bad_feedback"] })?.origin, "manual");
-  assert.equal(normalizeRejection({ source: "unknown-source", text: "a", reasons: ["bad_feedback"] })?.origin, "unknown");
-});
-
-test("sinceCutoff accepts relative durations and ISO timestamps", () => {
-  const now = new Date("2026-01-15T12:00:00.000Z").getTime();
-
-  assert.equal(sinceCutoff("14d", now), now - 14 * 86_400_000);
-  assert.equal(sinceCutoff("3h", now), now - 3 * 3_600_000);
-  assert.equal(sinceCutoff("30m", now), now - 30 * 60_000);
-  assert.equal(sinceCutoff("2026-01-01T00:00:00.000Z", now), new Date("2026-01-01T00:00:00.000Z").getTime());
-  assert.throws(() => sinceCutoff("forever", now), (error: unknown) => {
-    assert.ok(error instanceof CliInputError);
-    assert.equal((error as Error).message, "Invalid --since value: forever");
-    return true;
-  });
-});
-
-test("rejectionQualitySummary keeps architecture-like false-positive grouping", () => {
-  const records = [
-    normalizeRejection({ type: "decision", source: "compaction", text: "Retention scoring model uses evidence caps to avoid normalization drift", reasons: ["bad_decision"] }),
-    normalizeRejection({ type: "decision", source: "compaction", text: "Implemented phase 2 and updated tests", reasons: ["bad_decision"] }),
-    normalizeRejection({ type: "decision", source: "compaction", text: "Maybe useful", reasons: ["bad_decision"] }),
-  ].filter(record => record !== null);
-
-  const summary = rejectionQualitySummary(records);
-
-  assert.equal(summary.totalRecords, 3);
-  assert.equal(summary.possibleFalsePositiveGroups.architecture_like_possible_false_positive.count, 1);
-  assert.equal(summary.possibleFalsePositiveGroups.clearly_garbage.count, 1);
-  assert.equal(summary.possibleFalsePositiveGroups.ambiguous.count, 1);
-});
-
-test("coverageRows classifies current and historical memory evidence", () => {
-  const entries = [entry("mem-full", "feedback"), entry("mem-render-only", "decision"), entry("mem-no-evidence", "project")];
-  const events = [
-    event({ type: "extraction_candidate_accepted", phase: "extraction", outcome: "accepted", memory: { memoryId: "mem-full", type: "feedback", source: "compaction" } }),
-    event({ type: "promotion_promoted", phase: "promotion", outcome: "promoted", memory: { memoryId: "mem-full", type: "feedback", source: "compaction" } }),
-    event({ type: "render_selected", phase: "render", outcome: "rendered", memory: { memoryId: "mem-render-only", type: "decision", source: "compaction" } }),
-    event({ type: "memory_removed_capacity", phase: "storage", outcome: "removed", memory: { memoryId: "historical-cap", type: "project", source: "compaction" }, reasonCodes: ["global_cap"] }),
-    event({ type: "promotion_promoted", phase: "promotion", outcome: "promoted", memory: { memoryId: "historical-unknown", type: "reference", source: "compaction" } }),
-  ];
-
-  const rows = coverageRows(model(entries, events), true);
-  const byId = new Map(rows.map(row => [row.id, row.class]));
-
-  assert.equal(byId.get("mem-full"), "full_lifecycle");
-  assert.equal(byId.get("mem-render-only"), "render_only");
-  assert.equal(byId.get("mem-no-evidence"), "no_evidence");
-  assert.equal(byId.get("historical-cap"), "historical_absent_with_reason");
-  assert.equal(byId.get("historical-unknown"), "historical_absent_unknown_reason");
-});
-
-test("disappearanceRows surfaces terminal capacity evidence", () => {
-  const events = [
-    event({ type: "promotion_promoted", phase: "promotion", outcome: "promoted", memory: { memoryId: "capacity-loser", type: "decision", source: "compaction" } }),
-    event({ type: "memory_removed_capacity", phase: "storage", outcome: "removed", memory: { memoryId: "capacity-loser", type: "decision", source: "compaction" }, reasonCodes: ["type_cap"] }),
-  ];
-
-  const rows = disappearanceRows(model([], events));
-
-  assert.equal(rows.length, 1);
-  assert.equal(rows[0].id, "capacity-loser");
-  assert.equal(rows[0].classification, "historical_absent_with_reason");
-  assert.equal(rows[0].terminalType, "memory_removed_capacity");
-  assert.deepEqual(rows[0].reasonCodes, ["type_cap"]);
-});
-
-test("statusFromTraceEvent maps lifecycle events", () => {
-  assert.equal(statusFromTraceEvent(undefined), "unknown");
-  assert.equal(statusFromTraceEvent(event({ type: "render_selected", phase: "render", outcome: "rendered" })), "rendered");
-  assert.equal(statusFromTraceEvent(event({ type: "render_omitted", phase: "render", outcome: "omitted", reasonCodes: ["type_cap"] })), "omitted_type_cap");
-  assert.equal(statusFromTraceEvent(event({ type: "promotion_absorbed_exact", phase: "promotion", outcome: "absorbed" })), "omitted_absorbed_duplicate");
-  assert.equal(statusFromTraceEvent(event({ type: "promotion_retry_scheduled", phase: "promotion", outcome: "retried" })), "pending_retry");
-  assert.equal(statusFromTraceEvent(event({ type: "promotion_retry_exhausted", phase: "promotion", outcome: "exhausted" })), "pending_rejected_capacity");
-  assert.equal(statusFromTraceEvent(event({ type: "storage_corrupt_json_quarantined", phase: "storage", outcome: "quarantined" })), "quarantined_corrupt_store");
-  assert.equal(statusFromTraceEvent(event({ type: "promotion_superseded", phase: "promotion", outcome: "superseded" })), "omitted_superseded");
-});
@@ -1,142 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { parseArgs } from "../scripts/memory-diag/cli.ts";
-
-test("help returns usage without exposing hidden or removed commands", () => {
-  const parsed = parseArgs(["--help"]);
-
-  assert.equal(parsed.ok, true);
-  assert.equal("help" in parsed && parsed.help, true);
-  assert.match(parsed.usage, /Usage:/);
-  assert.match(parsed.usage, /memory-diag \[status\]/);
-  assert.match(parsed.usage, /memory-diag commands/);
-  assert.match(parsed.usage, /memory-diag revert/);
-  for (const command of ["health", "quality", "rejections", "disappearances", "trace", "coverage", "audit"]) {
-    assert.doesNotMatch(parsed.usage, new RegExp(command));
-  }
-});
-
-test("status defaults when no subcommand", () => {
-  const parsed = parseArgs([]);
-
-  assert.equal(parsed.ok, true);
-  assert.equal("command" in parsed && parsed.command, "status");
-  assert.deepEqual("options" in parsed && parsed.options, { raw: false, positional: [] });
-});
-
-test("unknown command returns usage error", () => {
-  const parsed = parseArgs(["unknown"]);
-
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.equal(parsed.message, "Unknown subcommand: unknown");
-  assert.equal(parsed.exitCode, 1);
-  assert.match(parsed.usage, /Usage:/);
-});
-
-test("removed legacy aliases are ordinary unknown subcommands", () => {
-  for (const command of ["health", "quality", "rejections", "disappearances", "trace"]) {
-    const parsed = parseArgs([command]);
-
-    assert.equal(parsed.ok, false, command);
-    if (parsed.ok) continue;
-    assert.equal(parsed.message, `Unknown subcommand: ${command}`);
-    assert.match(parsed.usage, /Usage:/);
-  }
-});
-
-test("hidden maintainer commands are accepted with neutral notices", () => {
-  const coverage = parseArgs(["coverage"]);
-  assert.equal(coverage.ok, true);
-  assert.equal("command" in coverage && coverage.command, "coverage");
-  assert.equal("deprecationNotice" in coverage && coverage.deprecationNotice, "Note: 'coverage' is a maintainer-only diagnostic and is not part of the public CLI surface.");
-
-  const audit = parseArgs(["audit"]);
-  assert.equal(audit.ok, true);
-  assert.equal("command" in audit && audit.command, "audit");
-  assert.equal("deprecationNotice" in audit && audit.deprecationNotice, "Note: 'audit' is a maintainer-only diagnostic and is not part of the public CLI surface.");
-});
-
-test("current command flag validation messages are preserved", () => {
-  const cases: Array<{ args: string[]; message: string }> = [
-    { args: ["status", "--all"], message: "status does not accept --all" },
-    { args: ["coverage", "--all"], message: "coverage does not accept --all" },
-    { args: ["missing", "--all"], message: "missing does not accept --all" },
-    { args: ["rejected", "--all"], message: "rejected does not accept --all" },
-    { args: ["audit", "--workspace", "/tmp/workspace"], message: "audit does not accept --all or --workspace" },
-    { args: ["explain", "--all"], message: "explain does not accept --all" },
-    { args: ["status", "--since", "forever"], message: "status does not accept rejection filters" },
-    { args: ["status", "--reason", "bad_decision"], message: "status does not accept rejection filters" },
-    { args: ["status", "--quality"], message: "Unknown option: --quality" },
-    { args: ["rejected", "--unique"], message: "Unknown option: --unique" },
-  ];
-
-  for (const item of cases) {
-    const parsed = parseArgs(item.args);
-    assert.equal(parsed.ok, false, item.args.join(" "));
-    if (parsed.ok) continue;
-    assert.equal(parsed.message, item.message);
-    assert.match(parsed.usage, /Usage:/);
-  }
-});
-
-test("commands accepts workspace json and verbose flags", () => {
-  const parsed = parseArgs(["commands", "--workspace", "/tmp/workspace", "--json", "--verbose"]);
-
-  assert.equal(parsed.ok, true);
-  assert.equal("command" in parsed && parsed.command, "commands");
-  assert.equal("options" in parsed && parsed.options.workspace, "/tmp/workspace");
-  assert.equal("options" in parsed && parsed.options.json, true);
-  assert.equal("options" in parsed && parsed.options.verbose, true);
-});
-
-test("revert accepts memory or event selectors and apply flag", () => {
-  const byMemory = parseArgs(["revert", "--memory", "mem-new", "--workspace", "/tmp/workspace", "--apply"]);
-  assert.equal(byMemory.ok, true);
-  assert.equal("command" in byMemory && byMemory.command, "revert");
-  assert.equal("options" in byMemory && byMemory.options.memory, "mem-new");
-  assert.equal("options" in byMemory && byMemory.options.workspace, "/tmp/workspace");
-  assert.equal("options" in byMemory && byMemory.options.apply, true);
-
-  const byEvent = parseArgs(["revert", "--event", "evt_1"]);
-  assert.equal(byEvent.ok, true);
-  assert.equal("command" in byEvent && byEvent.command, "revert");
-  assert.equal("options" in byEvent && byEvent.options.event, "evt_1");
-  assert.equal("options" in byEvent && byEvent.options.apply, undefined);
-});
-
-test("revert requires exactly one selector", () => {
-  const missing = parseArgs(["revert"]);
-  assert.equal(missing.ok, false);
-  if (!missing.ok) assert.equal(missing.message, "revert requires --memory or --event");
-
-  const both = parseArgs(["revert", "--memory", "mem-new", "--event", "evt_1"]);
-  assert.equal(both.ok, false);
-  if (!both.ok) assert.equal(both.message, "Use either --memory or --event, not both");
-});
-
-test("rejected invalid since value returns current error", () => {
-  const parsed = parseArgs(["rejected", "--since", "forever"]);
-
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.equal(parsed.message, "Invalid --since value: forever");
-  assert.match(parsed.usage, /Usage:/);
-});
-
-test("explain accepts positional memory id", () => {
-  const parsed = parseArgs(["explain", "mem-1", "--workspace", "/tmp/workspace"]);
-
-  assert.equal(parsed.ok, true);
-  assert.equal("command" in parsed && parsed.command, "explain");
-  assert.equal("options" in parsed && parsed.options.memory, "mem-1");
-  assert.deepEqual("options" in parsed && parsed.options.positional, ["mem-1"]);
-});
-
-test("explain with both positional and memory flag errors", () => {
-  const parsed = parseArgs(["explain", "mem-1", "--memory", "mem-2"]);
-
-  assert.equal(parsed.ok, false);
-  if (parsed.ok) return;
-  assert.equal(parsed.message, "Use either explain <memory-id> or --memory, not both");
-});
@@ -1,110 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import type { EvidenceEventType, EvidenceEventV1, EvidenceOutcome, EvidencePhase } from "../src/evidence-log.ts";
-import type { MemoryInspectionReadModel, WorkspaceDiagSnapshot } from "../scripts/memory-diag/types.ts";
-import { formatCoverage } from "../scripts/memory-diag/formatters/coverage.ts";
-import { formatMigrationAudit } from "../scripts/memory-diag/formatters/audit.ts";
-import { formatExplain } from "../scripts/memory-diag/formatters/explain.ts";
-import { buildMissingJSON, formatMissing } from "../scripts/memory-diag/formatters/missing.ts";
-import { formatTrace } from "../scripts/memory-diag/formatters/trace.ts";
-
-function emptyInspectionModel(): MemoryInspectionReadModel {
-  return {
-    store: {
-      version: 1,
-      workspace: { root: "/tmp/workspace", key: "workspace-key" },
-      limits: { maxRenderedChars: 24_000, maxEntries: 28 },
-      entries: [],
-      migrations: [],
-      updatedAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-    },
-    pending: { version: 1, workspace: { root: "", key: "" }, entries: [], updatedAt: new Date(0).toISOString() },
-    evidenceEvents: [],
-    rejectionRecords: [],
-    currentById: new Map(),
-    evidenceByMemoryId: new Map(),
-  };
-}
-
-function emptySnapshot(): WorkspaceDiagSnapshot {
-  return {
-    store: emptyInspectionModel().store,
-    journal: emptyInspectionModel().pending,
-    retention: { sorted: [], rendered: [], typeCapped: [], globalCapped: [] },
-    memories: [],
-    recentEvents: [],
-    allEvents: [],
-    summary: {
-      storedActive: 0,
-      rendered: 0,
-      pending: 0,
-      rejectedLast7Days: 0,
-      corruptStoresQuarantinedLast30Days: 0,
-    },
-  };
-}
-
-function event(overrides: Partial<EvidenceEventV1> & { type: EvidenceEventType; phase: EvidencePhase; outcome: EvidenceOutcome }): EvidenceEventV1 {
-  return {
-    version: 1,
-    eventId: `evt-${overrides.type}`,
-    createdAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-    workspaceKey: "workspace-key",
-    workspaceRootHash: "workspace-root-hash",
-    reasonCodes: [],
-    ...overrides,
-  };
-}
-
-test("coverage formatter includes class counts section", () => {
-  const output = formatCoverage([]);
-
-  assert.match(output, /Class counts:/);
-  assert.match(output, /Per-memory rows:\n  \(none\)/);
-});
-
-test("missing formatter verbose output preserves disappearance details", () => {
-  const output = formatMissing([], { verbose: true });
-
-  assert.match(output, /No missing memories found\./);
-});
-
-test("missing JSON includes disappearance rows and summary", () => {
-  const rows = [{
-    id: "historical-1",
-    classification: "historical_absent_unknown_reason" as const,
-    terminalType: "unknown" as const,
-    reasonCodes: [],
-    events: [event({ type: "extraction_candidate_accepted", phase: "extraction", outcome: "accepted" })],
-    event: undefined,
-  }];
-
-  const output = buildMissingJSON(rows, { generatedAt: "2026-01-01T00:00:00.000Z" });
-
-  assert.equal(output.version, 1);
-  assert.deepEqual(output.summary, { total: 1, explained: 0, needsReview: 1 });
-  assert.deepEqual((output.disappearances as Array<{ id: string }>)[0]?.id, "historical-1");
-});
-
-test("trace formatter includes lifecycle section", () => {
-  const output = formatTrace("mem-1", emptySnapshot(), {
-    events: [event({ type: "render_selected", phase: "render", outcome: "rendered", memory: { memoryId: "mem-1", type: "feedback", source: "explicit" } })],
-  });
-
-  assert.match(output, /Lifecycle:/);
-  assert.match(output, /evt-render_selected render_selected/);
-});
-
-test("audit formatter preserves no-log output", () => {
-  const output = formatMigrationAudit([], { raw: false });
-
-  assert.match(output, /Migration audit report/);
-  assert.match(output, /No migration logs found\./);
-});
-
-test("explain formatter preserves no-memory output", () => {
-  const output = formatExplain(emptySnapshot());
-
-  assert.match(output, /Workspace memory explainability/);
-  assert.match(output, /No memories found\./);
-});
@@ -1,54 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { canonicalMemoryText, cleanText, countBy, sortedCounts, truncate } from "../scripts/memory-diag/text.ts";
-import { readJSONLFile } from "../scripts/memory-diag/io.ts";
-
-test("cleanText redacts credentials and absolute paths unless raw", () => {
-  const text = "Use password: sushi and api_key=abc123 in /Users/alice/project/config.json";
-
-  const cleaned = cleanText(text, false);
-
-  assert.match(cleaned, /password: \[REDACTED\]/);
-  assert.match(cleaned, /api_key=\[REDACTED\]/);
-  assert.match(cleaned, /<path>/);
-  assert.doesNotMatch(cleaned, /sushi/);
-  assert.doesNotMatch(cleaned, /\/Users\/alice/);
-  assert.equal(cleanText(text, true), text);
-});
-
-test("truncate collapses whitespace and applies ellipsis at max length", () => {
-  assert.equal(truncate("  hello\n\tworld   "), "hello world");
-  assert.equal(truncate("abcdef", 5), "abcd…");
-});
-
-test("canonicalMemoryText normalizes punctuation and case", () => {
-  assert.equal(canonicalMemoryText("Hello, WORLD!!!　Path?"), "hello world path");
-});
-
-test("sortedCounts sorts by count descending then key ascending", () => {
-  const counts = new Map<string, number>([["b", 2], ["a", 2], ["c", 3]]);
-
-  assert.deepEqual(sortedCounts(counts), [["c", 3], ["a", 2], ["b", 2]]);
-});
-
-test("countBy counts string items", () => {
-  assert.deepEqual([...countBy(["beta", "alpha", "beta"]).entries()], [["beta", 2], ["alpha", 1]]);
-});
-
-test("readJSONLFile returns valid records and invalid line count", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-utils-"));
-  try {
-    const path = join(root, "records.jsonl");
-    await writeFile(path, '{"id":"one"}\nnot-json\n\n{"id":"two"}\n', "utf8");
-
-    const result = await readJSONLFile<{ id: string }>(path);
-
-    assert.deepEqual(result.records, [{ id: "one" }, { id: "two" }]);
-    assert.equal(result.invalidLines, 1);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
@@ -1,224 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { appendEvidenceEvents, queryEvidenceEvents, summarizeMemoryEvidence, type EvidenceEventInput, type EvidenceEventV1 } from "../src/evidence-log.ts";
-import { groupEvidenceByMemoryId } from "../scripts/memory-diag/evidence-model.ts";
-import { retentionCandidatesForDiag } from "../scripts/memory-diag/retention-model.ts";
-import { buildMemoryDiagJSON, memoryDiagJSONFromSnapshot, normalizedJournal, normalizedStore, snapshotForOptions } from "../scripts/memory-diag/workspace-snapshot.ts";
-import { workspaceKey, workspaceMemoryPath, workspacePendingJournalPath } from "../src/paths.ts";
-import { LONG_TERM_LIMITS, type LongTermMemoryEntry, type PendingMemoryJournalStore, type WorkspaceMemoryStore } from "../src/types.ts";
-
-function entry(id: string, text: string, type: LongTermMemoryEntry["type"]): LongTermMemoryEntry {
-  const now = new Date("2026-01-01T00:00:00.000Z").toISOString();
-  return {
-    id,
-    type,
-    text,
-    source: "compaction",
-    confidence: 0.75,
-    status: "active",
-    createdAt: now,
-    updatedAt: now,
-    retentionClock: new Date(now).getTime(),
-  };
-}
-
-function evidence(overrides: Partial<EvidenceEventInput>): EvidenceEventInput {
-  return {
-    type: "promotion_promoted",
-    phase: "promotion",
-    outcome: "promoted",
-    memory: { memoryId: "mem-active", type: "decision", source: "compaction", status: "active" },
-    reasonCodes: ["new_workspace_entry"],
-    ...overrides,
-  };
-}
-
-function groupedEvidenceSummary(grouped: Map<string, EvidenceEventV1[]>, memoryId: string): { eventIds: string[]; reasonCodes: string[] } {
-  const events = grouped.get(memoryId) ?? [];
-  const reasonCodes = new Set<string>();
-  for (const event of events) {
-    for (const reason of event.reasonCodes) reasonCodes.add(reason);
-  }
-  return {
-    eventIds: events.map(event => event.eventId),
-    reasonCodes: [...reasonCodes],
-  };
-}
-
-async function writeWorkspaceStore(root: string, entries: LongTermMemoryEntry[]): Promise<void> {
-  const key = await workspaceKey(root);
-  const path = await workspaceMemoryPath(root);
-  const store: WorkspaceMemoryStore = {
-    version: 1,
-    workspace: { root, key },
-    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries,
-    migrations: [],
-    updatedAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-  };
-
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, JSON.stringify(store, null, 2), "utf8");
-}
-
-async function writePendingJournal(root: string, entries: LongTermMemoryEntry[]): Promise<void> {
-  const key = await workspaceKey(root);
-  const path = await workspacePendingJournalPath(root);
-  const store: PendingMemoryJournalStore = {
-    version: 1,
-    workspace: { root, key },
-    entries,
-    updatedAt: new Date("2026-01-01T00:00:00.000Z").toISOString(),
-  };
-
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, JSON.stringify(store, null, 2), "utf8");
-}
-
-test("normalizedStore returns an empty store with limits and empty arrays", () => {
-  const store = normalizedStore(null, "/tmp/example-workspace", "workspace-key");
-
-  assert.equal(store.version, 1);
-  assert.deepEqual(store.workspace, { root: "/tmp/example-workspace", key: "workspace-key" });
-  assert.deepEqual(store.limits, { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries });
-  assert.deepEqual(store.entries, []);
-  assert.deepEqual(store.migrations, []);
-});
-
-test("normalizedJournal returns an empty journal", () => {
-  const journal = normalizedJournal(null);
-
-  assert.equal(journal.version, 1);
-  assert.deepEqual(journal.workspace, { root: "", key: "" });
-  assert.deepEqual(journal.entries, []);
-  assert.equal(journal.updatedAt, new Date(0).toISOString());
-});
-
-test("retentionCandidatesForDiag separates rendered, type-capped, and global-capped entries", () => {
-  const entries: LongTermMemoryEntry[] = [
-    ...Array.from({ length: 11 }, (_, i) => entry(`feedback-${String(i).padStart(2, "0")}`, `Feedback memory ${i}`, "feedback")),
-    ...Array.from({ length: 10 }, (_, i) => entry(`decision-${String(i).padStart(2, "0")}`, `Decision memory ${i}`, "decision")),
-    ...Array.from({ length: 8 }, (_, i) => entry(`project-${String(i).padStart(2, "0")}`, `Project memory ${i}`, "project")),
-    ...Array.from({ length: 6 }, (_, i) => entry(`reference-${String(i).padStart(2, "0")}`, `Reference memory ${i}`, "reference")),
-  ];
-  const store = normalizedStore({ entries, workspace: { root: "/tmp/root", key: "key" } } as WorkspaceMemoryStore, "/tmp/root", "key");
-
-  const candidates = retentionCandidatesForDiag(store, new Date("2026-01-02T00:00:00.000Z").getTime());
-
-  assert.equal(candidates.rendered.length, LONG_TERM_LIMITS.maxEntries);
-  assert.equal(candidates.typeCapped.length, 1);
-  assert.equal(candidates.globalCapped.length, 6);
-  assert.equal(candidates.typeCapped[0].entry.type, "feedback");
-});
-
-test("buildMemoryDiagJSON redacts previews, includes pending entries, and preserves summary fields", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-workspace-model-"));
-  try {
-    const active = entry("mem-active", "Remember password: sushi and file /Users/alice/private.txt", "decision");
-    const pending = { ...entry("mem-pending", "Pending api_key=secret-value", "project"), promotionAttempts: 1 };
-    await writeWorkspaceStore(root, [active]);
-    await writePendingJournal(root, [pending]);
-
-    const diag = await buildMemoryDiagJSON(root);
-
-    assert.equal(diag.version, 1);
-    assert.equal(diag.summary.storedActive, 1);
-    assert.equal(diag.summary.rendered, 1);
-    assert.equal(diag.summary.pending, 1);
-    assert.equal(diag.summary.rejectedLast7Days, 0);
-    assert.equal(diag.summary.corruptStoresQuarantinedLast30Days, 0);
-    assert.equal(diag.memories.length, 2);
-    assert.equal(diag.memories.find(memory => memory.id === "mem-pending")?.status, "pending_retry");
-    assert.ok(diag.memories.some(memory => memory.textPreview?.includes("[REDACTED]")));
-    assert.ok(diag.memories.some(memory => memory.textPreview?.includes("<path>")));
-    assert.ok(!JSON.stringify(diag).includes("sushi"));
-    assert.ok(!JSON.stringify(diag).includes("secret-value"));
-    assert.equal(diag.workspace.key, await workspaceKey(root));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memoryDiagJSONFromSnapshot serializes an existing snapshot with fixed generatedAt", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-snapshot-json-"));
-  try {
-    const active = entry("mem-active", "Stable decision memory", "decision");
-    const pending = { ...entry("mem-pending", "Pending project memory", "project"), promotionAttempts: 1 };
-    await writeWorkspaceStore(root, [active]);
-    await writePendingJournal(root, [pending]);
-
-    const snapshot = await snapshotForOptions({ raw: false, workspace: root });
-    const generatedAt = "2026-05-02T00:00:00.000Z";
-    const diag = memoryDiagJSONFromSnapshot(root, snapshot, generatedAt);
-
-    assert.equal(diag.version, 1);
-    assert.equal(diag.generatedAt, generatedAt);
-    assert.equal(diag.memories, snapshot.memories);
-    assert.equal(diag.recentEvents, snapshot.recentEvents);
-    assert.equal(diag.summary, snapshot.summary);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("grouped evidence summaries match per-memory summaries for stored pending and absorbed memories", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-evidence-equivalence-"));
-  try {
-    const active = entry("mem-active", "Stable decision memory", "decision");
-    const pending = { ...entry("mem-pending", "Pending project memory", "project"), promotionAttempts: 1 };
-    await writeWorkspaceStore(root, [active]);
-    await writePendingJournal(root, [pending]);
-    await appendEvidenceEvents(root, [
-      evidence({ memory: { memoryId: "mem-active", type: "decision", source: "compaction", status: "active" }, reasonCodes: ["stored_reason"] }),
-      evidence({ type: "pending_memory_appended", phase: "pending_journal", outcome: "accepted", memory: { memoryId: "mem-pending", type: "project", source: "compaction" }, reasonCodes: ["pending_reason"] }),
-      evidence({ type: "promotion_absorbed_exact", phase: "promotion", outcome: "absorbed", memory: { memoryId: "mem-absorbed", type: "feedback", source: "compaction" }, reasonCodes: ["same_exact_key"] }),
-    ]);
-
-    const grouped = groupEvidenceByMemoryId(await queryEvidenceEvents(root));
-    for (const id of ["mem-active", "mem-pending", "mem-absorbed"]) {
-      const oldSummary = await summarizeMemoryEvidence(root, { memoryId: id });
-      const groupedSummary = groupedEvidenceSummary(grouped, id);
-
-      assert.deepEqual(groupedSummary.eventIds, oldSummary.eventIds);
-      assert.deepEqual(groupedSummary.reasonCodes, oldSummary.reasonCodes);
-    }
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("buildMemoryDiagJSON preserves evidence ids and reason codes for stored pending and absorbed memories", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-evidence-rows-"));
-  try {
-    const active = entry("mem-active", "Stable decision memory", "decision");
-    const pending = { ...entry("mem-pending", "Pending project memory", "project"), promotionAttempts: 1 };
-    await writeWorkspaceStore(root, [active]);
-    await writePendingJournal(root, [pending]);
-    const events = await appendEvidenceEvents(root, [
-      evidence({ memory: { memoryId: "mem-active", type: "decision", source: "compaction", status: "active" }, reasonCodes: ["stored_reason"] }),
-      evidence({ type: "pending_memory_appended", phase: "pending_journal", outcome: "accepted", memory: { memoryId: "mem-pending", type: "project", source: "compaction" }, reasonCodes: ["pending_reason"] }),
-      evidence({ type: "promotion_absorbed_exact", phase: "promotion", outcome: "absorbed", memory: { memoryId: "mem-absorbed", type: "feedback", source: "compaction" }, reasonCodes: ["same_exact_key"] }),
-    ]);
-
-    const diag = await buildMemoryDiagJSON(root);
-    const activeRow = diag.memories.find(memory => memory.id === "mem-active");
-    const pendingRow = diag.memories.find(memory => memory.id === "mem-pending");
-    const absorbedRow = diag.memories.find(memory => memory.id === "mem-absorbed");
-
-    assert.ok(activeRow);
-    assert.ok(pendingRow);
-    assert.ok(absorbedRow);
-    assert.deepEqual(activeRow.evidenceEventIds, [events[0].eventId]);
-    assert.ok(activeRow.reasonCodes.includes("stored_reason"));
-    assert.deepEqual(pendingRow.evidenceEventIds, [events[1].eventId]);
-    assert.ok(pendingRow.reasonCodes.includes("pending_reason"));
-    assert.deepEqual(absorbedRow.evidenceEventIds, [events[2].eventId]);
-    assert.ok(absorbedRow.reasonCodes.includes("same_exact_key"));
-    assert.ok(absorbedRow.reasonCodes.includes("absorbed_duplicate"));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
@@ -1,16 +1,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdtempSync } from "node:fs";
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import { appendEvidenceEvents, queryEvidenceEvents, type EvidenceEventInput } from "../src/evidence-log.ts";
+import { appendEvidenceEvents, type EvidenceEventInput } from "../src/evidence-log.ts";
 import type { LongTermMemoryEntry, WorkspaceMemoryStore } from "../src/types.ts";
 import { LONG_TERM_LIMITS, PROMOTION_RETRY_LIMITS, type PendingMemoryJournalStore } from "../src/types.ts";
-import { extractionRejectionLogPath, workspaceEvidenceLogPath, workspaceKey, workspaceMemoryPath, workspacePendingJournalPath } from "../src/paths.ts";
+import { extractionRejectionLogPath, workspaceKey, workspaceMemoryPath, workspacePendingJournalPath } from "../src/paths.ts";

 const execFileAsync = promisify(execFile);
 const repoRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
@@ -47,23 +46,18 @@ async function writeWorkspaceStore(root: string, entries: LongTermMemoryEntry[],
  await writeFile(path, JSON.stringify(store, null, 2), "utf8");
 }

-async function runMemoryDiagStatusVerbose(root: string): Promise<string> {
-  return runMemoryDiag(["status", "--workspace", root, "--verbose"]);
+async function runMemoryDiagHealth(root: string): Promise<string> {
+  return runMemoryDiag(["health", "--workspace", root]);
 }

 async function runMemoryDiag(args: string[]): Promise<string> {
-  const { stdout } = await runMemoryDiagResult(args);
-  return stdout;
-}
-
-async function runMemoryDiagResult(args: string[], options: { cwd?: string } = {}): Promise<{ stdout: string; stderr: string }> {
-  const { stdout, stderr } = await execFileAsync(process.execPath, [
+  const { stdout } = await execFileAsync(process.execPath, [
    "--experimental-strip-types",
    "scripts/memory-diag.ts",
    ...args,
-  ], { cwd: options.cwd ?? repoRoot });
+  ], { cwd: repoRoot });

-  return { stdout: stdout.trim(), stderr: stderr.trim() };
+  return stdout;
 }

 async function writePendingJournal(root: string, entries: LongTermMemoryEntry[]): Promise<void> {
@@ -96,141 +90,6 @@ function evidence(overrides: Partial<EvidenceEventInput>): EvidenceEventInput {
  };
 }

-function replacementFixture(): { original: LongTermMemoryEntry; replacement: LongTermMemoryEntry } {
-  const original = {
-    ...entry("mem-original", "Original compaction memory to restore", "decision"),
-    status: "superseded" as const,
-  };
-  const replacement = {
-    ...entry("mem-replacement", "Replacement compaction memory to revert", "decision"),
-    supersedes: [original.id],
-  };
-  return { original, replacement };
-}
-
-function replacementEvidence(original: LongTermMemoryEntry, replacement: LongTermMemoryEntry): EvidenceEventInput {
-  return evidence({
-    type: "memory_replaced_numbered_ref",
-    phase: "storage",
-    outcome: "superseded",
-    memory: { memoryId: original.id, type: original.type, source: original.source, status: "superseded" },
-    relations: [
-      { role: "superseded", memory: { memoryId: original.id, type: original.type, source: original.source, status: "superseded" } },
-      { role: "superseded_by", memory: { memoryId: replacement.id, type: replacement.type, source: replacement.source, status: "active" } },
-    ],
-    reasonCodes: ["numbered_ref_replace", "same_type_replace"],
-    details: { ref: "M1", oldMemoryId: original.id, newMemoryId: replacement.id },
-  });
-}
-
-test("status handles missing workspace store as empty", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-missing-health-"));
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root]);
-
-    assert.match(stdout, /Memory status/);
-    assert.match(stdout, /active memories: 0/);
-    assert.match(stdout, /pending: 0/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status verbose handles missing workspace store as empty", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-missing-quality-"));
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--verbose"]);
-
-    assert.match(stdout, /Memory status inspection/);
-    assert.match(stdout, /Caps:/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("coverage and disappearances handle missing workspace store as empty", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-missing-inspection-"));
-  try {
-    const coverageStdout = await runMemoryDiag(["coverage", "--workspace", root]);
-    assert.match(coverageStdout, /no_evidence: 0/);
-    assert.match(coverageStdout, /Per-memory rows:\n\s+\(none\)/);
-
-    const missingStdout = await runMemoryDiag(["missing", "--workspace", root]);
-    assert.match(missingStdout, /No missing memories found\./);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status with unsupported all flag shows usage error", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-conflicting-flags-"));
-  try {
-    await assert.rejects(
-      runMemoryDiagResult(["status", "--all", "--workspace", root]),
-      (error: unknown) => {
-        const err = error as { code?: number; stderr?: string };
-        assert.notEqual(err.code, 0);
-        assert.match(err.stderr ?? "", /status does not accept --all/);
-        assert.match(err.stderr ?? "", /Usage:/);
-        return true;
-      },
-    );
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag reports unexpected command errors without stack traces", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-error-boundary-"));
-  try {
-    await writeWorkspaceStore(root, []);
-    // Invalid rejection filter values are parse-caught before dispatch, so this
-    // fixture exercises the same top-level boundary with a command-thrown Error.
-    await mkdir(await workspaceEvidenceLogPath(root), { recursive: true });
-
-    await assert.rejects(
-      runMemoryDiagResult(["status", "--workspace", root]),
-      (error: unknown) => {
-        const err = error as { code?: number; stderr?: string };
-        assert.notEqual(err.code, 0);
-        assert.match(err.stderr ?? "", /memory-diag failed:/);
-        assert.doesNotMatch(err.stderr ?? "", /\n\s+at\s|Error:/);
-        return true;
-      },
-    );
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag defaults to status when no subcommand is supplied", async () => {
-  const result = await runMemoryDiagResult([]);
-
-  assert.match(result.stdout, /Memory status/);
-  assert.match(result.stdout, /Key metrics:/);
-  assert.equal(result.stderr, "");
-});
-
-test("removed legacy aliases return unknown subcommand", async () => {
-  const root = mkdtempSync(join(tmpdir(), "opencode-memory-diag-legacy-health-"));
-  try {
-    for (const command of ["health", "quality", "rejections", "disappearances", "trace"]) {
-      await assert.rejects(
-        runMemoryDiagResult([command, "--workspace", root]),
-        (error: unknown) => {
-          const err = error as { code?: number; stderr?: string };
-          assert.notEqual(err.code, 0);
-          assert.match(err.stderr ?? "", new RegExp(`Unknown subcommand: ${command}`));
-          assert.match(err.stderr ?? "", /Usage:/);
-          return true;
-        },
-      );
-    }
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
 test("memory health reports stored vs rendered retention counts", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-"));
  try {
@@ -240,281 +99,17 @@ test("memory health reports stored vs rendered retention counts", async () => {
    ];
    await writeWorkspaceStore(root, entries);

-    const stdout = await runMemoryDiagStatusVerbose(root);
+    const stdout = await runMemoryDiagHealth(root);

-    assert.match(stdout, /Memory status inspection/);
-    assert.match(stdout, /active: 28 \/ 28/);
-    assert.match(stdout, /rendered: 21/);
-    assert.match(stdout, /feedback: 17 \/ 10 FULL/);
+    assert.match(stdout, /Stored active memories:/);
+    assert.match(stdout, /Rendered candidates:/);
+    assert.match(stdout, /feedback\s+stored=17\s+rendered=10/);
    assert.match(stdout, /Top rendered candidates:\n\s+- strength=/);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
 });

-test("memory-diag commands reports zero counts for empty evidence log", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-commands-empty-"));
-  try {
-    const stdout = await runMemoryDiag(["commands", "--workspace", root]);
-
-    assert.match(stdout, /Memory command diagnostics/);
-    assert.match(stdout, /compactions with command evidence: 0/);
-    assert.match(stdout, /reinforce: 0/);
-    assert.match(stdout, /replace: 0/);
-    assert.match(stdout, /invalid\/malformed commands: 0/);
-    assert.match(stdout, /Protected REPLACE blocked: 0 \(reinforced: 0, source: 0\)/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag commands summarizes seeded command evidence", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-commands-"));
-  try {
-    await appendEvidenceEvents(root, [
-      evidence({
-        type: "memory_reinforced",
-        phase: "reinforcement",
-        outcome: "reinforced",
-        memory: { memoryId: "reinforced-1", type: "decision", source: "compaction", status: "active" },
-        reasonCodes: ["numbered_ref_reinforce", "reinforcement_window_allowed"],
-        sessionHash: "command-session-a",
-      }),
-      evidence({
-        type: "memory_reinforced",
-        phase: "reinforcement",
-        outcome: "rejected",
-        memory: { memoryId: "reinforced-blocked", type: "feedback", source: "compaction", status: "active" },
-        reasonCodes: ["numbered_ref_reinforce", "reinforcement_window_blocked"],
-        sessionHash: "command-session-a",
-      }),
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "superseded",
-        memory: { memoryId: "replace-old-same", type: "decision", source: "compaction", status: "superseded" },
-        relations: [
-          { role: "superseded", memory: { memoryId: "replace-old-same", type: "decision", source: "compaction", status: "superseded" } },
-          { role: "superseded_by", memory: { memoryId: "replace-new-same", type: "decision", source: "compaction", status: "active" } },
-        ],
-        reasonCodes: ["numbered_ref_replace", "same_type_replace"],
-        sessionHash: "command-session-b",
-      }),
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "superseded",
-        memory: { memoryId: "replace-old-cross", type: "project", source: "compaction", status: "superseded" },
-        relations: [
-          { role: "superseded", memory: { memoryId: "replace-old-cross", type: "project", source: "compaction", status: "superseded" } },
-          { role: "superseded_by", memory: { memoryId: "replace-new-cross", type: "decision", source: "compaction", status: "active" } },
-        ],
-        reasonCodes: ["numbered_ref_replace", "cross_type_replace"],
-        sessionHash: "command-session-b",
-      }),
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "rejected",
-        memory: { memoryId: "replace-protected-reinforced", type: "decision", source: "compaction", status: "active" },
-        reasonCodes: ["protected_reinforced_target"],
-        sessionHash: "command-session-c",
-      }),
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "rejected",
-        memory: { memoryId: "replace-protected-source", type: "feedback", source: "explicit", status: "active" },
-        reasonCodes: ["protected_memory_source"],
-        sessionHash: "command-session-c",
-      }),
-      evidence({
-        type: "extraction_candidate_rejected",
-        phase: "extraction",
-        outcome: "rejected",
-        memory: { type: "decision", source: "compaction" },
-        reasonCodes: ["invalid_memory_ref"],
-        textPreview: "REINFORCE [X3]",
-        sessionHash: "command-session-c",
-      }),
-    ]);
-
-    const stdout = await runMemoryDiag(["commands", "--workspace", root, "--verbose"]);
-
-    assert.match(stdout, /compactions with command evidence: 3/);
-    assert.match(stdout, /reinforce: 2/);
-    assert.match(stdout, /replace: 4/);
-    assert.match(stdout, /reinforced: 1/);
-    assert.match(stdout, /superseded: 2/);
-    assert.match(stdout, /rejected: 3/);
-    assert.match(stdout, /blocked: 3/);
-    assert.match(stdout, /invalid\/malformed commands: 1/);
-    assert.match(stdout, /same-type replacements: 1/);
-    assert.match(stdout, /cross-type replacements: 1/);
-    assert.match(stdout, /Protected REPLACE blocked: 2 \(reinforced: 1, source: 1\)/);
-    assert.match(stdout, /protected_reinforced_target: 1/);
-    assert.match(stdout, /protected_memory_source: 1/);
-    assert.match(stdout, /Latest command events/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag commands json exposes protected replacement counts", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-commands-json-"));
-  try {
-    await appendEvidenceEvents(root, [
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "rejected",
-        memory: { memoryId: "replace-protected-reinforced-json", type: "decision", source: "compaction", status: "active" },
-        reasonCodes: ["protected_reinforced_target"],
-        sessionHash: "json-command-session",
-      }),
-      evidence({
-        type: "memory_replaced_numbered_ref",
-        phase: "storage",
-        outcome: "rejected",
-        memory: { memoryId: "replace-protected-source-json", type: "feedback", source: "manual", status: "active" },
-        reasonCodes: ["protected_memory_source"],
-        sessionHash: "json-command-session",
-      }),
-    ]);
-
-    const stdout = await runMemoryDiag(["commands", "--workspace", root, "--json"]);
-    const parsed = JSON.parse(stdout) as {
-      protectedReplacements: { total: number; protectedReinforcedTarget: number; protectedMemorySource: number };
-      commands: { reinforce: number; replace: number };
-      outcomes: { rejected: number };
-    };
-
-    assert.deepEqual(parsed.protectedReplacements, {
-      total: 2,
-      protectedReinforcedTarget: 1,
-      protectedMemorySource: 1,
-    });
-    assert.equal(parsed.commands.replace, 2);
-    assert.equal(parsed.commands.reinforce, 0);
-    assert.equal(parsed.outcomes.rejected, 2);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag revert dry-run plans changes without mutating", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-dry-run-"));
-  try {
-    const { original, replacement } = replacementFixture();
-    await writeWorkspaceStore(root, [original, replacement]);
-    await appendEvidenceEvents(root, [replacementEvidence(original, replacement)]);
-    const path = await workspaceMemoryPath(root);
-    const before = await readFile(path, "utf8");
-
-    const stdout = await runMemoryDiag(["revert", "--workspace", root, "--memory", replacement.id]);
-    const after = await readFile(path, "utf8");
-    const reverts = await queryEvidenceEvents(root, { types: ["memory_reverted_numbered_ref"] });
-
-    assert.match(stdout, /Memory revert dry run/);
-    assert.match(stdout, /replacement: mem-replacement/);
-    assert.match(stdout, /original: mem-original/);
-    assert.match(stdout, /No changes applied/);
-    assert.equal(after, before);
-    assert.equal(reverts.length, 0);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag revert apply restores original and emits evidence", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-apply-"));
-  try {
-    const { original, replacement } = replacementFixture();
-    await writeWorkspaceStore(root, [original, replacement]);
-    const [replaceEvent] = await appendEvidenceEvents(root, [replacementEvidence(original, replacement)]);
-
-    const stdout = await runMemoryDiag(["revert", "--workspace", root, "--event", replaceEvent.eventId, "--apply"]);
-    const stored = JSON.parse(await readFile(await workspaceMemoryPath(root), "utf8")) as WorkspaceMemoryStore;
-    const restored = stored.entries.find(item => item.id === original.id);
-    const supersededReplacement = stored.entries.find(item => item.id === replacement.id);
-    const reverts = await queryEvidenceEvents(root, { types: ["memory_reverted_numbered_ref"], outcomes: ["recovered"] });
-    const commandsStdout = await runMemoryDiag(["commands", "--workspace", root, "--verbose"]);
-
-    assert.match(stdout, /Memory revert applied/);
-    assert.equal(restored?.status, "active");
-    assert.equal(supersededReplacement?.status, "superseded");
-    assert.ok(restored?.updatedAt && restored.updatedAt !== original.updatedAt);
-    assert.ok(supersededReplacement?.updatedAt && supersededReplacement.updatedAt !== replacement.updatedAt);
-    assert.equal(reverts.length, 1);
-    assert.equal(reverts[0].type, "memory_reverted_numbered_ref");
-    assert.equal(reverts[0].outcome, "recovered");
-    assert.ok(reverts[0].reasonCodes.includes("manual_revert_numbered_ref"));
-    assert.ok(reverts[0].relations?.some(relation => relation.role === "recovered" && relation.memory?.memoryId === original.id));
-    assert.match(commandsStdout, /memory_reverted_numbered_ref/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag revert rejects unsafe requests", async () => {
-  const missingOriginalRoot = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-missing-original-"));
-  const replacementSupersededRoot = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-replacement-superseded-"));
-  const laterSupersessionRoot = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-later-supersession-"));
-  const wrongEventRoot = await mkdtemp(join(tmpdir(), "opencode-memory-diag-revert-wrong-event-"));
-  try {
-    const { original, replacement } = replacementFixture();
-
-    await writeWorkspaceStore(missingOriginalRoot, [replacement]);
-    await appendEvidenceEvents(missingOriginalRoot, [replacementEvidence(original, replacement)]);
-    await assert.rejects(
-      runMemoryDiagResult(["revert", "--workspace", missingOriginalRoot, "--memory", replacement.id]),
-      (error: unknown) => {
-        const err = error as { stderr?: string };
-        assert.match(err.stderr ?? "", /revert rejected: original memory mem-original is missing/);
-        return true;
-      },
-    );
-
-    await writeWorkspaceStore(replacementSupersededRoot, [original, { ...replacement, status: "superseded" }]);
-    await appendEvidenceEvents(replacementSupersededRoot, [replacementEvidence(original, replacement)]);
-    await assert.rejects(
-      runMemoryDiagResult(["revert", "--workspace", replacementSupersededRoot, "--memory", replacement.id]),
-      (error: unknown) => {
-        const err = error as { stderr?: string };
-        assert.match(err.stderr ?? "", /revert rejected: replacement memory mem-replacement is not active/);
-        return true;
-      },
-    );
-
-    const later = { ...entry("mem-later", "Later active supersession", "decision"), supersedes: [replacement.id] };
-    await writeWorkspaceStore(laterSupersessionRoot, [original, replacement, later]);
-    await appendEvidenceEvents(laterSupersessionRoot, [replacementEvidence(original, replacement)]);
-    await assert.rejects(
-      runMemoryDiagResult(["revert", "--workspace", laterSupersessionRoot, "--memory", replacement.id]),
-      (error: unknown) => {
-        const err = error as { stderr?: string };
-        assert.match(err.stderr ?? "", /revert rejected: replacement memory mem-replacement is superseded by active memory mem-later/);
-        return true;
-      },
-    );
-
-    const [wrongEvent] = await appendEvidenceEvents(wrongEventRoot, [evidence({ type: "promotion_promoted", phase: "promotion", outcome: "promoted" })]);
-    await assert.rejects(
-      runMemoryDiagResult(["revert", "--workspace", wrongEventRoot, "--event", wrongEvent.eventId]),
-      (error: unknown) => {
-        const err = error as { stderr?: string };
-        assert.match(err.stderr ?? "", /revert rejected: event .* is not a memory_replaced_numbered_ref event/);
-        return true;
-      },
-    );
-  } finally {
-    await rm(missingOriginalRoot, { recursive: true, force: true });
-    await rm(replacementSupersededRoot, { recursive: true, force: true });
-    await rm(laterSupersessionRoot, { recursive: true, force: true });
-    await rm(wrongEventRoot, { recursive: true, force: true });
-  }
-});
-
 test("memory health reports dormancy and retention monitoring deprecations", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-"));
  try {
@@ -527,14 +122,15 @@ test("memory health reports dormancy and retention monitoring deprecations", asy
    }));
    await writeWorkspaceStore(root, entries, { lastActivityAt });

-    const stdout = await runMemoryDiagStatusVerbose(root);
+    const stdout = await runMemoryDiagHealth(root);

    assert.match(stdout, /Dormancy:/);
    assert.match(stdout, /wall days since activity: 19\.0/);
    assert.match(stdout, /dormant discount active: yes/);
    assert.match(stdout, /dormant days past grace: 5\.0/);
-    assert.match(stdout, /Top rendered candidates:/);
-    assert.match(stdout, /Weakest active memories:/);
+    assert.match(stdout, /high_importance_ratio: 40\.0% .* ALERT/);
+    assert.match(stdout, /safety_critical_count: 6 .*deprecated.* WARNING/);
+    assert.match(stdout, /max_reinforced_count: 2 \(20\.0%, alert > 10%\) ALERT/);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
@@ -551,9 +147,9 @@ test("memory health reports global cap overflow separately from type caps", asyn
    ];
    await writeWorkspaceStore(root, entries);

-    const stdout = await runMemoryDiagStatusVerbose(root);
+    const stdout = await runMemoryDiagHealth(root);

-    assert.match(stdout, /rendered: 28/);
+    assert.match(stdout, /Rendered candidates: 28/);
    assert.match(stdout, /type-capped entries: 0/);
    assert.match(stdout, /global-cap overflow: 6/);
  } finally {
@@ -566,13 +162,14 @@ test("memory health reports missing dormancy and non-alert monitoring defaults",
  try {
    await writeWorkspaceStore(root, [], { omitLastActivityAt: true });

-    const stdout = await runMemoryDiagStatusVerbose(root);
+    const stdout = await runMemoryDiagHealth(root);

    assert.match(stdout, /lastActivityAt: \(missing\)/);
    assert.match(stdout, /wall days since activity: unknown/);
    assert.match(stdout, /dormant discount active: no/);
-    assert.match(stdout, /Top rendered candidates:\n\s+\(none\)/);
-    assert.match(stdout, /Weakest active memories:\n\s+\(none\)/);
+    assert.match(stdout, /high_importance_ratio: 0\.0% \(alert > 30%\)\n/);
+    assert.match(stdout, /safety_critical_count: 0 \(deprecated field\)\n/);
+    assert.match(stdout, /max_reinforced_count: 0 \(alert > 10% active\)/);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
@@ -594,8 +191,8 @@ test("memory health --json prints parseable privacy-safe diagnostics matching hu
      evidence({ type: "render_selected", phase: "render", outcome: "rendered", memory: { memoryId: "mem-rendered", type: "feedback", source: "explicit", status: "active" }, reasonCodes: ["within_caps", "within_char_budget"] }),
    ]);

-    const human = await runMemoryDiagStatusVerbose(root);
-    const jsonText = await runMemoryDiag(["status", "--workspace", root, "--json"]);
+    const human = await runMemoryDiagHealth(root);
+    const jsonText = await runMemoryDiag(["health", "--workspace", root, "--json"]);
    const parsed = JSON.parse(jsonText) as {
      version: 1;
      summary: { storedActive: number; rendered: number; pending: number; rejectedLast7Days: number; corruptStoresQuarantinedLast30Days: number };
@@ -604,9 +201,9 @@ test("memory health --json prints parseable privacy-safe diagnostics matching hu
    };

    assert.equal(parsed.version, 1);
-    assert.equal(parsed.summary.storedActive, Number(human.match(/active: (\d+) \/ 28/)?.[1]));
-    assert.equal(parsed.summary.rendered, Number(human.match(/rendered: (\d+)/)?.[1]));
-    assert.equal(parsed.summary.pending, 1);
+    assert.equal(parsed.summary.storedActive, Number(human.match(/Stored active memories: (\d+)/)?.[1]));
+    assert.equal(parsed.summary.rendered, Number(human.match(/Rendered candidates: (\d+)/)?.[1]));
+    assert.equal(parsed.summary.pending, Number(human.match(/Pending journal:\n\s+total: (\d+)/)?.[1]));
    assert.equal(parsed.summary.rejectedLast7Days, 1);
    assert.equal(parsed.summary.corruptStoresQuarantinedLast30Days, 1);
    assert.ok(parsed.recentEvents.some(event => event.eventId && event.type === "render_selected" && event.outcome === "rendered" && event.createdAt && event.reasonCodes.includes("within_caps")));
@@ -666,7 +263,7 @@ test("memory-diag explain shows rendered, omitted, pending, and evidence reason
  }
 });

-test("memory-diag explain --memory prints lifecycle relations and redacts secrets", async () => {
+test("memory-diag trace prints lifecycle relations and redacts secrets", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-trace-"));
  try {
    await writeWorkspaceStore(root, [
@@ -682,7 +279,7 @@ test("memory-diag explain --memory prints lifecycle relations and redacts secret
      evidence({ type: "render_omitted", phase: "render", outcome: "omitted", memory: { memoryId: "mem-life", type: "decision", source: "compaction" }, relations: [{ role: "omitted", memory: { memoryId: "mem-life" } }], reasonCodes: ["superseded"] }),
    ]);

-    const stdout = await runMemoryDiag(["explain", "--workspace", root, "--memory", "mem-life"]);
+    const stdout = await runMemoryDiag(["trace", "--workspace", root, "--memory", "mem-life"]);

    assert.match(stdout, /Memory mem-life: omitted_superseded/);
    assert.match(stdout, /Lifecycle:/);
@@ -698,34 +295,21 @@ test("memory-diag explain --memory prints lifecycle relations and redacts secret
  }
 });

-test("memory-diag explain positional memory id prints lifecycle", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-explain-positional-"));
-  try {
-    await writeWorkspaceStore(root, [
-      { ...entry("mem-life", "Old token password: sushi should be redacted", "decision"), status: "superseded" as const },
-      entry("mem-new", "Replacement memory", "decision"),
-    ]);
-    await appendEvidenceEvents(root, [
-      evidence({ type: "extraction_candidate_accepted", phase: "extraction", outcome: "accepted", memory: { memoryId: "mem-life", type: "decision", source: "compaction" }, reasonCodes: ["quality_gate_passed"], textPreview: "password: sushi" }),
-      evidence({ type: "promotion_superseded", phase: "promotion", outcome: "superseded", memory: { memoryId: "mem-life", type: "decision", source: "compaction" }, relations: [{ role: "superseded_by", memory: { memoryId: "mem-new" } }], reasonCodes: ["superseded_existing"] }),
-    ]);
-
-    const stdout = await runMemoryDiag(["explain", "mem-life", "--workspace", root]);
-
-    assert.match(stdout, /Memory mem-life: omitted_superseded/);
-    assert.match(stdout, /Lifecycle:/);
-    assert.match(stdout, /promotion_superseded: superseded; reasons=superseded_existing; .*superseded_by=mem-new/);
-    assert.match(stdout, /Superseded by:\n- mem-new/);
-    assert.ok(!stdout.includes("sushi"));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("memory-diag explain --memory reports unknown IDs", async () => {
+test("memory-diag trace requires --memory and reports unknown IDs", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-trace-unknown-"));
  try {
-    const stdout = await runMemoryDiag(["explain", "--workspace", root, "--memory", "missing-memory"]);
+    await assert.rejects(
+      execFileAsync(process.execPath, ["--experimental-strip-types", "scripts/memory-diag.ts", "trace", "--workspace", root], { cwd: repoRoot }),
+      (error: unknown) => {
+        const err = error as { code?: number; stderr?: string };
+        assert.notEqual(err.code, 0);
+        assert.match(err.stderr ?? "", /--memory requires an id/);
+        assert.match(err.stderr ?? "", /Usage:/);
+        return true;
+      },
+    );
+
+    const stdout = await runMemoryDiag(["trace", "--workspace", root, "--memory", "missing-memory"]);
    assert.match(stdout, /Memory missing-memory: unknown/);
    assert.match(stdout, /Lifecycle:\n\(none\)/);
  } finally {
@@ -753,15 +337,15 @@ async function setupQualityFixture(): Promise<string> {
  return root;
 }

-test("status verbose output includes summary and aggregate inspection counts", async () => {
+test("quality human output includes summary and aggregate inspection counts", async () => {
  const root = await setupQualityFixture();
  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--verbose"]);
+    const stdout = await runMemoryDiag(["quality", "--workspace", root]);

-    assert.match(stdout, /Memory status inspection/);
+    assert.match(stdout, /Memory quality inspection/);
    assert.match(stdout, /Summary: Workspace memory quality is degraded:/);
    assert.match(stdout, /Caps:\n\s+active: 28 \/ 28/);
-    assert.match(stdout, /decision: 14 \/ 12 FULL/);
+    assert.match(stdout, /decision: 14 \/ 10 FULL/);
    assert.match(stdout, /feedback: 14 \/ 10 FULL/);
    assert.match(stdout, /Retention clocks:\n\s+present: 27\n\s+missing: 0\n\s+invalid: 1/);
    assert.match(stdout, /Evidence:\n\s+current with evidence: 1\n\s+current without evidence: 27/);
@@ -771,106 +355,26 @@ test("status verbose output includes summary and aggregate inspection counts", a
  }
 });

-test("status --json includes summary status fields", async () => {
+test("quality --json includes summaryText, caps, retention, evidence, and rejections", async () => {
  const root = await setupQualityFixture();
  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--json"]);
+    const stdout = await runMemoryDiag(["quality", "--workspace", root, "--json"]);
    const parsed = JSON.parse(stdout) as {
-      summary: { storedActive: number; status: string; evidenceCoveragePercent: number; needsAttention: string[] };
+      summaryText: string;
+      caps: { active: number; capsFull: boolean };
+      retention: { invalid: number };
+      evidence: { currentWithEvidence: number; unknownDisappearances: number };
+      rejections: { workspaceScopedCount: number; legacyUnscopedCount: number };
    };

-    assert.equal(parsed.summary.storedActive, LONG_TERM_LIMITS.maxEntries);
-    assert.equal(parsed.summary.status, "degraded");
-    assert.equal(typeof parsed.summary.evidenceCoveragePercent, "number");
-    assert.ok(parsed.summary.needsAttention.length > 0);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status default output is concise and actionable", async () => {
-  const root = await setupQualityFixture();
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root]);
-
-    assert.match(stdout, /OK Memory status|WARNING Memory status|DEGRADED Memory status/);
-    assert.match(stdout, /Key metrics:/);
-    assert.match(stdout, /active memories:/);
-    assert.match(stdout, /rendered:/);
-    assert.match(stdout, /pending:/);
-    assert.match(stdout, /rejected 7d:/);
-    assert.match(stdout, /evidence coverage:/);
-    assert.match(stdout, /Needs attention:/);
-    assert.match(stdout, /Suggested next steps:/);
-    assert.doesNotMatch(stdout, /Caps:|Retention clocks:|Rejection scoping:|Dormancy:/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status --verbose includes detailed diagnostics", async () => {
-  const root = await setupQualityFixture();
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--verbose"]);
-
-    assert.match(stdout, /Memory status inspection/);
-    assert.match(stdout, /Caps:/);
-    assert.match(stdout, /Retention clocks:/);
-    assert.match(stdout, /Evidence:/);
-    assert.match(stdout, /Rejection scoping:/);
-    assert.match(stdout, /Dormancy:/);
-    assert.match(stdout, /Top rendered candidates:/);
-    assert.match(stdout, /Weakest active memories:/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status --json includes additive summary fields", async () => {
-  const root = await setupQualityFixture();
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--json"]);
-    const parsed = JSON.parse(stdout) as {
-      version: 1;
-      summary: {
-        storedActive: number;
-        rendered: number;
-        pending: number;
-        rejectedLast7Days: number;
-        corruptStoresQuarantinedLast30Days: number;
-        status?: string;
-        evidenceCoveragePercent?: number;
-        needsAttention?: string[];
-        suggestedNextSteps?: string[];
-      };
-      memories: unknown[];
-      recentEvents: unknown[];
-    };
-
-    assert.equal(parsed.version, 1);
-    assert.equal(typeof parsed.summary.storedActive, "number");
-    assert.equal(typeof parsed.summary.rendered, "number");
-    assert.equal(typeof parsed.summary.pending, "number");
-    assert.equal(typeof parsed.summary.rejectedLast7Days, "number");
-    assert.equal(typeof parsed.summary.corruptStoresQuarantinedLast30Days, "number");
-    assert.match(parsed.summary.status ?? "", /ok|warning|degraded/);
-    assert.equal(typeof parsed.summary.evidenceCoveragePercent, "number");
-    assert.ok(Array.isArray(parsed.summary.needsAttention));
-    assert.ok(Array.isArray(parsed.summary.suggestedNextSteps));
-    assert.ok(Array.isArray(parsed.memories));
-    assert.ok(Array.isArray(parsed.recentEvents));
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("status non-tty and --no-emoji use text labels", async () => {
-  const root = await setupQualityFixture();
-  try {
-    const stdout = await runMemoryDiag(["status", "--workspace", root, "--no-emoji"]);
-
-    assert.match(stdout, /^DEGRADED Memory status/);
-    assert.doesNotMatch(stdout, /🧠|⚠️|✖️/);
+    assert.match(parsed.summaryText, /Workspace memory quality is degraded/);
+    assert.equal(parsed.caps.active, LONG_TERM_LIMITS.maxEntries);
+    assert.equal(parsed.caps.capsFull, true);
+    assert.equal(parsed.retention.invalid, 1);
+    assert.equal(parsed.evidence.currentWithEvidence, 1);
+    assert.equal(parsed.evidence.unknownDisappearances, 1);
+    assert.equal(parsed.rejections.workspaceScopedCount, 1);
+    assert.equal(parsed.rejections.legacyUnscopedCount, 1);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
@@ -924,7 +428,7 @@ test("coverage --json includes event counts", async () => {
  }
 });

-test("missing default output summarizes unknown disappearances", async () => {
+test("disappearances labels historical evidence-only memory unknown without terminal event", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-disappear-"));
  try {
    await writeWorkspaceStore(root, [entry("current", "Current memory", "feedback")]);
@@ -932,21 +436,15 @@ test("missing default output summarizes unknown disappearances", async () => {
      evidence({ type: "promotion_promoted", phase: "promotion", outcome: "promoted", memory: { memoryId: "historical-unknown", type: "decision", source: "compaction" }, reasonCodes: ["new_workspace_entry"] }),
    ]);

-    const stdout = await runMemoryDiag(["missing", "--workspace", root]);
+    const stdout = await runMemoryDiag(["disappearances", "--workspace", root]);

-    assert.match(stdout, /Missing memory summary/);
-    assert.match(stdout, /Total missing: 1/);
-    assert.match(stdout, /Explained: 0/);
-    assert.match(stdout, /Needs review: 1/);
-    assert.match(stdout, /Unknown disappearance samples:/);
-    assert.match(stdout, /- historical-unknown terminal=unknown reasons=none/);
-    assert.doesNotMatch(stdout, /Memory historical-unknown:/);
+    assert.match(stdout, /Memory historical-unknown: historical_absent_unknown_reason terminal=unknown/);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
 });

-test("missing --verbose shows capacity details and render omitted type-cap observations", async () => {
+test("disappearances --explain shows capacity details and render omitted type-cap observations", async () => {
  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-disappear-explain-"));
  try {
    await writeWorkspaceStore(root, [entry("current", "Current memory", "feedback")]);
@@ -963,11 +461,9 @@ test("missing --verbose shows capacity details and render omitted type-cap obser
      evidence({ type: "render_omitted", phase: "render", outcome: "omitted", memory: { memoryId: "render-loser", type: "feedback", source: "compaction" }, reasonCodes: ["type_cap"] }),
    ]);

-    const stdout = await runMemoryDiag(["missing", "--workspace", root, "--verbose"]);
+    const stdout = await runMemoryDiag(["disappearances", "--workspace", root, "--explain"]);

-    assert.match(stdout, /Missing memory summary/);
    assert.match(stdout, /capacity-loser: historical_absent_with_reason terminal=memory_removed_capacity reasons=type_cap/);
-    assert.match(stdout, /events:/);
    assert.match(stdout, /memory_removed_capacity details: .*globalCap=28 .*typeCap=10/);
    assert.match(stdout, /render-loser: historical_absent_with_reason terminal=render_omitted reasons=type_cap/);
    assert.match(stdout, /render_omitted type-cap observation: reasons=type_cap/);
@@ -976,92 +472,50 @@ test("missing --verbose shows capacity details and render omitted type-cap obser
  }
 });

-test("missing --json includes disappearances and additive summary", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-missing-json-"));
+test("rejections --quality --reason bad_decision --unique groups architecture-like samples heuristically", async () => {
+  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-rejections-quality-"));
  try {
-    await writeWorkspaceStore(root, [entry("current", "Current memory", "feedback")]);
-    await appendEvidenceEvents(root, [
-      evidence({ type: "promotion_promoted", phase: "promotion", outcome: "promoted", memory: { memoryId: "historical-unknown", type: "decision", source: "compaction" }, reasonCodes: ["new_workspace_entry"] }),
+    const key = await workspaceKey(root);
+    const now = new Date().toISOString();
+    await writeRejectionRecords([
+      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Retention scoring model uses evidence caps to avoid normalization drift", reasons: ["bad_decision"] },
+      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Implemented phase 2 and updated tests", reasons: ["bad_decision"] },
+      { timestamp: now, type: "decision", source: "compaction", text: "Maybe useful", reasons: ["bad_decision"] },
    ]);

-    const stdout = await runMemoryDiag(["missing", "--workspace", root, "--json"]);
-    const parsed = JSON.parse(stdout) as { disappearances: Array<{ id: string }>; summary: { total: number; explained: number; needsReview: number } };
+    const stdout = await runMemoryDiag(["rejections", "--quality", "--workspace", root, "--reason", "bad_decision", "--unique"]);

-    assert.equal(parsed.summary.total, 1);
-    assert.equal(parsed.summary.explained, 0);
-    assert.equal(parsed.summary.needsReview, 1);
-    assert.equal(parsed.disappearances[0]?.id, "historical-unknown");
+    assert.match(stdout, /Possible false-positive grouping is heuristic, not deterministic truth/);
+    assert.match(stdout, /architecture_like_possible_false_positive: 1/);
+    assert.match(stdout, /clearly_garbage: 1/);
+    assert.match(stdout, /ambiguous: 1/);
+    assert.doesNotMatch(stdout, /deterministic truth\s*:/);
  } finally {
    await rm(root, { recursive: true, force: true });
  }
 });

-test("rejected default output is concise with top reasons and samples", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-rejected-"));
+test("rejections --quality --json includes scoping, unique reasons, and possible false-positive groups", async () => {
+  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-rejections-json-"));
  try {
    const key = await workspaceKey(root);
    const now = new Date().toISOString();
    await writeRejectionRecords([
-      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Keep memory system boundary stable", reasons: ["bad_decision"] },
-      { timestamp: now, workspaceKey: key, type: "feedback", source: "explicit", text: "Remember password: sushi from rejected sample", reasons: ["raw_secret", "bad_feedback"] },
-      { timestamp: "2020-01-01T00:00:00.000Z", workspaceKey: key, type: "project", source: "manual", text: "Old rejected sample", reasons: ["bad_project"] },
+      { timestamp: now, workspaceKey: key, workspaceRootHash: "hash", type: "decision", source: "compaction", text: "Memory system schema boundary should remain stable", reasons: ["bad_decision"] },
+      { timestamp: now, type: "feedback", source: "compaction", text: "Wave 1 completed successfully", reasons: ["progress_snapshot", "bad_feedback"] },
    ]);

-    const stdout = await runMemoryDiag(["rejected", "--workspace", root]);
+    const stdout = await runMemoryDiag(["rejections", "--quality", "--workspace", root, "--json"]);
+    const parsed = JSON.parse(stdout) as {
+      workspaceScopedCount: number;
+      legacyUnscopedCount: number;
+      uniqueReasonDistribution: Record<string, number>;
+      possibleFalsePositiveGroups: Record<string, { count: number }>;
+    };

-    assert.match(stdout, /Rejected memory summary/);
-    assert.match(stdout, /Total rejected: 3/);
-    assert.match(stdout, /Unique texts: 3/);
-    assert.match(stdout, /Top reasons:/);
-    assert.match(stdout, /bad_decision\s+1/);
-    assert.match(stdout, /False-positive risk: low/);
-    assert.match(stdout, /Recent samples:/);
-    assert.match(stdout, /\[decision\] Keep memory system boundary stable/);
-    assert.ok(!stdout.includes("sushi"));
-    assert.doesNotMatch(stdout, /By origin:|Reason distribution \(raw records\):|Possible false-positive groups/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("rejected --verbose includes detailed distributions", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-rejected-verbose-"));
-  try {
-    const key = await workspaceKey(root);
-    const now = new Date().toISOString();
-    await writeRejectionRecords([
-      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Memory system schema boundary should remain stable", reasons: ["bad_decision"] },
-      { timestamp: now, workspaceKey: key, type: "feedback", source: "explicit", text: "Status update completed", reasons: ["bad_feedback"] },
-    ]);
-
-    const stdout = await runMemoryDiag(["rejected", "--workspace", root, "--verbose"]);
-
-    assert.match(stdout, /Rejected memory summary/);
-    assert.match(stdout, /Reason distribution \(raw records\):/);
-    assert.match(stdout, /Reason distribution \(unique text\):/);
-    assert.match(stdout, /By origin:/);
-    assert.match(stdout, /Possible false-positive groups \(heuristic, not deterministic\):/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("rejected --json includes quality summary and false-positive risk", async () => {
-  const root = await mkdtemp(join(tmpdir(), "opencode-memory-diag-rejected-json-"));
-  try {
-    const key = await workspaceKey(root);
-    const now = new Date().toISOString();
-    await writeRejectionRecords([
-      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Memory system schema boundary should remain stable", reasons: ["bad_decision"] },
-      { timestamp: now, workspaceKey: key, type: "decision", source: "compaction", text: "Memory system schema boundary should remain stable", reasons: ["bad_decision"] },
-    ]);
-
-    const stdout = await runMemoryDiag(["rejected", "--workspace", root, "--json"]);
-    const parsed = JSON.parse(stdout) as { totalRecords: number; uniqueTexts: number; falsePositiveRisk: string; possibleFalsePositiveGroups: Record<string, { count: number }> };
-
-    assert.equal(parsed.totalRecords, 2);
-    assert.equal(parsed.uniqueTexts, 1);
-    assert.equal(parsed.falsePositiveRisk, "high");
+    assert.equal(parsed.workspaceScopedCount, 1);
+    assert.equal(parsed.legacyUnscopedCount, 1);
+    assert.equal(parsed.uniqueReasonDistribution.bad_decision, 1);
    assert.equal(parsed.possibleFalsePositiveGroups.architecture_like_possible_false_positive.count, 1);
  } finally {
    await rm(root, { recursive: true, force: true });
@@ -35,18 +35,6 @@ const acceptedCases = [
    expectedType: "reference",
    expectedText: /bracketless/,
  },
-  {
-    name: "stable URL query reference",
-    line: "- [reference] Memory diagnostics dashboard URL is https://example.test/search?q=memory&view=summary",
-    expectedType: "reference",
-    expectedText: /search\?q=memory/,
-  },
-  {
-    name: "bilingual stable rule",
-    line: "- [decision] 使用 durable evidence records 保持 memory command auditability",
-    expectedType: "decision",
-    expectedText: /保持 memory command auditability/,
-  },
 ] as const;

 const rejectedCases = [
@@ -90,34 +78,6 @@ const rejectedCases = [
    name: "session internal review note",
    line: "- [feedback] The assistant reviewed the code reviewer feedback and updated the plan",
  },
-  {
-    name: "unresolved question suffix",
-    line: "- [project] Should we add semantic merge to workspace memory?",
-  },
-  {
-    name: "unresolved question prefix",
-    line: "- [reference] TODO: decide whether to keep this migration path",
-  },
-  {
-    name: "unresolved Chinese question",
-    line: "- [decision] 需要決定是否要增加新的記憶壓縮策略",
-  },
-  {
-    name: "transient bug state",
-    line: "- [project] Tests are failing and the next step is to fix the retry path",
-  },
-  {
-    name: "Chinese transient bug state",
-    line: "- [reference] 目前正在 debug storage lock failure，暫時 workaround 待修",
-  },
-  {
-    name: "deployment snapshot",
-    line: "- [reference] Latest deployed revision is rev-a8F3kL9pQ2xZ7bN4",
-  },
-  {
-    name: "Chinese deployment snapshot",
-    line: "- [project] 目前部署版本 build-9f8A7c6D5e4F3g2H 是 active release",
-  },
 ] as const;

 for (const item of acceptedCases) {
@@ -165,57 +125,6 @@ test("progress snapshot rejection is type independent", () => {
  }
 });

-test("new v1.6 hard quality reasons are emitted by concrete heuristics", () => {
-  const cases = [
-    {
-      reason: "unresolved_question",
-      entry: { type: "reference" as const, text: "Open question: whether to keep legacy prompt rendering", source: "compaction" as const },
-    },
-    {
-      reason: "unresolved_question",
-      entry: { type: "project" as const, text: "We need to decide storage migration order?", source: "compaction" as const },
-    },
-    {
-      reason: "transient_bug_state",
-      entry: { type: "project" as const, text: "Currently debugging memory replacement and tests are failing", source: "compaction" as const },
-    },
-    {
-      reason: "deployment_snapshot",
-      entry: { type: "reference" as const, text: "Current active release build is build-X9kLmN42pQ7rT6z", source: "compaction" as const },
-    },
-  ];
-
-  for (const { reason, entry } of cases) {
-    const result = assessMemoryQuality(entry);
-    assert.equal(result.accepted, false, `${entry.text} should reject`);
-    assert.ok(result.reasons.includes(reason), `${entry.text} -> ${result.reasons.join(",")}`);
-  }
-});
-
-test("unresolved question guardrails preserve stable URL queries and durable rules", () => {
-  const urlResult = assessMemoryQuality({
-    type: "reference",
-    text: "Memory dashboard URL is https://example.test/search?q=memory&view=summary",
-    source: "compaction",
-  });
-  assert.equal(urlResult.reasons.includes("unresolved_question"), false, urlResult.reasons.join(","));
-  assert.equal(urlResult.accepted, true);
-
-  const durableRule = assessMemoryQuality({
-    type: "decision",
-    text: "Use verifier questions only when acceptance evidence is missing?",
-    source: "compaction",
-  });
-  assert.equal(durableRule.reasons.includes("unresolved_question"), false, durableRule.reasons.join(","));
-});
-
-test("terse_label is diagnostic only and does not block quality acceptance", () => {
-  const result = assessMemoryQuality({ type: "reference", text: "Cache key", source: "compaction" });
-  assert.equal(result.accepted, true);
-  assert.deepEqual(result.reasons, []);
-  assert.ok(result.diagnostics?.includes("terse_label"));
-});
-
 test("feedback must be stable user preference or instruction", () => {
  assert.equal(assessMemoryQuality({ type: "feedback", text: "User prefers concise architecture reviews", source: "compaction" }).accepted, true);
  assert.equal(assessMemoryQuality({ type: "feedback", text: "Implemented owner-aware cleanup in plugin.ts", source: "compaction" }).accepted, false);
@@ -287,11 +196,7 @@ test("hard quality reasons exclude soft whitelist failures", () => {
  assert.equal(isHardQualityReason("code_or_api_signature"), true);
  assert.equal(isHardQualityReason("path_heavy"), true);
  assert.equal(isHardQualityReason("empty"), true);
-  assert.equal(isHardQualityReason("unresolved_question"), true);
-  assert.equal(isHardQualityReason("transient_bug_state"), true);
-  assert.equal(isHardQualityReason("deployment_snapshot"), true);

  assert.equal(isHardQualityReason("bad_feedback"), false);
  assert.equal(isHardQualityReason("bad_decision"), false);
-  assert.equal(isHardQualityReason("terse_label"), false);
 });
@@ -1,363 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { MemoryV2Plugin } from "../src/plugin.ts";
-import * as sessionStateModule from "../src/session-state.ts";
-import type { HotSessionStateRenderAccounting } from "../src/session-state.ts";
-import { sessionStatePath, workspaceMemoryPath } from "../src/paths.ts";
-import type { ActiveFile, CompactionMemoryRef, LongTermMemoryEntry, OpenError, SessionDecision, SessionState } from "../src/types.ts";
-import { HOT_STATE_LIMITS, LONG_TERM_LIMITS } from "../src/types.ts";
-
-type AccountHotSessionStateRender = (state: SessionState, workspaceRoot: string) => HotSessionStateRenderAccounting;
-
-const accountHotSessionStateRender = (
-  sessionStateModule as typeof sessionStateModule & { accountHotSessionStateRender: AccountHotSessionStateRender }
-).accountHotSessionStateRender;
-
-const { createEmptySessionState, loadSessionState, renderHotSessionState, saveSessionState } = sessionStateModule;
-
-const root = "/repo";
-
-function state(overrides: Partial<SessionState> = {}): SessionState {
-  return {
-    version: 1,
-    sessionID: "session-state-test",
-    turn: 0,
-    updatedAt: "2026-05-05T00:00:00.000Z",
-    activeFiles: [],
-    openErrors: [],
-    recentDecisions: [],
-    pendingMemories: [],
-    compactionMemoryRefs: [],
-    ...overrides,
-  };
-}
-
-function compactionRef(index: number, overrides: Partial<CompactionMemoryRef> = {}): CompactionMemoryRef {
-  return {
-    ref: `M${index}`,
-    memoryId: `memory-${index}`,
-    type: "decision",
-    source: "compaction",
-    exactKey: `decision:durable fact ${index}`,
-    identityKey: `decision:durable fact ${index}`,
-    textPreview: `Durable fact ${index}`,
-    capturedAt: 1_777_000_000_000 + index,
-    ...overrides,
-  };
-}
-
-function mockRootClient(summary = "") {
-  return {
-    session: {
-      get: async () => ({ data: { parentID: null } }),
-      messages: async () => ({
-        data: summary
-          ? [{ info: { role: "assistant", summary: true }, parts: [{ type: "text", text: summary }] }]
-          : [],
-      }),
-      todo: async () => ({ data: [] }),
-    },
-  };
-}
-
-function activeFile(path: string, action: ActiveFile["action"], count: number, lastSeen: number): ActiveFile {
-  return { path, action, count, lastSeen };
-}
-
-function openError(id: string, summary: string, lastSeen: number): OpenError {
-  return {
-    id,
-    category: "test",
-    summary,
-    fingerprint: `fingerprint-${id}`,
-    status: "open",
-    firstSeen: lastSeen - 1,
-    lastSeen,
-    seenCount: 1,
-  };
-}
-
-function decision(id: string, text: string, createdAt: number): SessionDecision {
-  return { id, text, source: "assistant", createdAt };
-}
-
-function memory(id: string, text: string, type: LongTermMemoryEntry["type"] = "decision"): LongTermMemoryEntry {
-  return {
-    id,
-    type,
-    text,
-    source: "compaction",
-    confidence: 0.75,
-    status: "active",
-    createdAt: "2026-05-05T00:00:00.000Z",
-    updatedAt: "2026-05-05T00:00:00.000Z",
-  };
-}
-
-test("accountHotSessionStateRender returns empty prompt and no omissions for empty state", () => {
-  const accounting = accountHotSessionStateRender(createEmptySessionState("empty-session"), root);
-
-  assert.equal(accounting.prompt, "");
-  assert.deepEqual(accounting.omitted, []);
-  assert.equal(accounting.maxRenderedChars, HOT_STATE_LIMITS.maxRenderedChars);
-});
-
-test("accountHotSessionStateRender renders hot-state sections in stable order", () => {
-  const accounting = accountHotSessionStateRender(state({
-    activeFiles: [activeFile("/repo/src/a.ts", "read", 1, 1)],
-    openErrors: [openError("err-1", "one failing test", 2)],
-    recentDecisions: [decision("dec-1", "Keep renderer simple", 3)],
-    pendingMemories: [memory("mem-1", "Promote useful fact")],
-  }), root);
-
-  assert.ok(accounting.prompt.startsWith("Hot session state (current session):"));
-  assert.ok(accounting.prompt.indexOf("active_files:") < accounting.prompt.indexOf("open_errors:"));
-  assert.ok(accounting.prompt.indexOf("open_errors:") < accounting.prompt.indexOf("recent_decisions:"));
-  assert.ok(accounting.prompt.indexOf("recent_decisions:") < accounting.prompt.indexOf("pending_memories:"));
-});
-
-test("accountHotSessionStateRender ranks active files by score then lastSeen descending", () => {
-  const accounting = accountHotSessionStateRender(state({
-    activeFiles: [
-      activeFile("/repo/src/edit.ts", "edit", 1, 400),
-      activeFile("/repo/src/write.ts", "write", 5, 200),
-      activeFile("/repo/src/grep.ts", "grep", 10, 300),
-      activeFile("/repo/src/read.ts", "read", 12, 100),
-    ],
-  }), root);
-
-  const lines = accounting.prompt.split("\n");
-  const activeLines = lines.filter(line => line.startsWith("- src/"));
-  assert.deepEqual(activeLines, [
-    "- src/grep.ts (grep, 10x)",
-    "- src/write.ts (write, 5x)",
-    "- src/read.ts (read, 12x)",
-    "- src/edit.ts (edit, 1x)",
-  ]);
-});
-
-test("accountHotSessionStateRender reports section-cap omissions for every capped section", () => {
-  const accounting = accountHotSessionStateRender(state({
-    activeFiles: Array.from({ length: 9 }, (_, index) => activeFile(`/repo/a${index}.ts`, "read", 1, 100 - index)),
-    openErrors: Array.from({ length: 4 }, (_, index) => openError(`err-${index}`, `e${index}`, 100 - index)),
-    recentDecisions: Array.from({ length: 9 }, (_, index) => decision(`dec-${index}`, `d${index}`, index)),
-    pendingMemories: Array.from({ length: 7 }, (_, index) => memory(`mem-${index}`, `m${index}`)),
-  }), root);
-
-  const sectionCapOmissions = accounting.omitted.filter(item => item.reason === "section_cap");
-  assert.deepEqual(
-    sectionCapOmissions.map(item => item.section).sort(),
-    ["active_files", "open_errors", "pending_memories", "recent_decisions"].sort(),
-  );
-  assert.equal(sectionCapOmissions.find(item => item.section === "pending_memories")?.memoryId, "mem-0");
-});
-
-test("accountHotSessionStateRender omits over-budget entries without cutting rendered lines", () => {
-  const longPath = `/repo/${"x".repeat(650)}.ts`;
-  const accounting = accountHotSessionStateRender(state({
-    activeFiles: [
-      activeFile("/repo/src/short.ts", "read", 1, 20),
-      activeFile(longPath, "read", 1, 10),
-    ],
-  }), root);
-
-  assert.equal(accounting.prompt, [
-    "Hot session state (current session):",
-    "active_files:",
-    "- src/short.ts (read, 1x)",
-  ].join("\n"));
-  assert.equal(accounting.omitted.length, 1);
-  assert.equal(accounting.omitted[0]?.reason, "char_budget");
-  assert.equal(accounting.omitted[0]?.section, "active_files");
-  assert.ok(!accounting.prompt.includes("x".repeat(20)));
-});
-
-test("accountHotSessionStateRender includes exact 700-char prompt but omits one additional character", () => {
-  const fixedPrompt = [
-    "Hot session state (current session):",
-    "pending_memories:",
-    "- [decision] ",
-  ].join("\n");
-  const exactText = "x".repeat(HOT_STATE_LIMITS.maxRenderedChars - fixedPrompt.length);
-  const exactAccounting = accountHotSessionStateRender(state({
-    pendingMemories: [memory("mem-exact", exactText)],
-  }), root);
-
-  assert.equal(exactAccounting.prompt.length, HOT_STATE_LIMITS.maxRenderedChars);
-  assert.equal(exactAccounting.omitted.length, 0);
-
-  const overAccounting = accountHotSessionStateRender(state({
-    pendingMemories: [memory("mem-over", `${exactText}y`)],
-  }), root);
-
-  assert.equal(overAccounting.prompt, "");
-  assert.equal(overAccounting.omitted.length, 1);
-  assert.equal(overAccounting.omitted[0]?.reason, "char_budget");
-  assert.equal(overAccounting.omitted[0]?.memoryId, "mem-over");
-});
-
-test("accountHotSessionStateRender suppresses header-only sections when no entries fit", () => {
-  const accounting = accountHotSessionStateRender(state({
-    activeFiles: [activeFile(`/repo/${"z".repeat(720)}.ts`, "read", 1, 1)],
-  }), root);
-
-  assert.equal(accounting.prompt, "");
-  assert.equal(accounting.omitted.length, 1);
-  assert.equal(accounting.omitted[0]?.reason, "char_budget");
-  assert.ok(!accounting.prompt.includes("active_files:"));
-});
-
-test("renderHotSessionState delegates to accounted renderer prompt for empty and seeded states", () => {
-  const empty = createEmptySessionState("compat-empty");
-  const seeded = state({
-    activeFiles: [activeFile("/repo/src/a.ts", "edit", 2, 1)],
-    pendingMemories: [memory("mem-compat", "Compatibility prompt")],
-  });
-
-  assert.equal(renderHotSessionState(empty, root), accountHotSessionStateRender(empty, root).prompt);
-  assert.equal(renderHotSessionState(seeded, root), accountHotSessionStateRender(seeded, root).prompt);
-});
-
-test("accountHotSessionStateRender counts newline separators in the 700-char budget", () => {
-  const fixedPrompt = [
-    "Hot session state (current session):",
-    "recent_decisions:",
-    "- ",
-  ].join("\n");
-  const exactText = "n".repeat(HOT_STATE_LIMITS.maxRenderedChars - fixedPrompt.length);
-
-  const exactAccounting = accountHotSessionStateRender(state({
-    recentDecisions: [decision("dec-exact", exactText, 1)],
-  }), root);
-  assert.equal(exactAccounting.prompt.length, HOT_STATE_LIMITS.maxRenderedChars);
-  assert.equal(exactAccounting.omitted.length, 0);
-
-  const overAccounting = accountHotSessionStateRender(state({
-    recentDecisions: [decision("dec-over", `${exactText}!`, 1)],
-  }), root);
-  assert.equal(overAccounting.prompt, "");
-  assert.equal(overAccounting.omitted.length, 1);
-  assert.equal(overAccounting.omitted[0]?.reason, "char_budget");
-});
-
-test("compaction memory refs round-trip through session state and are capped", async () => {
-  const tmpDir = await mkdtemp(join(tmpdir(), "memory-session-state-"));
-
-  try {
-    const refs = Array.from({ length: LONG_TERM_LIMITS.maxEntries + 2 }, (_, index) => compactionRef(
-      index + 1,
-      index === 0 ? { compactionId: "compaction-snapshot-1" } : {},
-    ));
-    await saveSessionState(tmpDir, state({
-      sessionID: "compaction-ref-roundtrip",
-      compactionMemoryRefs: refs,
-    }));
-
-    const loaded = await loadSessionState(tmpDir, "compaction-ref-roundtrip");
-    assert.equal(loaded.compactionMemoryRefs.length, LONG_TERM_LIMITS.maxEntries);
-    assert.deepEqual(loaded.compactionMemoryRefs, refs.slice(0, LONG_TERM_LIMITS.maxEntries));
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
-  }
-});
-
-test("invalid stored compaction memory refs normalize to empty without crashing", async () => {
-  const tmpDir = await mkdtemp(join(tmpdir(), "memory-session-state-"));
-
-  try {
-    const path = await sessionStatePath(tmpDir, "invalid-compaction-ref-session");
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify({
-      version: 1,
-      sessionID: "stale-id",
-      turn: 0,
-      updatedAt: "2026-05-05T00:00:00.000Z",
-      activeFiles: [],
-      openErrors: [],
-      recentDecisions: [],
-      pendingMemories: [],
-      compactionMemoryRefs: [
-        compactionRef(1),
-        { ...compactionRef(2), ref: "not-a-numbered-ref" },
-      ],
-    }), "utf8");
-
-    const loaded = await loadSessionState(tmpDir, "invalid-compaction-ref-session");
-    assert.equal(loaded.sessionID, "invalid-compaction-ref-session");
-    assert.deepEqual(loaded.compactionMemoryRefs, []);
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
-  }
-});
-
-test("compaction memory refs never render in hot session state", () => {
-  const rendered = renderHotSessionState(state({
-    activeFiles: [activeFile("/repo/src/a.ts", "read", 1, 1)],
-    compactionMemoryRefs: [compactionRef(1, {
-      memoryId: "secret-memory-id",
-      exactKey: "decision:secret exact key",
-      identityKey: "decision:secret identity key",
-      textPreview: "Secret compaction ref preview must not render",
-    })],
-  }), root);
-
-  assert.match(rendered, /active_files:/);
-  assert.doesNotMatch(rendered, /Secret compaction ref preview/);
-  assert.doesNotMatch(rendered, /secret-memory-id/);
-  assert.doesNotMatch(rendered, /secret exact key/);
-  assert.doesNotMatch(rendered, /secret identity key/);
-  assert.doesNotMatch(rendered, /\bM1\b/);
-});
-
-test("session.compacted clears compaction memory refs after processing", async () => {
-  const tmpDir = await mkdtemp(join(tmpdir(), "memory-session-state-"));
-
-  try {
-    await saveSessionState(tmpDir, state({
-      sessionID: "clear-compaction-refs-session",
-      compactionMemoryRefs: [compactionRef(1)],
-    }));
-
-    const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
-    await (plugin as Record<string, Function>)["event"]({
-      event: { type: "session.compacted", properties: { sessionID: "clear-compaction-refs-session" } },
-    });
-
-    const loaded = await loadSessionState(tmpDir, "clear-compaction-refs-session");
-    assert.deepEqual(loaded.compactionMemoryRefs, []);
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
-  }
-});
-
-test("session.compacted clears compaction memory refs even when promotion fails", async () => {
-  const tmpDir = await mkdtemp(join(tmpdir(), "memory-session-state-"));
-
-  try {
-    await saveSessionState(tmpDir, state({
-      sessionID: "clear-compaction-refs-failure-session",
-      pendingMemories: [memory("mem-pending-failure", "Keep pending memory when promotion fails")],
-      compactionMemoryRefs: [compactionRef(1)],
-    }));
-
-    const workspacePath = await workspaceMemoryPath(tmpDir);
-    await rm(workspacePath, { force: true }).catch(() => undefined);
-    await mkdir(workspacePath, { recursive: true });
-
-    const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
-    await (plugin as Record<string, Function>)["event"]({
-      event: { type: "session.compacted", properties: { sessionID: "clear-compaction-refs-failure-session" } },
-    });
-
-    const loaded = await loadSessionState(tmpDir, "clear-compaction-refs-failure-session");
-    assert.deepEqual(loaded.compactionMemoryRefs, []);
-    assert.equal(loaded.pendingMemories.length, 1,
-      "unrelated retryable pending memory should remain on promotion failure");
-    assert.equal(loaded.pendingMemories[0].id, "mem-pending-failure");
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true });
-  }
-});
@@ -6,11 +6,9 @@ import { tmpdir } from "node:os";
 import type { LongTermMemoryEntry, WorkspaceMemoryStore } from "../src/types.ts";
 import { HOT_STATE_LIMITS, LONG_TERM_LIMITS } from "../src/types.ts";
 import { workspaceKey, workspaceMemoryPath } from "../src/paths.ts";
-import { queryEvidenceEvents } from "../src/evidence-log.ts";
 import {
  renderWorkspaceMemory,
  accountWorkspaceMemoryRender,
-  accountWorkspaceMemoryCompactionRefs,
  enforceLongTermLimits,
  dedupeLongTermEntriesWithAccounting,
  enforceLongTermLimitsWithAccounting,
@@ -45,15 +43,6 @@ test("default prompt budgets use calibrated conservative character caps", () =>
  assert.equal(HOT_STATE_LIMITS.maxRenderedChars, 700);
 });

-test("retention type caps use v1.6 decision headroom without changing other caps", () => {
-  assert.equal(RETENTION_TYPE_MAX.feedback, 10);
-  assert.equal(RETENTION_TYPE_MAX.decision, 12);
-  assert.equal(RETENTION_TYPE_MAX.project, 8);
-  assert.equal(RETENTION_TYPE_MAX.reference, 6);
-  assert.equal(LONG_TERM_LIMITS.maxEntries, 28);
-  assert.equal(LONG_TERM_LIMITS.maxRenderedChars, 3600);
-});
-
 function entry(id: string, text: string, type: LongTermMemoryEntry["type"] = "decision"): LongTermMemoryEntry {
  const now = new Date().toISOString();
  return {
@@ -169,92 +158,6 @@ test("renderWorkspaceMemory returns empty for no entries", () => {
  assert.equal(rendered, "");
 });

-test("accountWorkspaceMemoryCompactionRefs returns empty prompt and refs for no entries", () => {
-  const store: WorkspaceMemoryStore = {
-    version: 1,
-    workspace: { root: "/repo", key: "abc" },
-    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries: [],
-    updatedAt: new Date().toISOString(),
-  };
-
-  const accounting = accountWorkspaceMemoryCompactionRefs(store);
-
-  assert.equal(accounting.prompt, "");
-  assert.deepEqual(accounting.refs, []);
-});
-
-test("accountWorkspaceMemoryCompactionRefs renders numbered refs by type with snapshot keys", () => {
-  const originalNow = Date.now;
-  const capturedAt = Date.UTC(2026, 4, 7, 12, 0, 0);
-  Date.now = () => capturedAt;
-
-  try {
-    const createdAt = new Date(capturedAt).toISOString();
-    const entries: LongTermMemoryEntry[] = [
-      { ...entry("mem-feedback", "User requires verifier confirmation after each wave.", "feedback"), createdAt, updatedAt: createdAt, source: "explicit" },
-      { ...entry("mem-project", "This repository is an OpenCode plugin using local JSON stores.", "project"), createdAt, updatedAt: createdAt },
-      { ...entry("mem-decision", "Decision dedupe stays exact-only.", "decision"), createdAt, updatedAt: createdAt },
-      { ...entry("mem-reference", "Workspace memory is rendered as frozen system[1] during normal chat turns.", "reference"), createdAt, updatedAt: createdAt },
-      { ...entry("mem-superseded", "Superseded memory should not get a ref.", "decision"), status: "superseded" as const },
-    ];
-    const store: WorkspaceMemoryStore = {
-      version: 1,
-      workspace: { root: "/repo", key: "abc" },
-      limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-      entries,
-      updatedAt: createdAt,
-      lastActivityAt: createdAt,
-    };
-
-    const accounting = accountWorkspaceMemoryCompactionRefs(store);
-
-    assert.equal(accounting.prompt, [
-      "Existing workspace memories available for consolidation:",
-      "feedback:",
-      "[M1] User requires verifier confirmation after each wave.",
-      "project:",
-      "[M2] This repository is an OpenCode plugin using local JSON stores.",
-      "decision:",
-      "[M3] Decision dedupe stays exact-only.",
-      "reference:",
-      "[M4] Workspace memory is rendered as frozen system[1] during normal chat turns.",
-    ].join("\n"));
-    assert.deepEqual(accounting.refs.map(ref => ref.ref), ["M1", "M2", "M3", "M4"]);
-    assert.deepEqual(accounting.refs.map(ref => ref.memoryId), ["mem-feedback", "mem-project", "mem-decision", "mem-reference"]);
-    assert.deepEqual(accounting.refs.map(ref => ref.exactKey), accounting.rendered.map(workspaceMemoryExactKey));
-    assert.deepEqual(accounting.refs.map(ref => ref.identityKey), accounting.rendered.map(workspaceMemoryIdentityKey));
-    assert.ok(accounting.refs.every(ref => ref.capturedAt === capturedAt));
-    assert.equal(accounting.refs.some(ref => ref.memoryId === "mem-superseded"), false);
-  } finally {
-    Date.now = originalNow;
-  }
-});
-
-test("accountWorkspaceMemoryCompactionRefs is bounded by long-term caps", () => {
-  const now = new Date().toISOString();
-  const entries: LongTermMemoryEntry[] = [
-    ...Array.from({ length: 10 }, (_, i) => entry(`compaction-feedback-${i}`, `Compaction feedback ${i}`, "feedback")),
-    ...Array.from({ length: 10 }, (_, i) => entry(`compaction-decision-${i}`, `Compaction decision ${i}`, "decision")),
-    ...Array.from({ length: 8 }, (_, i) => entry(`compaction-project-${i}`, `Compaction project ${i}`, "project")),
-    ...Array.from({ length: 6 }, (_, i) => entry(`compaction-reference-${i}`, `Compaction reference ${i}`, "reference")),
-  ].map(memory => ({ ...memory, createdAt: now, updatedAt: now }));
-  const store: WorkspaceMemoryStore = {
-    version: 1,
-    workspace: { root: "/repo", key: "abc" },
-    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries,
-    updatedAt: now,
-    lastActivityAt: now,
-  };
-
-  const accounting = accountWorkspaceMemoryCompactionRefs(store);
-
-  assert.equal(accounting.refs.length, LONG_TERM_LIMITS.maxEntries);
-  assert.equal(accounting.prompt.includes("[M28]"), true);
-  assert.equal(accounting.prompt.includes("[M29]"), false);
-});
-
 test("accountWorkspaceMemoryRender reports rendered and omitted reasons", () => {
  const store: WorkspaceMemoryStore = {
    version: 1,
@@ -659,23 +562,6 @@ test("dedupeLongTermEntriesWithAccounting reinforces absorbed exact duplicates",
  ));
 });

-test("dedupeLongTermEntriesWithAccounting decision same-identity variants absorb exact only", () => {
-  const retained = entry("decision-a", "Use pnpm for package management!!!", "decision");
-  const duplicate = entry("decision-b", "use pnpm for package management", "decision");
-
-  assert.notEqual(retained.text, duplicate.text);
-  assert.equal(workspaceMemoryIdentityKey(retained), workspaceMemoryIdentityKey(duplicate));
-  assert.equal(workspaceMemoryExactKey(retained), workspaceMemoryExactKey(duplicate));
-
-  const result = dedupeLongTermEntriesWithAccounting([retained, duplicate]);
-
-  assert.equal(result.kept.length, 1);
-  assert.equal(result.absorbed.length, 1);
-  assert.equal(result.absorbed[0].reason, "absorbed_exact");
-  assert.equal(result.superseded.length, 0);
-  assert.equal(result.absorbed.some(event => event.reason === "superseded_existing"), false);
-});
-
 test("dedupeLongTermEntriesWithAccounting emits identity reinforcement evidence", () => {
  const now = Date.now();
  const retained: LongTermMemoryEntry = {
@@ -949,15 +835,15 @@ test("mixed retention scenario applies caps and reinforcement ordering", () => {

 test("type max sum above global cap still respects maxEntries", () => {
  const entries: LongTermMemoryEntry[] = [
-    ...Array.from({ length: RETENTION_TYPE_MAX.feedback }, (_, i) => entry(`feedback-${i}`, `Unique feedback preference ${i}`, "feedback")),
-    ...Array.from({ length: RETENTION_TYPE_MAX.decision }, (_, i) => entry(`decision-${i}`, `Unique durable decision ${i}`, "decision")),
-    ...Array.from({ length: RETENTION_TYPE_MAX.project }, (_, i) => entry(`project-${i}`, `Unique project fact ${i}`, "project")),
-    ...Array.from({ length: RETENTION_TYPE_MAX.reference }, (_, i) => entry(`reference-${i}`, `Unique reference fact ${i}`, "reference")),
+    ...Array.from({ length: 10 }, (_, i) => entry(`feedback-${i}`, `Unique feedback preference ${i}`, "feedback")),
+    ...Array.from({ length: 10 }, (_, i) => entry(`decision-${i}`, `Unique durable decision ${i}`, "decision")),
+    ...Array.from({ length: 8 }, (_, i) => entry(`project-${i}`, `Unique project fact ${i}`, "project")),
+    ...Array.from({ length: 6 }, (_, i) => entry(`reference-${i}`, `Unique reference fact ${i}`, "reference")),
  ];

  const kept = enforceLongTermLimits(entries);

-  assert.equal(entries.length, Object.values(RETENTION_TYPE_MAX).reduce((sum, count) => sum + count, 0));
+  assert.equal(entries.length, 34);
  assert.equal(kept.length, LONG_TERM_LIMITS.maxEntries);
 });

@@ -1113,16 +999,6 @@ test("workspaceMemoryExactKey uses pending-compatible canonical semantics", () =
  assert.equal(workspaceMemoryExactKey(entry), "decision:opencode uses npm cache for plugin loading");
 });

-test("workspaceMemoryIdentityKey returns exact key for feedback entries", () => {
-  const feedback = entry(
-    "feedback-exact-identity",
-    "User prefers references to mention `.opencode/opencode.json` explicitly.",
-    "feedback",
-  );
-
-  assert.equal(workspaceMemoryIdentityKey(feedback), workspaceMemoryExactKey(feedback));
-});
-
 test("normalizeWorkspaceMemoryWithAccounting redacts credentials before accounting", async () => {
  const root = "/repo";
  const now = new Date().toISOString();
@@ -1376,50 +1252,6 @@ test("updateWorkspaceMemoryWithAccounting emits accounting events for persisted
  }
 });

-test("updateWorkspaceMemoryWithAccounting includes migration evidence from pre-update normalization", async () => {
-  const sandbox = await mkdtemp(join(tmpdir(), "wm-accounting-migration-update-"));
-  const dataHome = join(sandbox, "xdg-data-home");
-  const root = join(sandbox, "workspace");
-  const previousXdgDataHome = process.env.XDG_DATA_HOME;
-  process.env.XDG_DATA_HOME = dataHome;
-
-  try {
-    await mkdir(root, { recursive: true });
-    const now = "2026-04-26T00:00:00.000Z";
-    const storePath = await workspaceMemoryPath(root);
-    await mkdir(dirname(storePath), { recursive: true });
-    await writeFile(storePath, JSON.stringify({
-      version: 1,
-      workspace: { root, key: await workspaceKey(root) },
-      limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-      entries: [{
-        id: "update_p0_progress",
-        type: "project",
-        text: "Phase 1-4 completed successfully",
-        source: "compaction",
-        confidence: 0.75,
-        status: "active",
-        createdAt: now,
-        updatedAt: now,
-      }],
-      migrations: ["2026-04-28-quality-cleanup"],
-      updatedAt: now,
-    }, null, 2), "utf8");
-
-    const result = await updateWorkspaceMemoryWithAccounting(root, store => store);
-    const migrationEvidence = result.evidence.filter(event => event.type === "memory_migration_superseded");
-
-    assert.equal(result.store.entries.find(memory => memory.id === "update_p0_progress")?.status, "superseded");
-    assert.equal(migrationEvidence.length, 1);
-    assert.deepEqual(migrationEvidence[0].reasonCodes, ["migration:p0_cleanup"]);
-    assert.equal(migrationEvidence[0].memory?.memoryId, "update_p0_progress");
-  } finally {
-    if (previousXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
-    else process.env.XDG_DATA_HOME = previousXdgDataHome;
-    await rm(sandbox, { recursive: true, force: true });
-  }
-});
-
 // ============================================
 // P0d: identity-key dedup, supersession, staleness
 // ============================================
@@ -1772,7 +1604,7 @@ test("redactCredentials is idempotent and also redacts rationale text", () => {
      })),
    },
    now,
-  ).store;
+  );
  assert.equal(migrated.entries[0].text, "Admin PIN 是 [REDACTED]");
  assert.equal(migrated.entries[0].rationale, "password: [REDACTED]");
 });
@@ -1831,69 +1663,14 @@ test("runMigrationP0Cleanup marks only non-explicit project snapshots and runs o
  };

  const once = runMigrationP0Cleanup(store, now);
-  assert.deepEqual(once.store.migrations, ["2026-04-26-p0-cleanup"]);
-  assert.equal(once.store.entries.find(e => e.id === "project-snapshot")?.status, "superseded");
-  assert.equal(once.store.entries.find(e => e.id === "project-explicit")?.status, "active");
-  assert.equal(once.store.entries.find(e => e.id === "feedback-snapshot-like")?.status, "active");
-  assert.equal(once.events.length, 1);
-  assert.equal(once.events[0].type, "memory_migration_superseded");
-  assert.equal(once.events[0].phase, "storage");
-  assert.equal(once.events[0].outcome, "superseded");
-  assert.ok(once.events[0].reasonCodes.includes("migration:p0_cleanup"));
-  assert.equal(once.events[0].memory?.memoryId, "project-snapshot");
+  assert.deepEqual(once.migrations, ["2026-04-26-p0-cleanup"]);
+  assert.equal(once.entries.find(e => e.id === "project-snapshot")?.status, "superseded");
+  assert.equal(once.entries.find(e => e.id === "project-explicit")?.status, "active");
+  assert.equal(once.entries.find(e => e.id === "feedback-snapshot-like")?.status, "active");

-  const twice = runMigrationP0Cleanup(once.store, later);
-  assert.deepEqual(twice.store.migrations, ["2026-04-26-p0-cleanup"], "migration id should not duplicate");
-  assert.equal(twice.store.entries.find(e => e.id === "project-snapshot")?.updatedAt, once.store.entries.find(e => e.id === "project-snapshot")?.updatedAt);
-  assert.equal(twice.events.length, 0);
-});
-
-test("loadWorkspaceMemory appends P0 migration evidence once", async () => {
-  const sandbox = await mkdtemp(join(tmpdir(), "wm-p0-evidence-"));
-  const dataHome = join(sandbox, "xdg-data-home");
-  const root = join(sandbox, "workspace");
-  const previousXdgDataHome = process.env.XDG_DATA_HOME;
-  process.env.XDG_DATA_HOME = dataHome;
-
-  try {
-    await mkdir(root, { recursive: true });
-    const now = "2026-04-26T00:00:00.000Z";
-    const storePath = await workspaceMemoryPath(root);
-    await mkdir(dirname(storePath), { recursive: true });
-    await writeFile(storePath, JSON.stringify({
-      version: 1,
-      workspace: { root, key: await workspaceKey(root) },
-      limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-      entries: [{
-        id: "p0_progress",
-        type: "project",
-        text: "Phase 1-4 completed successfully",
-        source: "compaction",
-        confidence: 0.75,
-        status: "active",
-        createdAt: now,
-        updatedAt: now,
-      }],
-      migrations: ["2026-04-28-quality-cleanup"],
-      updatedAt: now,
-    }, null, 2), "utf8");
-
-    const firstLoad = await loadWorkspaceMemory(root);
-    await loadWorkspaceMemory(root);
-    const events = await queryEvidenceEvents(root, { types: ["memory_migration_superseded"] });
-
-    assert.equal(firstLoad.entries.find(memory => memory.id === "p0_progress")?.status, "superseded");
-    assert.equal(events.length, 1);
-    assert.equal(events[0].type, "memory_migration_superseded");
-    assert.equal(events[0].phase, "storage");
-    assert.equal(events[0].outcome, "superseded");
-    assert.deepEqual(events[0].reasonCodes, ["migration:p0_cleanup"]);
-    assert.equal(events[0].memory?.memoryId, "p0_progress");
-  } finally {
-    if (previousXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
-    else process.env.XDG_DATA_HOME = previousXdgDataHome;
-    await rm(sandbox, { recursive: true, force: true });
-  }
+  const twice = runMigrationP0Cleanup(once, later);
+  assert.deepEqual(twice.migrations, ["2026-04-26-p0-cleanup"], "migration id should not duplicate");
+  assert.equal(twice.entries.find(e => e.id === "project-snapshot")?.updatedAt, once.entries.find(e => e.id === "project-snapshot")?.updatedAt);
 });

 test("quality cleanup migration preserves soft-only feedback and decision violations", async () => {
@@ -2020,56 +1797,6 @@ test("quality cleanup migration writes audit log for hard supersedes", async ()
  }
 });

-test("quality cleanup migration appends superseded evidence with hard reasons", async () => {
-  const sandbox = await mkdtemp(join(tmpdir(), "wm-quality-evidence-"));
-  const dataHome = join(sandbox, "xdg-data-home");
-  const root = join(sandbox, "workspace");
-  const previousXdgDataHome = process.env.XDG_DATA_HOME;
-  process.env.XDG_DATA_HOME = dataHome;
-
-  try {
-    await mkdir(root, { recursive: true });
-    const now = "2026-04-28T00:00:00.000Z";
-    const storePath = await workspaceMemoryPath(root);
-    await mkdir(dirname(storePath), { recursive: true });
-    await writeFile(storePath, JSON.stringify({
-      version: 1,
-      workspace: { root, key: await workspaceKey(root) },
-      limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-      entries: [{
-        id: "quality_progress",
-        type: "project",
-        text: "Test suite: 1237 tests pass, 226 suites",
-        source: "compaction",
-        confidence: 0.75,
-        status: "active",
-        createdAt: now,
-        updatedAt: now,
-        staleAfterDays: 60,
-      }],
-      migrations: [],
-      updatedAt: now,
-    }, null, 2), "utf8");
-
-    const loaded = await loadWorkspaceMemory(root);
-    const events = await queryEvidenceEvents(root, { types: ["memory_migration_superseded"] });
-
-    assert.equal(loaded.entries.find(memory => memory.id === "quality_progress")?.status, "superseded");
-    assert.equal(events.length, 1);
-    assert.equal(events[0].type, "memory_migration_superseded");
-    assert.equal(events[0].phase, "storage");
-    assert.equal(events[0].outcome, "superseded");
-    assert.ok(events[0].reasonCodes.includes("migration:quality_cleanup"));
-    assert.ok(events[0].reasonCodes.includes("quality:progress_snapshot"));
-    assert.equal(events[0].memory?.memoryId, "quality_progress");
-    assert.equal(events[0].memory?.status, "superseded");
-  } finally {
-    if (previousXdgDataHome === undefined) delete process.env.XDG_DATA_HOME;
-    else process.env.XDG_DATA_HOME = previousXdgDataHome;
-    await rm(sandbox, { recursive: true, force: true });
-  }
-});
-
 test("quality cleanup migration aborts supersede when audit log cannot be written", async () => {
  const sandbox = await mkdtemp(join(tmpdir(), "wm-quality-audit-fail-"));
  const dataHome = join(sandbox, "xdg-data-home");
@@ -2605,7 +2332,7 @@ function decisionEntry(id: string, text: string, timestampMs: number): LongTermM
  };
 }

-test("enforceLongTermLimitsWithAccounting keeps 11th and 12th decisions and type-caps the 13th", () => {
+test("enforceLongTermLimitsWithAccounting capacity drops return 3 lower-ranked decisions in dropped", () => {
  const now = Date.UTC(2026, 4, 1, 6, 24, 0);
  const thirtyDaysAgo = now - 30 * DAY_MS;
  const existingDecisions = Array.from({ length: 10 }, (_, i) =>
@@ -2628,12 +2355,8 @@ test("enforceLongTermLimitsWithAccounting keeps 11th and 12th decisions and type
  const droppedIds = new Set(capacityDrops.map(event => event.memory.id));
  const capacityEvidence = result.evidence.filter(event => event.type === "memory_removed_capacity");

-  assert.equal(result.kept.filter(memory => memory.type === "decision").length, RETENTION_TYPE_MAX.decision);
-  assert.equal(result.kept.some(memory => memory.id === "new-decision-0"), true);
-  assert.equal(result.kept.some(memory => memory.id === "new-decision-1"), true);
-  assert.equal(result.kept.some(memory => memory.id === "new-decision-2"), true);
-  assert.equal(capacityDrops.length, 1);
-  assert.equal(capacityEvidence.length, 1);
+  assert.equal(capacityDrops.length, 3);
+  assert.equal(capacityEvidence.length, 3);
  for (const event of capacityEvidence) {
    assert.equal(event.phase, "storage");
    assert.equal(event.outcome, "removed");
@@ -2668,20 +2391,20 @@ test("enforceLongTermLimitsWithAccounting emits global_cap evidence for global c
  const capacityEvidence = result.evidence.filter(event => event.type === "memory_removed_capacity");
  const globalCapEvidence = capacityEvidence.filter(event => event.reasonCodes.includes("global_cap"));

-  assert.equal(entries.length, Object.values(RETENTION_TYPE_MAX).reduce((sum, count) => sum + count, 0));
+  assert.equal(entries.length, 34);
  assert.equal(result.kept.length, LONG_TERM_LIMITS.maxEntries);
  assert.equal(globalCapEvidence.length, entries.length - LONG_TERM_LIMITS.maxEntries);
  assert.equal(capacityEvidence.some(event => event.reasonCodes.includes("type_cap")), false);
  assert.ok(globalCapEvidence.every(event => event.phase === "storage" && event.outcome === "removed"));
 });

-test("accountWorkspaceMemoryRender emits render_omitted for type_cap with 13 decisions", () => {
+test("accountWorkspaceMemoryRender emits render_omitted for type_cap with 11 decisions", () => {
  const now = Date.UTC(2026, 4, 1, 6, 24, 0);
  const store: WorkspaceMemoryStore = {
    version: 1,
    workspace: { root: "/repo", key: "abc" },
    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries: Array.from({ length: 13 }, (_, i) =>
+    entries: Array.from({ length: 11 }, (_, i) =>
      decisionEntry(`render-decision-${i}`, `Render durable decision ${i}`, now)
    ),
    updatedAt: new Date(now).toISOString(),
@@ -2698,50 +2421,3 @@ test("accountWorkspaceMemoryRender emits render_omitted for type_cap with 13 dec
  assert.equal(typeCapOmissions.length, 1);
  assert.equal(typeCapEvidence.length, 1);
 });
-
-test("accountWorkspaceMemoryRender records char-budget omissions when 12 decisions crowd other types", () => {
-  const now = Date.UTC(2026, 4, 1, 6, 24, 0);
-  const longText = (prefix: string, i: number) => `${prefix} ${i}: ${"durable architecture context ".repeat(8)}`;
-  const entries: LongTermMemoryEntry[] = [
-    ...Array.from({ length: 2 }, (_, i) => ({
-      ...decisionEntry(`crowd-feedback-${i}`, longText("User feedback preference", i), now),
-      type: "feedback" as const,
-      source: "explicit" as const,
-    })),
-    ...Array.from({ length: 2 }, (_, i) => ({
-      ...decisionEntry(`crowd-project-${i}`, longText("Project fact", i), now),
-      type: "project" as const,
-    })),
-    ...Array.from({ length: RETENTION_TYPE_MAX.decision }, (_, i) =>
-      decisionEntry(`crowd-decision-${i}`, longText("Decision rule", i), now)
-    ),
-    ...Array.from({ length: 2 }, (_, i) => ({
-      ...decisionEntry(`crowd-reference-${i}`, longText("Reference fact", i), now),
-      type: "reference" as const,
-    })),
-  ];
-  const store: WorkspaceMemoryStore = {
-    version: 1,
-    workspace: { root: "/repo", key: "abc" },
-    limits: { maxRenderedChars: LONG_TERM_LIMITS.maxRenderedChars, maxEntries: LONG_TERM_LIMITS.maxEntries },
-    entries,
-    updatedAt: new Date(now).toISOString(),
-    lastActivityAt: new Date(now).toISOString(),
-  };
-
-  const accounting = accountWorkspaceMemoryRender(store);
-  const charBudgetOmissions = accounting.omitted.filter(item => item.reason === "char_budget");
-  const charBudgetEvidence = accounting.evidence.filter(event =>
-    event.type === "render_omitted" && event.reasonCodes.includes("char_budget")
-  );
-  const omittedIds = new Set(charBudgetOmissions.map(item => item.memory.id));
-  const evidenceIds = new Set(charBudgetEvidence.map(event => event.memory?.memoryId).filter(Boolean));
-
-  assert.ok(accounting.prompt.length <= LONG_TERM_LIMITS.maxRenderedChars);
-  assert.equal(accounting.omitted.some(item => item.reason === "type_cap"), false);
-  assert.equal(accounting.omitted.some(item => item.reason === "global_cap"), false);
-  assert.ok(charBudgetOmissions.length > 0, "crowded render should omit by char budget");
-  assert.ok(charBudgetOmissions.some(item => item.memory.type === "reference"), "later non-decision types should be accounted if crowded out");
-  assert.equal(charBudgetEvidence.length, charBudgetOmissions.length);
-  assert.deepEqual(evidenceIds, omittedIds);
-});
@@ -25,6 +25,6 @@
    "allowImportingTsExtensions": true,
    "noEmit": true
  },
-  "include": ["index.ts", "src/**/*.ts", "scripts/memory-diag.ts", "scripts/memory-diag/**/*.ts"],
+  "include": ["index.ts", "src/**/*.ts"],
  "exclude": ["node_modules", "dist"]
 }
Author	SHA1	Message	Date
Ralph Chang	ff5c568cb7	chore(release): prepare v1.5.2	2026-05-01 16:00:44 +08:00
Ralph Chang	0ed61d1ba2	Merge branch 'feat/deprecate-safety-critical'	2026-04-30 19:54:50 +08:00
Ralph Chang	2dbfb50080	chore(release): prepare v1.5.1	2026-04-30 19:54:24 +08:00
Ralph Chang	d569297c30	fix(retention): add UTC calendar-day diversity gate to reinforceMemory Implement OQ-2 decision: allow at most one reinforcement per memory identity per UTC calendar day. Same-day reinforcement is blocked regardless of session or interval. This prevents repetitive-task gaming where a daily recurring task could reach MAX_COUNT=6 in hours. Guard order: same-session → calendar-day → 1-hour → max-count (existing guards kept as defense-in-depth) 1 hour guard is redundant within same day but preserved for sub-hour edge cases.	2026-04-30 18:38:29 +08:00
Ralph Chang	4f1c0348b4	feat(explainability): add diagnostics JSON, per-memory explain, lifecycle trace Phase 4 Tasks 4.1-4.3: - memory-diag health --json: machine-readable MemoryDiagJSON output - memory-diag explain: per-memory render status with strength, reasons, evidence event IDs - memory-diag trace --memory <id>: lifecycle history from evidence events and relations (superseded_by, reinforced_by) - MemoryRenderStatus type with 9 statuses - All diagnostics are read-only, no storage mutations - Privacy-safe: redacted text previews, no raw secrets - 270 tests pass, typecheck pass	2026-04-30 18:06:28 +08:00
Ralph Chang	bc0847e3ed	feat(evidence): wire evidence events into extraction, promotion, reinforcement, render, storage, and hook lifecycle Phase 3 Tasks 3.2-3.6: - Extraction evidence: accepted/rejected/explicit_detected/explicit_ignored - Promotion evidence with relation edges (superseded/superseded_by, absorbed/retained) - Reinforcement evidence with reinforced/reinforced_by relations - Render accounting helper with render_selected/render_omitted evidence - Storage evidence: corrupt_json_quarantined, stale_lock_recovered, lock_timeout - Hook failure evidence in plugin - All evidence failures swallowed, never throw into memory behavior - Privacy-safe textPreview (redacted + truncated) - 266 tests pass, typecheck pass	2026-04-30 17:54:13 +08:00
Ralph Chang	6a81fc384c	feat(evidence): add evidence infrastructure - types, append, query, retention Phase 3 Task 3.1: - Create src/evidence-log.ts with EvidenceEventType, EvidencePhase, EvidenceOutcome, MemoryEvidenceRef, EvidenceRelation, EvidenceEventV1, EvidenceEventInput types - Add appendEvidenceEvent/appendEvidenceEvents with safe write, privacy hashing (SHA-256 truncated), textPreview redaction, bounded retention - Add queryEvidenceEvents, summarizeMemoryEvidence, traceMemoryLifecycle - Add workspaceEvidenceLogPath to src/paths.ts - Add 8 evidence-log tests: round-trip, privacy, query, resilience, retention - Relations limited to wiring roles only (no kind/derived_from/validates) - 253 tests pass	2026-04-30 17:33:40 +08:00
Ralph Chang	ed4590ca18	refactor(retention): extract retention module from workspace-memory Move retention constants and math to a focused src/retention.ts module: - All half-life, reinforcement, dormancy constants - TYPE_FACTOR, SOURCE_FACTOR, USER_IMPORTANCE_FACTOR - RETENTION_TYPE_MAX (renamed from TYPE_MAX) - calculateInitialStrength, calculateEffectiveHalfLife, calculateRetentionStrength, calculateDormantDays, calculateEffectiveAgeDays, reinforceMemory No behavior changes. retention.ts imports only types from types.ts. Workspace-memory.ts still owns storage, consolidation, and rendering.	2026-04-30 17:28:31 +08:00
Ralph Chang	09cc4a2ffb	feat(deprecation): remove safetyCritical retention multiplier and type-cap bypass - Remove SAFETY_CRITICAL_FACTOR = 6.0 from workspace-memory.ts - Remove safetyFactor from calculateInitialStrength() - all memories now fade according to the same rules - Remove safetyCritical bypass from applyTypeMaxCaps() - safetyCritical entries compete normally under TYPE_MAX caps - Preserve safetyCritical?: boolean in LongTermMemoryEntry type for backward compatibility (no producer sets it to true) - Update memory-diag to show deprecation warning instead of capacity alert - Update tests: add backward-compatibility fixture test, deprecation strength test, normal cap competition test - Update docs/architecture.md, RELEASE_NOTES.md, CHANGELOG.md, docs/configuration.md Phase 1.5 complete: safetyCritical is now a deprecated field with no active behavior. Safety rules belong in user-controlled agent.md files.	2026-04-30 17:23:01 +08:00
Ralph Chang	c0ebd84d7e	fix(security): harden hooks, quarantine corrupt JSON, test locks, fix promotion dedupe - Wrap hooks with try/catch to prevent OpenCode disruption - Add warnMemoryHook() for safe error logging - Quarantine corrupt JSON files before fallback - Add cross-process lock safety tests - Fix pending promotion same-batch dedupe - Update docs/architecture.md with lock semantics - 242 tests passing	2026-04-30 11:52:01 +08:00
Ralph Chang	20a6cfe1a6	chore(release): prepare v1.5.0	2026-04-29 16:56:47 +08:00
Ralph Chang	36b78ea91c	feat(memory): add retention model test gaps and health diagnostics Wave 1 - P0 Test Gaps: - Add hard stale prune removed regression test - Add dormant overlap tests (entry created during dormancy) - Add invalid timestamp NaN protection test - Add reinforcement ordering test with reference type - Add dedupe same-session/under-1hr guard tests - Fix NaN handling with Number.isFinite check Wave 2 - Helper Functions: - Add timestampMs() for safe timestamp conversion - Add isSafetyCriticalForDiag() aligned with runtime Wave 3 - Health Output Format: - Fix top rendered candidates sorted by strength (not text length) - Add stored vs rendered counts breakdown - Add type caps and global cap overflow display - Track globalCapped array explicitly - Add dormant status section Wave 4 - Monitoring Metrics: - Add high_importance_ratio (alert > 30%) - Add safety_critical_count (alert > 5) - Add max_reinforced_count (alert > 10% active) Wave 5 - Integration Fixture: - Add 34-entry over-cap test - Add mixed retention regression fixture - Test TYPE_MAX caps, safety-critical exemption, reinforcement ordering Tests: 224 → 237	2026-04-29 15:26:44 +08:00
Ralph Chang	406c160c9f	fix(memory): correct dormant formula, remove hard prune, integrate reinforcement P0.1 - Fix dormant effective age formula: - Use overlap logic: only apply dormancy to entry's lifetime - Formula: activeDays + dormantOverlapDays * 0.25 - calculateDormantDays now returns total days (not excess past grace) - Test: 28 dormant days → 17.5 effective days P0.2 - Remove hard stale pruning: - Remove isPrunableByAge from enforcement - Remove rejected_stale from accounting reasons - Elimination now by cap competition only P0.3 - Integrate reinforcement: - Call reinforceMemory in dedupe absorption path - Call reinforceMemory in promotion duplicate path - Update retentionClock on reinforcement A1 - Retention clock reset on reinforcement A4 - Fix tests to encode correct formula	2026-04-29 14:55:25 +08:00
Ralph Chang	968aedd5c5	feat(memory): add dormant tracking and reinforcement mechanism Wave 2c - Dormant workspace tracking: - Add lastActivityAt to WorkspaceMemoryStore - Implement calculateDormantDays with 14-day grace period - Wire dormant days into retention-strength calculation Wave 3 - Reinforcement: - Add lastReinforcedSessionID to LongTermMemoryEntry - Implement reinforceMemory with guards (same-session, 1hr interval, max 6) - Set retentionClock on memory creation in extractors.ts and plugin.ts Tests: 219 → 222, all pass	2026-04-29 14:32:39 +08:00
Ralph Chang	d4053b2d35	feat(memory): implement retention decay model with strength-based ordering - Add retention model constants (45-day half-life, 6.0 safety factor) - Add TYPE_MAX caps (feedback:10, decision:10, project:8, reference:6) - Add strength calculation: initialStrength × 2^(-age/halfLife) - Integrate strength-based sorting into enforceLongTermLimits - Safety-critical entries bypass type caps - Add fields: retentionClock, reinforcementCount, userImportance, safetyCritical	2026-04-29 14:18:51 +08:00
Ralph Chang	85e11be2b9	feat: add maintainer diagnostics for memory quality calibration - health: inspect workspace memory store, pending journal, offline quality checks - rejections: review extraction rejection log with origin inference - audit: review migration logs with risky supersede heuristic - Maintainer-only, offline, no telemetry, no API calls	2026-04-29 10:25:35 +08:00
sdwolf4103	5b0083efae	Merge pull request #4 from sdwolf4103/feat/memory-quality-cleanup Release v1.4.0 memory quality cleanup	2026-04-28 14:53:12 +08:00
Ralph Chang	60b9ca75c8	fix(memory): isolate test workspace cleanup	2026-04-28 14:50:30 +08:00
Ralph Chang	8da39c7a9d	fix(memory): address quality cleanup audit findings	2026-04-28 14:29:28 +08:00
Ralph Chang	e8c95a62ec	docs(memory): document conservative quality cleanup migration	2026-04-28 14:19:18 +08:00
Ralph Chang	56d7ef9a68	test(memory): add real workspace quality cleanup regression fixture	2026-04-28 14:17:43 +08:00
Ralph Chang	7427221640	feat(memory): add local quality cleanup audit logs	2026-04-28 14:17:17 +08:00
Ralph Chang	9991c95ff6	fix(memory): make quality cleanup migration conservative	2026-04-28 14:15:34 +08:00
Ralph Chang	f7139f0844	chore: prepare v1.4.0 release	2026-04-28 13:37:14 +08:00
Ralph Chang	465edfabf1	fix: unify all memory quality rules in single module	2026-04-28 13:34:33 +08:00
Ralph Chang	6a80f4b047	fix: auto-supersede low-quality compaction memories	2026-04-28 13:29:28 +08:00
Ralph Chang	b21347c12b	fix: tighten compaction memory candidate prompt	2026-04-28 13:24:43 +08:00
Ralph Chang	ffb0477251	fix: unify workspace memory quality gate	2026-04-28 13:21:15 +08:00
Ralph Chang	a1b9bf4fbc	chore: prepare v1.3.3 release	2026-04-28 13:06:14 +08:00
Ralph Chang	a762e863d1	fix: owner scope in global unowned promotion Problem: clearPendingMemories() and recordPromotionRejections() would incorrectly clear or mutate owned entries during global unowned promotion. Fixes: 1. clearPendingMemories() now respects owner/unowned scope: - global clearUnowned only clears unowned same-key entries - owned same-key entries are preserved - explicit global clear-all-by-key fallback still works 2. recordPromotionRejections() now has includeUnownedOnly option: - global unowned rejection only increments/exhausts unowned entries - owned same-key entries are preserved 3. Added regression tests: - global unowned clear keeps owned same-key entries - global unowned rejection only exhausts unowned same-key entries Tests: 182 pass, 0 fail	2026-04-28 12:27:46 +08:00
Ralph Chang	222bae28de	fix: cross-process lock stale judgment and heartbeat Problem: CI test "updateJSON serializes writes across separate node processes" was failing with expect 100 but got 89/97. The root cause was isLockStale() being too aggressive - it could mistakenly delete locks held by other processes. Fixes: 1. isLockStale() now uses mtime only - fresh locks are never stale 2. Added heartbeat mechanism during lock hold to support long updaters 3. Removed PID check that was unreliable in CI/containers 4. Fixed ENOENT race when lock is released between EEXIST and stat Tests: 180 pass, 0 fail	2026-04-28 12:24:56 +08:00
Ralph Chang	53aa6d3c31	feat: implement Plan 1 - Critical Stability fixes Wave 1: Storage and Journal Safety - Add frozen cache TTL (1h) and size bounds (50 sessions) - Add pending journal source-aware retention (compaction-only TTL) - Add inter-process file lock with stale recovery - Move processLatestUserMessage to first transform (after isSubAgent guard) Wave 2: Promotion Ownership and Bounded Rejection - Add pendingOwnerSessionID/pendingMessageID metadata - Add owner-aware pending journal clearing - Add explicit/manual bounded retry (max 3 attempts) - Fix session.deleted cleanup idempotency Wave 3: Normalize, Security, and Cache Hardening - Fix load-time write loop (only write on security/migration change) - Add deterministic sort tie-breaker (createdAt -> id) - Add Bearer token redaction - Add processed message cache bounds - Remove priorityWithFreshness dead code Tests: 180 pass, 0 fail	2026-04-28 11:59:29 +08:00
Ralph Chang	034dfe8d91	fix: run compatibility CI on Node 24	2026-04-27 22:13:23 +08:00
Ralph Chang	e3ebdbfe9f	fix: support CI installs without lockfile	2026-04-27 22:04:11 +08:00
Ralph Chang	fdebd304f6	chore: prepare v1.3.1 release	2026-04-27 22:00:04 +08:00
Ralph Chang	77d60abf5f	refactor: make memory dedupe repo-agnostic	2026-04-27 21:19:42 +08:00
Ralph Chang	560f63f96b	docs: note PR 3 security hardening	2026-04-27 20:22:26 +08:00
Ralph Chang	11361abc91	test: cover security hardening edge cases	2026-04-27 20:22:09 +08:00
Ralph Chang	e071095422	merge: integrate PR #3 security hardening	2026-04-27 20:14:08 +08:00
Ralph Chang	909d6c7767	docs: document concise compatibility limitations	2026-04-27 19:57:21 +08:00
Ralph Chang	c697f63c67	fix: cap and prune pending memory journal	2026-04-27 18:54:44 +08:00
Ralph Chang	25b673fbb7	test: add opencode plugin compatibility checks	2026-04-27 18:54:14 +08:00
Steven Choo	acaa829df4	feat: implement indirect prompt injection protection and expanded secret redaction	2026-04-27 12:42:20 +02:00
Ralph Chang	fe6ce36e09	docs: prepare v1.3.0 release notes	2026-04-27 17:06:43 +08:00
Ralph Chang	3cc6dff7ae	feat: add consolidation accounting for workspace memory promotion P0 implementation with four waves: Wave 1: Dedup with accounting - Add dedupeLongTermEntriesWithAccounting() - Classify exact duplicate, identity duplicate, topic duplicate Wave 2: Normalization with accounting - Add normalizeWorkspaceMemoryWithAccounting() - Chain redaction → migration → enforceLongTermLimitsWithAccounting Wave 3: Promotion accounting integration - Update accountPendingPromotions() to use new accounting API - Add supersededKeys to classification - Distinguish promoted / absorbed / superseded / rejected Wave 4: Integration tests - End-to-end tests covering full pipeline Bug fixes: - Fix active vs superseded boundary (superseded entries no longer block promotion) - Remove unused rejected_duplicate_lower_quality type - Defer pending journal safety cap (TODO added) Tests: 135 passing (up from 115)	2026-04-27 16:45:55 +08:00
Ralph Chang	1c748f3ee2	chore: ignore superpowers plans and update architecture doc - Add docs/superpowers/plans/ to .gitignore - Remove tracked plan files from git - Update docs/architecture.md: - Change primary extraction format from XML to 'Memory candidates:' - Mark XML format as legacy/deprecated - Fix hot session state injection example	2026-04-27 14:53:07 +08:00
Ralph Chang	ca68b7f55c	feat: sharpen compaction memory extraction prompt Wave 3 of memory quality optimization plan. - Add good memory examples in buildCompactionPrompt() - Add bad memory examples to skip (test counts, commit hashes, etc.) - Add prompt assertions in tests to prevent regression - Emphasize 'useful if a new agent opens this workspace next week'	2026-04-27 14:40:32 +08:00
Ralph Chang	023589a905	test: add memory quality eval fixtures Wave 2 of memory quality optimization plan. - 5 accepted cases: durable facts that should be kept - 7 rejected cases: noise that should be filtered - Parser-level regression guard (zero API call) - All cases pass against current extractors.ts	2026-04-27 14:34:53 +08:00
Ralph Chang	24f807fed0	fix: account for absorbed pending memories - Add workspaceMemoryIdentityKey() to unify dedup/supersession identity semantics - Add accountPendingPromotions() to distinguish promoted/absorbed/rejected - Wire promotion accounting into promotePendingMemories() - Add clearableKeys.size > 0 guard to prevent journal wipe - Add regression tests for absorbed duplicate, cap-rejected, all-rejected edge cases Wave 1 of memory quality optimization plan.	2026-04-27 14:27:43 +08:00
Ralph Chang	097235e43b	docs: add memory quality optimization implementation plan P0 implementation plan with 3 waves: - Wave 1: Promotion accounting (fix absorbed duplicate data loss) - Wave 2: Memory quality eval (fixture-based regression guard) - Wave 3: Compaction prompt negative examples Addresses architecture review feedback: - Distinguish promoted/absorbed/rejected pending memories - Add clearableKeys.size > 0 guard to prevent journal wipe - Add regression tests for all edge cases	2026-04-27 14:16:46 +08:00
sdwolf4103	14bbb76cf1	Fix formatting in README.md	2026-04-27 13:00:26 +08:00