@sorenllm/opencode-forge 0.3.2 → 0.3.4

package/dist/index.js

@@ -12335,9 +12335,9 @@ function tool(input) {
 tool.schema = exports_external;
 // plugin.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { isAbsolute, join as join4, relative } from "node:path";
-import { tmpdir as tmpdir2 } from "node:os";
+import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync6, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { isAbsolute, join as join5, relative } from "node:path";
+import { tmpdir as tmpdir3, homedir } from "node:os";
 
 // src/plan-file.ts
 class PlanError extends Error {
@@ -14723,188 +14723,1773 @@ function createLocator(platform = process.platform, posix = {}, win = {}) {
   return platform === "win32" ? createWindowsLocator(win) : createPosixLocator(posix);
 }
 
-// plugin.ts
-var FORGE_AGENT = "forge";
-var FORGE_PROMPT = `You are forge — the single general-purpose coding agent. You handle every task directly: exploration, planning, implementation, and verification. There is no agent switching.
-
-Workflow modes are strictly user-initiated. Never enter plan or goal mode — and never call a plan_* or goal_* tool — unless the user ran /plan or /goal, unmistakably asked for that mode (e.g. "plan first", "set a goal"), or the session already carries a [forge:plan-notice] / [forge:goal-notice] for a mode they started. Ordinary task requests are normal work. Mode-specific rules arrive with those commands and notices; when a notice is present, follow it.`;
-var PLAN_COMMAND_TEMPLATE = [
-  '(forge plan harness routing. Argument: "$ARGUMENTS")',
-  "",
-  "Current .opencode/plan/ directory:",
-  "!`ls -1 .opencode/plan 2>/dev/null || echo '(empty)'`",
-  "",
-  "Route on the argument above (decide silently; do not recite this routing text to the user):",
-  "- Argument empty: for every non-terminal plan (status draft or approved) in the directory above, read its frontmatter and task checkboxes, then report to the user: path, status, progress (x/y ticked). Ask whether to resume one or start something new.",
-  '- Argument "resume": pick the most recently updated non-terminal plan, summarize its remaining unticked tasks to the user in one short list, then continue executing it — tick each task the moment it is done (plan_tick). If none exists, say so.',
-  '- Argument "discard": call the plan_discard tool, then tell the user the plan was abandoned and writes are restored.',
-  "- Any other argument: treat it as the task goal — you are now in planning mode for this goal. Follow the plan discipline below end to end.",
-  "",
-  "## Plan discipline",
-  "",
-  "Plans are short-horizon, single-task-goal documents (.opencode/plan/<date>-<slug>.md). The harness enforces the hard parts (draft write-ban, approval/close dialogs); you supply the engineering judgment. Never edit or create plan files by hand — every change goes through the plan_* tools.",
-  "",
-  "1. Reconnaissance and alignment (read-only): explore with read/grep/glob only — all write tools, bash, and subagents are DENIED while a draft exists; do not attempt them, do not ask the user to bypass. Gather concrete evidence with file:line references (verified findings, not guesses). If the goal is ambiguous or leaves meaningful choices open (scope, approach, acceptance), settle them with the user FIRST — 1-3 focused questions — and only write the draft once the shape is agreed; never plan against assumptions the user could settle in one line.",
-  "2. Draft (plan_write): call plan_write with structured fields; the tool renders and validates the fixed sections, so a malformed plan cannot exist. Quality bar: goal = one line, the outcome not the activity; context = verified findings with file:line evidence, including what you ruled out and why; approach = the chosen approach AND at least one rejected alternative with the reason (a plan with no considered alternative is a guess); tasks = 3-8 concrete, independently verifiable steps, each doable in one sitting ('improve the code' is invalid; 'extract the timeout constant into config.ts and default it to 3000' is valid); risks = what could break, blast radius, rollback path; acceptance = criteria verifiable by a command, a file, or an observable behavior (vague criteria will fail the close); nonGoals = explicit out-of-scope items. To revise after feedback, call plan_write again — while in draft it overwrites the same file.",
-  `3. User review, then approval (plan_approve): after plan_write, present the plan in chat — goal, chosen approach with one line why, the numbered task list, the acceptance criteria — then STOP: end your turn and wait. The user owns the review, at their own pace: feedback → revise with plan_write, re-present, and wait again; rejection → /plan discard (or re-plan together); explicit go-ahead (e.g. "execute", "批准", "looks good") → call plan_approve — its confirmation dialog is the final hard gate, and the user's Allow starts execution. Never call plan_approve in the same turn that presents a draft, and never implement before approval succeeds.`,
-  "4. Execution (tick as you go): work tasks in order; call plan_tick with the task number immediately after EACH task's work is actually done — never batch ticks, never tick ahead of reality (tick timestamps are an audit trail). If the plan turns out wrong mid-execution, do not silently improvise: tell the user what changed and either finish the affected task or ask about revising (/plan with the same goal re-enters planning).",
-  "5. Completion (plan_close): when all tasks are ticked, self-check EVERY acceptance criterion with concrete evidence (file:line, command output, test result), then call plan_close with one check per criterion, pass/fail honest — a failing check refuses the close, and that is the design working, not an inconvenience. The user confirms closure in a dialog.",
-  "",
-  "Boundaries: /plan discard abandons the plan (terminal, file kept as history, writes restored); /plan resume continues an unfinished plan from its remaining tasks. Work expected to span multiple sessions or days of multi-file change is spec work (e.g. OpenSpec), not plan work — say so once and let the user choose.",
-  ""
-].join(`
-`);
-var GOAL_COMMAND_TEMPLATE = [
-  '(forge goal harness routing. Argument: "$ARGUMENTS")',
-  "",
-  "Current .opencode/goal/ directory:",
-  "!`ls -1 .opencode/goal 2>/dev/null || echo '(empty)'`",
-  "",
-  "Route on the argument above (decide silently; do not recite this routing text to the user):",
-  "- Argument empty: for every non-terminal goal in the directory above, read its frontmatter and report to the user: path, status (queued/active/paused + stop_reason), revision, turns_used/max_turns budget. Mention queued goals and the /goal next promotion option. Ask whether to resume/promote one or arm something new.",
-  '- Argument "pause": call the goal_pause tool (with the blocker text as `blocker` when there is one), then tell the user the loop is stopped and how to resume.',
-  `- Argument "resume": call the goal_resume tool for the session's paused goal (optionally with addTurns if the user asked for more budget). If no live goal exists but queued goals do, promote the oldest via goal_resume instead. The user confirms in a dialog.`,
-  '- Argument "next": promote the oldest queued goal via the goal_resume tool (no live goal must remain). The user confirms in a dialog.',
-  '- Argument "discard" (also "stop"/"cancel"/"off"): call the goal_discard tool. The user confirms in a dialog.',
-  '- Argument starting with "add " (or the user clearly wants to queue without arming): create a NEW contract from the rest of the argument and call goal_write with arm=false — never revise an existing goal for an add, never omit arm. It becomes a queued, inert goal (no dialog).',
-  '- Any other argument: treat it as a goal statement. Extract contract markers into the structured goal_write fields: --check "cmd" becomes a shell verification item, --contains "file::text" a file-contract item, --success "..." an extra success criterion, --constraint "..." goes into constraints, --non-goal "..." into nonGoals, --max-turns N and --max-minutes N set budgets. Draft a complete contract (goal, criteria, checks, constraints, non-goals), SHOW the verification items verbatim to the user, then call goal_write with arm=true — a confirmation dialog arms the autonomous loop. If this session already has a live goal, say so and offer revise/queue/discard instead.',
-  "",
-  "Goal files are host-managed: never edit or create anything under .opencode/goal/ by hand — contract changes go through goal_write (each revision bump invalidates evidence collected under earlier revisions), state changes through the goal_* tools. Likewise never enter the goal loop or call any goal_* tool unless the user ran /goal or explicitly asked for a goal loop.",
-  ""
-].join(`
-`);
-function isRootish(p) {
-  if (!p)
-    return true;
-  return p === "/" || p === "\\" || /^[A-Za-z]:[\\/]?$/.test(p);
+// src/dispatch-roster.ts
+var DEFAULT_TIERS = {
+  scout: { shape: "readonly", defaultDepth: "low" },
+  build: { shape: "write", defaultDepth: "high" },
+  review: { shape: "readonly", defaultDepth: "high" },
+  quick: { shape: "write", defaultDepth: "off" }
+};
+var TIER_ID_RE = /^[a-z0-9-]+$/;
+function nativeLadder(catalog, identity) {
+  const parsed = parseIdentity(identity);
+  if (!parsed)
+    return null;
+  const entry = catalog.providers?.[parsed.provider]?.models?.[parsed.model];
+  if (!entry)
+    return null;
+  const options = entry.reasoningOptions;
+  return Array.isArray(options) ? [...options] : null;
 }
-function effectiveWorktree(worktree, fallback) {
-  const wt = (worktree ?? "").trim();
-  if (!isRootish(wt))
-    return wt;
-  return (fallback ?? "").trim();
+function identityCost(catalog, identity) {
+  const parsed = parseIdentity(identity);
+  if (!parsed)
+    return;
+  return catalog.providers?.[parsed.provider]?.models?.[parsed.model]?.cost;
 }
-var sessions = new Map;
-var forgeDisabled = false;
-var jobsMode = "auto";
-var jobsKeepBuiltinShell = false;
-var jobsSurviveMode = "never";
-function effectiveSurvive(config2, param) {
-  if (config2 === "deny") {
-    if (param === true)
-      throw new Error("[forge] jobs.survive is explicitly denied in config; a per-call survive=true cannot override it.");
+function parseIdentity(identity) {
+  const slash = identity.indexOf("/");
+  if (slash <= 0 || slash === identity.length - 1)
+    return null;
+  return { provider: identity.slice(0, slash), model: identity.slice(slash + 1) };
+}
+function catalogKnowsIdentity(catalog, identity) {
+  const parsed = parseIdentity(identity);
+  if (!parsed)
     return false;
+  return Boolean(catalog.providers?.[parsed.provider]?.models?.[parsed.model]);
+}
+function buildDispatchConfig(opts) {
+  const findings = [];
+  const catalog = opts.catalog ?? { providers: {} };
+  const tiers = {};
+  for (const [id, def] of Object.entries(DEFAULT_TIERS)) {
+    tiers[id] = { ...def, shape: def.shape ?? "readonly" };
+  }
+  for (const [id, def] of Object.entries(opts.userTiers ?? {})) {
+    if (!TIER_ID_RE.test(id)) {
+      findings.push({
+        level: "warn",
+        code: "tier-id-charset",
+        message: `tier id "${id}" violates [a-z0-9-] (it materializes as forge-<tier> agent ids)`
+      });
+    }
+    const shape = def.shape ?? "readonly";
+    if (def.shape === undefined) {
+      findings.push({
+        level: "warn",
+        code: "shape-defaulted",
+        message: `custom tier "${id}" has no shape; defaulting to readonly (write requires explicit "shape": "write")`
+      });
+    }
+    tiers[id] = { ...def, shape };
+  }
+  const roster = [];
+  for (const entry of opts.userRoster ?? []) {
+    const ladder = nativeLadder(catalog, entry.model);
+    const verified = ladder !== null;
+    if (verified && catalogKnowsIdentity(catalog, entry.model)) {
+      const legal = ladder;
+      if (legal.length === 0) {
+        findings.push({
+          level: "notice",
+          code: "unnamed-levels-accepted",
+          message: `roster entry ${entry.model} has no cataloged named reasoning levels (toggle/budget model); expose accepted verbatim without validation`
+        });
+        roster.push({ model: entry.model, expose: [...entry.expose ?? []], profiles: [...entry.profiles], verified: true });
+      } else {
+        const expose = entry.expose ?? legal;
+        const illegal = expose.filter((d) => !legal.includes(d));
+        if (illegal.length > 0) {
+          findings.push({
+            level: "error",
+            code: "expose-unknown-level",
+            message: `roster entry ${entry.model} exposes unknown level(s) ${illegal.map((d) => `"${d}"`).join(", ")}; legal ladder: ${legal.join(", ")}`
+          });
+        }
+        roster.push({
+          model: entry.model,
+          expose: expose.filter((d) => legal.includes(d)),
+          profiles: [...entry.profiles],
+          verified: true
+        });
+      }
+    } else {
+      findings.push({
+        level: "notice",
+        code: "unverified-identity",
+        message: `roster entry ${entry.model} is not in the models.dev snapshot; expose accepted verbatim without validation`
+      });
+      roster.push({ model: entry.model, expose: [...entry.expose ?? []], profiles: [...entry.profiles], verified: false });
+    }
   }
-  if (param !== undefined)
-    return param;
-  return config2 === "always";
+  const tierIds = new Set(Object.keys(tiers));
+  for (const entry of roster) {
+    if (!opts.configuredIdentities.includes(entry.model)) {
+      findings.push({
+        level: "warn",
+        code: "dead-key",
+        message: `roster entry ${entry.model} is not a configured provider/model identity (dead key)`
+      });
+    }
+    const unknownTiers = entry.profiles.filter((p) => !tierIds.has(p));
+    if (unknownTiers.length > 0) {
+      findings.push({
+        level: "warn",
+        code: "unknown-tier-ref",
+        message: `roster entry ${entry.model} references nonexistent tier(s): ${unknownTiers.join(", ")}`
+      });
+    }
+  }
+  for (const [id, tier] of Object.entries(tiers)) {
+    if (tier.defaultDepth === undefined)
+      continue;
+    const served = roster.some((e) => e.profiles.includes(id) && e.expose.includes(tier.defaultDepth));
+    if (!served) {
+      findings.push({
+        level: "warn",
+        code: "dead-default-depth",
+        message: `tier "${id}" defaultDepth "${tier.defaultDepth}" is exposed by no candidate; tier degrades to depth-required (dispatches must pass depth explicitly)`
+      });
+      tiers[id] = { ...tier, defaultDepth: undefined, depthRequired: true };
+    }
+  }
+  return { roster, tiers, findings };
 }
-var jobFence = null;
-var jobRegistry = null;
-var exitCleanup = null;
-var jobsLifecycleStarted = false;
-function ensureJobLifecycle() {
-  if (jobsLifecycleStarted)
-    return { registry: jobRegistry, fence: jobFence };
-  jobsLifecycleStarted = true;
-  const registry2 = createJobRegistry(registryPathFor(jobLogDir));
-  jobRegistry = registry2;
-  const { adopted, dead } = registry2.rescan(pidAlive, structuralRelocate);
-  for (const entry of adopted) {
-    adoptSurvivor(jobManager, entry, { registry: registry2, logDir: jobLogDir, relocate: structuralRelocate });
+
+// src/dispatch-client.ts
+var CONSECUTIVE_STABLE_POLLS = 2;
+function completionVerdict(prev, cur) {
+  if (!prev) {
+    return { stablePolls: 0, verdict: "waiting", last: { ...cur } };
   }
-  for (const entry of dead) {
-    jobLedgerSink({ at: new Date().toISOString(), kind: "orphan-job", jobId: entry.id, session: entry.ownerSession, detail: `previous-run survivor pid ${entry.pid} is dead (cmd: ${entry.cmd.slice(0, 120)})` });
+  const unchanged = cur.count === prev.last.count && cur.text === prev.last.text;
+  const stablePolls = unchanged ? prev.stablePolls + 1 : 0;
+  if (stablePolls >= CONSECUTIVE_STABLE_POLLS && cur.count > 0) {
+    return { stablePolls, verdict: cur.text.trim() === "" ? "empty" : "complete", last: { ...cur } };
   }
-  jobFence = process.env.FORGE_TEST_NO_FENCE === "1" ? null : createJobFence({
-    onDegrade: (reason) => {
-      jobLedgerSink({ at: new Date().toISOString(), kind: "fence-degraded", jobId: "-", session: "-", detail: reason });
-    }
-  });
-  exitCleanup = createExitCleanup(jobManager, {
-    graceMs: 3000,
-    after: () => {
-      jobFence?.dispose();
-    }
-  });
-  return { registry: registry2, fence: jobFence };
+  return { stablePolls, verdict: "waiting", last: { ...cur } };
 }
-var nativeBackgroundSeen = false;
-function jobStage() {
-  if (jobsMode === "native")
-    return 2;
-  if (jobsMode === "forge")
-    return 0;
-  return nativeBackgroundSeen ? 1 : 0;
+function sumTokens(list) {
+  const total = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+  for (const t of list) {
+    total.input += t.input ?? 0;
+    total.output += t.output ?? 0;
+    total.reasoning += t.reasoning ?? 0;
+    total.cache.read += t.cache?.read ?? 0;
+    total.cache.write += t.cache?.write ?? 0;
+  }
+  return total;
 }
-var jobLogDir = jobsLogDir();
-var jobLedgerPath = join4(jobLogDir, "ledger.jsonl");
-function jobLedgerSink(entry) {
-  try {
-    mkdirSync4(jobLogDir, { recursive: true });
-    if (existsSync3(jobLedgerPath) && statSync3(jobLedgerPath).size > 1e6)
-      writeFileSync4(jobLedgerPath, "");
-    appendFileSync(jobLedgerPath, `${JSON.stringify(entry)}
-`);
-  } catch {}
+function computeCost(tokens, price) {
+  if (!price || typeof price.input !== "number" || typeof price.output !== "number") {
+    return { costUsd: null, note: "price unavailable for this identity (no snapshot price)" };
+  }
+  if (tokens.cache.read > 0 && typeof price.cacheRead !== "number") {
+    return { costUsd: null, note: "price unavailable: cache-read price missing from snapshot" };
+  }
+  if (tokens.cache.write > 0 && typeof price.cacheWrite !== "number") {
+    return { costUsd: null, note: "price unavailable: cache-write price missing from snapshot" };
+  }
+  const usd = (tokens.input * price.input + (tokens.output + tokens.reasoning) * price.output + tokens.cache.read * (price.cacheRead ?? 0) + tokens.cache.write * (price.cacheWrite ?? 0)) / 1e6;
+  return { costUsd: usd };
 }
-var jobManager = createJobManager({ sink: jobLedgerSink });
-var jobClient = null;
-function jobWakeText(job) {
+
+// src/dispatch-prompt.ts
+var COMMON_MANDATES = [
+  "Mandates (non-negotiable):",
+  "- Use workspace-relative paths ONLY. Never write to or read from absolute paths outside this workspace; the workspace root is where you were started, not the filesystem root.",
+  "- If any tool call is refused or denied, report the refusal VERBATIM in your final answer and stop that line of work. Never improvise a workaround around a permission denial.",
+  "- End with conclusions backed by evidence references (file:line, command output, or the exact file/content you produced)."
+].join(`
+`);
+var READONLY_DISCIPLINE = `You are a readonly {agent} worker: you gather, read, run read-only checks, and REPORT. Your restrictions are the design, not obstacles — do not attempt to work around them; report what you found instead.`;
+var WRITE_DISCIPLINE = `You are an {agent} worker executing one scoped task. Do exactly the task, nothing else: no refactoring beyond scope, no unrelated files, no starting side quests.`;
+function composeWorkerPrompt(input) {
+  const discipline = input.shape === "readonly" ? READONLY_DISCIPLINE.replaceAll("{agent}", input.agent) : WRITE_DISCIPLINE.replaceAll("{agent}", input.agent);
   return [
-    `[forge:job-complete] Background job ${job.id} finished (${job.state}${job.exitCode !== null ? `, exit ${job.exitCode}` : ""}).`,
-    `Command: ${job.cmd}`,
-    `Recent output:
-${job.tail.slice(-1500) || "(none)"}`,
-    "Details via forge_jobs (poll/log); the job stays in the registry until cleared."
+    "[forge:dispatch] You were dispatched by the forge main agent as a scoped worker.",
+    discipline,
+    ...input.role ? ["", "Your role:", input.role.trim()] : [],
+    "",
+    "Task:",
+    input.prompt.trim(),
+    "",
+    COMMON_MANDATES,
+    "",
+    "Finish with a single concluding report (the main agent will read only this): what you did, what you found/produced, and the evidence."
   ].join(`
 `);
 }
-async function deliverJobWakes(sessionID) {
-  if (forgeDisabled || jobStage() >= 2)
-    return;
-  if (!jobClient || typeof jobClient.session.promptAsync !== "function")
-    return;
-  for (const job of jobManager.deliverWakesFor(sessionID)) {
-    try {
-      await jobClient.session.promptAsync({ path: { id: sessionID }, body: { parts: [{ type: "text", text: jobWakeText(job) }] } });
-    } catch {
-      job.wakeState = "queued";
+
+// src/dispatch-resolver.ts
+function exposedVocabulary(cfg) {
+  const set2 = new Set;
+  for (const entry of cfg.roster)
+    for (const d of entry.expose)
+      set2.add(d);
+  return [...set2];
+}
+function menuFor(cfg, tierId, depth, exclude, available) {
+  const lines = [];
+  for (const entry of cfg.roster) {
+    if (!entry.profiles.includes(tierId))
+      continue;
+    let reason;
+    if (exclude.includes(entry.model))
+      reason = "excluded after a failed attempt";
+    else if (!available(entry.model))
+      reason = "identity currently unavailable";
+    else if (depth !== undefined && !entry.expose.includes(depth))
+      reason = `depth "${depth}" not exposed`;
+    else
+      reason = "eligible";
+    lines.push({ identity: entry.model, expose: [...entry.expose], verified: entry.verified, reason });
+  }
+  return lines;
+}
+function costRank(catalog, identity) {
+  const cost = identityCost(catalog, identity);
+  if (!cost || typeof cost.input !== "number" || typeof cost.output !== "number")
+    return Number.POSITIVE_INFINITY;
+  return cost.input + cost.output;
+}
+function resolveDispatch(cfg, req, available, catalog = { providers: {} }) {
+  const tier = cfg.tiers[req.profile];
+  if (!tier) {
+    return {
+      ok: false,
+      error: {
+        code: "unknown-tier",
+        message: `unknown tier "${req.profile}"; known tiers: ${Object.keys(cfg.tiers).join(", ")}`,
+        menu: [],
+        vocabulary: exposedVocabulary(cfg)
+      }
+    };
+  }
+  const exclude = req.exclude ?? [];
+  if (tier.model) {
+    const pinnedIdentity = tier.model;
+    const entry = cfg.roster.find((e) => e.model === pinnedIdentity);
+    const expose = entry?.expose ?? [];
+    const menu = [
+      { identity: pinnedIdentity, expose, verified: entry?.verified ?? false, reason: "pinned tier target" }
+    ];
+    if (!available(pinnedIdentity)) {
+      return {
+        ok: false,
+        error: {
+          code: "pin-unavailable",
+          message: `tier "${req.profile}" is pinned to ${pinnedIdentity}, which is currently unavailable; fix or unpin the tier — no fallback model will be used`,
+          menu,
+          vocabulary: exposedVocabulary(cfg)
+        }
+      };
+    }
+    const depth2 = req.depth ?? tier.depth;
+    if (depth2 === undefined) {
+      return {
+        ok: false,
+        error: {
+          code: "depth-required",
+          message: `tier "${req.profile}" is pinned without a depth and none was requested; pass depth explicitly`,
+          menu,
+          vocabulary: exposedVocabulary(cfg)
+        }
+      };
+    }
+    if (!expose.includes(depth2)) {
+      return {
+        ok: false,
+        error: {
+          code: "pin-depth-mismatch",
+          message: `pinned model ${pinnedIdentity} does not expose depth "${depth2}" (expose: ${expose.join(", ") || "none"}); exact match only — no clamping`,
+          menu,
+          vocabulary: exposedVocabulary(cfg)
+        }
+      };
     }
+    return { ok: true, identity: pinnedIdentity, depth: depth2, pinned: true };
+  }
+  const depth = req.depth ?? tier.defaultDepth;
+  if (depth === undefined) {
+    return {
+      ok: false,
+      error: {
+        code: "depth-required",
+        message: `tier "${req.profile}" has no usable default depth (its default was removed at validation); pass depth explicitly`,
+        menu: menuFor(cfg, req.profile, undefined, exclude, available),
+        vocabulary: exposedVocabulary(cfg)
+      }
+    };
+  }
+  const candidates = cfg.roster.map((entry, index) => ({ entry, index })).filter(({ entry }) => entry.profiles.includes(req.profile)).filter(({ entry }) => !exclude.includes(entry.model)).filter(({ entry }) => available(entry.model)).filter(({ entry }) => entry.expose.includes(depth)).sort((a, b) => a.index - b.index || costRank(catalog, a.entry.model) - costRank(catalog, b.entry.model));
+  if (candidates.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "no-candidate",
+        message: `no candidate serves tier "${req.profile}" at depth "${depth}"; pick a depth from the menu's exposures (exact match — the plugin never clamps)`,
+        menu: menuFor(cfg, req.profile, depth, exclude, available),
+        vocabulary: exposedVocabulary(cfg)
+      }
+    };
   }
+  return { ok: true, identity: candidates[0].entry.model, depth, pinned: false };
 }
-async function handoffTarget(sessionID) {
-  if (!jobClient || typeof jobClient.session.get !== "function")
-    return;
-  let current = sessionID;
-  for (let depth = 0;depth < 10; depth++) {
-    try {
-      const info = await jobClient.session.get({ path: { id: current } });
-      if (!info?.parentID)
-        return current === sessionID ? undefined : current;
-      current = info.parentID;
-    } catch {
-      return;
-    }
+function resolveAgent(agents, req, available) {
+  const def = agents[req.agent];
+  if (!def || typeof def !== "object") {
+    return {
+      ok: false,
+      error: {
+        code: "unknown-agent",
+        message: `unknown dispatch agent "${req.agent}"; defined agents: ${Object.keys(agents).join(", ") || "(none)"}`
+      }
+    };
   }
-  return current === sessionID ? undefined : current;
+  if (!def.model || typeof def.model !== "string") {
+    return {
+      ok: false,
+      error: {
+        code: "pin-unavailable",
+        message: `agent "${req.agent}" has no usable model (model: ${JSON.stringify(def.model)}); fix its "model" in forge.json — no fallback model will be used`
+      }
+    };
+  }
+  if (!available(def.model)) {
+    return {
+      ok: false,
+      error: {
+        code: "pin-unavailable",
+        message: `agent "${req.agent}" is pinned to ${def.model}, which is not configured on this host; fix the agent's "model" in forge.json — no fallback model will be used`
+      }
+    };
+  }
+  const depths = Array.isArray(def.depths) ? def.depths : [];
+  if (depths.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "depth-not-in-set",
+        message: `agent "${req.agent}" defines no depths; give it at least one depth in forge.json (canonical words: none, low, medium, high, max — or the model's native level names)`
+      }
+    };
+  }
+  const depth = req.depth ?? depths[0];
+  if (!depths.includes(depth)) {
+    return {
+      ok: false,
+      error: {
+        code: "depth-not-in-set",
+        message: `agent "${req.agent}" does not allow depth "${depth}" (allowed: ${depths.join(", ")}) — exact match only, the plugin never clamps`
+      }
+    };
+  }
+  return { ok: true, model: def.model, depth, def };
 }
-var WRITE_TOOLS = new Set(["write", "edit", "bash", "task", "apply", "applypatch", "patch", "multiedit"]);
-function isWriteTool(name) {
-  const n = name.toLowerCase();
-  return WRITE_TOOLS.has(n) || n.includes("patch");
+
+// src/dispatch-depth.ts
+var META_DEPTHS = ["none", "low", "medium", "high", "max"];
+var BUDGET_TIERS = {
+  low: 8192,
+  medium: 16384,
+  high: 24576,
+  max: 32768
+};
+function noMapping(depth, family, nativeVocabulary, metaAvailable) {
+  return {
+    kind: "no-mapping",
+    family,
+    message: `depth "${depth}" has no native counterpart on this model — the plugin never interpolates. Native levels: ${nativeVocabulary.join(", ") || "(none named)"}. Meta words this model accepts: ${metaAvailable.join(", ") || "(none)"}.`,
+    nativeVocabulary,
+    metaAvailable
+  };
 }
-function nowIso() {
-  return new Date().toISOString();
+function translateDepth(depth, family, ladder) {
+  if (family === "unknown") {
+    return { kind: "not-injected", family, disclose: "not injected (unknown provider shape)" };
+  }
+  if (family === "anthropic") {
+    if (depth === "none")
+      return { kind: "off", family, disclose: "canonical none → native thinking:off" };
+    const budget = BUDGET_TIERS[depth];
+    if (budget !== undefined) {
+      return { kind: "tiered", family, budgetTokens: budget, disclose: `canonical ${depth} → native thinking budget:${budget}` };
+    }
+    return noMapping(depth, family, [], [...META_DEPTHS]);
+  }
+  if (family === "zai") {
+    if (depth === "none")
+      return { kind: "off", family, disclose: "canonical none → native thinking:off" };
+    if (META_DEPTHS.includes(depth)) {
+      return { kind: "toggle-on", family, disclose: `canonical ${depth} → native thinking:on (this provider shape takes a toggle, not a level)` };
+    }
+    return noMapping(depth, family, ["thinking on/off"], [...META_DEPTHS]);
+  }
+  const native = ladder ?? null;
+  if (native !== null && native.includes(depth)) {
+    return { kind: "verbatim", family: "openai", word: depth, disclose: META_DEPTHS.includes(depth) ? "verbatim" : `verbatim (native word "${depth}")` };
+  }
+  if (native !== null && native.length > 0 && META_DEPTHS.includes(depth)) {
+    return noMapping(depth, family, native, META_DEPTHS.filter((w) => native.includes(w)));
+  }
+  return { kind: "verbatim", family: "openai", word: depth, disclose: `verbatim (unverified — ${native === null ? "catalog does not know this model" : `catalog ladder does not list "${depth}"`}; the provider judges)` };
 }
-function planDirOf(worktree) {
-  return join4(worktree, ".opencode", "plan");
+function applyDepthTranslation(options, t) {
+  if (t.kind === "verbatim") {
+    options.reasoningEffort = t.word;
+  } else if (t.kind === "tiered") {
+    options.thinking = { type: "enabled", budget_tokens: t.budgetTokens };
+  } else if (t.kind === "off") {
+    options.thinking = { type: "disabled" };
+  } else if (t.kind === "toggle-on") {
+    options.thinking = { type: "enabled" };
+  }
 }
-function readPlanDir(worktree) {
-  const dir = planDirOf(worktree);
-  if (!existsSync3(dir))
-    return [];
-  return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((name) => ({ name, text: readFileSync6(join4(dir, name), "utf8") }));
+
+// src/dispatch-tiers.ts
+var MUTATING_TOOLS = ["write", "edit", "bash"];
+var TIER_PROMPTS = {
+  scout: "You are forge-scout, a readonly reconnaissance worker. Search, read, and run read-only commands; report findings with file:line evidence. You never modify anything — write tools are denied by design.",
+  build: "You are forge-build, an implementation worker. Execute the dispatched task exactly: minimal, focused changes with tests where the task implies them. Do not expand scope.",
+  review: "You are forge-review, a readonly review worker. Read the diff or files under review, run read-only checks/tests, and report findings as a prioritized list with file:line evidence and a single-line verdict. Write tools are denied by design.",
+  quick: "You are forge-quick, a mechanical small-change worker. Make the smallest correct edit the task names (rename, constant, one-liner fix). No refactoring, no drive-by improvements."
+};
+function tierAgentPrompt(tierId) {
+  return TIER_PROMPTS[tierId] ?? `You are forge-${tierId}, a dispatched worker. Execute the dispatched task exactly as scoped.`;
+}
+var ROLE_PROMPTS = {
+  research: "You are a research worker: search, read, and run read-only checks to answer the dispatched question. Report findings as a compact brief with sources and file:line evidence; state plainly what could not be verified.",
+  review: "You are a review worker: read the diff or files under review, run read-only checks/tests, and report findings as a prioritized list, each with file:line evidence and a concrete fix suggestion. End with a single-line verdict."
+};
+function rolePromptFor(agentId, def) {
+  if (def?.prompt && def.prompt.trim().length > 0)
+    return def.prompt;
+  return ROLE_PROMPTS[agentId] ?? `You are forge-${agentId}, a dispatched worker. Execute the dispatched task exactly as scoped.`;
+}
+function forgeAgentDef(agentId, def) {
+  const permission = { task: "deny" };
+  const shape = def.shape ?? "readonly";
+  if (shape === "readonly") {
+    for (const t of MUTATING_TOOLS)
+      permission[t] = "deny";
+  }
+  Object.assign(permission, def.permission ?? {});
+  permission.task = "deny";
+  const shapeLine = shape === "readonly" ? "Readonly agent: mutating tools are denied by design — report findings, never work around restrictions." : "Write agent: execute the scoped task with minimal, focused changes.";
+  return {
+    description: `forge dispatch agent "${agentId}" (${shape}) — spawned by forge_dispatch, not user-facing.`,
+    mode: "subagent",
+    hidden: true,
+    prompt: `${rolePromptFor(agentId, def)}
+
+${shapeLine}`,
+    permission
+  };
+}
+function tierAgentDef(tierId, tier) {
+  const permission = { task: "deny" };
+  if (tier.shape === "readonly") {
+    for (const t of MUTATING_TOOLS)
+      permission[t] = "deny";
+  }
+  const shapeLine = tier.shape === "readonly" ? "Readonly tier: mutating tools are denied by design — report findings, never work around restrictions." : "Write tier: execute the scoped task with minimal, focused changes.";
+  const defaultLine = tier.defaultDepth ? ` Default reasoning depth: ${tier.defaultDepth}.` : "";
+  return {
+    description: `forge dispatch tier "${tierId}" (${tier.shape}) — spawned by forge_dispatch, not user-facing.${defaultLine}`,
+    mode: "subagent",
+    hidden: true,
+    prompt: `${tierAgentPrompt(tierId)}
+
+${shapeLine}`,
+    permission
+  };
+}
+
+// src/dispatch-engine.ts
+var DEFAULT_DISPATCH_TIMEOUT_MS = 600000;
+var MAX_DISPATCH_TIMEOUT_MS = 600000;
+var DEFAULT_MAX_CONCURRENT = 4;
+var DEFAULT_POLL_INTERVAL_MS = 2000;
+
+class DispatchError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "DispatchError";
+    this.code = code;
+  }
+}
+function textOf(messages) {
+  const assistant = [...messages].reverse().find((m) => (m.info?.role ?? m.role) === "assistant");
+  if (!assistant)
+    return "";
+  return (assistant.parts ?? []).filter((p) => p.type === "text" || typeof p.text === "string").map((p) => p.text ?? "").join(`
+`).trim();
+}
+function tokensOf(messages) {
+  return messages.filter((m) => (m.info?.role ?? m.role) === "assistant" && m.info?.tokens).map((m) => m.info.tokens);
+}
+function createDispatchEngine(deps) {
+  const maxConcurrent = deps.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+  const timeoutMs = Math.min(deps.timeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS, MAX_DISPATCH_TIMEOUT_MS);
+  const pollIntervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const inFlight = new Set;
+  let seq = 0;
+  const api2 = async (path, init) => {
+    const res = await deps.fetcher(`${deps.serverUrl}${path}`, {
+      ...init,
+      headers: { "content-type": "application/json", ...init?.headers ?? {} }
+    });
+    const text = await res.text();
+    if (!res.ok)
+      throw new DispatchError(`${init?.method ?? "GET"} ${path} -> ${res.status}: ${text.slice(0, 300)}`, "host-error");
+    return text ? JSON.parse(text) : undefined;
+  };
+  const fetchMessages = async (sessionID) => {
+    const list = await api2(`/session/${sessionID}/message`);
+    return Array.isArray(list) ? list : [];
+  };
+  const killControls = new Map;
+  const resolveOrThrow = (profile, depth, exclude) => {
+    const r = resolveDispatch(deps.cfg, { profile, depth, exclude }, deps.available, deps.catalog);
+    if (!r.ok) {
+      deps.sink({ ts: new Date().toISOString(), event: "resolve-error", tier: profile, outcome: r.error.code, note: r.error.message });
+      throw new DispatchError(`${r.error.message}
+Menu:
+${r.error.menu.map((m) => `- ${m.identity} expose=[${m.expose.join(", ") || "none"}] ${m.reason}`).join(`
+`)}
+Vocabulary: ${r.error.vocabulary.join(", ") || "(none)"}`, r.error.code);
+    }
+    return r;
+  };
+  const resolveForThrow = (req, exclude) => {
+    if (deps.legacy && req.agent in deps.cfg.tiers) {
+      const r = resolveOrThrow(req.agent, req.depth, exclude);
+      return {
+        model: r.identity,
+        depth: r.depth,
+        agentPath: false,
+        shape: deps.cfg.tiers[req.agent]?.shape ?? "readonly",
+        role: tierAgentPrompt(req.agent)
+      };
+    }
+    const a = resolveAgent(deps.agents(), { agent: req.agent, depth: req.depth }, deps.available);
+    if (!a.ok) {
+      deps.sink({ ts: new Date().toISOString(), event: "resolve-error", tier: req.agent, agent: req.agent, outcome: a.error.code, note: a.error.message });
+      throw new DispatchError(a.error.message, a.error.code);
+    }
+    return {
+      model: a.model,
+      depth: a.depth,
+      agentPath: true,
+      shape: a.def?.shape === "write" ? "write" : "readonly",
+      role: rolePromptFor(req.agent, a.def)
+    };
+  };
+  const translationFor = (identity, depth) => {
+    const providerID = identity.slice(0, identity.indexOf("/"));
+    const family = deps.providerFamily(providerID) ?? "unknown";
+    const ladder = nativeLadder(deps.catalog, identity);
+    return translateDepth(depth, family, ladder);
+  };
+  const translationOrThrow = (identity, depth) => {
+    const translation = translationFor(identity, depth);
+    if (translation.kind === "no-mapping") {
+      deps.sink({ ts: new Date().toISOString(), event: "resolve-error", agent: undefined, identity, depth, outcome: "no-native-mapping", note: translation.message });
+      throw new DispatchError(translation.message, "no-native-mapping");
+    }
+    return translation;
+  };
+  async function runAttempt(r, req, parentSessionID, t0, ctl, onChild, dispatchId) {
+    const providerID = r.model.slice(0, r.model.indexOf("/"));
+    const translation = translationOrThrow(r.model, r.depth);
+    let childID = "";
+    const dir = encodeURIComponent(deps.workspace);
+    let created;
+    try {
+      created = await api2(`/session?directory=${dir}`, { method: "POST", body: JSON.stringify(parentSessionID ? { parentID: parentSessionID } : {}) });
+    } catch {
+      created = await api2(`/session?directory=${dir}`, { method: "POST", body: JSON.stringify({}) });
+    }
+    childID = created?.id ?? "";
+    if (!childID)
+      throw new DispatchError("host returned no session id for the child session", "host-error");
+    onChild?.(childID);
+    deps.onDepth(childID, translation);
+    const depthInjected = translation.disclose;
+    let deadlineHit = false;
+    const deadlinePromise = deps.sleep(Math.max(timeoutMs - (deps.now() - t0), 0)).then(() => {
+      deadlineHit = true;
+    });
+    const turnPost = api2(`/session/${childID}/message`, {
+      method: "POST",
+      body: JSON.stringify({
+        model: { providerID, modelID: r.model.slice(r.model.indexOf("/") + 1) },
+        agent: `forge-${req.agent}`,
+        parts: [{ type: "text", text: composeWorkerPrompt({ prompt: req.prompt, agent: req.agent, shape: r.shape, ...r.role ? { role: r.role } : {} }) }]
+      })
+    });
+    turnPost.catch(() => {});
+    try {
+      await Promise.race([turnPost, deadlinePromise]);
+      if (deadlineHit && deps.now() - t0 >= timeoutMs) {
+        const elapsed = deps.now() - t0;
+        deps.sink({
+          ts: new Date().toISOString(),
+          event: "timeout",
+          tier: req.agent,
+          agent: req.agent,
+          identity: r.model,
+          depth: r.depth,
+          sessionID: childID,
+          durationMs: elapsed,
+          ...dispatchId !== undefined ? { dispatchId, parentSessionID: parentSessionID ?? "" } : {}
+        });
+        throw new DispatchError(`forge_dispatch timed out after ${elapsed}ms (deadline ${timeoutMs}ms). Partial state: child session ${childID} is left for the host to reclaim; its transcript remains queryable via the host API.`, "timeout");
+      }
+      await turnPost;
+    } catch (e) {
+      if (e instanceof DispatchError)
+        throw e;
+      deps.sink({
+        ts: new Date().toISOString(),
+        event: "transport-interrupted",
+        tier: req.agent,
+        agent: req.agent,
+        identity: r.model,
+        depth: r.depth,
+        sessionID: childID,
+        durationMs: deps.now() - t0,
+        note: e instanceof Error ? e.message : String(e),
+        ...dispatchId !== undefined ? { dispatchId, parentSessionID: parentSessionID ?? "" } : {}
+      });
+    }
+    let poll = null;
+    let messages = [];
+    for (;; ) {
+      if (ctl?.fired)
+        throw new KillRequested;
+      const elapsed = deps.now() - t0;
+      if (elapsed >= timeoutMs) {
+        deps.sink({
+          ts: new Date().toISOString(),
+          event: "timeout",
+          tier: req.agent,
+          agent: req.agent,
+          identity: r.model,
+          depth: r.depth,
+          sessionID: childID,
+          durationMs: elapsed,
+          ...dispatchId !== undefined ? { dispatchId, parentSessionID: parentSessionID ?? "" } : {}
+        });
+        throw new DispatchError(`forge_dispatch timed out after ${elapsed}ms (deadline ${timeoutMs}ms). Partial state: child session ${childID} is left for the host to reclaim; its transcript remains queryable via the host API.`, "timeout");
+      }
+      await deps.sleep(pollIntervalMs);
+      messages = await (ctl ? Promise.race([fetchMessages(childID), ctl.promise.then(() => [])]) : fetchMessages(childID));
+      if (ctl?.fired)
+        throw new KillRequested;
+      poll = completionVerdict(poll, { count: messages.length, text: textOf(messages) });
+      if (poll.verdict === "complete" || poll.verdict === "empty")
+        break;
+    }
+    const durationMs = deps.now() - t0;
+    if (poll.verdict === "empty") {
+      deps.sink({
+        ts: new Date().toISOString(),
+        event: "empty-response",
+        tier: req.agent,
+        agent: req.agent,
+        identity: r.model,
+        depth: r.depth,
+        sessionID: childID,
+        durationMs,
+        ...dispatchId !== undefined ? { dispatchId, parentSessionID: parentSessionID ?? "" } : {}
+      });
+      throw new DispatchError(`child session ${childID} returned an empty response (0-token assistant message). This is a known quirk of keyless endpoints combined with restricted tiers — see the README dispatch notes. The dispatch is NOT counted as success.`, "empty-response");
+    }
+    const tokens = sumTokens(tokensOf(messages));
+    const price = priceFor(deps.catalog, r.model);
+    const cost = computeCost(tokens, price?.spec ?? null);
+    const result = {
+      agent: req.agent,
+      requested: { agent: req.agent, depth: req.depth },
+      actual: { model: r.model, depth: r.depth },
+      sessionID: childID,
+      durationMs,
+      tokens,
+      costUsd: cost.costUsd,
+      ...cost.note ? { costNote: cost.note } : {},
+      ...price?.label ? { priceSnapshot: price.label } : {},
+      text: textOf(messages),
+      depthTranslation: depthInjected
+    };
+    deps.sink({
+      ts: new Date().toISOString(),
+      event: "completed",
+      tier: req.agent,
+      agent: req.agent,
+      identity: r.model,
+      depth: r.depth,
+      sessionID: childID,
+      outcome: "completed",
+      tokens,
+      costUsd: cost.costUsd,
+      durationMs,
+      ...dispatchId !== undefined ? { dispatchId, parentSessionID: parentSessionID ?? "" } : {}
+    });
+    return result;
+  }
+  function bgTerminal(reg, dispatchId, identity, req, t0, e) {
+    let entrySessionID = "";
+    let parentSessionID = "";
+    try {
+      const entry = reg.get(dispatchId);
+      entrySessionID = entry.sessionID;
+      parentSessionID = entry.parentSessionID;
+    } catch {}
+    const durationMs = deps.now() - t0;
+    const report = {
+      agent: req.agent,
+      requested: { agent: req.agent, depth: req.depth },
+      actual: { model: identity, depth: null },
+      sessionID: entrySessionID,
+      outcome: "error",
+      durationMs,
+      error: e instanceof Error ? e.message : String(e)
+    };
+    if (e instanceof DispatchError && e.code === "timeout") {
+      report.outcome = "timeout";
+      reg.markTimeout(dispatchId, report);
+      deps.onTerminal?.(parentSessionID);
+      return;
+    }
+    deps.sink({
+      ts: new Date().toISOString(),
+      event: "error",
+      tier: req.agent,
+      agent: req.agent,
+      identity,
+      outcome: "error",
+      sessionID: entrySessionID,
+      durationMs,
+      note: report.error,
+      dispatchId,
+      parentSessionID
+    });
+    reg.markError(dispatchId, report);
+    deps.onTerminal?.(parentSessionID);
+  }
+  async function dispatch(req, parentSessionID, opts) {
+    const t0 = deps.now();
+    if (inFlight.size >= maxConcurrent) {
+      deps.sink({ ts: new Date().toISOString(), event: "refused-cap", tier: req.agent, agent: req.agent, note: `${inFlight.size} in flight` });
+      throw new DispatchError(`forge_dispatch refused: ${inFlight.size} dispatches already in flight (cap ${maxConcurrent}). Wait for a completion and retry.`, "cap-refused");
+    }
+    const bg = opts?.background === true;
+    if (bg && !deps.registry)
+      throw new DispatchError("background dispatch requires the dispatch registry (internal error)", "host-error");
+    const first = resolveForThrow(req, undefined);
+    translationOrThrow(first.model, first.depth);
+    if (bg) {
+      const reg = deps.registry;
+      const { dispatchId } = reg.submit({ sessionID: "", identity: first.model, depth: first.depth, tier: req.agent, parentSessionID: parentSessionID ?? "" });
+      let fire = () => {};
+      const promise2 = new Promise((res) => {
+        fire = res;
+      });
+      const ctl = { fired: false, promise: promise2, fire: () => {
+        ctl.fired = true;
+        fire();
+      } };
+      killControls.set(dispatchId, ctl);
+      const slot = `d${++seq}`;
+      inFlight.add(slot);
+      (async () => {
+        try {
+          if (reg.get(dispatchId).state === "killed")
+            return;
+          reg.markRunning(dispatchId);
+          let current = first;
+          let exclude2 = undefined;
+          for (let attemptNo = 0;; attemptNo++) {
+            try {
+              const result = await runAttempt(current, req, parentSessionID, t0, ctl, (sid) => {
+                try {
+                  reg.get(dispatchId).sessionID = sid;
+                } catch {}
+              }, dispatchId);
+              if (reg.get(dispatchId).state === "killed") {
+                reg.noteLateCompletion(dispatchId, result);
+                deps.sink({ ts: new Date().toISOString(), event: "kill-late-completion", tier: req.agent, agent: req.agent, identity: current.model, sessionID: result.sessionID, outcome: "kill-late-completion" });
+              } else {
+                reg.markCompleted(dispatchId, result);
+                deps.onTerminal?.(reg.get(dispatchId).parentSessionID);
+              }
+              return;
+            } catch (e) {
+              if (e instanceof KillRequested)
+                return;
+              if (reg.get(dispatchId).state === "killed")
+                return;
+              const retryable = !current.agentPath && e instanceof DispatchError && (e.code === "host-error" || e.code === "empty-response");
+              const alternative = retryable ? resolveDispatch(deps.cfg, { profile: req.agent, depth: req.depth, exclude: [current.model] }, deps.available, deps.catalog) : { ok: false };
+              if (!retryable || attemptNo > 0 || !alternative.ok) {
+                bgTerminal(reg, dispatchId, current.model, req, t0, e);
+                return;
+              }
+              deps.sink({ ts: new Date().toISOString(), event: "retry-excluded", tier: req.agent, agent: req.agent, identity: current.model, note: `${current.model}: ${e.code}` });
+              exclude2 = [current.model];
+              current = resolveForThrow(req, exclude2);
+              reg.get(dispatchId).identity = current.model;
+            }
+          }
+        } finally {
+          inFlight.delete(slot);
+          killControls.delete(dispatchId);
+        }
+      })();
+      return {
+        dispatchId,
+        agent: req.agent,
+        requested: { agent: req.agent, depth: req.depth },
+        resolved: first.model,
+        depth: first.depth,
+        queuedAt: reg.get(dispatchId).queuedAt
+      };
+    }
+    let exclude = undefined;
+    for (let attemptNo = 0;; attemptNo++) {
+      const r = attemptNo === 0 ? first : resolveForThrow(req, exclude);
+      const slot = `d${++seq}`;
+      inFlight.add(slot);
+      try {
+        return await runAttempt(r, req, parentSessionID, t0, undefined, undefined);
+      } catch (e) {
+        const identity = r.model;
+        const retryable = !r.agentPath && e instanceof DispatchError && (e.code === "host-error" || e.code === "empty-response");
+        if (!retryable || attemptNo > 0)
+          throw e;
+        const alternative = resolveDispatch(deps.cfg, { profile: req.agent, depth: req.depth, exclude: [identity] }, deps.available, deps.catalog);
+        if (!alternative.ok)
+          throw e;
+        deps.sink({ ts: new Date().toISOString(), event: "retry-excluded", tier: req.agent, agent: req.agent, identity, note: `${identity}: ${e.code}` });
+        exclude = [identity];
+      } finally {
+        inFlight.delete(slot);
+      }
+    }
+  }
+  return {
+    dispatch,
+    kill: (dispatchId) => {
+      const reg = deps.registry;
+      if (!reg)
+        throw new DispatchError("forge_dispatch_kill unavailable: no dispatch registry (internal error)", "kill-failed");
+      const e = reg.get(dispatchId);
+      if (e.state === "completed" || e.state === "timeout" || e.state === "error") {
+        throw new DispatchError(`forge_dispatch_kill refused: dispatch ${dispatchId} already ${e.state}; use forge_dispatch_list for its result.`, "kill-failed");
+      }
+      if (e.state === "killed")
+        throw new DispatchError(`dispatch ${dispatchId} is already killed.`, "kill-failed");
+      reg.markKilled(dispatchId);
+      deps.sink({ ts: new Date().toISOString(), event: "killed", tier: e.tier, identity: e.identity, depth: e.depth ?? undefined, sessionID: e.sessionID, outcome: "killed" });
+      killControls.get(dispatchId)?.fire();
+    },
+    inFlightCount: () => inFlight.size,
+    inFlightIDs: () => [...inFlight],
+    dispose: () => {
+      for (const slot of inFlight) {
+        deps.sink({ ts: new Date().toISOString(), event: "lost-on-exit", note: `dispatch ${slot} in flight at host exit` });
+      }
+      inFlight.clear();
+    }
+  };
+}
+
+class KillRequested extends Error {
+  constructor() {
+    super("kill requested");
+  }
+}
+function priceFor(catalog, identity) {
+  const slash = identity.indexOf("/");
+  if (slash <= 0)
+    return null;
+  const model = catalog.providers?.[identity.slice(0, slash)]?.models?.[identity.slice(slash + 1)];
+  const cost = model?.cost;
+  if (!cost)
+    return null;
+  return {
+    spec: {
+      input: cost.input,
+      output: cost.output,
+      cacheRead: cost.cache_read,
+      cacheWrite: cost.cache_write
+    },
+    label: "models.dev snapshot"
+  };
+}
+
+// src/dispatch-ledger.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+var DISPATCH_LEDGER_MAX_ENTRIES = 200;
+var DISPATCH_LEDGER_MAX_BYTES = 1e6;
+function createDispatchLedger(logPath, maxEntries = DISPATCH_LEDGER_MAX_ENTRIES, maxBytes = DISPATCH_LEDGER_MAX_BYTES) {
+  const append = (entry) => {
+    try {
+      mkdirSync4(dirname3(logPath), { recursive: true });
+      let lines = [];
+      try {
+        lines = readFileSync6(logPath, "utf8").split(`
+`).filter((l) => l.trim().length > 0);
+      } catch {}
+      if (lines.length >= maxEntries)
+        lines = lines.slice(lines.length - maxEntries + 1);
+      lines.push(JSON.stringify(entry));
+      let text = lines.join(`
+`) + `
+`;
+      if (text.length > maxBytes) {
+        const keep = Math.max(1, Math.floor(maxEntries / 2));
+        text = lines.slice(-keep).join(`
+`) + `
+`;
+      }
+      writeFileSync4(logPath, text, "utf8");
+    } catch {}
+  };
+  const entries = () => {
+    try {
+      return readFileSync6(logPath, "utf8").split(`
+`).filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  };
+  return { append, entries, path: logPath };
+}
+
+// src/dispatch-registry.ts
+var TERMINAL_CAP = 50;
+function createDispatchRegistry() {
+  const entries = new Map;
+  let seq = 0;
+  const fail = (msg) => {
+    throw new Error(`[forge:dispatch-registry] ${msg}`);
+  };
+  const isTerminal2 = (st) => st === "completed" || st === "timeout" || st === "killed" || st === "error";
+  return {
+    submit(entry) {
+      const dispatchId = `bg-${++seq}`;
+      entries.set(dispatchId, {
+        ...entry,
+        dispatchId,
+        background: true,
+        queuedAt: entry.queuedAt ?? new Date().toISOString(),
+        state: "queued",
+        delivered: false
+      });
+      return { dispatchId };
+    },
+    get(dispatchId) {
+      const e = entries.get(dispatchId);
+      if (!e)
+        throw new Error(`[forge:dispatch-registry] unknown dispatch id "${dispatchId}"`);
+      return e;
+    },
+    markRunning(dispatchId) {
+      const e = this.get(dispatchId);
+      if (e.state !== "queued")
+        fail(`illegal transition ${e.state} → running for ${dispatchId}`);
+      e.state = "running";
+      return e;
+    },
+    markCompleted(dispatchId, result) {
+      return this.terminate(dispatchId, "completed", result);
+    },
+    markTimeout(dispatchId, report) {
+      return this.terminate(dispatchId, "timeout", report);
+    },
+    markError(dispatchId, report) {
+      return this.terminate(dispatchId, "error", report);
+    },
+    markKilled(dispatchId) {
+      return this.terminate(dispatchId, "killed");
+    },
+    noteLateCompletion(dispatchId, result) {
+      const e = this.get(dispatchId);
+      if (e.state !== "killed")
+        fail(`late completion only makes sense on a killed dispatch (${dispatchId} is ${e.state})`);
+      e.lateCompletion = result;
+    },
+    terminate(dispatchId, state, result) {
+      const e = this.get(dispatchId);
+      if (isTerminal2(e.state))
+        fail(`illegal transition ${e.state} → ${state} for ${dispatchId}`);
+      e.state = state;
+      if (result !== undefined)
+        e.result = result;
+      return e;
+    },
+    takeUndelivered(parentSessionID) {
+      const out = [];
+      for (const e of entries.values()) {
+        if (parentSessionID !== undefined && e.parentSessionID !== parentSessionID)
+          continue;
+        if (isTerminal2(e.state) && !e.delivered && e.state !== "killed") {
+          e.delivered = true;
+          out.push(e);
+        }
+      }
+      return out;
+    },
+    list() {
+      const inFlight = [];
+      const terminal = [];
+      for (const e of entries.values()) {
+        if (isTerminal2(e.state))
+          terminal.push(e);
+        else
+          inFlight.push(e);
+      }
+      return { inFlight, terminal: terminal.slice(-TERMINAL_CAP) };
+    }
+  };
+}
+
+// src/crew-gate.ts
+var CREW_DISPATCH_EVENTS = new Set(["completed", "timeout", "error", "killed", "empty-response"]);
+var DISPATCH_ID = /bg-\d+/g;
+function validateCrewReport(report, ledgerRows, crew) {
+  const gaps = [];
+  if (!Array.isArray(report) || report.length === 0) {
+    return { ok: false, gaps: ["the report lists no subtasks — a crew completion report must cover every subtask"], dispatchIds: [] };
+  }
+  const rowById = new Map;
+  for (const row of ledgerRows) {
+    if (row.parentSessionID !== crew.sessionID)
+      continue;
+    if (row.ts < crew.startedAt)
+      continue;
+    if (row.event === "validation" || row.event === "resolve-error" || row.event === "refused-cap" || row.event === "models-dev-degraded" || row.event === "retry-excluded" || row.event === "lost-on-exit" || row.event === "kill-late-completion" || row.event === "transport-interrupted")
+      continue;
+    if (CREW_DISPATCH_EVENTS.has(row.event) && row.dispatchId)
+      rowById.set(row.dispatchId, row);
+  }
+  const referenced = new Set;
+  report.forEach((sub, i) => {
+    const label = sub?.title?.trim() || `subtask #${i + 1}`;
+    const verdict = String(sub?.verdict ?? "").toUpperCase();
+    if (!sub?.title?.trim())
+      gaps.push(`${label}: missing title`);
+    if (verdict !== "PASS" && verdict !== "FAIL")
+      gaps.push(`${label}: verdict must be PASS or FAIL (got "${sub?.verdict ?? ""}")`);
+    const ids = [...String(sub?.evidence ?? "").matchAll(DISPATCH_ID)].map((m) => m[0]);
+    if (!String(sub?.evidence ?? "").trim())
+      gaps.push(`${label}: missing evidence reference`);
+    else if (ids.length === 0)
+      gaps.push(`${label}: evidence must reference a dispatch id (bg-N) that exists in the dispatch ledger`);
+    for (const id of ids) {
+      if (referenced.has(id))
+        gaps.push(`${label}: dispatch ${id} is already cited by another subtask — each dispatch belongs to exactly one verdict`);
+      referenced.add(id);
+      const row = rowById.get(id);
+      if (!row)
+        gaps.push(`${label}: dispatch ${id} has no ledger row for this crew (fabricated, stale, or pre-crew)`);
+      else if (verdict === "PASS" && row.event !== "completed") {
+        gaps.push(`${label}: marked PASS but dispatch ${id} ended ${row.event} — a subtask whose attempt and retry both failed must be marked FAIL with both reports visible`);
+      }
+    }
+    if (verdict === "FAIL" && (!Array.isArray(sub?.attempts) || sub.attempts.length < 2)) {
+      gaps.push(`${label}: FAIL requires both failure reports (the attempt and the one retry) in attempts[]`);
+    }
+  });
+  for (const [id, row] of rowById) {
+    if (!referenced.has(id))
+      gaps.push(`dispatch ${id} (${row.event}, ${row.ts}) has no verdict in the report — a dispatched subtask was silently dropped`);
+  }
+  return { ok: gaps.length === 0, gaps, dispatchIds: [...rowById.keys()] };
+}
+
+// src/forge-config.ts
+import { readFileSync as readFileSync7, statSync as statSync3 } from "node:fs";
+function sanitizeJsonc(text) {
+  const out = [];
+  let i = 0;
+  const n = text.length;
+  let pendingComma = false;
+  const flushComma = (nextChar) => {
+    if (pendingComma) {
+      if (nextChar !== "}" && nextChar !== "]")
+        out.push(",");
+      pendingComma = false;
+    }
+  };
+  while (i < n) {
+    const c = text[i];
+    const d = i + 1 < n ? text[i + 1] : "";
+    if (c === "/" && d === "/") {
+      while (i < n && text[i] !== `
+`) {
+        out.push(" ");
+        i++;
+      }
+      continue;
+    }
+    if (c === "/" && d === "*") {
+      out.push(" ", " ");
+      i += 2;
+      while (i < n && !(text[i] === "*" && i + 1 < n && text[i + 1] === "/")) {
+        out.push(text[i] === `
+` ? `
+` : " ");
+        i++;
+      }
+      if (i < n) {
+        out.push(" ", " ");
+        i += 2;
+      }
+      continue;
+    }
+    if (c === '"') {
+      flushComma(c);
+      out.push(c);
+      i++;
+      while (i < n && text[i] !== '"') {
+        out.push(text[i]);
+        if (text[i] === "\\") {
+          i++;
+          if (i < n)
+            out.push(text[i]);
+        }
+        i++;
+      }
+      if (i < n) {
+        out.push('"');
+        i++;
+      }
+      continue;
+    }
+    if (c === ",") {
+      pendingComma = true;
+      out.push(" ");
+      i++;
+      continue;
+    }
+    if (c === " " || c === "\t" || c === `
+` || c === "\r") {
+      out.push(c);
+      i++;
+      continue;
+    }
+    flushComma(c);
+    out.push(c);
+    i++;
+  }
+  return out.join("");
+}
+function lineColumnAt(text, offset) {
+  let line = 1;
+  let lineStart = 0;
+  for (let i = 0;i < offset && i < text.length; i++) {
+    if (text[i] === `
+`) {
+      line++;
+      lineStart = i + 1;
+    }
+  }
+  return { line, column: offset - lineStart + 1 };
+}
+function locateJsonError(text) {
+  const n = text.length;
+  let i = 0;
+  const stack = [];
+  const ws = () => {
+    while (i < n && (text[i] === " " || text[i] === "\t" || text[i] === `
+` || text[i] === "\r"))
+      i++;
+  };
+  const fail = (why) => {
+    const { line, column } = lineColumnAt(text, Math.min(i, n));
+    return { message: `${why} (line ${line}, column ${column})`, line, column };
+  };
+  const skipString = () => {
+    if (text[i] !== '"')
+      return null;
+    i++;
+    while (i < n && text[i] !== '"') {
+      if (text[i] === "\\")
+        i++;
+      i++;
+    }
+    if (i >= n)
+      return "unterminated string";
+    i++;
+    return null;
+  };
+  let expectValue = true;
+  ws();
+  if (i >= n)
+    return { message: "empty document", line: 1, column: 1 };
+  for (;; ) {
+    ws();
+    if (i >= n)
+      return stack.length === 0 ? null : fail("unexpected end of document");
+    const top = stack[stack.length - 1];
+    const c = text[i];
+    if (expectValue) {
+      if (c === "{") {
+        stack.push("o");
+        i++;
+        expectValue = false;
+        continue;
+      }
+      if (c === "[") {
+        stack.push("a");
+        i++;
+        continue;
+      }
+      if (c === "}") {
+        return fail(`expected a value before '}'`);
+      }
+      if (c === "]") {
+        if (top === "a" || top === "av") {
+          stack.pop();
+          expectValue = false;
+          if (stack.length === 0) {
+            ws();
+            return i >= n ? null : fail(`unexpected token '${text[i]}' after top-level value`);
+          }
+          i++;
+          continue;
+        }
+        return fail(`unexpected ']'`);
+      }
+      if (c === '"') {
+        const err = skipString();
+        if (err)
+          return fail(err);
+        expectValue = false;
+        if (top === "o")
+          stack[stack.length - 1] = "ov";
+        if (top === "a")
+          stack[stack.length - 1] = "av";
+        continue;
+      }
+      if (c === "-" || c >= "0" && c <= "9" || c === "t" || c === "f" || c === "n") {
+        while (i < n && !`{}[],:" 	
+\r`.includes(text[i]))
+          i++;
+        expectValue = false;
+        if (top === "a")
+          stack[stack.length - 1] = "av";
+        continue;
+      }
+      return fail(`unexpected token '${c}'`);
+    }
+    if (top === "o") {
+      if (c === '"') {
+        const err = skipString();
+        if (err)
+          return fail(err);
+        ws();
+        if (text[i] !== ":")
+          return fail("expected ':' after object key");
+        i++;
+        expectValue = true;
+        continue;
+      }
+      return fail(`expected '"' or '}' in object, got '${c}'`);
+    }
+    if (top === "ov" || top === "av") {
+      if (c === ",") {
+        i++;
+        expectValue = true;
+        if (top === "ov")
+          stack[stack.length - 1] = "o";
+        else
+          stack[stack.length - 1] = "a";
+        continue;
+      }
+      if (top === "ov" && c === "}" || top === "av" && c === "]") {
+        stack.pop();
+        if (stack.length === 0) {
+          i++;
+          ws();
+          return i >= n ? null : fail(`unexpected token '${text[i]}' after top-level value`);
+        }
+        i++;
+        continue;
+      }
+      return fail(`expected ',' or closing bracket, got '${c}'`);
+    }
+    if (c === "]") {
+      stack.pop();
+      if (stack.length === 0) {
+        i++;
+        ws();
+        return i >= n ? null : fail(`unexpected token '${text[i]}' after top-level value`);
+      }
+      i++;
+      continue;
+    }
+    return fail(`unexpected token '${c}'`);
+  }
+}
+function parseForgeJsonc(text) {
+  const sanitized = sanitizeJsonc(text);
+  let parsed;
+  try {
+    parsed = JSON.parse(sanitized);
+  } catch {
+    const located = locateJsonError(sanitized);
+    return {
+      ok: false,
+      error: located ?? { message: "invalid JSON", line: 1, column: 1 }
+    };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { ok: false, error: { message: "forge.json top level must be an object", line: 1, column: 1 } };
+  }
+  const agents = parsed.agents;
+  if (agents === undefined)
+    return { ok: true, config: { agents: {} } };
+  if (typeof agents !== "object" || agents === null || Array.isArray(agents)) {
+    return { ok: false, error: { message: 'forge.json "agents" must be an object mapping agent ids to definitions', line: 1, column: 1 } };
+  }
+  return { ok: true, config: { agents } };
+}
+function forgeRecipe(input) {
+  const suggested = input.detectedIdentities[0] ?? "provider/model";
+  const identityLines = input.detectedIdentities.length > 0 ? input.detectedIdentities.map((id) => `   - ${id}`).join(`
+`) : "   (none detected — check the provider section of the host's opencode config)";
+  const template = `{
+  // forge dispatch agents — save the file; changes apply on the next dispatch, no restart
+  "agents": {
+    "research": {
+      "model": "${suggested}", // exact "provider/model" string, pick from the detected list above
+      "depths": ["low", "medium"], // first entry is the default; canonical words: none, low, medium, high, max — or the model's native level names, passed through verbatim
+      // "prompt": "optional role prompt riding inside the discipline wrapper",
+      // "shape": "write", // default readonly denies mutating tools; write agents need this
+      // "permission": { "bash": "deny" } // optional override of the shape-derived permission
+    }
+  }
+}`;
+  return [
+    "[forge dispatch onboarding recipe]",
+    'The dispatch agent you called is pinned to the placeholder model "Local/GPT Luna" — forge.json is not configured. Steps:',
+    "",
+    "1. Detected configured identities (use one as the exact model string):",
+    identityLines,
+    "",
+    "2. Create ONE of these files (project-level wins; a single file fully applies — never merged):",
+    `   - ${input.projectPath}  (project-level, versionable, team-shared)`,
+    `   - ${input.globalPath}  (global)`,
+    "",
+    "3. Copy-paste template (JSONC — comments allowed) and edit model/depths:",
+    "",
+    template,
+    "",
+    '4. Verify: call the forge_dispatch tool again with agent "research" and a depth from its depths — the report shows the actual model and the depth translation.',
+    "",
+    '5. Extending: more agents are more entries under "agents"; agents that edit files need "shape": "write"; an explicit "permission" map overrides the shape-derived defaults — "task" is always denied, recursive dispatch stays impossible.'
+  ].join(`
+`);
+}
+var PLACEHOLDER_IDENTITY = "Local/GPT Luna";
+var SEED_AGENTS = {
+  research: { model: PLACEHOLDER_IDENTITY, depths: ["low", "medium"], shape: "readonly" },
+  review: { model: PLACEHOLDER_IDENTITY, depths: ["medium", "high", "max"], shape: "readonly" }
+};
+function forgeConfigPaths(opts) {
+  const sep2 = opts.projectDir?.includes("\\") && !opts.projectDir?.includes("/") ? "\\" : "/";
+  const project = opts.projectDir ? `${opts.projectDir}${sep2}.opencode${sep2}forge.json` : "";
+  const global = opts.homeDir ? `${opts.homeDir}${sep2}.config${sep2}opencode${sep2}forge.json` : "";
+  return { project, global };
+}
+function createForgeConfigLoader(deps) {
+  const stat = deps.stat ?? ((path) => {
+    try {
+      const s = statSync3(path);
+      return { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      return null;
+    }
+  });
+  const readFile = deps.readFile ?? ((path) => readFileSync7(path, "utf8"));
+  const paths = forgeConfigPaths({ projectDir: deps.projectDir, homeDir: deps.homeDir });
+  const cache = new Map;
+  const readCandidate = (path, source) => {
+    const st = stat(path);
+    if (st === null) {
+      cache.delete(path);
+      return null;
+    }
+    const hit = cache.get(path);
+    if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size)
+      return hit.result;
+    const text = readFile(path);
+    const parsed = parseForgeJsonc(text);
+    let result;
+    if (!parsed.ok) {
+      result = {
+        agents: { ...SEED_AGENTS },
+        source: "seed",
+        path: null,
+        findings: [
+          {
+            level: "error",
+            code: "config-parse-error",
+            message: `${path}: ${parsed.error.message}${parsed.error.line !== undefined ? ` (line ${parsed.error.line}, column ${parsed.error.column})` : ""} — fell back to the built-in seed`
+          }
+        ]
+      };
+    } else {
+      result = { agents: parsed.config.agents, source, path, findings: [] };
+    }
+    cache.set(path, { mtimeMs: st.mtimeMs, size: st.size, result });
+    return result;
+  };
+  return {
+    load() {
+      const project = paths.project ? readCandidate(paths.project, "project") : null;
+      if (project)
+        return project;
+      const global = paths.global ? readCandidate(paths.global, "global") : null;
+      if (global)
+        return global;
+      return {
+        agents: { ...SEED_AGENTS },
+        source: "seed",
+        path: null,
+        findings: [
+          {
+            level: "notice",
+            code: "dispatch-unconfigured",
+            message: "forge dispatch is unconfigured (no forge.json found): every forge_dispatch call will fail with the configuration recipe. Create .opencode/forge.json (project) or ~/.config/opencode/forge.json (global), or ask your session AI to configure dispatch — the recipe in the dispatch error tells it exactly what to write."
+          }
+        ]
+      };
+    }
+  };
+}
+
+// src/models-dev.ts
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join4 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
+var DEFAULT_MODELS_DEV_URL = "https://models.dev/api.json";
+function modelsDevCacheDir(base) {
+  return join4(base ?? join4(tmpdir2(), "opencode-forge"), "models-dev");
+}
+function namedLevels(rows) {
+  const out = [];
+  for (const r of rows) {
+    if (r && typeof r === "object" && r.type === "effort") {
+      const values = r.values;
+      if (Array.isArray(values)) {
+        for (const v of values)
+          if (typeof v === "string")
+            out.push(v);
+      }
+    }
+  }
+  return out;
+}
+function reduceModelsDev(raw) {
+  const catalog = { providers: {} };
+  const providers = raw?.constructor === Object ? raw : null;
+  if (!providers)
+    return catalog;
+  for (const [providerID, provider] of Object.entries(providers)) {
+    const models = provider.models;
+    if (!models || typeof models !== "object")
+      continue;
+    const out = { models: {} };
+    for (const [modelID, model] of Object.entries(models)) {
+      const m = model;
+      const options = Array.isArray(m.reasoning_options) ? namedLevels(m.reasoning_options) : undefined;
+      const cost = m.cost && typeof m.cost === "object" ? m.cost : undefined;
+      out.models[modelID] = {
+        ...options ? { reasoningOptions: options } : {},
+        ...cost ? { cost } : {}
+      };
+    }
+    catalog.providers[providerID] = out;
+  }
+  return catalog;
+}
+async function loadModelsDevSnapshot(opts = {}) {
+  const url2 = opts.url ?? process.env.OPENCODE_MODELS_URL ?? DEFAULT_MODELS_DEV_URL;
+  const cacheDir = modelsDevCacheDir(opts.cacheDir);
+  const cacheFile = join4(cacheDir, "snapshot.json");
+  const fetcher = opts.fetcher;
+  if (fetcher) {
+    try {
+      const res = await fetcher(url2, { signal: AbortSignal.timeout(opts.timeoutMs ?? 8000) });
+      if (res.ok)
+        return { catalog: reduceModelsDev(JSON.parse(await res.text())), degraded: false, source: url2 };
+    } catch {}
+    return { catalog: { providers: {} }, degraded: true, source: "fetch-failed" };
+  }
+  try {
+    const res = await fetch(url2, { signal: AbortSignal.timeout(opts.timeoutMs ?? 8000) });
+    if (res.ok) {
+      const catalog = reduceModelsDev(JSON.parse(await res.text()));
+      try {
+        mkdirSync5(cacheDir, { recursive: true });
+        writeFileSync5(cacheFile, JSON.stringify(catalog));
+      } catch {}
+      return { catalog, degraded: false, source: url2 };
+    }
+  } catch {}
+  try {
+    const cached2 = JSON.parse(readFileSync8(cacheFile, "utf8"));
+    if (cached2 && typeof cached2 === "object" && cached2.providers)
+      return { catalog: cached2, degraded: true, source: "cache" };
+  } catch {}
+  return { catalog: { providers: {} }, degraded: true, source: "unavailable" };
+}
+
+// plugin.ts
+var FORGE_AGENT = "forge";
+var FORGE_PROMPT = `You are forge — the single general-purpose coding agent. You handle every task directly: exploration, planning, implementation, and verification. There is no agent switching.
+
+Workflow modes are strictly user-initiated. Never enter plan or goal mode — and never call a plan_* or goal_* tool — unless the user ran /plan or /goal, unmistakably asked for that mode (e.g. "plan first", "set a goal"), or the session already carries a [forge:plan-notice] / [forge:goal-notice] for a mode they started. Ordinary task requests are normal work. Mode-specific rules arrive with those commands and notices; when a notice is present, follow it.`;
+var PLAN_COMMAND_TEMPLATE = [
+  '(forge plan harness routing. Argument: "$ARGUMENTS")',
+  "",
+  "Current .opencode/plan/ directory:",
+  "!`ls -1 .opencode/plan 2>/dev/null || echo '(empty)'`",
+  "",
+  "Route on the argument above (decide silently; do not recite this routing text to the user):",
+  "- Argument empty: for every non-terminal plan (status draft or approved) in the directory above, read its frontmatter and task checkboxes, then report to the user: path, status, progress (x/y ticked). Ask whether to resume one or start something new.",
+  '- Argument "resume": pick the most recently updated non-terminal plan, summarize its remaining unticked tasks to the user in one short list, then continue executing it — tick each task the moment it is done (plan_tick). If none exists, say so.',
+  '- Argument "discard": call the plan_discard tool, then tell the user the plan was abandoned and writes are restored.',
+  "- Any other argument: treat it as the task goal — you are now in planning mode for this goal. Follow the plan discipline below end to end.",
+  "",
+  "## Plan discipline",
+  "",
+  "Plans are short-horizon, single-task-goal documents (.opencode/plan/<date>-<slug>.md). The harness enforces the hard parts (draft write-ban, approval/close dialogs); you supply the engineering judgment. Never edit or create plan files by hand — every change goes through the plan_* tools.",
+  "",
+  "1. Reconnaissance and alignment (read-only): explore with read/grep/glob only — all write tools, bash, and subagents are DENIED while a draft exists; do not attempt them, do not ask the user to bypass. Gather concrete evidence with file:line references (verified findings, not guesses). If the goal is ambiguous or leaves meaningful choices open (scope, approach, acceptance), settle them with the user FIRST — 1-3 focused questions — and only write the draft once the shape is agreed; never plan against assumptions the user could settle in one line.",
+  "2. Draft (plan_write): call plan_write with structured fields; the tool renders and validates the fixed sections, so a malformed plan cannot exist. Quality bar: goal = one line, the outcome not the activity; context = verified findings with file:line evidence, including what you ruled out and why; approach = the chosen approach AND at least one rejected alternative with the reason (a plan with no considered alternative is a guess); tasks = 3-8 concrete, independently verifiable steps, each doable in one sitting ('improve the code' is invalid; 'extract the timeout constant into config.ts and default it to 3000' is valid); risks = what could break, blast radius, rollback path; acceptance = criteria verifiable by a command, a file, or an observable behavior (vague criteria will fail the close); nonGoals = explicit out-of-scope items. To revise after feedback, call plan_write again — while in draft it overwrites the same file.",
+  `3. User review, then approval (plan_approve): after plan_write, present the plan in chat — goal, chosen approach with one line why, the numbered task list, the acceptance criteria — then STOP: end your turn and wait. The user owns the review, at their own pace: feedback → revise with plan_write, re-present, and wait again; rejection → /plan discard (or re-plan together); explicit go-ahead (e.g. "execute", "批准", "looks good") → call plan_approve — its confirmation dialog is the final hard gate, and the user's Allow starts execution. Never call plan_approve in the same turn that presents a draft, and never implement before approval succeeds.`,
+  "4. Execution (tick as you go): work tasks in order; call plan_tick with the task number immediately after EACH task's work is actually done — never batch ticks, never tick ahead of reality (tick timestamps are an audit trail). If the plan turns out wrong mid-execution, do not silently improvise: tell the user what changed and either finish the affected task or ask about revising (/plan with the same goal re-enters planning).",
+  "5. Completion (plan_close): when all tasks are ticked, self-check EVERY acceptance criterion with concrete evidence (file:line, command output, test result), then call plan_close with one check per criterion, pass/fail honest — a failing check refuses the close, and that is the design working, not an inconvenience. The user confirms closure in a dialog.",
+  "",
+  "Boundaries: /plan discard abandons the plan (terminal, file kept as history, writes restored); /plan resume continues an unfinished plan from its remaining tasks. Work expected to span multiple sessions or days of multi-file change is spec work (e.g. OpenSpec), not plan work — say so once and let the user choose.",
+  ""
+].join(`
+`);
+var GOAL_COMMAND_TEMPLATE = [
+  '(forge goal harness routing. Argument: "$ARGUMENTS")',
+  "",
+  "Current .opencode/goal/ directory:",
+  "!`ls -1 .opencode/goal 2>/dev/null || echo '(empty)'`",
+  "",
+  "Route on the argument above (decide silently; do not recite this routing text to the user):",
+  "- Argument empty: for every non-terminal goal in the directory above, read its frontmatter and report to the user: path, status (queued/active/paused + stop_reason), revision, turns_used/max_turns budget. Mention queued goals and the /goal next promotion option. Ask whether to resume/promote one or arm something new.",
+  '- Argument "pause": call the goal_pause tool (with the blocker text as `blocker` when there is one), then tell the user the loop is stopped and how to resume.',
+  `- Argument "resume": call the goal_resume tool for the session's paused goal (optionally with addTurns if the user asked for more budget). If no live goal exists but queued goals do, promote the oldest via goal_resume instead. The user confirms in a dialog.`,
+  '- Argument "next": promote the oldest queued goal via the goal_resume tool (no live goal must remain). The user confirms in a dialog.',
+  '- Argument "discard" (also "stop"/"cancel"/"off"): call the goal_discard tool. The user confirms in a dialog.',
+  '- Argument starting with "add " (or the user clearly wants to queue without arming): create a NEW contract from the rest of the argument and call goal_write with arm=false — never revise an existing goal for an add, never omit arm. It becomes a queued, inert goal (no dialog).',
+  '- Any other argument: treat it as a goal statement. Extract contract markers into the structured goal_write fields: --check "cmd" becomes a shell verification item, --contains "file::text" a file-contract item, --success "..." an extra success criterion, --constraint "..." goes into constraints, --non-goal "..." into nonGoals, --max-turns N and --max-minutes N set budgets. Draft a complete contract (goal, criteria, checks, constraints, non-goals), SHOW the verification items verbatim to the user, then call goal_write with arm=true — a confirmation dialog arms the autonomous loop. If this session already has a live goal, say so and offer revise/queue/discard instead.',
+  "",
+  "Goal files are host-managed: never edit or create anything under .opencode/goal/ by hand — contract changes go through goal_write (each revision bump invalidates evidence collected under earlier revisions), state changes through the goal_* tools. Likewise never enter the goal loop or call any goal_* tool unless the user ran /goal or explicitly asked for a goal loop.",
+  ""
+].join(`
+`);
+function isRootish(p) {
+  if (!p)
+    return true;
+  return p === "/" || p === "\\" || /^[A-Za-z]:[\\/]?$/.test(p);
+}
+function effectiveWorktree(worktree, fallback) {
+  const wt = (worktree ?? "").trim();
+  if (!isRootish(wt))
+    return wt;
+  return (fallback ?? "").trim();
+}
+var sessions = new Map;
+var forgeDisabled = false;
+var dispatchDisabled = false;
+var dispatchMaxConcurrent = 4;
+var dispatchTimeoutMs = 600000;
+var dispatchBase = null;
+var forgeLoader = null;
+var forgeLoaderDir = null;
+var forgeConfigState = null;
+var lastDetectedIdentities = [];
+var activeDispatchEngine = null;
+var dispatchLogDir = join5(tmpdir3(), "opencode-forge", "dispatch");
+var dispatchLedger = createDispatchLedger(join5(dispatchLogDir, "ledger.jsonl"));
+var activeDispatchRegistry = null;
+var dispatchClient = null;
+var dispatchWakeTimers = new Map;
+var crews = new Map;
+var dispatchDepths = new Map;
+var OPENAI_FAMILY = new Set(["openai", "opencode", "openrouter", "groq", "xai", "azure", "github-copilot", "deepseek", "together", "vercel", "opus"]);
+var ANTHROPIC_FAMILY = new Set(["anthropic"]);
+var ZAI_FAMILY = new Set(["zai", "zai-coding-plan"]);
+function dispatchProviderFamily(providerID) {
+  if (OPENAI_FAMILY.has(providerID))
+    return "openai";
+  if (ANTHROPIC_FAMILY.has(providerID))
+    return "anthropic";
+  if (ZAI_FAMILY.has(providerID))
+    return "zai";
+  return null;
+}
+function queueDispatchDepth(sessionID, translation) {
+  const key = (t) => t.kind === "verbatim" ? `verbatim:${t.word}` : t.kind === "tiered" ? `tiered:${t.budgetTokens}` : t.kind;
+  const existing = dispatchDepths.get(sessionID);
+  if (existing)
+    return key(existing) === key(translation);
+  dispatchDepths.set(sessionID, translation);
+  return true;
+}
+function configuredIdentitiesOf(cfg, catalog) {
+  const providers = cfg.provider ?? {};
+  const identities = [];
+  for (const [providerID, provider] of Object.entries(providers)) {
+    const modelKeys = provider?.models ? Object.keys(provider.models) : null;
+    if (modelKeys && modelKeys.length > 0) {
+      for (const m of modelKeys)
+        identities.push(`${providerID}/${m}`);
+    } else {
+      const catModels = catalog.providers?.[providerID]?.models ?? {};
+      const ids = Object.keys(catModels);
+      if (ids.length > 0)
+        for (const m of ids)
+          identities.push(`${providerID}/${m}`);
+    }
+  }
+  return identities;
+}
+var jobsMode = "auto";
+var jobsKeepBuiltinShell = false;
+var jobsSurviveMode = "never";
+function effectiveSurvive(config2, param) {
+  if (config2 === "deny") {
+    if (param === true)
+      throw new Error("[forge] jobs.survive is explicitly denied in config; a per-call survive=true cannot override it.");
+    return false;
+  }
+  if (param !== undefined)
+    return param;
+  return config2 === "always";
+}
+var jobFence = null;
+var jobRegistry = null;
+var exitCleanup = null;
+var jobsLifecycleStarted = false;
+function ensureJobLifecycle() {
+  if (jobsLifecycleStarted)
+    return { registry: jobRegistry, fence: jobFence };
+  jobsLifecycleStarted = true;
+  const registry2 = createJobRegistry(registryPathFor(jobLogDir));
+  jobRegistry = registry2;
+  const { adopted, dead } = registry2.rescan(pidAlive, structuralRelocate);
+  for (const entry of adopted) {
+    adoptSurvivor(jobManager, entry, { registry: registry2, logDir: jobLogDir, relocate: structuralRelocate });
+  }
+  for (const entry of dead) {
+    jobLedgerSink({ at: new Date().toISOString(), kind: "orphan-job", jobId: entry.id, session: entry.ownerSession, detail: `previous-run survivor pid ${entry.pid} is dead (cmd: ${entry.cmd.slice(0, 120)})` });
+  }
+  jobFence = process.env.FORGE_TEST_NO_FENCE === "1" ? null : createJobFence({
+    onDegrade: (reason) => {
+      jobLedgerSink({ at: new Date().toISOString(), kind: "fence-degraded", jobId: "-", session: "-", detail: reason });
+    }
+  });
+  exitCleanup = createExitCleanup(jobManager, {
+    graceMs: 3000,
+    after: () => {
+      jobFence?.dispose();
+    }
+  });
+  return { registry: registry2, fence: jobFence };
+}
+var nativeBackgroundSeen = false;
+function jobStage() {
+  if (jobsMode === "native")
+    return 2;
+  if (jobsMode === "forge")
+    return 0;
+  return nativeBackgroundSeen ? 1 : 0;
+}
+var jobLogDir = jobsLogDir();
+var jobLedgerPath = join5(jobLogDir, "ledger.jsonl");
+function jobLedgerSink(entry) {
+  try {
+    mkdirSync6(jobLogDir, { recursive: true });
+    if (existsSync3(jobLedgerPath) && statSync4(jobLedgerPath).size > 1e6)
+      writeFileSync6(jobLedgerPath, "");
+    appendFileSync(jobLedgerPath, `${JSON.stringify(entry)}
+`);
+  } catch {}
+}
+var jobManager = createJobManager({ sink: jobLedgerSink });
+var jobClient = null;
+function jobWakeText(job) {
+  return [
+    `[forge:job-complete] Background job ${job.id} finished (${job.state}${job.exitCode !== null ? `, exit ${job.exitCode}` : ""}).`,
+    `Command: ${job.cmd}`,
+    `Recent output:
+${job.tail.slice(-1500) || "(none)"}`,
+    "Details via forge_jobs (poll/log); the job stays in the registry until cleared."
+  ].join(`
+`);
+}
+async function deliverJobWakes(sessionID) {
+  if (forgeDisabled || jobStage() >= 2)
+    return;
+  if (!jobClient || typeof jobClient.session.promptAsync !== "function")
+    return;
+  for (const job of jobManager.deliverWakesFor(sessionID)) {
+    try {
+      await jobClient.session.promptAsync({ path: { id: sessionID }, body: { parts: [{ type: "text", text: jobWakeText(job) }] } });
+    } catch {
+      job.wakeState = "queued";
+    }
+  }
+}
+async function handoffTarget(sessionID) {
+  if (!jobClient || typeof jobClient.session.get !== "function")
+    return;
+  let current = sessionID;
+  for (let depth = 0;depth < 10; depth++) {
+    try {
+      const info = await jobClient.session.get({ path: { id: current } });
+      if (!info?.parentID)
+        return current === sessionID ? undefined : current;
+      current = info.parentID;
+    } catch {
+      return;
+    }
+  }
+  return current === sessionID ? undefined : current;
+}
+var WRITE_TOOLS = new Set(["write", "edit", "bash", "task", "apply", "applypatch", "patch", "multiedit"]);
+function isWriteTool(name) {
+  const n = name.toLowerCase();
+  return WRITE_TOOLS.has(n) || n.includes("patch");
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+function planDirOf(worktree) {
+  return join5(worktree, ".opencode", "plan");
+}
+function readPlanDir(worktree) {
+  const dir = planDirOf(worktree);
+  if (!existsSync3(dir))
+    return [];
+  return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((name) => ({ name, text: readFileSync9(join5(dir, name), "utf8") }));
 }
 function ensureSession(sessionID, worktree) {
   const existing = sessions.get(sessionID);
@@ -14921,7 +16506,7 @@ function worktreeFor(context) {
 }
 function resolveActivePlan(state) {
   if (state.planPath && existsSync3(state.planPath)) {
-    const doc2 = parsePlanLoose(readFileSync6(state.planPath, "utf8"));
+    const doc2 = parsePlanLoose(readFileSync9(state.planPath, "utf8"));
     if (doc2 && !isTerminal(doc2.status))
       return { path: state.planPath, doc: doc2 };
     state.planPath = undefined;
@@ -14929,7 +16514,7 @@ function resolveActivePlan(state) {
   const ranked = rankActivePlans(readPlanDir(state.worktree));
   if (ranked.length === 0)
     return null;
-  const path = join4(planDirOf(state.worktree), ranked[0].name);
+  const path = join5(planDirOf(state.worktree), ranked[0].name);
   state.planPath = path;
   return { path, doc: ranked[0].doc };
 }
@@ -14963,12 +16548,12 @@ var planWriteTool = tool({
       throw new PlanError(`A plan in ${active.doc.status} state is already active (${relFrom(state.worktree, active.path)}). Finish it with plan_close, or /plan discard it before planning something new.`);
     } else {
       const dir = planDirOf(state.worktree);
-      mkdirSync4(dir, { recursive: true });
-      path = join4(dir, planFileName(localDate(), slugify(args.goal), readdirSync4(dir).filter((f) => f.endsWith(".md"))));
+      mkdirSync6(dir, { recursive: true });
+      path = join5(dir, planFileName(localDate(), slugify(args.goal), readdirSync4(dir).filter((f) => f.endsWith(".md"))));
       mode = "created";
     }
     const text = renderPlan(args, now, created);
-    writeFileSync4(path, text);
+    writeFileSync6(path, text);
     state.planPath = path;
     const doc2 = parsePlan(text);
     context.metadata({ title: `${mode === "created" ? "Create" : "Revise"} plan: ${doc2.goal}` });
@@ -14996,8 +16581,8 @@ var planTickTool = tool({
     if (active.doc.status !== "approved") {
       throw new PlanError(`Plan status is ${active.doc.status}; only an approved plan can be ticked. Get user approval via plan_approve first.`);
     }
-    const next = tickTask(readFileSync6(active.path, "utf8"), args.n, nowIso());
-    writeFileSync4(active.path, next);
+    const next = tickTask(readFileSync9(active.path, "utf8"), args.n, nowIso());
+    writeFileSync6(active.path, next);
     const doc2 = parsePlan(next);
     const p = progressOf(doc2);
     context.metadata({ title: `Tick task ${args.n} (${p.done}/${p.total})` });
@@ -15024,7 +16609,7 @@ var planApproveTool = tool({
       throw new PlanError(`Plan status is ${active.doc.status}; only a draft plan can be approved.`);
     }
     await gate(context.ask, "plan_approve", `Approve plan: ${active.doc.goal}`);
-    writeFileSync4(active.path, transitionStatus(readFileSync6(active.path, "utf8"), "approved", nowIso()));
+    writeFileSync6(active.path, transitionStatus(readFileSync9(active.path, "utf8"), "approved", nowIso()));
     context.metadata({ title: `Plan approved: ${active.doc.goal}` });
     return {
       title: "plan approved",
@@ -15057,7 +16642,7 @@ var planCloseTool = tool({
 Fix the implementation and retry, or revise the plan first.`);
     }
     await gate(context.ask, "plan_close", `Close plan: ${active.doc.goal}`);
-    writeFileSync4(active.path, transitionStatus(readFileSync6(active.path, "utf8"), "done", nowIso()));
+    writeFileSync6(active.path, transitionStatus(readFileSync9(active.path, "utf8"), "done", nowIso()));
     context.metadata({ title: `Plan done: ${active.doc.goal}` });
     return {
       title: "plan done",
@@ -15075,31 +16660,31 @@ var planDiscardTool = tool({
     const active = resolveActivePlan(state);
     if (!active)
       throw new PlanError("No plan to abandon in this workspace.");
-    writeFileSync4(active.path, transitionStatus(readFileSync6(active.path, "utf8"), "abandoned", nowIso()));
+    writeFileSync6(active.path, transitionStatus(readFileSync9(active.path, "utf8"), "abandoned", nowIso()));
     state.planPath = undefined;
     context.metadata({ title: `Plan abandoned: ${active.doc.goal}` });
     return { title: "plan abandoned", output: `Plan abandoned: ${relFrom(state.worktree, active.path)}. Write operations are restored.` };
   }
 });
 function goalDirOf(worktree) {
-  return join4(worktree, ".opencode", "goal");
+  return join5(worktree, ".opencode", "goal");
 }
 function readGoalDir(worktree) {
   const dir = goalDirOf(worktree);
   if (!existsSync3(dir))
     return [];
-  return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((name) => ({ name, text: readFileSync6(join4(dir, name), "utf8") }));
+  return readdirSync4(dir).filter((f) => f.endsWith(".md")).map((name) => ({ name, text: readFileSync9(join5(dir, name), "utf8") }));
 }
 function resolveSessionGoal(state) {
   if (state.goalPath && existsSync3(state.goalPath)) {
-    const doc2 = parseGoalLoose(readFileSync6(state.goalPath, "utf8"));
+    const doc2 = parseGoalLoose(readFileSync9(state.goalPath, "utf8"));
     if (doc2 && !isGoalTerminal(doc2.status))
       return { path: state.goalPath, doc: doc2 };
     state.goalPath = undefined;
   }
   const live = rankLiveGoals(readGoalDir(state.worktree))[0];
   if (live) {
-    const path = join4(goalDirOf(state.worktree), live.name);
+    const path = join5(goalDirOf(state.worktree), live.name);
     state.goalPath = path;
     return { path, doc: live.doc };
   }
@@ -15196,9 +16781,9 @@ var goalWriteTool = tool({
       await gate(context.ask, "goal_write", `Arm goal: ${args.goal}`);
     }
     const dir = goalDirOf(state.worktree);
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync6(dir, { recursive: true });
     const name = goalFileName(localDateNow(), slugifyGoal(args.goal), readdirSync4(dir).filter((f) => f.endsWith(".md")));
-    const path = join4(dir, name);
+    const path = join5(dir, name);
     const text = renderGoal(input, {
       now,
       status: arm ? "active" : "queued",
@@ -15238,7 +16823,7 @@ var goalCheckTool = tool({
       o.index = selected[i].n;
     });
     const runId = `${nowIso()}-${Math.random().toString(36).slice(2, 8)}`;
-    const next = appendCheckLog(readFileSync6(goal.path, "utf8"), runId, outcomes, nowIso());
+    const next = appendCheckLog(readFileSync9(goal.path, "utf8"), runId, outcomes, nowIso());
     atomicWrite(goal.path, next);
     const ok = outcomesAllOk(outcomes);
     context.metadata({ title: `goal_check: ${outcomes.filter((o) => o.ok).length}/${outcomes.length} pass` });
@@ -15272,7 +16857,7 @@ var goalCompleteTool = tool({
     const failures = outcomes.filter((o) => !o.ok);
     if (failures.length > 0) {
       const runId2 = `${nowIso()}-${Math.random().toString(36).slice(2, 8)}`;
-      atomicWrite(goal.path, appendCheckLog(readFileSync6(goal.path, "utf8"), runId2, outcomes, nowIso()));
+      atomicWrite(goal.path, appendCheckLog(readFileSync9(goal.path, "utf8"), runId2, outcomes, nowIso()));
       throw new GoalError(`Completion gate: verification re-run failed (fail-closed). The goal stays active.
 ${formatOutcomes(failures)}
 Fix the work and retry; recorded results never substitute for the gate's own re-run.`);
@@ -15285,7 +16870,7 @@ Fix the work and retry; recorded results never substitute for the gate's own re-
     }
     await gate(context.ask, "goal_complete", `Complete goal: ${goal.doc.goal}`);
     const runId = `${nowIso()}-${Math.random().toString(36).slice(2, 8)}`;
-    let text = appendCheckLog(readFileSync6(goal.path, "utf8"), runId, outcomes, nowIso());
+    let text = appendCheckLog(readFileSync9(goal.path, "utf8"), runId, outcomes, nowIso());
     text = transitionGoal(text, "completed", nowIso());
     atomicWrite(goal.path, text);
     context.metadata({ title: `Goal completed: ${goal.doc.goal}` });
@@ -15307,7 +16892,7 @@ var goalPauseTool = tool({
       throw new GoalError(`No active goal to pause (status: ${goal?.doc.status ?? "none"}).`);
     }
     const stopReason = args.blocker ? "blocker" : "user";
-    atomicWrite(goal.path, transitionGoal(readFileSync6(goal.path, "utf8"), "paused", nowIso(), { stopReason }));
+    atomicWrite(goal.path, transitionGoal(readFileSync9(goal.path, "utf8"), "paused", nowIso(), { stopReason }));
     engineForgetSession(context.sessionID);
     context.metadata({ title: `Goal paused (${stopReason}): ${goal.doc.goal}` });
     return {
@@ -15327,7 +16912,7 @@ var goalResumeTool = tool({
     if (!goal || goal.doc.status === "queued") {
       const oldest = rankQueuedGoals(readGoalDir(state.worktree))[0];
       if (oldest) {
-        const path = join4(goalDirOf(state.worktree), oldest.name);
+        const path = join5(goalDirOf(state.worktree), oldest.name);
         state.goalPath = path;
         goal = { path, doc: oldest.doc };
       }
@@ -15337,7 +16922,7 @@ var goalResumeTool = tool({
     }
     const promoting = goal.doc.status === "queued";
     await gate(context.ask, "goal_resume", `${promoting ? "Promote" : "Resume"} goal: ${goal.doc.goal}`);
-    let text = readFileSync6(goal.path, "utf8");
+    let text = readFileSync9(goal.path, "utf8");
     if (args.addTurns)
       text = bumpBudget(text, args.addTurns, nowIso());
     text = transitionGoal(text, "active", nowIso(), { session: context.sessionID });
@@ -15363,7 +16948,7 @@ var goalDiscardTool = tool({
     if (!goal)
       throw new GoalError("No goal to discard in this workspace.");
     await gate(context.ask, "goal_discard", `Discard goal: ${goal.doc.goal}`);
-    atomicWrite(goal.path, transitionGoal(readFileSync6(goal.path, "utf8"), "abandoned", nowIso()));
+    atomicWrite(goal.path, transitionGoal(readFileSync9(goal.path, "utf8"), "abandoned", nowIso()));
     state.goalPath = undefined;
     engineForgetSession(context.sessionID);
     context.metadata({ title: `Goal abandoned: ${goal.doc.goal}` });
@@ -15410,7 +16995,7 @@ var forgeShellTool = tool({
       }
     }
     const { registry: registry2, fence } = ensureJobLifecycle();
-    const cwd = args.workdir ? isAbsolute(args.workdir) ? args.workdir : join4(state.worktree, args.workdir) : state.worktree;
+    const cwd = args.workdir ? isAbsolute(args.workdir) ? args.workdir : join5(state.worktree, args.workdir) : state.worktree;
     const started = startJob(jobManager, {
       cmd: args.command,
       cwd,
@@ -15556,7 +17141,323 @@ ${p.newOutput || "(none in this window)"}`,
     jobManager.handoff(args.jobId, target);
     return {
       title: `${job.id} handed off`,
-      output: `[forge:job] ${job.id} promoted to plugin-global scope${target ? ` and rebound to root session ${target}` : ""}; it now survives this session's end.`
+      output: `[forge:job] ${job.id}: promoted to plugin-global scope${target ? ` and rebound to root session ${target}` : ""}; it now survives this session's end.`
+    };
+  }
+});
+function dispatchWakeDelay(idleDriven) {
+  const env = Number(process.env.FORGE_DISPATCH_WAKE_DEBOUNCE_MS);
+  if (Number.isFinite(env) && env >= 0)
+    return env;
+  return idleDriven ? IDLE_DEBOUNCE_MS + 50 : 1500;
+}
+function scheduleDispatchWake(sessionID, idleDriven) {
+  if (dispatchDisabled || forgeDisabled)
+    return;
+  if (dispatchWakeTimers.has(sessionID))
+    return;
+  const t = setTimeout(() => {
+    dispatchWakeTimers.delete(sessionID);
+    injectDispatchBrief(sessionID);
+  }, dispatchWakeDelay(idleDriven));
+  dispatchWakeTimers.set(sessionID, t);
+}
+function dispatchBriefText(entries) {
+  const lines = [`[forge:dispatch-complete] ${entries.length} background dispatch(es) reached terminal state:`];
+  for (const e of entries) {
+    lines.push("", `- ${e.dispatchId} · agent ${e.tier} · ${e.identity}${e.depth ? ` @${e.depth}` : ""} · ${e.state.toUpperCase()} · session ${e.sessionID || "(not yet started)"}`);
+    const r = e.result;
+    if (r !== undefined) {
+      lines.push(`  result: ${JSON.stringify(r, null, 1).replace(/\n/g, `
+`).slice(0, 2000)}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+async function injectDispatchBrief(sessionID) {
+  const reg = activeDispatchRegistry;
+  if (!reg)
+    return;
+  const c0 = dispatchClient;
+  if (typeof c0?.session.status === "function") {
+    try {
+      const st = await c0.session.status({ path: { id: sessionID } });
+      const t = st?.[sessionID]?.type;
+      if (t && t !== "idle")
+        return;
+    } catch {
+      return;
+    }
+  }
+  const entries = reg.takeUndelivered(sessionID);
+  if (entries.length === 0)
+    return;
+  const c = dispatchClient;
+  const send = c?.session.promptAsync ?? c?.session.prompt;
+  if (typeof send !== "function")
+    return;
+  try {
+    await send.call(c.session, { path: { id: sessionID }, body: { parts: [{ type: "text", text: dispatchBriefText(entries) }] } });
+  } catch {
+    for (const e of entries)
+      e.delivered = false;
+  }
+}
+var forgeDispatchTool = tool({
+  description: "Dispatch a scoped task to a worker subagent defined in forge.json. Takes {prompt, agent, depth}: agent names a dispatch agent (see forge_dispatch_config for the effective set); the agent's model is pinned by its definition — no fallback ever. depth comes from the canonical metalanguage (none, low, medium, high, max; default = the agent's first entry) or the model's native level names verbatim (escape hatch); the ONLY validation is membership in the agent's depths — the provider is the final judge and its raw errors flow back. The report discloses the depth translation (canonical -> native). Background mode targets live TUI sessions; under `opencode run` prefer sync. The result reports the actual model/depth, real token counts, a self-computed cost (null when unpriced), and the worker's concluding report. Refuses while a plan draft is active.",
+  args: {
+    prompt: tool.schema.string().describe("Complete, self-contained task for the worker (it cannot see this conversation)"),
+    agent: tool.schema.string().describe("Dispatch agent id from forge.json (e.g. research, review, or a custom id; legacy inline tier ids still work when configured)"),
+    depth: tool.schema.string().optional().describe("Reasoning depth: none | low | medium | high | max (canonical) or the model's native level name verbatim; omit to use the agent's first depths entry"),
+    background: tool.schema.boolean().optional().describe("Run in the background: returns {dispatchId, resolved, queuedAt} immediately; the full result arrives later as a coalesced [forge:dispatch-complete] brief when the session is idle. Background mode targets live TUI sessions — under `opencode run` the session ends before any brief, so completions are ledger-only (read them via forge_dispatch_list) and sync mode is preferred.")
+  },
+  execute: async (args, context) => {
+    const state = stateForBan(context.sessionID);
+    const active = state ? resolveActivePlan(state) : null;
+    if (active && active.doc.status === "draft") {
+      throw new Error("[forge] A plan is in draft; dispatching workers is denied during planning. Call plan_approve for user approval, or /plan discard to abandon the plan.");
+    }
+    if (!args.prompt?.trim())
+      throw new Error("forge_dispatch requires a non-empty prompt.");
+    const engine = activeDispatchEngine;
+    if (!engine)
+      throw new Error("[forge] dispatch engine unavailable (disabled by dispatch.disable, or config still loading).");
+    try {
+      const r = await engine.dispatch({ prompt: args.prompt, agent: args.agent, ...args.depth !== undefined ? { depth: args.depth } : {} }, context.sessionID, args.background === true ? { background: true } : undefined);
+      if ("dispatchId" in r) {
+        context.metadata({ title: `dispatch ${r.agent} queued (${r.dispatchId})` });
+        return {
+          title: `dispatch ${r.agent} queued → ${r.resolved}${r.depth ? ` @${r.depth}` : ""}`,
+          output: [
+            `[forge:dispatch] accepted in the background: ${r.dispatchId}`,
+            `agent: ${r.agent}   resolved: ${r.resolved}${r.depth ? `   depth: ${r.depth}` : ""}`,
+            `queuedAt: ${r.queuedAt}`,
+            "",
+            "The full result (tokens/cost/report — or the timeout/error report) arrives as a [forge:dispatch-complete] brief when this session is next idle. Track progress any time with forge_dispatch_list; cancel with forge_dispatch_kill."
+          ].join(`
+`)
+        };
+      }
+      const tok = r.tokens;
+      const costLine = r.costUsd !== null && r.costUsd !== undefined ? `$${r.costUsd.toFixed(6)}${r.priceSnapshot ? ` (${r.priceSnapshot})` : ""}` : `unpriced${r.costNote ? ` — ${r.costNote}` : ""}`;
+      context.metadata({ title: `dispatch ${r.agent}: ${r.actual.model} @ ${r.actual.depth}` });
+      return {
+        title: `dispatch ${r.agent} → ${r.actual.model} @${r.actual.depth}`,
+        output: [
+          `[forge:dispatch] completed in ${r.durationMs}ms`,
+          `agent: ${r.agent}   model: ${r.actual.model}   depth: ${r.actual.depth}${r.requested.depth !== undefined && r.requested.depth !== r.actual.depth ? ` (requested ${r.requested.depth})` : ""}`,
+          `session: ${r.sessionID}`,
+          `tokens: input ${tok.input ?? 0}, output ${tok.output ?? 0}, reasoning ${tok.reasoning ?? 0}, cache r/w ${tok.cache?.read ?? 0}/${tok.cache?.write ?? 0}`,
+          `cost: ${costLine}`,
+          `depthTranslation: ${r.depthTranslation}`,
+          "",
+          "Worker report:",
+          r.text || "(empty worker report)"
+        ].join(`
+`)
+      };
+    } catch (err) {
+      if (err instanceof DispatchError && err.code === "pin-unavailable") {
+        throw new Error(`[forge:dispatch:pin-unavailable] ${err.message}
+
+${dispatchRecipeText()}`);
+      }
+      if (err instanceof DispatchError)
+        throw new Error(`[forge:dispatch:${err.code}] ${err.message}`);
+      throw err;
+    }
+  }
+});
+function dispatchRecipeText() {
+  const paths = forgeConfigPaths({ projectDir: forgeLoaderDir ?? undefined, homeDir: process.env.FORGE_TEST_FORGE_HOME ?? homedir() });
+  return forgeRecipe({
+    detectedIdentities: lastDetectedIdentities,
+    projectPath: paths.project || "(project .opencode/forge.json)",
+    globalPath: paths.global
+  });
+}
+var forgeDispatchConfigTool = tool({
+  description: "Read the effective forge dispatch configuration: {agents, knobs, findings}. agents mirrors the winning forge.json (project .opencode/forge.json > global ~/.config/opencode/forge.json > built-in seed) exactly — same keys, same shapes, writable back as valid forge.json agents content. knobs are the inline dispatch options {timeoutMs, maxConcurrent}. findings carry config state (config-parse-error, dispatch-unconfigured notice). Re-reads the file (mtime-cached) on every call, so edits are reflected immediately.",
+  args: {},
+  execute: async (_args, context) => {
+    const loaded = forgeLoader?.load() ?? { agents: {}, source: "seed", path: null, findings: [] };
+    context.metadata({ title: `dispatch config (${loaded.source})` });
+    return {
+      title: `dispatch config (${loaded.source}${loaded.path ? `: ${loaded.path}` : ""})`,
+      output: JSON.stringify({
+        agents: loaded.agents,
+        knobs: { timeoutMs: dispatchTimeoutMs, maxConcurrent: dispatchMaxConcurrent },
+        findings: loaded.findings
+      }, null, 2)
+    };
+  }
+});
+var forgeDispatchListTool = tool({
+  description: "List background forge_dispatch activity: in-flight dispatches (with dispatchIds) and recent terminal results (completed/timeout/error, full report objects). Use it to recover dispatch state after context compaction or to check on a background dispatch instead of waiting.",
+  args: {},
+  execute: async () => {
+    const reg = activeDispatchRegistry;
+    if (!reg)
+      throw new Error("[forge] no background dispatches have been submitted.");
+    const l = reg.list();
+    if (l.inFlight.length === 0 && l.terminal.length === 0) {
+      return { title: "no background dispatches", output: "[forge:dispatch-list] no background dispatches recorded in this session." };
+    }
+    const lines = [];
+    if (l.inFlight.length > 0) {
+      lines.push("In flight:");
+      for (const e of l.inFlight) {
+        lines.push(`- ${e.dispatchId} · agent ${e.tier} · ${e.identity}${e.depth ? ` @${e.depth}` : ""} · ${e.state} · queued ${e.queuedAt} · session ${e.sessionID || "(starting)"}`);
+      }
+    }
+    if (l.terminal.length > 0) {
+      lines.push("", "Recent terminal results:");
+      for (const e of l.terminal.slice().reverse()) {
+        lines.push(`- ${e.dispatchId} · agent ${e.tier} · ${e.identity}${e.depth ? ` @${e.depth}` : ""} · ${e.state.toUpperCase()} · session ${e.sessionID || "(not started)"}`);
+        const r = e.result;
+        if (r !== undefined)
+          lines.push(`  result: ${JSON.stringify(r, null, 1).slice(0, 2000)}`);
+        if (e.lateCompletion !== undefined)
+          lines.push(`  (killed; a late result arrived after the kill and was discarded: ${JSON.stringify(e.lateCompletion).slice(0, 300)})`);
+      }
+    }
+    return { title: `dispatches: ${l.inFlight.length} in flight, ${l.terminal.length} terminal`, output: lines.join(`
+`) };
+  }
+});
+var forgeDispatchKillTool = tool({
+  description: "Cancel an in-flight background forge_dispatch by dispatchId: polling stops, the completion brief is suppressed, and the outcome is ledgered as killed. Refuses honestly if the dispatch already finished (use forge_dispatch_list). The child session itself cannot be aborted on this host version and is left for the host to reclaim.",
+  args: {
+    dispatchId: tool.schema.string().describe("The dispatchId returned by forge_dispatch (background) or shown by forge_dispatch_list")
+  },
+  execute: async (args) => {
+    const engine = activeDispatchEngine;
+    if (!engine)
+      throw new Error("[forge] dispatch engine unavailable.");
+    try {
+      engine.kill(args.dispatchId);
+    } catch (err) {
+      if (err instanceof DispatchError)
+        throw new Error(`[forge:dispatch:${err.code}] ${err.message}`);
+      throw err;
+    }
+    return {
+      title: `${args.dispatchId} killed`,
+      output: `[forge:dispatch] ${args.dispatchId}: killed — polling stopped, the completion brief is suppressed, and the outcome is ledgered. The child session cannot be aborted on this host and is left for the host to reclaim.`
+    };
+  }
+});
+var CREW_COMMAND_TEMPLATE = [
+  "Objective: {args}",
+  "",
+  "You are entering CREW ORCHESTRATION discipline for this session (single subject: do not switch agents). Follow it exactly:",
+  "",
+  "1. REGISTER: call `crew_begin` with the objective. If it refuses (a crew is already active here, or a plan draft is active), STOP and tell the user why — never start a second crew.",
+  "2. DECOMPOSE: break the objective into subtasks. Every subtask carries FOUR fields before dispatch: (a) a self-contained prompt, (b) a tier/profile (scout = readonly recon, build = implementation, review = readonly review, quick = mechanical change), (c) an exact reasoning depth from the exposed vocabulary, (d) an acceptance-evidence statement — what the result text must contain for you to call it PASS.",
+  "3. WAVES, NEVER FLOODS: dispatch subtasks with background forge_dispatch in batches no larger than the concurrency cap (default 4). Launch the next batch ONLY as [forge:dispatch-complete] briefs free capacity. Never fire more dispatches while the cap is full.",
+  "4. VERIFY: judge each subtask strictly against its acceptance-evidence statement from the dispatch result text — cite the dispatchId (bg-N) as the evidence reference. A result that does not meet the statement is a failure even if the worker sounded confident.",
+  "5. RETRY AT MOST ONCE: a failed subtask may be retried once with an adjusted prompt or depth. If the retry also fails, record the subtask as FAIL with BOTH failure reports visible (attempts[]). Do not retry twice, do not paper over a failure.",
+  "6. CLOSE: when every subtask has a verdict, call `crew_close` with the full report (title/verdict/evidence per subtask; attempts[] for FAILs). The gate cross-checks your report against the dispatch ledger — a dispatched subtask missing from the report refuses the close. The user confirms the closing dialog."
+].join(`
+`);
+var crewBeginTool = tool({
+  description: "Register this session's crew (from /crew). Refuses when a crew is already active in the session or while a plan draft is active. Crew state is in-memory: a host restart ends it honestly (the dispatch ledger keeps the history).",
+  args: {
+    objective: tool.schema.string().describe("One-line crew objective (from /crew)")
+  },
+  execute: async (args, context) => {
+    const state = stateForBan(context.sessionID);
+    const active = state ? resolveActivePlan(state) : null;
+    if (active && active.doc.status === "draft") {
+      throw new Error("[forge:crew] A plan is in draft; crew orchestration is denied during planning. Call plan_approve for user approval, or /plan discard to abandon the plan.");
+    }
+    if (!args.objective?.trim())
+      throw new Error("crew_begin requires a non-empty objective (from /crew <objective>).");
+    const existing = crews.get(context.sessionID);
+    if (existing) {
+      throw new Error(`[forge:crew] This session already has an active crew: "${existing.objective}" (started ${existing.startedAt}). Finish and close it with crew_close before starting another.`);
+    }
+    crews.set(context.sessionID, { objective: args.objective.trim(), startedAt: nowIso() });
+    return {
+      title: `crew registered: ${args.objective.trim().slice(0, 60)}`,
+      output: `[forge:crew] Crew registered for this session. Objective: ${args.objective.trim()}. Proceed with the discipline: decompose → waves paced on completion briefs (never past the cap) → per-subtask evidence verdicts → at most one retry → crew_close with the full report.`
+    };
+  }
+});
+var crewCloseTool = tool({
+  description: "Close this session's crew with the final report (ask-level user confirmation). The gate cross-checks the report against the dispatch ledger: every subtask needs a verdict (PASS/FAIL) and a bg-N evidence reference; every dispatch this crew submitted must appear in the report; FAIL requires both failure reports (attempt + the one retry). On success the summary (verdicts, ledger references, aggregate tokens/cost) is appended to the dispatch ledger and the crew ends.",
+  args: {
+    report: tool.schema.array(tool.schema.object({
+      title: tool.schema.string().describe("Subtask title"),
+      verdict: tool.schema.string().describe("PASS or FAIL"),
+      evidence: tool.schema.string().describe("Acceptance evidence with the bg-N dispatch id reference"),
+      attempts: tool.schema.array(tool.schema.string()).optional().describe("For FAIL: both failure reports (attempt and retry)")
+    })).describe("The full crew report — one entry per subtask")
+  },
+  execute: async (args, context) => {
+    const crew = crews.get(context.sessionID);
+    if (!crew)
+      throw new Error("[forge:crew] No active crew in this session (crew state is in-memory and dies on host restart). Start one with /crew <objective>.");
+    const rows = [];
+    try {
+      const file2 = readFileSync9(join5(dispatchLogDir, "ledger.jsonl"), "utf8");
+      for (const line of file2.split(`
+`)) {
+        const t = line.trim();
+        if (!t)
+          continue;
+        try {
+          rows.push(JSON.parse(t));
+        } catch {}
+      }
+    } catch {}
+    const check2 = validateCrewReport(args.report ?? [], rows, { objective: crew.objective, startedAt: crew.startedAt, sessionID: context.sessionID });
+    if (!check2.ok) {
+      throw new Error(`[forge:crew] crew_close refused — the report does not match the dispatch ledger:
+${check2.gaps.map((g) => `- ${g}`).join(`
+`)}
+The crew stays active; complete or correct the report and call crew_close again.`);
+    }
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let costSum = 0;
+    let costKnown = 0;
+    for (const row of rows) {
+      if (typeof row.dispatchId !== "string" || !check2.dispatchIds.includes(row.dispatchId))
+        continue;
+      const tok = row.tokens;
+      tokensIn += tok?.input ?? 0;
+      tokensOut += (tok?.output ?? 0) + (tok?.reasoning ?? 0);
+      if (typeof row.costUsd === "number") {
+        costSum += row.costUsd;
+        costKnown++;
+      }
+    }
+    await gate(context.ask, "crew_close", `Close crew: ${crew.objective}`);
+    dispatchLedger.append({
+      ts: nowIso(),
+      event: "crew-summary",
+      tier: "crew",
+      outcome: "closed",
+      sessionID: context.sessionID,
+      note: crew.objective,
+      tokens: { input: tokensIn, output: tokensOut, reasoning: 0, cache: { read: 0, write: 0 } },
+      costUsd: costKnown > 0 ? costSum : null,
+      dispatchIds: check2.dispatchIds,
+      subtasks: (args.report ?? []).map((r) => ({ title: r.title, verdict: String(r.verdict).toUpperCase(), evidence: r.evidence }))
+    });
+    crews.delete(context.sessionID);
+    const fails = (args.report ?? []).filter((r) => String(r.verdict).toUpperCase() === "FAIL").length;
+    return {
+      title: `crew closed: ${crew.objective.slice(0, 60)}`,
+      output: [
+        `[forge:crew] Crew closed: ${crew.objective}`,
+        `subtasks: ${(args.report ?? []).length} (PASS ${(args.report ?? []).length - fails}, FAIL ${fails})`,
+        `dispatches: ${check2.dispatchIds.length}   tokens: in ${tokensIn}, out ${tokensOut}   cost: ${costKnown > 0 ? `$${costSum.toFixed(6)}` : "unpriced"}`,
+        "The summary is appended to the dispatch ledger."
+      ].join(`
+`)
     };
   }
 });
@@ -15578,6 +17479,14 @@ function forgeTools() {
     tools.forge_shell = forgeShellTool;
     tools.forge_jobs = forgeJobsTool;
   }
+  if (!dispatchDisabled && !forgeDisabled) {
+    tools.forge_dispatch = forgeDispatchTool;
+    tools.forge_dispatch_config = forgeDispatchConfigTool;
+    tools.forge_dispatch_list = forgeDispatchListTool;
+    tools.forge_dispatch_kill = forgeDispatchKillTool;
+    tools.crew_begin = crewBeginTool;
+    tools.crew_close = crewCloseTool;
+  }
   return tools;
 }
 var hostWorktree = "";
@@ -15601,7 +17510,7 @@ var pendingContinuationTurn = new Set;
 function goalProbe(line) {
   if (process.env.FORGE_GOAL_PROBE) {
     try {
-      appendFileSync(join4(tmpdir2(), "forge-goal-probe.log"), `${new Date().toISOString()} ${line}
+      appendFileSync(join5(tmpdir3(), "forge-goal-probe.log"), `${new Date().toISOString()} ${line}
 `);
     } catch {}
   }
@@ -15647,7 +17556,7 @@ function wrapupBriefText(goal, reason) {
 }
 async function autoPauseGoal(client, state, goal, reason, wrapup) {
   goalProbe(`auto-pause session=${state.sessionID} reason=${reason} wrapup=${wrapup}`);
-  atomicWrite(goal.path, transitionGoal(readFileSync6(goal.path, "utf8"), "paused", nowIso(), { stopReason: reason }));
+  atomicWrite(goal.path, transitionGoal(readFileSync9(goal.path, "utf8"), "paused", nowIso(), { stopReason: reason }));
   engineForgetSession(state.sessionID);
   if (wrapup && goal.doc.session) {
     try {
@@ -15696,9 +17605,9 @@ async function continueIfEligible(client, sessionID) {
       const ledgerPath = state.goalPath;
       if (ledgerPath && existsSync3(ledgerPath)) {
         try {
-          const fresh = parseGoalLoose(readFileSync6(ledgerPath, "utf8"));
+          const fresh = parseGoalLoose(readFileSync9(ledgerPath, "utf8"));
           if (fresh && fresh.turnsUsed > 0) {
-            atomicWrite(ledgerPath, appendLedger(readFileSync6(ledgerPath, "utf8"), { turn: fresh.turnsUsed, revision: fresh.revision, at: nowIso(), activity: turnHadActivity, writes: act?.writes ?? 0, checks: act?.checks ?? 0 }, nowIso()));
+            atomicWrite(ledgerPath, appendLedger(readFileSync9(ledgerPath, "utf8"), { turn: fresh.turnsUsed, revision: fresh.revision, at: nowIso(), activity: turnHadActivity, writes: act?.writes ?? 0, checks: act?.checks ?? 0 }, nowIso()));
           }
         } catch (err) {
           goalProbe(`ledger append failed session=${sessionID} err=${String(err)}`);
@@ -15751,15 +17660,19 @@ async function continueIfEligible(client, sessionID) {
       }
     }
     try {
+      const wakeEntries = activeDispatchRegistry?.takeUndelivered(sessionID) ?? [];
+      const briefText = wakeEntries.length > 0 ? `${dispatchBriefText(wakeEntries)}
+
+${goalBriefText(state, goal)}` : goalBriefText(state, goal);
       await client.session.prompt({
         path: { id: sessionID },
-        body: { parts: [{ type: "text", text: goalBriefText(state, goal) }] }
+        body: { parts: [{ type: "text", text: briefText }] }
       });
       transportFails.delete(sessionID);
       pendingContinuationTurn.add(sessionID);
       turnActivity.set(sessionID, { writes: 0, checks: 0 });
       state.goalPath = goal.path;
-      atomicWrite(goal.path, incTurns(readFileSync6(goal.path, "utf8"), nowIso()));
+      atomicWrite(goal.path, incTurns(readFileSync9(goal.path, "utf8"), nowIso()));
       goalProbe(`continued session=${sessionID} turn=${goal.doc.turnsUsed + 1}/${goal.doc.maxTurns}`);
     } catch (err) {
       const n = (transportFails.get(sessionID) ?? 0) + 1;
@@ -15790,6 +17703,7 @@ var server = async (input, options) => {
   hostWorktree = effectiveWorktree(input.worktree, input.directory) || input.directory || "";
   const client = input.client;
   jobClient = input.client;
+  dispatchClient = input.client;
   const jobsOpts = options?.jobs;
   if (jobsOpts?.mode === "auto" || jobsOpts?.mode === "forge" || jobsOpts?.mode === "native")
     jobsMode = jobsOpts.mode;
@@ -15807,14 +17721,26 @@ var server = async (input, options) => {
   if (wdStallRaw !== undefined && wdStallRaw !== wdStall) {
     wdFallbacks.push(`watchdog.stallMs ${JSON.stringify(String(wdStallRaw))} adjusted to ${wdStall} (floor/default applied)`);
   }
-  const watchdogLedger = createFileLedger(join4(watchdogLogDir(), "log.jsonl"));
+  const dpOpts = options?.dispatch;
+  dispatchDisabled = dpOpts?.disable === true;
+  if (Number.isInteger(dpOpts?.maxConcurrent) && dpOpts.maxConcurrent >= 1 && dpOpts.maxConcurrent <= 16) {
+    dispatchMaxConcurrent = dpOpts.maxConcurrent;
+  } else if (dpOpts?.maxConcurrent !== undefined) {
+    dispatchMaxConcurrent = 4;
+  }
+  if (Number.isInteger(dpOpts?.timeoutMs) && dpOpts.timeoutMs >= 1000 && dpOpts.timeoutMs <= 600000) {
+    dispatchTimeoutMs = dpOpts.timeoutMs;
+  } else if (dpOpts?.timeoutMs !== undefined) {
+    dispatchTimeoutMs = 600000;
+  }
+  const watchdogLedger = createFileLedger(join5(watchdogLogDir(), "log.jsonl"));
   const rawLocator = createLocator();
   const probing = () => process.env.FORGE_WATCHDOG_PROBE === "1";
   const probeLine = (text) => {
     if (!probing())
       return;
     try {
-      appendFileSync(join4(tmpdir2(), "forge-watchdog-probe.log"), `${new Date().toISOString()} ${text}
+      appendFileSync(join5(tmpdir3(), "forge-watchdog-probe.log"), `${new Date().toISOString()} ${text}
 `);
     } catch {}
   };
@@ -15862,6 +17788,7 @@ var server = async (input, options) => {
       exitCleanup?.trigger("dispose");
       jobManager.disposeAll();
       watchdog.dispose();
+      activeDispatchEngine?.dispose();
       sessions.clear();
     },
     config: async (cfg) => {
@@ -15895,16 +17822,90 @@ var server = async (input, options) => {
         template: PLAN_COMMAND_TEMPLATE,
         description: "forge plan harness: no argument lists in-progress plans; resume continues the latest; discard abandons it; a goal enters planning discipline"
       };
+      cfg.command["crew"] ??= {
+        template: CREW_COMMAND_TEMPLATE,
+        description: "forge crew orchestration: decompose an objective into evidence-checked subtasks dispatched as paced background waves; at most one retry per subtask; crew_close cross-checks the report against the dispatch ledger"
+      };
       cfg.command["goal"] ??= {
         template: GOAL_COMMAND_TEMPLATE,
         description: "forge goal harness (autonomous, host-verified): no argument lists goals; pause/resume/discard drive the loop; add queues; next promotes; an objective drafts a contract and arms it (--check/--contains markers become verification items)"
       };
       const perm = cfg.permission;
       const permSection = perm ?? (cfg.permission = {});
-      for (const gateKey of ["plan_approve", "plan_close", "goal_write", "goal_complete", "goal_resume", "goal_discard", "forge_shell"]) {
+      for (const gateKey of ["plan_approve", "plan_close", "goal_write", "goal_complete", "goal_resume", "goal_discard", "forge_shell", "crew_close"]) {
         if (permSection[gateKey] !== "deny")
           permSection[gateKey] = "ask";
       }
+      if (!dispatchDisabled) {
+        const snapshot = process.env.FORGE_TEST_NO_DISPATCH_FETCH === "1" ? { catalog: { providers: {} }, degraded: true, source: "test-off" } : await loadModelsDevSnapshot();
+        const dispatchOpts = options?.dispatch ?? {};
+        const legacyInline = (dispatchOpts.roster?.length ?? 0) > 0 || dispatchOpts.tiers !== undefined;
+        if (!forgeLoader || forgeLoaderDir !== hostWorktree) {
+          forgeLoader = createForgeConfigLoader({
+            projectDir: hostWorktree,
+            homeDir: process.env.FORGE_TEST_FORGE_HOME ?? homedir()
+          });
+          forgeLoaderDir = hostWorktree;
+        }
+        const loaded = forgeLoader.load();
+        forgeConfigState = loaded;
+        for (const finding of loaded.findings) {
+          dispatchLedger.append({ ts: new Date().toISOString(), event: "validation", level: finding.level, code: finding.code, note: finding.message });
+        }
+        for (const [agentId, def] of Object.entries(loaded.agents)) {
+          const id = `forge-${agentId}`;
+          if (agentSection[id] !== undefined)
+            continue;
+          agentSection[id] = forgeAgentDef(agentId, def);
+        }
+        const detected = configuredIdentitiesOf(cfg, snapshot.catalog);
+        lastDetectedIdentities = detected;
+        const built = buildDispatchConfig({
+          configuredIdentities: detected,
+          catalog: snapshot.catalog,
+          userRoster: legacyInline ? dispatchOpts.roster ?? [] : [],
+          userTiers: legacyInline ? dispatchOpts.tiers : undefined
+        });
+        dispatchBase = { cfg: built, catalog: snapshot.catalog, findings: built.findings, degraded: snapshot.degraded };
+        for (const finding of built.findings) {
+          dispatchLedger.append({ ts: new Date().toISOString(), event: "validation", level: finding.level, code: finding.code, note: finding.message });
+        }
+        if (snapshot.degraded) {
+          dispatchLedger.append({ ts: new Date().toISOString(), event: "models-dev-degraded", note: "models.dev snapshot unavailable — cost reporting degrades to null" });
+        }
+        if (legacyInline) {
+          for (const [tierId, tier] of Object.entries(built.tiers)) {
+            const id = `forge-${tierId}`;
+            if (agentSection[id] !== undefined)
+              continue;
+            agentSection[id] = tierAgentDef(tierId, tier);
+          }
+        }
+        const roster = built;
+        activeDispatchRegistry = activeDispatchRegistry ?? createDispatchRegistry();
+        activeDispatchEngine?.dispose();
+        activeDispatchEngine = createDispatchEngine({
+          serverUrl: String(input.serverUrl ?? "").replace(/\/$/, ""),
+          workspace: hostWorktree,
+          fetcher: globalThis.fetch,
+          now: Date.now,
+          sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+          cfg: roster,
+          catalog: snapshot.catalog,
+          available: (identity) => {
+            return roster.roster.some((e) => e.model === identity) || lastDetectedIdentities.includes(identity);
+          },
+          agents: () => forgeLoader?.load().agents ?? {},
+          legacy: legacyInline,
+          sink: (entry) => dispatchLedger.append(entry),
+          registry: activeDispatchRegistry,
+          onTerminal: (parentSessionID) => scheduleDispatchWake(parentSessionID, false),
+          onDepth: queueDispatchDepth,
+          providerFamily: dispatchProviderFamily,
+          maxConcurrent: dispatchMaxConcurrent,
+          timeoutMs: dispatchTimeoutMs
+        });
+      }
     },
     get tool() {
       return forgeDisabled ? {} : forgeTools();
@@ -15912,7 +17913,7 @@ var server = async (input, options) => {
     "tool.execute.before": async (input2, output) => {
       if (process.env.FORGE_PERM_PROBE) {
         try {
-          appendFileSync(join4(tmpdir2(), "forge-perm-probe.log"), `${new Date().toISOString()} before tool=${JSON.stringify(input2.tool)} session=${input2.sessionID}
+          appendFileSync(join5(tmpdir3(), "forge-perm-probe.log"), `${new Date().toISOString()} before tool=${JSON.stringify(input2.tool)} session=${input2.sessionID}
 `);
         } catch {}
       }
@@ -15922,7 +17923,7 @@ var server = async (input, options) => {
         watchdog.track(input2.callID, input2.sessionID, input2.tool, undefined, cmdText !== undefined ? commandNeedle(cmdText) : undefined);
         if (process.env.FORGE_WATCHDOG_PROBE) {
           try {
-            appendFileSync(join4(tmpdir2(), "forge-watchdog-probe.log"), `${new Date().toISOString()} track ${input2.callID} needle=${JSON.stringify(cmdText !== undefined ? commandNeedle(cmdText) : undefined)} rawArgs=${JSON.stringify(output?.args ?? null).slice(0, 200)}
+            appendFileSync(join5(tmpdir3(), "forge-watchdog-probe.log"), `${new Date().toISOString()} track ${input2.callID} needle=${JSON.stringify(cmdText !== undefined ? commandNeedle(cmdText) : undefined)} rawArgs=${JSON.stringify(output?.args ?? null).slice(0, 200)}
 `);
           } catch {}
         }
@@ -15934,6 +17935,32 @@ var server = async (input, options) => {
           throw new Error(`[forge] A plan is in draft; write operations are denied (${input2.tool}). Present the plan summary and call plan_approve for user approval, or /plan discard to abandon it.`);
         }
       }
+      if (input2.tool === "forge_dispatch") {
+        const state = stateForBan(input2.sessionID);
+        const active = state ? resolveActivePlan(state) : null;
+        if (active && active.doc.status === "draft") {
+          throw new Error("[forge] A plan is in draft; dispatching workers is denied during planning. Call plan_approve for user approval, or /plan discard to abandon the plan.");
+        }
+      }
+    },
+    "chat.params": async (input2, output) => {
+      const entry = dispatchDepths.get(input2.sessionID);
+      if (!entry || entry.kind === "not-injected")
+        return;
+      applyDepthTranslation(output.options ?? (output.options = {}), entry);
+    },
+    __forgeDispatchTest: {
+      queueDepth: queueDispatchDepth,
+      depthState: (sessionID) => dispatchDepths.get(sessionID) ?? null,
+      composePrompt: composeWorkerPrompt,
+      registry: () => activeDispatchRegistry,
+      crews: () => crews,
+      dispatchLogDir: () => dispatchLogDir,
+      dispatchBriefText,
+      setEngine: (engine) => {
+        activeDispatchEngine?.dispose();
+        activeDispatchEngine = engine;
+      }
     },
     "permission.ask": async (input2, output) => {
       const meta = input2.metadata ?? {};
@@ -15941,7 +17968,7 @@ var server = async (input, options) => {
       const name = (typeof meta.tool === "string" ? meta.tool : undefined) ?? (typeof permissionField === "string" ? permissionField : undefined) ?? input2.id ?? input2.type;
       if (process.env.FORGE_PERM_PROBE) {
         try {
-          appendFileSync(join4(tmpdir2(), "forge-perm-probe.log"), `${new Date().toISOString()} ask name=${JSON.stringify(name)} in_status=${output.status} id=${JSON.stringify(input2.id)} type=${JSON.stringify(input2.type)} meta=${JSON.stringify(input2.metadata)}
+          appendFileSync(join5(tmpdir3(), "forge-perm-probe.log"), `${new Date().toISOString()} ask name=${JSON.stringify(name)} in_status=${output.status} id=${JSON.stringify(input2.id)} type=${JSON.stringify(input2.type)} meta=${JSON.stringify(input2.metadata)}
 `);
         } catch {}
       }
@@ -15972,6 +17999,7 @@ var server = async (input, options) => {
           goalProbe(`idle event session=${sessionID}`);
           scheduleIdleContinuation(client, sessionID);
           deliverJobWakes(sessionID);
+          scheduleDispatchWake(sessionID, true);
         }
       }
       if (event.type === "session.deleted") {
@@ -15990,7 +18018,7 @@ var server = async (input, options) => {
       watchdog.markSeen(input2.callID);
       if (process.env.FORGE_WATCHDOG_PROBE) {
         try {
-          appendFileSync(join4(tmpdir2(), "forge-watchdog-probe.log"), `${new Date().toISOString()} mark ${input2.callID} hostpid=${process.pid}
+          appendFileSync(join5(tmpdir3(), "forge-watchdog-probe.log"), `${new Date().toISOString()} mark ${input2.callID} hostpid=${process.pid}
 `);
         } catch {}
       }
@@ -16000,7 +18028,7 @@ var server = async (input, options) => {
         watchdog.untrack(input2.callID);
         if (process.env.FORGE_WATCHDOG_PROBE) {
           try {
-            appendFileSync(join4(tmpdir2(), "forge-watchdog-probe.log"), `${new Date().toISOString()} untrack ${input2.callID}
+            appendFileSync(join5(tmpdir3(), "forge-watchdog-probe.log"), `${new Date().toISOString()} untrack ${input2.callID}
 `);
           } catch {}
         }
@@ -16030,6 +18058,10 @@ ${output.description}`;
     "experimental.chat.system.transform": async (input2, output) => {
       if (!input2.sessionID)
         return;
+      const crewActive = crews.get(input2.sessionID);
+      if (crewActive && !output.system.some((s) => s.startsWith("[forge:crew-active]"))) {
+        output.system.push(`[forge:crew-active] A crew is ACTIVE in this session: "${crewActive.objective}" (started ${crewActive.startedAt}). A second /crew must be refused; finish with crew_close when every subtask has a verdict.`);
+      }
       if (!forgeDisabled && jobStage() < 2 && !output.system.some((s) => s.startsWith("[forge:job-guidance]"))) {
         output.system.push("[forge:job-guidance] Long-running or possibly non-exiting shell commands (dev servers, watchers, installers, anything spawning detached children) go through forge_shell, never the builtin shell: it returns on idle/success/exit with a jobId instead of blocking indefinitely; manage jobs with forge_jobs. Delegated agents: collect your job results with forge_jobs poll before yielding your conclusion.");
       }