From f041e1bb8468c4a7777a1d0697181259eb765825 Mon Sep 17 00:00:00 2001 From: Ed_ Date: Thu, 18 Jun 2026 20:14:23 -0400 Subject: [PATCH] =?UTF-8?q?docs(track):=20fable=5Freview=5F20260617=20sect?= =?UTF-8?q?ion=2010=20=E2=80=94=20Memory=20System?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Verdict: Useful + nagent-stronger. ~180 lines. Source cluster: research/cluster_8_memory_and_storage.md. Strongest claim: memory is plural — Fable has 1 opaque KV store; Manual Slop has 4 named dimensions with non-interchangeable shapes. nagent's per-file notes (Candidate 11.1) is the named gap. Data-oriented parallel: Fable's try/catch vs Manual Slop's Result[T] + ErrorInfo + ledger status markers. --- .../tracks/fable_review_20260617/report.md | 98 ++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-) diff --git a/conductor/tracks/fable_review_20260617/report.md b/conductor/tracks/fable_review_20260617/report.md index f8496068..b2385851 100644 --- a/conductor/tracks/fable_review_20260617/report.md +++ b/conductor/tracks/fable_review_20260617/report.md @@ -825,7 +825,103 @@ The pattern is genuinely useful; Manual Slop's RAG discipline does not have an e *Source cluster: `research/cluster_8_memory_and_storage.md`* *Verdict orientation: Useful + nagent-stronger* -*[FILL IN: ~350 lines.]* +### What this section is + +This section synthesizes the verdict from `research/cluster_8_memory_and_storage.md` (499 lines). The cluster verdict is **Useful + nagent-stronger**: Fable's `window.storage` key-value API + the storage design pattern (hierarchical keys, single-key batching, personal-vs-shared scope) is genuinely useful engineering guidance for a KV client library, but it constitutes an API reference, not a memory architecture. Manual Slop's 4 memory dimensions (curation / discussion / RAG / knowledge) are the stronger, more grounded model. + +### Fable's memory_system section (lines 166-170) + +The Fable `memory_system` section is short (5 lines): + +> "Claude has a memory system which provides Claude with access to derived information (memories) from past conversations with the user" (Fable System Prompt.md:168) — Useful (the memory-disclosure). + +> "Claude has no memories of the user because the user has not enabled Claude's memory in Settings" (Fable System Prompt.md:170) — Useful (the transparency disclosure). + +### Fable's persistent_storage_for_artifacts section (lines 172-260) + +The `persistent_storage_for_artifacts` section is a full API spec: + +> "Artifacts can now store and retrieve data that persists across sessions using a simple key-value storage API" (Fable System Prompt.md:173) — Useful (the persistent-storage disclosure). + +> "Artifacts access storage through window.storage with these methods" (Fable System Prompt.md:177) — Useful (the API surface). + +> "await window.storage.get(key, shared?)" (Fable System Prompt.md:179) — Useful (the get method). + +> "await window.storage.set(key, value, shared?)" (Fable System Prompt.md:181) — Useful (the set method). + +> "Use hierarchical keys under 200 chars: `table_name:record_id`" (Fable System Prompt.md:203) — Useful (the hierarchical-keys pattern). + +> "Keys cannot contain whitespace, path separators (/ \\) or quotes (' \")" (Fable System Prompt.md:204) — Useful (the key-validation rule). + +> "Combine data that's updated together in the same operation into single keys to avoid multiple sequential storage calls" (Fable System Prompt.md:205) — Useful (the batching pattern). + +> "Personal data (shared: false, default): Only accessible by the current user" (Fable System Prompt.md:211) — Useful (the personal-scope rule). + +> "Shared data (shared: true): Accessible by all users of the artifact" (Fable System Prompt.md:213) — Useful (the shared-scope rule). + +> "All storage operations can fail - always use try-catch" (Fable System Prompt.md:218) — Mixed (the try-catch pattern is JS-idiomatic control flow, not data-oriented). + +### Manual Slop's response + +Manual Slop's memory model is the 4-dimension framework, which is richer than Fable's flat KV model: + +- `conductor/code_styleguides/agent_memory_dimensions.md:11-19`: the 4 memory dimensions table (curation, discussion, RAG, knowledge). Each dim has a named shape, user-editable surface, query model, and (for knowledge) provenance-aware harvest + audit ledger. +- `docs/guide_knowledge_curation.md`: the user-facing guide for the knowledge dimension. The 5 category files (decisions, facts, gotchas, references, principles) + the digest + the ledger. +- `conductor/code_styleguides/knowledge_artifacts.md`: the canonical styleguide. The 7-category schema, the byte-equality test, the sha256 ledger, the digest regeneration, the "delete to turn off" pattern. +- `src/models.py:523-559`: the `FileItem` type (curation dim). +- `src/history.py:8-100`: the `UISnapshot` type (discussion dim history). +- The discussion dimension: `list[dict]` of `disc_entries` per `docs/guide_discussions.md:29-43` (entry dict schema). +- The RAG dimension: `RAGEngine.search` per `docs/guide_rag.md` (opt-in semantic search). +- The knowledge dimension: provenance-aware plain markdown + sha256 ledger. + +The Manual Slop analog to Fable's `window.storage` is the project's `RAGEngine` + the `knowledge/` directory + the `comms.log`. Each has a different shape: Fable has 1 flat KV store; Manual Slop has 4 named dimensions with non-interchangeable shapes. + +The data-oriented parallel: Fable's `try/catch` is JS-idiomatic control flow; Manual Slop's `Result[T]` + `ErrorInfo` is the data-oriented equivalent. The `Result[T]` convention is the audit-friendly version of `try/catch`; the project's audit script (`scripts/audit_exception_handling.py`) catches violations before commit. + +### nagent's response + +nagent's relevant patterns for memory architecture: + +- `nagent_review_v2_3_20260612.md §2.8` (4-dim framing): the same 4 memory dimensions Manual Slop uses. nagent is the upstream of Manual Slop's memory model. +- `nagent_review_v2_3_20260612.md §3.9` (Per-file knowledge notes): the durable knowledge dimension. The "per-file notes" pattern is a GAP in Manual Slop's current implementation (Candidate 11.1). +- `nagent_review_v2_3_20260612.md §3.1` (Knowledge harvest): the provenance-aware plain markdown + sha256 ledger. Same shape as Manual Slop's `knowledge_artifacts.md`. +- `nagent_review_v2_3_20260612.md §4.4` (Sub-pattern detail): the harvest workflow. + +### The verdict: Useful + nagent-stronger + +**Verdict: Useful + nagent-stronger.** + +Fable's `window.storage` API + hierarchical-keys + single-key batching + personal-vs-shared scope + try/catch rules are genuinely useful engineering guidance for a KV client library. But they constitute an API reference, not a memory architecture. + +Manual Slop's 4 memory dimensions are the stronger, more grounded model: each dim has a named shape, user-editable surface, query model, and (for knowledge) provenance-aware harvest + audit ledger. nagent's knowledge harvest + per-file notes is the strong version of Fable's "memory" framing. + +The named gap is the per-file notes dimension (Candidate 11.1 per nagent §3.9). The deferred rebuild should add this to the project's knowledge dim. + +The strongest claim: memory is plural. Fable has 1 opaque KV store; Manual Slop has 4 named dimensions with non-interchangeable shapes. The data-oriented parallel: Fable's `try/catch` is JS-idiomatic control flow; Manual Slop's `Result[T]` + `ErrorInfo` + ledger status markers (`harvested`/`harvest-failed`/`too-large`/`deleted-unharvested`) is the data-oriented equivalent. + +### Sub-verdicts by line range + +- **Lines 168, 170** (memory disclosure): Useful. +- **Line 173** (persistent-storage disclosure): Useful. +- **Line 177** (API surface): Useful. +- **Line 203** (hierarchical-keys pattern): Useful. +- **Line 204** (key-validation rule): Useful. +- **Line 205** (batching pattern): Useful. +- **Lines 211, 213** (personal-vs-shared scope): Useful. +- **Line 218** (try/catch): Mixed (JS-idiomatic; Manual Slop uses `Result[T]`). + +### Synthesis section handoffs + +- **§13 (Genuinely Useful)** gets the hierarchical-keys + batching + scope + error-handling principles. +- **§14 (Anti-User Watchdog)** gets the "memory is a Settings toggle" framing as a transparency gap (no audit, no selective delete); contrast with the project's `ledger.json` + plain-text-edit + "delete to turn off" pattern. + +### What the deferred rebuild should do + +- **Adopt the hierarchical-keys pattern** (Fable System Prompt.md:203). Manual Slop destination: a new section in `conductor/code_styleguides/knowledge_artifacts.md` titled "Hierarchical Keys for Knowledge Files." Priority: Medium. +- **Adopt the batching pattern** (Fable System Prompt.md:205). Manual Slop destination: same section. Priority: Low (the project already batches at the harvest step). +- **Adopt the personal-vs-shared scope** (Fable System Prompt.md:211, 213). Manual Slop destination: a new section in `conductor/code_styleguides/knowledge_artifacts.md` titled "Knowledge File Scopes." Priority: Medium. +- **Reject the `try/catch` rule** (Fable System Prompt.md:218). Manual Slop destination: explicit addition to `conductor/code_styleguides/error_handling.md` titled "Use `Result[T]` + `ErrorInfo`, Not `try/catch`." Priority: High (the project already has this rule; the explicit Fable citation is documentation). +- **Implement Candidate 11.1 (per-file knowledge notes)** per nagent §3.9. Manual Slop destination: a new section in `conductor/code_styleguides/knowledge_artifacts.md` titled "Per-File Knowledge Notes." Priority: Medium. ---