@dv.nghiem/flowdeck 0.5.2 → 0.5.4

package/dist/index.js

@@ -1259,7 +1259,7 @@ Before routing, you MUST emit a routing decision in this exact format:
 \`\`\`
 
 ### Step 5: Route and Supervise
-- Use the \`delegate\` tool to assign work to the selected agent(s)
+- Use native OpenCode agent routing: mention the agent with \`@agent-name <full task description>\`
 - Provide clear, focused context including task description and any relevant files
 - Wait for completion
 - Collect results
@@ -1276,7 +1276,6 @@ You may ONLY use these tools directly:
 - **decision-trace** — Record decisions
 - **policy-engine** — Check policies
 - **reflect** — Gather session artifacts
-- **delegate** — Assign execution to another agent
 
 You may NEVER use:
 - write, write_file, create, create_file
@@ -1286,9 +1285,9 @@ You may NEVER use:
 
 ## Execution Paths After Routing
 
-### Direct Execution Path (via delegate tool)
+### Direct Execution Path
 When workflow class is \`quick\` or \`docs-only\` (simple):
-- Call \`delegate\` with agent=\`default-executor\` and mode=\`direct\`
+- Route to @default-executor with a concise task description
 - Choose the appropriate mode in the task description:
   - \`direct-stock-tools\` — for simple file changes
   - \`quick-answer\` — for questions
@@ -1298,26 +1297,26 @@ When workflow class is \`quick\` or \`docs-only\` (simple):
 
 ### Specialist Execution Path
 When workflow class is \`standard\`, \`explore\`, \`ui-heavy\`, \`bugfix\`, or \`verify-heavy\`:
-- Call \`delegate\` with the role-specific specialist agent:
-  - \`backend-coder\` — server, API, business logic, database
-  - \`frontend-coder\` — UI components, client state, styling
-  - \`devops\` — CI/CD, deployment, infrastructure
-  - \`tester\` — tests, builds, verification
-  - \`researcher\` — API docs, library research
-  - \`reviewer\` — code quality review
-  - \`security-auditor\` — security review
-  - \`debug-specialist\` — root cause analysis
+- Route to the role-specific specialist agent:
+  - \`@backend-coder\` — server, API, business logic, database
+  - \`@frontend-coder\` — UI components, client state, styling
+  - \`@devops\` — CI/CD, deployment, infrastructure
+  - \`@tester\` — tests, builds, verification
+  - \`@researcher\` — API docs, library research
+  - \`@reviewer\` — code quality review
+  - \`@security-auditor\` — security review
+  - \`@debug-specialist\` — root cause analysis
 
 ### Parallel Execution Patterns
 
 Wave 1 (parallel):
-  delegate(agent: "researcher")       — research the library API
-  delegate(agent: "backend-coder")    — implement the model and types
-  delegate(agent: "tester")           — write test cases
+  @researcher research the library API
+  @backend-coder implement the model and types
+  @tester write test cases
 
 Wave 2 (after Wave 1):
-  delegate(agent: "backend-coder")    — implement service using Wave 1 research
-  delegate(agent: "reviewer")         — review Wave 1 implementation
+  @backend-coder implement service using Wave 1 research
+  @reviewer review Wave 1 implementation
 
 ## Adaptive Routing and Escalation
 
@@ -5744,469 +5743,6 @@ var mergeAssistTool = tool12({
   }
 });
 
-// src/tools/delegate.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/services/run-trace.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16, appendFileSync as appendFileSync4, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11 } from "fs";
-import { join as join16 } from "path";
-import { randomUUID } from "crypto";
-function runsPath(dir) {
-  return join16(codebaseDir(dir), "RUNS.jsonl");
-}
-function startTrace(dir, command, args, session_id = "session-0") {
-  const cd = codebaseDir(dir);
-  if (!existsSync16(cd))
-    mkdirSync11(cd, { recursive: true });
-  const trace = {
-    run_id: randomUUID(),
-    session_id,
-    command,
-    args,
-    started_at: new Date().toISOString(),
-    status: "running",
-    files_touched: [],
-    event_ids: [],
-    risk_score: 0
-  };
-  appendFileSync4(runsPath(dir), JSON.stringify(trace) + `
-`, "utf-8");
-  return trace;
-}
-function loadAllTraces(dir) {
-  const p = runsPath(dir);
-  if (!existsSync16(p))
-    return [];
-  try {
-    return readFileSync16(p, "utf-8").trim().split(`
-`).filter(Boolean).map((l) => JSON.parse(l));
-  } catch {
-    return [];
-  }
-}
-function saveAllTraces(dir, traces) {
-  const p = runsPath(dir);
-  writeFileSync12(p, traces.map((t) => JSON.stringify(t)).join(`
-`) + `
-`, "utf-8");
-}
-function endTrace(dir, run_id, status, outcome, error) {
-  const traces = loadAllTraces(dir);
-  const idx = traces.findLastIndex((t) => t.run_id === run_id);
-  if (idx === -1)
-    return;
-  traces[idx] = {
-    ...traces[idx],
-    ended_at: new Date().toISOString(),
-    status,
-    ...outcome ? { outcome } : {},
-    ...error ? { error } : {}
-  };
-  saveAllTraces(dir, traces);
-}
-function getTrace(dir, run_id) {
-  return loadAllTraces(dir).findLast((t) => t.run_id === run_id) ?? null;
-}
-function recordVerification(dir, run_id, kind, evidence) {
-  const traces = loadAllTraces(dir);
-  const idx = traces.findLastIndex((t) => t.run_id === run_id);
-  if (idx === -1)
-    return;
-  const list = traces[idx].verifications ?? [];
-  traces[idx] = {
-    ...traces[idx],
-    verifications: [
-      ...list,
-      { kind, evidence, timestamp: new Date().toISOString() }
-    ]
-  };
-  saveAllTraces(dir, traces);
-}
-
-// src/services/delegation-budget.ts
-var DEFAULT_BUDGET_CONFIG = {
-  maxToolCalls: 200,
-  maxDepth: 3,
-  maxSameStepRetries: 3
-};
-var budgets = new Map;
-function allowDecision(remaining) {
-  return {
-    verdict: "allow",
-    reason: `Tool budget consumed; ${remaining} calls remaining`,
-    riskFlags: [],
-    source: "delegation-budget"
-  };
-}
-function denyDecision(reason) {
-  return {
-    verdict: "deny",
-    reason,
-    riskFlags: ["budget-exhausted"],
-    source: "delegation-budget",
-    escalationMessage: `[FlowDeck Budget] ${reason}. End the current step or escalate to the human.`
-  };
-}
-function resolveDelegationBudgetConfig(config) {
-  const incoming = config?.governance?.delegationBudget ?? {};
-  return {
-    maxToolCalls: incoming.maxToolCalls ?? DEFAULT_BUDGET_CONFIG.maxToolCalls,
-    maxDepth: incoming.maxDepth ?? DEFAULT_BUDGET_CONFIG.maxDepth,
-    maxSameStepRetries: incoming.maxSameStepRetries ?? DEFAULT_BUDGET_CONFIG.maxSameStepRetries
-  };
-}
-function init(runId, config) {
-  const resolved = resolveDelegationBudgetConfig(config);
-  const budget = {
-    runId,
-    config: resolved,
-    spentToolCalls: 0,
-    currentDepth: 0,
-    sameStepRetries: 0
-  };
-  budgets.set(runId, budget);
-  return budget;
-}
-function getBudget(runId) {
-  const budget = budgets.get(runId);
-  if (!budget)
-    return null;
-  return toSnapshot(budget);
-}
-function checkSpend(runId, _toolName) {
-  const budget = budgets.get(runId);
-  if (!budget) {
-    return denyDecision("No budget initialized for this run");
-  }
-  const remaining = budget.config.maxToolCalls - budget.spentToolCalls;
-  if (remaining <= 0) {
-    return denyDecision(`Tool call budget exhausted (${budget.spentToolCalls}/${budget.config.maxToolCalls})`);
-  }
-  budget.spentToolCalls += 1;
-  return allowDecision(Math.max(0, budget.config.maxToolCalls - budget.spentToolCalls));
-}
-function recordDelegation(parentRunId, childRunId) {
-  const parent = budgets.get(parentRunId);
-  if (!parent)
-    return false;
-  const child = budgets.get(childRunId) ?? init(childRunId);
-  child.config = parent.config;
-  child.currentDepth = parent.currentDepth + 1;
-  budgets.set(childRunId, child);
-  return child.currentDepth <= child.config.maxDepth;
-}
-function incrementSameStepRetry(runId) {
-  const budget = budgets.get(runId);
-  if (!budget)
-    return false;
-  budget.sameStepRetries += 1;
-  return budget.sameStepRetries <= budget.config.maxSameStepRetries;
-}
-function toSnapshot(budget) {
-  return {
-    runId: budget.runId,
-    maxToolCalls: budget.config.maxToolCalls,
-    maxDepth: budget.config.maxDepth,
-    maxSameStepRetries: budget.config.maxSameStepRetries,
-    spentToolCalls: budget.spentToolCalls,
-    currentDepth: budget.currentDepth,
-    sameStepRetries: budget.sameStepRetries,
-    remainingToolCalls: Math.max(0, budget.config.maxToolCalls - budget.spentToolCalls)
-  };
-}
-
-// src/tools/delegate.ts
-var DEFAULT_TIMEOUT_MS = 120000;
-function normalizeMode(mode) {
-  if (mode === "council" || mode === "pipeline")
-    return mode;
-  return "direct";
-}
-function validateCouncilContext(context) {
-  if (!context || !Array.isArray(context.agents) || context.agents.length === 0) {
-    return { ok: false, error: "council mode requires context.agents to be a non-empty array of strings." };
-  }
-  for (const agent of context.agents) {
-    if (typeof agent !== "string") {
-      return { ok: false, error: "context.agents must contain only strings." };
-    }
-  }
-  return { ok: true, agents: context.agents };
-}
-function validatePipelineContext(context) {
-  if (!context || !Array.isArray(context.stages) || context.stages.length === 0) {
-    return { ok: false, error: "pipeline mode requires context.stages to be a non-empty array of { agent, task? }." };
-  }
-  for (const stage of context.stages) {
-    if (!stage || typeof stage !== "object" || typeof stage.agent !== "string") {
-      return { ok: false, error: "Each pipeline stage must be an object with a string 'agent' property." };
-    }
-  }
-  return { ok: true, stages: context.stages };
-}
-function isRegisteredAgent(agent) {
-  return AGENT_NAMES.includes(agent);
-}
-function isTextPart2(part) {
-  return part.type === "text";
-}
-function createDelegateTool(client, statePersistence, ensureRunContext) {
-  return tool13({
-    description: "Delegate work to another FlowDeck agent. Use this instead of raw @agent references for any work requiring write/edit/bash or specialist knowledge. " + "Modes: direct (single agent), council (fan out the same task to multiple agents in parallel), pipeline (sequential stages where each stage's output is passed to the next via context.previousOutput). " + "For council mode, provide context.agents (non-empty string array). For pipeline mode, provide context.stages (non-empty array of { agent, task? }).",
-    args: {
-      agent: tool13.schema.string(),
-      task: tool13.schema.string(),
-      mode: tool13.schema.enum(["direct", "council", "pipeline"]).optional().default("direct"),
-      context: tool13.schema.object().optional()
-    },
-    async execute(args, ctx) {
-      const { agent, task, mode, context } = args;
-      const directory = ctx.directory;
-      const sessionID = ctx.sessionID;
-      const resolvedMode = normalizeMode(mode);
-      let runCtx = statePersistence.getRunContext(sessionID);
-      if (!runCtx) {
-        runCtx = ensureRunContext({
-          sessionID,
-          description: task,
-          agent
-        });
-      }
-      if (!getBudget(runCtx.runId)) {
-        init(runCtx.runId);
-      }
-      const childRunId = randomUUID2();
-      const withinDepth = recordDelegation(runCtx.runId, childRunId);
-      if (!withinDepth) {
-        const snapshot = getBudget(runCtx.runId);
-        return {
-          span_id: "",
-          run_id: runCtx.runId,
-          status: "blocked",
-          output: "",
-          error: `Delegation depth limit exceeded (current: ${snapshot?.currentDepth ?? 0}, max: ${snapshot?.maxDepth ?? 0}). Escalate to the human.`
-        };
-      }
-      try {
-        if (resolvedMode === "direct") {
-          if (!isRegisteredAgent(agent)) {
-            return {
-              span_id: "",
-              run_id: runCtx.runId,
-              status: "blocked",
-              output: "",
-              error: `Agent "${agent}" is not a registered FlowDeck agent. Registered agents: ${AGENT_NAMES.join(", ")}.`
-            };
-          }
-          const span = statePersistence.openAgentSpan(runCtx, runCtx.currentSpanId, agent, task, runCtx.currentStage ?? "execute");
-          const result = await executeDirectDelegation(client, ctx, agent, task, span, runCtx, statePersistence, context);
-          statePersistence.closeAgentSpan(span.span_id, result.status === "blocked" ? "blocked" : "complete", {
-            output_valid: result.status === "complete"
-          });
-          return {
-            span_id: span.span_id,
-            run_id: runCtx.runId,
-            ...result
-          };
-        }
-        if (resolvedMode === "council") {
-          const validation = validateCouncilContext(context);
-          if (!validation.ok) {
-            return {
-              span_id: "",
-              run_id: runCtx.runId,
-              status: "blocked",
-              output: "",
-              error: validation.error
-            };
-          }
-          const unknownAgents = validation.agents.filter((a) => !isRegisteredAgent(a));
-          if (unknownAgents.length > 0) {
-            return {
-              span_id: "",
-              run_id: runCtx.runId,
-              status: "blocked",
-              output: "",
-              error: `Agents are not registered FlowDeck agents: ${unknownAgents.join(", ")}. Registered agents: ${AGENT_NAMES.join(", ")}.`
-            };
-          }
-          const results = await runCouncil(client, { directory, sessionID }, task, validation.agents, { maxConcurrency: 3 });
-          const spans = [];
-          for (const r of results) {
-            const span = statePersistence.openAgentSpan(runCtx, runCtx.currentSpanId, r.agent, task, runCtx.currentStage ?? "execute");
-            const status = r.error ? "failed" : "complete";
-            statePersistence.closeAgentSpan(span.span_id, status, { output_valid: status === "complete" });
-            spans.push({ span_id: span.span_id, status });
-          }
-          const anySuccess = results.some((r) => !r.error);
-          const output = results.map((r) => `--- ${r.agent} ---
-${r.error ? `ERROR: ${r.error}` : r.output}`).join(`
-
-`);
-          return {
-            span_id: spans[0]?.span_id ?? "",
-            run_id: runCtx.runId,
-            status: anySuccess ? "complete" : results.every((r) => r.error) ? "failed" : "blocked",
-            output
-          };
-        }
-        if (resolvedMode === "pipeline") {
-          const validation = validatePipelineContext(context);
-          if (!validation.ok) {
-            return {
-              span_id: "",
-              run_id: runCtx.runId,
-              status: "blocked",
-              output: "",
-              error: validation.error
-            };
-          }
-          const progress = [];
-          let previousOutput = "";
-          for (const stage of validation.stages) {
-            if (!isRegisteredAgent(stage.agent)) {
-              progress.push({
-                stage: stage.agent,
-                status: "blocked",
-                error: `Agent "${stage.agent}" is not a registered FlowDeck agent.`
-              });
-              return {
-                span_id: "",
-                run_id: runCtx.runId,
-                status: "blocked",
-                output: "",
-                error: `Agent "${stage.agent}" is not a registered FlowDeck agent.`,
-                pipeline_progress: progress
-              };
-            }
-            const span = statePersistence.openAgentSpan(runCtx, runCtx.currentSpanId, stage.agent, stage.task ?? task, runCtx.currentStage ?? "execute");
-            const stageContext = {
-              ...context,
-              previousOutput
-            };
-            let result;
-            try {
-              result = await executeDirectDelegation(client, ctx, stage.agent, stage.task ?? task, span, runCtx, statePersistence, stageContext);
-            } catch (error) {
-              const message = error instanceof Error ? error.message : String(error);
-              result = { status: "failed", output: "", error: message };
-            }
-            const spanStatus = result.status === "blocked" ? "blocked" : result.status === "failed" ? "failed" : "complete";
-            statePersistence.closeAgentSpan(span.span_id, spanStatus, { output_valid: spanStatus === "complete" });
-            progress.push({
-              stage: stage.agent,
-              status: spanStatus,
-              output: result.output,
-              error: result.error
-            });
-            if (spanStatus === "failed" || spanStatus === "blocked") {
-              return {
-                span_id: span.span_id,
-                run_id: runCtx.runId,
-                status: spanStatus,
-                output: result.output,
-                error: result.error,
-                pipeline_progress: progress
-              };
-            }
-            previousOutput = result.output;
-          }
-          return {
-            span_id: "",
-            run_id: runCtx.runId,
-            status: "complete",
-            output: previousOutput,
-            pipeline_progress: progress
-          };
-        }
-        return {
-          span_id: "",
-          run_id: runCtx.runId,
-          status: "blocked",
-          output: "",
-          error: `Delegation mode "${resolvedMode}" is not supported.`
-        };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-          span_id: "",
-          run_id: runCtx.runId,
-          status: "failed",
-          output: "",
-          error: message
-        };
-      }
-    }
-  });
-}
-function extractErrorMessage(error) {
-  if (error instanceof Error)
-    return error.message;
-  if (typeof error === "string")
-    return error;
-  if (error && typeof error === "object" && "message" in error)
-    return String(error.message);
-  return String(error);
-}
-async function executeDirectDelegation(client, ctx, agent, task, span, runCtx, statePersistence, context) {
-  const createRes = await client.session.create({
-    body: { parentID: ctx.sessionID, title: `Delegate: ${agent}` },
-    query: { directory: ctx.directory }
-  });
-  if (createRes.error || !createRes.data?.id) {
-    return {
-      status: "failed",
-      output: "",
-      error: extractErrorMessage(createRes.error ?? "Failed to create delegate session")
-    };
-  }
-  const childId = createRes.data.id;
-  statePersistence.updateRunContext({
-    ...runCtx,
-    sessionID: childId,
-    currentSpanId: span.span_id
-  });
-  const parts = [
-    { type: "text", text: buildDelegatePrompt(agent, task, context) }
-  ];
-  const promptRes = await Promise.race([
-    client.session.prompt({
-      path: { id: childId },
-      body: { agent, parts },
-      query: { directory: ctx.directory }
-    }),
-    new Promise((_, reject) => setTimeout(() => reject(new Error("Delegate session timed out")), DEFAULT_TIMEOUT_MS))
-  ]);
-  if (promptRes.error) {
-    return {
-      status: "failed",
-      output: "",
-      error: extractErrorMessage(promptRes.error)
-    };
-  }
-  const output = (promptRes.data?.parts ?? []).filter(isTextPart2).map((p) => p.text).join(`
-`);
-  return {
-    status: "complete",
-    output: output || "(no output)"
-  };
-}
-function buildDelegatePrompt(agent, task, context) {
-  const lines = [
-    `You are @${agent}.`,
-    "",
-    "Task:",
-    task
-  ];
-  if (context && Object.keys(context).length > 0) {
-    lines.push("", "Context:", JSON.stringify(context, null, 2));
-  }
-  lines.push("", "Do the work above. Return a concise summary of what you did and any results.");
-  return lines.join(`
-`);
-}
-
 // src/hooks/notifications.ts
 import { execFile } from "child_process";
 var INTERACTIVE_COMMANDS = new Set([
@@ -6327,13 +5863,13 @@ class NotificationController {
     return this.lastNotifiedKey;
   }
 }
-function notifyPermissionNeeded(tool14) {
-  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool14}`, "critical");
+function notifyPermissionNeeded(tool13) {
+  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool13}`, "critical");
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { join as join16 } from "path";
 import { createRequire } from "module";
 var _version;
 function getVersion() {
@@ -6369,7 +5905,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync17(join17(root, lockfile)))
+    if (existsSync16(join16(root, lockfile)))
       return pm;
   }
   return;
@@ -6378,7 +5914,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync17(join17(root, marker))) {
+    if (!seen.has(lang) && existsSync16(join16(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -6386,11 +5922,11 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath3 = join17(root, ".planning", "STATE.md");
-  if (!existsSync17(statePath3))
+  const statePath3 = join16(root, ".planning", "STATE.md");
+  if (!existsSync16(statePath3))
     return;
   try {
-    const content = readFileSync17(statePath3, "utf-8");
+    const content = readFileSync16(statePath3, "utf-8");
     const match = content.match(/phase:\s*(\S+)/i);
     return match?.[1];
   } catch {
@@ -6495,8 +6031,8 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync18, readFileSync as readFileSync18 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join17 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -6537,10 +6073,10 @@ For each: agent name, status, description, session_id.
 var _lastInjected = new Map;
 function readPlanningState2(directory) {
   const sp = statePath(directory);
-  if (!existsSync18(sp))
+  if (!existsSync17(sp))
     return null;
   try {
-    const content = readFileSync18(sp, "utf-8");
+    const content = readFileSync17(sp, "utf-8");
     const parsed = parseState(content);
     const version = typeof parsed.summaryVersion === "number" ? parsed.summaryVersion : 0;
     return { content: content.slice(0, 1500), version };
@@ -6577,15 +6113,15 @@ function createCompactionHook(ctx, tracker, promptFragment) {
       sections.push(`_State unchanged since last compaction. summaryVersion=${currentStateVersion}_`);
       sections.push("");
     }
-    const indexPath2 = join18(ctx.directory, ".planning", "CODEBASE_INDEX.md");
-    if (indexChanged && existsSync18(indexPath2)) {
+    const indexPath2 = join17(ctx.directory, ".planning", "CODEBASE_INDEX.md");
+    if (indexChanged && existsSync17(indexPath2)) {
       try {
-        const indexContent = readFileSync18(indexPath2, "utf-8");
+        const indexContent = readFileSync17(indexPath2, "utf-8");
         const indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
         sections.push(indexSummary);
         sections.push("");
       } catch {}
-    } else if (existsSync18(indexPath2)) {
+    } else if (existsSync17(indexPath2)) {
       sections.push(`## Codebase Index (unchanged, v${currentIndexVersion})`);
       sections.push(`_Index unchanged since last compaction. summaryVersion=${currentIndexVersion}_`);
       sections.push("");
@@ -6762,23 +6298,23 @@ function createFlowDeckMcps() {
 }
 
 // src/config/loader.ts
-import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync18 } from "fs";
+import { join as join18 } from "path";
 import { homedir } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join19(process.env.XDG_CONFIG_HOME, "opencode") : join19(homedir(), ".config", "opencode"));
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join18(process.env.XDG_CONFIG_HOME, "opencode") : join18(homedir(), ".config", "opencode"));
 }
 function loadFlowDeckConfig(directory) {
   const candidates = [];
   if (directory) {
-    candidates.push(join19(directory, ".opencode", CONFIG_FILENAME));
+    candidates.push(join18(directory, ".opencode", CONFIG_FILENAME));
   }
-  candidates.push(join19(getGlobalConfigDir(), CONFIG_FILENAME));
+  candidates.push(join18(getGlobalConfigDir(), CONFIG_FILENAME));
   for (const configPath of candidates) {
-    if (existsSync19(configPath)) {
+    if (existsSync18(configPath)) {
       try {
-        const content = readFileSync19(configPath, "utf-8");
+        const content = readFileSync18(configPath, "utf-8");
         return JSON.parse(content);
       } catch {}
     }
@@ -6801,8 +6337,8 @@ function resolveDesignFirstConfig(config) {
   };
 }
 // src/services/context-ingress.ts
-import { existsSync as existsSync20, readFileSync as readFileSync20, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync12, writeFileSync as writeFileSync13 } from "fs";
-import { join as join20, basename as basename2 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync19, readdirSync as readdirSync3, statSync, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { join as join19, basename as basename2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname3 } from "path";
 
@@ -6927,8 +6463,8 @@ function computeLanguageSnapshot(projectRoot) {
   let maxMtime = 0;
   const present = [];
   for (const file of INDICATOR_FILES) {
-    const path = join20(projectRoot, file);
-    if (existsSync20(path)) {
+    const path = join19(projectRoot, file);
+    if (existsSync19(path)) {
       present.push(file);
       try {
         const stat = statSync(path);
@@ -6953,14 +6489,14 @@ function getCachedLanguages(projectRoot) {
 function computeSkillsSnapshot(skillsDir) {
   let maxMtime = 0;
   const entries = [];
-  if (existsSync20(skillsDir)) {
+  if (existsSync19(skillsDir)) {
     try {
       for (const entry of readdirSync3(skillsDir, { withFileTypes: true })) {
         if (!entry.isDirectory())
           continue;
         entries.push(entry.name);
         try {
-          const stat = statSync(join20(skillsDir, entry.name));
+          const stat = statSync(join19(skillsDir, entry.name));
           if (stat.mtimeMs > maxMtime) {
             maxMtime = stat.mtimeMs;
           }
@@ -6977,7 +6513,7 @@ function getCachedSkillNames(skillsDir) {
     return cached.names;
   }
   const names = [];
-  if (existsSync20(skillsDir)) {
+  if (existsSync19(skillsDir)) {
     try {
       for (const entry of readdirSync3(skillsDir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
@@ -7161,9 +6697,9 @@ class ContextIngressService {
   }
   persistBudgetSnapshot(ctx) {
     try {
-      const cacheDir = join20(ctx.directory, ".planning", "cache");
-      if (!existsSync20(cacheDir)) {
-        mkdirSync12(cacheDir, { recursive: true });
+      const cacheDir = join19(ctx.directory, ".planning", "cache");
+      if (!existsSync19(cacheDir)) {
+        mkdirSync11(cacheDir, { recursive: true });
       }
       const snapshot = {
         sessionID: ctx.sessionID,
@@ -7173,7 +6709,7 @@ class ContextIngressService {
         componentBudgets: this.getComponentBudgets(ctx),
         writtenAt: new Date().toISOString()
       };
-      writeFileSync13(join20(cacheDir, "latest-context.json"), JSON.stringify(snapshot, null, 2), "utf-8");
+      writeFileSync12(join19(cacheDir, "latest-context.json"), JSON.stringify(snapshot, null, 2), "utf-8");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.error(`[context-ingress] failed to persist budget snapshot: ${message}`);
@@ -7279,12 +6815,12 @@ class ContextIngressService {
     return this._assembledBySession.get(sessionID);
   }
   readPlanContent(projectRoot, state) {
-    const planningDir2 = join20(projectRoot, ".planning");
-    const planPath = join20(planningDir2, "PLAN.md");
-    if (!existsSync20(planPath))
+    const planningDir2 = join19(projectRoot, ".planning");
+    const planPath = join19(planningDir2, "PLAN.md");
+    if (!existsSync19(planPath))
       return "";
     try {
-      let content = readFileSync20(planPath, "utf-8");
+      let content = readFileSync19(planPath, "utf-8");
       if (content.length > this.options.planTruncateThreshold) {
         content = `${content.slice(0, this.options.planTruncateTo)}
 
@@ -7296,28 +6832,28 @@ class ContextIngressService {
     }
   }
   readCodebaseDocs(projectRoot) {
-    const codebaseDir2 = join20(projectRoot, ".codebase");
-    if (!existsSync20(codebaseDir2))
+    const codebaseDir2 = join19(projectRoot, ".codebase");
+    if (!existsSync19(codebaseDir2))
       return {};
     const docs = {};
     try {
       for (const file of readdirSync3(codebaseDir2)) {
         if (!file.endsWith(".md"))
           continue;
-        const filePath = join20(codebaseDir2, file);
+        const filePath = join19(codebaseDir2, file);
         try {
-          docs[file] = readFileSync20(filePath, "utf-8");
+          docs[file] = readFileSync19(filePath, "utf-8");
         } catch {}
       }
     } catch {}
     return docs;
   }
   readRecentEvents(projectRoot) {
-    const eventsPath = join20(projectRoot, ".opencode", "flowdeck-events.jsonl");
-    if (!existsSync20(eventsPath))
+    const eventsPath = join19(projectRoot, ".opencode", "flowdeck-events.jsonl");
+    if (!existsSync19(eventsPath))
       return [];
     try {
-      const content = readFileSync20(eventsPath, "utf-8");
+      const content = readFileSync19(eventsPath, "utf-8");
       const cutoff = Date.now() - this.options.eventMaxAgeMinutes * 60 * 1000;
       const events = [];
       for (const line of content.split(`
@@ -7378,8 +6914,9 @@ class ContextIngressService {
   }
   selectRelevantRules(projectRoot, description, state, route, currentStage) {
     const __dir = dirname3(fileURLToPath2(import.meta.url));
-    const rulesDir = join20(__dir, "..", "rules");
-    if (!existsSync20(rulesDir))
+    const rulesDir = join19(__dir, "..", "rules");
+    const sharedDir = join19(__dir, "..", "agents", "shared");
+    if (!existsSync19(rulesDir))
       return [];
     const stage = currentStage ?? this.inferStageFromRoute(route);
     const languages = getCachedLanguages(projectRoot);
@@ -7391,6 +6928,17 @@ class ContextIngressService {
     }
     const seen = new Set;
     const result = [];
+    if (existsSync19(sharedDir)) {
+      for (const file of readdirSync3(sharedDir)) {
+        if (!file.endsWith(".md"))
+          continue;
+        const path = join19(sharedDir, file);
+        if (seen.has(path))
+          continue;
+        seen.add(path);
+        result.push(path);
+      }
+    }
     for (const rule of selection.selected) {
       const name = basename2(rule.path);
       if (seen.has(name))
@@ -7405,8 +6953,8 @@ class ContextIngressService {
   }
   selectRelevantSkills(description) {
     const __dir = dirname3(fileURLToPath2(import.meta.url));
-    const skillsDir = join20(__dir, "..", "skills");
-    if (!existsSync20(skillsDir))
+    const skillsDir = join19(__dir, "..", "skills");
+    if (!existsSync19(skillsDir))
       return [];
     const names = getCachedSkillNames(skillsDir);
     return scoreSkills(names, description);
@@ -7417,7 +6965,7 @@ function createContextIngressService(options) {
 }
 
 // src/services/harness-policy.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/services/loop-detector.ts
 import { resolve as resolve2 } from "path";
@@ -7504,39 +7052,39 @@ function collapseWhitespace(input) {
   return input.replace(/\s+/g, " ").trim();
 }
 function normalizeAction(toolName, args) {
-  const tool14 = toolName.toLowerCase();
-  if (tool14 === "bash" || tool14 === "shell") {
+  const tool13 = toolName.toLowerCase();
+  if (tool13 === "bash" || tool13 === "shell") {
     const command = typeof args.command === "string" ? args.command : "";
     const normalized = collapseWhitespace(resolveEnvVars(command)).toLowerCase();
     return `shell:${normalized}`;
   }
-  if (tool14 === "read" || tool14 === "view") {
+  if (tool13 === "read" || tool13 === "view") {
     const filePath = typeof args.filePath === "string" ? args.filePath : "";
     try {
-      return `${tool14}:${resolve2(filePath || "")}`;
+      return `${tool13}:${resolve2(filePath || "")}`;
     } catch {
-      return `${tool14}:${filePath}`;
+      return `${tool13}:${filePath}`;
     }
   }
-  if (tool14 === "write" || tool14 === "edit") {
+  if (tool13 === "write" || tool13 === "edit") {
     const filePath = typeof args.filePath === "string" ? args.filePath : "";
     try {
-      return `${tool14}:${resolve2(filePath || "")}`;
+      return `${tool13}:${resolve2(filePath || "")}`;
     } catch {
-      return `${tool14}:${filePath}`;
+      return `${tool13}:${filePath}`;
     }
   }
-  if (tool14 === "grep" || tool14 === "glob" || tool14 === "search") {
+  if (tool13 === "grep" || tool13 === "glob" || tool13 === "search") {
     const pattern = typeof args.pattern === "string" ? args.pattern : "";
     const path = typeof args.path === "string" ? args.path : "";
-    return `${tool14}:${pattern}:${resolve2(path || ".")}`;
+    return `${tool13}:${pattern}:${resolve2(path || ".")}`;
   }
   const sorted = stableStringify(args);
-  return `${tool14}:${sorted}`;
+  return `${tool13}:${sorted}`;
 }
 function classifyObservation(toolName, previous, output, status, similarityThreshold) {
   const outputPreview = getOutputPreview(output);
-  const tool14 = toolName.toLowerCase();
+  const tool13 = toolName.toLowerCase();
   if (status === "blocked") {
     return { observation: "same_result", outputHash: hashOutput(output), outputPreview };
   }
@@ -7550,7 +7098,7 @@ function classifyObservation(toolName, previous, output, status, similarityThres
       outputPreview: errorMessage.slice(0, 200)
     };
   }
-  if (tool14 === "write" || tool14 === "edit") {
+  if (tool13 === "write" || tool13 === "edit") {
     const contentHash = hashOutput(output);
     return { observation: "new_information", outputHash: contentHash, outputPreview };
   }
@@ -7561,7 +7109,7 @@ function classifyObservation(toolName, previous, output, status, similarityThres
   if (outputHash === previous.outputHash) {
     return { observation: "same_result", outputHash, outputPreview };
   }
-  if (NON_MUTATING_TOOLS.has(tool14)) {
+  if (NON_MUTATING_TOOLS.has(tool13)) {
     const similarity = lineSimilarity(outputPreview, previous.outputPreview);
     if (similarity >= similarityThreshold) {
       return { observation: "no_progress", outputHash, outputPreview };
@@ -7570,25 +7118,25 @@ function classifyObservation(toolName, previous, output, status, similarityThres
   return { observation: "new_information", outputHash, outputPreview };
 }
 function redactForDisplay(toolName, normalizedKey) {
-  const tool14 = toolName.toLowerCase();
-  if (tool14 === "bash" || tool14 === "shell") {
+  const tool13 = toolName.toLowerCase();
+  if (tool13 === "bash" || tool13 === "shell") {
     const idx2 = normalizedKey.indexOf(":");
     const cmd = idx2 >= 0 ? normalizedKey.slice(idx2 + 1) : normalizedKey;
     const preview = cmd.slice(0, 30);
     const hash = djb2Hash(cmd);
-    return `${tool14}:"${preview}" (hash: ${hash})`;
+    return `${tool13}:"${preview}" (hash: ${hash})`;
   }
   const idx = normalizedKey.indexOf(":");
   if (idx >= 0) {
     const body = normalizedKey.slice(idx + 1);
     if (body.startsWith("/") || body.startsWith(".") || body.includes("/")) {
-      return `${tool14}:"${body}"`;
+      return `${tool13}:"${body}"`;
     }
     const preview = body.slice(0, 30);
     const hash = djb2Hash(body);
-    return `${tool14}:"${preview}" (hash: ${hash})`;
+    return `${tool13}:"${preview}" (hash: ${hash})`;
   }
-  return `${tool14}:"${normalizedKey}"`;
+  return `${tool13}:"${normalizedKey}"`;
 }
 
 class LoopDetector {
@@ -7766,8 +7314,7 @@ var CONTRACTS = [
       "load-rules",
       "list-rules",
       "hash-edit",
-      "failure-replay",
-      "delegate"
+      "failure-replay"
     ],
     forbiddenActions: [
       "write_file",
@@ -8271,13 +7818,13 @@ function resolveSupervisorConfig(directory) {
 function isRegisteredCommand(name) {
   return REGISTERED_COMMANDS.includes(name);
 }
-function isRegisteredAgent2(name) {
+function isRegisteredAgent(name) {
   return AGENT_NAMES.includes(name);
 }
 function isRegisteredTarget(name) {
   if (isRegisteredCommand(name))
     return { exists: true, type: "command" };
-  if (isRegisteredAgent2(name))
+  if (isRegisteredAgent(name))
     return { exists: true, type: "agent" };
   return { exists: false, type: "agent" };
 }
@@ -8519,8 +8066,8 @@ function reviewToolCall(directory, input) {
 }
 
 // src/hooks/tool-guard.ts
-import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
+import { join as join20 } from "path";
 
 // src/lib/task-routing.ts
 var UI_HEAVY_KEYWORDS = [
@@ -8632,23 +8179,23 @@ function isBashCommandDangerous(cmd) {
   }
   return null;
 }
-function isBlocked(tool14, args) {
-  const patterns = BLOCKED_PATTERNS[tool14];
+function isBlocked(tool13, args) {
+  const patterns = BLOCKED_PATTERNS[tool13];
   if (!patterns)
     return null;
-  if (tool14 === "bash") {
+  if (tool13 === "bash") {
     const cmd = args.command;
     if (!cmd)
       return null;
     return isBashCommandDangerous(cmd);
   }
-  if (tool14 === "read" || tool14 === "write") {
+  if (tool13 === "read" || tool13 === "write") {
     const filePath = extractTargetPath(args);
     if (!filePath)
       return null;
     for (const p of patterns) {
       if (filePath.includes(p)) {
-        return tool14 === "read" ? `FLOWDECK: Access to "${p}" files is blocked.` : `FLOWDECK: Writing to "${p}" is blocked.`;
+        return tool13 === "read" ? `FLOWDECK: Access to "${p}" files is blocked.` : `FLOWDECK: Writing to "${p}" is blocked.`;
       }
     }
     return null;
@@ -8656,11 +8203,11 @@ function isBlocked(tool14, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join21(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync21(constraintsPath))
+  const constraintsPath = join20(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync20(constraintsPath))
     return null;
   try {
-    const content = readFileSync21(constraintsPath, "utf-8");
+    const content = readFileSync20(constraintsPath, "utf-8");
     const match = content.match(/## Forbidden Paths\n([\s\S]*?)(?:\n##|$)/);
     if (!match)
       return null;
@@ -8701,9 +8248,9 @@ function isUiDesignApprovalRequired(directory) {
     return !(state.design_stage === "handoff_complete" && state.design_approved);
   }
   const planPath = phasePlanPath(directory, state.phase || 1);
-  if (!existsSync21(planPath))
+  if (!existsSync20(planPath))
     return false;
-  const planContent = readFileSync21(planPath, "utf-8");
+  const planContent = readFileSync20(planPath, "utf-8");
   if (!isUiHeavyTask(planContent))
     return false;
   return !(state.design_stage === "handoff_complete" && state.design_approved);
@@ -8721,15 +8268,15 @@ function deny(reason, escalationMessage, riskFlags = []) {
   };
 }
 function evaluate(input) {
-  const { directory, tool: tool14, args } = input;
-  if (tool14 !== "bash" && tool14 !== "read" && tool14 !== "write" && tool14 !== "edit") {
+  const { directory, tool: tool13, args } = input;
+  if (tool13 !== "bash" && tool13 !== "read" && tool13 !== "write" && tool13 !== "edit") {
     return allow("Tool is not guardable");
   }
-  const blocked = isBlocked(tool14, args);
+  const blocked = isBlocked(tool13, args);
   if (blocked) {
     return deny(blocked, blocked, ["dangerous-pattern"]);
   }
-  if (tool14 === "write" || tool14 === "edit") {
+  if (tool13 === "write" || tool13 === "edit") {
     const phaseBlock = checkPhaseEnforcement(directory);
     if (phaseBlock) {
       const isAdvisory = phaseBlock.includes("[design-gate]: advisory");
@@ -8748,15 +8295,15 @@ function evaluate(input) {
 }
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync21 } from "fs";
+import { join as join21 } from "path";
 var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync22(configPath)) {
+  if (existsSync21(configPath)) {
     try {
-      const config = JSON.parse(readFileSync22(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync21(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
         return "review-only";
       if (config.execution_mode === "guarded")
@@ -8818,24 +8365,24 @@ function deny2(reason, escalationMessage, riskFlags = []) {
   };
 }
 function evaluate2(input) {
-  const { directory, tool: tool14, args } = input;
-  const planningDirPath = join22(directory, PLANNING_DIR2);
+  const { directory, tool: tool13, args } = input;
+  const planningDirPath = join21(directory, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(directory);
-  const configPath = join22(planningDirPath, CONFIG_FILE);
-  const statePath3 = join22(planningDirPath, STATE_FILE2);
+  const configPath = join21(planningDirPath, CONFIG_FILE);
+  const statePath3 = join21(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(directory);
   if (workspaceRoot && directory !== workspaceRoot) {
     const workspaceConfig = getWorkspaceConfig(directory);
-    if (workspaceConfig && workspaceConfig.workspace_mode === "shared" && !existsSync22(planningDirPath)) {
+    if (workspaceConfig && workspaceConfig.workspace_mode === "shared" && !existsSync21(planningDirPath)) {
       const msg = `No .planning/ in this sub-repo. Switch to workspace root: cd ${workspaceRoot}`;
       return deny2(msg, `[flowdeck] BLOCK: ${msg}`, ["workspace-shared-mode"]);
     }
   }
-  if (tool14 === "write" || tool14 === "edit") {
-    if (!existsSync22(planningDirPath)) {
+  if (tool13 === "write" || tool13 === "edit") {
+    if (!existsSync21(planningDirPath)) {
       return allow2("FlowDeck not initialized in this directory — skipping guard-rails");
     }
-    if (!existsSync22(codebaseDirectory)) {
+    if (!existsSync21(codebaseDirectory)) {
       const msg = ".codebase/ not found. Run /fd-map-codebase to map the codebase.";
       return allow2(msg, ["codebase-missing"]);
     }
@@ -8865,7 +8412,7 @@ function evaluate2(input) {
     const blockMessage = getBlockMessage(planningDirPath);
     return deny2(blockMessage, `[flowdeck] BLOCK: ${blockMessage}`, ["plan-not-confirmed"]);
   }
-  if (tool14 === "bash") {
+  if (tool13 === "bash") {
     const cmd = String(args?.command || "");
     for (const pattern of BUILD_DEPLOY_PATTERNS) {
       if (cmd.includes(pattern)) {
@@ -8899,15 +8446,15 @@ function getDesignGateMessage(dir) {
 }
 function planSuggestsUiHeavy(dir, phase) {
   const planPath = phasePlanPath(dir, phase);
-  if (!existsSync22(planPath))
+  if (!existsSync21(planPath))
     return false;
-  const planContent = readFileSync22(planPath, "utf-8");
+  const planContent = readFileSync21(planPath, "utf-8");
   return isUiHeavyTask(planContent);
 }
 function effectiveSeverity(configPath, statePath3) {
-  if (existsSync22(configPath)) {
+  if (existsSync21(configPath)) {
     try {
-      const configContent = readFileSync22(configPath, "utf-8");
+      const configContent = readFileSync21(configPath, "utf-8");
       const config = JSON.parse(configContent);
       if (config.guard_enforcement === "warn")
         return "warn";
@@ -8920,10 +8467,10 @@ function effectiveSeverity(configPath, statePath3) {
   return getPlanConfirmed(statePath3) ? "block" : "warn";
 }
 function getPlanConfirmed(statePath3) {
-  if (!existsSync22(statePath3))
+  if (!existsSync21(statePath3))
     return false;
   try {
-    const content = readFileSync22(statePath3, "utf-8");
+    const content = readFileSync21(statePath3, "utf-8");
     const match = content.match(/plan_confirmed:\s*(true|false)/i);
     return match ? match[1].toLowerCase() === "true" : false;
   } catch {
@@ -8931,23 +8478,23 @@ function getPlanConfirmed(statePath3) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync22(join22(planningDir2, STATE_FILE2))) {
+  if (!existsSync21(join21(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 function getBlockMessage(planningDir2) {
-  if (!existsSync22(join22(planningDir2, STATE_FILE2))) {
+  if (!existsSync21(join21(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync23, readFileSync as readFileSync23, writeFileSync as writeFileSync14, mkdirSync as mkdirSync13 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync22, writeFileSync as writeFileSync13, mkdirSync as mkdirSync12 } from "fs";
+import { join as join22 } from "path";
 import { createHash as createHash4 } from "crypto";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID } from "crypto";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -8984,28 +8531,28 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join23(codebaseDir(dir), "APPROVALS.json");
+  return join22(codebaseDir(dir), "APPROVALS.json");
 }
 function loadStore(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync23(p))
+  if (!existsSync22(p))
     return { requests: [] };
   try {
-    return JSON.parse(readFileSync23(p, "utf-8"));
+    return JSON.parse(readFileSync22(p, "utf-8"));
   } catch {
     return { requests: [] };
   }
 }
 function saveStore(dir, store) {
   const cd = codebaseDir(dir);
-  if (!existsSync23(cd))
-    mkdirSync13(cd, { recursive: true });
-  writeFileSync14(approvalsPath(dir), JSON.stringify(store, null, 2), "utf-8");
+  if (!existsSync22(cd))
+    mkdirSync12(cd, { recursive: true });
+  writeFileSync13(approvalsPath(dir), JSON.stringify(store, null, 2), "utf-8");
 }
 function requestApproval(dir, run_id, trigger, reason, options = {}) {
   const store = loadStore(dir);
   const req = {
-    id: randomUUID3(),
+    id: randomUUID(),
     run_id,
     session_id: options.session_id ?? "session-0",
     requested_at: new Date().toISOString(),
@@ -9032,16 +8579,16 @@ function computeContentHash(args) {
   const payload = JSON.stringify(args, keys);
   return createHash4("sha256").update(payload).digest("hex").slice(0, 16);
 }
-function requestApprovalForTool(dir, run_id, session_id, agent, tool14, args) {
+function requestApprovalForTool(dir, run_id, session_id, agent, tool13, args) {
   const filePath = extractTargetPath2(args);
   const isSensitive = filePath ? isSensitivePath(filePath) : false;
-  return requestApproval(dir, run_id, tool14, `Approval required for tool "${tool14}"`, {
+  return requestApproval(dir, run_id, tool13, `Approval required for tool "${tool13}"`, {
     file_path: filePath,
     risk_score: isSensitive ? 30 : 50,
     session_id,
     agent,
     content_hash: computeContentHash(args),
-    change_description: `Tool "${tool14}" requested on ${filePath || "unknown target"}`
+    change_description: `Tool "${tool13}" requested on ${filePath || "unknown target"}`
   });
 }
 function extractTargetPath2(args) {
@@ -9070,8 +8617,8 @@ function ask(reason, riskFlags = []) {
   };
 }
 function evaluate3(input) {
-  const { directory, tool: tool14, args } = input;
-  if (!WRITE_TOOLS.has(tool14)) {
+  const { directory, tool: tool13, args } = input;
+  if (!WRITE_TOOLS.has(tool13)) {
     return allow3("Tool does not require approval");
   }
   const filePath = String(args?.path ?? args?.file_path ?? args?.filename ?? args?.filePath ?? "");
@@ -9095,23 +8642,23 @@ function evaluate3(input) {
 }
 
 // src/services/deadlock-detector.ts
-import { existsSync as existsSync25, readFileSync as readFileSync25, appendFileSync as appendFileSync6, mkdirSync as mkdirSync15 } from "fs";
-import { join as join25 } from "path";
-import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync24, readFileSync as readFileSync24, appendFileSync as appendFileSync5, mkdirSync as mkdirSync14 } from "fs";
+import { join as join24 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/services/agent-trace-graph.ts
-import { existsSync as existsSync24, readFileSync as readFileSync24, appendFileSync as appendFileSync5, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14 } from "fs";
-import { join as join24 } from "path";
-import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync23, readFileSync as readFileSync23, appendFileSync as appendFileSync4, writeFileSync as writeFileSync14, mkdirSync as mkdirSync13 } from "fs";
+import { join as join23 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 function agentSpansPath(dir) {
-  return join24(codebaseDir(dir), "AGENT_SPANS.jsonl");
+  return join23(codebaseDir(dir), "AGENT_SPANS.jsonl");
 }
 function loadAllSpans(dir) {
   const p = agentSpansPath(dir);
-  if (!existsSync24(p))
+  if (!existsSync23(p))
     return [];
   try {
-    return readFileSync24(p, "utf-8").trim().split(`
+    return readFileSync23(p, "utf-8").trim().split(`
 `).filter(Boolean).map((l) => JSON.parse(l));
   } catch {
     return [];
@@ -9120,18 +8667,18 @@ function loadAllSpans(dir) {
 function saveAllSpans(dir, spans) {
   const p = agentSpansPath(dir);
   const cd = codebaseDir(dir);
-  if (!existsSync24(cd))
-    mkdirSync14(cd, { recursive: true });
-  writeFileSync15(p, spans.map((s) => JSON.stringify(s)).join(`
+  if (!existsSync23(cd))
+    mkdirSync13(cd, { recursive: true });
+  writeFileSync14(p, spans.map((s) => JSON.stringify(s)).join(`
 `) + `
 `, "utf-8");
 }
 function openSpan(dir, opts) {
   const cd = codebaseDir(dir);
-  if (!existsSync24(cd))
-    mkdirSync14(cd, { recursive: true });
+  if (!existsSync23(cd))
+    mkdirSync13(cd, { recursive: true });
   const span = {
-    span_id: randomUUID4(),
+    span_id: randomUUID2(),
     trace_id: opts.trace_id,
     parent_span_id: opts.parent_span_id,
     invoker: opts.invoker,
@@ -9147,7 +8694,7 @@ function openSpan(dir, opts) {
     depth: opts.depth ?? 0,
     model: opts.model
   };
-  appendFileSync5(agentSpansPath(dir), JSON.stringify(span) + `
+  appendFileSync4(agentSpansPath(dir), JSON.stringify(span) + `
 `, "utf-8");
   return span;
 }
@@ -9192,9 +8739,6 @@ function addSpanViolation(dir, span_id, violation) {
 function recordContractViolation(dir, span_id, violation) {
   addSpanViolation(dir, span_id, violation);
 }
-function getSpan(dir, span_id) {
-  return loadAllSpans(dir).findLast((s) => s.span_id === span_id) ?? null;
-}
 function getTraceSpans(dir, trace_id) {
   return loadAllSpans(dir).filter((s) => s.trace_id === trace_id);
 }
@@ -9216,21 +8760,21 @@ function resolveConfig(directory) {
   }
 }
 function deadlockSignalsPath(dir) {
-  return join25(codebaseDir(dir), "DEADLOCK_SIGNALS.jsonl");
+  return join24(codebaseDir(dir), "DEADLOCK_SIGNALS.jsonl");
 }
 function appendSignal(dir, signal) {
   const cd = codebaseDir(dir);
-  if (!existsSync25(cd))
-    mkdirSync15(cd, { recursive: true });
-  appendFileSync6(deadlockSignalsPath(dir), JSON.stringify(signal) + `
+  if (!existsSync24(cd))
+    mkdirSync14(cd, { recursive: true });
+  appendFileSync5(deadlockSignalsPath(dir), JSON.stringify(signal) + `
 `, "utf-8");
 }
 function getSignals(dir, trace_id) {
   const p = deadlockSignalsPath(dir);
-  if (!existsSync25(p))
+  if (!existsSync24(p))
     return [];
   try {
-    const all = readFileSync25(p, "utf-8").trim().split(`
+    const all = readFileSync24(p, "utf-8").trim().split(`
 `).filter(Boolean).map((l) => JSON.parse(l));
     return trace_id ? all.filter((s) => s.trace_id === trace_id) : all;
   } catch {
@@ -9248,7 +8792,7 @@ function detectAgentBounce(dir, trace_id, cfg) {
     if (count >= cfg.bounceThreshold) {
       const [a, b] = pair.split("→");
       return {
-        signal_id: randomUUID5(),
+        signal_id: randomUUID3(),
         trace_id,
         detected_at: new Date().toISOString(),
         type: "agent_bounce",
@@ -9290,7 +8834,7 @@ function detectCircularDelegation(dir, trace_id, cfg) {
       const cycle = findCycle(node, visited, [node]);
       if (cycle) {
         return {
-          signal_id: randomUUID5(),
+          signal_id: randomUUID3(),
           trace_id,
           detected_at: new Date().toISOString(),
           type: "circular_delegation",
@@ -9318,7 +8862,7 @@ function detectStepRetryLoop(dir, trace_id, cfg) {
   for (const [key, count] of Object.entries(stageCounts)) {
     if (count >= cfg.retryLoopThreshold) {
       return {
-        signal_id: randomUUID5(),
+        signal_id: randomUUID3(),
         trace_id,
         detected_at: new Date().toISOString(),
         type: "step_retry_loop",
@@ -9340,7 +8884,7 @@ function detectStageStall(dir, trace_id, cfg) {
     const elapsed = (now - new Date(span.started_at).getTime()) / 1000 / 60;
     if (elapsed >= cfg.stageStallMinutes) {
       return {
-        signal_id: randomUUID5(),
+        signal_id: randomUUID3(),
         trace_id,
         detected_at: new Date().toISOString(),
         type: "stage_stall",
@@ -9377,29 +8921,29 @@ function isTraceStuck(dir, trace_id) {
 
 // src/services/audit-log.ts
 import {
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync16,
-  appendFileSync as appendFileSync7,
-  readFileSync as readFileSync26,
-  writeFileSync as writeFileSync16,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync15,
+  appendFileSync as appendFileSync6,
+  readFileSync as readFileSync25,
+  writeFileSync as writeFileSync15,
   renameSync,
   unlinkSync
 } from "fs";
-import { join as join26 } from "path";
+import { join as join25 } from "path";
 var AUDIT_FILE = "AUDIT.jsonl";
 var ROTATE_LINE_COUNT = 1000;
 function auditPath(directory) {
-  return join26(codebaseDir(directory), AUDIT_FILE);
+  return join25(codebaseDir(directory), AUDIT_FILE);
 }
 function ensureDirectory(dir) {
   const base = codebaseDir(dir);
-  if (!existsSync26(base)) {
-    mkdirSync16(base, { recursive: true });
+  if (!existsSync25(base)) {
+    mkdirSync15(base, { recursive: true });
   }
 }
 function rotateIfNeeded(path, appLog) {
   try {
-    const content = readFileSync26(path, "utf-8");
+    const content = readFileSync25(path, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     if (lines.length <= ROTATE_LINE_COUNT)
@@ -9407,7 +8951,7 @@ function rotateIfNeeded(path, appLog) {
     const backupPath = `${path}.backup`;
     renameSync(path, backupPath);
     const keep = lines.slice(-ROTATE_LINE_COUNT);
-    writeFileSync16(path, keep.join(`
+    writeFileSync15(path, keep.join(`
 `) + `
 `, "utf-8");
     try {
@@ -9423,16 +8967,16 @@ function rotateIfNeeded(path, appLog) {
 function appendAuditEntry(directory, entry, appLog) {
   ensureDirectory(directory);
   const path = auditPath(directory);
-  appendFileSync7(path, JSON.stringify(entry) + `
+  appendFileSync6(path, JSON.stringify(entry) + `
 `, "utf-8");
   rotateIfNeeded(path, appLog);
 }
 function queryAudit(directory, filter) {
   const path = auditPath(directory);
-  if (!existsSync26(path))
+  if (!existsSync25(path))
     return [];
   try {
-    const lines = readFileSync26(path, "utf-8").split(`
+    const lines = readFileSync25(path, "utf-8").split(`
 `).filter((line) => line.trim().length > 0);
     const results = [];
     for (const line of lines) {
@@ -9498,7 +9042,7 @@ function validationToDecision(result) {
 }
 function buildAuditEntry(input, decision) {
   return {
-    id: randomUUID6(),
+    id: randomUUID4(),
     timestamp: new Date().toISOString(),
     run_id: input.runId,
     session_id: input.sessionID,
@@ -9531,11 +9075,6 @@ function createHarnessPolicy(directory, appLog) {
       }
     }
   }
-  function ensureBudget(runId) {
-    if (!getBudget(runId)) {
-      init(runId, config);
-    }
-  }
   function checkRuntimeLimits(input) {
     try {
       const loop = loopDetector.checkBefore(input.tool, input.args, input.sessionID);
@@ -9545,11 +9084,6 @@ function createHarnessPolicy(directory, appLog) {
       if (loop.action === "warn") {
         return allow4(loop.message, "loop-detector", ["loop-warning"]);
       }
-      ensureBudget(input.runId);
-      const spend = checkSpend(input.runId, input.tool);
-      if (spend.verdict === "deny") {
-        return deny3(spend.reason, "delegation-budget", spend.escalationMessage ?? "Tool call budget exhausted", ["budget-exhausted"]);
-      }
       if (isTraceStuck(input.directory, input.runId)) {
         return deny3("Run is stuck (deadlock signal with auto_stop)", "deadlock-detector", "Deadlock detection flagged this run for auto-stop. Escalate to the human.", ["deadlock"]);
       }
@@ -9728,7 +9262,7 @@ function createHarnessPolicy(directory, appLog) {
 }
 
 // src/services/harness-controller.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/services/preflight-explorer.ts
 var QUESTION_KIND_PATTERNS = [
@@ -10242,10 +9776,86 @@ function classifyTaskWithContext(description, exploration, sessionHistory = [])
   };
 }
 
+// src/services/run-trace.ts
+import { existsSync as existsSync26, readFileSync as readFileSync26, appendFileSync as appendFileSync7, writeFileSync as writeFileSync16, mkdirSync as mkdirSync16 } from "fs";
+import { join as join26 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+function runsPath(dir) {
+  return join26(codebaseDir(dir), "RUNS.jsonl");
+}
+function startTrace(dir, command, args, session_id = "session-0") {
+  const cd = codebaseDir(dir);
+  if (!existsSync26(cd))
+    mkdirSync16(cd, { recursive: true });
+  const trace = {
+    run_id: randomUUID5(),
+    session_id,
+    command,
+    args,
+    started_at: new Date().toISOString(),
+    status: "running",
+    files_touched: [],
+    event_ids: [],
+    risk_score: 0
+  };
+  appendFileSync7(runsPath(dir), JSON.stringify(trace) + `
+`, "utf-8");
+  return trace;
+}
+function loadAllTraces(dir) {
+  const p = runsPath(dir);
+  if (!existsSync26(p))
+    return [];
+  try {
+    return readFileSync26(p, "utf-8").trim().split(`
+`).filter(Boolean).map((l) => JSON.parse(l));
+  } catch {
+    return [];
+  }
+}
+function saveAllTraces(dir, traces) {
+  const p = runsPath(dir);
+  writeFileSync16(p, traces.map((t) => JSON.stringify(t)).join(`
+`) + `
+`, "utf-8");
+}
+function endTrace(dir, run_id, status, outcome, error) {
+  const traces = loadAllTraces(dir);
+  const idx = traces.findLastIndex((t) => t.run_id === run_id);
+  if (idx === -1)
+    return;
+  traces[idx] = {
+    ...traces[idx],
+    ended_at: new Date().toISOString(),
+    status,
+    ...outcome ? { outcome } : {},
+    ...error ? { error } : {}
+  };
+  saveAllTraces(dir, traces);
+}
+function getTrace(dir, run_id) {
+  return loadAllTraces(dir).findLast((t) => t.run_id === run_id) ?? null;
+}
+function recordVerification(dir, run_id, kind, evidence) {
+  const traces = loadAllTraces(dir);
+  const idx = traces.findLastIndex((t) => t.run_id === run_id);
+  if (idx === -1)
+    return;
+  const list = traces[idx].verifications ?? [];
+  traces[idx] = {
+    ...traces[idx],
+    verifications: [
+      ...list,
+      { kind, evidence, timestamp: new Date().toISOString() }
+    ]
+  };
+  saveAllTraces(dir, traces);
+}
+
 // src/services/workflow-scorecard.ts
 import { existsSync as existsSync27, readFileSync as readFileSync27, appendFileSync as appendFileSync8, mkdirSync as mkdirSync17 } from "fs";
 import { join as join27 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var DIMENSION_WEIGHTS = {
   stageCompliance: 0.07,
   designFirstCompliance: 0.1,
@@ -10310,7 +9920,7 @@ function generateScorecard(dir, trace, input = {}) {
   const overallScore = Math.round(Object.entries(dimensions).reduce((sum, [key, val]) => sum + val * DIMENSION_WEIGHTS[key] * 100, 0));
   const completion_status = trace.status === "complete" ? "complete" : trace.status === "failed" ? "failed" : trace.status === "cancelled" ? "cancelled" : "blocked";
   const scorecard = {
-    scorecard_id: randomUUID7(),
+    scorecard_id: randomUUID6(),
     run_id: trace.run_id,
     session_id: trace.session_id,
     command: trace.command,
@@ -10363,7 +9973,9 @@ function createStatePersistence(options) {
         command,
         rootSpanId: span.span_id,
         currentSpanId: span.span_id,
-        status: "running"
+        status: "running",
+        toolCallCount: 0,
+        sameStepRetryCount: 0
       };
       contexts.set(sessionID, ctx);
       return ctx;
@@ -10386,25 +9998,6 @@ function createStatePersistence(options) {
         }
       }
     },
-    openAgentSpan(ctx, parentSpanId, agent, task, stage3) {
-      const parent = parentSpanId ? getSpan(directory, parentSpanId) : undefined;
-      const depth = parent ? parent.depth + 1 : 0;
-      const span = openSpan(directory, {
-        trace_id: ctx.runId,
-        invoker: ctx.command,
-        agent,
-        task_description: task,
-        stage: stage3,
-        parent_span_id: parentSpanId,
-        depth
-      });
-      const updated = { ...ctx, currentSpanId: span.span_id };
-      contexts.set(ctx.sessionID, updated);
-      return span;
-    },
-    closeAgentSpan(spanId, status, opts = {}) {
-      closeSpan(directory, spanId, status === "running" ? "failed" : status, opts);
-    },
     recordObservation(ctx, type, content) {
       const list = observations.get(ctx.runId) ?? [];
       list.push({
@@ -10425,8 +10018,8 @@ function createStatePersistence(options) {
 
 // src/services/execution-substrate.ts
 var executions = new Map;
-function makeKey(runId, sessionID, tool14) {
-  return `${runId}:${sessionID}:${tool14}`;
+function makeKey(runId, sessionID, tool13) {
+  return `${runId}:${sessionID}:${tool13}`;
 }
 function createExecutionSubstrate() {
   return {
@@ -10894,7 +10487,7 @@ function blockMessage(toolName) {
 
 ` + `Allowed tools for orchestrator: ${allowed.join(", ")}.
 
-` + `To delegate execution, use the \`delegate\` tool.
+` + `To route execution, mention the agent directly: @default-executor, @backend-coder, etc.
 
 ` + `To disable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=off`;
 }
@@ -11096,6 +10689,7 @@ function createVerificationLayer(directory) {
 
 // src/services/recovery-layer.ts
 var AUTO_STOP_TYPES = ["circular_delegation"];
+var retryCounts = new Map;
 function signalToRecoveryAction(signal) {
   switch (signal.recommended_action) {
     case "stop":
@@ -11109,10 +10703,10 @@ function signalToRecoveryAction(signal) {
       return "retry";
   }
 }
-function formatBudget(budget) {
-  if (!budget)
-    return "budget unavailable";
-  return `tool_calls=${budget.spentToolCalls}/${budget.maxToolCalls}, depth=${budget.currentDepth}/${budget.maxDepth}, retries=${budget.sameStepRetries}/${budget.maxSameStepRetries}`;
+function formatBudget(ctx) {
+  const toolCalls = ctx.toolCallCount ?? 0;
+  const retries = ctx.sameStepRetryCount ?? 0;
+  return `tool_calls=${toolCalls}, retries=${retries}`;
 }
 function taskTypeToFailureTag(taskType) {
   switch (taskType) {
@@ -11143,11 +10737,10 @@ function createRecoveryLayer(appLog) {
       return isTraceStuck(dir, runId);
     },
     explainBlockage(ctx) {
-      const budget = getBudget(ctx.runId);
       const signals = detectDeadlocks(ctx.directory, ctx.runId);
       const lines = [];
       lines.push(`Run ${ctx.runId} (${ctx.command}) is blocked.`);
-      lines.push(`Budget state: ${formatBudget(budget)}`);
+      lines.push(`Budget state: ${formatBudget(ctx)}`);
       if (signals.length === 0) {
         lines.push("No deadlock signals detected.");
       } else {
@@ -11160,14 +10753,11 @@ function createRecoveryLayer(appLog) {
 `);
     },
     recommendRecovery(ctx, signals) {
-      const budget = getBudget(ctx.runId);
       if (signals.some((s) => s.auto_stop || AUTO_STOP_TYPES.includes(s.type))) {
         return "stop";
       }
-      if (budget && budget.remainingToolCalls <= 0) {
-        return "escalate";
-      }
-      if (budget && budget.sameStepRetries >= budget.maxSameStepRetries) {
+      const maxRetries = 3;
+      if ((ctx.sameStepRetryCount ?? 0) >= maxRetries) {
         return "escalate";
       }
       const severityOrder = ["stop", "escalate", "fallback-agent", "retry"];
@@ -11179,7 +10769,9 @@ function createRecoveryLayer(appLog) {
       return "retry";
     },
     canRetry(runId) {
-      return incrementSameStepRetry(runId);
+      const current = retryCounts.get(runId) ?? 0;
+      retryCounts.set(runId, current + 1);
+      return current < 3;
     },
     getRelevantFailures(dir, taskType) {
       try {
@@ -11260,8 +10852,8 @@ function createToolOutcomeHandler(deps) {
     executionSubstrate,
     state
   } = deps;
-  function getLastAuditEntryId(runId, tool14) {
-    const entries = auditLog.query({ run_id: runId, tool: tool14 });
+  function getLastAuditEntryId(runId, tool13) {
+    const entries = auditLog.query({ run_id: runId, tool: tool13 });
     return entries.at(-1)?.id;
   }
   return (req, output, status) => {
@@ -11409,8 +11001,8 @@ function createHarnessController(config) {
   const orchestratorGuard = new OrchestratorGuard;
   orchestratorGuard.setPolicy(policy);
   const loopDetector = lazy(() => {
-    const flowdeckConfig = loadFlowDeckConfig(directory);
-    const loopCfg = flowdeckConfig.governance?.loopDetection ?? {};
+    const flowdeckConfig2 = loadFlowDeckConfig(directory);
+    const loopCfg = flowdeckConfig2.governance?.loopDetection ?? {};
     return new LoopDetector({
       enabled: loopCfg.enabled ?? true,
       maxRepeats: loopCfg.maxRepeats ?? 2,
@@ -11424,6 +11016,12 @@ function createHarnessController(config) {
   const contextMonitor = lazy(() => config.contextMonitor ?? createContextWindowMonitorHook({
     getTotalBudget: (sessionID) => contextIngress.getTotalBudget(sessionID)
   }));
+  const flowdeckConfig = loadFlowDeckConfig(directory);
+  const delegationConfig = flowdeckConfig.governance?.delegationBudget;
+  const maxDepth = delegationConfig?.maxDepth ?? 3;
+  const maxToolCalls = delegationConfig?.maxToolCalls ?? 200;
+  const sessionDepthMap = new Map;
+  const blockedSessions = new Set;
   const state = {
     loopDetector,
     eventLog,
@@ -11480,7 +11078,7 @@ function createHarnessController(config) {
   };
   function buildCommandAuditEntry(req, runCtx) {
     return {
-      id: randomUUID8(),
+      id: randomUUID7(),
       timestamp: new Date().toISOString(),
       run_id: runCtx.runId,
       session_id: req.sessionID,
@@ -11601,10 +11199,52 @@ function createHarnessController(config) {
     recordToolOutcome(req, output, status) {
       toolOutcomeHandler(req, output, status);
     },
+    checkToolCallBudget(sessionID) {
+      if (blockedSessions.has(sessionID)) {
+        return {
+          allow: false,
+          reason: `Session ${sessionID} blocked: delegation depth limit exceeded. Agent must surface result to user rather than delegating further.`
+        };
+      }
+      const runCtx = statePersistence.getRunContext(sessionID);
+      if (runCtx) {
+        const nextCount = (runCtx.toolCallCount ?? 0) + 1;
+        if (nextCount > maxToolCalls) {
+          return {
+            allow: false,
+            reason: `Run ${runCtx.runId} exceeded maxToolCalls (${maxToolCalls}). Stop and summarize progress to the user.`
+          };
+        }
+        statePersistence.updateRunContext({ ...runCtx, toolCallCount: nextCount });
+      }
+      return { allow: true };
+    },
     async onSessionEvent(evt) {
       const type = evt.type;
       const properties = evt.properties ?? {};
-      const sessionID = String(properties.sessionID ?? properties.id ?? properties.sessionId ?? "");
+      const sessionID = extractSessionId2(properties) ?? "";
+      const parentSessionID = extractParentSessionId2(properties);
+      if (type === "session.created" && sessionID) {
+        if (parentSessionID) {
+          const parentCtx = statePersistence.getRunContext(parentSessionID);
+          if (parentCtx) {
+            statePersistence.updateRunContext({ ...parentCtx, sessionID });
+          }
+          const parentDepth = sessionDepthMap.get(parentSessionID) ?? 0;
+          const childDepth = parentDepth + 1;
+          sessionDepthMap.set(sessionID, childDepth);
+          if (childDepth > maxDepth) {
+            log(`[harness] delegation depth ${childDepth} exceeds maxDepth ${maxDepth} — session ${sessionID} will be policy-blocked`);
+            blockedSessions.add(sessionID);
+          }
+        } else {
+          sessionDepthMap.set(sessionID, 0);
+        }
+      }
+      if ((type === "session.idle" || type === "session.error") && sessionID) {
+        sessionDepthMap.delete(sessionID);
+        blockedSessions.delete(sessionID);
+      }
       orchestratorGuard.onEvent({ type, properties });
       if (type === "session.created" || type === "session.started") {
         const healthy = await eventLog.get().session({ directory }, { type, properties });
@@ -11651,6 +11291,30 @@ function createHarnessController(config) {
     }
   };
 }
+function extractSessionId2(props) {
+  const id = props.sessionID ?? props.sessionId ?? props.id;
+  if (typeof id === "string")
+    return id;
+  const info = props.info;
+  if (typeof info?.sessionID === "string")
+    return info.sessionID;
+  if (typeof info?.sessionId === "string")
+    return info.sessionId;
+  if (typeof info?.id === "string")
+    return info.id;
+  return;
+}
+function extractParentSessionId2(props) {
+  const parentId = props.parentID ?? props.parentId ?? props.parentSessionId ?? props.parent_session_id;
+  if (typeof parentId === "string")
+    return parentId;
+  const info = props.info;
+  if (typeof info?.parentID === "string")
+    return info.parentID;
+  if (typeof info?.parentId === "string")
+    return info.parentId;
+  return;
+}
 
 // src/index.ts
 function lazyLoadRulePaths(projectRoot) {
@@ -11710,7 +11374,6 @@ var plugin = async (input, _options) => {
     contextIngress
   });
   harness.init();
-  const delegateTool = createDelegateTool(client, harness.getStatePersistence(), (input2) => harness.ensureRunContext(input2));
   const contextMonitor = harness.getContextMonitor();
   const shellEnvHook = createShellEnvHook({ directory, worktree });
   const todoHook = createTodoHook(client);
@@ -11816,8 +11479,7 @@ var plugin = async (input, _options) => {
       codegraph: codegraphTool,
       "load-rules": loadRulesTool,
       "list-rules": listRulesTool,
-      "merge-assist": mergeAssistTool,
-      delegate: delegateTool
+      "merge-assist": mergeAssistTool
     },
     "shell.env": shellEnvHook,
     "todo.updated": todoHook,
@@ -11870,6 +11532,11 @@ var plugin = async (input, _options) => {
       }
     },
     "tool.execute.before": async (toolInput, toolOutput) => {
+      const sessionID = toolInput.sessionID ?? "";
+      const budgetCheck = harness.checkToolCallBudget(sessionID);
+      if (!budgetCheck.allow) {
+        throw new Error(budgetCheck.reason ?? `Tool blocked: ${budgetCheck.reason}`);
+      }
       if ((toolInput.tool === "read" || toolInput.tool === "view") && toolOutput?.args) {
         if (typeof toolOutput.args.offset === "string") {
           const n = Number(toolOutput.args.offset);
@@ -11881,7 +11548,7 @@ var plugin = async (input, _options) => {
         }
       }
       const decision = harness.evaluateToolCall({
-        sessionID: toolInput.sessionID ?? "",
+        sessionID,
         tool: toolInput.tool ?? toolInput.name ?? "unknown",
         args: toolOutput?.args ?? toolInput?.args ?? {},
         agent: toolInput.agent