micode 0.9.1 → 0.10.0

package/dist/index.js

@@ -1,13 +1,17 @@
 // @bun
 var __defProp = Object.defineProperty;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = import.meta.require;
@@ -72,7 +76,7 @@ var require_visit = __commonJS((exports) => {
   var BREAK = Symbol("break visit");
   var SKIP = Symbol("skip children");
   var REMOVE = Symbol("remove node");
-  function visit(node, visitor) {
+  function visit2(node, visitor) {
     const visitor_ = initVisitor(visitor);
     if (identity.isDocument(node)) {
       const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
@@ -81,9 +85,9 @@ var require_visit = __commonJS((exports) => {
     } else
       visit_(null, node, visitor_, Object.freeze([]));
   }
-  visit.BREAK = BREAK;
-  visit.SKIP = SKIP;
-  visit.REMOVE = REMOVE;
+  visit2.BREAK = BREAK;
+  visit2.SKIP = SKIP;
+  visit2.REMOVE = REMOVE;
   function visit_(key, node, visitor, path) {
     const ctrl = callVisitor(key, node, visitor, path);
     if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
@@ -217,14 +221,14 @@ var require_visit = __commonJS((exports) => {
       throw new Error(`Cannot replace node with ${pt} parent`);
     }
   }
-  exports.visit = visit;
+  exports.visit = visit2;
   exports.visitAsync = visitAsync;
 });
 
 // node_modules/yaml/dist/doc/directives.js
 var require_directives = __commonJS((exports) => {
   var identity = require_identity();
-  var visit = require_visit();
+  var visit2 = require_visit();
   var escapeChars = {
     "!": "%21",
     ",": "%2C",
@@ -351,7 +355,7 @@ var require_directives = __commonJS((exports) => {
       let tagNames;
       if (doc && tagEntries.length > 0 && identity.isNode(doc.contents)) {
         const tags = {};
-        visit.visit(doc.contents, (_key, node) => {
+        visit2.visit(doc.contents, (_key, node) => {
           if (identity.isNode(node) && node.tag)
             tags[node.tag] = true;
         });
@@ -376,7 +380,7 @@ var require_directives = __commonJS((exports) => {
 // node_modules/yaml/dist/doc/anchors.js
 var require_anchors = __commonJS((exports) => {
   var identity = require_identity();
-  var visit = require_visit();
+  var visit2 = require_visit();
   function anchorIsValid(anchor) {
     if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
       const sa = JSON.stringify(anchor);
@@ -387,7 +391,7 @@ var require_anchors = __commonJS((exports) => {
   }
   function anchorNames(root) {
     const anchors = new Set;
-    visit.visit(root, {
+    visit2.visit(root, {
       Value(_key, node) {
         if (node.anchor)
           anchors.add(node.anchor);
@@ -549,7 +553,7 @@ var require_Node = __commonJS((exports) => {
 // node_modules/yaml/dist/nodes/Alias.js
 var require_Alias = __commonJS((exports) => {
   var anchors = require_anchors();
-  var visit = require_visit();
+  var visit2 = require_visit();
   var identity = require_identity();
   var Node = require_Node();
   var toJS = require_toJS();
@@ -570,7 +574,7 @@ var require_Alias = __commonJS((exports) => {
         nodes = ctx.aliasResolveCache;
       } else {
         nodes = [];
-        visit.visit(doc, {
+        visit2.visit(doc, {
           Node: (_key, node) => {
             if (identity.isAlias(node) || identity.hasAnchor(node))
               nodes.push(node);
@@ -2206,14 +2210,14 @@ var require_bool = __commonJS((exports) => {
 
 // node_modules/yaml/dist/stringify/stringifyNumber.js
 var require_stringifyNumber = __commonJS((exports) => {
-  function stringifyNumber({ format, minFractionDigits, tag, value }) {
+  function stringifyNumber({ format: format2, minFractionDigits, tag, value }) {
     if (typeof value === "bigint")
       return String(value);
     const num = typeof value === "number" ? value : Number(value);
     if (!isFinite(num))
       return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
     let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
-    if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+    if (!format2 && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
       let i = n.indexOf(".");
       if (i < 0) {
         i = n.length;
@@ -5202,15 +5206,15 @@ var require_cst_visit = __commonJS((exports) => {
   var BREAK = Symbol("break visit");
   var SKIP = Symbol("skip children");
   var REMOVE = Symbol("remove item");
-  function visit(cst, visitor) {
+  function visit2(cst, visitor) {
     if ("type" in cst && cst.type === "document")
       cst = { start: cst.start, value: cst.value };
     _visit(Object.freeze([]), cst, visitor);
   }
-  visit.BREAK = BREAK;
-  visit.SKIP = SKIP;
-  visit.REMOVE = REMOVE;
-  visit.itemAtPath = (cst, path) => {
+  visit2.BREAK = BREAK;
+  visit2.SKIP = SKIP;
+  visit2.REMOVE = REMOVE;
+  visit2.itemAtPath = (cst, path) => {
     let item = cst;
     for (const [field, index] of path) {
       const tok = item?.[field];
@@ -5221,8 +5225,8 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return item;
   };
-  visit.parentCollection = (cst, path) => {
-    const parent = visit.itemAtPath(cst, path.slice(0, -1));
+  visit2.parentCollection = (cst, path) => {
+    const parent = visit2.itemAtPath(cst, path.slice(0, -1));
     const field = path[path.length - 1][0];
     const coll = parent?.[field];
     if (coll && "items" in coll)
@@ -5253,7 +5257,7 @@ var require_cst_visit = __commonJS((exports) => {
     }
     return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
   }
-  exports.visit = visit;
+  exports.visit = visit2;
 });
 
 // node_modules/yaml/dist/parse/cst.js
@@ -6867,7 +6871,7 @@ var require_public_api = __commonJS((exports) => {
     }
     return doc;
   }
-  function parse2(src, reviver, options) {
+  function parse4(src, reviver, options) {
     let _reviver = undefined;
     if (typeof reviver === "function") {
       _reviver = reviver;
@@ -6908,12 +6912,85 @@ var require_public_api = __commonJS((exports) => {
       return value.toString(options);
     return new Document.Document(value, _replacer, options).toString(options);
   }
-  exports.parse = parse2;
+  exports.parse = parse4;
   exports.parseAllDocuments = parseAllDocuments;
   exports.parseDocument = parseDocument;
   exports.stringify = stringify;
 });
 
+// src/utils/config.ts
+var config = {
+  compaction: {
+    threshold: 0.7,
+    cooldownMs: 120000,
+    timeoutMs: 120000
+  },
+  contextWindow: {
+    warningThreshold: 0.7,
+    criticalThreshold: 0.85,
+    warningCooldownMs: 120000
+  },
+  tokens: {
+    charsPerToken: 4,
+    defaultContextLimit: 200000,
+    defaultMaxOutputTokens: 50000,
+    safetyMargin: 0.5,
+    preserveHeaderLines: 3
+  },
+  paths: {
+    ledgerDir: "thoughts/ledgers",
+    ledgerPrefix: "CONTINUITY_",
+    rootContextFiles: ["README.md", "ARCHITECTURE.md", "CODE_STYLE.md"],
+    dirContextFiles: ["README.md"],
+    planPattern: /thoughts\/shared\/plans\/.*\.md$/,
+    ledgerPattern: /thoughts\/ledgers\/CONTINUITY_.*\.md$/,
+    mindmodelDir: ".mindmodel",
+    mindmodelManifest: "manifest.yaml",
+    mindmodelSystem: "system.md"
+  },
+  timeouts: {
+    btcaMs: 120000,
+    toastSuccessMs: 3000,
+    toastWarningMs: 4000,
+    toastErrorMs: 5000
+  },
+  limits: {
+    largeFileBytes: 100 * 1024,
+    maxLinesNoExtract: 200,
+    ptyMaxBufferLines: 50000,
+    ptyDefaultReadLimit: 500,
+    ptyMaxLineLength: 2000,
+    astGrepMaxMatches: 100,
+    contextCacheTtlMs: 30000,
+    contextCacheMaxSize: 100
+  },
+  octto: {
+    answerTimeoutMs: 5 * 60 * 1000,
+    reviewTimeoutMs: 10 * 60 * 1000,
+    maxIterations: 50,
+    maxQuestions: 15,
+    stateDir: "thoughts/brainstorms",
+    bindAddress: "127.0.0.1",
+    allowRemoteBind: false
+  },
+  model: {
+    default: "openai/gpt-5.2-codex"
+  },
+  mindmodel: {
+    overrideLogFile: "overrides.log",
+    reviewMaxRetries: 1,
+    reviewEnabled: true,
+    categoryGroups: ["stack", "architecture", "patterns", "style", "components", "domain", "ops"]
+  },
+  fetch: {
+    warnThreshold: 3,
+    maxCallsPerResource: 5,
+    cacheTtlMs: 300000,
+    cacheMaxEntries: 50
+  }
+};
+var DEFAULT_MODEL = config.model.default;
+
 // src/agents/artifact-searcher.ts
 var artifactSearcherAgent = {
   description: "Searches past handoffs, plans, and ledgers for relevant precedent",
@@ -7262,7 +7339,7 @@ The redesigned artifact system treats artifacts as first\u2011class records stor
 
 <phase name="finalizing" trigger="after presenting design">
   <action>Write validated design to thoughts/shared/designs/YYYY-MM-DD-{topic}-design.md</action>
-  <action>Commit the design document to git</action>
+  <action>Commit the design document to git (if git add fails because the file is gitignored, skip the commit \u2014 NEVER force-add ignored files)</action>
   <action>IMMEDIATELY spawn planner - do NOT ask "Ready for planner?"</action>
   <spawn>
     Task(
@@ -7668,6 +7745,7 @@ Not everything needs brainstorm \u2192 plan \u2192 execute.
 <rule>Commit message format: type(scope): description</rule>
 <rule>Types: feat, fix, refactor, docs, test, chore</rule>
 <rule>Reference plan file in commit body</rule>
+<rule>NEVER use git add -f or --force. If a file is gitignored, respect it and skip it.</rule>
 </phase>
 
 <phase name="ledger" trigger="context getting full or session ending">
@@ -7789,7 +7867,7 @@ var primaryAgent = {
   temperature: 0.2,
   thinking: {
     type: "enabled",
-    budgetTokens: 32000
+    budgetTokens: 64000
   },
   maxTokens: 64000,
   tools: {
@@ -10476,221 +10554,1061 @@ Code: \`for (let i = 0; i <= arr.length - 1; i++)\`
 
 // src/agents/index.ts
 var agents = {
-  [PRIMARY_AGENT_NAME]: { ...primaryAgent, model: "openai/gpt-5.2-codex" },
-  brainstormer: { ...brainstormerAgent, model: "openai/gpt-5.2-codex" },
-  bootstrapper: { ...bootstrapperAgent, model: "openai/gpt-5.2-codex" },
-  "codebase-locator": { ...codebaseLocatorAgent, model: "openai/gpt-5.2-codex" },
-  "codebase-analyzer": { ...codebaseAnalyzerAgent, model: "openai/gpt-5.2-codex" },
-  "pattern-finder": { ...patternFinderAgent, model: "openai/gpt-5.2-codex" },
-  planner: { ...plannerAgent, model: "openai/gpt-5.2-codex" },
-  implementer: { ...implementerAgent, model: "openai/gpt-5.2-codex" },
-  reviewer: { ...reviewerAgent, model: "openai/gpt-5.2-codex" },
-  executor: { ...executorAgent, model: "openai/gpt-5.2-codex" },
-  "ledger-creator": { ...ledgerCreatorAgent, model: "openai/gpt-5.2-codex" },
-  "artifact-searcher": { ...artifactSearcherAgent, model: "openai/gpt-5.2-codex" },
-  "project-initializer": { ...projectInitializerAgent, model: "openai/gpt-5.2-codex" },
-  octto: { ...octtoAgent, model: "openai/gpt-5.2-codex" },
-  probe: { ...probeAgent, model: "openai/gpt-5.2-codex" },
-  "mm-stack-detector": { ...stackDetectorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-pattern-discoverer": { ...mindmodelPatternDiscovererAgent, model: "openai/gpt-5.2-codex" },
-  "mm-example-extractor": { ...exampleExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-orchestrator": { ...mindmodelOrchestratorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-dependency-mapper": { ...dependencyMapperAgent, model: "openai/gpt-5.2-codex" },
-  "mm-convention-extractor": { ...conventionExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-domain-extractor": { ...domainExtractorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-code-clusterer": { ...codeClustererAgent, model: "openai/gpt-5.2-codex" },
-  "mm-anti-pattern-detector": { ...antiPatternDetectorAgent, model: "openai/gpt-5.2-codex" },
-  "mm-constraint-writer": { ...constraintWriterAgent, model: "openai/gpt-5.2-codex" },
-  "mm-constraint-reviewer": { ...constraintReviewerAgent, model: "openai/gpt-5.2-codex" }
+  [PRIMARY_AGENT_NAME]: { ...primaryAgent, model: DEFAULT_MODEL },
+  brainstormer: { ...brainstormerAgent, model: DEFAULT_MODEL },
+  bootstrapper: { ...bootstrapperAgent, model: DEFAULT_MODEL },
+  "codebase-locator": { ...codebaseLocatorAgent, model: DEFAULT_MODEL },
+  "codebase-analyzer": { ...codebaseAnalyzerAgent, model: DEFAULT_MODEL },
+  "pattern-finder": { ...patternFinderAgent, model: DEFAULT_MODEL },
+  planner: { ...plannerAgent, model: DEFAULT_MODEL },
+  implementer: { ...implementerAgent, model: DEFAULT_MODEL },
+  reviewer: { ...reviewerAgent, model: DEFAULT_MODEL },
+  executor: { ...executorAgent, model: DEFAULT_MODEL },
+  "ledger-creator": { ...ledgerCreatorAgent, model: DEFAULT_MODEL },
+  "artifact-searcher": { ...artifactSearcherAgent, model: DEFAULT_MODEL },
+  "project-initializer": { ...projectInitializerAgent, model: DEFAULT_MODEL },
+  octto: { ...octtoAgent, model: DEFAULT_MODEL },
+  probe: { ...probeAgent, model: DEFAULT_MODEL },
+  "mm-stack-detector": { ...stackDetectorAgent, model: DEFAULT_MODEL },
+  "mm-pattern-discoverer": { ...mindmodelPatternDiscovererAgent, model: DEFAULT_MODEL },
+  "mm-example-extractor": { ...exampleExtractorAgent, model: DEFAULT_MODEL },
+  "mm-orchestrator": { ...mindmodelOrchestratorAgent, model: DEFAULT_MODEL },
+  "mm-dependency-mapper": { ...dependencyMapperAgent, model: DEFAULT_MODEL },
+  "mm-convention-extractor": { ...conventionExtractorAgent, model: DEFAULT_MODEL },
+  "mm-domain-extractor": { ...domainExtractorAgent, model: DEFAULT_MODEL },
+  "mm-code-clusterer": { ...codeClustererAgent, model: DEFAULT_MODEL },
+  "mm-anti-pattern-detector": { ...antiPatternDetectorAgent, model: DEFAULT_MODEL },
+  "mm-constraint-writer": { ...constraintWriterAgent, model: DEFAULT_MODEL },
+  "mm-constraint-reviewer": { ...constraintReviewerAgent, model: DEFAULT_MODEL }
 };
 
 // src/config-loader.ts
-import { readFileSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { readFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
-function loadOpencodeConfig(configDir) {
-  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
-  try {
-    const configPath = join(baseDir, "opencode.json");
-    const content = readFileSync(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function loadAvailableModels(configDir) {
-  const availableModels = new Set;
-  const config = loadOpencodeConfig(configDir);
-  if (config?.provider) {
-    for (const [providerId, providerConfig] of Object.entries(config.provider)) {
-      if (providerConfig.models) {
-        for (const modelId of Object.keys(providerConfig.models)) {
-          availableModels.add(`${providerId}/${modelId}`);
-        }
+
+// node_modules/jsonc-parser/lib/esm/impl/scanner.js
+function createScanner(text, ignoreTrivia = false) {
+  const len = text.length;
+  let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
+  function scanHexDigits(count, exact) {
+    let digits = 0;
+    let value2 = 0;
+    while (digits < count || !exact) {
+      let ch = text.charCodeAt(pos);
+      if (ch >= 48 && ch <= 57) {
+        value2 = value2 * 16 + ch - 48;
+      } else if (ch >= 65 && ch <= 70) {
+        value2 = value2 * 16 + ch - 65 + 10;
+      } else if (ch >= 97 && ch <= 102) {
+        value2 = value2 * 16 + ch - 97 + 10;
+      } else {
+        break;
       }
+      pos++;
+      digits++;
+    }
+    if (digits < count) {
+      value2 = -1;
     }
+    return value2;
   }
-  return availableModels;
-}
-function loadDefaultModel(configDir) {
-  const config = loadOpencodeConfig(configDir);
-  return config?.model ?? null;
-}
-var SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens"];
-var BUILTIN_MODELS = new Set(["opencode/big-pickle"]);
-async function loadMicodeConfig(configDir) {
-  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
-  const configPath = join(baseDir, "micode.json");
-  try {
-    const content = await readFile(configPath, "utf-8");
-    const parsed = JSON.parse(content);
-    const result = {};
-    if (parsed.agents && typeof parsed.agents === "object") {
-      const sanitizedAgents = {};
-      for (const [agentName, agentConfig] of Object.entries(parsed.agents)) {
-        if (agentConfig && typeof agentConfig === "object") {
-          const sanitized = {};
-          const config = agentConfig;
-          for (const prop of SAFE_AGENT_PROPERTIES) {
-            if (prop in config) {
-              sanitized[prop] = config[prop];
-            }
-          }
-          sanitizedAgents[agentName] = sanitized;
-        }
+  function setPosition(newPosition) {
+    pos = newPosition;
+    value = "";
+    tokenOffset = 0;
+    token = 16;
+    scanError = 0;
+  }
+  function scanNumber() {
+    let start = pos;
+    if (text.charCodeAt(pos) === 48) {
+      pos++;
+    } else {
+      pos++;
+      while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
       }
-      result.agents = sanitizedAgents;
-    }
-    if (parsed.features && typeof parsed.features === "object") {
-      const features = parsed.features;
-      result.features = {
-        mindmodelInjection: features.mindmodelInjection === true
-      };
     }
-    if (typeof parsed.compactionThreshold === "number") {
-      const threshold = parsed.compactionThreshold;
-      if (threshold >= 0 && threshold <= 1) {
-        result.compactionThreshold = threshold;
+    if (pos < text.length && text.charCodeAt(pos) === 46) {
+      pos++;
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
+        }
+      } else {
+        scanError = 3;
+        return text.substring(start, pos);
       }
     }
-    if (parsed.fragments && typeof parsed.fragments === "object") {
-      const fragments = parsed.fragments;
-      const sanitizedFragments = {};
-      for (const [agentName, fragmentList] of Object.entries(fragments)) {
-        if (Array.isArray(fragmentList)) {
-          const validFragments = fragmentList.filter((f) => typeof f === "string" && f.trim().length > 0);
-          if (validFragments.length > 0) {
-            sanitizedFragments[agentName] = validFragments;
-          }
+    let end = pos;
+    if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
+      pos++;
+      if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
+        pos++;
+      }
+      if (pos < text.length && isDigit(text.charCodeAt(pos))) {
+        pos++;
+        while (pos < text.length && isDigit(text.charCodeAt(pos))) {
+          pos++;
         }
+        end = pos;
+      } else {
+        scanError = 3;
       }
-      result.fragments = sanitizedFragments;
     }
-    return result;
-  } catch {
-    return null;
+    return text.substring(start, end);
   }
-}
-function loadModelContextLimits(configDir) {
-  const limits = new Map;
-  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
-  try {
-    const configPath = join(baseDir, "opencode.json");
-    const content = readFileSync(configPath, "utf-8");
-    const config = JSON.parse(content);
-    if (config.provider) {
-      for (const [providerId, providerConfig] of Object.entries(config.provider)) {
-        if (providerConfig.models) {
-          for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
-            const contextLimit = modelConfig?.limit?.context;
-            if (typeof contextLimit === "number" && contextLimit > 0) {
-              limits.set(`${providerId}/${modelId}`, contextLimit);
+  function scanString() {
+    let result = "", start = pos;
+    while (true) {
+      if (pos >= len) {
+        result += text.substring(start, pos);
+        scanError = 2;
+        break;
+      }
+      const ch = text.charCodeAt(pos);
+      if (ch === 34) {
+        result += text.substring(start, pos);
+        pos++;
+        break;
+      }
+      if (ch === 92) {
+        result += text.substring(start, pos);
+        pos++;
+        if (pos >= len) {
+          scanError = 2;
+          break;
+        }
+        const ch2 = text.charCodeAt(pos++);
+        switch (ch2) {
+          case 34:
+            result += '"';
+            break;
+          case 92:
+            result += "\\";
+            break;
+          case 47:
+            result += "/";
+            break;
+          case 98:
+            result += "\b";
+            break;
+          case 102:
+            result += "\f";
+            break;
+          case 110:
+            result += `
+`;
+            break;
+          case 114:
+            result += "\r";
+            break;
+          case 116:
+            result += "\t";
+            break;
+          case 117:
+            const ch3 = scanHexDigits(4, true);
+            if (ch3 >= 0) {
+              result += String.fromCharCode(ch3);
+            } else {
+              scanError = 4;
             }
-          }
+            break;
+          default:
+            scanError = 5;
         }
+        start = pos;
+        continue;
       }
-    }
-  } catch {}
-  return limits;
-}
-function mergeAgentConfigs(pluginAgents, userConfig, availableModels, defaultModel) {
-  const models = availableModels ?? loadAvailableModels();
-  const shouldValidateModels = models.size > 0;
-  const opencodeDefaultModel = defaultModel ?? loadDefaultModel();
-  const isValidModel = (model) => {
-    if (BUILTIN_MODELS.has(model))
-      return true;
-    if (!shouldValidateModels)
-      return true;
-    return models.has(model);
-  };
-  const merged = {};
-  for (const [name, agentConfig] of Object.entries(pluginAgents)) {
-    const userOverride = userConfig?.agents?.[name];
-    let finalConfig = { ...agentConfig };
-    if (opencodeDefaultModel && isValidModel(opencodeDefaultModel)) {
-      finalConfig = { ...finalConfig, model: opencodeDefaultModel };
-    }
-    if (userOverride) {
-      if (userOverride.model) {
-        if (isValidModel(userOverride.model)) {
-          finalConfig = { ...finalConfig, ...userOverride };
+      if (ch >= 0 && ch <= 31) {
+        if (isLineBreak(ch)) {
+          result += text.substring(start, pos);
+          scanError = 2;
+          break;
         } else {
-          const fallbackModel = finalConfig.model || "plugin default";
-          console.warn(`[micode] Model "${userOverride.model}" for agent "${name}" is not available. Using ${fallbackModel}.`);
-          const { model: _ignored, ...safeOverrides } = userOverride;
-          finalConfig = { ...finalConfig, ...safeOverrides };
+          scanError = 6;
         }
-      } else {
-        finalConfig = { ...finalConfig, ...userOverride };
       }
+      pos++;
     }
-    merged[name] = finalConfig;
+    return result;
   }
-  return merged;
-}
-
-// src/hooks/artifact-auto-index.ts
-import { readFileSync as readFileSync3 } from "fs";
-
-// src/tools/artifact-index/index.ts
-import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
-var DEFAULT_DB_DIR = join2(homedir2(), ".config", "opencode", "artifact-index");
-var DB_NAME = "context.db";
-
-class ArtifactIndex {
-  db = null;
-  dbPath;
-  constructor(dbDir = DEFAULT_DB_DIR) {
-    this.dbPath = join2(dbDir, DB_NAME);
+  function scanNext() {
+    value = "";
+    scanError = 0;
+    tokenOffset = pos;
+    lineStartOffset = lineNumber;
+    prevTokenLineStartOffset = tokenLineStartOffset;
+    if (pos >= len) {
+      tokenOffset = len;
+      return token = 17;
+    }
+    let code = text.charCodeAt(pos);
+    if (isWhiteSpace(code)) {
+      do {
+        pos++;
+        value += String.fromCharCode(code);
+        code = text.charCodeAt(pos);
+      } while (isWhiteSpace(code));
+      return token = 15;
+    }
+    if (isLineBreak(code)) {
+      pos++;
+      value += String.fromCharCode(code);
+      if (code === 13 && text.charCodeAt(pos) === 10) {
+        pos++;
+        value += `
+`;
+      }
+      lineNumber++;
+      tokenLineStartOffset = pos;
+      return token = 14;
+    }
+    switch (code) {
+      case 123:
+        pos++;
+        return token = 1;
+      case 125:
+        pos++;
+        return token = 2;
+      case 91:
+        pos++;
+        return token = 3;
+      case 93:
+        pos++;
+        return token = 4;
+      case 58:
+        pos++;
+        return token = 6;
+      case 44:
+        pos++;
+        return token = 5;
+      case 34:
+        pos++;
+        value = scanString();
+        return token = 10;
+      case 47:
+        const start = pos - 1;
+        if (text.charCodeAt(pos + 1) === 47) {
+          pos += 2;
+          while (pos < len) {
+            if (isLineBreak(text.charCodeAt(pos))) {
+              break;
+            }
+            pos++;
+          }
+          value = text.substring(start, pos);
+          return token = 12;
+        }
+        if (text.charCodeAt(pos + 1) === 42) {
+          pos += 2;
+          const safeLength = len - 1;
+          let commentClosed = false;
+          while (pos < safeLength) {
+            const ch = text.charCodeAt(pos);
+            if (ch === 42 && text.charCodeAt(pos + 1) === 47) {
+              pos += 2;
+              commentClosed = true;
+              break;
+            }
+            pos++;
+            if (isLineBreak(ch)) {
+              if (ch === 13 && text.charCodeAt(pos) === 10) {
+                pos++;
+              }
+              lineNumber++;
+              tokenLineStartOffset = pos;
+            }
+          }
+          if (!commentClosed) {
+            pos++;
+            scanError = 1;
+          }
+          value = text.substring(start, pos);
+          return token = 13;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+      case 45:
+        value += String.fromCharCode(code);
+        pos++;
+        if (pos === len || !isDigit(text.charCodeAt(pos))) {
+          return token = 16;
+        }
+      case 48:
+      case 49:
+      case 50:
+      case 51:
+      case 52:
+      case 53:
+      case 54:
+      case 55:
+      case 56:
+      case 57:
+        value += scanNumber();
+        return token = 11;
+      default:
+        while (pos < len && isUnknownContentCharacter(code)) {
+          pos++;
+          code = text.charCodeAt(pos);
+        }
+        if (tokenOffset !== pos) {
+          value = text.substring(tokenOffset, pos);
+          switch (value) {
+            case "true":
+              return token = 8;
+            case "false":
+              return token = 9;
+            case "null":
+              return token = 7;
+          }
+          return token = 16;
+        }
+        value += String.fromCharCode(code);
+        pos++;
+        return token = 16;
+    }
   }
-  async initialize() {
-    const dir = dirname(this.dbPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+  function isUnknownContentCharacter(code) {
+    if (isWhiteSpace(code) || isLineBreak(code)) {
+      return false;
     }
-    this.db = new Database(this.dbPath);
-    const schemaPath = join2(dirname(import.meta.path), "schema.sql");
-    let schema;
-    try {
-      schema = readFileSync2(schemaPath, "utf-8");
-    } catch {
-      schema = this.getInlineSchema();
+    switch (code) {
+      case 125:
+      case 93:
+      case 123:
+      case 91:
+      case 34:
+      case 58:
+      case 44:
+      case 47:
+        return false;
     }
-    this.db.exec(schema);
+    return true;
   }
-  getInlineSchema() {
-    return `
-      CREATE TABLE IF NOT EXISTS plans (
-        id TEXT PRIMARY KEY,
-        title TEXT,
-        file_path TEXT UNIQUE NOT NULL,
-        overview TEXT,
-        approach TEXT,
+  function scanNextNonTrivia() {
+    let result;
+    do {
+      result = scanNext();
+    } while (result >= 12 && result <= 15);
+    return result;
+  }
+  return {
+    setPosition,
+    getPosition: () => pos,
+    scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
+    getToken: () => token,
+    getTokenValue: () => value,
+    getTokenOffset: () => tokenOffset,
+    getTokenLength: () => pos - tokenOffset,
+    getTokenStartLine: () => lineStartOffset,
+    getTokenStartCharacter: () => tokenOffset - prevTokenLineStartOffset,
+    getTokenError: () => scanError
+  };
+}
+function isWhiteSpace(ch) {
+  return ch === 32 || ch === 9;
+}
+function isLineBreak(ch) {
+  return ch === 10 || ch === 13;
+}
+function isDigit(ch) {
+  return ch >= 48 && ch <= 57;
+}
+var CharacterCodes;
+(function(CharacterCodes2) {
+  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
+  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
+  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
+  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
+  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
+  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
+  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
+  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
+  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
+  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
+  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
+  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
+  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
+  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
+  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
+  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
+  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
+  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
+  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
+  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
+  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
+  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
+  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
+  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
+  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
+  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
+  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
+  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
+  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
+  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
+  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
+  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
+  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
+  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
+  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
+  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
+  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
+  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
+  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
+  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
+  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
+  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
+  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
+  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
+  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
+  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
+  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
+  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
+  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
+  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
+  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
+  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
+  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
+  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
+  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
+  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
+  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
+  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
+  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
+  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
+  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
+  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
+  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
+  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
+  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
+  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
+  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
+  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
+  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
+  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
+  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
+  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
+  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
+  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
+  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+})(CharacterCodes || (CharacterCodes = {}));
+
+// node_modules/jsonc-parser/lib/esm/impl/string-intern.js
+var cachedSpaces = new Array(20).fill(0).map((_, index) => {
+  return " ".repeat(index);
+});
+var maxCachedValues = 200;
+var cachedBreakLinesWithSpaces = {
+  " ": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + " ".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + " ".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + " ".repeat(index);
+    })
+  },
+  "\t": {
+    "\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `
+` + "\t".repeat(index);
+    }),
+    "\r": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return "\r" + "\t".repeat(index);
+    }),
+    "\r\n": new Array(maxCachedValues).fill(0).map((_, index) => {
+      return `\r
+` + "\t".repeat(index);
+    })
+  }
+};
+
+// node_modules/jsonc-parser/lib/esm/impl/parser.js
+var ParseOptions;
+(function(ParseOptions2) {
+  ParseOptions2.DEFAULT = {
+    allowTrailingComma: false
+  };
+})(ParseOptions || (ParseOptions = {}));
+function parse(text, errors = [], options = ParseOptions.DEFAULT) {
+  let currentProperty = null;
+  let currentParent = [];
+  const previousParents = [];
+  function onValue(value) {
+    if (Array.isArray(currentParent)) {
+      currentParent.push(value);
+    } else if (currentProperty !== null) {
+      currentParent[currentProperty] = value;
+    }
+  }
+  const visitor = {
+    onObjectBegin: () => {
+      const object = {};
+      onValue(object);
+      previousParents.push(currentParent);
+      currentParent = object;
+      currentProperty = null;
+    },
+    onObjectProperty: (name) => {
+      currentProperty = name;
+    },
+    onObjectEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onArrayBegin: () => {
+      const array = [];
+      onValue(array);
+      previousParents.push(currentParent);
+      currentParent = array;
+      currentProperty = null;
+    },
+    onArrayEnd: () => {
+      currentParent = previousParents.pop();
+    },
+    onLiteralValue: onValue,
+    onError: (error, offset, length) => {
+      errors.push({ error, offset, length });
+    }
+  };
+  visit(text, visitor, options);
+  return currentParent[0];
+}
+function visit(text, visitor, options = ParseOptions.DEFAULT) {
+  const _scanner = createScanner(text, false);
+  const _jsonPath = [];
+  let suppressedCallbacks = 0;
+  function toNoArgVisit(visitFunction) {
+    return visitFunction ? () => suppressedCallbacks === 0 && visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisit(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()) : () => true;
+  }
+  function toOneArgVisitWithPath(visitFunction) {
+    return visitFunction ? (arg) => suppressedCallbacks === 0 && visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice()) : () => true;
+  }
+  function toBeginVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks++;
+      } else {
+        let cbReturn = visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter(), () => _jsonPath.slice());
+        if (cbReturn === false) {
+          suppressedCallbacks = 1;
+        }
+      }
+    } : () => true;
+  }
+  function toEndVisit(visitFunction) {
+    return visitFunction ? () => {
+      if (suppressedCallbacks > 0) {
+        suppressedCallbacks--;
+      }
+      if (suppressedCallbacks === 0) {
+        visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter());
+      }
+    } : () => true;
+  }
+  const onObjectBegin = toBeginVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisitWithPath(visitor.onObjectProperty), onObjectEnd = toEndVisit(visitor.onObjectEnd), onArrayBegin = toBeginVisit(visitor.onArrayBegin), onArrayEnd = toEndVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisitWithPath(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
+  const disallowComments = options && options.disallowComments;
+  const allowTrailingComma = options && options.allowTrailingComma;
+  function scanNext() {
+    while (true) {
+      const token = _scanner.scan();
+      switch (_scanner.getTokenError()) {
+        case 4:
+          handleError(14);
+          break;
+        case 5:
+          handleError(15);
+          break;
+        case 3:
+          handleError(13);
+          break;
+        case 1:
+          if (!disallowComments) {
+            handleError(11);
+          }
+          break;
+        case 2:
+          handleError(12);
+          break;
+        case 6:
+          handleError(16);
+          break;
+      }
+      switch (token) {
+        case 12:
+        case 13:
+          if (disallowComments) {
+            handleError(10);
+          } else {
+            onComment();
+          }
+          break;
+        case 16:
+          handleError(1);
+          break;
+        case 15:
+        case 14:
+          break;
+        default:
+          return token;
+      }
+    }
+  }
+  function handleError(error, skipUntilAfter = [], skipUntil = []) {
+    onError(error);
+    if (skipUntilAfter.length + skipUntil.length > 0) {
+      let token = _scanner.getToken();
+      while (token !== 17) {
+        if (skipUntilAfter.indexOf(token) !== -1) {
+          scanNext();
+          break;
+        } else if (skipUntil.indexOf(token) !== -1) {
+          break;
+        }
+        token = scanNext();
+      }
+    }
+  }
+  function parseString(isValue) {
+    const value = _scanner.getTokenValue();
+    if (isValue) {
+      onLiteralValue(value);
+    } else {
+      onObjectProperty(value);
+      _jsonPath.push(value);
+    }
+    scanNext();
+    return true;
+  }
+  function parseLiteral() {
+    switch (_scanner.getToken()) {
+      case 11:
+        const tokenValue = _scanner.getTokenValue();
+        let value = Number(tokenValue);
+        if (isNaN(value)) {
+          handleError(2);
+          value = 0;
+        }
+        onLiteralValue(value);
+        break;
+      case 7:
+        onLiteralValue(null);
+        break;
+      case 8:
+        onLiteralValue(true);
+        break;
+      case 9:
+        onLiteralValue(false);
+        break;
+      default:
+        return false;
+    }
+    scanNext();
+    return true;
+  }
+  function parseProperty() {
+    if (_scanner.getToken() !== 10) {
+      handleError(3, [], [2, 5]);
+      return false;
+    }
+    parseString(false);
+    if (_scanner.getToken() === 6) {
+      onSeparator(":");
+      scanNext();
+      if (!parseValue()) {
+        handleError(4, [], [2, 5]);
+      }
+    } else {
+      handleError(5, [], [2, 5]);
+    }
+    _jsonPath.pop();
+    return true;
+  }
+  function parseObject() {
+    onObjectBegin();
+    scanNext();
+    let needsComma = false;
+    while (_scanner.getToken() !== 2 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 2 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (!parseProperty()) {
+        handleError(4, [], [2, 5]);
+      }
+      needsComma = true;
+    }
+    onObjectEnd();
+    if (_scanner.getToken() !== 2) {
+      handleError(7, [2], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseArray() {
+    onArrayBegin();
+    scanNext();
+    let isFirstElement = true;
+    let needsComma = false;
+    while (_scanner.getToken() !== 4 && _scanner.getToken() !== 17) {
+      if (_scanner.getToken() === 5) {
+        if (!needsComma) {
+          handleError(4, [], []);
+        }
+        onSeparator(",");
+        scanNext();
+        if (_scanner.getToken() === 4 && allowTrailingComma) {
+          break;
+        }
+      } else if (needsComma) {
+        handleError(6, [], []);
+      }
+      if (isFirstElement) {
+        _jsonPath.push(0);
+        isFirstElement = false;
+      } else {
+        _jsonPath[_jsonPath.length - 1]++;
+      }
+      if (!parseValue()) {
+        handleError(4, [], [4, 5]);
+      }
+      needsComma = true;
+    }
+    onArrayEnd();
+    if (!isFirstElement) {
+      _jsonPath.pop();
+    }
+    if (_scanner.getToken() !== 4) {
+      handleError(8, [4], []);
+    } else {
+      scanNext();
+    }
+    return true;
+  }
+  function parseValue() {
+    switch (_scanner.getToken()) {
+      case 3:
+        return parseArray();
+      case 1:
+        return parseObject();
+      case 10:
+        return parseString(true);
+      default:
+        return parseLiteral();
+    }
+  }
+  scanNext();
+  if (_scanner.getToken() === 17) {
+    if (options.allowEmptyContent) {
+      return true;
+    }
+    handleError(4, [], []);
+    return false;
+  }
+  if (!parseValue()) {
+    handleError(4, [], []);
+    return false;
+  }
+  if (_scanner.getToken() !== 17) {
+    handleError(9, [], []);
+  }
+  return true;
+}
+
+// node_modules/jsonc-parser/lib/esm/main.js
+var ScanError;
+(function(ScanError2) {
+  ScanError2[ScanError2["None"] = 0] = "None";
+  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+})(ScanError || (ScanError = {}));
+var SyntaxKind;
+(function(SyntaxKind2) {
+  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+})(SyntaxKind || (SyntaxKind = {}));
+var parse2 = parse;
+var ParseErrorCode;
+(function(ParseErrorCode2) {
+  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+})(ParseErrorCode || (ParseErrorCode = {}));
+
+// src/config-loader.ts
+function parseConfigJson(content) {
+  const errors = [];
+  const result = parse2(content, errors, { allowTrailingComma: true });
+  if (errors.length > 0) {
+    throw new Error(`Invalid JSON/JSONC: ${errors.length} parse error(s)`);
+  }
+  return result;
+}
+function resolveConfigFileSync(baseDir, baseName) {
+  const jsoncPath = join(baseDir, `${baseName}.jsonc`);
+  if (existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+  const jsonPath = join(baseDir, `${baseName}.json`);
+  if (existsSync(jsonPath)) {
+    return jsonPath;
+  }
+  return null;
+}
+async function readConfigFileAsync(baseDir, baseName) {
+  try {
+    return await readFile(join(baseDir, `${baseName}.jsonc`), "utf-8");
+  } catch {}
+  try {
+    return await readFile(join(baseDir, `${baseName}.json`), "utf-8");
+  } catch {
+    return null;
+  }
+}
+function loadOpencodeConfig(configDir) {
+  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
+  try {
+    const configPath = resolveConfigFileSync(baseDir, "opencode");
+    if (!configPath)
+      return null;
+    const content = readFileSync(configPath, "utf-8");
+    return parseConfigJson(content);
+  } catch {
+    return null;
+  }
+}
+function loadAvailableModels(configDir) {
+  const availableModels = new Set;
+  const config2 = loadOpencodeConfig(configDir);
+  if (config2?.provider) {
+    for (const [providerId, providerConfig] of Object.entries(config2.provider)) {
+      if (providerConfig.models) {
+        for (const modelId of Object.keys(providerConfig.models)) {
+          availableModels.add(`${providerId}/${modelId}`);
+        }
+      }
+    }
+  }
+  return availableModels;
+}
+function loadDefaultModel(configDir) {
+  const config2 = loadOpencodeConfig(configDir);
+  return config2?.model ?? null;
+}
+var SAFE_AGENT_PROPERTIES = ["model", "temperature", "maxTokens", "thinking"];
+var BUILTIN_MODELS = new Set(["opencode/big-pickle"]);
+async function loadMicodeConfig(configDir) {
+  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
+  try {
+    const content = await readConfigFileAsync(baseDir, "micode");
+    if (!content)
+      return null;
+    const parsed = parseConfigJson(content);
+    const result = {};
+    if (parsed.agents && typeof parsed.agents === "object") {
+      const sanitizedAgents = {};
+      for (const [agentName, agentConfig] of Object.entries(parsed.agents)) {
+        if (agentConfig && typeof agentConfig === "object") {
+          const sanitized = {};
+          const config2 = agentConfig;
+          for (const prop of SAFE_AGENT_PROPERTIES) {
+            if (prop in config2) {
+              sanitized[prop] = config2[prop];
+            }
+          }
+          sanitizedAgents[agentName] = sanitized;
+        }
+      }
+      result.agents = sanitizedAgents;
+    }
+    if (parsed.features && typeof parsed.features === "object") {
+      const features = parsed.features;
+      result.features = {
+        mindmodelInjection: features.mindmodelInjection === true
+      };
+    }
+    if (typeof parsed.compactionThreshold === "number") {
+      const threshold = parsed.compactionThreshold;
+      if (threshold >= 0 && threshold <= 1) {
+        result.compactionThreshold = threshold;
+      }
+    }
+    if (parsed.fragments && typeof parsed.fragments === "object") {
+      const fragments = parsed.fragments;
+      const sanitizedFragments = {};
+      for (const [agentName, fragmentList] of Object.entries(fragments)) {
+        if (Array.isArray(fragmentList)) {
+          const validFragments = fragmentList.filter((f) => typeof f === "string" && f.trim().length > 0);
+          if (validFragments.length > 0) {
+            sanitizedFragments[agentName] = validFragments;
+          }
+        }
+      }
+      result.fragments = sanitizedFragments;
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function loadModelContextLimits(configDir) {
+  const limits = new Map;
+  const baseDir = configDir ?? join(homedir(), ".config", "opencode");
+  try {
+    const configPath = resolveConfigFileSync(baseDir, "opencode");
+    if (!configPath)
+      return limits;
+    const content = readFileSync(configPath, "utf-8");
+    const config2 = parseConfigJson(content);
+    if (config2.provider) {
+      for (const [providerId, providerConfig] of Object.entries(config2.provider)) {
+        if (providerConfig.models) {
+          for (const [modelId, modelConfig] of Object.entries(providerConfig.models)) {
+            const contextLimit = modelConfig?.limit?.context;
+            if (typeof contextLimit === "number" && contextLimit > 0) {
+              limits.set(`${providerId}/${modelId}`, contextLimit);
+            }
+          }
+        }
+      }
+    }
+  } catch {}
+  return limits;
+}
+function mergeAgentConfigs(pluginAgents, userConfig, availableModels, defaultModel) {
+  const models = availableModels ?? loadAvailableModels();
+  const shouldValidateModels = models.size > 0;
+  const opencodeDefaultModel = defaultModel ?? loadDefaultModel();
+  const isValidModel = (model) => {
+    if (BUILTIN_MODELS.has(model))
+      return true;
+    if (!shouldValidateModels)
+      return true;
+    return models.has(model);
+  };
+  const merged = {};
+  for (const [name, agentConfig] of Object.entries(pluginAgents)) {
+    const userOverride = userConfig?.agents?.[name];
+    let finalConfig = { ...agentConfig };
+    if (opencodeDefaultModel && isValidModel(opencodeDefaultModel)) {
+      finalConfig = { ...finalConfig, model: opencodeDefaultModel };
+    }
+    if (userOverride) {
+      if (userOverride.model) {
+        if (isValidModel(userOverride.model)) {
+          finalConfig = { ...finalConfig, ...userOverride };
+        } else {
+          const fallbackModel = finalConfig.model || "DEFAULT_MODEL";
+          console.warn(`[micode] Model "${userOverride.model}" for agent "${name}" is not available. Using ${fallbackModel}.`);
+          const { model: _ignored, ...safeOverrides } = userOverride;
+          finalConfig = { ...finalConfig, ...safeOverrides };
+        }
+      } else {
+        finalConfig = { ...finalConfig, ...userOverride };
+      }
+    }
+    merged[name] = finalConfig;
+  }
+  return merged;
+}
+
+// src/hooks/artifact-auto-index.ts
+import { readFileSync as readFileSync3 } from "fs";
+
+// src/tools/artifact-index/index.ts
+import { Database } from "bun:sqlite";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var DEFAULT_DB_DIR = join2(homedir2(), ".config", "opencode", "artifact-index");
+var DB_NAME = "context.db";
+
+class ArtifactIndex {
+  db = null;
+  dbPath;
+  constructor(dbDir = DEFAULT_DB_DIR) {
+    this.dbPath = join2(dbDir, DB_NAME);
+  }
+  async initialize() {
+    const dir = dirname(this.dbPath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    const schemaPath = join2(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 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
       );
@@ -11026,79 +11944,16 @@ function createArtifactAutoIndexHook(_ctx) {
           await index.indexPlan(record);
           return;
         }
-      } catch (e) {
-        log.error("artifact-auto-index", `Error indexing ${filePath}`, e);
-      }
-    }
-  };
-}
-
-// src/hooks/auto-compact.ts
-import { mkdir, writeFile } from "fs/promises";
-import { join as join3 } from "path";
-
-// src/utils/config.ts
-var config = {
-  compaction: {
-    threshold: 0.7,
-    cooldownMs: 120000,
-    timeoutMs: 120000
-  },
-  contextWindow: {
-    warningThreshold: 0.7,
-    criticalThreshold: 0.85,
-    warningCooldownMs: 120000
-  },
-  tokens: {
-    charsPerToken: 4,
-    defaultContextLimit: 200000,
-    defaultMaxOutputTokens: 50000,
-    safetyMargin: 0.5,
-    preserveHeaderLines: 3
-  },
-  paths: {
-    ledgerDir: "thoughts/ledgers",
-    ledgerPrefix: "CONTINUITY_",
-    rootContextFiles: ["README.md", "ARCHITECTURE.md", "CODE_STYLE.md"],
-    dirContextFiles: ["README.md"],
-    planPattern: /thoughts\/shared\/plans\/.*\.md$/,
-    ledgerPattern: /thoughts\/ledgers\/CONTINUITY_.*\.md$/,
-    mindmodelDir: ".mindmodel",
-    mindmodelManifest: "manifest.yaml",
-    mindmodelSystem: "system.md"
-  },
-  timeouts: {
-    btcaMs: 120000,
-    toastSuccessMs: 3000,
-    toastWarningMs: 4000,
-    toastErrorMs: 5000
-  },
-  limits: {
-    largeFileBytes: 100 * 1024,
-    maxLinesNoExtract: 200,
-    ptyMaxBufferLines: 50000,
-    ptyDefaultReadLimit: 500,
-    ptyMaxLineLength: 2000,
-    astGrepMaxMatches: 100,
-    contextCacheTtlMs: 30000,
-    contextCacheMaxSize: 100
-  },
-  octto: {
-    answerTimeoutMs: 5 * 60 * 1000,
-    reviewTimeoutMs: 10 * 60 * 1000,
-    maxIterations: 50,
-    maxQuestions: 15,
-    stateDir: "thoughts/brainstorms",
-    bindAddress: "127.0.0.1",
-    allowRemoteBind: false
-  },
-  mindmodel: {
-    overrideLogFile: "overrides.log",
-    reviewMaxRetries: 1,
-    reviewEnabled: true,
-    categoryGroups: ["stack", "architecture", "patterns", "style", "components", "domain", "ops"]
-  }
-};
+      } catch (e) {
+        log.error("artifact-auto-index", `Error indexing ${filePath}`, e);
+      }
+    }
+  };
+}
+
+// src/hooks/auto-compact.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join3 } from "path";
 
 // src/utils/errors.ts
 function extractErrorMessage(e) {
@@ -11720,7 +12575,7 @@ function string(message$1) {
     }
   };
 }
-function parse(schema, input, config$1) {
+function parse3(schema, input, config$1) {
   const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config$1));
   if (dataset.issues)
     throw new ValiError(dataset.issues);
@@ -11764,7 +12619,7 @@ var lexer = require_lexer();
 var lineCounter = require_line_counter();
 var parser = require_parser();
 var publicApi = require_public_api();
-var visit = require_visit();
+var visit2 = require_visit();
 var $Composer = composer.Composer;
 var $Document = Document.Document;
 var $Schema = Schema.Schema;
@@ -11791,8 +12646,8 @@ var $parse = publicApi.parse;
 var $parseAllDocuments = publicApi.parseAllDocuments;
 var $parseDocument = publicApi.parseDocument;
 var $stringify = publicApi.stringify;
-var $visit = visit.visit;
-var $visitAsync = visit.visitAsync;
+var $visit = visit2.visit;
+var $visitAsync = visit2.visitAsync;
 
 // src/mindmodel/types.ts
 var CategorySchema = object({
@@ -11807,7 +12662,7 @@ var ManifestSchema = object({
 });
 function parseManifest(yamlContent) {
   const parsed = $parse(yamlContent);
-  return parse(ManifestSchema, parsed);
+  return parse3(ManifestSchema, parsed);
 }
 
 // src/mindmodel/loader.ts
@@ -11827,7 +12682,7 @@ async function loadMindmodel(projectDir) {
       manifest
     };
   } catch (error) {
-    console.warn(`[micode] Failed to load mindmodel manifest: ${error}`);
+    log.warn("mindmodel", `Failed to load manifest: ${error}`);
     return null;
   }
 }
@@ -11846,7 +12701,7 @@ async function loadExamples(mindmodel, categoryPaths) {
         content
       });
     } catch {
-      console.warn(`[micode] Failed to load mindmodel example: ${categoryPath}`);
+      log.warn("mindmodel", `Failed to load example: ${categoryPath}`);
     }
   }
   return examples;
@@ -12205,6 +13060,165 @@ function createContextWindowMonitorHook(ctx, hookConfig) {
   };
 }
 
+// src/hooks/fetch-tracker.ts
+var FETCH_TOOLS = new Set(["webfetch", "context7_query-docs", "context7_resolve-library-id", "btca_ask"]);
+
+class LRUCache {
+  maxSize;
+  cache = new Map;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined)
+        this.cache.delete(firstKey);
+    }
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+var sessionCallCounts = new Map;
+var sessionCaches = new Map;
+function normalizeKey(tool, args) {
+  if (!FETCH_TOOLS.has(tool) || !args)
+    return null;
+  try {
+    switch (tool) {
+      case "webfetch": {
+        const rawUrl = args.url;
+        if (!rawUrl)
+          return null;
+        try {
+          const parsed = new URL(rawUrl);
+          parsed.searchParams.sort();
+          return `webfetch|${parsed.toString()}`;
+        } catch {
+          return `webfetch|${rawUrl}`;
+        }
+      }
+      case "context7_query-docs": {
+        const libraryId = args.libraryId;
+        const query = args.query;
+        if (!libraryId || !query)
+          return null;
+        return `context7_query-docs|${libraryId}|${query}`;
+      }
+      case "context7_resolve-library-id": {
+        const libraryName = args.libraryName;
+        const query = args.query;
+        if (!libraryName || !query)
+          return null;
+        return `context7_resolve-library-id|${libraryName}|${query}`;
+      }
+      case "btca_ask": {
+        const tech = args.tech;
+        const question = args.question;
+        if (!tech || !question)
+          return null;
+        return `btca_ask|${tech}|${question}`;
+      }
+      default:
+        return null;
+    }
+  } catch (error) {
+    log.warn("hooks.fetch-tracker", `Key normalization failed: ${error instanceof Error ? error.message : "unknown"}`);
+    return null;
+  }
+}
+function clearSession(sessionID) {
+  sessionCallCounts.delete(sessionID);
+  sessionCaches.delete(sessionID);
+}
+function getOrCreateCounts(sessionID) {
+  let counts = sessionCallCounts.get(sessionID);
+  if (!counts) {
+    counts = new Map;
+    sessionCallCounts.set(sessionID, counts);
+  }
+  return counts;
+}
+function getOrCreateCache(sessionID) {
+  let cache = sessionCaches.get(sessionID);
+  if (!cache) {
+    cache = new LRUCache(config.fetch.cacheMaxEntries);
+    sessionCaches.set(sessionID, cache);
+  }
+  return cache;
+}
+function incrementCount(sessionID, key) {
+  const counts = getOrCreateCounts(sessionID);
+  const current = counts.get(key) ?? 0;
+  const next = current + 1;
+  counts.set(key, next);
+  return next;
+}
+function isCacheExpired(entry) {
+  return Date.now() - entry.timestamp > config.fetch.cacheTtlMs;
+}
+function createFetchTrackerHook(_ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      try {
+        if (!FETCH_TOOLS.has(input.tool))
+          return;
+        const key = normalizeKey(input.tool, input.args);
+        if (!key)
+          return;
+        const count = incrementCount(input.sessionID, key);
+        if (count > config.fetch.maxCallsPerResource) {
+          output.output = `<fetch-blocked>This resource has been fetched ${count} times this session. The content is already available in the conversation above. Use the information already available instead of re-fetching.</fetch-blocked>`;
+          return;
+        }
+        const cache = getOrCreateCache(input.sessionID);
+        const cached = cache.get(key);
+        if (count > 1 && cached && !isCacheExpired(cached)) {
+          let cachedOutput = `<from-cache>Returning cached result (fetched ${count} time${count !== 1 ? "s" : ""} previously).</from-cache>
+
+${cached.content}`;
+          if (count >= config.fetch.warnThreshold) {
+            cachedOutput += `
+
+<fetch-warning>You have fetched this resource ${count} times. The content is cached and identical. Consider using the information you already have instead of re-fetching.</fetch-warning>`;
+          }
+          output.output = cachedOutput;
+        } else {
+          if (output.output) {
+            cache.set(key, { content: output.output, timestamp: Date.now() });
+          }
+        }
+      } catch (error) {
+        log.warn("hooks.fetch-tracker", `After hook error: ${error instanceof Error ? error.message : "unknown"}`);
+      }
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        if (props?.info?.id) {
+          clearSession(props.info.id);
+        }
+      }
+    },
+    cleanupSession: clearSession
+  };
+}
+
 // src/hooks/file-ops-tracker.ts
 var sessionFileOps = new Map;
 function getOrCreateOps(sessionID) {
@@ -12495,7 +13509,7 @@ __export(exports_external, {
   pipe: () => pipe2,
   partialRecord: () => partialRecord,
   parseAsync: () => parseAsync2,
-  parse: () => parse4,
+  parse: () => parse6,
   overwrite: () => _overwrite,
   optional: () => optional2,
   object: () => object2,
@@ -12685,7 +13699,7 @@ __export(exports_core2, {
   regexes: () => exports_regexes,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
-  parse: () => parse2,
+  parse: () => parse4,
   locales: () => exports_locales,
   isValidJWT: () => isValidJWT,
   isValidBase64URL: () => isValidBase64URL,
@@ -13784,7 +14798,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-var parse2 = /* @__PURE__ */ _parse($ZodRealError);
+var parse4 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -16302,10 +17316,10 @@ var $ZodFunction = /* @__PURE__ */ $constructor("$ZodFunction", (inst, def) => {
       throw new Error("implement() must be called with a function");
     }
     return function(...args) {
-      const parsedArgs = inst._def.input ? parse2(inst._def.input, args) : args;
+      const parsedArgs = inst._def.input ? parse4(inst._def.input, args) : args;
       const result = Reflect.apply(func, this, parsedArgs);
       if (inst._def.output) {
-        return parse2(inst._def.output, result);
+        return parse4(inst._def.output, result);
       }
       return result;
     };
@@ -22814,13 +23828,13 @@ function _stringbool(Classes, _params) {
   });
   return codec;
 }
-function _stringFormat(Class2, format, fnOrRegex, _params = {}) {
+function _stringFormat(Class2, format2, fnOrRegex, _params = {}) {
   const params = normalizeParams(_params);
   const def = {
     ...normalizeParams(_params),
     check: "string_format",
     type: "string",
-    format,
+    format: format2,
     fn: typeof fnOrRegex === "function" ? fnOrRegex : (val) => fnOrRegex.test(val),
     ...params
   };
@@ -22882,13 +23896,13 @@ class JSONSchemaGenerator {
           case "string": {
             const json = _json;
             json.type = "string";
-            const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+            const { minimum, maximum, format: format2, patterns, contentEncoding } = schema._zod.bag;
             if (typeof minimum === "number")
               json.minLength = minimum;
             if (typeof maximum === "number")
               json.maxLength = maximum;
-            if (format) {
-              json.format = formatMap[format] ?? format;
+            if (format2) {
+              json.format = formatMap[format2] ?? format2;
               if (json.format === "")
                 delete json.format;
             }
@@ -22911,8 +23925,8 @@ class JSONSchemaGenerator {
           }
           case "number": {
             const json = _json;
-            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
-            if (typeof format === "string" && format.includes("int"))
+            const { minimum, maximum, format: format2, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+            if (typeof format2 === "string" && format2.includes("int"))
               json.type = "integer";
             else
               json.type = "number";
@@ -23713,7 +24727,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
 });
 
 // node_modules/zod/v4/classic/parse.js
-var parse4 = /* @__PURE__ */ _parse(ZodRealError);
+var parse6 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -23747,7 +24761,7 @@ var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     reg.add(inst, meta);
     return inst;
   };
-  inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
+  inst.parse = (data, params) => parse6(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse2(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -24012,8 +25026,8 @@ var ZodCustomStringFormat = /* @__PURE__ */ $constructor("ZodCustomStringFormat"
   $ZodCustomStringFormat.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
-function stringFormat(format, fnOrRegex, _params = {}) {
-  return _stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params);
+function stringFormat(format2, fnOrRegex, _params = {}) {
+  return _stringFormat(ZodCustomStringFormat, format2, fnOrRegex, _params);
 }
 function hostname2(_params) {
   return _stringFormat(ZodCustomStringFormat, "hostname", exports_regexes.hostname, _params);
@@ -24023,11 +25037,11 @@ function hex2(_params) {
 }
 function hash(alg, params) {
   const enc = params?.enc ?? "hex";
-  const format = `${alg}_${enc}`;
-  const regex = exports_regexes[format];
+  const format2 = `${alg}_${enc}`;
+  const regex = exports_regexes[format2];
   if (!regex)
-    throw new Error(`Unrecognized hash format: ${format}`);
-  return _stringFormat(ZodCustomStringFormat, format, regex, params);
+    throw new Error(`Unrecognized hash format: ${format2}`);
+  return _stringFormat(ZodCustomStringFormat, format2, regex, params);
 }
 var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   $ZodNumber.init(inst, def);
@@ -24802,13 +25816,13 @@ Returns relevant code examples and patterns to follow.`,
         if (categories.length === 0) {
           return "No specific patterns found for this task. Proceed using general best practices.";
         }
-        log.info("mindmodel", `Matched categories: ${categories.join(", ")}`);
+        log.debug("mindmodel", `Matched categories: ${categories.join(", ")}`);
         const examples = await loadExamples(mindmodel, categories);
         if (examples.length === 0) {
           return "Categories matched but no examples found. Proceed using general best practices.";
         }
         const formatted = formatExamplesForInjection(examples);
-        log.info("mindmodel", `Returning ${examples.length} examples`);
+        log.debug("mindmodel", `Returning ${examples.length} examples`);
         return formatted;
       } catch (error45) {
         log.warn("mindmodel", `Lookup failed: ${error45 instanceof Error ? error45.message : "unknown"}`);
@@ -24830,7 +25844,7 @@ function hashTask(task) {
   return hash2.toString(36);
 }
 
-class LRUCache {
+class LRUCache2 {
   maxSize;
   cache = new Map;
   constructor(maxSize) {
@@ -24862,7 +25876,7 @@ function createMindmodelInjectorHook(ctx) {
   let cachedMindmodel2;
   let cachedSystemMd;
   let pendingInjection = null;
-  const matchedTasks = new LRUCache(2000);
+  const matchedTasks = new LRUCache2(2000);
   async function getMindmodel2() {
     if (cachedMindmodel2 === undefined) {
       cachedMindmodel2 = await loadMindmodel(ctx.directory);
@@ -27957,7 +28971,7 @@ function createSessionStore(options = {}) {
   return store;
 }
 // src/octto/state/persistence.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
 import { join as join10 } from "path";
 function validateSessionId(sessionId) {
   if (!/^[a-zA-Z0-9_-]+$/.test(sessionId)) {
@@ -27970,7 +28984,7 @@ function createStatePersistence(baseDir = STATE_DIR) {
     return join10(baseDir, `${sessionId}.json`);
   }
   function ensureDir() {
-    if (!existsSync2(baseDir)) {
+    if (!existsSync3(baseDir)) {
       mkdirSync2(baseDir, { recursive: true });
     }
   }
@@ -27983,7 +28997,7 @@ function createStatePersistence(baseDir = STATE_DIR) {
     },
     async load(sessionId) {
       const filePath = getFilePath(sessionId);
-      if (!existsSync2(filePath)) {
+      if (!existsSync3(filePath)) {
         return null;
       }
       const content = await Bun.file(filePath).text();
@@ -27991,12 +29005,12 @@ function createStatePersistence(baseDir = STATE_DIR) {
     },
     async delete(sessionId) {
       const filePath = getFilePath(sessionId);
-      if (existsSync2(filePath)) {
+      if (existsSync3(filePath)) {
         rmSync(filePath);
       }
     },
     async list() {
-      if (!existsSync2(baseDir)) {
+      if (!existsSync3(baseDir)) {
         return [];
       }
       const files = readdirSync(baseDir);
@@ -29249,9 +30263,6 @@ function createOcttoTools(sessions, client, tracker) {
   };
 }
 
-// src/tools/pty/manager.ts
-import { spawn as spawn3 } from "bun-pty";
-
 // src/tools/pty/buffer.ts
 var parsed = parseInt(process.env.PTY_MAX_BUFFER_LINES || "50000", 10);
 var DEFAULT_MAX_LINES = isNaN(parsed) ? 50000 : parsed;
@@ -29294,7 +30305,6 @@ class RingBuffer {
     this.lines = [];
   }
 }
-
 // src/tools/pty/manager.ts
 function generateId2() {
   const hex3 = Array.from(crypto.getRandomValues(new Uint8Array(4))).map((b) => b.toString(16).padStart(2, "0")).join("");
@@ -29303,7 +30313,19 @@ function generateId2() {
 
 class PTYManager {
   sessions = new Map;
+  spawnFn = null;
+  _available = false;
+  init(spawnFn) {
+    this.spawnFn = spawnFn;
+    this._available = true;
+  }
+  get available() {
+    return this._available;
+  }
   spawn(opts) {
+    if (!this.spawnFn) {
+      throw new Error("PTY unavailable: bun-pty native library could not be loaded. " + "Set BUN_PTY_LIB environment variable to the path of the native library " + "(e.g., .opencode/node_modules/bun-pty/rust-pty/target/release/librust_pty.dylib)");
+    }
     const id = generateId2();
     const args = opts.args ?? [];
     const workdir = opts.workdir ?? process.cwd();
@@ -29311,7 +30333,7 @@ class PTYManager {
     const title = opts.title ?? (`${opts.command} ${args.join(" ")}`.trim() || `Terminal ${id.slice(-4)}`);
     let ptyProcess;
     try {
-      ptyProcess = spawn3(opts.command, args, {
+      ptyProcess = this.spawnFn(opts.command, args, {
         name: "xterm-256color",
         cols: 120,
         rows: 40,
@@ -29433,150 +30455,166 @@ class PTYManager {
     };
   }
 }
-// src/tools/pty/tools/spawn.ts
-var DESCRIPTION = `Spawns a new interactive PTY (pseudo-terminal) session that runs in the background.
-
-Unlike the built-in bash tool which runs commands synchronously and waits for completion, PTY sessions persist and allow you to:
-- Run long-running processes (dev servers, watch modes, etc.)
-- Send interactive input (including Ctrl+C, arrow keys, etc.)
-- Read output at any time
-- Manage multiple concurrent terminal sessions
-
-Usage:
-- The \`command\` parameter is required (e.g., "npm", "python", "bash")
-- Use \`args\` to pass arguments to the command (e.g., ["run", "dev"])
-- Use \`workdir\` to set the working directory (defaults to project root)
-- Use \`env\` to set additional environment variables
-- Use \`title\` to give the session a human-readable name
-- Use \`description\` for a clear, concise 5-10 word description (optional)
-
-Returns the session info including:
-- \`id\`: Unique identifier (pty_XXXXXXXX) for use with other pty_* tools
-- \`pid\`: Process ID
-- \`status\`: Current status ("running")
-
-After spawning, use:
-- \`pty_write\` to send input to the PTY
-- \`pty_read\` to read output from the PTY
-- \`pty_list\` to see all active PTY sessions
-- \`pty_kill\` to terminate the PTY
-
-Examples:
-- Start a dev server: command="npm", args=["run", "dev"], title="Dev Server"
-- Start a Python REPL: command="python3", title="Python REPL"
-- Run tests in watch mode: command="npm", args=["test", "--", "--watch"]`;
-function createPtySpawnTool(manager) {
-  return tool({
-    description: DESCRIPTION,
-    args: {
-      command: tool.schema.string().describe("The command/executable to run"),
-      args: tool.schema.array(tool.schema.string()).optional().describe("Arguments to pass to the command"),
-      workdir: tool.schema.string().optional().describe("Working directory for the PTY session"),
-      env: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Additional environment variables"),
-      title: tool.schema.string().optional().describe("Human-readable title for the session"),
-      description: tool.schema.string().optional().describe("Clear, concise description of what this PTY session is for in 5-10 words")
-    },
-    execute: async (args, ctx) => {
-      const info = manager.spawn({
-        command: args.command,
-        args: args.args,
-        workdir: args.workdir,
-        env: args.env,
-        title: args.title,
-        parentSessionId: ctx.sessionID
-      });
-      const output = [
-        `<pty_spawned>`,
-        `ID: ${info.id}`,
-        `Title: ${info.title}`,
-        `Command: ${info.command} ${info.args.join(" ")}`,
-        `Workdir: ${info.workdir}`,
-        `PID: ${info.pid}`,
-        `Status: ${info.status}`,
-        `</pty_spawned>`
-      ].join(`
-`);
-      return output;
+// src/tools/pty/pty-loader.ts
+import { existsSync as existsSync4 } from "fs";
+import { dirname as dirname3, join as join11 } from "path";
+var cachedModule = null;
+var loadAttempted = false;
+var loadError = null;
+function probeBunPtyLib() {
+  if (process.env.BUN_PTY_LIB)
+    return;
+  const platform = process.platform;
+  const arch = process.arch;
+  const filenames = platform === "darwin" ? arch === "arm64" ? ["librust_pty_arm64.dylib", "librust_pty.dylib"] : ["librust_pty.dylib"] : platform === "win32" ? ["rust_pty.dll"] : arch === "arm64" ? ["librust_pty_arm64.so", "librust_pty.so"] : ["librust_pty.so"];
+  const cwd = process.cwd();
+  const additionalBasePaths = [
+    join11(cwd, ".opencode", "node_modules", "bun-pty", "rust-pty", "target", "release"),
+    join11(cwd, ".micode", "node_modules", "bun-pty", "rust-pty", "target", "release")
+  ];
+  try {
+    const bunPtyMain = __require.resolve("bun-pty");
+    if (bunPtyMain) {
+      const pkgDir = dirname3(dirname3(bunPtyMain));
+      additionalBasePaths.unshift(join11(pkgDir, "rust-pty", "target", "release"));
     }
-  });
+  } catch {}
+  for (const basePath of additionalBasePaths) {
+    for (const filename of filenames) {
+      const candidate = join11(basePath, filename);
+      if (existsSync4(candidate)) {
+        process.env.BUN_PTY_LIB = candidate;
+        log.info("pty.loader", `Auto-resolved BUN_PTY_LIB=${candidate}`);
+        return;
+      }
+    }
+  }
 }
-// src/tools/pty/tools/write.ts
-var DESCRIPTION2 = `Sends input data to an active PTY session.
+async function loadBunPty() {
+  if (loadAttempted)
+    return cachedModule;
+  loadAttempted = true;
+  probeBunPtyLib();
+  try {
+    cachedModule = await import("bun-pty");
+    log.info("pty.loader", "bun-pty loaded successfully");
+    return cachedModule;
+  } catch (error45) {
+    loadError = error45 instanceof Error ? error45.message : String(error45);
+    const firstLine = loadError.split(`
+`)[0];
+    log.warn("pty.loader", `bun-pty unavailable: ${firstLine}`);
+    log.warn("pty.loader", "PTY tools will be disabled. Set BUN_PTY_LIB env var to the native library path to fix.");
+    cachedModule = null;
+    return null;
+  }
+}
+// src/tools/pty/tools/kill.ts
+var DESCRIPTION = `Terminates a PTY session and optionally cleans up its buffer.
 
 Use this tool to:
-- Type commands or text into an interactive terminal
-- Send special key sequences (Ctrl+C, Enter, arrow keys, etc.)
-- Respond to prompts in interactive programs
+- Stop a running process (sends SIGTERM)
+- Clean up an exited session to free memory
+- Remove a session from the list
 
 Usage:
 - \`id\`: The PTY session ID (from pty_spawn or pty_list)
-- \`data\`: The input to send (text, commands, or escape sequences)
+- \`cleanup\`: If true, removes the session and frees the buffer (default: false)
 
-Common escape sequences:
-- Enter/newline: "\\n" or "\\r"
-- Ctrl+C (interrupt): "\\x03"
-- Ctrl+D (EOF): "\\x04"
-- Ctrl+Z (suspend): "\\x1a"
-- Tab: "\\t"
-- Arrow Up: "\\x1b[A"
-- Arrow Down: "\\x1b[B"
-- Arrow Right: "\\x1b[C"
-- Arrow Left: "\\x1b[D"
+Behavior:
+- If the session is running, it will be killed (status becomes "killed")
+- If cleanup=false (default), the session remains in the list with its output buffer intact
+- If cleanup=true, the session is removed entirely and the buffer is freed
+- Keeping sessions without cleanup allows you to compare logs between runs
 
-Returns success or error message.
+Tips:
+- Use cleanup=false if you might want to read the output later
+- Use cleanup=true when you're done with the session entirely
+- To send Ctrl+C instead of killing, use pty_write with data="\\x03"
 
 Examples:
-- Send a command: data="ls -la\\n"
-- Interrupt a process: data="\\x03"
-- Answer a prompt: data="yes\\n"`;
-function parseEscapeSequences(input) {
-  return input.replace(/\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|[nrt0\\])/g, (match, seq) => {
-    if (seq.startsWith("x")) {
-      return String.fromCharCode(parseInt(seq.slice(1), 16));
-    }
-    if (seq.startsWith("u")) {
-      return String.fromCharCode(parseInt(seq.slice(1), 16));
-    }
-    switch (seq) {
-      case "n":
-        return `
-`;
-      case "r":
-        return "\r";
-      case "t":
-        return "\t";
-      case "0":
-        return "\x00";
-      case "\\":
-        return "\\";
-      default:
-        return match;
+- Kill but keep logs: cleanup=false (or omit)
+- Kill and remove: cleanup=true`;
+function createPtyKillTool(manager) {
+  return tool({
+    description: DESCRIPTION,
+    args: {
+      id: tool.schema.string().describe("The PTY session ID (e.g., pty_a1b2c3d4)"),
+      cleanup: tool.schema.boolean().optional().describe("If true, removes the session and frees the buffer (default: false)")
+    },
+    execute: async (args) => {
+      const session = manager.get(args.id);
+      if (!session) {
+        throw new Error(`PTY session '${args.id}' not found. Use pty_list to see active sessions.`);
+      }
+      const wasRunning = session.status === "running";
+      const cleanup = args.cleanup ?? false;
+      const success2 = manager.kill(args.id, cleanup);
+      if (!success2) {
+        throw new Error(`Failed to kill PTY session '${args.id}'.`);
+      }
+      const action = wasRunning ? "Killed" : "Cleaned up";
+      const cleanupNote = cleanup ? " (session removed)" : " (session retained for log access)";
+      return [
+        `<pty_killed>`,
+        `${action}: ${args.id}${cleanupNote}`,
+        `Title: ${session.title}`,
+        `Command: ${session.command} ${session.args.join(" ")}`,
+        `Final line count: ${session.lineCount}`,
+        `</pty_killed>`
+      ].join(`
+`);
     }
   });
 }
-function createPtyWriteTool(manager) {
+// src/tools/pty/tools/list.ts
+var DESCRIPTION2 = `Lists all PTY sessions (active and exited).
+
+Use this tool to:
+- See all running and exited PTY sessions
+- Get session IDs for use with other pty_* tools
+- Check the status and output line count of each session
+- Monitor which processes are still running
+
+Returns for each session:
+- \`id\`: Unique identifier for use with other tools
+- \`title\`: Human-readable name
+- \`command\`: The command that was executed
+- \`status\`: Current status (running, exited, killed)
+- \`exitCode\`: Exit code (if exited/killed)
+- \`pid\`: Process ID
+- \`lineCount\`: Number of lines in the output buffer
+- \`createdAt\`: When the session was created
+
+Tips:
+- Use the session ID with pty_read, pty_write, or pty_kill
+- Sessions remain in the list after exit until explicitly cleaned up with pty_kill
+- This allows you to compare output from multiple sessions`;
+function createPtyListTool(manager) {
   return tool({
     description: DESCRIPTION2,
-    args: {
-      id: tool.schema.string().describe("The PTY session ID (e.g., pty_a1b2c3d4)"),
-      data: tool.schema.string().describe("The input data to send to the PTY")
-    },
-    execute: async (args) => {
-      const session = manager.get(args.id);
-      if (!session) {
-        throw new Error(`PTY session '${args.id}' not found. Use pty_list to see active sessions.`);
-      }
-      if (session.status !== "running") {
-        throw new Error(`Cannot write to PTY '${args.id}' - session status is '${session.status}'.`);
+    args: {},
+    execute: async () => {
+      const sessions = manager.list();
+      if (sessions.length === 0) {
+        return `<pty_list>
+No active PTY sessions.
+</pty_list>`;
       }
-      const parsedData = parseEscapeSequences(args.data);
-      const success2 = manager.write(args.id, parsedData);
-      if (!success2) {
-        throw new Error(`Failed to write to PTY '${args.id}'.`);
+      const lines = ["<pty_list>"];
+      for (const session of sessions) {
+        const exitInfo = session.exitCode !== undefined ? ` (exit: ${session.exitCode})` : "";
+        lines.push(`[${session.id}] ${session.title}`);
+        lines.push(`  Command: ${session.command} ${session.args.join(" ")}`);
+        lines.push(`  Status: ${session.status}${exitInfo}`);
+        lines.push(`  PID: ${session.pid} | Lines: ${session.lineCount} | Workdir: ${session.workdir}`);
+        lines.push(`  Created: ${session.createdAt.toISOString()}`);
+        lines.push("");
       }
-      const preview = args.data.length > 50 ? `${args.data.slice(0, 50)}...` : args.data;
-      const displayPreview = preview.replace(/\x03/g, "^C").replace(/\x04/g, "^D").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-      return `Sent ${parsedData.length} bytes to ${args.id}: "${displayPreview}"`;
+      lines.push(`Total: ${sessions.length} session(s)`);
+      lines.push("</pty_list>");
+      return lines.join(`
+`);
     }
   });
 }
@@ -29710,112 +30748,150 @@ function createPtyReadTool(manager) {
     }
   });
 }
-// src/tools/pty/tools/list.ts
-var DESCRIPTION4 = `Lists all PTY sessions (active and exited).
+// src/tools/pty/tools/spawn.ts
+var DESCRIPTION4 = `Spawns a new interactive PTY (pseudo-terminal) session that runs in the background.
 
-Use this tool to:
-- See all running and exited PTY sessions
-- Get session IDs for use with other pty_* tools
-- Check the status and output line count of each session
-- Monitor which processes are still running
+Unlike the built-in bash tool which runs commands synchronously and waits for completion, PTY sessions persist and allow you to:
+- Run long-running processes (dev servers, watch modes, etc.)
+- Send interactive input (including Ctrl+C, arrow keys, etc.)
+- Read output at any time
+- Manage multiple concurrent terminal sessions
 
-Returns for each session:
-- \`id\`: Unique identifier for use with other tools
-- \`title\`: Human-readable name
-- \`command\`: The command that was executed
-- \`status\`: Current status (running, exited, killed)
-- \`exitCode\`: Exit code (if exited/killed)
+Usage:
+- The \`command\` parameter is required (e.g., "npm", "python", "bash")
+- Use \`args\` to pass arguments to the command (e.g., ["run", "dev"])
+- Use \`workdir\` to set the working directory (defaults to project root)
+- Use \`env\` to set additional environment variables
+- Use \`title\` to give the session a human-readable name
+- Use \`description\` for a clear, concise 5-10 word description (optional)
+
+Returns the session info including:
+- \`id\`: Unique identifier (pty_XXXXXXXX) for use with other pty_* tools
 - \`pid\`: Process ID
-- \`lineCount\`: Number of lines in the output buffer
-- \`createdAt\`: When the session was created
+- \`status\`: Current status ("running")
 
-Tips:
-- Use the session ID with pty_read, pty_write, or pty_kill
-- Sessions remain in the list after exit until explicitly cleaned up with pty_kill
-- This allows you to compare output from multiple sessions`;
-function createPtyListTool(manager) {
+After spawning, use:
+- \`pty_write\` to send input to the PTY
+- \`pty_read\` to read output from the PTY
+- \`pty_list\` to see all active PTY sessions
+- \`pty_kill\` to terminate the PTY
+
+Examples:
+- Start a dev server: command="npm", args=["run", "dev"], title="Dev Server"
+- Start a Python REPL: command="python3", title="Python REPL"
+- Run tests in watch mode: command="npm", args=["test", "--", "--watch"]`;
+function createPtySpawnTool(manager) {
   return tool({
     description: DESCRIPTION4,
-    args: {},
-    execute: async () => {
-      const sessions = manager.list();
-      if (sessions.length === 0) {
-        return `<pty_list>
-No active PTY sessions.
-</pty_list>`;
-      }
-      const lines = ["<pty_list>"];
-      for (const session of sessions) {
-        const exitInfo = session.exitCode !== undefined ? ` (exit: ${session.exitCode})` : "";
-        lines.push(`[${session.id}] ${session.title}`);
-        lines.push(`  Command: ${session.command} ${session.args.join(" ")}`);
-        lines.push(`  Status: ${session.status}${exitInfo}`);
-        lines.push(`  PID: ${session.pid} | Lines: ${session.lineCount} | Workdir: ${session.workdir}`);
-        lines.push(`  Created: ${session.createdAt.toISOString()}`);
-        lines.push("");
-      }
-      lines.push(`Total: ${sessions.length} session(s)`);
-      lines.push("</pty_list>");
-      return lines.join(`
+    args: {
+      command: tool.schema.string().describe("The command/executable to run"),
+      args: tool.schema.array(tool.schema.string()).optional().describe("Arguments to pass to the command"),
+      workdir: tool.schema.string().optional().describe("Working directory for the PTY session"),
+      env: tool.schema.record(tool.schema.string(), tool.schema.string()).optional().describe("Additional environment variables"),
+      title: tool.schema.string().optional().describe("Human-readable title for the session"),
+      description: tool.schema.string().optional().describe("Clear, concise description of what this PTY session is for in 5-10 words")
+    },
+    execute: async (args, ctx) => {
+      const info = manager.spawn({
+        command: args.command,
+        args: args.args,
+        workdir: args.workdir,
+        env: args.env,
+        title: args.title,
+        parentSessionId: ctx.sessionID
+      });
+      const output = [
+        `<pty_spawned>`,
+        `ID: ${info.id}`,
+        `Title: ${info.title}`,
+        `Command: ${info.command} ${info.args.join(" ")}`,
+        `Workdir: ${info.workdir}`,
+        `PID: ${info.pid}`,
+        `Status: ${info.status}`,
+        `</pty_spawned>`
+      ].join(`
 `);
+      return output;
     }
   });
 }
-// src/tools/pty/tools/kill.ts
-var DESCRIPTION5 = `Terminates a PTY session and optionally cleans up its buffer.
+// src/tools/pty/tools/write.ts
+var DESCRIPTION5 = `Sends input data to an active PTY session.
 
 Use this tool to:
-- Stop a running process (sends SIGTERM)
-- Clean up an exited session to free memory
-- Remove a session from the list
+- Type commands or text into an interactive terminal
+- Send special key sequences (Ctrl+C, Enter, arrow keys, etc.)
+- Respond to prompts in interactive programs
 
 Usage:
 - \`id\`: The PTY session ID (from pty_spawn or pty_list)
-- \`cleanup\`: If true, removes the session and frees the buffer (default: false)
+- \`data\`: The input to send (text, commands, or escape sequences)
 
-Behavior:
-- If the session is running, it will be killed (status becomes "killed")
-- If cleanup=false (default), the session remains in the list with its output buffer intact
-- If cleanup=true, the session is removed entirely and the buffer is freed
-- Keeping sessions without cleanup allows you to compare logs between runs
+Common escape sequences:
+- Enter/newline: "\\n" or "\\r"
+- Ctrl+C (interrupt): "\\x03"
+- Ctrl+D (EOF): "\\x04"
+- Ctrl+Z (suspend): "\\x1a"
+- Tab: "\\t"
+- Arrow Up: "\\x1b[A"
+- Arrow Down: "\\x1b[B"
+- Arrow Right: "\\x1b[C"
+- Arrow Left: "\\x1b[D"
 
-Tips:
-- Use cleanup=false if you might want to read the output later
-- Use cleanup=true when you're done with the session entirely
-- To send Ctrl+C instead of killing, use pty_write with data="\\x03"
+Returns success or error message.
 
 Examples:
-- Kill but keep logs: cleanup=false (or omit)
-- Kill and remove: cleanup=true`;
-function createPtyKillTool(manager) {
+- Send a command: data="ls -la\\n"
+- Interrupt a process: data="\\x03"
+- Answer a prompt: data="yes\\n"`;
+function parseEscapeSequences(input) {
+  return input.replace(/\\(x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|[nrt0\\])/g, (match, seq) => {
+    if (seq.startsWith("x")) {
+      return String.fromCharCode(parseInt(seq.slice(1), 16));
+    }
+    if (seq.startsWith("u")) {
+      return String.fromCharCode(parseInt(seq.slice(1), 16));
+    }
+    switch (seq) {
+      case "n":
+        return `
+`;
+      case "r":
+        return "\r";
+      case "t":
+        return "\t";
+      case "0":
+        return "\x00";
+      case "\\":
+        return "\\";
+      default:
+        return match;
+    }
+  });
+}
+function createPtyWriteTool(manager) {
   return tool({
     description: DESCRIPTION5,
     args: {
       id: tool.schema.string().describe("The PTY session ID (e.g., pty_a1b2c3d4)"),
-      cleanup: tool.schema.boolean().optional().describe("If true, removes the session and frees the buffer (default: false)")
+      data: tool.schema.string().describe("The input data to send to the PTY")
     },
     execute: async (args) => {
       const session = manager.get(args.id);
       if (!session) {
         throw new Error(`PTY session '${args.id}' not found. Use pty_list to see active sessions.`);
       }
-      const wasRunning = session.status === "running";
-      const cleanup = args.cleanup ?? false;
-      const success2 = manager.kill(args.id, cleanup);
+      if (session.status !== "running") {
+        throw new Error(`Cannot write to PTY '${args.id}' - session status is '${session.status}'.`);
+      }
+      const parsedData = parseEscapeSequences(args.data);
+      const success2 = manager.write(args.id, parsedData);
       if (!success2) {
-        throw new Error(`Failed to kill PTY session '${args.id}'.`);
+        throw new Error(`Failed to write to PTY '${args.id}'.`);
       }
-      const action = wasRunning ? "Killed" : "Cleaned up";
-      const cleanupNote = cleanup ? " (session removed)" : " (session retained for log access)";
-      return [
-        `<pty_killed>`,
-        `${action}: ${args.id}${cleanupNote}`,
-        `Title: ${session.title}`,
-        `Command: ${session.command} ${session.args.join(" ")}`,
-        `Final line count: ${session.lineCount}`,
-        `</pty_killed>`
-      ].join(`
-`);
+      const preview = args.data.length > 50 ? `${args.data.slice(0, 50)}...` : args.data;
+      const displayPreview = preview.replace(/\x03/g, "^C").replace(/\x04/g, "^D").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+      return `Sent ${parsedData.length} bytes to ${args.id}: "${displayPreview}"`;
     }
   });
 }
@@ -30004,6 +31080,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
   const commentCheckerHook = createCommentCheckerHook(ctx);
   const artifactAutoIndexHook = createArtifactAutoIndexHook(ctx);
   const fileOpsTrackerHook = createFileOpsTrackerHook(ctx);
+  const fetchTrackerHook = createFetchTrackerHook(ctx);
   const fragmentInjectorHook = createFragmentInjectorHook(ctx, userConfig);
   if (userConfig?.fragments) {
     const knownAgentNames = new Set(Object.keys(agents));
@@ -30057,7 +31134,11 @@ var OpenCodeConfigPlugin = async (ctx) => {
     }
   });
   const ptyManager = new PTYManager;
-  const ptyTools = createPtyTools(ptyManager);
+  const bunPty = await loadBunPty();
+  if (bunPty) {
+    ptyManager.init(bunPty.spawn);
+  }
+  const ptyTools = ptyManager.available ? createPtyTools(ptyManager) : {};
   const spawn_agent = createSpawnAgentTool(ctx);
   const batch_read = createBatchReadTool(ctx);
   const octtoSessionStore = createSessionStore();
@@ -30098,7 +31179,6 @@ var OpenCodeConfigPlugin = async (ctx) => {
         edit: "allow",
         bash: "allow",
         webfetch: "allow",
-        doom_loop: "allow",
         external_directory: "allow"
       };
       const mergedAgents = mergeAgentConfigs(agents, userConfig);
@@ -30154,7 +31234,7 @@ var OpenCodeConfigPlugin = async (ctx) => {
           ...output.options,
           thinking: {
             type: "enabled",
-            budget_tokens: 32000
+            budgetTokens: 128000
           }
         };
       }
@@ -30215,6 +31295,7 @@ IMPORTANT:
       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);
+      await fetchTrackerHook["tool.execute.after"]({ tool: input.tool, sessionID: input.sessionID, args: input.args }, output);
       await constraintReviewerHook["tool.execute.after"]({ tool: input.tool, sessionID: input.sessionID, args: input.args }, output);
     },
     "experimental.chat.messages.transform": async (input, output) => {
@@ -30248,6 +31329,7 @@ IMPORTANT:
           thinkModeState.delete(sessionId);
           ptyManager.cleanupBySession(sessionId);
           constraintReviewerHook.cleanupSession(sessionId);
+          fetchTrackerHook.cleanupSession(sessionId);
           const octtoSessions = octtoSessionsMap.get(sessionId);
           if (octtoSessions) {
             for (const octtoSessionId of octtoSessions) {
@@ -30262,6 +31344,7 @@ IMPORTANT:
       await tokenAwareTruncationHook.event({ event });
       await contextWindowMonitorHook.event({ event });
       await fileOpsTrackerHook.event({ event });
+      await fetchTrackerHook.event({ event });
     }
   };
 };