micode 0.3.1 → 0.3.2

package/dist/index.js

@@ -869,6 +869,8 @@ Create handoff document to transfer context to future session.
 </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>
@@ -878,6 +880,8 @@ Create handoff document to transfer context to future session.
 </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>
@@ -886,13 +890,17 @@ Create handoff document to transfer context to future session.
 <step>Commit handoff document</step>
 </process>
 
-<output-path>thoughts/shared/handoffs/YYYY-MM-DD_HH-MM-SS_description.md</output-path>
+<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>
@@ -1316,6 +1324,116 @@ var projectInitializerAgent = {
   prompt: PROMPT2
 };
 
+// src/agents/ledger-creator.ts
+var ledgerCreatorAgent = {
+  description: "Creates and updates continuity ledgers for session state preservation",
+  mode: "subagent",
+  model: "anthropic/claude-sonnet-4-20250514",
+  temperature: 0.2,
+  tools: {
+    edit: false,
+    task: false
+  },
+  prompt: `<purpose>
+Create or update a continuity ledger to preserve session state across context clears.
+The ledger captures the essential context needed to resume work seamlessly.
+</purpose>
+
+<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>
+
+<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>Gather current state: goal, decisions, progress, blockers</step>
+<step>Write ledger in the exact format below</step>
+</process>
+
+<output-path>thoughts/ledgers/CONTINUITY_{session-name}.md</output-path>
+
+<ledger-format>
+# Session: {session-name}
+Updated: {ISO timestamp}
+
+## Goal
+{One sentence describing success criteria}
+
+## Constraints
+{Technical requirements, patterns to follow, things to avoid}
+
+## Key Decisions
+- {Decision}: {Rationale}
+
+## State
+- Done: {Completed items as comma-separated list}
+- Now: {Current focus - exactly ONE thing}
+- Next: {Queued items in priority order}
+
+## Open Questions
+- UNCONFIRMED: {Things needing verification}
+
+## Working Set
+- Branch: \`{branch-name}\`
+- Key files: \`{paths}\`
+</ledger-format>
+
+<output-summary>
+Ledger updated: thoughts/ledgers/CONTINUITY_{session-name}.md
+State: {Now item}
+</output-summary>`
+};
+
+// src/agents/artifact-searcher.ts
+var artifactSearcherAgent = {
+  description: "Searches past handoffs, plans, and ledgers for relevant precedent",
+  mode: "subagent",
+  model: "anthropic/claude-sonnet-4-20250514",
+  temperature: 0.3,
+  tools: {
+    edit: false,
+    task: false
+  },
+  prompt: `<purpose>
+Search the artifact index to find relevant past work, patterns, and lessons learned.
+Help the user discover precedent from previous sessions.
+</purpose>
+
+<rules>
+<rule>Use artifact_search tool to query the index</rule>
+<rule>Explain WHY each result is relevant to the query</rule>
+<rule>Suggest which files to read for more detail</rule>
+<rule>If no results, suggest alternative search terms</rule>
+<rule>Highlight learnings and patterns that might apply</rule>
+</rules>
+
+<process>
+<step>Understand what the user is looking for</step>
+<step>Formulate effective search query</step>
+<step>Execute search with artifact_search tool</step>
+<step>Analyze and explain results</step>
+<step>Recommend next steps (files to read, patterns to apply)</step>
+</process>
+
+<output-format>
+## Search: {query}
+
+### Relevant Results
+{For each result: explain relevance and key takeaways}
+
+### Recommendations
+{Which files to read, patterns to consider}
+
+### Alternative Searches
+{If results sparse, suggest other queries}
+</output-format>`
+};
+
 // src/agents/index.ts
 var agents = {
   [PRIMARY_AGENT_NAME]: primaryAgent,
@@ -1329,7 +1447,9 @@ var agents = {
   executor: executorAgent,
   "handoff-creator": handoffCreatorAgent,
   "handoff-resumer": handoffResumerAgent,
-  "project-initializer": projectInitializerAgent
+  "project-initializer": projectInitializerAgent,
+  "ledger-creator": ledgerCreatorAgent,
+  "artifact-searcher": artifactSearcherAgent
 };
 
 // src/tools/ast-grep/index.ts
@@ -13744,7 +13864,7 @@ function formatMatches(matches, isDryRun = false) {
   const shown = matches.slice(0, MAX);
   const lines = shown.map((m) => {
     const loc = `${m.file}:${m.range.start.line}:${m.range.start.column}`;
-    const text = m.text.length > 100 ? m.text.slice(0, 100) + "..." : m.text;
+    const text = m.text.length > 100 ? `${m.text.slice(0, 100)}...` : m.text;
     if (isDryRun && m.replacement) {
       return `${loc}
   - ${text}
@@ -13788,16 +13908,7 @@ var ast_grep_replace = tool({
     apply: tool.schema.boolean().optional().describe("Apply changes (default: false, dry-run)")
   },
   execute: async (args) => {
-    const sgArgs = [
-      "run",
-      "-p",
-      args.pattern,
-      "-r",
-      args.rewrite,
-      "--lang",
-      args.lang,
-      "--json=compact"
-    ];
+    const sgArgs = ["run", "-p", args.pattern, "-r", args.rewrite, "--lang", args.lang, "--json=compact"];
     if (args.apply) {
       sgArgs.push("--update-all");
     }
@@ -13812,7 +13923,7 @@ var ast_grep_replace = tool({
     const isDryRun = !args.apply;
     const output = formatMatches(result.matches, isDryRun);
     if (isDryRun && result.matches.length > 0) {
-      return output + `
+      return `${output}
 
 (Dry run - use apply=true to apply changes)`;
     }
@@ -13829,7 +13940,20 @@ import { readFileSync, statSync } from "fs";
 import { extname, basename } from "path";
 var LARGE_FILE_THRESHOLD = 100 * 1024;
 var MAX_LINES_WITHOUT_EXTRACT = 200;
-var EXTRACTABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".rs", ".java", ".md", ".json", ".yaml", ".yml"];
+var EXTRACTABLE_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".md",
+  ".json",
+  ".yaml",
+  ".yml"
+];
 function extractStructure(content, ext) {
   const lines = content.split(`
 `);
@@ -13861,7 +13985,7 @@ function extractTypeScriptStructure(lines) {
     const line = lines[i];
     const trimmed = line.trim();
     if (trimmed.startsWith("export ") || trimmed.startsWith("class ") || trimmed.startsWith("interface ") || trimmed.startsWith("type ") || trimmed.startsWith("function ") || trimmed.startsWith("const ") || trimmed.startsWith("async function ")) {
-      const signature = trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed;
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
       output.push(`Line ${i + 1}: ${signature}`);
     }
   }
@@ -13875,7 +13999,7 @@ function extractPythonStructure(lines) {
     const line = lines[i];
     const trimmed = line.trim();
     if (trimmed.startsWith("class ") || trimmed.startsWith("def ") || trimmed.startsWith("async def ") || trimmed.startsWith("@")) {
-      const signature = trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed;
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
       output.push(`Line ${i + 1}: ${signature}`);
     }
   }
@@ -13889,7 +14013,7 @@ function extractGoStructure(lines) {
     const line = lines[i];
     const trimmed = line.trim();
     if (trimmed.startsWith("type ") || trimmed.startsWith("func ") || trimmed.startsWith("package ")) {
-      const signature = trimmed.length > 80 ? trimmed.slice(0, 80) + "..." : trimmed;
+      const signature = trimmed.length > 80 ? `${trimmed.slice(0, 80)}...` : trimmed;
       output.push(`Line ${i + 1}: ${signature}`);
     }
   }
@@ -13988,6 +14112,302 @@ ${content}`;
   }
 });
 
+// src/tools/artifact-index/index.ts
+import { Database } from "bun:sqlite";
+import { readFileSync as readFileSync2 } from "fs";
+import { join, dirname } from "path";
+import { mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+var DEFAULT_DB_DIR = join(homedir(), ".config", "opencode", "artifact-index");
+var DB_NAME = "context.db";
+
+class ArtifactIndex {
+  db = null;
+  dbPath;
+  constructor(dbDir = DEFAULT_DB_DIR) {
+    this.dbPath = join(dbDir, DB_NAME);
+  }
+  async initialize() {
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    const schemaPath = join(dirname(import.meta.path), "schema.sql");
+    let schema;
+    try {
+      schema = readFileSync2(schemaPath, "utf-8");
+    } catch {
+      schema = this.getInlineSchema();
+    }
+    this.db.exec(schema);
+  }
+  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,
+        file_path TEXT UNIQUE NOT NULL,
+        overview TEXT,
+        approach TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE TABLE IF NOT EXISTS ledgers (
+        id TEXT PRIMARY KEY,
+        session_name TEXT,
+        file_path TEXT UNIQUE NOT NULL,
+        goal TEXT,
+        state_now TEXT,
+        key_decisions 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");
+    const existing = this.db.query(`SELECT id FROM plans WHERE file_path = ?`).get(record2.filePath);
+    if (existing) {
+      this.db.run(`DELETE FROM plans_fts WHERE id = ?`, [existing.id]);
+    }
+    this.db.run(`
+      INSERT INTO plans (id, title, file_path, overview, approach, indexed_at)
+      VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(file_path) DO UPDATE SET
+        id = excluded.id,
+        title = excluded.title,
+        overview = excluded.overview,
+        approach = excluded.approach,
+        indexed_at = CURRENT_TIMESTAMP
+    `, [record2.id, record2.title ?? null, record2.filePath, record2.overview ?? null, record2.approach ?? null]);
+    this.db.run(`
+      INSERT INTO plans_fts (id, title, overview, approach)
+      VALUES (?, ?, ?, ?)
+    `, [record2.id, record2.title ?? null, record2.overview ?? null, record2.approach ?? null]);
+  }
+  async indexLedger(record2) {
+    if (!this.db)
+      throw new Error("Database not initialized");
+    const existing = this.db.query(`SELECT id FROM ledgers WHERE file_path = ?`).get(record2.filePath);
+    if (existing) {
+      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)
+      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,
+        indexed_at = CURRENT_TIMESTAMP
+    `, [
+      record2.id,
+      record2.sessionName ?? null,
+      record2.filePath,
+      record2.goal ?? null,
+      record2.stateNow ?? null,
+      record2.keyDecisions ?? null
+    ]);
+    this.db.run(`
+      INSERT INTO ledgers_fts (id, session_name, goal, state_now, key_decisions)
+      VALUES (?, ?, ?, ?, ?)
+    `, [
+      record2.id,
+      record2.sessionName ?? null,
+      record2.goal ?? null,
+      record2.stateNow ?? null,
+      record2.keyDecisions ?? null
+    ]);
+  }
+  async search(query, limit = 10) {
+    if (!this.db)
+      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
+      JOIN plans p ON plans_fts.id = p.id
+      WHERE plans_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(escapedQuery, limit);
+    for (const row of plans) {
+      results.push({
+        type: "plan",
+        id: row.id,
+        filePath: row.file_path,
+        title: row.title,
+        score: -row.rank
+      });
+    }
+    const ledgers = this.db.query(`
+      SELECT l.id, l.file_path, l.session_name, l.goal, rank
+      FROM ledgers_fts
+      JOIN ledgers l ON ledgers_fts.id = l.id
+      WHERE ledgers_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(escapedQuery, limit);
+    for (const row of ledgers) {
+      results.push({
+        type: "ledger",
+        id: row.id,
+        filePath: row.file_path,
+        title: row.session_name,
+        summary: row.goal,
+        score: -row.rank
+      });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  escapeFtsQuery(query) {
+    return query.replace(/['"]/g, "").split(/\s+/).filter((term) => term.length > 0).map((term) => `"${term}"`).join(" OR ");
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+var globalIndex = null;
+async function getArtifactIndex() {
+  if (!globalIndex) {
+    globalIndex = new ArtifactIndex;
+    await globalIndex.initialize();
+  }
+  return globalIndex;
+}
+
+// src/tools/artifact-search.ts
+var artifact_search = tool({
+  description: `Search past handoffs, plans, and ledgers for relevant precedent.
+Use this to find:
+- Similar problems you've solved before
+- Patterns and approaches that worked
+- Lessons learned from past sessions
+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)")
+  },
+  execute: async (args) => {
+    try {
+      const index = await getArtifactIndex();
+      const results = await index.search(args.query, args.limit || 10);
+      const filtered = args.type && args.type !== "all" ? results.filter((r) => r.type === args.type) : results;
+      if (filtered.length === 0) {
+        return `No results found for "${args.query}". Try broader search terms.`;
+      }
+      let output = `## Search Results for "${args.query}"
+
+`;
+      output += `Found ${filtered.length} result(s):
+
+`;
+      for (const result of filtered) {
+        const typeLabel = result.type.charAt(0).toUpperCase() + result.type.slice(1);
+        output += `### ${typeLabel}: ${result.title || result.id}
+`;
+        output += `**File:** \`${result.filePath}\`
+`;
+        if (result.summary) {
+          output += `**Summary:** ${result.summary}
+`;
+        }
+        output += `**Relevance Score:** ${result.score.toFixed(2)}
+
+`;
+      }
+      output += `---
+*Use the Read tool to view full content of relevant files.*`;
+      return output;
+    } catch (e) {
+      return `Error searching artifacts: ${e instanceof Error ? e.message : String(e)}`;
+    }
+  }
+});
+
 // src/hooks/auto-compact.ts
 function parseTokenLimitError(error45) {
   if (!error45)
@@ -14083,9 +14503,9 @@ function createAutoCompactHook(ctx) {
           }
         }).catch(() => {});
       }
-    } catch (e) {
+    } catch (_e) {
       state.retryCount.set(sessionID, retries + 1);
-      const delay = Math.min(1000 * Math.pow(2, retries), 1e4);
+      const delay = Math.min(1000 * 2 ** retries, 1e4);
       setTimeout(() => {
         state.inProgress.delete(sessionID);
         attemptRecovery(sessionID, providerID, modelID);
@@ -14167,14 +14587,8 @@ function createAutoCompactHook(ctx) {
 
 // src/hooks/context-injector.ts
 import { readFile } from "fs/promises";
-import { join, dirname, resolve } from "path";
-var ROOT_CONTEXT_FILES = [
-  "ARCHITECTURE.md",
-  "CODE_STYLE.md",
-  "AGENTS.md",
-  "CLAUDE.md",
-  "README.md"
-];
+import { join as join2, dirname as dirname2, resolve } from "path";
+var ROOT_CONTEXT_FILES = ["ARCHITECTURE.md", "CODE_STYLE.md", "AGENTS.md", "CLAUDE.md", "README.md"];
 var DIRECTORY_CONTEXT_FILES = ["AGENTS.md", "README.md"];
 var FILE_ACCESS_TOOLS = ["Read", "read", "Edit", "edit"];
 var CACHE_TTL = 30000;
@@ -14193,7 +14607,7 @@ function createContextInjectorHook(ctx) {
     cache.lastRootCheck = now;
     for (const filename of ROOT_CONTEXT_FILES) {
       try {
-        const filepath = join(ctx.directory, filename);
+        const filepath = join2(ctx.directory, filename);
         const content = await readFile(filepath, "utf-8");
         if (content.trim()) {
           cache.rootContent.set(filename, content);
@@ -14205,15 +14619,15 @@ function createContextInjectorHook(ctx) {
   async function walkUpForContextFiles(filePath) {
     const absPath = resolve(filePath);
     const projectRoot = resolve(ctx.directory);
-    const cacheKey = dirname(absPath);
+    const cacheKey = dirname2(absPath);
     if (cache.directoryContent.has(cacheKey)) {
       return cache.directoryContent.get(cacheKey);
     }
     const collected = new Map;
-    let currentDir = dirname(absPath);
+    let currentDir = dirname2(absPath);
     while (currentDir.startsWith(projectRoot) || currentDir === projectRoot) {
       for (const filename of DIRECTORY_CONTEXT_FILES) {
-        const contextPath = join(currentDir, filename);
+        const contextPath = join2(currentDir, filename);
         const relPath = currentDir.replace(projectRoot, "").replace(/^\//, "") || ".";
         const key = `${relPath}/${filename}`;
         if (!collected.has(key)) {
@@ -14227,7 +14641,7 @@ function createContextInjectorHook(ctx) {
       }
       if (currentDir === projectRoot)
         break;
-      const parent = dirname(currentDir);
+      const parent = dirname2(currentDir);
       if (parent === currentDir)
         break;
       currentDir = parent;
@@ -14288,144 +14702,6 @@ ${blocks.join(`
   };
 }
 
-// src/hooks/preemptive-compaction.ts
-var MODEL_CONTEXT_LIMITS = {
-  "claude-opus": 200000,
-  "claude-sonnet": 200000,
-  "claude-haiku": 200000,
-  "claude-3": 200000,
-  "claude-4": 200000,
-  "gpt-4o": 128000,
-  "gpt-4-turbo": 128000,
-  "gpt-4": 128000,
-  "gpt-5": 200000,
-  o1: 200000,
-  o3: 200000,
-  gemini: 1e6
-};
-var DEFAULT_CONTEXT_LIMIT = 200000;
-var DEFAULT_THRESHOLD = 0.8;
-var MIN_TOKENS_FOR_COMPACTION = 50000;
-var COMPACTION_COOLDOWN_MS = 60000;
-function getContextLimit(modelID) {
-  const modelLower = modelID.toLowerCase();
-  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
-    if (modelLower.includes(pattern)) {
-      return limit;
-    }
-  }
-  return DEFAULT_CONTEXT_LIMIT;
-}
-function createPreemptiveCompactionHook(ctx) {
-  const state = {
-    lastCompactionTime: new Map,
-    compactionInProgress: new Set
-  };
-  async function checkAndCompact(sessionID, providerID, modelID) {
-    if (state.compactionInProgress.has(sessionID))
-      return;
-    const lastTime = state.lastCompactionTime.get(sessionID) || 0;
-    if (Date.now() - lastTime < COMPACTION_COOLDOWN_MS)
-      return;
-    try {
-      const resp = await ctx.client.session.messages({
-        path: { id: sessionID },
-        query: { directory: ctx.directory }
-      });
-      const messages = resp.data;
-      if (!Array.isArray(messages) || messages.length === 0)
-        return;
-      const lastAssistant = [...messages].reverse().find((m) => {
-        const msg = m;
-        const info2 = msg.info;
-        return info2?.role === "assistant";
-      });
-      if (!lastAssistant)
-        return;
-      const info = lastAssistant.info;
-      const usage = info?.usage;
-      const inputTokens = usage?.inputTokens || 0;
-      const cacheRead = usage?.cacheReadInputTokens || 0;
-      const totalUsed = inputTokens + cacheRead;
-      if (totalUsed < MIN_TOKENS_FOR_COMPACTION)
-        return;
-      const model = modelID || info?.modelID || "";
-      const contextLimit = getContextLimit(model);
-      const usageRatio = totalUsed / contextLimit;
-      if (usageRatio < DEFAULT_THRESHOLD)
-        return;
-      const lastUserMsg = [...messages].reverse().find((m) => {
-        const msg = m;
-        const msgInfo = msg.info;
-        return msgInfo?.role === "user";
-      });
-      if (lastUserMsg) {
-        const parts = lastUserMsg.parts;
-        const text = parts?.find((p) => p.type === "text")?.text || "";
-        if (text.includes("summarized") || text.includes("compacted"))
-          return;
-      }
-      state.compactionInProgress.add(sessionID);
-      state.lastCompactionTime.set(sessionID, Date.now());
-      await ctx.client.tui.showToast({
-        body: {
-          title: "Context Window",
-          message: `${Math.round(usageRatio * 100)}% used - auto-compacting...`,
-          variant: "warning",
-          duration: 3000
-        }
-      }).catch(() => {});
-      const provider = providerID || info?.providerID;
-      const modelToUse = modelID || info?.modelID;
-      if (provider && modelToUse) {
-        await ctx.client.session.summarize({
-          path: { id: sessionID },
-          body: { providerID: provider, modelID: modelToUse },
-          query: { directory: ctx.directory }
-        });
-        await ctx.client.tui.showToast({
-          body: {
-            title: "Compacted",
-            message: "Session summarized successfully",
-            variant: "success",
-            duration: 3000
-          }
-        }).catch(() => {});
-      }
-    } catch (e) {} finally {
-      state.compactionInProgress.delete(sessionID);
-    }
-  }
-  return {
-    event: async ({ event }) => {
-      const props = event.properties;
-      if (event.type === "session.deleted") {
-        const sessionInfo = props?.info;
-        if (sessionInfo?.id) {
-          state.lastCompactionTime.delete(sessionInfo.id);
-          state.compactionInProgress.delete(sessionInfo.id);
-        }
-        return;
-      }
-      if (event.type === "message.updated") {
-        const info = props?.info;
-        const sessionID = info?.sessionID;
-        if (sessionID && info?.role === "assistant") {
-          const providerID = info.providerID;
-          const modelID = info.modelID;
-          await checkAndCompact(sessionID, providerID, modelID);
-        }
-      }
-      if (event.type === "session.idle") {
-        const sessionID = props?.sessionID;
-        if (sessionID) {
-          await checkAndCompact(sessionID);
-        }
-      }
-    }
-  };
-}
-
 // src/hooks/session-recovery.ts
 var RECOVERABLE_ERRORS = {
   TOOL_RESULT_MISSING: "tool_result block(s) missing",
@@ -14608,15 +14884,9 @@ function createSessionRecoveryHook(ctx) {
 }
 
 // src/hooks/token-aware-truncation.ts
-var TRUNCATABLE_TOOLS = [
-  "grep",
-  "Grep",
-  "glob",
-  "Glob",
-  "ast_grep_search"
-];
+var TRUNCATABLE_TOOLS = ["grep", "Grep", "glob", "Glob", "ast_grep_search"];
 var CHARS_PER_TOKEN = 4;
-var DEFAULT_CONTEXT_LIMIT2 = 200000;
+var DEFAULT_CONTEXT_LIMIT = 200000;
 var DEFAULT_MAX_OUTPUT_TOKENS = 50000;
 var SAFETY_MARGIN = 0.5;
 var PRESERVE_HEADER_LINES = 3;
@@ -14677,7 +14947,7 @@ function createTokenAwareTruncationHook(ctx) {
       });
       const messages = resp.data;
       if (!Array.isArray(messages) || messages.length === 0) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT2 };
+        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
       }
       const lastAssistant = [...messages].reverse().find((m) => {
         const msg = m;
@@ -14685,19 +14955,19 @@ function createTokenAwareTruncationHook(ctx) {
         return info2?.role === "assistant";
       });
       if (!lastAssistant) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT2 };
+        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
       }
       const info = lastAssistant.info;
       const usage = info?.usage;
       const inputTokens = usage?.inputTokens || 0;
       const cacheRead = usage?.cacheReadInputTokens || 0;
       const used = inputTokens + cacheRead;
-      const limit = DEFAULT_CONTEXT_LIMIT2;
+      const limit = DEFAULT_CONTEXT_LIMIT;
       const result = { used, limit };
       state.sessionTokenUsage.set(sessionID, result);
       return result;
     } catch {
-      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT2 };
+      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
     }
   }
   function calculateMaxOutputTokens(used, limit) {
@@ -14757,8 +15027,8 @@ function createTokenAwareTruncationHook(ctx) {
 // src/hooks/context-window-monitor.ts
 var WARNING_THRESHOLD = 0.7;
 var CRITICAL_THRESHOLD = 0.85;
-var DEFAULT_CONTEXT_LIMIT3 = 200000;
-var MODEL_CONTEXT_LIMITS2 = {
+var DEFAULT_CONTEXT_LIMIT2 = 200000;
+var MODEL_CONTEXT_LIMITS = {
   "claude-opus": 200000,
   "claude-sonnet": 200000,
   "claude-haiku": 200000,
@@ -14768,14 +15038,14 @@ var MODEL_CONTEXT_LIMITS2 = {
   o3: 200000,
   gemini: 1e6
 };
-function getContextLimit2(modelID) {
+function getContextLimit(modelID) {
   const modelLower = modelID.toLowerCase();
-  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS2)) {
+  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
     if (modelLower.includes(pattern)) {
       return limit;
     }
   }
-  return DEFAULT_CONTEXT_LIMIT3;
+  return DEFAULT_CONTEXT_LIMIT2;
 }
 var WARNING_COOLDOWN_MS = 120000;
 function createContextWindowMonitorHook(ctx) {
@@ -14825,7 +15095,7 @@ function createContextWindowMonitorHook(ctx) {
         const cacheRead = usage?.cacheReadInputTokens || 0;
         const totalUsed = inputTokens + cacheRead;
         const modelID = info.modelID || "";
-        const contextLimit = getContextLimit2(modelID);
+        const contextLimit = getContextLimit(modelID);
         const usageRatio = totalUsed / contextLimit;
         state.lastUsageRatio.set(sessionID, usageRatio);
         if (usageRatio >= WARNING_THRESHOLD) {
@@ -14907,7 +15177,7 @@ function analyzeComments(content) {
   }
   return issues;
 }
-function createCommentCheckerHook(ctx) {
+function createCommentCheckerHook(_ctx) {
   return {
     "tool.execute.after": async (input, output) => {
       if (input.tool !== "Edit" && input.tool !== "edit")
@@ -14933,6 +15203,373 @@ Comments should explain WHY, not WHAT. Consider removing obvious comments.`;
   };
 }
 
+// src/hooks/ledger-loader.ts
+import { readFile as readFile2, readdir } from "fs/promises";
+import { join as join3 } from "path";
+var LEDGER_DIR = "thoughts/ledgers";
+var LEDGER_PREFIX = "CONTINUITY_";
+async function findCurrentLedger(directory) {
+  const ledgerDir = join3(directory, LEDGER_DIR);
+  try {
+    const files = await readdir(ledgerDir);
+    const ledgerFiles = files.filter((f) => f.startsWith(LEDGER_PREFIX) && f.endsWith(".md"));
+    if (ledgerFiles.length === 0)
+      return null;
+    let latestFile = ledgerFiles[0];
+    let latestMtime = 0;
+    for (const file2 of ledgerFiles) {
+      const filePath2 = join3(ledgerDir, file2);
+      try {
+        const stat = await Bun.file(filePath2).stat();
+        if (stat && stat.mtime.getTime() > latestMtime) {
+          latestMtime = stat.mtime.getTime();
+          latestFile = file2;
+        }
+      } catch {}
+    }
+    const filePath = join3(ledgerDir, latestFile);
+    const content = await readFile2(filePath, "utf-8");
+    const sessionName = latestFile.replace(LEDGER_PREFIX, "").replace(".md", "");
+    return { sessionName, filePath, content };
+  } catch {
+    return null;
+  }
+}
+function formatLedgerInjection(ledger) {
+  return `<continuity-ledger session="${ledger.sessionName}">
+${ledger.content}
+</continuity-ledger>
+
+You are resuming work from a previous context clear. The ledger above contains your session state.
+Review it and continue from where you left off. The "Now" item is your current focus.`;
+}
+function createLedgerLoaderHook(ctx) {
+  return {
+    "chat.params": async (_input, output) => {
+      const ledger = await findCurrentLedger(ctx.directory);
+      if (!ledger)
+        return;
+      const injection = formatLedgerInjection(ledger);
+      if (output.system) {
+        output.system = `${injection}
+
+${output.system}`;
+      } else {
+        output.system = injection;
+      }
+    }
+  };
+}
+
+// src/hooks/auto-clear-ledger.ts
+var MODEL_CONTEXT_LIMITS2 = {
+  "claude-opus": 200000,
+  "claude-sonnet": 200000,
+  "claude-haiku": 200000,
+  "claude-3": 200000,
+  "claude-4": 200000,
+  "gpt-4o": 128000,
+  "gpt-4-turbo": 128000,
+  "gpt-4": 128000,
+  "gpt-5": 200000,
+  o1: 200000,
+  o3: 200000,
+  gemini: 1e6
+};
+var DEFAULT_CONTEXT_LIMIT3 = 200000;
+var DEFAULT_THRESHOLD = 0.8;
+var MIN_TOKENS_FOR_CLEAR = 50000;
+var CLEAR_COOLDOWN_MS = 60000;
+function getContextLimit2(modelID) {
+  const modelLower = modelID.toLowerCase();
+  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS2)) {
+    if (modelLower.includes(pattern)) {
+      return limit;
+    }
+  }
+  return DEFAULT_CONTEXT_LIMIT3;
+}
+function createAutoClearLedgerHook(ctx) {
+  const state = {
+    lastClearTime: new Map,
+    clearInProgress: new Set
+  };
+  async function checkAndClear(sessionID, _providerID, modelID) {
+    if (state.clearInProgress.has(sessionID))
+      return;
+    const lastTime = state.lastClearTime.get(sessionID) || 0;
+    if (Date.now() - lastTime < CLEAR_COOLDOWN_MS)
+      return;
+    try {
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory }
+      });
+      const messages = resp.data;
+      if (!Array.isArray(messages) || messages.length === 0)
+        return;
+      const lastAssistant = [...messages].reverse().find((m) => {
+        const msg = m;
+        const info2 = msg.info;
+        return info2?.role === "assistant";
+      });
+      if (!lastAssistant)
+        return;
+      const info = lastAssistant.info;
+      const usage = info?.usage;
+      const inputTokens = usage?.inputTokens || 0;
+      const cacheRead = usage?.cacheReadInputTokens || 0;
+      const totalUsed = inputTokens + cacheRead;
+      if (totalUsed < MIN_TOKENS_FOR_CLEAR)
+        return;
+      const model = modelID || info?.modelID || "";
+      const contextLimit = getContextLimit2(model);
+      const usageRatio = totalUsed / contextLimit;
+      if (usageRatio < DEFAULT_THRESHOLD)
+        return;
+      state.clearInProgress.add(sessionID);
+      state.lastClearTime.set(sessionID, Date.now());
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Context Window",
+          message: `${Math.round(usageRatio * 100)}% used - saving ledger and clearing...`,
+          variant: "warning",
+          duration: 3000
+        }
+      }).catch(() => {});
+      const ledgerSessionResp = await ctx.client.session.create({
+        body: {},
+        query: { directory: ctx.directory }
+      });
+      const ledgerSessionID = ledgerSessionResp.data?.id;
+      if (ledgerSessionID) {
+        await ctx.client.session.prompt({
+          path: { id: ledgerSessionID },
+          body: {
+            parts: [
+              { type: "text", text: "Update the continuity ledger with current session state before context clear." }
+            ],
+            agent: "ledger-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: ledgerSessionID },
+            query: { directory: ctx.directory }
+          });
+          if (statusResp.data?.status === "idle") {
+            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++;
+        }
+      }
+      const firstMessage = messages[0];
+      const firstMessageID = firstMessage?.info?.id;
+      if (!firstMessageID) {
+        throw new Error("Could not find first message ID for revert");
+      }
+      await ctx.client.session.revert({
+        path: { id: sessionID },
+        body: { messageID: firstMessageID },
+        query: { directory: ctx.directory }
+      });
+      const ledger = await findCurrentLedger(ctx.directory);
+      if (ledger) {
+        const injection = formatLedgerInjection(ledger);
+        await ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{ type: "text", text: injection }],
+            noReply: true
+          },
+          query: { directory: ctx.directory }
+        });
+      }
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Context Cleared",
+          message: "Ledger + handoff saved. Session ready to continue.",
+          variant: "success",
+          duration: 5000
+        }
+      }).catch(() => {});
+    } catch (e) {
+      console.error("[auto-clear-ledger] Error:", e);
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Clear Failed",
+          message: "Could not complete context clear. Continuing normally.",
+          variant: "error",
+          duration: 5000
+        }
+      }).catch(() => {});
+    } finally {
+      state.clearInProgress.delete(sessionID);
+    }
+  }
+  return {
+    event: async ({ event }) => {
+      const props = event.properties;
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info;
+        if (sessionInfo?.id) {
+          state.lastClearTime.delete(sessionInfo.id);
+          state.clearInProgress.delete(sessionInfo.id);
+        }
+        return;
+      }
+      if (event.type === "message.updated") {
+        const info = props?.info;
+        const sessionID = info?.sessionID;
+        if (sessionID && info?.role === "assistant") {
+          const providerID = info.providerID;
+          const modelID = info.modelID;
+          await checkAndClear(sessionID, providerID, modelID);
+        }
+      }
+      if (event.type === "session.idle") {
+        const sessionID = props?.sessionID;
+        if (sessionID) {
+          await checkAndClear(sessionID);
+        }
+      }
+    }
+  };
+}
+
+// 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 decisionsMatch = content.match(/## Key Decisions\n([\s\S]*?)(?=\n## |$)/);
+  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"
+  };
+}
+function parsePlan(content, filePath, fileName) {
+  const titleMatch = content.match(/^# (.+)$/m);
+  const title = titleMatch?.[1] || fileName;
+  const overviewMatch = content.match(/## Overview\n\n([\s\S]*?)(?=\n## |$)/);
+  const overview = overviewMatch?.[1]?.trim() || "";
+  const approachMatch = content.match(/## Approach\n\n([\s\S]*?)(?=\n## |$)/);
+  const approach = approachMatch?.[1]?.trim() || "";
+  return {
+    id: `plan-${fileName}`,
+    title,
+    filePath,
+    overview,
+    approach
+  };
+}
+function createArtifactAutoIndexHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, _output) => {
+      if (input.tool !== "write")
+        return;
+      const filePath = input.args?.filePath;
+      if (!filePath)
+        return;
+      try {
+        const ledgerMatch = filePath.match(LEDGER_PATH_PATTERN);
+        if (ledgerMatch) {
+          const content = readFileSync3(filePath, "utf-8");
+          const index = await getArtifactIndex();
+          const record2 = parseLedger(content, filePath, ledgerMatch[1]);
+          await index.indexLedger(record2);
+          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");
+          const index = await getArtifactIndex();
+          const record2 = parsePlan(content, filePath, planMatch[1]);
+          await index.indexPlan(record2);
+          console.log(`[artifact-auto-index] Indexed plan: ${filePath}`);
+          return;
+        }
+      } catch (e) {
+        console.error(`[artifact-auto-index] Error indexing ${filePath}:`, e);
+      }
+    }
+  };
+}
+
 // src/tools/background-task/manager.ts
 var POLL_INTERVAL_MS = 2000;
 function generateTaskId() {
@@ -15103,7 +15740,7 @@ ${task.error}
 `;
     }
     if (task.progress?.lastMessage) {
-      const preview = task.progress.lastMessage.length > 200 ? task.progress.lastMessage.slice(0, 200) + "..." : task.progress.lastMessage;
+      const preview = task.progress.lastMessage.length > 200 ? `${task.progress.lastMessage.slice(0, 200)}...` : task.progress.lastMessage;
       output += `
 ### Last Message Preview
 ${preview}
@@ -15343,6 +15980,18 @@ var MCP_SERVERS = {
     command: ["npx", "-y", "@upstash/context7-mcp@latest"]
   }
 };
+if (process.env.PERPLEXITY_API_KEY) {
+  MCP_SERVERS.perplexity = {
+    type: "local",
+    command: ["npx", "-y", "@anthropic/mcp-perplexity"]
+  };
+}
+if (process.env.FIRECRAWL_API_KEY) {
+  MCP_SERVERS.firecrawl = {
+    type: "local",
+    command: ["npx", "-y", "firecrawl-mcp"]
+  };
+}
 var OpenCodeConfigPlugin = async (ctx) => {
   const astGrepStatus = await checkAstGrepAvailable();
   if (!astGrepStatus.available) {
@@ -15351,11 +16000,13 @@ var OpenCodeConfigPlugin = async (ctx) => {
   const thinkModeState = new Map;
   const autoCompactHook = createAutoCompactHook(ctx);
   const contextInjectorHook = createContextInjectorHook(ctx);
-  const preemptiveCompactionHook = createPreemptiveCompactionHook(ctx);
+  const autoClearLedgerHook = createAutoClearLedgerHook(ctx);
+  const ledgerLoaderHook = createLedgerLoaderHook(ctx);
   const sessionRecoveryHook = createSessionRecoveryHook(ctx);
   const tokenAwareTruncationHook = createTokenAwareTruncationHook(ctx);
   const contextWindowMonitorHook = createContextWindowMonitorHook(ctx);
   const commentCheckerHook = createCommentCheckerHook(ctx);
+  const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
   const backgroundTaskManager = new BackgroundTaskManager(ctx);
   const backgroundTaskTools = createBackgroundTaskTools(backgroundTaskManager);
   return {
@@ -15363,6 +16014,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
       ast_grep_search,
       ast_grep_replace,
       look_at,
+      artifact_search,
       ...backgroundTaskTools
     },
     config: async (config2) => {
@@ -15391,6 +16043,16 @@ var OpenCodeConfigPlugin = async (ctx) => {
           description: "Initialize project with ARCHITECTURE.md and CODE_STYLE.md",
           agent: "project-initializer",
           template: `Initialize this project. $ARGUMENTS`
+        },
+        ledger: {
+          description: "Create or update continuity ledger for session state",
+          agent: "ledger-creator",
+          template: `Update the continuity ledger. $ARGUMENTS`
+        },
+        search: {
+          description: "Search past handoffs, plans, and ledgers",
+          agent: "artifact-searcher",
+          template: `Search for: $ARGUMENTS`
         }
       };
     },
@@ -15399,6 +16061,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
       thinkModeState.set(input.sessionID, detectThinkKeyword(text));
     },
     "chat.params": async (input, output) => {
+      await ledgerLoaderHook["chat.params"](input, output);
       await contextInjectorHook["chat.params"](input, output);
       await contextWindowMonitorHook["chat.params"](input, output);
       if (thinkModeState.get(input.sessionID)) {
@@ -15415,6 +16078,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
       await tokenAwareTruncationHook["tool.execute.after"]({ name: input.tool, sessionID: input.sessionID }, output);
       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);
     },
     event: async ({ event }) => {
       if (event.type === "session.deleted") {
@@ -15424,7 +16088,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
         }
       }
       await autoCompactHook.event({ event });
-      await preemptiveCompactionHook.event({ event });
+      await autoClearLedgerHook.event({ event });
       await sessionRecoveryHook.event({ event });
       await tokenAwareTruncationHook.event({ event });
       await contextWindowMonitorHook.event({ event });