micode 0.3.4 → 0.4.1

package/README.md

@@ -135,29 +135,55 @@ Each task gets its own implement→review loop:
 
 ### 4. Session Continuity
 
-Maintain context across long sessions and context clears with the ledger system:
+Maintain context across long sessions and context clears with structured compaction:
 
 #### Ledger System
 
-The **continuity ledger** captures essential session state:
+The **continuity ledger** serves as both session state and compaction summary. Based on [Factory.ai's structured compaction research](https://factory.ai/blog/context-compression), which found that structured summarization with deterministic file tracking retains more useful context.
 
 ```
 /ledger
 ```
 
 Creates/updates `thoughts/ledgers/CONTINUITY_{session-name}.md` with:
-- Goal and constraints
-- Key decisions with rationale
-- Current state (Done/Now/Next)
-- Working set (branch, key files)
 
-**Auto-injection:** When starting a session, the most recent ledger is automatically injected into the system prompt.
+```markdown
+# Session: {name}
+Updated: {timestamp}
+
+## Goal
+## Constraints
+## Progress
+### Done
+- [x] {Completed items}
+### In Progress
+- [ ] {Current work}
+### Blocked
+- {Issues, if any}
+## Key Decisions
+- **{Decision}**: {Rationale}
+## Next Steps
+1. {Ordered list}
+## File Operations
+### Read
+- `{paths read since last compaction}`
+### Modified
+- `{paths written/edited since last compaction}`
+## Critical Context
+- {Data, examples, references needed to continue}
+```
+
+**Key features:**
+
+- **Iterative merging** - Updates preserve existing information, adding new progress rather than regenerating from scratch
+- **Deterministic file tracking** - Read/write/edit operations tracked automatically via tool call interception, not LLM extraction
+- **Auto-injection** - Most recent ledger injected into system prompt on session start
 
 **Auto-clear:** At 80% context usage, the system automatically:
-1. Updates the ledger
-2. Creates a handoff document
+1. Captures file operations tracked since last clear
+2. Updates ledger with current state (iterative merge with previous)
 3. Clears the session
-4. Injects the ledger into the fresh context
+4. Injects the updated ledger into fresh context
 
 #### Artifact Search
 
@@ -170,26 +196,17 @@ Search past work to find relevant precedent:
 
 Searches across:
 - Ledgers (`thoughts/ledgers/`)
-- Handoffs (`thoughts/shared/handoffs/`)
 - Plans (`thoughts/shared/plans/`)
 
 **Auto-indexing:** Artifacts are automatically indexed when created.
 
-#### Handoff
-
-Save/resume session state for continuity:
-
-- `handoff-creator`: Save current session (reads ledger for context)
-- `handoff-resumer`: Resume from handoff
-- Output: `thoughts/shared/handoffs/`
-
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `/init` | Initialize project with ARCHITECTURE.md and CODE_STYLE.md |
 | `/ledger` | Create or update continuity ledger for session state |
-| `/search` | Search past handoffs, plans, and ledgers |
+| `/search` | Search past plans and ledgers |
 
 ## Agents
 
@@ -207,8 +224,6 @@ Save/resume session state for continuity:
 | reviewer | subagent | claude-opus-4-5 | Review correctness and style |
 | ledger-creator | subagent | claude-sonnet | Create/update continuity ledgers |
 | artifact-searcher | subagent | claude-sonnet | Search past work for precedent |
-| handoff-creator | subagent | claude-opus-4-5 | Save session state |
-| handoff-resumer | subagent | claude-opus-4-5 | Resume from handoff |
 
 ## Tools
 
@@ -217,7 +232,7 @@ Save/resume session state for continuity:
 | `ast_grep_search` | AST-aware code pattern search |
 | `ast_grep_replace` | AST-aware code pattern replacement |
 | `look_at` | Extract file structure for large files |
-| `artifact_search` | Search past handoffs, plans, and ledgers |
+| `artifact_search` | Search past plans and ledgers |
 | `background_task` | Run long-running tasks in background |
 | `background_output` | Check background task status/output |
 | `background_cancel` | Cancel background tasks |
@@ -229,7 +244,8 @@ Save/resume session state for continuity:
 |------|-------------|
 | Think Mode | Keywords like "think hard" enable 32k token thinking budget |
 | Ledger Loader | Injects continuity ledger into system prompt |
-| Auto-Clear Ledger | At 80% context, saves ledger + handoff and clears session |
+| Auto-Clear Ledger | At 80% context, saves ledger with file ops and clears session |
+| File Ops Tracker | Tracks read/write/edit tool calls for deterministic file operation logging |
 | Artifact Auto-Index | Indexes artifacts when written to thoughts/ directories |
 | Auto-Compact | Summarizes session when hitting token limits |
 | Context Injector | Injects ARCHITECTURE.md, CODE_STYLE.md, .cursorrules |
@@ -276,8 +292,7 @@ micode/
     ├── ledgers/        # Continuity ledgers
     └── shared/
         ├── designs/    # Brainstorm outputs
-        ├── plans/      # Implementation plans
-        └── handoffs/   # Session handoffs
+        └── plans/      # Implementation plans
 ```
 
 ## Development
@@ -341,3 +356,4 @@ Built on techniques from:
 
 - **[oh-my-opencode](https://github.com/code-yeongyu/oh-my-opencode)** - OpenCode plugin architecture, agent orchestration patterns, and trusted publishing setup
 - **[HumanLayer ACE-FCA](https://github.com/humanlayer/12-factor-agents)** - Advanced Context Engineering for Coding Agents, structured workflows, and the research → plan → implement methodology
+- **[Factory.ai Context Compression](https://factory.ai/blog/context-compression)** - Structured compaction research showing that anchored iterative summarization with deterministic file tracking outperforms generic compression

package/dist/agents/index.d.ts

@@ -7,11 +7,9 @@ import { plannerAgent } from "./planner";
 import { implementerAgent } from "./implementer";
 import { reviewerAgent } from "./reviewer";
 import { executorAgent } from "./executor";
-import { handoffCreatorAgent } from "./handoff-creator";
-import { handoffResumerAgent } from "./handoff-resumer";
 import { primaryAgent, PRIMARY_AGENT_NAME } from "./commander";
 import { projectInitializerAgent } from "./project-initializer";
 import { ledgerCreatorAgent } from "./ledger-creator";
 import { artifactSearcherAgent } from "./artifact-searcher";
 export declare const agents: Record<string, AgentConfig>;
-export { primaryAgent, PRIMARY_AGENT_NAME, brainstormerAgent, codebaseLocatorAgent, codebaseAnalyzerAgent, patternFinderAgent, plannerAgent, implementerAgent, reviewerAgent, executorAgent, handoffCreatorAgent, handoffResumerAgent, projectInitializerAgent, ledgerCreatorAgent, artifactSearcherAgent, };
+export { primaryAgent, PRIMARY_AGENT_NAME, brainstormerAgent, codebaseLocatorAgent, codebaseAnalyzerAgent, patternFinderAgent, plannerAgent, implementerAgent, reviewerAgent, executorAgent, projectInitializerAgent, ledgerCreatorAgent, artifactSearcherAgent, };

package/dist/hooks/artifact-auto-index.d.ts

@@ -1,4 +1,14 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+export declare function parseLedger(content: string, filePath: string, sessionName: string): {
+    id: string;
+    sessionName: string;
+    filePath: string;
+    goal: string;
+    stateNow: string;
+    keyDecisions: string;
+    filesRead: string;
+    filesModified: string;
+};
 export declare function createArtifactAutoIndexHook(_ctx: PluginInput): {
     "tool.execute.after": (input: {
         tool: string;

package/dist/hooks/file-ops-tracker.d.ts

@@ -0,0 +1,26 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface FileOps {
+    read: Set<string>;
+    modified: Set<string>;
+}
+export declare function trackFileOp(sessionID: string, operation: "read" | "write" | "edit", filePath: string): void;
+export declare function getFileOps(sessionID: string): FileOps;
+export declare function clearFileOps(sessionID: string): void;
+export declare function getAndClearFileOps(sessionID: string): FileOps;
+export declare function formatFileOpsForPrompt(ops: FileOps): string;
+export declare function createFileOpsTrackerHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        args?: Record<string, unknown>;
+    }, _output: {
+        output?: string;
+    }) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/index.js

@@ -763,14 +763,22 @@ Batch 3 (parallel):
     Executes ONE task from the plan.
     Input: Single task with context (which files, what to do).
     Output: Changes made and verification results for that task.
+    Invoke with: Task tool, subagent_type="implementer"
   </subagent>
   <subagent name="reviewer" spawn="parallel-per-task">
     Reviews ONE task's implementation.
     Input: Single task's changes against its requirements.
     Output: APPROVED or CHANGES REQUESTED for that task.
+    Invoke with: Task tool, subagent_type="reviewer"
   </subagent>
 </available-subagents>
 
+<critical-instruction>
+You MUST use the Task tool to spawn implementer and reviewer subagents.
+Example: Task(description="Implement task 1", prompt="...", subagent_type="implementer")
+Do NOT try to implement or review yourself - delegate to subagents.
+</critical-instruction>
+
 <per-task-cycle>
 For each task:
 1. Spawn implementer with task details
@@ -782,18 +790,17 @@ For each task:
 </per-task-cycle>
 
 <parallel-spawning>
-Within a batch, spawn ALL implementers in a SINGLE message:
-
-Example for batch with tasks 1, 2, 3:
-- In ONE message, spawn:
-  - implementer: "Execute task 1: [details]"
-  - implementer: "Execute task 2: [details]"
-  - implementer: "Execute task 3: [details]"
-
-Then after all complete, in ONE message spawn:
-  - reviewer: "Review task 1 implementation"
-  - reviewer: "Review task 2 implementation"
-  - reviewer: "Review task 3 implementation"
+Within a batch, spawn ALL implementers in a SINGLE message using the Task tool:
+
+Example for batch with tasks 1, 2, 3 - call Task tool 3 times in ONE message:
+- Task(description="Task 1", prompt="Execute task 1: [details]", subagent_type="implementer")
+- Task(description="Task 2", prompt="Execute task 2: [details]", subagent_type="implementer")
+- Task(description="Task 3", prompt="Execute task 3: [details]", subagent_type="implementer")
+
+Then after all complete, in ONE message call Task tool for reviewers:
+- Task(description="Review 1", prompt="Review task 1 implementation", subagent_type="reviewer")
+- Task(description="Review 2", prompt="Review task 2 implementation", subagent_type="reviewer")
+- Task(description="Review 3", prompt="Review task 3 implementation", subagent_type="reviewer")
 </parallel-spawning>
 
 <rules>
@@ -848,159 +855,6 @@ Then after all complete, in ONE message spawn:
 </never-do>`
 };
 
-// src/agents/handoff-creator.ts
-var handoffCreatorAgent = {
-  description: "Creates handoff documents for session continuity",
-  mode: "subagent",
-  model: "anthropic/claude-opus-4-5",
-  temperature: 0.2,
-  tools: {
-    edit: false,
-    task: false
-  },
-  prompt: `<purpose>
-Create handoff document to transfer context to future session.
-</purpose>
-
-<when-to-use>
-<trigger>Hitting context limits</trigger>
-<trigger>Ending work session</trigger>
-<trigger>Switching to different task</trigger>
-</when-to-use>
-
-<rules>
-<rule>FIRST check for existing ledger at thoughts/ledgers/CONTINUITY_*.md</rule>
-<rule>If ledger exists, use its session name for handoff directory</rule>
-<rule>Capture ALL in-progress work</rule>
-<rule>Include exact file:line references for changes</rule>
-<rule>Document learnings and gotchas</rule>
-<rule>Prioritize next steps clearly</rule>
-<rule>Include git state (branch, commit)</rule>
-<rule>Reference all artifacts created</rule>
-</rules>
-
-<process>
-<step>Check for ledger at thoughts/ledgers/CONTINUITY_*.md</step>
-<step>If ledger exists, extract session name and state</step>
-<step>Review what was worked on</step>
-<step>Check git status for uncommitted changes</step>
-<step>Gather learnings and decisions made</step>
-<step>Identify next steps in priority order</step>
-<step>Write handoff document</step>
-<step>Commit handoff document</step>
-</process>
-
-<output-path>
-If ledger exists: thoughts/shared/handoffs/{session-name}/YYYY-MM-DD_HH-MM-SS.md
-Otherwise: thoughts/shared/handoffs/YYYY-MM-DD_HH-MM-SS_description.md
-</output-path>
-
-<document-format>
-<frontmatter>
-date: [ISO datetime]
-branch: [branch name]
-commit: [hash]
-session: [session name from ledger, if available]
-</frontmatter>
-<sections>
-<section name="Tasks">Table with Task | Status (completed/in-progress/blocked)</section>
-<section name="Current State">Working on, Blocked by, Plan location</section>
-<section name="Changes Made">file:line - what changed</section>
-<section name="Learnings">Discoveries, gotchas, decisions made and why</section>
-<section name="Next Steps">Prioritized list 1-3</section>
-<section name="Notes">Anything else for next session</section>
-</sections>
-</document-format>
-
-<output-summary>
-<template>
-Handoff: [path]
-Tasks: [X done, Y in-progress]
-Next: [top priority]
-</template>
-</output-summary>`
-};
-
-// src/agents/handoff-resumer.ts
-var handoffResumerAgent = {
-  description: "Resumes work from a handoff document",
-  mode: "subagent",
-  model: "anthropic/claude-opus-4-5",
-  temperature: 0.2,
-  tools: {
-    write: false,
-    edit: false,
-    task: false
-  },
-  prompt: `<purpose>
-Resume work from a handoff document. Verify state before proceeding.
-</purpose>
-
-<rules>
-<rule>Read handoff document COMPLETELY</rule>
-<rule>Load ALL referenced artifacts</rule>
-<rule>Verify git state matches</rule>
-<rule>Check for changes since handoff</rule>
-<rule>Report discrepancies before proceeding</rule>
-<rule>Don't assume - verify</rule>
-</rules>
-
-<process>
-<step>Find handoff (use provided path or list available)</step>
-<step>Read handoff completely</step>
-<step>Load referenced plans, research, files</step>
-<step>Verify current state matches</step>
-<step>Report analysis</step>
-<step>Wait for confirmation</step>
-</process>
-
-<state-verification>
-<check>Current branch</check>
-<check>Commit history (ahead/behind)</check>
-<check>Files mentioned still exist</check>
-<check>Changes mentioned are present</check>
-<check>No conflicting changes made</check>
-</state-verification>
-
-<output-format>
-<template>
-## Resuming: [handoff path]
-
-**Created**: [date]
-**Branch**: [expected] \u2192 [actual]
-**Commit**: [expected] \u2192 [actual]
-
-### State
-- Branch: [matches/differs]
-- Commit: [matches/X ahead/X behind]
-- Files: [verified/issues]
-
-### Tasks
-| Task | Status | Verified |
-|------|--------|----------|
-| [Task] | [status] | [yes/no] |
-
-### Learnings
-- [From handoff]
-
-### Next Action
-[Top priority from handoff]
-
-### Loaded
-- [x] [artifact]
-- [x] [artifact]
-</template>
-</output-format>
-
-<on-mismatch>
-<action>Report discrepancy and wait for guidance</action>
-<discrepancy>Branch different</discrepancy>
-<discrepancy>Unexpected commits</discrepancy>
-<discrepancy>Files changed/missing</discrepancy>
-<discrepancy>Conflicting work detected</discrepancy>
-</on-mismatch>`
-};
-
 // src/agents/commander.ts
 var PROMPT = `<identity>
 You are Commander - pragmatic software engineer and orchestrator.
@@ -1078,9 +932,9 @@ Just do it - including obvious follow-up actions.
 <rule>Reference plan file in commit body</rule>
 </phase>
 
-<phase name="handoff">
-<agent name="handoff-creator">Save session state</agent>
-<agent name="handoff-resumer">Resume from handoff</agent>
+<phase name="ledger" trigger="context getting full or session ending">
+<action>System auto-updates ledger at 80% context usage</action>
+<output>thoughts/ledgers/CONTINUITY_{session-name}.md</output>
 </phase>
 </workflow>
 
@@ -1091,8 +945,7 @@ Just do it - including obvious follow-up actions.
 <agent name="pattern-finder" mode="subagent" purpose="Find existing patterns"/>
 <agent name="planner" mode="subagent" purpose="Create detailed implementation plans"/>
 <agent name="executor" mode="subagent" purpose="Execute plan (runs implementer then reviewer automatically)"/>
-<agent name="handoff-creator" mode="subagent" purpose="Create handoff docs"/>
-<agent name="handoff-resumer" mode="subagent" purpose="Resume from handoffs"/>
+<agent name="ledger-creator" mode="subagent" purpose="Create/update continuity ledgers"/>
 <parallelization>
 <safe>locator, analyzer, pattern-finder</safe>
 <sequential>planner then executor</sequential>
@@ -1186,17 +1039,25 @@ var PROMPT2 = `
     <subagent name="codebase-locator" spawn="multiple">
       Fast file/pattern finder. Spawn multiple with different queries.
       Examples: "Find all entry points", "Find all config files", "Find test directories"
+      Invoke with: Task tool, subagent_type="codebase-locator"
     </subagent>
     <subagent name="codebase-analyzer" spawn="multiple">
       Deep module analyzer. Spawn multiple for different areas.
       Examples: "Analyze src/core", "Analyze api layer", "Analyze database module"
+      Invoke with: Task tool, subagent_type="codebase-analyzer"
     </subagent>
     <subagent name="pattern-finder" spawn="multiple">
       Pattern extractor. Spawn for different pattern types.
       Examples: "Find naming patterns", "Find error handling patterns", "Find async patterns"
+      Invoke with: Task tool, subagent_type="pattern-finder"
     </subagent>
   </available-subagents>
 
+  <critical-instruction>
+  You MUST use the Task tool to spawn subagents. Call multiple Task tools in a SINGLE message for parallelism.
+  Example: Task(description="Find entry points", prompt="Find all entry points and main files", subagent_type="codebase-locator")
+  </critical-instruction>
+
   <language-detection>
     <rule>Identify language(s) by examining file extensions and config files</rule>
     <markers>
@@ -1290,22 +1151,19 @@ var PROMPT2 = `
 
   <execution-example>
     <step description="Start with maximum parallelism">
-      In a SINGLE message, spawn:
-      - codebase-locator: "Find all entry points and main files"
-      - codebase-locator: "Find all config files (linters, formatters, build)"
-      - codebase-locator: "Find test directories and test files"
-      - codebase-analyzer: "Analyze the directory structure and organization"
-      - pattern-finder: "Find naming conventions used across the codebase"
-
-      AND run tools:
+      In a SINGLE message, call Task tool multiple times AND run other tools:
+      - Task(description="Find entry points", prompt="Find all entry points and main files", subagent_type="codebase-locator")
+      - Task(description="Find configs", prompt="Find all config files (linters, formatters, build)", subagent_type="codebase-locator")
+      - Task(description="Find tests", prompt="Find test directories and test files", subagent_type="codebase-locator")
+      - Task(description="Analyze structure", prompt="Analyze the directory structure and organization", subagent_type="codebase-analyzer")
+      - Task(description="Find patterns", prompt="Find naming conventions used across the codebase", subagent_type="pattern-finder")
       - Glob: package.json, pyproject.toml, go.mod, Cargo.toml, etc.
       - Glob: README*, ARCHITECTURE*, docs/*
-      - Bash: ls -la (root directory)
     </step>
 
     <step description="Parallel deep analysis">
-      Based on discovery, in a SINGLE message spawn:
-      - codebase-analyzer for each major module found
+      Based on discovery, in a SINGLE message:
+      - Task for each major module: subagent_type="codebase-analyzer"
       - Read multiple source files simultaneously
       - Read multiple test files simultaneously
     </step>
@@ -1339,19 +1197,50 @@ Create or update a continuity ledger to preserve session state across context cl
 The ledger captures the essential context needed to resume work seamlessly.
 </purpose>
 
+<modes>
+<mode name="initial">Create new ledger when none exists</mode>
+<mode name="iterative">Update existing ledger with new information</mode>
+</modes>
+
 <rules>
 <rule>Keep the ledger CONCISE - only essential information</rule>
 <rule>Focus on WHAT and WHY, not HOW</rule>
-<rule>State should have exactly ONE item in "Now"</rule>
 <rule>Mark uncertain information as UNCONFIRMED</rule>
 <rule>Include git branch and key file paths</rule>
 </rules>
 
+<iterative-update-rules>
+<rule>PRESERVE all existing information from previous ledger</rule>
+<rule>ADD new progress, decisions, context from new messages</rule>
+<rule>UPDATE Progress: move In Progress items to Done when completed</rule>
+<rule>UPDATE Next Steps based on current state</rule>
+<rule>MERGE file operations: combine previous + new (passed deterministically)</rule>
+<rule>Never lose information - only add or update</rule>
+</iterative-update-rules>
+
+<input-format-for-update>
+When updating an existing ledger, you will receive:
+
+<previous-ledger>
+{content of existing ledger}
+</previous-ledger>
+
+<file-operations>
+Read: path1, path2, path3
+Modified: path4, path5
+</file-operations>
+
+<instruction>
+Update the ledger with the current session state. Merge the file operations above with any existing ones in the previous ledger.
+</instruction>
+</input-format-for-update>
+
 <process>
-<step>Check for existing ledger at thoughts/ledgers/CONTINUITY_*.md</step>
-<step>If exists, read and update it</step>
-<step>If not, create new ledger with session name from current task</step>
+<step>Check if previous-ledger is provided in input</step>
+<step>If provided: parse existing content and merge with new state</step>
+<step>If not: create new ledger with session name from current task</step>
 <step>Gather current state: goal, decisions, progress, blockers</step>
+<step>Merge file operations (previous + new from input)</step>
 <step>Write ledger in the exact format below</step>
 </process>
 
@@ -1362,21 +1251,37 @@ The ledger captures the essential context needed to resume work seamlessly.
 Updated: {ISO timestamp}
 
 ## Goal
-{One sentence describing success criteria}
+{What we're trying to accomplish - one sentence describing success criteria}
 
 ## Constraints
 {Technical requirements, patterns to follow, things to avoid}
 
+## Progress
+### Done
+- [x] {Completed items}
+
+### In Progress
+- [ ] {Current work - what's actively being worked on}
+
+### Blocked
+- {Issues preventing progress, if any}
+
 ## Key Decisions
-- {Decision}: {Rationale}
+- **{Decision}**: {Rationale}
+
+## Next Steps
+1. {Ordered list of what to do next}
 
-## State
-- Done: {Completed items as comma-separated list}
-- Now: {Current focus - exactly ONE thing}
-- Next: {Queued items in priority order}
+## File Operations
+### Read
+- \`{paths that were read}\`
 
-## Open Questions
-- UNCONFIRMED: {Things needing verification}
+### Modified
+- \`{paths that were written or edited}\`
+
+## Critical Context
+- {Data, examples, references needed to continue work}
+- {Important findings or discoveries}
 
 ## Working Set
 - Branch: \`{branch-name}\`
@@ -1385,7 +1290,7 @@ Updated: {ISO timestamp}
 
 <output-summary>
 Ledger updated: thoughts/ledgers/CONTINUITY_{session-name}.md
-State: {Now item}
+State: {Current In Progress item}
 </output-summary>`
 };
 
@@ -1445,8 +1350,6 @@ var agents = {
   implementer: implementerAgent,
   reviewer: reviewerAgent,
   executor: executorAgent,
-  "handoff-creator": handoffCreatorAgent,
-  "handoff-resumer": handoffResumerAgent,
   "project-initializer": projectInitializerAgent,
   "ledger-creator": ledgerCreatorAgent,
   "artifact-searcher": artifactSearcherAgent
@@ -14144,18 +14047,6 @@ class ArtifactIndex {
   }
   getInlineSchema() {
     return `
-      CREATE TABLE IF NOT EXISTS handoffs (
-        id TEXT PRIMARY KEY,
-        session_name TEXT,
-        file_path TEXT UNIQUE NOT NULL,
-        task_summary TEXT,
-        what_worked TEXT,
-        what_failed TEXT,
-        learnings TEXT,
-        outcome TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
       CREATE TABLE IF NOT EXISTS plans (
         id TEXT PRIMARY KEY,
         title TEXT,
@@ -14172,55 +14063,15 @@ class ArtifactIndex {
         goal TEXT,
         state_now TEXT,
         key_decisions TEXT,
+        files_read TEXT,
+        files_modified TEXT,
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       );
-      CREATE VIRTUAL TABLE IF NOT EXISTS handoffs_fts USING fts5(id, session_name, task_summary, what_worked, what_failed, learnings);
       CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(id, title, overview, approach);
       CREATE VIRTUAL TABLE IF NOT EXISTS ledgers_fts USING fts5(id, session_name, goal, state_now, key_decisions);
     `;
   }
-  async indexHandoff(record2) {
-    if (!this.db)
-      throw new Error("Database not initialized");
-    const existing = this.db.query(`SELECT id FROM handoffs WHERE file_path = ?`).get(record2.filePath);
-    if (existing) {
-      this.db.run(`DELETE FROM handoffs_fts WHERE id = ?`, [existing.id]);
-    }
-    this.db.run(`
-      INSERT INTO handoffs (id, session_name, file_path, task_summary, what_worked, what_failed, learnings, outcome, indexed_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-      ON CONFLICT(file_path) DO UPDATE SET
-        id = excluded.id,
-        session_name = excluded.session_name,
-        task_summary = excluded.task_summary,
-        what_worked = excluded.what_worked,
-        what_failed = excluded.what_failed,
-        learnings = excluded.learnings,
-        outcome = excluded.outcome,
-        indexed_at = CURRENT_TIMESTAMP
-    `, [
-      record2.id,
-      record2.sessionName ?? null,
-      record2.filePath,
-      record2.taskSummary ?? null,
-      record2.whatWorked ?? null,
-      record2.whatFailed ?? null,
-      record2.learnings ?? null,
-      record2.outcome ?? null
-    ]);
-    this.db.run(`
-      INSERT INTO handoffs_fts (id, session_name, task_summary, what_worked, what_failed, learnings)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `, [
-      record2.id,
-      record2.sessionName ?? null,
-      record2.taskSummary ?? null,
-      record2.whatWorked ?? null,
-      record2.whatFailed ?? null,
-      record2.learnings ?? null
-    ]);
-  }
   async indexPlan(record2) {
     if (!this.db)
       throw new Error("Database not initialized");
@@ -14251,14 +14102,16 @@ class ArtifactIndex {
       this.db.run(`DELETE FROM ledgers_fts WHERE id = ?`, [existing.id]);
     }
     this.db.run(`
-      INSERT INTO ledgers (id, session_name, file_path, goal, state_now, key_decisions, indexed_at)
-      VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      INSERT INTO ledgers (id, session_name, file_path, goal, state_now, key_decisions, files_read, files_modified, indexed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
       ON CONFLICT(file_path) DO UPDATE SET
         id = excluded.id,
         session_name = excluded.session_name,
         goal = excluded.goal,
         state_now = excluded.state_now,
         key_decisions = excluded.key_decisions,
+        files_read = excluded.files_read,
+        files_modified = excluded.files_modified,
         indexed_at = CURRENT_TIMESTAMP
     `, [
       record2.id,
@@ -14266,7 +14119,9 @@ class ArtifactIndex {
       record2.filePath,
       record2.goal ?? null,
       record2.stateNow ?? null,
-      record2.keyDecisions ?? null
+      record2.keyDecisions ?? null,
+      record2.filesRead ?? null,
+      record2.filesModified ?? null
     ]);
     this.db.run(`
       INSERT INTO ledgers_fts (id, session_name, goal, state_now, key_decisions)
@@ -14284,23 +14139,6 @@ class ArtifactIndex {
       throw new Error("Database not initialized");
     const results = [];
     const escapedQuery = this.escapeFtsQuery(query);
-    const handoffs = this.db.query(`
-      SELECT h.id, h.file_path, h.task_summary, rank
-      FROM handoffs_fts
-      JOIN handoffs h ON handoffs_fts.id = h.id
-      WHERE handoffs_fts MATCH ?
-      ORDER BY rank
-      LIMIT ?
-    `).all(escapedQuery, limit);
-    for (const row of handoffs) {
-      results.push({
-        type: "handoff",
-        id: row.id,
-        filePath: row.file_path,
-        summary: row.task_summary,
-        score: -row.rank
-      });
-    }
     const plans = this.db.query(`
       SELECT p.id, p.file_path, p.title, rank
       FROM plans_fts
@@ -14360,7 +14198,7 @@ async function getArtifactIndex() {
 
 // src/tools/artifact-search.ts
 var artifact_search = tool({
-  description: `Search past handoffs, plans, and ledgers for relevant precedent.
+  description: `Search past plans and ledgers for relevant precedent.
 Use this to find:
 - Similar problems you've solved before
 - Patterns and approaches that worked
@@ -14369,7 +14207,7 @@ Returns ranked results with file paths for further reading.`,
   args: {
     query: tool.schema.string().describe("Search query - describe what you're looking for"),
     limit: tool.schema.number().optional().describe("Max results to return (default: 10)"),
-    type: tool.schema.enum(["all", "handoff", "plan", "ledger"]).optional().describe("Filter by artifact type (default: all)")
+    type: tool.schema.enum(["all", "plan", "ledger"]).optional().describe("Filter by artifact type (default: all)")
   },
   execute: async (args) => {
     try {
@@ -15261,6 +15099,69 @@ ${output.system}`;
   };
 }
 
+// src/hooks/file-ops-tracker.ts
+var sessionFileOps = new Map;
+function getOrCreateOps(sessionID) {
+  let ops = sessionFileOps.get(sessionID);
+  if (!ops) {
+    ops = { read: new Set, modified: new Set };
+    sessionFileOps.set(sessionID, ops);
+  }
+  return ops;
+}
+function trackFileOp(sessionID, operation, filePath) {
+  const ops = getOrCreateOps(sessionID);
+  if (operation === "read") {
+    ops.read.add(filePath);
+  } else {
+    ops.modified.add(filePath);
+  }
+}
+function getFileOps(sessionID) {
+  const ops = sessionFileOps.get(sessionID);
+  if (!ops) {
+    return { read: new Set, modified: new Set };
+  }
+  return ops;
+}
+function clearFileOps(sessionID) {
+  sessionFileOps.delete(sessionID);
+}
+function formatFileOpsForPrompt(ops) {
+  const readPaths = Array.from(ops.read).sort();
+  const modifiedPaths = Array.from(ops.modified).sort();
+  let result = `<file-operations>
+`;
+  result += `Read: ${readPaths.length > 0 ? readPaths.join(", ") : "(none)"}
+`;
+  result += `Modified: ${modifiedPaths.length > 0 ? modifiedPaths.join(", ") : "(none)"}
+`;
+  result += "</file-operations>";
+  return result;
+}
+function createFileOpsTrackerHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, _output) => {
+      const toolName = input.tool.toLowerCase();
+      if (!["read", "write", "edit"].includes(toolName)) {
+        return;
+      }
+      const filePath = input.args?.filePath;
+      if (!filePath)
+        return;
+      trackFileOp(input.sessionID, toolName, filePath);
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        if (props?.info?.id) {
+          clearFileOps(props.info.id);
+        }
+      }
+    }
+  };
+}
+
 // src/hooks/auto-clear-ledger.ts
 var MODEL_CONTEXT_LIMITS2 = {
   "claude-opus": 200000,
@@ -15337,23 +15238,40 @@ function createAutoClearLedgerHook(ctx) {
           duration: 3000
         }
       }).catch(() => {});
+      const fileOps = getFileOps(sessionID);
+      const existingLedger = await findCurrentLedger(ctx.directory);
       const ledgerSessionResp = await ctx.client.session.create({
         body: {},
         query: { directory: ctx.directory }
       });
       const ledgerSessionID = ledgerSessionResp.data?.id;
       if (ledgerSessionID) {
+        let promptText = "";
+        if (existingLedger) {
+          promptText += `<previous-ledger>
+${existingLedger.content}
+</previous-ledger>
+
+`;
+        }
+        promptText += formatFileOpsForPrompt(fileOps);
+        promptText += `
+
+<instruction>
+`;
+        promptText += existingLedger ? "Update the ledger with the current session state. Merge the file operations above with any existing ones in the previous ledger." : "Create a new continuity ledger for this session.";
+        promptText += `
+</instruction>`;
         await ctx.client.session.prompt({
           path: { id: ledgerSessionID },
           body: {
-            parts: [
-              { type: "text", text: "Update the continuity ledger with current session state before context clear." }
-            ],
+            parts: [{ type: "text", text: promptText }],
             agent: "ledger-creator"
           },
           query: { directory: ctx.directory }
         });
         let attempts = 0;
+        let ledgerCompleted = false;
         while (attempts < 30) {
           await new Promise((resolve2) => setTimeout(resolve2, 2000));
           const statusResp = await ctx.client.session.get({
@@ -15361,41 +15279,13 @@ function createAutoClearLedgerHook(ctx) {
             query: { directory: ctx.directory }
           });
           if (statusResp.data?.status === "idle") {
+            ledgerCompleted = true;
             break;
           }
           attempts++;
         }
-      }
-      const handoffSessionResp = await ctx.client.session.create({
-        body: {},
-        query: { directory: ctx.directory }
-      });
-      const handoffSessionID = handoffSessionResp.data?.id;
-      if (handoffSessionID) {
-        await ctx.client.session.prompt({
-          path: { id: handoffSessionID },
-          body: {
-            parts: [
-              {
-                type: "text",
-                text: "Create a handoff document. Read the current ledger at thoughts/ledgers/ for context."
-              }
-            ],
-            agent: "handoff-creator"
-          },
-          query: { directory: ctx.directory }
-        });
-        let attempts = 0;
-        while (attempts < 30) {
-          await new Promise((resolve2) => setTimeout(resolve2, 2000));
-          const statusResp = await ctx.client.session.get({
-            path: { id: handoffSessionID },
-            query: { directory: ctx.directory }
-          });
-          if (statusResp.data?.status === "idle") {
-            break;
-          }
-          attempts++;
+        if (ledgerCompleted) {
+          clearFileOps(sessionID);
         }
       }
       const firstMessage = messages[0];
@@ -15423,7 +15313,7 @@ function createAutoClearLedgerHook(ctx) {
       await ctx.client.tui.showToast({
         body: {
           title: "Context Cleared",
-          message: "Ledger + handoff saved. Session ready to continue.",
+          message: "Ledger saved. Session ready to continue.",
           variant: "success",
           duration: 5000
         }
@@ -15475,41 +15365,35 @@ function createAutoClearLedgerHook(ctx) {
 // src/hooks/artifact-auto-index.ts
 import { readFileSync as readFileSync3 } from "fs";
 var LEDGER_PATH_PATTERN = /thoughts\/ledgers\/CONTINUITY_(.+)\.md$/;
-var HANDOFF_PATH_PATTERN = /thoughts\/shared\/handoffs\/(.+)\.md$/;
 var PLAN_PATH_PATTERN = /thoughts\/shared\/plans\/(.+)\.md$/;
 function parseLedger(content, filePath, sessionName) {
   const goalMatch = content.match(/## Goal\n([^\n]+)/);
-  const stateMatch = content.match(/- Now: ([^\n]+)/);
+  const stateMatch = content.match(/### In Progress\n- \[ \] ([^\n]+)/);
   const decisionsMatch = content.match(/## Key Decisions\n([\s\S]*?)(?=\n## |$)/);
+  const fileOpsSection = content.match(/## File Operations\n([\s\S]*?)(?=\n## |$)/);
+  let filesRead = "";
+  let filesModified = "";
+  if (fileOpsSection) {
+    const readMatch = fileOpsSection[1].match(/### Read\n([\s\S]*?)(?=\n### |$)/);
+    const modifiedMatch = fileOpsSection[1].match(/### Modified\n([\s\S]*?)(?=\n### |$)/);
+    if (readMatch) {
+      const paths = readMatch[1].match(/`([^`]+)`/g);
+      filesRead = paths ? paths.map((p) => p.replace(/`/g, "")).join(",") : "";
+    }
+    if (modifiedMatch) {
+      const paths = modifiedMatch[1].match(/`([^`]+)`/g);
+      filesModified = paths ? paths.map((p) => p.replace(/`/g, "")).join(",") : "";
+    }
+  }
   return {
     id: `ledger-${sessionName}`,
     sessionName,
     filePath,
     goal: goalMatch?.[1] || "",
     stateNow: stateMatch?.[1] || "",
-    keyDecisions: decisionsMatch?.[1]?.trim() || ""
-  };
-}
-function parseHandoff(content, filePath, fileName) {
-  const sessionMatch = content.match(/^session:\s*(.+)$/m);
-  const sessionName = sessionMatch?.[1] || fileName;
-  const taskMatch = content.match(/\*\*Working on:\*\*\s*([^\n]+)/);
-  const taskSummary = taskMatch?.[1] || "";
-  const learningsMatch = content.match(/## Learnings\n\n([\s\S]*?)(?=\n## |$)/);
-  const learnings = learningsMatch?.[1]?.trim() || "";
-  const workedMatch = content.match(/## What Worked\n\n([\s\S]*?)(?=\n## |$)/);
-  const whatWorked = workedMatch?.[1]?.trim() || learnings;
-  const failedMatch = content.match(/## What Failed\n\n([\s\S]*?)(?=\n## |$)/);
-  const whatFailed = failedMatch?.[1]?.trim() || "";
-  return {
-    id: `handoff-${fileName}`,
-    sessionName,
-    filePath,
-    taskSummary,
-    whatWorked,
-    whatFailed,
-    learnings,
-    outcome: "UNKNOWN"
+    keyDecisions: decisionsMatch?.[1]?.trim() || "",
+    filesRead,
+    filesModified
   };
 }
 function parsePlan(content, filePath, fileName) {
@@ -15545,15 +15429,6 @@ function createArtifactAutoIndexHook(_ctx) {
           console.log(`[artifact-auto-index] Indexed ledger: ${filePath}`);
           return;
         }
-        const handoffMatch = filePath.match(HANDOFF_PATH_PATTERN);
-        if (handoffMatch) {
-          const content = readFileSync3(filePath, "utf-8");
-          const index = await getArtifactIndex();
-          const record2 = parseHandoff(content, filePath, handoffMatch[1]);
-          await index.indexHandoff(record2);
-          console.log(`[artifact-auto-index] Indexed handoff: ${filePath}`);
-          return;
-        }
         const planMatch = filePath.match(PLAN_PATH_PATTERN);
         if (planMatch) {
           const content = readFileSync3(filePath, "utf-8");
@@ -16062,6 +15937,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
   const contextWindowMonitorHook = createContextWindowMonitorHook(ctx);
   const commentCheckerHook = createCommentCheckerHook(ctx);
   const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
+  const fileOpsTrackerHook = createFileOpsTrackerHook(ctx);
   const backgroundTaskManager = new BackgroundTaskManager(ctx);
   const backgroundTaskTools = createBackgroundTaskTools(backgroundTaskManager);
   return {
@@ -16083,11 +15959,13 @@ var OpenCodeConfigPlugin = async (ctx) => {
       };
       const mergedAgents = mergeAgentConfigs(agents, userConfig);
       config2.agent = {
-        [PRIMARY_AGENT_NAME]: mergedAgents[PRIMARY_AGENT_NAME],
-        ...Object.fromEntries(Object.entries(mergedAgents).filter(([k]) => k !== PRIMARY_AGENT_NAME)),
         ...config2.agent,
         build: { ...config2.agent?.build, mode: "subagent" },
-        plan: { ...config2.agent?.plan, mode: "subagent" }
+        plan: { ...config2.agent?.plan, mode: "subagent" },
+        triage: { ...config2.agent?.triage, mode: "subagent" },
+        docs: { ...config2.agent?.docs, mode: "subagent" },
+        ...Object.fromEntries(Object.entries(mergedAgents).filter(([k]) => k !== PRIMARY_AGENT_NAME)),
+        [PRIMARY_AGENT_NAME]: mergedAgents[PRIMARY_AGENT_NAME]
       };
       config2.mcp = {
         ...config2.mcp,
@@ -16135,6 +16013,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
       await commentCheckerHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
       await contextInjectorHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
       await artifactAutoIndexHook["tool.execute.after"]({ tool: input.tool, args: input.args }, output);
+      await fileOpsTrackerHook["tool.execute.after"]({ tool: input.tool, sessionID: input.sessionID, args: input.args }, output);
     },
     event: async ({ event }) => {
       if (event.type === "session.deleted") {
@@ -16149,6 +16028,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
       await tokenAwareTruncationHook.event({ event });
       await contextWindowMonitorHook.event({ event });
       backgroundTaskManager.handleEvent(event);
+      await fileOpsTrackerHook.event({ event });
     }
   };
 };

package/dist/tools/artifact-index/index.d.ts

@@ -1,13 +1,3 @@
-export interface HandoffRecord {
-    id: string;
-    sessionName?: string;
-    filePath: string;
-    taskSummary?: string;
-    whatWorked?: string;
-    whatFailed?: string;
-    learnings?: string;
-    outcome?: "SUCCEEDED" | "PARTIAL_PLUS" | "PARTIAL_MINUS" | "FAILED" | "UNKNOWN";
-}
 export interface PlanRecord {
     id: string;
     title?: string;
@@ -22,9 +12,11 @@ export interface LedgerRecord {
     goal?: string;
     stateNow?: string;
     keyDecisions?: string;
+    filesRead?: string;
+    filesModified?: string;
 }
 export interface SearchResult {
-    type: "handoff" | "plan" | "ledger";
+    type: "plan" | "ledger";
     id: string;
     filePath: string;
     title?: string;
@@ -37,7 +29,6 @@ export declare class ArtifactIndex {
     constructor(dbDir?: string);
     initialize(): Promise<void>;
     private getInlineSchema;
-    indexHandoff(record: HandoffRecord): Promise<void>;
     indexPlan(record: PlanRecord): Promise<void>;
     indexLedger(record: LedgerRecord): Promise<void>;
     search(query: string, limit?: number): Promise<SearchResult[]>;

package/dist/tools/artifact-search.d.ts

@@ -5,7 +5,6 @@ export declare const artifact_search: {
         limit: import("zod").ZodOptional<import("zod").ZodNumber>;
         type: import("zod").ZodOptional<import("zod").ZodEnum<{
             all: "all";
-            handoff: "handoff";
             plan: "plan";
             ledger: "ledger";
         }>>;
@@ -13,6 +12,6 @@ export declare const artifact_search: {
     execute(args: {
         query: string;
         limit?: number | undefined;
-        type?: "all" | "handoff" | "plan" | "ledger" | undefined;
+        type?: "all" | "plan" | "ledger" | undefined;
     }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "micode",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "OpenCode plugin with Brainstorm-Research-Plan-Implement workflow",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,7 +44,7 @@
     "url": "https://github.com/vtemian/micode/issues"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.0.207"
+    "@opencode-ai/plugin": "^1.0.219"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.10",

package/dist/agents/handoff-creator.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const handoffCreatorAgent: AgentConfig;

package/dist/agents/handoff-resumer.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare const handoffResumerAgent: AgentConfig;