@lawaty/lacode 0.1.1 → 0.1.2

package/README.md

@@ -108,11 +108,11 @@ Nothing here hot-reloads, so the restart is part of the step, not a footnote.
 **2 — Check whether the plugin loaded.**
 
 ```bash
-opencode agent list | grep -E '^(explore-fast|implement-fast|explore-deep|implement-deep)'
+opencode agent list | grep -E '^(explore|implement|context)'
 ```
 
-A working install prints `explore-fast`, `implement-fast`, `explore-deep` and
-`implement-deep`, each with the hidden `-1`..`-4` pool variants alongside. If the
+A working install prints `explore`, `implement` and `context`, each with the
+hidden `-1`..`-4` pool variants alongside. If the
 grep returns nothing and the list holds only opencode's own built-ins, the plugin
 did not load. Run it in the same shell environment opencode runs in — an
 `agent list` under a different `HOME` or `XDG_CONFIG_HOME` tests a different
@@ -284,7 +284,6 @@ option is optional:
 | `enabled` | `true` | The single off switch. `false` injects nothing at all and does no writes. |
 | `models` | — | An inline slot list. Highest-priority source. |
 | `modelsFile` | — | An explicit slot file; short-circuits the chain below. |
-| `deepModel` | — | A `provider/model-id` pinned onto `explore-deep` and `implement-deep`. |
 | `reapMs` | `30000` | Hang-reaper interval. |
 
 ### Pool preset resolution
@@ -308,46 +307,26 @@ that is a sensible default, not because the pool requires it.
 ### Which models run which agent
 
 Only the **pool** writes a model onto a pooled agent, from whichever source wins
-above. The pooled bases (`explore-fast`, `implement-fast`, `context-manager`)
+above. The pooled bases (`explore`, `implement`, `context`)
 and their hidden `-1`..`-4` variants therefore carry no model of their own: a
 model written next to an agent would be a second source of truth that silently
 wins whenever routing falls through. Spawn a base and let the pool route it.
 
-`explore-deep` and `implement-deep` are **not** pooled — they are the deliberate
-escalation above a pooled tier — so nothing routes them and nothing writes their
-model. Left alone they fall through to your default model, which turns "I am
-stuck, escalate" into an unannounced jump to the most expensive model in your
-setup. Set `deepModel` to pin them:
-
-```jsonc
-"plugin": [["@lawaty/lacode", { "deepModel": "your-provider/your-deep-model" }]]
-```
-
-It is an option and not a literal in the package because which model to escalate
-onto is a property of your providers, not of LaCode. If you keep a `whitelist`
-on that provider, LaCode appends the pinned model to it for you: the whitelist is
-an allowlist, so opencode drops any model a provider offers that it does not
-name, and an unlisted pin would resolve to nothing at all. If you have no
-whitelist there, none is written — an absent one already allows every model. With
-`deepModel` unset, no model is written and the deep tiers use your
-default model — the behaviour of earlier versions.
-
 ### ⚠️ Per-agent tool grants must be in your own config
 
 **LaCode cannot grant tools to its agents, and this is not an oversight you can
 work around by configuring it.** If you keep a global `"tools"` block in your
-config — for example `"tools": { "playwright_*": false }` — then the four
-exploration and implementation tiers (`explore-fast`, `explore-deep`,
-`implement-fast`, `implement-deep`, plus their hidden `-1`..`-4` pool variants)
-lose browser access, and **nothing tells them why**: the tool call is simply
-refused mid-task. `context-manager` gets no grant either, which is correct — it
+config — for example `"tools": { "playwright_*": false }` — then the pooled
+exploration and implementation bases (`explore` and `implement`, plus their
+hidden `-1`..`-4` pool variants) lose browser access, and **nothing tells them why**: the tool call is simply
+refused mid-task. `context` gets no grant either, which is correct — it
 writes the context map and has no business in a browser.
 
 opencode folds an agent's `tools` into its permission list **at config-load
 time**, while decoding the config — before any plugin runs. A plugin's `config`
 hook mutates the already-decoded config, so the fold never re-runs and anything
 it puts in `agent.tools` is inert. (Verified on opencode 1.18.34/1.18.35 with
-`opencode debug agent explore-fast`: a grant written in your own config shows two
+`opencode debug agent explore`: a grant written in your own config shows two
 `playwright_*` entries — `deny` then `allow`, last one winning — while the same
 grant injected by the plugin shows only the `deny`.) LaCode's other injected
 fields are not affected; `permission`, `prompt`, `model`, `description`,
@@ -359,15 +338,13 @@ fields are not affected; `permission`, `prompt`, `model`, `description`,
 {
   "tools": { "playwright_*": false },
   "agent": {
-    "explore-fast": { "tools": { "playwright_*": true } },
-    "explore-deep": { "tools": { "playwright_*": true } },
-    "implement-fast": { "tools": { "playwright_*": true } },
-    "implement-deep": { "tools": { "playwright_*": true } }
+    "explore": { "tools": { "playwright_*": true } },
+    "implement": { "tools": { "playwright_*": true } }
   }
 }
 ```
 
-The hidden pool variants (`explore-fast-1`, `implement-fast-2`, …) inherit
+The hidden pool variants (`explore-1`, `implement-2`, …) inherit
 nothing here — add a line per variant you actually spawn, or drop the global
 deny and scope it to the agents that should not have browser access instead.
 
@@ -376,8 +353,8 @@ process.
 
 ### What gets injected
 
-**19 agent keys**: the 7 bases `build`, `plan`, `explore-fast`, `explore-deep`,
-`implement-fast`, `implement-deep`, `context-manager`, plus one hidden
+**17 agent keys**: the 5 bases `build`, `plan`, `explore`, `implement`,
+`context`, plus one hidden
 `<base>-1`..`-4` pool variant for each of the 3 pooled bases.
 
 `build` and `plan` exist in opencode as built-ins, so on a stock config those
@@ -424,7 +401,7 @@ inventories: it answers "what should I look at first?" and nothing else, which
 is what makes reading it cheaper than the exploration it replaces.
 
 It keeps itself current. When a session that edited code goes idle, LaCode
-starts a `context-manager` run that borrows a slot from the same pool every
+starts a `context` run that borrows a slot from the same pool every
 other subagent uses and updates the map from the changed paths and their
 architectural neighbourhood — defaulting to *no edit*, since a changed file is
 not a changed fact. Only that one agent ever writes the map; everything else

package/dist/agents.js

@@ -10,6 +10,7 @@ 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 UNAVAILABLE_COOLDOWN_MS = 60 * 1e3;
 var MAX_SLOTS = 4;
 var COOLDOWN_BASE_MS = 60 * 1e3;
 var COOLDOWN_MAX_MS = 15 * 60 * 1e3;
@@ -34,11 +35,10 @@ var USER_CONFIG_DIR = join(homedir(), ".config", "lacode");
 var USER_MODELS_PATH = join(USER_CONFIG_DIR, "pool.json");
 
 // src/agents.ts
-var DEEP_TIERS = ["explore-deep", "implement-deep"];
-var POOLED_BASES = ["explore-fast", "implement-fast", "context-manager"];
+var POOLED_BASES = ["explore", "implement", "context"];
 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.",
+    "description": "Default root agent. Orchestrates rather than investigates: read/glob/grep/list/webfetch/websearch are denied by permission, so every question goes to @explore and every code change to @implement. Keeps edit/write/bash for applying and verifying what comes back.",
     "mode": "primary",
     "temperature": 0.1,
     prompt: `# Role
@@ -53,17 +53,15 @@ Every question of the form "what does this file do", "where is X handled", or
 
 # Delegation
 
-- **Investigation \u2192 @explore-fast.** Give it specific, focused instructions
+- **Investigation \u2192 @explore.** 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
+- **Implementation \u2192 @implement**, 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
+The agents you spawn are the pooled \`explore\` / \`implement\` bases \u2014
 spawn the bare name and let the pool route, never a \`-1\`/\`-2\` slot variant.
 
 # What stays yours
@@ -74,11 +72,11 @@ 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.
+to @explore. Bash is for executing and verifying, not for looking.
 
 # Repository context
 
-Before delegating a non-trivial task, tell @explore-fast to check
+Before delegating a non-trivial task, tell @explore 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
@@ -90,7 +88,7 @@ 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
+context 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.
 
@@ -117,13 +115,13 @@ missing). Never paste context file contents into the report.`,
       "question": "allow",
       "task": {
         "*": "deny",
-        "explore-fast*": "allow",
-        "implement-fast*": "allow"
+        "explore*": "allow",
+        "implement*": "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.",
+    "description": "Read-only planner. Identical to @basic: it cannot read, grep, glob, list or run commands, so all investigation is delegated to @explore. 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.
@@ -132,8 +130,8 @@ You CANNOT read files, grep, glob, list directories, or run commands directly. A
 
 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
+2. Invoke @explore with specific, focused instructions (e.g. "read src/auth.ts", "grep for 'migration' in *.py files", "list the src/ directory")
+3. @explore 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
@@ -147,12 +145,12 @@ 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
+context 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
+2. Delegate investigation to @explore in focused batches
 3. Analyze findings for dependencies, edge cases, and architecture impact
 4. Produce a structured output:
    - Summary of the change
@@ -187,13 +185,13 @@ Once the plan is complete, present it clearly so the caller can implement it ste
       "question": "allow",
       "task": {
         "*": "deny",
-        "explore-fast*": "allow",
-        "implement-fast*": "allow"
+        "explore*": "allow",
+        "implement*": "allow"
       }
     }
   },
-  "explore-fast": {
-    "description": "Default read-only codebase exploration. Free via Zen. Escalates to @explore-deep when stuck or looping.",
+  "explore": {
+    "description": "Default read-only codebase exploration. Free via Zen.",
     "mode": "subagent",
     "temperature": 0.2,
     prompt: `# Role
@@ -226,119 +224,26 @@ 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
+context 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
+# When to report back
 
-If you hit any of the following, STOP and delegate to @explore-deep via the
-task tool instead of continuing to search:
+There is no deeper tier to hand off to. If after genuinely trying \u2014 one
+alternative search strategy first \u2014 you still cannot answer:
 
-- 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)
+- STOP. Do not loop or guess.
+- Report the exact question, every search you already tried and what each
+  one returned, and your best hypothesis even if unconfirmed.
+- Never guess or fabricate a file path, line number, or code behavior. An
+  honest "I couldn't find this, here's why" is the correct output.
 
-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.`,
+You may only explore. Do not attempt to call @implement or any other agent \u2014
+exploration agents only explore.`,
     permission: {
       "read": "allow",
       "glob": "allow",
@@ -354,8 +259,8 @@ or any other agent.`,
       }
     }
   },
-  "implement-fast": {
-    "description": "Default agent that executes a finalized plan. Escalates to @implement-deep when stuck or looping.",
+  "implement": {
+    "description": "Default agent that executes a finalized plan.",
     "mode": "subagent",
     "temperature": 0.2,
     prompt: `# Role
@@ -381,7 +286,7 @@ 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
+responsibility handled by the context 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.
@@ -391,115 +296,21 @@ your final report instead of editing it yourself.
      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:
+# When to report back
 
-- 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
+There is no deeper tier to hand off to. If after genuinely trying \u2014 at least
+one different fix, or a re-read of the relevant code \u2014 you still cannot
+complete the step:
 
-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).
+- STOP. Do not loop or guess.
+- Leave the code in the most coherent state you can; prefer reverting a
+  broken partial change over leaving it half-done.
+- Report the plan step, every approach tried and why each failed, and the
+  current state of the code. Never mark a step done if it isn't, and never
+  fabricate a passing test.
 
-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.`,
+You may only implement. Do not attempt to call @explore or any other agent \u2014
+if the blocker is understanding rather than execution, report that instead.`,
     permission: {
       "read": "allow",
       "glob": "allow",
@@ -519,7 +330,7 @@ trying to explore yourself.`,
       }
     }
   },
-  "context-manager": {
+  "context": {
     "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,
@@ -792,19 +603,16 @@ function buildAgentSet() {
   }
   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);
   }
@@ -812,7 +620,6 @@ function applyAgents(cfg, agents = buildAgentSet(), opts = {}) {
 }
 export {
   AGENTS,
-  DEEP_TIERS,
   POOLED_BASES,
   applyAgents,
   buildAgentSet

package/dist/commands.js

@@ -1,8 +1,8 @@
 // src/commands.ts
 var COMMANDS = {
   "context-init": {
-    description: "Bootstrap the repository context map (.opencode/context/) via the context-manager agent.",
-    agent: "context-manager",
+    description: "Bootstrap the repository context map (.opencode/context/) via the context agent.",
+    agent: "context",
     subtask: true,
     template: `Bootstrap the repository context map.
 
@@ -22,8 +22,8 @@ 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",
+    description: "Incrementally update .opencode/context/ after recent work via the context agent.",
+    agent: "context",
     subtask: true,
     template: `Incremental context update.
 
@@ -46,7 +46,7 @@ timestamp-only edits. If nothing material changed, make no edits and report
   },
   "context-review": {
     description: "Audit .opencode/context/ for staleness, contradictions, excess size, duplication, and missing entry points.",
-    agent: "context-manager",
+    agent: "context",
     subtask: true,
     template: `Context review.
 
@@ -93,7 +93,7 @@ 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
+yourself \u2014 the context 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;