cognitive-core 0.2.5 → 0.3.1

package/playbooks/alfworld/cool-and-place.json

@@ -0,0 +1,35 @@
+{
+  "name": "alfworld-cool-and-place",
+  "curatedBy": "alfworld-seed",
+  "confidence": 0.8,
+  "complexity": "moderate",
+  "applicability": {
+    "situations": [
+      "cool some object and put it in a receptacle",
+      "chill an item then place it somewhere"
+    ],
+    "triggers": ["cool", "chill", "cold"],
+    "antiPatterns": ["heating an object (use the microwave, not the fridge)"],
+    "domains": ["embodied"]
+  },
+  "guidance": {
+    "strategy": "Find the object, cool it at the fridge, then place it at the destination receptacle.",
+    "tactics": [
+      "Objects are usually on a countertop, in a cabinet, or on a table — 'go to' likely locations and 'take' the object",
+      "Cooling happens at the fridge: 'go to fridge 1', then 'cool <obj> with fridge 1'",
+      "Open closed receptacles before putting"
+    ],
+    "steps": [
+      "go to a likely source (countertop / cabinet / diningtable)",
+      "take the target object",
+      "go to fridge 1",
+      "cool the object with fridge 1",
+      "go to the destination receptacle",
+      "open it if it is closed",
+      "put the object in/on the receptacle"
+    ]
+  },
+  "verification": {
+    "successIndicators": ["the object is cooled and placed in the target receptacle"]
+  }
+}

package/playbooks/alfworld/examine-in-light.json

@@ -0,0 +1,32 @@
+{
+  "name": "alfworld-examine-in-light",
+  "curatedBy": "alfworld-seed",
+  "confidence": 0.8,
+  "complexity": "simple",
+  "applicability": {
+    "situations": [
+      "examine an object with the desklamp",
+      "look at an object under the desklamp"
+    ],
+    "triggers": ["examine", "look at", "desklamp"],
+    "antiPatterns": ["placing the object anywhere — this task only requires looking at it in light"],
+    "domains": ["embodied"]
+  },
+  "guidance": {
+    "strategy": "Find and take the object, go to the desklamp, and use the desklamp to examine it.",
+    "tactics": [
+      "The object is usually on a desk, shelf, sidetable, or drawer — 'go to' and 'take' it",
+      "The desklamp is usually on a desk or sidetable; 'go to' it",
+      "Finish with 'use desklamp 1' while holding the object — no need to put it down"
+    ],
+    "steps": [
+      "go to a likely source (desk / shelf / sidetable / drawer)",
+      "take the target object",
+      "go to the desklamp",
+      "use the desklamp to examine the object"
+    ]
+  },
+  "verification": {
+    "successIndicators": ["the object is examined under the desklamp while held"]
+  }
+}

package/playbooks/alfworld/heat-and-place.json

@@ -0,0 +1,35 @@
+{
+  "name": "alfworld-heat-and-place",
+  "curatedBy": "alfworld-seed",
+  "confidence": 0.8,
+  "complexity": "moderate",
+  "applicability": {
+    "situations": [
+      "heat some object and put it in a receptacle",
+      "warm up an item then place it somewhere"
+    ],
+    "triggers": ["heat", "warm", "hot"],
+    "antiPatterns": ["cooling an object (use the fridge, not the microwave)"],
+    "domains": ["embodied"]
+  },
+  "guidance": {
+    "strategy": "Find the object, heat it at the microwave, then place it at the destination receptacle.",
+    "tactics": [
+      "Objects are usually on a countertop, in the fridge, or in a cabinet — 'go to' likely locations and 'take' the object",
+      "Heating happens at the microwave: 'go to microwave 1', then 'heat <obj> with microwave 1'",
+      "Open closed receptacles (fridge/cabinet/drawer) before putting"
+    ],
+    "steps": [
+      "go to a likely source (countertop / fridge / cabinet)",
+      "take the target object",
+      "go to microwave 1",
+      "heat the object with microwave 1",
+      "go to the destination receptacle",
+      "open it if it is closed",
+      "put the object in/on the receptacle"
+    ]
+  },
+  "verification": {
+    "successIndicators": ["the object is heated and placed in the target receptacle"]
+  }
+}

package/playbooks/alfworld/pick-and-place.json

@@ -0,0 +1,37 @@
+{
+  "name": "alfworld-pick-and-place",
+  "curatedBy": "alfworld-seed",
+  "confidence": 0.8,
+  "complexity": "simple",
+  "applicability": {
+    "situations": [
+      "put some object in or on a receptacle",
+      "find an object and place it somewhere"
+    ],
+    "triggers": ["put", "place", "find"],
+    "antiPatterns": [
+      "tasks that also require heat/cool/clean — handle the process first",
+      "tasks that require two of the object (that is pick-two)"
+    ],
+    "domains": ["embodied"]
+  },
+  "guidance": {
+    "strategy": "Find the object at a likely location, take it, then place it at the destination receptacle.",
+    "tactics": [
+      "Scan likely sources: countertop, drawer, shelf, cabinet, diningtable, sidetable",
+      "Open closed receptacles (drawer / cabinet / fridge) before taking or putting",
+      "Only one object is needed for this task type"
+    ],
+    "steps": [
+      "go to a likely source for the object",
+      "open it if it is closed",
+      "take the target object",
+      "go to the destination receptacle",
+      "open it if it is closed",
+      "put the object in/on the receptacle"
+    ]
+  },
+  "verification": {
+    "successIndicators": ["the object is placed in/on the target receptacle"]
+  }
+}

package/playbooks/alfworld/pick-two-and-place.json

@@ -0,0 +1,35 @@
+{
+  "name": "alfworld-pick-two-and-place",
+  "curatedBy": "alfworld-seed",
+  "confidence": 0.8,
+  "complexity": "moderate",
+  "applicability": {
+    "situations": [
+      "put two of an object in or on a receptacle",
+      "find two identical items and place both somewhere"
+    ],
+    "triggers": ["put two", "two", "both"],
+    "antiPatterns": ["stopping after placing only one object — two are required"],
+    "domains": ["embodied"]
+  },
+  "guidance": {
+    "strategy": "Place the first object, then return for the second and place it too — the task needs BOTH.",
+    "tactics": [
+      "You can usually only carry one object at a time: take one, place it, then go back for the next",
+      "The two objects may be in different locations — re-scan likely sources for the second",
+      "Open closed receptacles before taking or putting"
+    ],
+    "steps": [
+      "go to a likely source and take the first object",
+      "go to the destination receptacle (open it if closed)",
+      "put the first object in/on the receptacle",
+      "go find the second object (re-scan likely sources)",
+      "take the second object",
+      "go back to the destination receptacle",
+      "put the second object in/on the receptacle"
+    ]
+  },
+  "verification": {
+    "successIndicators": ["both objects are placed in/on the target receptacle"]
+  }
+}

package/.claude/settings.json

@@ -1,197 +0,0 @@
-{
-  "attribution": {
-    "commit": "",
-    "pr": ""
-  },
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code post-task"
-          }
-        ]
-      },
-      {
-        "matcher": "TodoWrite",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code post-todo"
-          }
-        ]
-      },
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-task"
-          }
-        ]
-      },
-      {
-        "matcher": "TodoWrite",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-todo"
-          }
-        ]
-      },
-      {
-        "matcher": "TaskCreate",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-task-create"
-          }
-        ]
-      },
-      {
-        "matcher": "TaskUpdate",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-task-update"
-          }
-        ]
-      },
-      {
-        "matcher": "EnterPlanMode",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-plan-enter"
-          }
-        ]
-      },
-      {
-        "matcher": "ExitPlanMode",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-plan-exit"
-          }
-        ]
-      },
-      {
-        "matcher": "Skill",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code post-skill"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code pre-task"
-          }
-        ]
-      },
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code pre-task"
-          }
-        ]
-      }
-    ],
-    "SessionEnd": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code session-end"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code session-end"
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code session-start"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code session-start"
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code stop"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code stop"
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "entire hooks claude-code user-prompt-submit"
-          }
-        ]
-      },
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "sessionlog hooks claude-code user-prompt-submit"
-          }
-        ]
-      }
-    ]
-  },
-  "permissions": {
-    "deny": [
-      "Read(./.entire/metadata/**)",
-      "Read(./.sessionlog/metadata/**)"
-    ]
-  }
-}

package/.entire/settings.json

@@ -1,4 +0,0 @@
-{
-  "strategy": "manual-commit",
-  "enabled": true
-}

package/.sessionlog/settings.json

@@ -1,4 +0,0 @@
-{
-  "enabled": true,
-  "strategy": "manual-commit"
-}

package/CLAUDE.md

@@ -1,233 +0,0 @@
-# CLAUDE.md
-
-Project conventions and architecture for Claude Code working on cognitive-core.
-
-## Build & Test
-
-```bash
-npm run build          # tsc — compile TypeScript
-npm run test:run       # vitest run — run tests once
-npm test               # vitest — watch mode
-npm run typecheck      # tsc --noEmit — type checking without emit
-npm run lint           # eslint src --ext .ts
-```
-
-Tests use Vitest. All test files are in `tests/` mirroring the `src/` structure.
-
-Pre-existing build warnings exist for `skill-tree` module resolution (3 files in `src/surfacing/`) and some unused variables — these are known issues.
-
-## Project Structure
-
-```
-src/
-├── index.ts                    # Root exports (17 subsystems)
-├── atlas.ts                    # Main orchestrator (Atlas class)
-├── factory.ts                  # Factory interface for external integration
-│
-├── types/                      # Shared type definitions + Zod schemas
-│   ├── task.ts, step.ts, outcome.ts, trajectory.ts, playbook.ts
-│   ├── knowledge.ts, knowledge-graph.ts, memory.ts, meta.ts, config.ts
-│   └── team-trajectory.ts, team-playbook.ts, team-meta.ts
-│
-├── memory/                     # Memory stores
-│   ├── system.ts               # MemorySystem aggregator
-│   ├── experience.ts           # ExperienceMemory (domain-partitioned, InvertedIndex)
-│   ├── playbook.ts             # PlaybookLibrary (domain-partitioned, InvertedIndex)
-│   ├── knowledge-bank.ts       # KnowledgeBank (Markdown + YAML frontmatter)
-│   ├── knowledge-graph.ts      # Multi-layer graph overlay
-│   ├── knowledge-defrag.ts     # Knowledge note deduplication
-│   ├── meta.ts                 # MetaMemory (routing/retrieval observations)
-│   ├── reflexion.ts            # ReflexionMemory (self-reflection episodes)
-│   ├── reasoning-bank.ts       # ReasoningBank (K-means++ clustering)
-│   ├── causal-store.ts         # CausalStore (cause→effect edges)
-│   ├── coherence.ts            # CoherenceChecker (contradiction detection)
-│   ├── temporal-compressor.ts  # TemporalCompressor (Hot/Warm/Cold/Evicted tiers)
-│   ├── candidate-retrieval.ts  # Shared InvertedIndex → fallback retrieval
-│   ├── team-experience.ts      # TeamExperienceMemory
-│   ├── graph-layers/           # Knowledge graph layers (semantic, temporal, causal, entity)
-│   └── search-provider.ts      # SearchProvider strategy (TextSimilarity, Minimem)
-│
-├── learning/                   # Learning pipeline
-│   ├── unified-pipeline.ts     # UnifiedLearningPipeline (three-speed: immediate + batch + maintenance)
-│   ├── analyzer.ts             # TrajectoryAnalyzer (credit assignment + error patterns)
-│   ├── playbook-extractor.ts   # PlaybookExtractor (heuristic generation)
-│   ├── knowledge-extractor.ts  # KnowledgeExtractor (4 heuristic strategies)
-│   ├── reflexion-generator.ts  # ReflexionGenerator (structured self-critique)
-│   ├── meta-learner.ts         # MetaLearner (routing/retrieval effectiveness)
-│   ├── usage-inference.ts      # PlaybookUsageInference
-│   ├── effectiveness.ts        # LearningEffectivenessTracker
-│   ├── instant-loop.ts         # InstantLoop (hot-path, <200ms, no LLM)
-│   ├── energy-evaluator.ts     # EnergyEvaluator (batch trigger logic)
-│   ├── maintenance-scheduler.ts # MaintenanceScheduler (circadian-gated)
-│   ├── healing-orchestrator.ts # HealingOrchestrator (anomaly detection + repair)
-│   ├── team-pipeline.ts        # TeamLearningPipeline
-│   ├── team-ingester.ts        # TeamTrajectoryIngester
-│   ├── team-meta-learner.ts    # TeamMetaLearner
-│   └── trajectory-sources/     # InMemory, File, Pipeline, Entire, Dataclaw, HuggingFace
-│
-├── search/                     # Routing and solving
-│   ├── router.ts               # TaskRouter (strategy selection)
-│   ├── moe-gate.ts             # MoEGate (learned routing via softmax gate)
-│   ├── solver.ts               # DirectSolver
-│   ├── refinement-loop.ts      # RefinementLoop (up to 3 retries)
-│   ├── evaluator.ts            # SolutionEvaluator
-│   ├── verification-runner.ts  # VerificationRunner (command execution)
-│   └── team-router.ts          # TeamRouter (composition recommender)
-│
-├── runtime/                    # Agent execution
-│   ├── manager.ts              # AgentManager (spawning + knowledge injection)
-│   ├── compute-provider.ts     # ComputeProvider (cost tiers)
-│   ├── subprocess.ts           # SubprocessBackend
-│   ├── acp.ts                  # ACPBackend
-│   ├── mock.ts                 # MockBackend
-│   ├── macro-agent.ts          # MacroAgentBackendAdapter
-│   └── learning.ts, validation.ts  # LearningFlow, ValidationFlow
-│
-├── surfacing/                  # Skill library + publishing
-│   ├── skill-library.ts        # SkillLibrary (Core/Domain/Contextual/OnDemand tiers)
-│   ├── skill-publisher.ts      # SkillPublisher (playbook → skill-tree format)
-│   ├── sqlite-storage-adapter.ts  # SQLite persistence for skill-tree
-│   └── team-skill-library.ts   # TeamSkillLibrary
-│
-├── embeddings/                 # Vector search
-│   ├── manager.ts              # EmbeddingManager (multi-provider)
-│   ├── inverted-index.ts       # InvertedIndex (candidate narrowing)
-│   ├── bm25.ts                 # BM25Index (text search fallback)
-│   ├── vector-store.ts         # SqliteVectorStore (sqlite-vec)
-│   └── provider.ts             # OpenAI, Voyage, Local embedding providers
-│
-├── workspace/                  # Agentic analysis
-│   ├── runner.ts               # AgenticTaskRunner
-│   ├── skill-converter.ts      # Playbook ↔ Skill markdown conversion
-│   └── templates/              # 10 workspace templates
-│
-├── session-bank/               # Claude Code CLI integration
-│   ├── session-bank.ts         # SessionBank
-│   ├── git-reader.ts           # EntireGitReader
-│   └── parser.ts               # EntireTranscriptParser
-│
-├── mcp/                        # MCP server (deprecated)
-│   └── playbook-server.ts
-│
-├── persistence/                # Unified SQLite persistence
-│   ├── sqlite-persistence.ts   # SqlitePersistence (WAL mode, prepared statements, CRUD)
-│   ├── serializers.ts          # Date/embedding/JSON serialization helpers
-│   ├── migrator.ts             # One-time JSON→SQLite migration
-│   └── index.ts                # Barrel exports
-│
-├── utils/                      # Shared utilities
-│   ├── similarity.ts           # cosine, jaccard, text, ngram similarity + tokenize
-│   ├── storage.ts              # JsonStore, saveJson, loadJson, ensureDir (legacy)
-│   ├── partitioned-store.ts    # PartitionedStore (legacy, replaced by SqlitePersistence)
-│   ├── validation.ts           # Zod schemas + validators
-│   ├── frontmatter.ts          # YAML frontmatter parsing for knowledge notes
-│   ├── error-classifier.ts     # Unified error classification (shared by analyzer, reflexion, etc.)
-│   └── trajectory-helpers.ts   # Shared action repetition + tool name extraction
-│
-└── bin/
-    └── cognitive-core.ts       # CLI entry point
-```
-
-## Key Architectural Patterns
-
-### Solve pipeline
-`atlas.solve(task)` is the main entry point. After the agent produces a trajectory, processing runs in this order:
-1. **Post-execution subsystems** (per-solve, synchronous) — PlaybookUsageInference, MetaLearner reflection, EffectivenessTracker annotation. These require `RoutingDecision` + injected playbook context, so they only run via `solve()`, NOT via `processTrajectory()`.
-2. **Unified pipeline** — delegates to `UnifiedLearningPipeline` which manages three speeds:
-   - **Immediate** (InstantLoop, <200ms): store experience, bump playbook confidence, extract lightweight knowledge, causal edges, reflexion episodes
-   - **Batch**: triggered by energy evaluation (not just count). Runs full analysis, playbook extraction, temporal compression, re-clustering, pruning
-   - **Maintenance** (circadian-gated): knowledge defrag, healing orchestrator, meta-strategy generation
-
-Atlas delegates all learning to `UnifiedLearningPipeline`. The pipeline owns InstantLoop, EnergyEvaluator, MaintenanceScheduler, and HealingOrchestrator internally.
-
-### processTrajectory() vs solve()
-`atlas.processTrajectory(trajectory)` runs only the unified learning pipeline (immediate + batch + maintenance). The post-execution subsystems (UsageInference, MetaLearner, EffectivenessTracker) do NOT run — they need routing context from `solve()`. Use `processTrajectory()` for feeding external trajectories.
-
-### Shared candidate retrieval
-`memory/candidate-retrieval.ts` implements the "InvertedIndex narrow → fallback to full scan" pattern used by ExperienceMemory, PlaybookLibrary, and CausalStore. Don't duplicate this pattern.
-
-### Shared error classification
-`utils/error-classifier.ts` provides canonical error types used by TrajectoryAnalyzer and ReflexionGenerator. Don't create local error classification — use `classifyError()` or `classifyErrorType()`.
-
-### Shared trajectory helpers
-`utils/trajectory-helpers.ts` provides `detectRepeatedActions()` and `extractToolNames()` used by analyzer, reflexion-generator, and meta-learner. Don't duplicate action counting or tool name regex.
-
-### Unified SQLite persistence
-All system-internal data lives in a single SQLite database (`.atlas/cognitive-core.db`) managed by `SqlitePersistence`. This includes experiences, playbooks, reflexion episodes, causal edges, meta observations/strategies, playbook version history, and system state (MoEGate weights, ReasoningBank clusters, TemporalCompressor pending demotions).
-
-Two persistence layers, separated by audience:
-
-| Layer | What | Format | Managed by |
-|-------|------|--------|------------|
-| **SQLite DB** (system-internal) | Experiences, playbooks, causal edges, meta state, routing weights, version history | `.atlas/cognitive-core.db` | SqlitePersistence |
-| **Files** (agent-accessible) | Knowledge notes | Markdown + YAML frontmatter | KnowledgeBank |
-| | Published skills | skill-tree format | SkillPublisher / SqliteStorageAdapter (own `skills.db`) |
-| | Session transcripts | git orphan branch | SessionBank |
-
-Memory stores (ExperienceMemory, PlaybookLibrary, ReflexionMemory, CausalStore, MetaMemory) use write-through to SQLite — no dirty tracking, immediate INSERT/UPDATE. InvertedIndex is an in-memory cache rebuilt from SQLite on `init()`.
-
-System state for stateful subsystems (MoEGate, ReasoningBank, TemporalCompressor) is persisted via the `system_state` key-value table and restored on startup via `loadPersistedState()`.
-
-Playbook versioning: `snapshotPlaybookVersion()` captures pre-mutation snapshots to `playbook_versions` table on `recordSuccess`, `recordFailure`, and `evolve` calls.
-
-### JSON→SQLite migration
-`persistence/migrator.ts` auto-detects old JSON files on first startup and migrates them to SQLite. Old directories are renamed to `{collection}.migrated/` as backup.
-
-### Knowledge storage
-Knowledge notes are Markdown files with YAML frontmatter. Types: observation, entity, domain-summary. Stored in `knowledge/{observations,entities,domains}/`. Any filesystem-aware agent can read them directly.
-
-### Factory pattern for external consumers
-`factory.ts` provides `CognitiveCoreFactory` for skill-tree and other external integrations. Prefer using factory for external consumers rather than direct imports.
-
-## Coding Conventions
-
-- **TypeScript strict mode** — `noUnusedLocals`, `noUnusedParameters`, `noImplicitReturns`, `noFallthroughCasesInSwitch` all enabled
-- **ES modules** — all imports use `.js` extensions (TypeScript ESM convention)
-- **Target**: ES2022, module: ESNext, moduleResolution: bundler
-- **Creator functions** — every class has a `createX()` factory function exported alongside it (e.g., `createAnalyzer()`, `createMetaLearner()`)
-- **Config pattern** — classes take `Partial<Config>` and merge with `DEFAULT_CONFIG` using spread
-- **Type-only imports** — use `import type { ... }` for types that aren't used at runtime
-- **Re-exports** — each directory has an `index.ts` barrel file; root `index.ts` re-exports everything
-- **No default exports** — all exports are named
-
-## Testing
-
-- Framework: Vitest with `globals: true`
-- Test files mirror source structure: `tests/learning/analyzer.test.ts` tests `src/learning/analyzer.ts`
-- Helper factories for test data: `createTrajectory()`, `createTask()`, `createStep()`, `successOutcome()`, `failureOutcome()`
-- Tests are unit-level; `tests/integration/` has e2e tests
-- Test timeout: 10s default
-
-## Dependencies
-
-Key runtime dependencies:
-- `agent-workspace` — workspace management (WorkspaceManager, WorkspaceHandle)
-- `better-sqlite3` + `sqlite-vec` — unified SQLite persistence + vector store
-- `yaml` — YAML frontmatter parsing
-- `zod` — schema validation
-- `acp-factory` — Agent Communication Protocol
-- `minimem` — optional hybrid search
-- `skill-tree` — skill publishing (has unresolved import issues in surfacing/)
-
-## Common Tasks
-
-### Adding a new memory store
-1. Create `src/memory/my-store.ts` with the store class
-2. Constructor takes `SqlitePersistence` — add table DDL in `sqlite-persistence.ts` `createTables()`
-3. Add to `src/memory/index.ts` barrel exports
-4. Wire into `MemorySystem` in `src/memory/system.ts`
-5. Use `getCandidates()` from `candidate-retrieval.ts` for retrieval if using InvertedIndex
-6. Add to root `src/index.ts` exports
-
-### Adding a new workspace template
-1. Create `src/workspace/templates/my-template.ts`
-2. Export the template constant
-3. Wire into `src/workspace/index.ts`
-
-### Adding a new learning component
-1. Create in `src/learning/`
-2. Wire into `LearningPipeline.batch()` or `InstantLoop.process()` as appropriate
-3. If shared logic exists, add to `utils/error-classifier.ts` or `utils/trajectory-helpers.ts`
-
-### Modifying error classification
-Update `src/utils/error-classifier.ts` — this is the single source of truth. Don't add local error classification logic in consumers.