@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/slash/slash-commands.js

@@ -2,8 +2,10 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText } from "@duckmind/dm-coding-agent";
-import { Key, matchesKey } from "@duckmind/dm-tui";
-import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll } from "../agents/agents.js";
+import { Key, matchesKey, truncateToWidth } from "@duckmind/dm-tui";
+import { BUILTIN_AGENT_NAMES, discoverAgentSnapshot, discoverAgents, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext } from "../agents/agents.js";
+import { listRuntimeAgentConfigs, mergeRuntimeAgents } from "../agents/runtime-agent-registry.js";
+import { resolveExistingReadPaths } from "../shared/settings.js";
 import {
   DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
   applySubagentProfile,
@@ -13,12 +15,21 @@ import {
   readSubagentProfile,
   refreshProviderModelCatalog
 } from "../profiles/profiles.js";
-import { isDynamicParallelStep, isParallelStep } from "../shared/settings.js";
 import { findModelInfo, toModelInfo } from "../shared/model-info.js";
-import { formatTokens } from "../shared/formatters.js";
-import { assertJsonSchemaObject } from "../runs/shared/structured-output.js";
-import { validateAcceptanceInput } from "../runs/shared/acceptance.js";
+import { formatTokens, shortenPath } from "../shared/formatters.js";
+import { listAsyncRuns, formatAsyncRunProgressLabel } from "../runs/background/async-status.js";
+import { encodeInspectReply, handleInspectRpcArgs, INSPECT_WIDGET_KEY } from "../runs/background/inspect-rpc.js";
+import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.js";
+import { SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/dm-args.js";
+import { resolveAsyncStatusChild } from "../runs/shared/child-identity.js";
+import { readStatus } from "../shared/utils.js";
+import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.js";
+import { readWorkflowReceipt } from "../workflows/workflow-receipt.js";
+import { FLEET_OPEN_SHORTCUT } from "../shared/shortcuts.js";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.js";
+import { openSubagentsAdmin } from "./subagents-admin.js";
+import { SUBAGENT_GUIDE_TOPICS } from "../extension/subagent-guide.js";
+import { openSubagentFleet } from "../tui/fleet.js";
 import {
   applySlashUpdate,
   buildSlashInitialResult,
@@ -33,7 +44,8 @@ import {
   SLASH_SUBAGENT_REQUEST_EVENT,
   SLASH_SUBAGENT_RESPONSE_EVENT,
   SLASH_SUBAGENT_STARTED_EVENT,
-  SLASH_SUBAGENT_UPDATE_EVENT
+  SLASH_SUBAGENT_UPDATE_EVENT,
+  DIRS
 } from "../shared/types.js";
 const parseInlineConfig = (raw) => {
   const config = {};
@@ -42,11 +54,8 @@ const parseInlineConfig = (raw) => {
     if (!trimmed)
       continue;
     const eq = trimmed.indexOf("=");
-    if (eq === -1) {
-      if (trimmed === "progress")
-        config.progress = true;
+    if (eq === -1)
       continue;
-    }
     const key = trimmed.slice(0, eq).trim();
     const val = trimmed.slice(eq + 1).trim();
     switch (key) {
@@ -67,33 +76,6 @@ const parseInlineConfig = (raw) => {
       case "skills":
         config.skill = val === "false" ? false : val.split("+").filter(Boolean);
         break;
-      case "progress":
-        config.progress = val !== "false";
-        break;
-      case "as":
-        config.as = val || undefined;
-        break;
-      case "label":
-        config.label = val || undefined;
-        break;
-      case "phase":
-        config.phase = val || undefined;
-        break;
-      case "cwd":
-        config.cwd = val || undefined;
-        break;
-      case "count": {
-        const n = Number(val);
-        if (Number.isInteger(n) && n > 0)
-          config.count = n;
-        break;
-      }
-      case "outputSchema":
-        config.outputSchema = val || undefined;
-        break;
-      case "acceptance":
-        config.acceptance = val || undefined;
-        break;
     }
   }
   return config;
@@ -124,73 +106,27 @@ const extractExecutionFlags = (rawArgs) => {
   }
   return { args, bg, fork };
 };
-const makeAgentCompletions = (state, multiAgent) => (prefix) => {
-  if (!state.baseCwd)
-    return null;
-  const agents = discoverAgents(state.baseCwd, "both").agents;
-  if (!multiAgent) {
-    if (prefix.includes(" "))
-      return null;
-    return agents.filter((a) => a.name.startsWith(prefix)).map((a) => ({ value: a.name, label: a.name }));
-  }
-  let inSingle = false, inDouble = false, depth = 0, segStart = 0;
-  for (let i = 0;i < prefix.length; i++) {
-    const ch = prefix[i];
-    if (inSingle) {
-      if (ch === "'")
-        inSingle = false;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === '"')
-        inDouble = false;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (ch === "(") {
-      if (!prefix.slice(segStart, i).includes(" -- ")) {
-        depth++;
-        segStart = i + 1;
-      }
-    } else if (ch === ")") {
-      if (depth > 0) {
-        depth--;
-        segStart = i + 1;
-      }
-    } else if (ch === "|" && depth > 0)
-      segStart = i + 1;
-    else if (ch === ">" && prefix[i - 1] === "-" && depth === 0)
-      segStart = i + 1;
-  }
-  if (inSingle || inDouble)
-    return null;
-  const segment = prefix.slice(segStart);
-  if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'"))
-    return null;
-  const lastWord = (segment.match(/(\S*)$/) || ["", ""])[1];
-  let beforeLastWord = prefix.slice(0, prefix.length - lastWord.length);
-  if (lastWord === "" && /[>|]$/.test(beforeLastWord))
-    beforeLastWord = `${beforeLastWord} `;
-  return agents.filter((a) => a.name.startsWith(lastWord)).map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
-};
-const discoverSavedChains = (cwd) => {
-  const chainsByName = new Map;
-  for (const chain of discoverAgentsAll(cwd).chains) {
-    chainsByName.set(chain.name, chain);
+function discoverSlashAgents(dm, cwd, scope) {
+  if (listRuntimeAgentConfigs(dm).length === 0) {
+    const discovered = discoverAgents(cwd, scope);
+    return { ...discovered, unknownAgentDiagnosticContext: unknownAgentDiagnosticContext(discovered) };
   }
-  return Array.from(chainsByName.values());
-};
-const makeChainCompletions = (state) => (prefix) => {
-  if (prefix.includes(" ") || !state.baseCwd)
+  const snapshot = discoverAgentSnapshot(cwd, scope, undefined, { includeChains: false });
+  const discovered = snapshot.effective;
+  const all = snapshot.all;
+  const configuredAgents = [
+    ...all.builtin,
+    ...all.package,
+    ...scope !== "project" ? all.user : [],
+    ...scope !== "user" ? all.project : []
+  ];
+  const merged = mergeRuntimeAgents(dm, discovered, configuredAgents);
+  return { ...merged, unknownAgentDiagnosticContext: { ...unknownAgentDiagnosticContext(discovered), agents: merged.agents } };
+}
+const makeAgentCompletions = (dm, state) => (prefix) => {
+  if (!state.baseCwd || prefix.includes(" "))
     return null;
-  return discoverSavedChains(state.baseCwd).filter((chain) => chain.name.startsWith(prefix)).map((chain) => ({ value: chain.name, label: chain.name }));
+  return discoverSlashAgents(dm, state.baseCwd, "both").agents.filter((agent) => agent.name.startsWith(prefix)).map((agent) => ({ value: agent.name, label: agent.name }));
 };
 const makeBuiltinAgentNameCompletions = () => (prefix) => {
   if (prefix.includes(" "))
@@ -206,8 +142,8 @@ const makeProviderCompletions = (state) => (prefix) => {
   const providers = [...new Set(available.map((model) => typeof model?.provider === "string" ? model.provider : "").filter(Boolean))].sort((a, b) => a.localeCompare(b));
   return providers.filter((provider) => provider.startsWith(prefix)).map((provider) => ({ value: provider, label: provider }));
 };
-function sendSlashText(pi, text) {
-  pi.sendMessage({ customType: SLASH_TEXT_RESULT_TYPE, content: text, display: true });
+function sendSlashText(dm, text) {
+  dm.sendMessage({ customType: SLASH_TEXT_RESULT_TYPE, content: text, display: true });
 }
 async function withSlashStatus(ctx, text, run) {
   if (ctx.hasUI)
@@ -219,6 +155,149 @@ async function withSlashStatus(ctx, text, run) {
       ctx.ui.setStatus("subagent-slash-text", undefined);
   }
 }
+function commandForTarget(target) {
+  return target.kind === "scheduled" ? `subagent({ action: "schedule.pause", id: ${JSON.stringify(target.id)} })` : `subagent({ action: "stop", id: ${JSON.stringify(target.id)} })`;
+}
+function formatAsyncStopTarget(run) {
+  const progress = formatAsyncRunProgressLabel(run);
+  const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
+  return {
+    kind: "async",
+    id: run.id,
+    label: `${run.id} · ${run.mode} · ${progress}`,
+    detail: `${run.state} · ${cwd}`,
+    actionLabel: "stop async run"
+  };
+}
+function scheduledStopTargets(ctx, _state) {
+  try {
+    return listScheduledRunSummaries(ctx.cwd).filter((schedule) => !schedule.paused && !schedule.activeRunId && schedule.trigger.nextRunAt).sort((left, right) => left.trigger.nextRunAt.localeCompare(right.trigger.nextRunAt)).map((schedule) => ({
+      kind: "scheduled",
+      id: schedule.id,
+      label: `${schedule.id} · ${schedule.name}`,
+      detail: `scheduled · ${schedule.trigger.nextRunAt}`,
+      actionLabel: "pause schedule"
+    }));
+  } catch {
+    return [];
+  }
+}
+function discoverStopTargets(ctx, state) {
+  const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined;
+  const asyncTargets = listAsyncRuns(DIRS.async, {
+    states: ["queued", "running"],
+    ...sessionId ? { sessionId } : {}
+  }).map(formatAsyncStopTarget);
+  return [...asyncTargets, ...scheduledStopTargets(ctx, state)];
+}
+function stopFallbackText(targets) {
+  if (targets.length === 0)
+    return "No active current-session async runs or scheduled subagent runs to stop.";
+  const lines = ["Subagent stop targets:", ""];
+  for (const target of targets) {
+    lines.push(`- ${target.label}`);
+    lines.push(`  ${target.detail}`);
+    lines.push(`  ${target.actionLabel}: ${commandForTarget(target)}`);
+    if (target.kind === "async")
+      lines.push(`  slash: /subagents-stop ${target.id}`);
+  }
+  return lines.join(`
+`);
+}
+function selectForegroundDetachControl(state, requested) {
+  const controls = [...state.foregroundControls.values()];
+  if (requested) {
+    const matches = controls.filter((control) => control.runId === requested || control.runId.startsWith(requested));
+    if (matches.length > 1)
+      throw new Error(`Ambiguous foreground run id prefix '${requested}' matched: ${matches.map((control) => control.runId).join(", ")}. Provide a longer id.`);
+    return matches[0];
+  }
+  const singleControls = controls.filter((control) => control.mode === "single");
+  if (state.lastForegroundControlId) {
+    const latest = state.foregroundControls.get(state.lastForegroundControlId);
+    if (latest?.mode === "single")
+      return latest;
+  }
+  return singleControls.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+}
+
+class SubagentsStopSelector {
+  width = 84;
+  selected = 0;
+  confirming = false;
+  tui;
+  theme;
+  targets;
+  done;
+  constructor(tui, theme, targets, done) {
+    this.tui = tui;
+    this.theme = theme;
+    this.targets = targets;
+    this.done = done;
+  }
+  handleInput(data) {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+      this.done({ confirmed: false });
+      return;
+    }
+    if (this.confirming) {
+      if (matchesKey(data, "return") || data.toLowerCase() === "y") {
+        this.done({ confirmed: true, target: this.targets[this.selected] });
+        return;
+      }
+      if (data.toLowerCase() === "n" || matchesKey(data, "backspace")) {
+        this.confirming = false;
+        this.tui.requestRender();
+      }
+      return;
+    }
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      this.selected = Math.max(0, this.selected - 1);
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      this.selected = Math.min(this.targets.length - 1, this.selected + 1);
+      this.tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, "return")) {
+      this.confirming = true;
+      this.tui.requestRender();
+    }
+  }
+  invalidate() {}
+  render(width) {
+    const contentWidth = Math.max(0, Math.min(this.width, Math.floor(width)));
+    const lines = [this.theme.bold("Stop subagent run"), this.theme.fg("dim", "Select a current-session async run to stop, or a scheduled run to cancel."), ""];
+    const maxRows = 10;
+    const start = Math.max(0, Math.min(this.selected - maxRows + 1, Math.max(0, this.targets.length - maxRows)));
+    for (let index = start;index < Math.min(this.targets.length, start + maxRows); index++) {
+      const target = this.targets[index];
+      const selected = index === this.selected;
+      const marker = selected ? "›" : " ";
+      const actionLabel = target.actionLabel;
+      const action = target.kind === "scheduled" ? this.theme.fg("warning", actionLabel) : this.theme.fg("accent", actionLabel);
+      const labelWidth = Math.max(0, contentWidth - marker.length - actionLabel.length - 2);
+      lines.push(`${marker} ${action} ${target.label.slice(0, labelWidth)}`);
+      if (selected)
+        lines.push(this.theme.fg("dim", `  ${target.detail}`.slice(0, contentWidth)));
+    }
+    if (this.targets.length > maxRows)
+      lines.push(this.theme.fg("dim", `Showing ${start + 1}-${Math.min(this.targets.length, start + maxRows)} of ${this.targets.length}`));
+    lines.push("");
+    if (this.confirming) {
+      const target = this.targets[this.selected];
+      lines.push(this.theme.fg("warning", `Confirm: ${target.actionLabel} ${target.id}?`));
+      if (target.kind === "async")
+        lines.push(this.theme.fg("dim", "Stop ends this run; use interrupt for a resumable pause."));
+      lines.push(this.theme.fg("dim", "Enter/Y confirms · N returns · Esc cancels"));
+    } else {
+      lines.push(this.theme.fg("dim", "↑↓/jk select · Enter confirm · Esc cancel"));
+    }
+    return lines.map((line) => truncateToWidth(line, contentWidth));
+  }
+}
 function emptyUsage() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
 }
@@ -233,21 +312,59 @@ function addUsage(target, source) {
 function usageHasValue(usage) {
   return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0;
 }
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function usageFromValue(value, turnsOverride) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  const costValue = typeof record.cost === "object" && record.cost !== null && !Array.isArray(record.cost) ? record.cost.total : record.cost;
+  const turnsValue = turnsOverride ?? record.turns;
+  const usage = {
+    input: nonNegativeNumber(record.input) ?? 0,
+    output: nonNegativeNumber(record.output) ?? 0,
+    cacheRead: nonNegativeNumber(record.cacheRead) ?? 0,
+    cacheWrite: nonNegativeNumber(record.cacheWrite) ?? 0,
+    cost: nonNegativeNumber(costValue) ?? 0,
+    turns: nonNegativeNumber(turnsValue) ?? 0
+  };
+  return Number.isSafeInteger(usage.turns) ? usage : undefined;
+}
 function assistantUsageFromMessage(message) {
   if (!message || typeof message !== "object")
     return;
   const msg = message;
-  if (msg.role !== "assistant" || !msg.usage || typeof msg.usage !== "object")
+  return msg.role === "assistant" ? usageFromValue(msg.usage, 1) : undefined;
+}
+function compactionUsageFromEntry(entry) {
+  if (!entry || typeof entry !== "object")
     return;
-  const usage = msg.usage;
-  return {
-    input: typeof usage.input === "number" ? usage.input : 0,
-    output: typeof usage.output === "number" ? usage.output : 0,
-    cacheRead: typeof usage.cacheRead === "number" ? usage.cacheRead : 0,
-    cacheWrite: typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0,
-    cost: typeof usage.cost?.total === "number" ? usage.cost.total : 0,
-    turns: 1
-  };
+  const record = entry;
+  return record.type === "compaction" ? usageFromValue(record.usage, 0) : undefined;
+}
+const MAX_USAGE_METADATA_BYTES = 2 * 1024 * 1024;
+function readUsageMetadata(metadataPath) {
+  let fd;
+  try {
+    fd = fs.openSync(metadataPath, "r");
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile() || stat.size > MAX_USAGE_METADATA_BYTES)
+      return;
+    const buffer = Buffer.allocUnsafe(stat.size);
+    let offset = 0;
+    while (offset < buffer.length) {
+      const bytesRead = fs.readSync(fd, buffer, offset, buffer.length - offset, null);
+      if (bytesRead <= 0)
+        return;
+      offset += bytesRead;
+    }
+    const value = JSON.parse(buffer.toString("utf-8"));
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+  } finally {
+    if (fd !== undefined)
+      fs.closeSync(fd);
+  }
 }
 function isSubagentDetails(value) {
   if (!value || typeof value !== "object")
@@ -266,10 +383,33 @@ function detailsFromSessionEntry(entry) {
   if (record.type !== "message" || !record.message || typeof record.message !== "object")
     return;
   const message = record.message;
-  if (message.role !== "toolResult" || message.toolName !== "subagent")
+  if (message.role !== "toolResult" || message.toolName !== "subagent" && message.toolName !== "bg_wait" && message.toolName !== "subagent_wait")
     return;
   return isSubagentDetails(message.details) ? message.details : undefined;
 }
+function metadataUsage(artifactsDirs, input) {
+  if (!/^[A-Za-z0-9._-]+$/.test(input.runId))
+    return;
+  for (const artifactsDir of artifactsDirs) {
+    for (const index of [0, undefined]) {
+      const metadataPath = getArtifactPaths(artifactsDir, input.runId, input.agent, index).metadataPath;
+      try {
+        const metadata = readUsageMetadata(metadataPath);
+        if (!metadata)
+          continue;
+        if (metadata.runId !== input.runId || metadata.agent !== input.agent)
+          continue;
+        const usage = usageFromValue(metadata.usage);
+        if (usage && usageHasValue(usage))
+          return usage;
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          console.error(`Failed to read subagent usage metadata '${metadataPath}':`, error);
+      }
+    }
+  }
+  return;
+}
 function formatCostUsage(label, usage) {
   const extras = [
     usage.cacheRead ? `cache read ${formatTokens(usage.cacheRead)}` : "",
@@ -278,29 +418,98 @@ function formatCostUsage(label, usage) {
   ].filter(Boolean);
   return `${label}: ↑${formatTokens(usage.input)} ↓${formatTokens(usage.output)} $${usage.cost.toFixed(4)}${extras.length ? ` (${extras.join(", ")})` : ""}`;
 }
-function buildSubagentCostReport(ctx) {
+function buildSubagentCostReport(ctx, state) {
   const parent = emptyUsage();
   const childTotal = emptyUsage();
   const total = emptyUsage();
   const children = [];
+  const seenChildren = new Set;
+  const workflowRunIds = new Set;
+  let unresolvedAsyncChildren = 0;
+  const addChild = (input) => {
+    if (!input.usage || !usageHasValue(input.usage))
+      return false;
+    const identity = input.runId ? `run:${input.runId}` : input.sessionFile ? `session:${input.sessionFile}` : undefined;
+    if (identity && seenChildren.has(identity))
+      return true;
+    if (identity)
+      seenChildren.add(identity);
+    const usage = { ...input.usage };
+    children.push({
+      label: `Child ${children.length + 1} (${input.agent ?? "unknown"})`,
+      usage,
+      ...input.sessionFile ? { sessionFile: input.sessionFile } : {}
+    });
+    addUsage(childTotal, usage);
+    return true;
+  };
   for (const entry of ctx.sessionManager.getBranch()) {
     const message = entry.type === "message" ? entry.message : undefined;
-    const parentUsage = assistantUsageFromMessage(message);
+    const parentUsage = assistantUsageFromMessage(message) ?? compactionUsageFromEntry(entry);
     if (parentUsage)
       addUsage(parent, parentUsage);
     const details = detailsFromSessionEntry(entry);
     if (!details)
       continue;
+    if (details.mode === "workflow" && details.runId)
+      workflowRunIds.add(details.runId);
     for (const result of details.results) {
-      if (!usageHasValue(result.usage))
-        continue;
-      const usage = { ...result.usage };
-      children.push({
-        label: `Child ${children.length + 1} (${result.agent})`,
-        usage,
-        ...result.sessionFile ? { sessionFile: result.sessionFile } : {}
-      });
-      addUsage(childTotal, usage);
+      const resultRunId = result.runId;
+      addChild({ agent: result.agent, runId: typeof resultRunId === "string" ? resultRunId : undefined, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
+    }
+    for (const completion of details.completions ?? []) {
+      if (completion.mode === "workflow")
+        workflowRunIds.add(completion.runId);
+      for (const result of completion.results ?? []) {
+        addChild({ agent: result.agent, runId: result.runId, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
+      }
+    }
+  }
+  let sessionFile = null;
+  try {
+    sessionFile = ctx.sessionManager.getSessionFile() ?? null;
+  } catch {}
+  const artifactsDirs = new Set;
+  const addArtifactsDir = (cwd) => {
+    try {
+      artifactsDirs.add(getArtifactsDir(sessionFile, cwd, state.artifactDirPreference));
+    } catch {}
+  };
+  addArtifactsDir(ctx.cwd);
+  addArtifactsDir(state.baseCwd);
+  for (const workflowRunId of workflowRunIds) {
+    try {
+      const status = readStatus(path.join(DIRS.async, workflowRunId));
+      addArtifactsDir(status?.cwd);
+      const receipt = readWorkflowReceipt(DIRS.async, workflowRunId);
+      const summaryChildren = new Map((receipt.workflowChildren?.children ?? []).map((child) => [child.childId, child]));
+      const refsByRunId = new Map;
+      const addRef = (runId, agent) => {
+        if (!runId || !agent || refsByRunId.has(runId))
+          return;
+        refsByRunId.set(runId, { runId, agent });
+      };
+      for (const [key, entry] of Object.entries(receipt.entries)) {
+        const summaryChild = summaryChildren.get(key);
+        const runIds = entry.continuation?.runIds?.length ? entry.continuation.runIds : entry.latestRunId ? [entry.latestRunId] : summaryChild?.runId ? [summaryChild.runId] : [];
+        for (const runId of runIds)
+          addRef(runId, entry.agent ?? summaryChild?.agent);
+      }
+      for (const child of receipt.workflowChildren?.children ?? []) {
+        if (!Object.hasOwn(receipt.entries, child.childId))
+          addRef(child.runId, child.agent);
+      }
+      const refs = [...refsByRunId.values()];
+      for (const ref of refs) {
+        if (seenChildren.has(`run:${ref.runId}`))
+          continue;
+        const usage = metadataUsage([...artifactsDirs], ref);
+        if (!usage || !addChild({ ...ref, usage }))
+          unresolvedAsyncChildren += 1;
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        console.error(`Failed to resolve async subagent usage for '${workflowRunId}':`, error);
     }
   }
   addUsage(total, parent);
@@ -319,6 +528,8 @@ function buildSubagentCostReport(ctx) {
         lines.push(`  Session: ${child.sessionFile}`);
     }
   }
+  if (unresolvedAsyncChildren > 0)
+    lines.push(`Async child usage unavailable: ${unresolvedAsyncChildren}.`);
   lines.push("────────────────────────────", formatCostUsage("Children", childTotal), formatCostUsage("Total", total));
   return lines.join(`
 `);
@@ -333,119 +544,121 @@ function getProfileWorkerModel(profile) {
   const model = profile.subagents?.agentOverrides?.worker?.model;
   return typeof model === "string" && model.trim() ? model.trim() : undefined;
 }
-function loadSavedOutputSchema(chain, stepAgent, outputSchema) {
-  if (outputSchema === undefined)
-    return;
-  if (typeof outputSchema === "string") {
-    const schemaPath = path.isAbsolute(outputSchema) ? outputSchema : path.join(path.dirname(chain.filePath), outputSchema);
-    const parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
-    assertJsonSchemaObject(parsed, `outputSchema for chain '${chain.name}' step '${stepAgent}' (${schemaPath})`);
-    return parsed;
+function isStaleExtensionContextError(error) {
+  return error instanceof Error && (error.message.includes("This extension ctx is stale") || error.message.includes("Extension context no longer active"));
+}
+function slashHasUI(ctx) {
+  try {
+    return ctx.hasUI;
+  } catch (error) {
+    if (isStaleExtensionContextError(error))
+      return;
+    throw error;
   }
-  assertJsonSchemaObject(outputSchema, `outputSchema for chain '${chain.name}' step '${stepAgent}'`);
-  return outputSchema;
 }
-const mapSavedChainSteps = (chain, worktree = false) => {
-  return chain.steps.map((step) => {
-    if (isParallelStep(step)) {
-      const parallel = step.parallel.map((task) => {
-        const { outputSchema: rawOutputSchema, ...rest } = task;
-        const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-        return { ...rest, ...outputSchema ? { outputSchema } : {} };
-      });
-      return { ...step, parallel, ...worktree ? { worktree: true } : {} };
-    }
-    if (isDynamicParallelStep(step)) {
-      const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel;
-      const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-      const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-      return {
-        ...step,
-        parallel: { ...parallelRest, ...outputSchema ? { outputSchema } : {} },
-        collect: { ...step.collect, ...collectSchema ? { outputSchema: collectSchema } : {} }
-      };
-    }
-    const outputSchema = loadSavedOutputSchema(chain, step.agent, step.outputSchema);
-    return {
-      agent: step.agent,
-      task: step.task || undefined,
-      ...step.phase ? { phase: step.phase } : {},
-      ...step.label ? { label: step.label } : {},
-      ...step.as ? { as: step.as } : {},
-      ...outputSchema ? { outputSchema } : {},
-      ...step.acceptance !== undefined ? { acceptance: step.acceptance } : {},
-      output: step.output,
-      outputMode: step.outputMode,
-      reads: step.reads,
-      progress: step.progress,
-      skill: step.skill ?? step.skills,
-      model: step.model
-    };
-  });
-};
-async function requestSlashRun(pi, ctx, requestId, params) {
+async function requestSlashRun(dm, ctx, requestId, params, signal) {
   return new Promise((resolve, reject) => {
     let done = false;
     let started = false;
-    const startTimeoutMs = 15000;
-    const startTimeout = setTimeout(() => {
-      finish(() => reject(new Error("Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly.")));
-    }, startTimeoutMs);
+    let startTimeout;
     const onStarted = (data) => {
-      if (done || !data || typeof data !== "object")
+      if (done || signal?.aborted || !data || typeof data !== "object")
         return;
       if (data.requestId !== requestId)
         return;
       started = true;
-      clearTimeout(startTimeout);
-      if (ctx.hasUI)
-        ctx.ui.setStatus("subagent-slash", "running...");
+      if (startTimeout)
+        clearTimeout(startTimeout);
+      try {
+        if (ctx.hasUI)
+          ctx.ui.setStatus("subagent-slash", "running...");
+      } catch (error) {
+        if (isStaleExtensionContextError(error)) {
+          finish(() => reject(error));
+          return;
+        }
+        throw error;
+      }
     };
     const onResponse = (data) => {
-      if (done || !data || typeof data !== "object")
+      if (done || signal?.aborted || !data || typeof data !== "object")
         return;
       const response = data;
       if (response.requestId !== requestId)
         return;
-      clearTimeout(startTimeout);
+      if (startTimeout)
+        clearTimeout(startTimeout);
       finish(() => resolve(response));
     };
     const onUpdate = (data) => {
-      if (done || !data || typeof data !== "object")
+      if (done || signal?.aborted || !data || typeof data !== "object")
         return;
       const update = data;
       if (update.requestId !== requestId)
         return;
       applySlashUpdate(requestId, update);
-      if (!ctx.hasUI)
-        return;
-      const tool = update.currentTool ? ` ${update.currentTool}` : "";
-      const count = update.toolCount ?? 0;
-      const liveDetailKey = keyText("app.tools.expand");
-      ctx.ui.setStatus("subagent-slash", `${count} tools${tool} | ${liveDetailKey} live detail`);
+      try {
+        if (!ctx.hasUI)
+          return;
+        const tool = update.currentTool ? ` ${update.currentTool}` : "";
+        const count = update.toolCount ?? 0;
+        const liveDetailKey = keyText("app.tools.expand");
+        ctx.ui.setStatus("subagent-slash", `${count} tools${tool} | ${liveDetailKey} live detail`);
+      } catch (error) {
+        if (isStaleExtensionContextError(error)) {
+          finish(() => reject(error));
+          return;
+        }
+        throw error;
+      }
     };
     const onTerminalInput = ctx.hasUI ? ctx.ui.onTerminalInput((input) => {
       if (!matchesKey(input, Key.escape))
         return;
-      pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
+      dm.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
       finish(() => reject(new Error("Cancelled")));
       return { consume: true };
     }) : undefined;
-    const unsubStarted = pi.events.on(SLASH_SUBAGENT_STARTED_EVENT, onStarted);
-    const unsubResponse = pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
-    const unsubUpdate = pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
+    const unsubStarted = dm.events.on(SLASH_SUBAGENT_STARTED_EVENT, onStarted);
+    const unsubResponse = dm.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
+    const unsubUpdate = dm.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
+    let onAbort;
     const finish = (next) => {
       if (done)
         return;
       done = true;
-      clearTimeout(startTimeout);
+      if (startTimeout)
+        clearTimeout(startTimeout);
       unsubStarted();
       unsubResponse();
       unsubUpdate();
-      onTerminalInput?.();
+      try {
+        onTerminalInput?.();
+      } catch (error) {
+        if (!isStaleExtensionContextError(error))
+          throw error;
+      }
+      signal?.removeEventListener("abort", onAbort);
       next();
     };
-    pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params, ctx });
+    onAbort = () => finish(() => reject(new Error("Slash subagent request canceled during session replacement or reload.")));
+    startTimeout = setTimeout(() => {
+      finish(() => reject(new Error("Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly.")));
+    }, 15000);
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+      dm.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params, ctx });
+    } catch (error) {
+      if (isStaleExtensionContextError(error)) {
+        finish(() => reject(error));
+        return;
+      }
+      throw error;
+    }
     if (!started && done)
       return;
     if (!started) {
@@ -500,466 +713,129 @@ function persistSlashSessionSnapshot(ctx) {
     console.error("Failed to persist slash session snapshot for export:", error);
   }
 }
-async function runSlashSubagent(pi, ctx, params) {
-  if (ctx.hasUI)
-    ctx.ui.setToolsExpanded(false);
+async function runSlashSubagent(dm, ctx, params, signal) {
+  if (signal?.aborted)
+    return;
+  const initialHasUI = slashHasUI(ctx);
+  if (initialHasUI === undefined)
+    return;
+  try {
+    if (initialHasUI)
+      ctx.ui.setToolsExpanded(false);
+  } catch (error) {
+    if (isStaleExtensionContextError(error))
+      return;
+    throw error;
+  }
   const requestId = randomUUID();
   const initialDetails = buildSlashInitialResult(requestId, params);
   const initialText = extractSlashMessageText(initialDetails.result.content) || "Running subagent...";
-  pi.sendMessage({
-    customType: SLASH_RESULT_TYPE,
-    content: initialText,
-    display: true,
-    details: initialDetails
-  });
+  try {
+    dm.sendMessage({
+      customType: SLASH_RESULT_TYPE,
+      content: initialText,
+      display: true,
+      details: initialDetails
+    });
+  } catch (error) {
+    if (isStaleExtensionContextError(error))
+      return;
+    throw error;
+  }
   persistSlashSessionSnapshot(ctx);
   try {
-    const response = await requestSlashRun(pi, ctx, requestId, params);
+    const response = await requestSlashRun(dm, ctx, requestId, params, signal);
+    if (signal?.aborted)
+      return;
+    const hasUI = slashHasUI(ctx);
+    if (hasUI === undefined)
+      return;
     const finalDetails = finalizeSlashResult(response);
-    pi.sendMessage({
+    dm.sendMessage({
       customType: SLASH_RESULT_TYPE,
       content: buildSlashExportText(response),
-      display: !ctx.hasUI,
+      display: !hasUI,
       details: finalDetails
     });
     persistSlashSessionSnapshot(ctx);
-    if (ctx.hasUI) {
+    if (hasUI) {
       ctx.ui.setStatus("subagent-slash", undefined);
     }
-    if (response.isError && ctx.hasUI) {
+    if (response.isError && hasUI) {
       ctx.ui.notify(response.errorText || "Subagent failed", "error");
     }
   } catch (error) {
+    if (signal?.aborted || isStaleExtensionContextError(error))
+      return;
     const message = error instanceof Error ? error.message : String(error);
+    const hasUI = slashHasUI(ctx);
+    if (hasUI === undefined)
+      return;
     const failedDetails = failSlashResult(requestId, params, message);
-    pi.sendMessage({
+    dm.sendMessage({
       customType: SLASH_RESULT_TYPE,
       content: `## Subagent result
 
 ${message}`,
-      display: !ctx.hasUI,
+      display: !hasUI,
       details: failedDetails
     });
     persistSlashSessionSnapshot(ctx);
-    if (ctx.hasUI) {
+    if (hasUI) {
       ctx.ui.setStatus("subagent-slash", undefined);
     }
     if (message === "Cancelled") {
-      if (ctx.hasUI)
+      if (hasUI)
         ctx.ui.notify("Cancelled", "warning");
       return;
     }
-    if (ctx.hasUI)
+    if (hasUI)
       ctx.ui.notify(message, "error");
   }
 }
-export const PARALLEL_GROUP_USAGE = 'Usage: /chain agent "task" -> (agent2 "task" | agent3 "task") -> agent4';
-
-export class SlashParseError extends Error {
-}
-function findUnmatchedCloseParen(input) {
-  let depth = 0, inSingle = false, inDouble = false;
-  for (let i = 0;i < input.length; i++) {
-    const ch = input[i];
-    if (inSingle) {
-      if (ch === "'")
-        inSingle = false;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === '"')
-        inDouble = false;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (ch === "(")
-      depth++;
-    else if (ch === ")") {
-      depth--;
-      if (depth < 0)
-        return true;
-    }
-  }
-  return depth !== 0;
-}
-function splitOnArrow(input) {
-  const segments = [];
-  let depth = 0, inSingle = false, inDouble = false, start = 0;
-  for (let i = 0;i < input.length; i++) {
-    const ch = input[i];
-    if (inSingle) {
-      if (ch === "'")
-        inSingle = false;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === '"')
-        inDouble = false;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (ch === "(")
-      depth++;
-    else if (ch === ")")
-      depth--;
-    else if (depth === 0 && ch === "-" && input[i + 1] === ">" && input[i + 2] === " ") {
-      segments.push(input.slice(start, i));
-      i += 2;
-      start = i + 1;
-    }
-  }
-  segments.push(input.slice(start));
-  return segments;
-}
-function splitGroupTasks(inner) {
-  const parts = [];
-  let depth = 0, inSingle = false, inDouble = false, start = 0;
-  for (let i = 0;i < inner.length; i++) {
-    const ch = inner[i];
-    if (inSingle) {
-      if (ch === "'")
-        inSingle = false;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === '"')
-        inDouble = false;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (ch === "(")
-      depth++;
-    else if (ch === ")")
-      depth--;
-    else if (ch === "|" && depth === 0) {
-      parts.push(inner.slice(start, i));
-      start = i + 1;
-    }
-  }
-  parts.push(inner.slice(start));
-  return parts;
-}
-export function parseSingleTaskToken(token) {
-  let agentPart;
-  let task;
-  const qMatch = token.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
-  if (qMatch) {
-    agentPart = qMatch[1];
-    task = (qMatch[2] ?? qMatch[3]) || undefined;
-  } else {
-    const dashIdx = token.indexOf(" -- ");
-    if (dashIdx !== -1) {
-      agentPart = token.slice(0, dashIdx).trim();
-      task = token.slice(dashIdx + 4).trim() || undefined;
-    } else {
-      agentPart = token;
-    }
-  }
-  return { kind: "step", ...parseAgentToken(agentPart), task };
-}
-const parseGroupConfig = (raw) => {
-  const config = {};
-  for (const part of raw.split(",")) {
-    const trimmed = part.trim();
-    if (!trimmed)
-      continue;
-    const eq = trimmed.indexOf("=");
-    const key = eq === -1 ? trimmed : trimmed.slice(0, eq).trim();
-    const val = eq === -1 ? "" : trimmed.slice(eq + 1).trim();
-    switch (key) {
-      case "concurrency": {
-        const n = Number(val);
-        if (Number.isInteger(n) && n > 0)
-          config.concurrency = n;
-        break;
-      }
-      case "failFast":
-        config.failFast = eq === -1 ? true : val !== "false";
-        break;
-      case "worktree":
-        config.worktree = eq === -1 ? true : val !== "false";
-        break;
-    }
-  }
-  return config;
-};
-const splitGroupBody = (trimmed) => {
-  let depth = 0, inSingle = false, inDouble = false, closeIdx = -1;
-  for (let i = 0;i < trimmed.length; i++) {
-    const ch = trimmed[i];
-    if (inSingle) {
-      if (ch === "'")
-        inSingle = false;
-      continue;
-    }
-    if (inDouble) {
-      if (ch === '"')
-        inDouble = false;
-      continue;
-    }
-    if (ch === "'") {
-      inSingle = true;
-      continue;
-    }
-    if (ch === '"') {
-      inDouble = true;
-      continue;
-    }
-    if (ch === "(")
-      depth++;
-    else if (ch === ")") {
-      depth--;
-      if (depth === 0) {
-        closeIdx = i;
-        break;
-      }
-    }
-  }
-  if (closeIdx === -1)
-    throw new SlashParseError(`Unmatched parentheses in group: '${trimmed}'`);
-  const inner = trimmed.slice(1, closeIdx);
-  const suffix = trimmed.slice(closeIdx + 1).trim();
-  if (!suffix)
-    return { inner, config: {} };
-  if (!suffix.startsWith("[") || !suffix.endsWith("]")) {
-    throw new SlashParseError(`Group options must be wrapped in [...]: '${suffix}'`);
-  }
-  return { inner, config: parseGroupConfig(suffix.slice(1, -1)) };
-};
-export function parseGroupSegment(segment) {
-  const trimmed = segment.trim();
-  if (!trimmed.startsWith("(")) {
-    throw new SlashParseError(`Parallel group must be wrapped in parentheses: '${trimmed}'`);
-  }
-  const { inner, config } = splitGroupBody(trimmed);
-  const rawParts = splitGroupTasks(inner).map((p) => p.trim()).filter((p) => p.length > 0);
-  if (rawParts.length < 2) {
-    throw new SlashParseError("Parallel group must contain at least two tasks separated by ' | '");
-  }
-  return { kind: "group", tasks: rawParts.map((part) => parseSingleTaskToken(part)), config };
-}
-export function hasGroupSyntax(input) {
-  return splitOnArrow(input).some((seg) => seg.trim().startsWith("("));
+function slashRunWorkflowScript(key, child) {
+  return `return runs.run(${JSON.stringify(key)}, ${JSON.stringify(child)})`;
 }
-export function parseChainExpression(input) {
-  const trimmed = input.trim();
-  if (!trimmed.includes(" -> ")) {
-    throw new SlashParseError('Parallel groups in /chain require " -> " between steps');
-  }
-  if (findUnmatchedCloseParen(trimmed)) {
-    throw new SlashParseError("Unmatched parentheses in /chain expression");
-  }
-  const steps = [];
-  for (const seg of splitOnArrow(trimmed)) {
-    const t = seg.trim();
-    if (!t)
-      continue;
-    if (t.startsWith("(")) {
-      steps.push(parseGroupSegment(t));
-      continue;
-    }
-    if (findUnmatchedCloseParen(t)) {
-      throw new SlashParseError(`Unmatched parentheses in chain segment: '${t}'`);
-    }
-    steps.push(parseSingleTaskToken(t));
-  }
-  if (steps.length === 0) {
-    throw new SlashParseError("/chain expression must include at least one step");
-  }
-  return { steps };
-}
-const parseAgentArgs = (state, args, command, ctx) => {
-  const input = args.trim();
-  const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
-  let steps;
-  let sharedTask;
-  let perStep = false;
-  if (input.includes(" -> ")) {
-    perStep = true;
-    const segments = input.split(" -> ");
-    steps = [];
-    for (const seg of segments) {
-      const trimmed = seg.trim();
-      if (!trimmed)
-        continue;
-      steps.push(parseSingleTaskToken(trimmed));
-    }
-    sharedTask = steps.find((s) => s.task)?.task ?? "";
-  } else {
-    const delimiterIndex = input.indexOf(" -- ");
-    if (delimiterIndex === -1) {
-      ctx.ui.notify(usage, "error");
-      return null;
-    }
-    const agentsPart = input.slice(0, delimiterIndex).trim();
-    sharedTask = input.slice(delimiterIndex + 4).trim();
-    if (!agentsPart || !sharedTask) {
-      ctx.ui.notify(usage, "error");
-      return null;
+export function registerSlashCommands(dm, state, options = {}) {
+  let fleetOpen = false;
+  let disposed = false;
+  const pendingRequests = new Set;
+  const runCommand = (ctx, params) => {
+    if (disposed)
+      return Promise.resolve();
+    const controller = new AbortController;
+    pendingRequests.add(controller);
+    return runSlashSubagent(dm, ctx, params, controller.signal).finally(() => pendingRequests.delete(controller));
+  };
+  const launchCommand = (ctx, params) => {
+    runCommand(ctx, params);
+  };
+  const showFleet = async (ctx) => {
+    state.lastUiContext = ctx;
+    if (!ctx.hasUI) {
+      await runCommand(ctx, { action: "status", view: "fleet" });
+      return;
     }
-    steps = agentsPart.split(/\s+/).filter(Boolean).map((t) => parseSingleTaskToken(t));
-  }
-  if (steps.length === 0) {
-    ctx.ui.notify(usage, "error");
-    return null;
-  }
-  if (!state.baseCwd) {
-    ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-    return null;
-  }
-  const agents = discoverAgents(state.baseCwd, "both").agents;
-  for (const step of steps) {
-    if (!agents.find((a) => a.name === step.name)) {
-      ctx.ui.notify(`Unknown agent: ${step.name}`, "error");
-      return null;
+    if (fleetOpen) {
+      ctx.ui.notify("Subagent fleet inspector is already open.", "info");
+      return;
     }
-  }
-  if (command === "chain" && !steps[0]?.task && (perStep || !sharedTask)) {
-    ctx.ui.notify(`First step must have a task: /chain agent "task" -> agent2`, "error");
-    return null;
-  }
-  if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
-    ctx.ui.notify("At least one step must have a task", "error");
-    return null;
-  }
-  return { steps, task: sharedTask };
-};
-const INLINE_ACCEPTANCE_LEVELS = new Set(["auto", "attested", "checked"]);
-function validateInlineAcceptanceInput(value, agent) {
-  const errors = validateAcceptanceInput(value, `acceptance for step '${agent}'`);
-  if (errors.length > 0)
-    throw new SlashParseError(errors[0]);
-  if (!INLINE_ACCEPTANCE_LEVELS.has(value)) {
-    throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none, verified, or reviewed acceptance contracts.`);
-  }
-}
-function loadInlineOutputSchema(baseCwd, agent, value) {
-  const schemaPath = path.isAbsolute(value) ? value : path.join(baseCwd, value);
-  const label = `outputSchema for step '${agent}' (${schemaPath})`;
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
-  } catch (error) {
-    throw new SlashParseError(`Cannot read ${label}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  assertJsonSchemaObject(parsed, label);
-  return parsed;
-}
-const mapParsedTaskToStepObject = (step, fallbackTask, isFirst, opts) => {
-  const { name, config, task: stepTask } = step;
-  if (config.acceptance !== undefined)
-    validateInlineAcceptanceInput(config.acceptance, name);
-  return {
-    agent: name,
-    ...stepTask ? { task: stepTask } : isFirst && fallbackTask ? { task: fallbackTask } : {},
-    ...config.output !== undefined ? { output: config.output } : {},
-    ...config.outputMode !== undefined ? { outputMode: config.outputMode } : {},
-    ...config.reads !== undefined ? { reads: config.reads } : {},
-    ...config.model ? { model: config.model } : {},
-    ...config.skill !== undefined ? { skill: config.skill } : {},
-    ...config.progress !== undefined ? { progress: config.progress } : {},
-    ...config.as ? { as: config.as } : {},
-    ...config.label ? { label: config.label } : {},
-    ...config.phase ? { phase: config.phase } : {},
-    ...config.cwd ? { cwd: config.cwd } : {},
-    ...opts.inGroup && config.count !== undefined ? { count: config.count } : {},
-    ...config.outputSchema ? { outputSchema: loadInlineOutputSchema(opts.baseCwd, name, config.outputSchema) } : {},
-    ...config.acceptance ? { acceptance: config.acceptance } : {}
-  };
-};
-export function buildChainExpressionSteps(state, input, ctx) {
-  const notify = (message) => ctx.ui.notify(message, "error");
-  if (!hasGroupSyntax(input)) {
-    const parsed = parseAgentArgs(state, input, "chain", ctx);
-    if (!parsed)
-      return null;
-    const baseCwd = state.baseCwd;
+    fleetOpen = true;
     try {
-      const chain = parsed.steps.map((step, i) => mapParsedTaskToStepObject(step, parsed.task || undefined, i === 0, { baseCwd, inGroup: false }));
-      return { chain, task: parsed.task };
-    } catch (error) {
-      notify(error instanceof Error ? error.message : String(error));
-      return null;
+      await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
+    } finally {
+      fleetOpen = false;
     }
-  }
-  let expression;
-  try {
-    expression = parseChainExpression(input);
-  } catch (error) {
-    notify(error instanceof Error ? error.message : String(error));
-    return null;
-  }
-  if (!state.baseCwd) {
-    notify("Subagent session cwd is not initialized yet");
-    return null;
-  }
-  const agents = discoverAgents(state.baseCwd, "both").agents;
-  const stepAgentNames = expression.steps.flatMap((step) => step.kind === "group" ? step.tasks.map((t) => t.name) : [step.name]);
-  for (const name of stepAgentNames) {
-    if (!agents.find((a) => a.name === name)) {
-      notify(`Unknown agent: ${name}`);
-      return null;
-    }
-  }
-  for (const step of expression.steps) {
-    if (step.kind === "group" && step.tasks.some((t) => !t.task)) {
-      notify('Each task in a parallel group needs a task: (agent "a" | agent "b")');
-      return null;
+  };
+  dm.registerCommand("subagents", {
+    description: "Administer subagents: inspect metadata and update models, thinking, or prompts",
+    handler: async (args, ctx) => {
+      await openSubagentsAdmin(dm, ctx, args);
     }
-  }
-  const firstStep = expression.steps[0];
-  const firstHasTask = firstStep.kind === "group" ? firstStep.tasks.some((t) => Boolean(t.task)) : Boolean(firstStep.task);
-  if (!firstHasTask) {
-    notify('First step must have a task: /chain agent "task" -> agent2');
-    return null;
-  }
-  const sharedTask = firstStep.kind === "group" ? firstStep.tasks.find((t) => t.task)?.task ?? "" : firstStep.task ?? "";
-  const baseCwd = state.baseCwd;
-  let chain;
-  try {
-    chain = expression.steps.map((step) => {
-      if (step.kind === "group") {
-        const parallel = step.tasks.map((t) => mapParsedTaskToStepObject(t, undefined, false, { baseCwd, inGroup: true }));
-        return {
-          parallel,
-          ...step.config.concurrency !== undefined ? { concurrency: step.config.concurrency } : {},
-          ...step.config.failFast !== undefined ? { failFast: step.config.failFast } : {},
-          ...step.config.worktree !== undefined ? { worktree: step.config.worktree } : {}
-        };
-      }
-      return mapParsedTaskToStepObject(step, sharedTask || undefined, false, { baseCwd, inGroup: false });
-    });
-  } catch (error) {
-    notify(error instanceof Error ? error.message : String(error));
-    return null;
-  }
-  return { chain, task: sharedTask };
-}
-export function registerSlashCommands(pi, state) {
-  pi.registerCommand("run", {
-    description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
-    getArgumentCompletions: makeAgentCompletions(state, false),
+  });
+  dm.registerCommand("run", {
+    description: "Run one subagent through workflowScript: /run agent[output=file] [task] [--bg] [--fork]",
+    getArgumentCompletions: makeAgentCompletions(dm, state),
     handler: async (args, ctx) => {
       const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
       const input = cleanedArgs.trim();
@@ -974,138 +850,242 @@ export function registerSlashCommands(pi, state) {
         ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
         return;
       }
-      const agents = discoverAgents(state.baseCwd, "both").agents;
-      if (!agents.find((a) => a.name === agentName)) {
-        ctx.ui.notify(`Unknown agent: ${agentName}`, "error");
+      const discovered = discoverSlashAgents(dm, state.baseCwd, "both");
+      const resolvedAgent = resolveAgentName(agentName, discovered.agents);
+      const candidates = resolvedAgent.error ? discovered.agents.filter((agent) => resolveAgentName(agentName, [agent]).agent) : resolvedAgent.agent;
+      const diagnostic = findBlockingAgentDiagnostic(agentName, candidates, discovered.agentDiagnostics);
+      if (diagnostic || resolvedAgent.error || !resolvedAgent.agent) {
+        ctx.ui.notify(diagnostic ? `Agent '${agentName}' has invalid configuration: ${diagnostic.error}` : resolvedAgent.error ?? formatUnknownAgentError(agentName, discovered.unknownAgentDiagnosticContext), "error");
         return;
       }
       let finalTask = task;
       if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
-        finalTask = `[Read from: ${inline.reads.join(", ")}]
+        const existingReads = inline.reads.filter((read) => resolveExistingReadPaths([read], state.baseCwd).length > 0);
+        if (existingReads.length > 0)
+          finalTask = `[Read from: ${existingReads.join(", ")}]
 
 ${finalTask}`;
       }
-      const params = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
+      const child = { agent: agentName, task: finalTask, agentScope: "both" };
       if (inline.output !== undefined)
-        params.output = inline.output;
+        child.output = inline.output;
       if (inline.outputMode !== undefined)
-        params.outputMode = inline.outputMode;
+        child.outputMode = inline.outputMode;
       if (inline.skill !== undefined)
-        params.skill = inline.skill;
+        child.skill = inline.skill;
       if (inline.model)
-        params.model = inline.model;
-      if (bg)
-        params.async = true;
+        child.model = inline.model;
       if (fork)
-        params.context = "fork";
-      await runSlashSubagent(pi, ctx, params);
+        child.context = "fork";
+      launchCommand(ctx, { workflowScript: slashRunWorkflowScript("run", child), async: bg ? true : false });
     }
   });
-  pi.registerCommand("chain", {
-    description: 'Run agents in sequence: /chain scout "task" -> planner [--bg] [--fork]',
-    getArgumentCompletions: makeAgentCompletions(state, true),
-    handler: async (args, ctx) => {
-      const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-      const built = buildChainExpressionSteps(state, cleanedArgs, ctx);
-      if (!built)
-        return;
-      const params = { chain: built.chain, task: built.task, clarify: false, agentScope: "both" };
-      if (bg)
-        params.async = true;
-      if (fork)
-        params.context = "fork";
-      await runSlashSubagent(pi, ctx, params);
+  dm.registerCommand("subagent-cost", {
+    description: "Show parent and subagent child usage cost for this session",
+    handler: async (_args, ctx) => {
+      sendSlashText(dm, buildSubagentCostReport(ctx, state));
     }
   });
-  pi.registerCommand("run-chain", {
-    description: "Run a saved chain: /run-chain chainName -- task [--bg] [--fork]",
-    getArgumentCompletions: makeChainCompletions(state),
+  dm.registerCommand("subagents-doctor", {
+    description: "Show subagent diagnostics",
+    handler: async (_args, ctx) => {
+      await runCommand(ctx, { action: "doctor" });
+    }
+  });
+  dm.registerCommand("subagents-inspect-rpc", {
+    description: "Host integration bridge: answer an async child inspection request with a correlated widget payload (no model turn)",
     handler: async (args, ctx) => {
-      const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-      const delimiterIndex = cleanedArgs.indexOf(" -- ");
-      const usage = "Usage: /run-chain <chainName> -- <task> [--bg] [--fork]";
-      if (delimiterIndex === -1) {
-        ctx.ui.notify(usage, "error");
-        return;
-      }
-      const chainName = cleanedArgs.slice(0, delimiterIndex).trim();
-      const task = cleanedArgs.slice(delimiterIndex + 4).trim();
-      if (!chainName || !task) {
-        ctx.ui.notify(usage, "error");
+      if (ctx.mode === "tui") {
+        ctx.ui.notify('Inspection replies are emitted only on RPC surfaces. Use /subagents or subagent({ action: "status", view: "transcript" }) interactively.', "info");
         return;
       }
-      if (!state.baseCwd) {
-        ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
+      if (!ctx.hasUI)
         return;
-      }
-      const chain = discoverSavedChains(state.baseCwd).find((candidate) => candidate.name === chainName);
-      if (!chain) {
-        ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
+      const reply = handleInspectRpcArgs(args, { state });
+      ctx.ui.setWidget(INSPECT_WIDGET_KEY, encodeInspectReply(reply));
+      ctx.ui.setWidget(INSPECT_WIDGET_KEY, undefined);
+    }
+  });
+  dm.registerCommand("subagents-guide", {
+    description: "Show a packaged subagents guide topic",
+    getArgumentCompletions: (prefix) => prefix.includes(" ") ? null : SUBAGENT_GUIDE_TOPICS.filter((topic) => topic.startsWith(prefix)).map((topic) => ({ value: topic, label: topic })),
+    handler: async (args, ctx) => {
+      const topic = args.trim();
+      if (topic.includes(" ")) {
+        ctx.ui.notify("Usage: /subagents-guide [topic]", "error");
         return;
       }
-      const params = { chain: mapSavedChainSteps(chain), task, clarify: false, agentScope: "both" };
-      if (bg)
-        params.async = true;
-      if (fork)
-        params.context = "fork";
-      await runSlashSubagent(pi, ctx, params);
+      await runCommand(ctx, { action: "guide", ...topic ? { topic } : {} });
     }
   });
-  pi.registerCommand("parallel", {
-    description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--bg] [--fork]',
-    getArgumentCompletions: makeAgentCompletions(state, true),
+  dm.registerCommand("subagents-refine", {
+    description: "Generate a bounded project-local refinement overlay for one subagent",
+    getArgumentCompletions: makeAgentCompletions(dm, state),
     handler: async (args, ctx) => {
-      const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-      const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
-      if (!parsed)
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      if (parts.length !== 1) {
+        ctx.ui.notify("Usage: /subagents-refine <agent>", "error");
         return;
-      const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
-        agent: name,
-        task: stepTask ?? parsed.task,
-        ...config.output !== undefined ? { output: config.output } : {},
-        ...config.outputMode !== undefined ? { outputMode: config.outputMode } : {},
-        ...config.reads !== undefined ? { reads: config.reads } : {},
-        ...config.model ? { model: config.model } : {},
-        ...config.skill !== undefined ? { skill: config.skill } : {},
-        ...config.progress !== undefined ? { progress: config.progress } : {}
-      }));
-      const params = { tasks, clarify: false, agentScope: "both" };
-      if (bg)
-        params.async = true;
-      if (fork)
-        params.context = "fork";
-      await runSlashSubagent(pi, ctx, params);
+      }
+      await runCommand(ctx, { action: "refine", agent: parts[0] });
     }
   });
-  pi.registerCommand("subagent-cost", {
-    description: "Show parent and subagent child usage cost for this session",
-    handler: async (_args, ctx) => {
-      sendSlashText(pi, buildSubagentCostReport(ctx));
+  dm.registerCommand("subagents-fleet", {
+    description: "Open the live subagent fleet inspector",
+    handler: async (_args, ctx) => showFleet(ctx)
+  });
+  dm.registerShortcut(FLEET_OPEN_SHORTCUT, {
+    description: "Open subagent fleet inspector",
+    handler: async (ctx) => showFleet(ctx)
+  });
+  const detachForegroundRun = (args, ctx) => {
+    const id = args.trim();
+    let control;
+    try {
+      control = selectForegroundDetachControl(state, id);
+    } catch (error) {
+      ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      return;
+    }
+    if (!control) {
+      ctx.ui.notify(id ? `No active foreground run found for '${id}'.` : "No active foreground single-subagent run to detach.", "info");
+      return;
+    }
+    if (control.mode !== "single") {
+      ctx.ui.notify("/subagents-detach currently supports single-subagent runs only.", "error");
+      return;
+    }
+    if (!control.detach?.()) {
+      ctx.ui.notify(`Foreground run ${control.runId} is not currently detachable.`, "info");
+      return;
     }
+    sendSlashText(dm, `Detached foreground run ${control.runId} without terminating its child. Use subagent({ action: "status", id: ${JSON.stringify(control.runId)} }) or bg_wait({ id: ${JSON.stringify(control.runId)} }) to recover the eventual result. This does not daemonize the process or guarantee survival across DM reload/restart.`);
+  };
+  dm.registerCommand("subagents-detach", {
+    description: "Detach the active foreground single-subagent run without terminating it",
+    handler: async (args, ctx) => detachForegroundRun(args, ctx)
   });
-  pi.registerCommand("subagents-doctor", {
-    description: "Show subagent diagnostics",
-    handler: async (_args, ctx) => {
-      await runSlashSubagent(pi, ctx, { action: "doctor" });
+  if (options.foregroundDetachShortcut) {
+    dm.registerShortcut(options.foregroundDetachShortcut, {
+      description: "Detach the active foreground subagent and keep it running in the background",
+      handler: async (ctx) => detachForegroundRun("", ctx)
+    });
+  }
+  dm.registerCommand("subagents-stop", {
+    description: "Stop a current-session async subagent run, or one child of it with /subagents-stop <run-id> <child-id>",
+    handler: async (args, ctx) => {
+      const [id, childId, ...extra] = args.trim().split(/\s+/).filter(Boolean);
+      if (extra.length > 0) {
+        sendSlashText(dm, "Usage: /subagents-stop [run-id] [child-id]");
+        return;
+      }
+      if (id) {
+        await runCommand(ctx, childId ? { action: "stop", id, childId } : { action: "stop", id });
+        return;
+      }
+      if (process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1") {
+        sendSlashText(dm, 'Selector unavailable in child-safe fanout mode. Pass an explicit current-session top-level async run id, for example `/subagents-stop <run-id>` or `subagent({ action: "stop", id: "<run-id>" })`.');
+        return;
+      }
+      let targets;
+      try {
+        targets = discoverStopTargets(ctx, state);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(message, "error");
+        return;
+      }
+      if (!ctx.hasUI) {
+        sendSlashText(dm, stopFallbackText(targets));
+        return;
+      }
+      if (targets.length === 0) {
+        ctx.ui.notify("No active current-session async runs or scheduled subagent runs to stop.", "info");
+        return;
+      }
+      const result = await ctx.ui.custom((tui, theme, _kb, done) => new SubagentsStopSelector(tui, theme, targets, done), { overlay: true, overlayOptions: { anchor: "center", width: 88, maxHeight: "80%" } });
+      if (!result?.confirmed || !result.target)
+        return;
+      if (result.target.kind === "scheduled") {
+        await runCommand(ctx, { action: "schedule.pause", id: result.target.id });
+        return;
+      }
+      await runCommand(ctx, { action: "stop", id: result.target.id });
     }
   });
-  pi.registerCommand("subagents-fleet", {
-    description: "Show active subagent fleet status and transcript commands",
-    handler: async (_args, ctx) => {
-      await runSlashSubagent(pi, ctx, { action: "status", view: "fleet" });
+  dm.registerCommand("subagents-steer", {
+    description: "Steer a live async subagent run with a message, or one child of it with --child <child-id>",
+    handler: async (args, ctx) => {
+      const tokens = args.trim().split(/\s+/).filter(Boolean);
+      const usage = "Usage: /subagents-steer <run-id> [--child <child-id>] <message>";
+      const [id, ...rest] = tokens;
+      if (!id || id.startsWith("--")) {
+        sendSlashText(dm, usage);
+        return;
+      }
+      let childId;
+      let messageStart = 0;
+      if (rest[0] === "--child" && rest[1] && !rest[1].startsWith("--")) {
+        childId = rest[1];
+        messageStart = 2;
+      }
+      const message = rest.slice(messageStart).join(" ").trim();
+      if (!message) {
+        sendSlashText(dm, usage);
+        return;
+      }
+      let targetId = id;
+      let childIndex;
+      if (childId !== undefined) {
+        const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined;
+        const run = listAsyncRuns(DIRS.async, {
+          runId: id,
+          states: ["queued", "running", "paused"],
+          ...sessionId ? { sessionId } : {}
+        })[0];
+        const status = run ? readStatus(run.asyncDir) : null;
+        if (!run || !status) {
+          sendSlashText(dm, `No current-session async run found for '${id}'.`);
+          return;
+        }
+        const resolutionStatus = {
+          ...status,
+          steps: status.steps?.map((step, index) => ({ ...step, children: run.steps[index]?.children ?? step.children }))
+        };
+        const resolution = resolveAsyncStatusChild(resolutionStatus, childId, { includeNested: true });
+        if (!resolution.ok) {
+          sendSlashText(dm, resolution.message);
+          return;
+        }
+        if (resolution.child.nested)
+          targetId = resolution.child.nested.id;
+        else if (resolution.child.step.runId)
+          targetId = resolution.child.step.runId;
+        else
+          childIndex = resolution.child.index;
+      }
+      await runCommand(ctx, {
+        action: "steer",
+        id: targetId,
+        message,
+        ...childIndex !== undefined ? { index: childIndex } : {},
+        steeringRecovery: false
+      });
     }
   });
   registerPromptWorkflowCommands({
-    pi,
-    run: (params, ctx) => runSlashSubagent(pi, ctx, params)
+    dm,
+    run: async (params, ctx) => {
+      launchCommand(ctx, params);
+    }
   });
-  pi.registerCommand("subagents-models", {
+  dm.registerCommand("subagents-models", {
     description: "Show runtime-loaded builtin subagent models",
     getArgumentCompletions: makeBuiltinAgentNameCompletions(),
     handler: async (args, ctx) => {
       const trimmed = args.trim();
       if (!trimmed) {
-        await runSlashSubagent(pi, ctx, { action: "models" });
+        await runCommand(ctx, { action: "models" });
         return;
       }
       const parts = trimmed.split(/\s+/).filter(Boolean);
@@ -1118,26 +1098,26 @@ ${finalTask}`;
         ctx.ui.notify(`Unknown builtin agent: ${agent}`, "error");
         return;
       }
-      await runSlashSubagent(pi, ctx, { action: "models", agent });
+      await runCommand(ctx, { action: "models", agent });
     }
   });
-  pi.registerCommand("subagents-profiles", {
+  dm.registerCommand("subagents-profiles", {
     description: "List saved subagent profiles",
     handler: async (_args, _ctx) => {
       const profiles = listSubagentProfiles();
       if (profiles.length === 0) {
-        sendSlashText(pi, `Subagent profiles
+        sendSlashText(dm, `Subagent profiles
 
 No subagent profiles found in ~/.dm/agent/profiles/dm-subagents/`);
         return;
       }
-      sendSlashText(pi, `Subagent profiles
+      sendSlashText(dm, `Subagent profiles
 
 ${profiles.join(`
 `)}`);
     }
   });
-  pi.registerCommand("subagents-load-profile", {
+  dm.registerCommand("subagents-load-profile", {
     description: "Load a subagent profile into ~/.dm/agent/settings.json",
     getArgumentCompletions: (prefix) => {
       if (prefix.includes(" "))
@@ -1146,7 +1126,7 @@ ${profiles.join(`
     },
     handler: async (args, ctx) => {
       const parsed = parseSingleRequiredArg(args, "Usage: /subagents-load-profile <name>");
-      if (!parsed.ok) {
+      if (parsed.ok === false) {
         ctx.ui.notify(parsed.message, "error");
         return;
       }
@@ -1160,7 +1140,7 @@ ${profiles.join(`
             `Profile: ${result.filePath}`,
             `Updated: ${result.settingsPath}`
           ];
-          if (workerModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
+          if (workerModel && typeof dm.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
             const shouldSwitch = await ctx.ui.confirm("", `Profile loaded. Also switch this session to the profile worker model?
 
 ${workerModel}`);
@@ -1170,7 +1150,7 @@ ${workerModel}`);
               if (!modelInfo || !model) {
                 lines.push(`Could not switch current session model: '${workerModel}' is not available in the current model registry.`);
               } else {
-                const success = await pi.setModel(model);
+                const success = await dm.setModel(model);
                 if (success)
                   lines.push(`Current session model switched to: ${modelInfo.fullId}`);
                 else
@@ -1180,7 +1160,7 @@ ${workerModel}`);
           } else if (workerModel) {
             lines.push(`Profile worker model: ${workerModel}`);
           }
-          sendSlashText(pi, lines.join(`
+          sendSlashText(dm, lines.join(`
 `));
         });
       } catch (error) {
@@ -1188,7 +1168,7 @@ ${workerModel}`);
       }
     }
   });
-  pi.registerCommand("subagents-refresh-provider-models", {
+  dm.registerCommand("subagents-refresh-provider-models", {
     description: "Refresh the cached model catalog for one provider",
     getArgumentCompletions: makeProviderCompletions(state),
     handler: async (args, ctx) => {
@@ -1196,13 +1176,13 @@ ${workerModel}`);
       const force = /(?:^|\s)--force$/.test(trimmed) || /(?:^|\s)force$/.test(trimmed);
       const withoutForce = trimmed.replace(/(?:^|\s)(?:--force|force)$/, "").trim();
       const parsed = parseSingleRequiredArg(withoutForce, "Usage: /subagents-refresh-provider-models <provider> [--force]");
-      if (!parsed.ok) {
+      if (parsed.ok === false) {
         ctx.ui.notify(parsed.message, "error");
         return;
       }
       try {
         await withSlashStatus(ctx, `Refreshing provider models for ${parsed.value}…`, async () => {
-          const result = await refreshProviderModelCatalog(pi, ctx, parsed.value, { force, maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
+          const result = await refreshProviderModelCatalog(dm, ctx, parsed.value, { force, maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
           const lines = [
             "Provider model catalog",
             `Provider: ${parsed.value}`,
@@ -1214,7 +1194,7 @@ ${workerModel}`);
           if (result.heuristicFallbackCount > 0) {
             lines.push(`Warning: ${result.heuristicFallbackCount} model${result.heuristicFallbackCount === 1 ? " was" : "s were"} classified with name heuristics fallback.`);
           }
-          sendSlashText(pi, lines.join(`
+          sendSlashText(dm, lines.join(`
 `));
         });
       } catch (error) {
@@ -1222,18 +1202,18 @@ ${workerModel}`);
       }
     }
   });
-  pi.registerCommand("subagents-generate-profiles", {
+  dm.registerCommand("subagents-generate-profiles", {
     description: "Generate <provider>.quota and <provider>.quality subagent profiles",
     getArgumentCompletions: makeProviderCompletions(state),
     handler: async (args, ctx) => {
       const parsed = parseSingleRequiredArg(args, "Usage: /subagents-generate-profiles <provider>");
-      if (!parsed.ok) {
+      if (parsed.ok === false) {
         ctx.ui.notify(parsed.message, "error");
         return;
       }
       try {
         await withSlashStatus(ctx, `Generating profiles for ${parsed.value}…`, async () => {
-          const result = await generateProfilesForProvider(pi, ctx, parsed.value, { maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
+          const result = await generateProfilesForProvider(dm, ctx, parsed.value, { maxAgeDays: DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS });
           const lines = [
             "Generated subagent profiles",
             `Provider: ${parsed.value}`,
@@ -1252,7 +1232,7 @@ ${workerModel}`);
           } else if (result.heuristicFallbackCount > 0) {
             lines.push(`Warning: provider catalog still contains ${result.heuristicFallbackCount} heuristic-classified model${result.heuristicFallbackCount === 1 ? "" : "s"}.`);
           }
-          sendSlashText(pi, lines.join(`
+          sendSlashText(dm, lines.join(`
 `));
         });
       } catch (error) {
@@ -1260,7 +1240,7 @@ ${workerModel}`);
       }
     }
   });
-  pi.registerCommand("subagents-check-profile", {
+  dm.registerCommand("subagents-check-profile", {
     description: "Check whether a saved profile still points to usable models",
     getArgumentCompletions: (prefix) => {
       if (prefix.includes(" "))
@@ -1269,13 +1249,13 @@ ${workerModel}`);
     },
     handler: async (args, ctx) => {
       const parsed = parseSingleRequiredArg(args, "Usage: /subagents-check-profile <name>");
-      if (!parsed.ok) {
+      if (parsed.ok === false) {
         ctx.ui.notify(parsed.message, "error");
         return;
       }
       try {
         await withSlashStatus(ctx, `Checking profile ${parsed.value}…`, async () => {
-          const result = await checkSubagentProfile(pi, ctx, parsed.value);
+          const result = await checkSubagentProfile(dm, ctx, parsed.value);
           const lines = [
             "Subagent profile check",
             `Profile: ${result.profileName}`,
@@ -1283,7 +1263,7 @@ ${workerModel}`);
             "",
             ...result.results.map((entry) => `${entry.agent} → ${entry.model} — registry ${entry.inRegistry ? "ok" : "missing"}; probe ${entry.probe.status}${entry.probe.message ? ` (${entry.probe.message.split(/\r?\n/, 1)[0]})` : ""}`)
           ];
-          sendSlashText(pi, lines.join(`
+          sendSlashText(dm, lines.join(`
 `));
         });
       } catch (error) {
@@ -1291,4 +1271,14 @@ ${workerModel}`);
       }
     }
   });
+  return {
+    dispose: () => {
+      if (disposed)
+        return;
+      disposed = true;
+      for (const controller of pendingRequests)
+        controller.abort();
+      pendingRequests.clear();
+    }
+  };
 }