@lawaty/lacode 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2250 @@
+// src/lib/pool.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var CLAIM_TTL_MS = 10 * 60 * 1e3;
+var DEAD_FILE_MS = 2 * CLAIM_TTL_MS;
+var ORPHAN_TMP_MS = 60 * 1e3;
+var CATALOG_TTL_MS = 10 * 60 * 1e3;
+var STUCK_MIN_AGE_MS = 5 * 60 * 1e3;
+var STUCK_IDLE_MS = 3 * 60 * 1e3;
+var HANG_COOLDOWN_MS = 10 * 60 * 1e3;
+var MAX_WEIGHT = 100;
+var MAX_SLOTS = 4;
+var COOLDOWN_BASE_MS = 60 * 1e3;
+var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
+var STRIKE_DECAY_MS = 30 * 60 * 1e3;
+var BASES = ["explore-fast", "implement-fast", "context-manager"];
+var findPackageRoot = (start) => {
+  let dir = start;
+  for (let up = 0; up < 6; up++) {
+    try {
+      if (JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === "@lawaty/lacode") return dir;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(start, "..", "..");
+};
+var PACKAGE_ROOT = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+var PRESETS_DIR = join(PACKAGE_ROOT, "presets");
+var DEFAULT_PRESET = join(PRESETS_DIR, "free-tier.json");
+var USER_CONFIG_DIR = join(homedir(), ".config", "lacode");
+var USER_MODELS_PATH = join(USER_CONFIG_DIR, "pool.json");
+var FALLBACK_SLOTS = [
+  { index: 1, model: "opencode/space-bunny-free", weight: 3 },
+  { index: 2, model: "openrouter/nvidia/nemotron-3-ultra-550b-a55b:free", weight: 2 },
+  { index: 3, model: "opencode/big-pickle", weight: 1 },
+  { index: 4, model: "openrouter/thinkingmachines/inkling:free", weight: 1 }
+];
+function parseSlots(parsed, origin) {
+  const problems = [];
+  const entries = parsed?.slots;
+  if (!Array.isArray(entries) || entries.length === 0) {
+    return { slots: FALLBACK_SLOTS, problems: [`${origin} has no non-empty "slots" array; using built-in defaults`] };
+  }
+  const slots = [];
+  entries.forEach((entry, i) => {
+    const model = typeof entry?.model === "string" ? entry.model.trim() : "";
+    const at = `slot ${i + 1}`;
+    if (slots.length >= MAX_SLOTS) {
+      problems.push(`${at} (${model || "?"}): the pool is capped at ${MAX_SLOTS} slots (one variant agent per base per slot is declared); entry ignored`);
+      return;
+    }
+    if (!model.includes("/")) return problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
+    const weight = readWeight(entry, at, model, problems);
+    if (slots.some((s) => s.model === model)) return problems.push(`${at}: ${model} is already used by another slot; slots must be distinct models`);
+    slots.push({ index: slots.length + 1, model, weight });
+  });
+  if (slots.length === 0) {
+    problems.push(`${origin} yielded no usable slot; using built-in defaults`);
+    return { slots: FALLBACK_SLOTS, problems };
+  }
+  return { slots, problems };
+}
+var readJSON = (path4) => {
+  try {
+    return { ok: true, value: JSON.parse(readFileSync(path4, "utf8")) };
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+};
+function readOptional(path4, origin, problems) {
+  const result = readJSON(path4);
+  if (!result.ok) {
+    if (existsSync(path4)) problems.push(`${origin} unreadable (${result.error}); trying the next source`);
+    return void 0;
+  }
+  return result.value;
+}
+function resolveModels(input = {}) {
+  const problems = [];
+  if (input.models !== void 0) {
+    const origin = "plugin options";
+    if (typeof input.models !== "object" || input.models === null || Array.isArray(input.models)) {
+      return { slots: FALLBACK_SLOTS, problems: [`${origin}: "models" must be an object like {"slots":[...]}`], origin };
+    }
+    const parsed = parseSlots(input.models, origin);
+    return { slots: parsed.slots, problems: [...problems, ...parsed.problems], origin };
+  }
+  if (input.modelsFile) {
+    const result = readJSON(input.modelsFile);
+    if (!result.ok) return { slots: FALLBACK_SLOTS, problems: [`${input.modelsFile} unreadable (${result.error}); using built-in defaults`], origin: input.modelsFile };
+    const parsed = parseSlots(result.value, input.modelsFile);
+    return { slots: parsed.slots, problems: parsed.problems, origin: input.modelsFile };
+  }
+  const user = readOptional(USER_MODELS_PATH, USER_MODELS_PATH, problems);
+  if (user !== void 0) {
+    const parsed = parseSlots(user, USER_MODELS_PATH);
+    if (parsed.slots !== FALLBACK_SLOTS) return { slots: parsed.slots, problems, origin: USER_MODELS_PATH };
+    problems.push(...parsed.problems);
+  }
+  const preset = readOptional(DEFAULT_PRESET, DEFAULT_PRESET, problems);
+  if (preset !== void 0) {
+    const parsed = parseSlots(preset, "presets/free-tier.json");
+    return { slots: parsed.slots, problems: [...problems, ...parsed.problems], origin: "presets/free-tier.json" };
+  }
+  return { slots: FALLBACK_SLOTS, problems: [...problems, `no pool source found (${USER_MODELS_PATH}, ${DEFAULT_PRESET}); using built-in defaults`], origin: "built-in defaults" };
+}
+function ensureUserConfigDir() {
+  try {
+    mkdirSync(USER_CONFIG_DIR, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readWeight(entry, at, model, problems) {
+  const raw = entry?.weight;
+  if (raw === void 0) {
+    const legacy = entry?.tier;
+    if (legacy !== void 0) {
+      problems.push(
+        `weight: "tier" is deprecated; write "weight" instead (primary is weight 2, overflow is weight 1), got ${JSON.stringify(legacy)}`
+      );
+      if (legacy === "primary" || legacy === "overflow") return legacy === "primary" ? 2 : 1;
+    }
+    return 1;
+  }
+  const weight = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(weight) || weight <= 0 || weight > MAX_WEIGHT) {
+    problems.push(`${at} (${model}): weight must be a number in (0, ${MAX_WEIGHT}], got ${JSON.stringify(raw)}; using weight 1`);
+    return 1;
+  }
+  return weight;
+}
+var LIMIT_PATTERNS = [
+  /rate[\s_-]?limit/i,
+  /usage limit/i,
+  /too many requests/i,
+  /\b429\b/,
+  /quota/i,
+  /freelimiterror/i,
+  /overloaded/i
+];
+var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text));
+var statedCooldown = (text) => {
+  const hm = /resets?\s+in\s+(\d+)\s*(?:h|hr|hour)s?\s*(\d+)?\s*(?:m|min|minute)?s?/i.exec(text);
+  if (hm) return (Number(hm[1]) * 60 + (hm[2] ? Number(hm[2]) : 0)) * 60 * 1e3;
+  const m = /resets?\s+in\s+(\d+)\s*(?:m|min|minute)s?/i.exec(text);
+  if (m) return Number(m[1]) * 60 * 1e3;
+  const s = /retry[\s-]?in\s+(\d+)\s*(?:s|sec|second)s?/i.exec(text);
+  if (s) return Number(s[1]) * 1e3;
+  return void 0;
+};
+var retryAfterMs = (headers) => {
+  if (!headers) return void 0;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== "retry-after") continue;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds > 0) return Math.min(seconds * 1e3, COOLDOWN_MAX_MS);
+    const when = Date.parse(value);
+    if (Number.isFinite(when)) return Math.min(Math.max(when - Date.now(), 1e3), COOLDOWN_MAX_MS);
+  }
+  return void 0;
+};
+function state(opts = {}) {
+  const id = opts.id ?? String(process.pid);
+  const dir = opts.dir ?? join(homedir(), ".local", "share", "opencode", "agent-pool");
+  const modelsFile = opts.modelsFile;
+  const models = opts.models;
+  const key = /* @__PURE__ */ Symbol.for(`agent-pool:state:${id}:${dir}:${modelsFile ?? ""}:${models === void 0 ? "" : "inline"}`);
+  const g = globalThis;
+  if (!g[key]) {
+    g[key] = {
+      own: /* @__PURE__ */ new Map(),
+      models: /* @__PURE__ */ new Map(),
+      known: /* @__PURE__ */ new Set(),
+      warned: /* @__PURE__ */ new Set(),
+      initialized: false,
+      dirReady: false,
+      catalog: /* @__PURE__ */ new Map(),
+      catalogAt: 0,
+      cooling: /* @__PURE__ */ new Map(),
+      activity: /* @__PURE__ */ new Map(),
+      reaped: 0,
+      reaping: false,
+      lastSweep: 0,
+      id,
+      dir,
+      modelsFile,
+      inlineModels: models,
+      origin: "unresolved",
+      slots: []
+    };
+  }
+  return g[key];
+}
+function ensureSlots(s, onWarn) {
+  if (s.slots.length > 0) return s.slots;
+  const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
+  s.slots = slots;
+  s.origin = origin;
+  for (const problem of problems) onWarn(problem);
+  return slots;
+}
+var claimKey = (sessionID, callID) => `${sessionID}:${callID}`;
+var selfFile = (id) => `claims.${id}.json`;
+var limitFile = (model) => `limit.${model.replace(/[^a-zA-Z0-9._-]/g, "__")}.json`;
+function init(s, onWarn) {
+  ensureSlots(s, onWarn);
+  if (s.initialized) return;
+  s.initialized = true;
+  try {
+    mkdirSync(s.dir, { recursive: true });
+    s.dirReady = true;
+    try {
+      unlinkSync(join(s.dir, selfFile(s.id)));
+    } catch {
+    }
+  } catch {
+    onWarn(`claim dir ${s.dir} unusable; pool load tracked in memory only`);
+  }
+}
+function pruneOwn(s) {
+  const now = Date.now();
+  for (const [key, claim] of s.own) if (now - claim.t > CLAIM_TTL_MS) s.own.delete(key);
+}
+function publish(s) {
+  if (!s.dirReady) return;
+  const now = Date.now();
+  const payload = {};
+  for (const [key, claim] of s.own) if (now - claim.t <= CLAIM_TTL_MS) payload[key] = claim;
+  try {
+    writeFileSync(join(s.dir, `${selfFile(s.id)}.tmp`), JSON.stringify(payload));
+    renameSync(join(s.dir, `${selfFile(s.id)}.tmp`), join(s.dir, selfFile(s.id)));
+  } catch {
+    s.dirReady = false;
+  }
+}
+function readSiblings(s) {
+  const siblings = [];
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return siblings;
+  }
+  const now = Date.now();
+  for (const entry of entries) {
+    const path4 = join(s.dir, entry);
+    let age;
+    try {
+      age = now - statSync(path4).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (entry.endsWith(".tmp")) {
+      if (age > ORPHAN_TMP_MS) try {
+        unlinkSync(path4);
+      } catch {
+      }
+      continue;
+    }
+    const match = /^claims\.(.+)\.json$/.exec(entry);
+    if (!match || match[1] === s.id) continue;
+    if (age > DEAD_FILE_MS) {
+      try {
+        unlinkSync(path4);
+      } catch {
+      }
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(readFileSync(path4, "utf8"));
+      const claims = Object.values(parsed).filter(
+        (c) => c && typeof c.v === "string" && typeof c.m === "string" && now - c.t <= CLAIM_TTL_MS
+      );
+      siblings.push({ id: match[1], claims });
+    } catch {
+    }
+  }
+  return siblings;
+}
+function readLimits(s) {
+  const cooling = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = readdirSync(s.dir);
+  } catch {
+    return cooling;
+  }
+  const now = Date.now();
+  for (const entry of entries) {
+    if (!entry.startsWith("limit.") || !entry.endsWith(".json")) continue;
+    const path4 = join(s.dir, entry);
+    try {
+      const strike = JSON.parse(readFileSync(path4, "utf8"));
+      if (typeof strike.until !== "number" || typeof strike.model !== "string") continue;
+      if (strike.until > now) cooling.set(strike.model, strike);
+      else unlinkSync(path4);
+    } catch {
+      try {
+        unlinkSync(path4);
+      } catch {
+      }
+    }
+  }
+  s.cooling = cooling;
+  return cooling;
+}
+function recordStrike(s, model, reason, stated) {
+  if (!s.dirReady) return;
+  const now = Date.now();
+  const prior = s.cooling.get(model);
+  const strikes = prior && now - prior.last < STRIKE_DECAY_MS ? prior.strikes + 1 : 1;
+  const backoff = Math.min(COOLDOWN_MAX_MS, COOLDOWN_BASE_MS * 2 ** (strikes - 1));
+  const strike = { model, until: now + (stated ?? backoff), strikes, reason, last: now };
+  s.cooling.set(model, strike);
+  const path4 = join(s.dir, limitFile(model));
+  try {
+    writeFileSync(`${path4}.tmp`, JSON.stringify(strike));
+    renameSync(`${path4}.tmp`, path4);
+  } catch {
+  }
+  return strike;
+}
+function refreshCatalog(s, serverUrl) {
+  if (!serverUrl || Date.now() - s.catalogAt < CATALOG_TTL_MS) return;
+  s.catalogAt = Date.now();
+  void (async () => {
+    try {
+      const response = await fetch(new URL("/api/model", serverUrl).toString());
+      if (!response.ok) return;
+      const payload = await response.json();
+      const catalog = /* @__PURE__ */ new Map();
+      for (const m of payload.data ?? []) catalog.set(`${m.providerID}/${m.id}`, m.status ?? "unknown");
+      if (catalog.size > 0) s.catalog = catalog;
+    } catch {
+    }
+  })();
+}
+function isAvailable(s, model, cooling) {
+  if (cooling.has(model)) return false;
+  const status = s.catalog.get(model);
+  return status === void 0 || status === "active" || status === "unknown";
+}
+function snapshot(s) {
+  pruneOwn(s);
+  const siblings = readSiblings(s);
+  const cooling = readLimits(s);
+  const counts = /* @__PURE__ */ new Map();
+  const bump = (m) => counts.set(m, (counts.get(m) ?? 0) + 1);
+  for (const claim of s.own.values()) bump(claim.m);
+  for (const sibling of siblings) for (const claim of sibling.claims) bump(claim.m);
+  return { counts, cooling, siblings, own: s.own, dirReady: s.dirReady };
+}
+var loadOf = (counts, model) => counts.get(model) ?? 0;
+var underCeiling = (slot, counts) => loadOf(counts, slot.model) < slot.weight;
+function pickSlot(s, snap) {
+  const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
+  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const pool = usable.length > 0 ? usable : slots;
+  const open = pool.filter((slot) => underCeiling(slot, snap.counts));
+  if (open.length > 0) return open.reduce((best, slot) => slot.weight > best.weight ? slot : best, open[0]);
+  return pool.reduce((best, slot) => loadOf(snap.counts, slot.model) < loadOf(snap.counts, best.model) ? slot : best, pool[0]);
+}
+function agentFor(base, slot) {
+  return `${base}-${slot}`;
+}
+function acquire(s, base, slot, ownerSession, key, target) {
+  s.own.set(key, { v: base, k: slot.index, m: slot.model, t: Date.now(), s: ownerSession, g: target });
+  if (target) s.activity.set(target, Date.now());
+  publish(s);
+}
+function release(s, key) {
+  if (s.own.delete(key)) publish(s);
+}
+function bindChild(s, parentID, childID) {
+  const candidates = [...s.own.entries()].filter(([, c]) => c.s === parentID && !c.g).sort((a, b) => a[1].t - b[1].t);
+  if (candidates.length === 0) return false;
+  candidates[0][1].g = childID;
+  s.activity.set(childID, Date.now());
+  publish(s);
+  return true;
+}
+function noteActivity(s, sessionID) {
+  s.activity.set(sessionID, Date.now());
+}
+function idleFor(s, claim, now) {
+  const target = claim.g;
+  if (!target) return Infinity;
+  const seen = s.activity.get(target);
+  return seen ? now - seen : Infinity;
+}
+function findStuck(s, now = Date.now()) {
+  const stuck = [];
+  for (const [key, claim] of s.own) {
+    if (now - claim.t <= STUCK_MIN_AGE_MS) continue;
+    if (idleFor(s, claim, now) < STUCK_IDLE_MS) continue;
+    stuck.push({ key, claim });
+  }
+  return stuck;
+}
+function releaseStuck(s, keys) {
+  for (const key of keys) s.own.delete(key);
+  if (keys.length > 0) publish(s);
+}
+function splitModel(model) {
+  const slash = model.indexOf("/");
+  if (slash < 0) return { provider: model, id: "" };
+  return { provider: model.slice(0, slash), id: model.slice(slash + 1) };
+}
+var providerOf = (model) => splitModel(model).provider;
+function coolProvider(s, provider, until, reason) {
+  const affected = [];
+  for (const slot of s.slots.length > 0 ? s.slots : FALLBACK_SLOTS) {
+    if (providerOf(slot.model) !== provider) continue;
+    const existing = s.cooling.get(slot.model);
+    const untilMs = Math.max(until, existing?.until ?? 0);
+    const strike = recordStrike(s, slot.model, reason, untilMs - Date.now());
+    if (strike) affected.push(strike);
+  }
+  return affected;
+}
+
+// src/agents.ts
+var DEEP_TIERS = ["explore-deep", "implement-deep"];
+var POOLED_BASES = ["explore-fast", "implement-fast", "context-manager"];
+var AGENTS = {
+  "build": {
+    "description": "Default root agent. Orchestrates rather than investigates: read/glob/grep/list/webfetch/websearch are denied by permission, so every question goes to @explore-fast and every code change to @implement-fast. Keeps edit/write/bash for applying and verifying what comes back.",
+    "mode": "primary",
+    "temperature": 0.1,
+    prompt: `# Role
+
+You are the default root agent. You orchestrate work \u2014 you do not perform
+investigation or implementation yourself.
+
+You CANNOT read files, grep, glob, or list directories, and you cannot fetch
+or search the web. Those tools are denied by configuration, not by convention.
+Every question of the form "what does this file do", "where is X handled", or
+"what does this error come from" belongs to an explorer, not to you.
+
+# Delegation
+
+- **Investigation \u2192 @explore-fast.** Give it specific, focused instructions
+  ("read src/auth.ts", "grep for 'migration' in *.py", "list the src/
+  directory"), one batch per question. Ask for the exact lines or
+  file:line references you need, not a survey.
+- **Implementation \u2192 @implement-fast**, with a finalized plan: the exact
+  steps, the files to touch, and the constraints you already learned from the
+  explorers. It edits, writes, and runs tests.
+- Never call @explore-deep or @implement-deep yourself. Each tier escalates on
+  its own when it is stuck; that ladder belongs to the subagents, not to you.
+
+The agents you spawn are the pooled \`explore-fast\` / \`implement-fast\` bases \u2014
+spawn the bare name and let the pool route, never a \`-1\`/\`-2\` slot variant.
+
+# What stays yours
+
+\`edit\`, \`write\`, and \`bash\` are available to you. Use them to apply what a
+subagent reported back, and to verify the result: run tests, typecheck, lint,
+build, and git.
+
+Do NOT use bash to inspect the codebase. \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`,
+\`grep\`, \`find\`, \`ls\`, \`tree\` and friends are exploration, and exploration goes
+to @explore-fast. Bash is for executing and verifying, not for looking.
+
+# Repository context
+
+Before delegating a non-trivial task, tell @explore-fast to check
+\`.opencode/context/\` first (\`ls .opencode/context\`, never the \`glob\` tool \u2014 it
+skips hidden directories) and to read only the file relevant to the task:
+architecture.md for architectural questions, contexts.md for subsystem
+questions, conventions.md before proposing code changes, workflows.md when
+tracing runtime behavior, decisions.md for architectural constraints. Ask it to
+start from the canonical entry points the map lists rather than exploring
+broadly.
+
+Files the user explicitly named always take priority over the context map.
+
+Never edit \`.opencode/context/\` \u2014 context maintenance belongs to the
+context-manager agent (\`/context-update\` or its automatic post-work runs). If
+your work reveals something that belongs in the map, say so in your final
+report instead of editing it yourself.
+
+# Reporting
+
+When you report back, say which explorer answered which question and name the
+context file(s) that actually shaped the work (or state plainly that the map was
+missing). Never paste context file contents into the report.`,
+    permission: {
+      "read": "deny",
+      "glob": "deny",
+      "grep": "deny",
+      "list": "deny",
+      // No "write" key appears in any permission block below: opencode folds the
+      // write and apply_patch tools onto "edit", so a "write" rule is never read.
+      "edit": {
+        "*": "allow",
+        "*/.opencode/context/**": "deny",
+        ".opencode/context/**": "deny"
+      },
+      "bash": "allow",
+      "webfetch": "deny",
+      "websearch": "deny",
+      "question": "allow",
+      "task": {
+        "*": "deny",
+        "explore-fast*": "allow",
+        "implement-fast*": "allow"
+      }
+    }
+  },
+  "plan": {
+    "description": "Read-only planner. Identical to @basic: it cannot read, grep, glob, list or run commands, so all investigation is delegated to @explore-fast. Produce a plan; do not edit.",
+    "mode": "primary",
+    "temperature": 0.1,
+    prompt: `You are a senior software architect. Your ONLY job is analysis and planning.
+
+You CANNOT read files, grep, glob, list directories, or run commands directly. All codebase investigation must be delegated.
+
+When you need to understand the codebase:
+1. Determine exactly what files or patterns need investigating
+2. Invoke @explore-fast with specific, focused instructions (e.g. "read src/auth.ts", "grep for 'migration' in *.py files", "list the src/ directory")
+3. @explore-fast will return its findings \u2014 you process them and plan accordingly
+
+Repository context: before delegating investigation for a non-trivial task,
+tell the exploration agent to first check \`.opencode/context/\` in this project
+(using \`ls\`, never \`glob\` \u2014 it skips hidden directories)
+and to read only the file relevant to the task \u2014 architecture.md for
+architectural questions, contexts.md for subsystem questions, conventions.md
+before proposing code changes, workflows.md when tracing behavior,
+decisions.md for architectural constraints. Ask it to start from the canonical
+entry points the map lists rather than exploring broadly.
+
+Files the user explicitly mentioned always take priority over the context map.
+
+Never edit \`.opencode/context/\` \u2014 context maintenance belongs to the
+context-manager agent (\`/context-update\` or its automatic post-work runs). If
+your plan implies the map needs a change, say so in the plan instead.
+
+When given a task:
+1. Think through what codebase context you need
+2. Delegate investigation to @explore-fast in focused batches
+3. Analyze findings for dependencies, edge cases, and architecture impact
+4. Produce a structured output:
+   - Summary of the change
+   - [ ] Checklist of concrete implementation steps
+   - Files to create or modify
+   - Risks or gotchas
+
+Cite the relevant context file(s) and canonical entry points in the plan when
+they actually shaped it (e.g. "Repository context indicates order mutations
+belong in Shop/Application, not the Bot layer"). Do not paste the context files
+into the plan. If the work would introduce information worth remembering for
+future agents \u2014 a new boundary, canonical entry point, workflow, convention, or
+architectural decision \u2014 note it at the end of the plan so /context-update can
+capture it.
+
+Do NOT edit files. Do NOT run commands. Do NOT use Read, Grep, Glob, or List tools directly.
+Once the plan is complete, present it clearly so the caller can implement it step by step.`,
+    permission: {
+      "read": "deny",
+      "glob": "deny",
+      "grep": "deny",
+      "list": "deny",
+      "edit": {
+        "*": "deny",
+        ".opencode/plans/*.md": "allow",
+        "*/.opencode/plans/*.md": "allow",
+        "../../.local/share/opencode/plans/*.md": "allow"
+      },
+      "bash": "deny",
+      "webfetch": "deny",
+      "websearch": "deny",
+      "question": "allow",
+      "task": {
+        "*": "deny",
+        "explore-fast*": "allow",
+        "implement-fast*": "allow"
+      }
+    }
+  },
+  "explore-fast": {
+    "description": "Default read-only codebase exploration. Free via Zen. Escalates to @explore-deep when stuck or looping.",
+    "mode": "subagent",
+    "temperature": 0.2,
+    prompt: `# Role
+
+You are the default codebase exploration agent. You are read-only: you locate,
+read, and summarize code, configuration, and documentation to answer questions
+or gather context for a plan. You never edit or write files.
+
+Be thorough but efficient. Prefer targeted grep/glob searches over reading
+whole directories. When you report findings, cite exact file paths and line
+ranges so the caller can verify or act on them directly.
+
+# Repository context map
+
+Before broad exploration, check whether \`.opencode/context/\` exists in this
+project (\`ls .opencode/context\` \u2014 never the \`glob\` tool, which skips hidden
+directories). If it exists, read only the file relevant to the question \u2014
+architecture.md (architectural questions), contexts.md (subsystem questions),
+conventions.md (repository conventions), workflows.md (tracing behavior),
+decisions.md (architectural constraints) \u2014 then start from the canonical entry
+points it lists. Explore beyond them only when the question requires it.
+
+Use the map to narrow exploration, not to expand it. Follow dependencies only
+when necessary to answer the question. Do not inspect unrelated modules merely
+to gain a complete understanding of the repository \u2014 minimum sufficient
+exploration, not zero exploration.
+
+If the user named specific files or paths, those take priority: use the map to
+understand them and find the surrounding code, never as a reason to skip them.
+
+If the map conflicts with the source, trust the source, say so in your report,
+and never repeat the stale claim. Never edit \`.opencode/context/\` files \u2014 the
+context-manager agent owns those (\`/context-update\` or its automatic post-work
+runs). Report what should be updated there instead.
+
+<!-- MERGE POINT: paste any project-specific exploration conventions from
+     your current plan.txt / explore instructions here (e.g. which
+     directories to ignore, naming conventions, where docs live). -->
+
+# Escalation
+
+If you hit any of the following, STOP and delegate to @explore-deep via the
+task tool instead of continuing to search:
+
+- You've made more than ~8 tool calls (read/glob/grep/bash) without
+  converging on an answer
+- The same search strategy (same query pattern, same directory) has failed
+  twice in a row
+- The code you need to understand involves genuinely complex logic you're
+  not confident you're reading correctly (e.g. dense concurrency, generated
+  code, deep inheritance/dependency chains, obscure build tooling)
+- You cannot locate a symbol, config value, or file the task clearly
+  requires, after searching from at least two different angles (e.g. by
+  name and by usage)
+
+Do not escalate on the first dead end \u2014 try at least one alternative search
+strategy yourself first (different keywords, different tool, broader or
+narrower scope).
+
+When escalating, pass full context to @explore-deep:
+- The exact question you were asked to answer
+- Every search strategy you already tried and what each one returned
+- Your best current hypothesis, even if unconfirmed
+
+Never guess or fabricate a file path, line number, or code behavior to avoid
+escalating. A wrong answer is worse than an escalation.
+
+# No further escalation beyond deep
+
+You may only escalate to @explore-deep. Do not attempt to call @implement-fast,
+@implement-deep, or any other agent \u2014 exploration agents only explore.`,
+    permission: {
+      "read": "allow",
+      "glob": "allow",
+      "grep": "allow",
+      "list": "allow",
+      "edit": "deny",
+      "bash": "allow",
+      "webfetch": "allow",
+      "websearch": "allow",
+      "question": "allow",
+      "task": {
+        "*": "deny",
+        "explore-deep": "allow"
+      }
+    }
+  },
+  "explore-deep": {
+    "description": "Last-resort read-only exploration for genuinely hard problems @explore-fast fails on. Most expensive explore tier \u2014 use deliberately.",
+    "mode": "subagent",
+    "temperature": 0.2,
+    prompt: `# Role
+
+You are the last-resort codebase exploration agent, called only when
+@explore-fast could not resolve a question. You are read-only: you locate,
+read, and summarize code, configuration, and documentation. You never edit or
+write files.
+
+You will typically receive context from @explore-fast including what was
+already tried and what failed \u2014 read it carefully before starting. Do not
+repeat a search strategy that's already been reported as unproductive; start
+from a genuinely different angle (e.g. searching by behavior/output instead of
+by name, checking git history or tests for hints, reading adjacent modules for
+context).
+
+# Repository context map
+
+You will usually receive findings that already include what
+\`.opencode/context/\` said about the area. Treat that as a starting point, not
+as a finished answer: the code is authoritative, and the map may be stale or
+incomplete.
+
+If you do need to consult the map, list it with \`ls .opencode/context\` \u2014 never
+the \`glob\` tool, which skips hidden directories \u2014 then read only the file
+relevant to the question \u2014 architecture.md, contexts.md, conventions.md,
+workflows.md, decisions.md \u2014 and start from its canonical entry points. Explore
+beyond them only when the question genuinely requires it. Do not re-walk the
+repository to build a complete picture, and do not repeat searches already
+reported as unproductive. Never edit \`.opencode/context/\` files \u2014 the
+context-manager agent owns those (\`/context-update\` or its automatic post-work
+runs). Report what should be updated there instead.
+
+<!-- MERGE POINT: paste any project-specific exploration conventions from
+     your current plan.txt / explore instructions here. -->
+
+# No further escalation
+
+You are the last resort \u2014 there is no one above you to hand this off to. If,
+after genuinely exhausting reasonable approaches, you still cannot answer the
+question:
+
+- STOP. Do not keep looping or guessing.
+- Report back clearly and specifically: what was asked, what you tried
+  (including what @explore-fast already tried, if provided), and exactly what
+  information is missing or ambiguous.
+- If relevant, state what additional access, file, or human input would
+  resolve it (e.g. "this appears to be defined in a private package not in
+  this repo").
+
+Never fabricate a file path, line number, or code behavior to produce an
+answer. An honest "I couldn't find this, here's why" is the correct output
+when that's the truth.
+
+You may only explore. Do not attempt to call @implement-fast, @implement-deep,
+or any other agent.`,
+    permission: {
+      "read": "allow",
+      "glob": "allow",
+      "grep": "allow",
+      "list": "allow",
+      "edit": "deny",
+      "bash": "allow",
+      "webfetch": "allow",
+      "websearch": "allow",
+      "question": "allow",
+      "task": {
+        "*": "deny"
+      }
+    }
+  },
+  "implement-fast": {
+    "description": "Default agent that executes a finalized plan. Escalates to @implement-deep when stuck or looping.",
+    "mode": "subagent",
+    "temperature": 0.2,
+    prompt: `# Role
+
+You are the default agent for executing a finalized plan. You read, edit,
+write, and run code/bash to make the plan's changes real. Work from the plan
+as given \u2014 if it's ambiguous or you believe it's wrong, say so explicitly
+rather than silently improvising a different approach.
+
+Make changes incrementally where possible, and verify your own work (run
+tests/build/lint if available) before considering a step done.
+
+# Repository context
+
+If \`.opencode/context/\` exists (\`ls .opencode/context\` \u2014 never the \`glob\`
+tool, which skips hidden directories), use it as a navigation aid:
+conventions.md
+before writing or modifying code, architecture.md and contexts.md for layer
+and boundary decisions, workflows.md when the change touches a flow,
+decisions.md for architectural constraints that must be respected. Read only
+the relevant file, and start from the canonical entry points it lists. Files
+named by the user or the plan always take priority over the map, and the map
+never justifies skipping work the plan asked for.
+
+Do NOT edit \`.opencode/context/\` \u2014 context maintenance is a separate
+responsibility handled by the context-manager agent (\`/context-update\` or its
+automatic post-work runs). If your work reveals something that belongs in the
+map (a new boundary, entry point, workflow, convention, or decision), say so in
+your final report instead of editing it yourself.
+
+<!-- MERGE POINT: paste your current implement.txt content here \u2014 task
+     execution conventions, commit/testing requirements, code style rules,
+     etc. This section should carry over everything from the original
+     shared implement.txt that both tiers need. -->
+
+# Escalation
+
+If you hit any of the following, STOP and delegate to @implement-deep via
+the task tool instead of continuing to retry:
+
+- The same error or test failure recurs after 2 different attempted fixes
+- You've made more than ~8 tool calls without a concrete, verifiable step of
+  progress (a passing test, a file that now does what it's supposed to, etc.)
+- The task requires reasoning you're not confident in \u2014 complex concurrency,
+  subtle type/generic errors, ambiguous or conflicting requirements in the
+  plan, or a fix that would require touching many unrelated files
+- You find yourself about to revert and redo the same change a third time
+
+Do not escalate at the first error \u2014 try at least one different approach
+yourself first (different fix, different file, re-reading the relevant code).
+
+When escalating, pass full context to @implement-deep:
+- The exact plan step / task you were given
+- Every approach you already tried and why each one failed (errors,
+  diffs, test output)
+- The current state of the code (what's already changed vs. untouched)
+
+Do not silently abandon a broken change and start over without escalating \u2014
+leaving inconsistent partial edits behind is worse than asking for help.
+
+# No further escalation beyond deep
+
+You may only escalate to @implement-deep. Do not attempt to call
+@explore-fast, @explore-deep, or any other agent for implementation help \u2014
+if you need investigation rather than execution, note that explicitly when
+you escalate so @implement-deep can decide whether to explore first.`,
+    permission: {
+      "read": "allow",
+      "glob": "allow",
+      "grep": "allow",
+      "list": "allow",
+      "edit": {
+        "*": "allow",
+        "*/.opencode/context/**": "deny",
+        ".opencode/context/**": "deny"
+      },
+      "bash": "allow",
+      "webfetch": "allow",
+      "websearch": "allow",
+      "question": "allow",
+      "task": {
+        "*": "deny",
+        "implement-deep": "allow"
+      }
+    }
+  },
+  "implement-deep": {
+    "description": "Last-resort executor for genuinely hard problems @implement-fast fails on. Most expensive implement tier \u2014 use deliberately.",
+    "mode": "subagent",
+    "temperature": 0.2,
+    prompt: `# Role
+
+You are the last-resort agent for executing a finalized plan, called only
+when @implement-fast could not complete a step. You read, edit, write, and
+run code/bash to make the plan's changes real.
+
+You will typically receive context from @implement-fast including what was
+already tried, what failed, and the current state of the code \u2014 read it
+carefully before touching anything. Don't repeat an approach already reported
+as failed. Before making further changes, confirm you understand the current
+state of the code (it may be a partial, broken edit left by @implement-fast)
+rather than assuming it matches the original plan.
+
+# Repository context
+
+If \`.opencode/context/\` exists (\`ls .opencode/context\` \u2014 never the \`glob\`
+tool, which skips hidden directories), use it as a navigation aid:
+conventions.md
+before writing or modifying code, architecture.md and contexts.md for layer
+and boundary decisions, workflows.md when the change touches a flow,
+decisions.md for architectural constraints that must be respected. Read only
+the relevant file. Files named by @implement-fast, the user, or the plan
+always take priority, and the map never justifies skipping a step.
+
+Do NOT edit \`.opencode/context/\` \u2014 that belongs to the context-manager agent
+(\`/context-update\` or its automatic post-work runs). If your work reveals
+something that belongs in the map, say so in your report instead.
+
+<!-- MERGE POINT: paste your current implement.txt content here \u2014 the same
+     execution conventions used by implement-fast should apply here too. -->
+
+# No further escalation
+
+You are the last resort \u2014 there is no one above you to hand this off to. If,
+after genuinely exhausting reasonable approaches, you still cannot complete
+the step:
+
+- STOP. Do not keep looping, guessing, or making speculative changes.
+- Leave the code in the most coherent state you can (prefer reverting a
+  broken partial change over leaving it half-done, unless partial progress is
+  clearly salvageable and you say so).
+- Report back clearly and specifically: the exact error or blocker, what was
+  already tried (including @implement-fast's attempts, if provided), and what
+  you believe is needed to unblock it (missing information, a plan
+  revision, human judgment call, etc.).
+
+Never mark a step as done if it isn't, and never fabricate a passing
+test/build result. An honest "this is blocked, here's why" is the correct
+output when that's the truth.
+
+You may only implement. Do not attempt to call @explore-fast, @explore-deep,
+or any other agent \u2014 if the blocker is a missing understanding of the
+codebase rather than an execution problem, report that explicitly instead of
+trying to explore yourself.`,
+    permission: {
+      "read": "allow",
+      "glob": "allow",
+      "grep": "allow",
+      "list": "allow",
+      "edit": {
+        "*": "allow",
+        "*/.opencode/context/**": "deny",
+        ".opencode/context/**": "deny"
+      },
+      "bash": "allow",
+      "webfetch": "allow",
+      "websearch": "allow",
+      "question": "allow",
+      "task": {
+        "*": "deny"
+      }
+    }
+  },
+  "context-manager": {
+    "description": "Repository cartographer and memory maintainer. Bootstraps and incrementally maintains .opencode/context/ (architecture, contexts, conventions, workflows, decisions) as a small navigation map for future agents. Runs automatically after sessions that changed files; can also be invoked with /context-init, /context-update, /context-review. Never use it for general coding tasks.",
+    "mode": "subagent",
+    "temperature": 0.1,
+    prompt: `# Role
+
+You are the repository cartographer and memory maintainer. You are not a coding
+agent. You maintain exactly one thing: the repository context map in
+\`.opencode/context/\`.
+
+The context map is a lightweight navigation index that future agents read
+before exploring. It exists to answer "what should I look at first?" \u2014 never
+"tell me everything about the repository". Source code is authoritative; the
+map is a derived index of it.
+
+# Owned files
+
+You own exactly these five files and nothing else:
+
+- \`.opencode/context/architecture.md\` \u2014 high-level architecture, major layers,
+  boundaries, important entry points, dependency rules. Target 50\u2013150 lines.
+- \`.opencode/context/contexts.md\` \u2014 the major subsystems/modules. For each:
+  purpose, canonical start-here files, boundaries, dependencies, and what must
+  not be changed while working there. Target 50\u2013200 lines.
+- \`.opencode/context/conventions.md\` \u2014 repository-specific conventions:
+  naming, patterns, error handling, testing, persistence, framework rules.
+  Target 30\u2013150 lines.
+- \`.opencode/context/workflows.md\` \u2014 the few runtime flows worth tracing.
+  Target 30\u2013150 lines.
+- \`.opencode/context/decisions.md\` \u2014 architectural decisions discovered
+  during work that are not already recorded in the project's own decision
+  log. Concise; variable length.
+
+Never create, modify, or delete anything outside \`.opencode/context/\`. The
+\`edit\` permission enforces this. Do not attempt to work around it with bash.
+
+To look for the map, use \`list\` or \`ls .opencode/context\`. Never use the
+\`glob\` tool for it: \`glob\` does not match hidden directories, so it reports
+"no files" even when the map exists.
+
+# Bootstrap
+
+Trigger: \`.opencode/context/\` does not exist or is empty.
+
+Explore progressively and stop as soon as you have a usable map:
+
+1. README files and any existing architecture or decision documentation.
+2. Project manifests (\`package.json\`, \`pyproject.toml\`, \`go.mod\`, \`Cargo.toml\`,
+   \u2026) for entry points, workspaces, and dependency structure.
+3. The top-level directory structure \u2014 one or two levels. Name what each
+   directory is for.
+4. Framework and build configuration (tsconfig, bundler config, CI, container
+   files) to learn how things are assembled and run.
+5. Application entry points. Read them.
+6. Obvious domain / application / infrastructure boundaries and the
+   interfaces between them.
+7. Only then inspect source selectively \u2014 the files that define the boundaries
+   you found.
+
+You are mapping a city, not auditing every house. Do not attempt to
+understand every file.
+
+Then write the five files. For each significant subsystem, give a short
+"Start here" list \u2014 at most about five canonical files, each with a one-phrase
+reason. This is the single most valuable thing you produce: where an agent
+should open its editor next.
+
+# Incremental update
+
+Trigger: \`.opencode/context/\` exists and work has just been done here.
+
+1. Start from the files that changed, plus their immediate architectural
+   neighborhood: what they import, who calls them, the boundary they sit on.
+2. Read only the context file(s) those changes could affect.
+3. Default to no edit. A changed file is not a changed fact: comments,
+   formatting, renames of local variables, added tests, dependency bumps, and
+   edits that stay inside one function rarely alter what the map should say.
+   Edit only when the work introduced or revealed information that will
+   materially help a future agent, such as:
+   - a new architectural boundary or module
+   - a new or moved canonical entry point
+   - a changed workflow
+   - a new repository convention
+   - an architectural decision
+   - a new dependency between subsystems
+   - a renamed or relocated subsystem
+   - a previously undocumented invariant
+
+Do not update documentation merely because source files changed. Do not
+rewrite files wholesale. Do not make timestamp-only edits. Do not add a fact
+that is already stated in another context file \u2014 one fact has one home, and
+the other files link to it. If nothing material changed, make no edits and
+report "no update needed".
+
+# Minimal exploration
+
+Default shape:
+
+    repository structure
+      \u2192 existing documentation
+      \u2192 relevant entry points
+      \u2192 relevant neighboring modules
+      \u2192 deeper exploration only when necessary
+
+Avoid:
+
+    repository
+      \u2192 every directory
+      \u2192 every file
+      \u2192 every dependency
+      \u2192 every caller
+      \u2192 the whole codebase
+
+Aim for minimum sufficient exploration. A few precise reads beat a broad
+sweep. When updating after a task, the changed files and their immediate
+neighborhood are almost always enough.
+
+# Stay inside this project
+
+The target repository is the only thing you are mapping. Everything outside its
+root is out of scope and is blocked:
+
+- Do not read OpenCode's own configuration, prompts, plugins, session storage,
+  or logs. They are not part of the project and hold no project facts.
+- Do not inspect other repositories, home directories, or system paths.
+- Do not treat a blocked tool call as a puzzle to solve. If a read or command
+  is refused, use the project's own files instead and move on.
+- Do not search the filesystem root or use \`grep -r /\`.
+
+# Source of truth
+
+Source code wins. If the context map disagrees with the code:
+
+1. Investigate the discrepancy.
+2. Trust the source.
+3. Correct the map.
+
+Never propagate stale context. Never edit source code to match the map \u2014 you
+never edit source code at all.
+
+# Confidence
+
+Do not record assumptions as facts. If something is uncertain, mark it inline:
+
+> Confidence: low \u2014 inferred from \`src/foo.ts\` naming only
+
+Intent is the most common thing code cannot tell you. A single \`export { app }\`
+does not prove a test seam was intended, and one carefully written expression
+does not prove a repository convention. Mark those inferences or leave them
+out.
+
+If a fact cannot be established with reasonable effort, omit it. A short map
+that is true beats a long map that is partly guesswork.
+
+# Keep it small
+
+The context system exists to REDUCE context consumption. Never let the map
+grow into an encyclopedia. Do not write:
+
+- file inventories or directory listings
+- copied or paraphrased source code
+- large API descriptions
+- content duplicated from the project's own docs \u2014 link to them instead
+- generated documentation
+- exhaustive class or function lists
+- the same finding restated in several files \u2014 state a fact once, in the file
+  that owns it, and let the others point at it
+- generic programming advice that would be true in any repository
+
+Write conclusions, not inventories. Prefer a statement like
+"\`OrderService\` is the application boundary for order mutations" over a
+description of every method it exposes.
+
+If a file grows past its target, consolidate: merge overlapping entries, drop
+the lowest-value ones, and link out to authoritative project docs.
+
+# Review mode
+
+Trigger: an explicit review (see the \`context-review\` command).
+
+Audit the five files for:
+
+- stale information \u2014 verify claims against the code
+- contradictions between files, or between the map and the code
+- excessive size \u2014 consolidate toward the targets above
+- duplicated information \u2014 one canonical place per fact
+- missing canonical entry points for significant subsystems
+- unsupported assumptions \u2014 anything unmarked that you cannot verify
+
+Fix problems only in \`.opencode/context/\`. Never modify source code during a
+review. Report what you found, what you fixed, and what you could not verify.
+
+# Reporting
+
+Finish with a short report:
+
+- what you inspected
+- what you created or changed, and why it matters for future agents
+- what you deliberately left out
+- anything you found that contradicts the code or the existing docs`,
+    permission: {
+      "read": "allow",
+      "glob": "allow",
+      "grep": "allow",
+      "list": "allow",
+      "edit": {
+        "*": "deny",
+        "*/.opencode/context/**": "allow",
+        ".opencode/context/**": "allow"
+      },
+      "bash": {
+        "*": "deny",
+        "ls": "allow",
+        "ls *": "allow",
+        "pwd": "allow",
+        "cat *": "allow",
+        "find *": "allow",
+        "fd *": "allow",
+        "tree *": "allow",
+        "wc *": "allow",
+        "head *": "allow",
+        "tail *": "allow",
+        "stat *": "allow",
+        "file *": "allow",
+        "du *": "allow",
+        "git status*": "allow",
+        "git log*": "allow",
+        "git ls-files*": "allow",
+        "git show*": "allow",
+        "git diff*": "allow",
+        "git blame*": "allow",
+        "git grep*": "allow",
+        "grep *": "allow",
+        "rg *": "allow",
+        "rg": "allow",
+        "echo *": "allow",
+        "sort*": "allow",
+        "uniq*": "allow",
+        "wc": "allow",
+        "which *": "allow",
+        "date": "allow",
+        "mkdir -p *": "deny"
+      },
+      "external_directory": {
+        "*": "deny",
+        "$HOME/.local/share/opencode/tool-output/*": "allow"
+      },
+      "webfetch": "deny",
+      "websearch": "deny",
+      "question": "deny",
+      "task": {
+        "*": "deny"
+      }
+    }
+  }
+};
+function buildAgentSet() {
+  const set = { ...AGENTS };
+  for (const base of POOLED_BASES) {
+    const def = AGENTS[base];
+    if (!def) continue;
+    for (let slot = 1; slot <= MAX_SLOTS; slot++) {
+      const variant = {
+        ...def,
+        description: `Hidden pool variant ${base}-${slot}: slot ${slot}. Its model is NOT set here -- LaCode injects it from the resolved pool preset at config time, so the preset is the only place a pool model is written down. Spawn '${base}' and let the pool route.`,
+        hidden: true
+      };
+      delete variant.model;
+      set[`${base}-${slot}`] = variant;
+    }
+  }
+  return set;
+}
+var DEEP_TIER_SET = new Set(DEEP_TIERS);
+function applyAgents(cfg, agents = buildAgentSet(), opts = {}) {
+  const target = cfg.agent ??= {};
+  const added = [];
+  const kept = [];
+  const deepModel = typeof opts.deepModel === "string" ? opts.deepModel.trim() : "";
+  for (const [name, def] of Object.entries(agents)) {
+    if (target[name] !== void 0) {
+      kept.push(name);
+      continue;
+    }
+    const copy = JSON.parse(JSON.stringify(def));
+    if (deepModel && DEEP_TIER_SET.has(name) && !copy.model) copy.model = deepModel;
+    target[name] = copy;
+    added.push(name);
+  }
+  return { added, kept };
+}
+
+// src/commands.ts
+var COMMANDS = {
+  "context-init": {
+    description: "Bootstrap the repository context map (.opencode/context/) via the context-manager agent.",
+    agent: "context-manager",
+    subtask: true,
+    template: `Bootstrap the repository context map.
+
+If \`.opencode/context/\` already exists, do NOT start over \u2014 verify and refresh
+it in place (correct stale entries, fill gaps) using the review procedure in
+your system prompt.
+
+Otherwise follow the bootstrap procedure in your system prompt: progressive
+exploration (README \u2192 existing docs \u2192 manifests \u2192 top-level structure \u2192 build
+and framework config \u2192 entry points \u2192 selective source), then write the five
+context files inside their size targets.
+
+Remember: write conclusions, not inventories. Link to the project's existing
+documentation instead of duplicating it.
+
+Report what you created or updated, what you deliberately left out, and
+anything that contradicts the code or existing docs.`
+  },
+  "context-update": {
+    description: "Incrementally update .opencode/context/ after recent work via the context-manager agent.",
+    agent: "context-manager",
+    subtask: true,
+    template: `Incremental context update.
+
+Focus: $ARGUMENTS
+
+If no focus was given, establish the recent work yourself (git status, git
+diff, git log) and start from those changed files plus their immediate
+architectural neighborhood.
+
+Follow the incremental-update procedure in your system prompt: update a
+context file only if this work introduced or revealed information that will
+materially help future agents \u2014 a new boundary or module, a new or moved
+canonical entry point, a changed workflow, a new convention, an architectural
+decision, a new dependency between subsystems, a renamed or moved subsystem,
+or a previously undocumented invariant.
+
+Do not edit documentation just because source files changed. No
+timestamp-only edits. If nothing material changed, make no edits and report
+"no update needed".`
+  },
+  "context-review": {
+    description: "Audit .opencode/context/ for staleness, contradictions, excess size, duplication, and missing entry points.",
+    agent: "context-manager",
+    subtask: true,
+    template: `Context review.
+
+Everything outside \`.opencode/context/\` is read-only for this run. Do not
+modify source code under any circumstances.
+
+Audit the five context files for:
+
+- stale information \u2014 verify claims against the actual code
+- contradictions between context files, or between the map and the code
+- excessive size \u2014 consolidate toward the per-file targets in your system
+  prompt
+- duplicated information \u2014 one canonical place per fact; link to the
+  project's own docs rather than restating them
+- missing canonical entry points for significant subsystems
+- unsupported assumptions \u2014 anything stated as fact that you cannot verify,
+  or that lacks a confidence marker
+
+Fix what you find in \`.opencode/context/\` only, then report: findings, fixes,
+and anything you could not verify.`
+  }
+};
+function applyCommands(cfg, commands = COMMANDS) {
+  const target = cfg.command ??= {};
+  const added = [];
+  const kept = [];
+  for (const [name, def] of Object.entries(commands)) {
+    if (target[name] !== void 0) {
+      kept.push(name);
+      continue;
+    }
+    target[name] = JSON.parse(JSON.stringify(def));
+    added.push(name);
+  }
+  return { added, kept };
+}
+var STANDING_INSTRUCTION = `## Repository context map
+
+This project may keep a navigation map in \`.opencode/context/\`. Before broad
+exploration, check whether it exists (\`ls .opencode/context\` \u2014 never the \`glob\`
+tool, which skips hidden directories). If it does, read only the file relevant to
+the task \u2014 architecture.md, contexts.md, conventions.md, workflows.md,
+decisions.md \u2014 then start from the canonical entry points it lists.
+
+Source code is authoritative: if the map disagrees with the code, trust the code,
+say so, and never edit source to match the map. Never edit \`.opencode/context/\`
+yourself \u2014 the context-manager agent owns it. Say in your final report if your
+work revealed something that belongs in the map.`;
+function applyInstructions(cfg) {
+  const existing = cfg.instructions;
+  if (Array.isArray(existing) && existing.length > 0) return { added: false };
+  cfg.instructions = [STANDING_INSTRUCTION];
+  return { added: true };
+}
+
+// src/plugins/agent-pool.ts
+import { tool } from "@opencode-ai/plugin";
+var SERVICE = "agent-pool";
+var REAP_INTERVAL_MS = 3e4;
+var HANG_FALLBACK_MS = 10 * 60 * 1e3;
+var agentPoolHooks = (async ({ client, serverUrl }, options) => {
+  const opts = options ?? {};
+  const s = state(opts);
+  ensureUserConfigDir();
+  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE, level, message, extra } }).catch(() => {
+  });
+  const warnOnce = async (message) => {
+    if (s.warned.has(message)) return;
+    s.warned.add(message);
+    await log("warn", message);
+  };
+  init(s, (m) => void warnOnce(m));
+  const abortSession = async (sessionID) => {
+    if (!serverUrl) return false;
+    try {
+      await fetch(new URL(`/session/${sessionID}/abort`, serverUrl).toString(), { method: "POST" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const reapStuck = async () => {
+    if (s.reaping) return;
+    s.reaping = true;
+    s.lastSweep = Date.now();
+    try {
+      const stuck = findStuck(s);
+      if (stuck.length === 0) return;
+      releaseStuck(s, stuck.map((x) => x.key));
+      for (const { claim } of stuck) {
+        const killed = claim.g ? await abortSession(claim.g) : false;
+        s.reaped++;
+        await log(
+          "warn",
+          `hung ${claim.v} on ${claim.m} after ${Math.round((Date.now() - claim.t) / 1e3)}s with ${Math.round(idleFor(s, claim, Date.now()) / 1e3)}s of silence; ${killed ? `aborted session ${claim.g}` : "no session to abort"}`,
+          { base: claim.v, model: claim.m, slot: claim.k, session: claim.g, aborted: killed }
+        );
+        const prior = s.cooling.get(claim.m);
+        const now = Date.now();
+        const strike = recordStrike(s, claim.m, "hang", prior && prior.until > now ? prior.until - now : HANG_FALLBACK_MS);
+        if (strike) await log("warn", `cooling ${claim.m} for ${Math.round((strike.until - now) / 1e3)}s (hang)`);
+      }
+    } catch (error) {
+      await log("error", `reaper failed: ${String(error)}`);
+    } finally {
+      s.reaping = false;
+    }
+  };
+  refreshCatalog(s, serverUrl);
+  const reapMs = opts.reapMs ?? REAP_INTERVAL_MS;
+  void reapStuck();
+  const timer = setInterval(() => void reapStuck(), reapMs);
+  timer.unref?.();
+  void log(
+    "info",
+    `reaper armed: every ${Math.round(reapMs / 1e3)}s, aborts a claim older than ${Math.round(STUCK_MIN_AGE_MS / 6e4)}m whose target has been silent ${Math.round(STUCK_IDLE_MS / 6e4)}m`
+  );
+  return {
+    config: async (cfg) => {
+      const slots = ensureSlots(s, (m) => void warnOnce(m));
+      const agents = cfg.agent;
+      const providers = cfg.provider;
+      const known = /* @__PURE__ */ new Set();
+      for (const [name, def] of Object.entries(cfg.agent ?? {})) if (def?.model) s.models.set(name, def.model);
+      for (const slot of slots) {
+        for (const base of BASES) {
+          const name = agentFor(base, slot.index);
+          const def = agents?.[name];
+          if (!def) {
+            await warnOnce(`variant ${name} is missing from the config; spawns of ${base} that route to slot ${slot.index} would fail`);
+            continue;
+          }
+          if (def.model && def.model !== slot.model) {
+            await warnOnce(`${name} still hard-codes ${def.model}; the resolved pool preset wins (${slot.model}). Delete the line to keep one source of truth.`);
+          }
+          def.model = slot.model;
+          known.add(name);
+          s.models.set(name, slot.model);
+        }
+        const slash = slot.model.indexOf("/");
+        const provider = slot.model.slice(0, slash);
+        const id = slot.model.slice(slash + 1);
+        const entry = providers?.[provider];
+        if (!entry) {
+          await warnOnce(`provider ${provider} is not configured in opencode.jsonc; slot ${slot.index} (${slot.model}) cannot resolve`);
+          continue;
+        }
+        const list = entry.whitelist;
+        if (list && !list.includes(id)) {
+          list.push(id);
+          await log("info", `whitelisted ${id} on ${provider} (${s.origin} slot ${slot.index})`);
+        }
+      }
+      const deepModel = typeof opts.deepModel === "string" ? opts.deepModel.trim() : "";
+      const deepSlash = deepModel.indexOf("/");
+      if (deepModel && deepSlash > 0) {
+        const provider = deepModel.slice(0, deepSlash);
+        const id = deepModel.slice(deepSlash + 1);
+        const entry = providers?.[provider];
+        if (!entry) {
+          await warnOnce(`deepModel ${deepModel} names provider ${provider}, which is not configured in opencode.jsonc; explore-deep and implement-deep cannot resolve it`);
+        } else {
+          const list = entry.whitelist;
+          if (list && !list.includes(id)) {
+            list.push(id);
+            await log("info", `whitelisted ${id} on ${provider} (deepModel)`);
+          }
+        }
+      } else if (deepModel) {
+        await warnOnce(`deepModel ${deepModel} is not in provider/model-id form and was ignored`);
+      }
+      s.known = known;
+      await log(
+        "info",
+        `${s.origin}: bound ${known.size} variant agent(s) to ${slots.length} slot(s): ${slots.map((sl) => `${sl.index}=${sl.model} w${sl.weight}`).join(", ")}`
+      );
+    },
+    event: async ({ event }) => {
+      try {
+        const props = event.properties ?? {};
+        if (event.type === "session.status") {
+          const status2 = props.status;
+          if (status2?.type === "retry" && status2.action?.reason === "free_tier_limit" && status2.action.provider) {
+            const provider = status2.action.provider;
+            const until = typeof status2.next === "number" && status2.next > Date.now() ? status2.next : Date.now() + HANG_FALLBACK_MS;
+            const cooled = coolProvider(s, provider, until, "free_tier_limit");
+            if (cooled.length > 0) {
+              await log("warn", `free tier exhausted on provider ${provider}; cooling ${cooled.length} slot(s) until ${new Date(until).toISOString().slice(11, 19)}Z`, {
+                provider,
+                until,
+                models: cooled.map((c) => c.model)
+              });
+            }
+          }
+          return;
+        }
+        if (event.type === "session.created") {
+          const info2 = props.info;
+          if (info2?.id && info2.parentID) bindChild(s, info2.parentID, info2.id);
+          return;
+        }
+        if (event.type === "message.updated" || event.type === "message.part.updated") {
+          const info2 = props.info;
+          const part = props.part;
+          const sessionID = info2?.sessionID ?? part?.sessionID;
+          if (sessionID) noteActivity(s, sessionID);
+        }
+        if (event.type !== "message.updated") return;
+        const info = props.info;
+        if (!info || info.role !== "assistant" || !info.error) return;
+        const haystack = JSON.stringify(info.error) ?? "";
+        const status = typeof info.error.data?.statusCode === "number" ? info.error.data.statusCode : void 0;
+        if (!isLimitText(haystack) && status !== 429) return;
+        const model = `${info.providerID ?? "?"}/${info.modelID ?? "?"}`;
+        const stated = statedCooldown(haystack) ?? retryAfterMs(info.error.data?.responseHeaders);
+        const reason = haystack.match(/rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded/i)?.[0]?.toLowerCase().replace(/[\s_]/g, "-");
+        const strike = recordStrike(s, model, reason ?? "rate-limited", stated);
+        if (strike) await log("warn", `cooling ${model} for ${Math.round((strike.until - Date.now()) / 1e3)}s (${reason ?? "rate-limited"}, strike ${strike.strikes})`);
+      } catch (error) {
+        await log("error", `limit detection failed: ${String(error)}`);
+      }
+    },
+    "tool.execute.before": async (input, output) => {
+      if (input.tool !== "task") return;
+      try {
+        const requested = output.args?.subagent_type;
+        if (typeof requested !== "string") return;
+        await reapStuck();
+        refreshCatalog(s, serverUrl);
+        const snap = snapshot(s);
+        if (BASES.includes(requested)) {
+          const slot = pickSlot(s, snap);
+          const variant = agentFor(requested, slot.index);
+          if (s.known.size > 0 && !s.known.has(variant)) {
+            await warnOnce(`variant ${variant} missing from config; spawn left unchanged`);
+            return;
+          }
+          acquire(s, requested, slot, input.sessionID, claimKey(input.sessionID, input.callID));
+          output.args.subagent_type = variant;
+          await log("info", `routed ${requested} -> ${variant}`, {
+            slot: slot.index,
+            weight: slot.weight,
+            model: slot.model,
+            ceiling: slot.weight,
+            load: (snap.counts.get(slot.model) ?? 0) + 1
+          });
+          return;
+        }
+        const direct = /^(.*)-([1-9][0-9]*)$/.exec(requested);
+        if (direct && BASES.includes(direct[1])) {
+          const slot = s.slots.find((sl) => sl.index === Number(direct[2]));
+          if (slot) acquire(s, direct[1], slot, input.sessionID, claimKey(input.sessionID, input.callID));
+        }
+      } catch (error) {
+        await log("error", `routing failed, spawn unchanged: ${String(error)}`);
+      }
+    },
+    "tool.execute.after": async (input) => {
+      if (input.tool !== "task") return;
+      release(s, claimKey(input.sessionID, input.callID));
+    },
+    tool: {
+      pool_status: tool({
+        description: "Show live pool load across every opencode process, per free model and per agent type, each slot's load against its weight ceiling, the slot marked <- next that the next spawn would take, and which models are cooling after a rate limit or a stuck task. Check it before launching many parallel subagents.",
+        args: {},
+        async execute() {
+          refreshCatalog(s, serverUrl);
+          const slots = ensureSlots(s, (m) => void warnOnce(m));
+          const snap = snapshot(s);
+          const now = Date.now();
+          const byModel = /* @__PURE__ */ new Map();
+          const add = (model, base) => {
+            const entry = byModel.get(model) ?? { total: 0, bases: /* @__PURE__ */ new Map() };
+            entry.total++;
+            entry.bases.set(base, (entry.bases.get(base) ?? 0) + 1);
+            byModel.set(model, entry);
+          };
+          for (const claim of snap.own.values()) add(claim.m, claim.v);
+          for (const sibling of snap.siblings) for (const claim of sibling.claims) add(claim.m, claim.v);
+          const next = pickSlot(s, snap);
+          const line = (slot) => {
+            const entry = byModel.get(slot.model);
+            const users = entry && entry.bases.size > 0 ? [...entry.bases].map(([b, n]) => `${b}x${n}`).join(" ") : "idle";
+            const strike = snap.cooling.get(slot.model);
+            const status = s.catalog.get(slot.model);
+            const notes = [
+              strike ? `COOLING ${Math.ceil((strike.until - now) / 1e3)}s (${strike.reason}, strike ${strike.strikes})` : "",
+              status && status !== "active" && status !== "unknown" ? `catalog:${status}` : ""
+            ].filter(Boolean);
+            const marker = slot.index === next.index ? " <- next" : "";
+            const load = entry?.total ?? 0;
+            const atCeiling = !underCeiling(slot, snap.counts);
+            return `  slot ${slot.index} w${slot.weight}  ${slot.model}  load=${load}/${slot.weight}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
+          };
+          const total = [...snap.counts.values()].reduce((sum, n) => sum + n, 0);
+          const coolingNow = [...snap.cooling.entries()].filter(([, st]) => st.until > now);
+          const hung = [...snap.own.values()].filter((c) => now - c.t > STUCK_MIN_AGE_MS && idleFor(s, c, now) >= STUCK_IDLE_MS).length;
+          return {
+            title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
+            output: [
+              `shared pool over ${slots.length} model(s) from ${s.origin}; bases: ${BASES.join(", ")}
+priority is weight: the heaviest slot under its ceiling takes the next spawn (FULL = at ceiling, used only when every slot is)`,
+              ...slots.map(line),
+              "",
+              "by process:",
+              `  ${s.id} (this process): ${snap.own.size} claim(s)`,
+              ...snap.siblings.map((sibling) => `  ${sibling.id}: ${sibling.claims.length} claim(s)`),
+              "",
+              `${total} claim(s) in flight across ${snap.siblings.length + 1} process(es).`,
+              `hung past ${Math.round(STUCK_MIN_AGE_MS / 6e4)}min with ${Math.round(STUCK_IDLE_MS / 6e4)}min silence: ${hung} (auto-aborted); reaped total: ${s.reaped}.`,
+              `watchdog alive: last sweep ${s.lastSweep ? `${Math.max(0, Math.round((now - s.lastSweep) / 1e3))}s ago` : "never"} (every ${Math.round(reapMs / 1e3)}s).`,
+              coolingNow.length === 0 ? "no models cooling down." : `cooling: ${coolingNow.map(([m, st]) => `${m} for ${Math.ceil((st.until - now) / 1e3)}s`).join(", ")}`
+            ].join("\n")
+          };
+        }
+      })
+    },
+    dispose: async () => {
+      clearInterval(timer);
+      s.own.clear();
+    }
+  };
+});
+
+// src/plugins/context-autoupdate.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import * as path2 from "node:path";
+
+// src/lib/writer-rule.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import * as path from "node:path";
+var CONTEXT_DIR = path.join(".opencode", "context");
+var WRITER = "context-manager";
+var toPosix = (value) => value.split(path.sep).join("/");
+var compilePattern = (pattern) => {
+  const escaped = toPosix(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "s");
+};
+var winningRule = (rule, file) => {
+  if (typeof rule === "string") return { pattern: "<whole tool>", action: rule };
+  if (!rule || typeof rule !== "object") return void 0;
+  let winner;
+  for (const [pattern, action] of Object.entries(rule)) {
+    if (compilePattern(pattern).test(file)) winner = { pattern, action: String(action) };
+  }
+  return winner;
+};
+var stripJsonc = (raw) => {
+  let out = "";
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw[i];
+    if (ch === '"') {
+      out += ch;
+      i++;
+      while (i < raw.length) {
+        out += raw[i];
+        if (raw[i] === "\\") {
+          out += raw[i + 1] ?? "";
+          i += 2;
+          continue;
+        }
+        if (raw[i] === '"') {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && raw[i + 1] === "/") {
+      while (i < raw.length && raw[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && raw[i + 1] === "*") {
+      i += 2;
+      while (i < raw.length && !(raw[i] === "*" && raw[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+};
+var readAgents = (raw) => {
+  try {
+    const agents = JSON.parse(stripJsonc(raw)).agent;
+    if (agents && typeof agents === "object" && !Array.isArray(agents)) return agents;
+    return {};
+  } catch {
+    return void 0;
+  }
+};
+var permissionOf = (agent) => agent?.permission?.edit;
+var evaluatedForm = (mapDir, projectRoot) => {
+  const absolute = toPosix(path.join(mapDir, "architecture.md"));
+  return projectRoot ? toPosix(path.relative(projectRoot, absolute)) : absolute;
+};
+var verifyWriterRule = (configPath, mapDir, projectRoot) => {
+  let raw;
+  try {
+    raw = readFileSync2(configPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const rules = [];
+  for (const block of raw.matchAll(/"edit"\s*:\s*\{([^}]*)\}/g)) {
+    for (const rule of block[1].matchAll(/"((?:[^"\\]|\\.)*)"\s*:\s*"(allow|ask|deny)"/g)) {
+      if (rule[2] === "allow") rules.push(rule[1].replace(/\\"/g, '"'));
+    }
+  }
+  const form = evaluatedForm(mapDir, projectRoot);
+  if (rules.length > 0) {
+    if (!rules.some((rule) => compilePattern(rule).test(form))) {
+      return `context map is not writable: none of the allow rules in ${path.basename(configPath)} match ` + (projectRoot ? `the project-root-relative form "${form}" that opencode actually evaluates for project root ${toPosix(projectRoot)}` : `the absolute form "${form}"`) + `. Rules seen: ${rules.map((r) => `"${r}"`).join(", ")}. opencode evaluates file permissions against the path RELATIVE TO THE PROJECT ROOT, so "${CONTEXT_DIR}/**" is what fires for a normally-rooted project while "*/${CONTEXT_DIR}/**" only fires when the project root is "/". Allow both forms.`;
+    }
+  }
+  const agents = readAgents(raw);
+  if (agents) {
+    const offenders = [];
+    for (const [name, def] of Object.entries(agents)) {
+      if (name === WRITER || name.startsWith(WRITER)) continue;
+      const win = winningRule(permissionOf(def), form);
+      if (win?.action === "allow") offenders.push(`${name} (edit rule "${win.pattern}": "${win.action}")`);
+    }
+    if (offenders.length > 0) {
+      return `context map has more than one writer: ${offenders.join(", ")} would be granted the map by permission, evaluating "${form}". Only ${WRITER} may write the map. Narrow the grant and put the deny LAST -- opencode takes the LAST matching rule, so "${CONTEXT_DIR}/**": "deny" written after "*": "allow" is what denies it: "*": "allow", "*/${CONTEXT_DIR}/**": "deny", "${CONTEXT_DIR}/**": "deny". Both spellings are required because the evaluated path depends on the project root.`;
+    }
+  }
+  return void 0;
+};
+
+// src/plugins/context-autoupdate.ts
+var SERVICE2 = "context-autoupdate";
+var CONTEXT_DIR2 = path2.join(".opencode", "context");
+var COOLDOWN_MS = 10 * 60 * 1e3;
+var OWNED_TTL_MS = 20 * 60 * 1e3;
+var MAX_FILES_LISTED = 25;
+var IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "dist-test",
+  "out",
+  "build",
+  "coverage",
+  "target",
+  "vendor",
+  "venv",
+  ".venv",
+  "__pycache__",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".git"
+]);
+var toPosix2 = (value) => value.split(path2.sep).join("/");
+var findProjectConfig = () => {
+  let dir = import.meta.dir ?? path2.dirname(new URL(import.meta.url).pathname);
+  for (let up = 0; up <= 3; up++) {
+    const candidate = path2.join(dir, "opencode.jsonc");
+    if (existsSync2(candidate)) return candidate;
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+};
+var snapshotMap = (dir) => {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    for (const name of readdirSync2(dir)) {
+      const file = path2.join(dir, name);
+      try {
+        const st = statSync2(file);
+        if (st.isFile()) out.set(name, `${st.size}:${st.mtimeMs}`);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+};
+var changedSince = (before, dir) => {
+  const after = snapshotMap(dir);
+  let changed = 0;
+  for (const [name, stamp] of after) if (before.get(name) !== stamp) changed++;
+  for (const name of before.keys()) if (!after.has(name)) changed++;
+  return changed;
+};
+var contextAutoUpdateHooks = (async ({ client, directory }) => {
+  const pending = /* @__PURE__ */ new Set();
+  const owned = /* @__PURE__ */ new Map();
+  let lastRun = 0;
+  const state2 = state();
+  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE2, level, message, extra } }).catch(() => {
+  });
+  const root = path2.resolve(directory);
+  const contextAbs = path2.join(root, CONTEXT_DIR2);
+  const config = findProjectConfig();
+  const writerProblem = config ? verifyWriterRule(config, contextAbs, root) : void 0;
+  if (writerProblem) void log("error", writerProblem);
+  const isTracked = (file) => {
+    const absolute = path2.resolve(root, file);
+    if (absolute !== root && !absolute.startsWith(root + path2.sep)) return false;
+    if (absolute === contextAbs || absolute.startsWith(contextAbs + path2.sep)) return false;
+    return !toPosix2(absolute).split("/").some((segment) => IGNORED_SEGMENTS.has(segment));
+  };
+  const listed = (files) => {
+    const shown = files.slice(0, MAX_FILES_LISTED);
+    const rest = files.length - shown.length;
+    const lines = shown.map((file) => `- ${toPosix2(file)}`).join("\n");
+    return rest > 0 ? `${lines}
+- \u2026and ${rest} more (check git status for the full set)` : lines;
+  };
+  const compose = (mode, files) => mode === "bootstrap" ? [
+    "Bootstrap the repository context map. Project root: " + directory,
+    "",
+    "`.opencode/context/` does not exist yet.",
+    "",
+    "This session touched these paths (starting context, not an exhaustive list):",
+    listed(files),
+    "",
+    "Follow the bootstrap procedure in your system prompt: progressive exploration, then write the five context files within their size targets. When the project already has architecture or decision documentation, link to it instead of duplicating it. Write conclusions, not inventories."
+  ].join("\n") : [
+    "Incremental context update. Project root: " + directory,
+    "",
+    "This session touched these paths (start from these and their immediate architectural neighborhood):",
+    listed(files),
+    "",
+    'Follow the incremental-update procedure in your system prompt. Update a context file only if this work introduced or revealed information that will materially help future agents: a new boundary or module, a new or moved canonical entry point, a changed workflow, a new convention, an architectural decision, a new dependency between subsystems, a renamed or moved subsystem, or a previously undocumented invariant. Do not edit documentation merely because source files changed. If nothing material changed, make no edits and report "no update needed".'
+  ].join("\n");
+  return {
+    event: async ({ event }) => {
+      try {
+        if (event.type === "file.edited") {
+          if (isTracked(event.properties.file)) pending.add(event.properties.file);
+          return;
+        }
+        if (event.type !== "session.idle") return;
+        const sessionID = event.properties.sessionID;
+        if (owned.delete(sessionID)) {
+          lastRun = Date.now();
+          return;
+        }
+        const now = Date.now();
+        for (const [id, startedAt] of owned) if (now - startedAt > OWNED_TTL_MS) owned.delete(id);
+        if (owned.size > 0) return;
+        if (Date.now() - lastRun < COOLDOWN_MS) return;
+        if (pending.size === 0) return;
+        const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((result) => result.data).catch(() => void 0);
+        if (!info) return;
+        if (info.parentID) return;
+        const files = [...pending];
+        for (const file of files) pending.delete(file);
+        const requeue = () => {
+          for (const file of files) pending.add(file);
+        };
+        const mode = existsSync2(contextAbs) ? "update" : "bootstrap";
+        init(state2, (m) => void log("warn", m));
+        const snap = snapshot(state2);
+        const slot = pickSlot(state2, snap);
+        const agent = agentFor("context-manager", slot.index);
+        const created = await client.session.create({
+          body: { title: `context-manager (auto ${mode})` },
+          query: { directory }
+        });
+        const target = created.data?.id;
+        if (!target) {
+          requeue();
+          await log("warn", "could not create context-manager session");
+          return;
+        }
+        const claimKey2 = claimKey(target, "context-autoupdate");
+        acquire(state2, "context-manager", slot, target, claimKey2, target);
+        await log("info", `borrowed pool slot ${slot.index} (${slot.model}, w${slot.weight}) for auto ${mode}`, {
+          slot: slot.index,
+          weight: slot.weight,
+          model: slot.model
+        });
+        lastRun = Date.now();
+        owned.set(target, Date.now());
+        const before = snapshotMap(contextAbs);
+        client.session.prompt({
+          path: { id: target },
+          query: { directory },
+          body: { agent, parts: [{ type: "text", text: compose(mode, files) }] }
+        }).then(async (result) => {
+          release(state2, claimKey2);
+          const failure = result.error ?? result.data?.info?.error;
+          if (failure) {
+            requeue();
+            await log("warn", `auto ${mode} did not complete`, {
+              sessionID: target,
+              files: files.length,
+              error: failure.name ?? String(failure)
+            });
+            return;
+          }
+          const changed = changedSince(before, contextAbs);
+          if (changed > 0) {
+            await log("info", `auto ${mode} finished`, { sessionID: target, considered: files.length, changed });
+          } else {
+            await log("warn", `auto ${mode} finished without changing the map`, {
+              sessionID: target,
+              considered: files.length,
+              changed: 0,
+              hint: "either nothing needed updating, or the cartographer could not write -- check the one-writer permission rule"
+            });
+          }
+        }).catch(async (error) => {
+          release(state2, claimKey2);
+          requeue();
+          await log("error", `auto ${mode} failed: ${String(error)}`);
+        });
+      } catch (error) {
+        await log("error", `handler failed: ${String(error)}`);
+      }
+    }
+  };
+});
+
+// src/plugins/notify.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import * as path3 from "node:path";
+
+// src/lib/notify.ts
+var INTERNAL_TITLE_PREFIXES = [
+  // context-autoupdate spawns the cartographer through the session API, with no
+  // parentID, so it looks exactly like a root session going idle. Notifying for
+  // it would announce the cartographer's own bookkeeping as a finished task.
+  "context-manager (auto"
+];
+var notifyMessage = (outcome, detail) => {
+  if (outcome === "error") return detail ? `Failed \u2014 ${detail}` : "Failed";
+  if (outcome === "question") return detail ? `Awaiting your response \u2014 ${detail}` : "Awaiting your response";
+  if (outcome === "permission") return detail ? `Awaiting your permission \u2014 ${detail}` : "Awaiting your permission";
+  return "Task finished, waiting for your review";
+};
+var safeTitle = (raw, fallback = "session") => {
+  if (!raw) return fallback;
+  const clean = raw.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!clean) return fallback;
+  return clean.length > 90 ? `${clean.slice(0, 89)}\u2026` : clean;
+};
+var shouldNotify = (input) => {
+  const { info, outcome, detail } = input;
+  if (!info?.id) return { notify: false, reason: "no session info" };
+  if (info.parentID) return { notify: false, reason: "subagent" };
+  const title = safeTitle(info.title);
+  if (INTERNAL_TITLE_PREFIXES.some((prefix) => title.startsWith(prefix))) {
+    return { notify: false, reason: "internal session" };
+  }
+  if (info.time?.compacting) return { notify: false, reason: "compacting" };
+  if (outcome === "done" && input.sawMessage === false) {
+    return { notify: false, reason: "no work done" };
+  }
+  if (outcome === "done" && input.awaitingResponse) {
+    return { notify: false, reason: "awaiting your response" };
+  }
+  return {
+    notify: true,
+    title: `opencode \u2014 ${title}`,
+    message: notifyMessage(outcome, detail),
+    urgency: outcome === "error" ? "critical" : "normal"
+  };
+};
+var questionHeadline = (questions) => {
+  const first = questions?.find((entry) => typeof entry?.question === "string" && entry.question.trim());
+  if (!first?.question) return "";
+  const clean = safeTitle(first.question);
+  return clean.length > 70 ? `${clean.slice(0, 69)}\u2026` : clean;
+};
+var str = (value) => typeof value === "string" && value.trim() ? value : void 0;
+var permissionKind = (request) => str(request.permission) ?? str(request.type) ?? "";
+var permissionPatterns = (request) => {
+  const list = Array.isArray(request.patterns) ? request.patterns : Array.isArray(request.pattern) ? request.pattern : [request.pattern];
+  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
+};
+var trimGlob = (raw) => {
+  const star = raw.indexOf("*");
+  return (star === -1 ? raw : raw.slice(0, star)).replace(/[\\/]+$/, "");
+};
+var shortenHome = (raw) => {
+  const home = process.env.HOME ?? "";
+  return home && raw.startsWith(`${home}/`) ? `~${raw.slice(home.length)}` : raw;
+};
+var permissionHeadline = (request) => {
+  const kind = permissionKind(request);
+  const patterns = permissionPatterns(request);
+  const metadata = request.metadata ?? {};
+  const meta = (key) => str(metadata[key]);
+  const requested = shortenHome(trimGlob(meta("parentDir") ?? meta("filepath") ?? patterns[0] ?? ""));
+  if (kind === "external_directory") {
+    return requested ? `access external directory ${requested}` : "access an external directory";
+  }
+  const command = meta("command");
+  if (kind === "bash" || kind === "shell") {
+    return command ? `run \`${safeTitle(command, "a shell command")}\`` : "run a shell command";
+  }
+  const label = kind || "a tool";
+  if (requested) return `${label} \u2014 ${requested}`;
+  if (patterns.length) return `${label} \u2014 ${patterns.join(", ")}`;
+  return `${label} is asking for permission`;
+};
+var MAX_TRACKED = 500;
+var Notifier = class {
+  lastSent = /* @__PURE__ */ new Map();
+  // Not a constructor parameter property: this module is loaded by node's
+  // type-stripping loader, which does not support the shorthand.
+  windowMs;
+  constructor(windowMs) {
+    this.windowMs = windowMs;
+  }
+  allow(sessionID, now) {
+    const previous = this.lastSent.get(sessionID);
+    if (previous !== void 0 && now - previous < this.windowMs) return false;
+    this.record(sessionID, now);
+    return true;
+  }
+  // Record without asking. Used by the error path, which must bypass the window
+  // rather than be blocked by it, but still needs the timestamp refreshed.
+  record(sessionID, now) {
+    this.lastSent.set(sessionID, now);
+    this.evict(now);
+  }
+  evict(now) {
+    if (this.lastSent.size <= MAX_TRACKED) return;
+    let excess = this.lastSent.size - MAX_TRACKED;
+    for (const key of this.lastSent.keys()) {
+      if (excess-- <= 0) break;
+      this.lastSent.delete(key);
+    }
+  }
+  // Exposed so the eviction test can assert on it: the map is otherwise
+  // unreachable from outside, which would make the bound untestable.
+  lastSentSize() {
+    return this.lastSent.size;
+  }
+};
+
+// src/plugins/notify.ts
+var SERVICE3 = "notify";
+var COOLDOWN_MS2 = 5e3;
+var findHelper = () => {
+  const home = process.env.HOME ?? "";
+  const candidates = [
+    process.env.OC_NOTIFY_HELPER,
+    path3.join(home, "bin", "lacode"),
+    path3.join(home, "bin", "oc-notify"),
+    path3.join(PACKAGE_ROOT, "bin", "oc-notify"),
+    path3.join(PACKAGE_ROOT, "dist", "lacode.js"),
+    path3.join(PACKAGE_ROOT, "bin", "lacode")
+  ].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+  for (const candidate of candidates) if (existsSync3(candidate)) return candidate;
+  return void 0;
+};
+var notifyHooks = (async ({ client, directory }, _options, deps = {}) => {
+  const notifier = new Notifier(COOLDOWN_MS2);
+  const active = /* @__PURE__ */ new Set();
+  const titles = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  const permissions = /* @__PURE__ */ new Set();
+  let warnedHelper = false;
+  const log = (level, message, extra) => client.app.log({ body: { service: SERVICE3, level, message, extra } }).catch(() => {
+  });
+  const fetchInfo = async (sessionID) => {
+    const info = await client.session.get({ path: { id: sessionID }, query: { directory } }).then((result) => result.data).catch(() => void 0);
+    return info;
+  };
+  const deliverViaHelper = (title, message, urgency) => new Promise((resolve2) => {
+    const helper = findHelper();
+    if (!helper) {
+      if (!warnedHelper) {
+        warnedHelper = true;
+        void log("warn", "no oc-notify helper found; run 'bin/oc-sync' to install one");
+      }
+      resolve2({ ok: false, detail: "no oc-notify helper found" });
+      return;
+    }
+    const child = spawn(helper, [title, message, urgency, "utilities-terminal"], {
+      stdio: ["ignore", "ignore", "pipe"],
+      detached: true
+    });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < 400) stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      void log("warn", `notification helper failed: ${String(error)}`, { title });
+      resolve2({ ok: false, detail: String(error) });
+    });
+    child.on("exit", (code) => {
+      const noise = stderr.trim();
+      const ok = code === 0 && noise === "";
+      if (!ok) {
+        void log("warn", `notification not delivered: ${noise || `helper exit ${code}`}`, {
+          title,
+          message
+        });
+      }
+      resolve2({ ok, detail: noise || void 0 });
+    });
+    child.unref();
+  });
+  const deliver = deps.deliver ?? deliverViaHelper;
+  const announce = async (sessionID, outcome, detail) => {
+    try {
+      const info = await fetchInfo(sessionID);
+      if (!info) {
+        void log("debug", "session info unavailable; not notifying", { sessionID });
+        return;
+      }
+      const titled = info.title ? info : { ...info, title: titles.get(sessionID) };
+      const isRemote = Boolean(process.env.SSH_CLIENT || process.env.SSH_TTY);
+      const decision = shouldNotify({
+        info: titled,
+        outcome,
+        detail,
+        sawMessage: active.has(sessionID),
+        // Either kind of block suppresses the idle event's "finished": a session
+        // parked on a permission prompt has not finished, it is waiting.
+        awaitingResponse: pending.has(sessionID) || permissions.has(sessionID)
+      });
+      if (!decision.notify) {
+        void log("debug", `suppressed: ${decision.reason}`, { sessionID });
+        return;
+      }
+      const kind = decision.urgency === "critical" ? "error" : outcome === "done" ? "done" : outcome;
+      const key = `${kind}:${sessionID}`;
+      const blocking = kind !== "done";
+      const now = Date.now();
+      if (blocking) {
+        notifier.record(key, now);
+      } else if (!notifier.allow(key, now)) {
+        void log("debug", "suppressed: cooldown", { sessionID });
+        return;
+      }
+      const message = isRemote ? `${decision.message} (remote)` : decision.message;
+      const sent = await deliver(decision.title, message, decision.urgency);
+      void log(sent.ok ? "info" : "error", sent.ok ? "notified" : "notification failed", {
+        sessionID,
+        outcome,
+        title: decision.title,
+        ...sent.detail ? { detail: sent.detail } : {}
+      });
+    } catch (error) {
+      void log("error", `notify failed: ${String(error)}`);
+    }
+  };
+  return {
+    event: async ({ event }) => {
+      try {
+        if (event.type === "session.status") {
+          const { sessionID: sessionID2, status } = event.properties;
+          if (status.type === "busy" && sessionID2) active.add(sessionID2);
+          return;
+        }
+        if (event.type === "session.updated") {
+          const info = event.properties.info;
+          if (info?.id) titles.set(info.id, info.title);
+          return;
+        }
+        if (event.type === "question.asked") {
+          const properties = event.properties;
+          const sessionID2 = properties?.sessionID;
+          if (!sessionID2) return;
+          pending.add(sessionID2);
+          active.add(sessionID2);
+          const headline = questionHeadline(properties.questions);
+          void announce(sessionID2, "question", headline || void 0);
+          return;
+        }
+        if (event.type === "question.replied" || event.type === "question.rejected") {
+          const sessionID2 = event.properties?.sessionID;
+          if (sessionID2) pending.delete(sessionID2);
+          return;
+        }
+        if (event.type === "permission.asked") {
+          const properties = event.properties;
+          const sessionID2 = properties?.sessionID;
+          if (!sessionID2) return;
+          permissions.add(sessionID2);
+          active.add(sessionID2);
+          void announce(sessionID2, "permission", permissionHeadline(properties) || void 0);
+          return;
+        }
+        if (event.type === "permission.replied") {
+          const sessionID2 = event.properties?.sessionID;
+          if (sessionID2) permissions.delete(sessionID2);
+          return;
+        }
+        if (event.type === "session.error") {
+          const sessionID2 = event.properties.sessionID;
+          if (sessionID2) {
+            pending.delete(sessionID2);
+            permissions.delete(sessionID2);
+            void announce(sessionID2, "error");
+          }
+          return;
+        }
+        if (event.type === "session.deleted") {
+          const sessionID2 = event.properties?.info?.id;
+          if (sessionID2) {
+            active.delete(sessionID2);
+            titles.delete(sessionID2);
+            pending.delete(sessionID2);
+            permissions.delete(sessionID2);
+          }
+          return;
+        }
+        if (event.type !== "session.idle") return;
+        const sessionID = event.properties.sessionID;
+        if (sessionID) void announce(sessionID, "done");
+      } catch (error) {
+        void log("error", `handler failed: ${String(error)}`);
+      }
+    }
+  };
+});
+
+// src/index.ts
+var inertHooks = {
+  config: async () => {
+  },
+  event: async () => {
+  },
+  dispose: async () => {
+  }
+};
+var LaCode = (async (input, options) => {
+  const opts = options ?? {};
+  if (opts.enabled === false) return inertHooks;
+  const log = (level, message, extra) => input.client.app.log({ body: { service: "lacode", level, message, extra } }).catch(() => {
+  });
+  const settled = async (label, make) => {
+    try {
+      return await make();
+    } catch (error) {
+      await log("error", `${label} failed to start: ${String(error)}`);
+      return void 0;
+    }
+  };
+  const agentSet = buildAgentSet();
+  const pool = await settled("agent-pool", () => agentPoolHooks(input, options)) ?? inertHooks;
+  const autoupdate = await settled("context-autoupdate", () => contextAutoUpdateHooks(input, options)) ?? inertHooks;
+  const notifier = await settled("notify", () => notifyHooks(input, options)) ?? inertHooks;
+  const config = async (cfg) => {
+    try {
+      const injected = applyAgents(cfg, agentSet, { deepModel: opts.deepModel });
+      if (injected.added.length > 0) {
+        await log("info", `agents: added ${injected.added.length}, kept ${injected.kept.length} already defined by the user`);
+      }
+      const cmds = applyCommands(cfg);
+      if (cmds.added.length > 0) {
+        await log("info", `commands: added ${cmds.added.join(", ")}; kept ${cmds.kept.join(", ") || "none"} already defined`);
+      }
+      if (applyInstructions(cfg).added) {
+        await log("info", "instructions: added the standing context-map rule (no user instructions were present)");
+      }
+      await pool.config?.(cfg);
+    } catch (error) {
+      await log("error", `config hook failed: ${String(error)}`);
+    }
+  };
+  const event = async (payload) => {
+    await Promise.all([
+      pool.event?.(payload).catch(() => {
+      }),
+      autoupdate.event?.(payload).catch(() => {
+      }),
+      notifier.event?.(payload).catch(() => {
+      })
+    ]);
+  };
+  return {
+    config,
+    event,
+    // Both tool hooks and the tool registry come from the pool alone: it is the
+    // only thing that routes task calls, so there is nothing to merge them with.
+    "tool.execute.before": pool["tool.execute.before"],
+    "tool.execute.after": pool["tool.execute.after"],
+    tool: pool.tool,
+    dispose: async () => {
+      await pool.dispose?.();
+      await autoupdate.dispose?.();
+      await notifier.dispose?.();
+    }
+  };
+});
+var index_default = LaCode;
+export {
+  index_default as default
+};