@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-EPYATQMG.js

@@ -0,0 +1,2718 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  isExtensionCommandToken
+} from "./chunk-RFCKPS2V.js";
+import {
+  createWorkerProgressFold
+} from "./chunk-K3W6BF5C.js";
+import {
+  PANES_PRESETS,
+  PANES_PRESET_IDS,
+  resolvePanesPresetId
+} from "./chunk-QUIJZSDW.js";
+import {
+  acceptanceFromTaskFlags,
+  formatUserTaskHandoff
+} from "./chunk-3IQOZRQ6.js";
+import {
+  AdmissionCanceledError,
+  WORKER_OUTPUT_MAX_BYTES,
+  activeDecisionRefs,
+  decisionRationale
+} from "./chunk-STC6CWUZ.js";
+import {
+  SKILL_SURFACE_CLEAR_ARG,
+  parseSkillCommand
+} from "./chunk-EXKUF426.js";
+import {
+  isLibraryKind
+} from "./chunk-6UJ7RDI7.js";
+import {
+  TOOL_PROFILE_NAMES,
+  isToolProfileName
+} from "./chunk-GEVQNST4.js";
+import {
+  requestExecutionRole
+} from "./chunk-FNVPQQYT.js";
+import {
+  resolveModelReference
+} from "./chunk-GVU4CXPJ.js";
+import {
+  truncateUtf8
+} from "./chunk-MYI32N4R.js";
+import {
+  BusChannels
+} from "./chunk-W5RM7YAH.js";
+import {
+  parseCouncilReport,
+  parseOracleResult
+} from "./chunk-ARRUMZ7X.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-3XE4NRLF.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/interactive/slash-commands.ts
+init_esm_shims();
+
+// src/interactive/council.ts
+init_esm_shims();
+var COUNCIL_DEFAULT_ROSTER = "default";
+var COUNCIL_SYNTHESIS_MODES = ["judge", "vote", "none"];
+var COUNCIL_MAX_ROUNDS = 3;
+var COUNCIL_SYNTHESIS_LABEL = "synthesis";
+function isCouncilSynthesisMode(value) {
+  return COUNCIL_SYNTHESIS_MODES.some((mode) => mode === value);
+}
+var COUNCIL_NO_ROSTER_NOTICE = `/council needs a roster. Declare one under workers.rosters in settings.yaml, for example workers.rosters.${COUNCIL_DEFAULT_ROSTER} with two to five members, each with a label and a target, then run /council <task> or name another roster with --roster <name>.`;
+function knownRosterNames(rosters) {
+  return Object.keys(rosters).sort();
+}
+function resolveCouncilRoster(requested, rosters) {
+  const known = knownRosterNames(rosters);
+  const wanted = requested?.trim();
+  if (wanted !== void 0 && wanted.length > 0) {
+    if (Object.hasOwn(rosters, wanted)) return { ok: true, roster: wanted };
+    const names = known.length === 0 ? "none are configured" : `configured rosters: ${known.join(", ")}`;
+    return { ok: false, reason: `no roster named "${wanted}" in workers.rosters (${names})` };
+  }
+  if (Object.hasOwn(rosters, COUNCIL_DEFAULT_ROSTER)) return { ok: true, roster: COUNCIL_DEFAULT_ROSTER };
+  return { ok: false, reason: COUNCIL_NO_ROSTER_NOTICE };
+}
+function buildCouncilDispatchArgs(task, roster, options = {}) {
+  return {
+    mode: "council",
+    task,
+    roster,
+    ...options.rounds !== void 0 ? { rounds: options.rounds } : {},
+    ...options.synthesis !== void 0 ? { synthesis: options.synthesis } : {}
+  };
+}
+
+// src/interactive/oracle.ts
+init_esm_shims();
+var ORACLE_AGENT_ID = "oracle";
+var ORACLE_DIGEST_MAX_BYTES = 12 * 1024;
+var ORACLE_DECISIONS_MAX_BYTES = 5120;
+var ORACLE_TASKS_MAX_BYTES = 3072;
+var ORACLE_COMPACTION_MAX_BYTES = 2048;
+var ORACLE_QUESTION_MAX_BYTES = 1536;
+var ORACLE_DECISIONS_MAX_ROWS = 24;
+var ORACLE_TASKS_MAX_ROWS = 24;
+var ORACLE_TRUNCATION_MARKER = "\n[truncated]";
+var ORACLE_NO_DECISIONS = "(no settled decisions on this branch)";
+var ORACLE_NO_TASKS = "(no open tasks on the board)";
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function clamp(text, maxBytes) {
+  if (byteLength(text) <= maxBytes) return { text, truncated: false };
+  const room = Math.max(0, maxBytes - byteLength(ORACLE_TRUNCATION_MARKER));
+  const buffer = Buffer.from(text, "utf8");
+  let cut = Math.min(room, buffer.byteLength);
+  while (cut > 0) {
+    const next = buffer[cut];
+    if (next === void 0 || (next & 192) !== 128) break;
+    cut -= 1;
+  }
+  return { text: `${buffer.subarray(0, cut).toString("utf8")}${ORACLE_TRUNCATION_MARKER}`, truncated: true };
+}
+function decisionLine(decision) {
+  const argument = decisionRationale(decision);
+  const details = argument ? `
+  ${argument}` : "";
+  const label = decision.label ? ` (${decision.label})` : "";
+  if (decision.status === "superseded") {
+    const correction = decision.correction ? `; corrected to ${decision.correction}` : "";
+    return `- ${decision.key}${label}: ${decision.value} [superseded${correction}]${details}`;
+  }
+  return `- ${decision.key}${label}: ${decision.value}${details}`;
+}
+function taskLine(task) {
+  return `- ${task.id} [${task.status}] ${task.title}`;
+}
+function isOpenTask(task) {
+  return task.status === "pending" || task.status === "active";
+}
+function packOracleDigest(sources) {
+  let truncated = false;
+  const decisionRows = sources.decisions.flatMap((entry) => entry.decisions.map(decisionLine)).slice(0, ORACLE_DECISIONS_MAX_ROWS);
+  if (decisionRows.length < sources.decisions.reduce((total, entry) => total + entry.decisions.length, 0)) {
+    truncated = true;
+  }
+  const decisions = clamp(decisionRows.join("\n") || ORACLE_NO_DECISIONS, ORACLE_DECISIONS_MAX_BYTES);
+  truncated = truncated || decisions.truncated;
+  const openTasks = sources.tasks.filter(isOpenTask);
+  const taskRows = openTasks.map(taskLine).slice(0, ORACLE_TASKS_MAX_ROWS);
+  if (taskRows.length < openTasks.length) truncated = true;
+  const tasks = clamp(taskRows.join("\n") || ORACLE_NO_TASKS, ORACLE_TASKS_MAX_BYTES);
+  truncated = truncated || tasks.truncated;
+  const summaryText = sources.compactionSummary?.trim() ?? "";
+  const summary = clamp(summaryText, ORACLE_COMPACTION_MAX_BYTES);
+  truncated = truncated || summary.truncated;
+  const question = clamp(sources.question.trim(), ORACLE_QUESTION_MAX_BYTES);
+  truncated = truncated || question.truncated;
+  const sections = [
+    "## Settled decisions",
+    decisions.text,
+    "",
+    "## Open tasks",
+    tasks.text,
+    "",
+    "## Last compaction summary",
+    summary.text.length > 0 ? summary.text : "(this session has not compacted)",
+    "",
+    "## Question",
+    question.text
+  ];
+  const whole = clamp(sections.join("\n"), ORACLE_DIGEST_MAX_BYTES);
+  return { text: whole.text, truncated: truncated || whole.truncated };
+}
+var ORACLE_TASK = "Answer the question in the briefing's Question section. Check it against the settled decisions first, then return the strongest challenge you can support and the evidence that would change your mind.";
+function formatOracleAnswer(result) {
+  const cited = result.citedDecisions.length === 0 ? "Cited decisions: none bear on this question." : `Cited decisions: ${result.citedDecisions.join(", ")}`;
+  return [
+    `Verdict: ${result.verdict}`,
+    "",
+    `Strongest challenge: ${result.challenge}`,
+    "",
+    `What would change its mind: ${result.changesMyMind}`,
+    "",
+    cited
+  ].join("\n");
+}
+
+// src/interactive/prompt-source-label.ts
+init_esm_shims();
+function promptSourceLabel(sourceInfo) {
+  const source = sourceInfo.source;
+  if (source === void 0) return `${sourceInfo.scope} prompts`;
+  const plugin = /^plugin:(?:[^:]+):(.+)$/u.exec(source);
+  if (plugin?.[1]) return `plugin ${plugin[1]}`;
+  if (source === "config") return "user prompts";
+  if (source === "project") return "project prompts";
+  if (source === "library") return "library";
+  const foreign = /^([a-z0-9-]+)-(user|project)$/u.exec(source);
+  if (foreign?.[1] && foreign[2]) return `${foreign[1]} ${foreign[2]} prompts`;
+  return source;
+}
+
+// src/interactive/slash-spec.ts
+init_esm_shims();
+var COMPLETION_SLOT_NAMES = [
+  "agents",
+  "agent-profiles",
+  "worker-runtimes",
+  "targets",
+  "models",
+  "capabilities",
+  "external-agents",
+  "rosters",
+  "shareable-runs",
+  "skills",
+  "fleet-contracts",
+  "fleet-vars",
+  "fleet-var-values",
+  "tasks",
+  "context-refs",
+  "receipts",
+  "pane-runs-agents",
+  "pane-presets",
+  "pane-targets",
+  "thinking-levels",
+  "settings-areas",
+  "settings-groups",
+  "help-queries",
+  "paths"
+];
+function getFlagValuePlaceholder(flag) {
+  if (flag.valueName) return flag.valueName;
+  if (flag.values && flag.values.length > 0) {
+    return flag.values.join("|");
+  }
+  return flag.name.replace(/^--/, "");
+}
+function renderArgsSpec(spec) {
+  const parts = [];
+  if (spec.flags) {
+    for (const flag of spec.flags) {
+      if (flag.takesValue) {
+        const placeholder = getFlagValuePlaceholder(flag);
+        parts.push(`[${flag.name} <${placeholder}>]`);
+      } else {
+        parts.push(`[${flag.name}]`);
+      }
+    }
+  }
+  if (spec.positionals) {
+    for (const pos of spec.positionals) {
+      if (pos.required) {
+        parts.push(`<${pos.name}>`);
+      } else {
+        parts.push(`[${pos.name}]`);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function usageLine(entry, subcommand) {
+  const prefix = `/${entry.name}`;
+  const argsSpec = entry.args ?? {};
+  if (subcommand && argsSpec.subcommands?.[subcommand]) {
+    const subSpec = argsSpec.subcommands[subcommand];
+    const subStr = renderArgsSpec(subSpec);
+    return `
+usage: ${prefix} ${subcommand}${subStr ? ` ${subStr}` : ""}
+`;
+  }
+  if (argsSpec.subcommands) {
+    const subParts = [];
+    const rootSpec = {
+      ...argsSpec.flags ? { flags: argsSpec.flags } : {},
+      ...argsSpec.positionals ? { positionals: argsSpec.positionals } : {}
+    };
+    const rootStr = renderArgsSpec(rootSpec);
+    if (rootStr.length > 0) subParts.push(`${prefix} ${rootStr}`);
+    for (const [subName, subSpec] of Object.entries(argsSpec.subcommands)) {
+      const subStr = renderArgsSpec(subSpec);
+      subParts.push(`${prefix} ${subName}${subStr ? ` ${subStr}` : ""}`);
+    }
+    return `
+usage: ${subParts.join(" | ")}
+`;
+  }
+  const argsStr = renderArgsSpec(argsSpec);
+  return `
+usage: ${prefix}${argsStr ? ` ${argsStr}` : ""}
+`;
+}
+function parseArgs(spec, argsLine) {
+  const flags = /* @__PURE__ */ new Map();
+  const flagValues = /* @__PURE__ */ new Map();
+  const positionals = [];
+  let subcommand;
+  let rest;
+  let currentSpec = spec;
+  let index = 0;
+  const skipWhitespace = () => {
+    while (index < argsLine.length) {
+      const char = argsLine[index];
+      if (char && /\s/.test(char)) {
+        index++;
+      } else {
+        break;
+      }
+    }
+  };
+  skipWhitespace();
+  if (currentSpec.subcommands && index < argsLine.length) {
+    const start = index;
+    while (index < argsLine.length) {
+      const char = argsLine[index];
+      if (char && !/\s/.test(char)) {
+        index++;
+      } else {
+        break;
+      }
+    }
+    const sub = argsLine.slice(start, index);
+    if (currentSpec.subcommands[sub]) {
+      subcommand = sub;
+      currentSpec = currentSpec.subcommands[sub];
+      skipWhitespace();
+    } else {
+      index = start;
+    }
+  }
+  const flagSpecs = currentSpec.flags ?? [];
+  const positionalSpecs = currentSpec.positionals ?? [];
+  let positionalIndex = 0;
+  const readToken = () => {
+    const tokenStart = index;
+    let token = "";
+    let quote = null;
+    while (index < argsLine.length) {
+      const char = argsLine[index] ?? "";
+      if (quote !== null) {
+        if (char === quote) quote = null;
+        else token += char;
+        index++;
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        quote = char;
+        index++;
+        continue;
+      }
+      if (/\s/.test(char)) break;
+      token += char;
+      index++;
+    }
+    if (index === tokenStart) return null;
+    return { token };
+  };
+  const consumeFlag = (matchedFlagSpec, token) => {
+    const flagName = matchedFlagSpec.name;
+    if (matchedFlagSpec.takesValue) {
+      skipWhitespace();
+      if (index >= argsLine.length) return `Flag ${token} requires a value`;
+      const value = readToken();
+      if (value === null) return `Flag ${token} requires a value`;
+      const val = value.token;
+      if (matchedFlagSpec.values && !matchedFlagSpec.values.includes(val)) {
+        return `Invalid value for ${flagName}: ${val}`;
+      }
+      if (matchedFlagSpec.repeatable) {
+        const next = [...flagValues.get(flagName) ?? [], val];
+        flagValues.set(flagName, next);
+        flags.set(flagName, next.join(" "));
+      } else {
+        flagValues.set(flagName, [val]);
+        flags.set(flagName, val);
+      }
+      return null;
+    }
+    flags.set(flagName, true);
+    return null;
+  };
+  const errorResult = (error) => ({
+    flags,
+    flagValues,
+    positionals,
+    ...subcommand !== void 0 ? { subcommand } : {},
+    error
+  });
+  while (index < argsLine.length) {
+    const currentPositionalSpec = positionalSpecs[positionalIndex];
+    if (currentPositionalSpec?.rest) {
+      if (currentSpec.parseFlagsInRest) {
+        const text = [];
+        while (index < argsLine.length) {
+          const start = index;
+          const read2 = readToken();
+          if (!read2) break;
+          if (read2.token === "--") {
+            text.push(argsLine.slice(index).trim());
+            index = argsLine.length;
+            break;
+          }
+          const flag = flagSpecs.find((item) => item.name === read2.token);
+          if (flag) {
+            const error = consumeFlag(flag, read2.token);
+            if (error) return errorResult(error);
+          } else if (read2.token.startsWith("--")) return errorResult(`Unknown flag: ${read2.token}`);
+          else text.push(argsLine.slice(start, index));
+          skipWhitespace();
+        }
+        const restVal2 = text.join(" ").trim();
+        if (!restVal2) return errorResult(`Missing required argument: ${currentPositionalSpec.name}`);
+        positionals.push(restVal2);
+        rest = restVal2;
+        positionalIndex++;
+        break;
+      }
+      if (currentSpec.parseFlagsBeforeRest) {
+        while (index < argsLine.length) {
+          const tokenStart = index;
+          const read2 = readToken();
+          if (read2 === null) break;
+          const matchedFlagSpec2 = flagSpecs.find((f) => f.name === read2.token);
+          if (!matchedFlagSpec2) {
+            index = tokenStart;
+            break;
+          }
+          const error = consumeFlag(matchedFlagSpec2, read2.token);
+          if (error) return errorResult(error);
+          skipWhitespace();
+        }
+      }
+      const restVal = argsLine.slice(index).trim();
+      if (restVal.length > 0) {
+        positionals.push(restVal);
+        rest = restVal;
+      }
+      positionalIndex++;
+      index = argsLine.length;
+      break;
+    }
+    const read = readToken();
+    if (read === null) break;
+    const token = read.token;
+    let isFlag = false;
+    let matchedFlagSpec;
+    if (token.startsWith("--")) {
+      matchedFlagSpec = flagSpecs.find((f) => f.name === token);
+      if (matchedFlagSpec) {
+        isFlag = true;
+      } else {
+        return errorResult(`Unknown flag: ${token}`);
+      }
+    }
+    if (isFlag && matchedFlagSpec) {
+      const error = consumeFlag(matchedFlagSpec, token);
+      if (error) return errorResult(error);
+    } else {
+      if (positionalIndex < positionalSpecs.length) {
+        positionals.push(token);
+        positionalIndex++;
+      } else {
+        return errorResult(`Unexpected argument: ${token}`);
+      }
+    }
+    skipWhitespace();
+  }
+  for (let idx = positionalIndex; idx < positionalSpecs.length; idx++) {
+    const spec2 = positionalSpecs[idx];
+    if (spec2?.required) {
+      return {
+        flags,
+        flagValues,
+        positionals,
+        ...subcommand !== void 0 ? { subcommand } : {},
+        error: `Missing required argument: ${spec2.name}`
+      };
+    }
+  }
+  return {
+    flags,
+    flagValues,
+    positionals,
+    ...subcommand !== void 0 ? { subcommand } : {},
+    ...rest !== void 0 ? { rest } : {}
+  };
+}
+function completionTokens(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    while (index < text.length && /\s/.test(text[index] ?? "")) index++;
+    if (index >= text.length) break;
+    const start = index;
+    let quote;
+    if (text[index] === '"' || text[index] === "'") {
+      quote = text[index];
+      index++;
+    }
+    const contentStart = index;
+    let value = "";
+    while (index < text.length) {
+      const char = text[index] ?? "";
+      if (quote) {
+        if (char === quote) break;
+      } else if (/\s/.test(char)) {
+        break;
+      } else if (char === '"' || char === "'") {
+        const embedded = char;
+        index++;
+        while (index < text.length && text[index] !== embedded) value += text[index++] ?? "";
+        if (text[index] === embedded) index++;
+        continue;
+      }
+      value += char;
+      index++;
+    }
+    const contentEnd = index;
+    if (quote && text[index] === quote) index++;
+    tokens.push({ value, start, end: index, contentStart, contentEnd, ...quote ? { quote } : {} });
+  }
+  return tokens;
+}
+function tokenAtCursor(text, cursor) {
+  const safeCursor = Math.max(0, Math.min(cursor, text.length));
+  const tokens = completionTokens(text);
+  const containing = tokens.find((token) => safeCursor >= token.start && safeCursor <= token.end);
+  if (containing) {
+    return { current: containing, completed: tokens.filter((token) => token.end <= containing.start) };
+  }
+  return {
+    current: { value: "", start: safeCursor, end: safeCursor, contentStart: safeCursor, contentEnd: safeCursor },
+    completed: tokens.filter((token) => token.end <= safeCursor)
+  };
+}
+function walkCompletedTokens(spec, tokens) {
+  const flagSpecs = spec.flags ?? [];
+  const positionalSpecs = spec.positionals ?? [];
+  const walk = { usedFlags: /* @__PURE__ */ new Set(), awaitingValue: null, positionalIndex: 0, restBegun: false };
+  for (const token of tokens) {
+    if (walk.awaitingValue) {
+      walk.awaitingValue = null;
+      continue;
+    }
+    const atRest = positionalSpecs[walk.positionalIndex]?.rest === true;
+    const flagsParseable = !atRest || spec.parseFlagsBeforeRest === true;
+    const matched = flagsParseable && token.startsWith("--") ? flagSpecs.find((flag) => flag.name === token) : void 0;
+    if (matched) {
+      walk.usedFlags.add(matched.name);
+      if (matched.takesValue) walk.awaitingValue = matched;
+      continue;
+    }
+    if (atRest) {
+      walk.restBegun = true;
+      break;
+    }
+    walk.positionalIndex += 1;
+  }
+  return walk;
+}
+function flagCompletions(spec, walk, current) {
+  const available = (spec.flags ?? []).filter((flag) => flag.repeatable === true || !walk.usedFlags.has(flag.name));
+  const lower = current.toLowerCase();
+  const rows = available.filter((flag) => flag.name.toLowerCase().startsWith(lower)).map((flag) => ({ flag, name: flag.name }));
+  return rows.map(({ flag, name }) => ({
+    token: name,
+    ...flag.takesValue ? { hint: `<${getFlagValuePlaceholder(flag)}>` } : {},
+    hasNextSlot: flag.takesValue === true
+  }));
+}
+function completeArgs(spec, argumentText, cursor = argumentText.length) {
+  const { current: currentToken, completed: completedTokens } = tokenAtCursor(argumentText, cursor);
+  const current = currentToken.value.slice(0, Math.max(0, cursor - currentToken.contentStart));
+  const completed = completedTokens.map((token) => token.value);
+  const range = {
+    tokenStart: currentToken.contentStart,
+    tokenEnd: currentToken.contentEnd,
+    ...currentToken.quote ? { quote: currentToken.quote } : {}
+  };
+  const completions = [];
+  let active = spec;
+  let walkTokens = completed;
+  let submenu;
+  if (spec.subcommands) {
+    const first = completed[0];
+    if (first === void 0) {
+      for (const [name, subSpec] of Object.entries(spec.subcommands)) {
+        if (!name.toLowerCase().startsWith(current.toLowerCase())) continue;
+        const hint = renderArgsSpec(subSpec);
+        completions.push({
+          token: name,
+          ...hint.length > 0 ? { hint } : {},
+          hasNextSlot: hint.length > 0
+        });
+      }
+      submenu = { parent: "", canGoBack: true };
+    } else if (spec.subcommands[first]) {
+      active = spec.subcommands[first];
+      walkTokens = completed.slice(1);
+    }
+  }
+  const walk = walkCompletedTokens(active, walkTokens);
+  if (walk.restBegun) {
+    return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
+  }
+  if (walk.awaitingValue) {
+    for (const value of walk.awaitingValue.values ?? []) {
+      if (value.toLowerCase().startsWith(current.toLowerCase())) completions.push({ token: value, hasNextSlot: true });
+    }
+    if (walk.awaitingValue.completionSlot) {
+      completions.push({ token: current, completionSlot: walk.awaitingValue.completionSlot, hasNextSlot: true });
+    }
+    return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
+  }
+  const atRest = (active.positionals ?? [])[walk.positionalIndex]?.rest === true;
+  const positional = (active.positionals ?? [])[walk.positionalIndex];
+  for (const value of positional?.values ?? []) {
+    if (value.toLowerCase().startsWith(current.toLowerCase())) {
+      completions.push({ token: value, hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0) });
+    }
+  }
+  if (positional?.completionSlot && !current.startsWith("-")) {
+    completions.push({
+      token: current,
+      completionSlot: positional.completionSlot,
+      hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0)
+    });
+  }
+  const flagsParseable = !atRest || active.parseFlagsBeforeRest === true;
+  if (flagsParseable && (current.length === 0 || current.startsWith("-"))) {
+    completions.push(...flagCompletions(active, walk, current));
+  }
+  return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
+}
+function matchFromSpec(entry, trimmed) {
+  const matchedPrefix = `/${entry.name}`;
+  if (trimmed !== matchedPrefix && !trimmed.startsWith(`${matchedPrefix} `)) return null;
+  const argsLine = trimmed.slice(matchedPrefix.length);
+  const parsed = parseArgs(entry.args ?? {}, argsLine);
+  if (entry.fromArgs) {
+    return entry.fromArgs(parsed, trimmed);
+  }
+  return null;
+}
+
+// src/interactive/worker-share.ts
+init_esm_shims();
+
+// src/interactive/worker-stream.ts
+init_esm_shims();
+function workerAskedByModel(state) {
+  return state.parentToolCallId !== void 0 || state.origin === "agent";
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function workerRuntimeKind(runtimeKind, runtimeId) {
+  if (runtimeKind === "acp-delegation") return "acp";
+  if (runtimeId === "claude-code") return "claude-code";
+  if (runtimeId === "claude-sdk") return "claude-sdk";
+  return "clio";
+}
+function runtimeIdentity(payload) {
+  const kind = workerRuntimeKind(payload.runtimeKind, payload.runtimeId);
+  if (kind === "acp") {
+    const peerId = nonEmptyString(payload.agentId);
+    return { kind, ...peerId !== void 0 ? { peerId } : {} };
+  }
+  const targetId = nonEmptyString(payload.targetId);
+  const wireModelId = nonEmptyString(payload.wireModelId);
+  return {
+    kind,
+    ...targetId !== void 0 ? { targetId } : {},
+    ...wireModelId !== void 0 ? { wireModelId } : {}
+  };
+}
+function workerTargetLabel(runtime) {
+  if (runtime.kind === "acp") return runtime.peerId ?? "acp";
+  if (runtime.targetId !== void 0 && runtime.wireModelId !== void 0) {
+    return `${runtime.targetId}/${runtime.wireModelId}`;
+  }
+  return runtime.targetId ?? runtime.wireModelId ?? "unknown";
+}
+function terminalFacts(payload) {
+  const detail = nonEmptyString(payload.outcomeDetail);
+  const tokenCount = finiteNumber(payload.tokenCount);
+  const durationMs = finiteNumber(payload.durationMs);
+  const exitCode = finiteNumber(payload.exitCode);
+  return {
+    outcome: payload.outcome,
+    ...payload.outcomeCode !== null && payload.outcomeCode !== void 0 ? { outcomeCode: payload.outcomeCode } : {},
+    ...detail !== void 0 ? { failureMessage: detail } : {},
+    ...exitCode !== void 0 ? { exitCode } : {},
+    ...tokenCount !== void 0 ? { tokenCount } : {},
+    ...durationMs !== void 0 ? { durationMs } : {},
+    ...payload.toolActivity ? { toolCalls: payload.toolActivity.calls } : {}
+  };
+}
+function workerReceiptSummary(facts) {
+  if (facts === null) return { outcome: "unknown", receiptUnavailable: true };
+  const { text: _text, ...summary } = facts;
+  return summary;
+}
+function createWorkerStream(options = {}) {
+  const byAssignment = /* @__PURE__ */ new Map();
+  const attemptByAssignment = /* @__PURE__ */ new Map();
+  const assignmentByRun = /* @__PURE__ */ new Map();
+  const progressByAssignment = /* @__PURE__ */ new Map();
+  const applyProgress = (entry, fold) => {
+    const snapshot = fold.snapshot();
+    entry.text = snapshot.tailText;
+    entry.droppedLines = snapshot.droppedLines;
+    entry.tools = [...snapshot.toolNames];
+    entry.progress = snapshot;
+  };
+  const currentEntryForRun = (runId) => {
+    const id = nonEmptyString(runId);
+    if (id === void 0) return void 0;
+    const assignmentId = assignmentByRun.get(id);
+    const entry = assignmentId === void 0 ? void 0 : byAssignment.get(assignmentId);
+    return entry?.runId === id ? entry : void 0;
+  };
+  const settle = (entry, payloadFacts) => {
+    const facts = options.readReceipt?.(entry.runId) ?? { ...payloadFacts, receiptUnavailable: true };
+    entry.receipt = workerReceiptSummary(facts);
+    entry.pending = false;
+    const attempt = entry.attempts[entry.attempts.length - 1];
+    if (attempt !== void 0) attempt.outcome = facts.outcome;
+    const fold = progressByAssignment.get(entry.assignmentId);
+    if (fold !== void 0) {
+      fold.settle(nonEmptyString(facts.text));
+      applyProgress(entry, fold);
+    }
+    return { kind: "updated", entry };
+  };
+  return {
+    started(payload) {
+      const runId = nonEmptyString(payload.runId);
+      const assignmentId = nonEmptyString(payload.assignmentId) ?? runId;
+      if (runId === void 0 || assignmentId === void 0) return null;
+      const runtime = runtimeIdentity(payload);
+      const existing = byAssignment.get(assignmentId);
+      if (existing !== void 0) {
+        if (payload.attempt <= (attemptByAssignment.get(assignmentId) ?? -1)) return null;
+        attemptByAssignment.set(assignmentId, payload.attempt);
+        existing.runId = runId;
+        existing.runtime = runtime;
+        existing.pending = true;
+        delete existing.receipt;
+        existing.attempts.push({ runId, targetLabel: workerTargetLabel(runtime) });
+        assignmentByRun.set(runId, assignmentId);
+        const progress2 = progressByAssignment.get(assignmentId);
+        if (progress2 !== void 0) {
+          progress2.restart();
+          applyProgress(existing, progress2);
+        }
+        return { kind: "updated", entry: existing };
+      }
+      if (payload.requestOrigin !== "user" && payload.requestOrigin !== "agent") return null;
+      attemptByAssignment.set(assignmentId, payload.attempt);
+      const progress = createWorkerProgressFold();
+      const entry = {
+        assignmentId,
+        runId,
+        origin: payload.requestOrigin,
+        agentId: payload.agentId,
+        runtime,
+        text: "",
+        droppedLines: 0,
+        tools: [],
+        progress: progress.snapshot(),
+        attempts: [{ runId, targetLabel: workerTargetLabel(runtime) }],
+        pending: true,
+        ...payload.council !== void 0 ? { council: { ...payload.council } } : {},
+        ...payload.parentToolCallId !== void 0 ? { parentToolCallId: payload.parentToolCallId } : {}
+      };
+      byAssignment.set(assignmentId, entry);
+      assignmentByRun.set(runId, assignmentId);
+      progressByAssignment.set(assignmentId, progress);
+      return { kind: "created", entry };
+    },
+    progress(payload) {
+      const entry = currentEntryForRun(payload.runId);
+      if (entry === void 0 || !entry.pending) return null;
+      const fold = progressByAssignment.get(entry.assignmentId);
+      if (fold === void 0 || !fold.observe(payload.event)) return null;
+      applyProgress(entry, fold);
+      return { kind: "updated", entry };
+    },
+    completed(payload) {
+      const entry = currentEntryForRun(payload.runId);
+      if (entry === void 0) return null;
+      return settle(entry, terminalFacts(payload));
+    },
+    failed(payload) {
+      const entry = currentEntryForRun(payload.runId);
+      if (entry === void 0) return null;
+      return settle(entry, terminalFacts(payload));
+    },
+    aborted(payload) {
+      const entry = currentEntryForRun(payload.runId);
+      if (entry === void 0 || !entry.pending) return null;
+      const durationMs = finiteNumber(payload.elapsedMs);
+      const failureMessage = nonEmptyString(payload.reason);
+      entry.pending = false;
+      entry.receipt = {
+        outcome: "canceled",
+        ...durationMs !== void 0 ? { durationMs } : {},
+        ...failureMessage !== void 0 ? { failureMessage } : {},
+        provisional: true
+      };
+      const attempt = entry.attempts[entry.attempts.length - 1];
+      if (attempt !== void 0) attempt.outcome = "canceled";
+      return { kind: "updated", entry };
+    },
+    get(assignmentId) {
+      return byAssignment.get(assignmentId);
+    },
+    reset() {
+      byAssignment.clear();
+      attemptByAssignment.clear();
+      assignmentByRun.clear();
+      progressByAssignment.clear();
+    }
+  };
+}
+
+// src/interactive/worker-share.ts
+var WORKER_SHARE_MAX_BYTES = WORKER_OUTPUT_MAX_BYTES;
+var SHARE_TRUNCATION_MARKER = "\n[worker output truncated]";
+function outcomeWord(outcome) {
+  return outcome === "succeeded" ? "ok" : outcome;
+}
+var WORKER_SHARE_NOTE_PREFIX = "[worker result]";
+var WORKER_SHARE_ORIGIN = "shared by the operator";
+function formatWorkerShareNote(facts) {
+  return shareNote(facts, facts.text);
+}
+function shareNote(facts, body) {
+  const text = body.trim();
+  if (text.length === 0) return null;
+  const header = `${WORKER_SHARE_NOTE_PREFIX} ${facts.agentId} \xB7 run ${facts.runId} \xB7 ${outcomeWord(facts.outcome)} \xB7 ${WORKER_SHARE_ORIGIN}`;
+  return `${header}
+${truncateUtf8(text, WORKER_SHARE_MAX_BYTES, SHARE_TRUNCATION_MARKER)}`;
+}
+function councilMemberLine(member) {
+  if (member.failed !== void 0) return `[${member.label}] failed: ${member.failed.reason}`;
+  const verdict = member.verdict === void 0 ? "" : ` (verdict ${member.verdict})`;
+  return `[${member.label}]${verdict} ${member.answer.trim()}`;
+}
+function councilSynthesisLines(synthesis) {
+  if (synthesis.kind === "none") return ["[synthesis none] the members answered separately; no synthesis was run."];
+  const facts = [
+    ...synthesis.verdict !== void 0 ? [`verdict ${synthesis.verdict}`] : [],
+    ...synthesis.tally !== void 0 ? [
+      `tally ${Object.entries(synthesis.tally).map(([key, count]) => `${key}=${count}`).join(" ")}`
+    ] : [],
+    ...synthesis.judgeRunId !== void 0 ? [`judge run ${synthesis.judgeRunId}`] : []
+  ];
+  const head = `[synthesis ${synthesis.kind}]${facts.length > 0 ? ` ${facts.join(" \xB7 ")}` : ""}`;
+  const text = synthesis.text?.trim() ?? "";
+  return text.length > 0 ? [head, text] : [head];
+}
+function formatCouncilShareNote(facts, report) {
+  const finalRound = report.members.reduce((highest, member) => Math.max(highest, member.round), 1);
+  const body = [
+    ...report.members.filter((member) => member.round === finalRound).map(councilMemberLine),
+    ...councilSynthesisLines(report.synthesis)
+  ].join("\n\n");
+  return shareNote(facts, body);
+}
+function formatCouncilMemberShareNote(facts, label) {
+  const text = facts.text.trim();
+  if (text.length === 0) return null;
+  return shareNote(facts, `[${label}] ${text}`);
+}
+function isWorkerShareNote(text) {
+  return text.trimStart().startsWith(`${WORKER_SHARE_NOTE_PREFIX} `);
+}
+function workerShareFactsFromEntry(entry) {
+  if (entry.pending || entry.receipt === void 0) return null;
+  return { agentId: entry.agentId, runId: entry.runId, outcome: entry.receipt.outcome, text: entry.text };
+}
+function selectWorkerRunToShare(entries, id) {
+  const wanted = id?.trim();
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry === void 0 || entry.pending || entry.receipt === void 0) continue;
+    if (wanted === void 0 || wanted.length === 0) {
+      if (!workerAskedByModel(entry)) return entry;
+      continue;
+    }
+    if (entry.assignmentId === wanted || entry.attempts.some((attempt) => attempt.runId === wanted)) return entry;
+  }
+  return null;
+}
+
+// src/interactive/slash-commands.ts
+var SETTINGS_AREA_IDS = [
+  "chat",
+  "fleet",
+  "targets",
+  "context",
+  "safety",
+  "interface",
+  "integrations"
+];
+function shareReceipt(agentId, receipt, deps) {
+  if (!deps.submitOperatorNote) {
+    deps.notice("error", "--share is not wired in this session; the result stayed local");
+    return;
+  }
+  const note = formatWorkerShareNote({
+    agentId,
+    runId: receipt.runId,
+    outcome: receipt.outcome,
+    text: receipt.output?.text ?? ""
+  });
+  if (note === null) {
+    deps.notice("warn", `--share: run ${receipt.runId} produced no text to share`);
+    return;
+  }
+  deps.submitOperatorNote(note);
+}
+async function runAttributed(command, request, deps, share) {
+  const { dispatch, notice, bus } = deps;
+  const progressBus = dispatch.ownsProgressBus?.(bus) === true ? void 0 : bus;
+  try {
+    const handle = await dispatch.dispatch(request);
+    for await (const event of handle.events) {
+      const e = event;
+      if (!e.type || e.type === "heartbeat") continue;
+      progressBus?.emit(BusChannels.DispatchProgress, { runId: handle.runId, agentId: request.agentId, event });
+    }
+    const receipt = await handle.finalPromise;
+    if (receipt.outcome === "canceled") {
+      notice("warn", `${command} aborted: ${receipt.outcomeDetail ?? "operator abort"}`);
+    } else if (receipt.exitCode !== 0 || receipt.failureMessage) {
+      const failure = receipt.failureMessage ? ` ${receipt.failureMessage}` : "";
+      notice("error", `${command} failed: exit=${receipt.exitCode}${failure}`);
+    }
+    if (share) shareReceipt(request.agentId, receipt, deps);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (err instanceof AdmissionCanceledError) {
+      notice("warn", `${command} aborted: ${msg.replace(/^dispatch:\s*/u, "")}`);
+    } else {
+      notice("error", `${command} failed: ${msg}`);
+    }
+  }
+}
+async function handleRun(agentId, task, deps, options = {}) {
+  const decisionRefs = activeDecisionRefs(deps.getDecisionBoard?.() ?? []);
+  if (options.target && options.workerProfile) {
+    deps.notice(
+      "warn",
+      `--target ${options.target} takes precedence; --agent-profile ${options.workerProfile} will be ignored`
+    );
+  }
+  if (options.target && options.workerRuntime) {
+    deps.notice(
+      "warn",
+      `--target ${options.target} takes precedence; --runtime ${options.workerRuntime} will be ignored`
+    );
+  }
+  await runAttributed(
+    "run",
+    {
+      agentId,
+      task,
+      executionRole: requestExecutionRole({
+        agentId,
+        ...deps.getAgentRoleFacts ? { resolveFacts: deps.getAgentRoleFacts } : {}
+      }),
+      requestOrigin: "user",
+      ...decisionRefs.length > 0 ? { decisionRefs } : {},
+      ...options.workerProfile ? { workerProfile: options.workerProfile } : {},
+      ...options.workerRuntime ? { workerRuntime: options.workerRuntime } : {},
+      ...options.target ? { target: options.target } : {},
+      ...options.model ? { model: options.model } : {},
+      ...options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {},
+      ...options.toolProfile ? { toolProfile: options.toolProfile } : {},
+      ...options.requiredCapabilities && options.requiredCapabilities.length > 0 ? { requiredCapabilities: options.requiredCapabilities } : {}
+    },
+    deps,
+    options.share === true
+  );
+}
+async function handleDelegate(agentId, task, deps, options = {}) {
+  await runAttributed(
+    "delegate",
+    { agentId, delegationAgentId: agentId, executionRole: "builder", requestOrigin: "user", task },
+    deps,
+    options.share === true
+  );
+}
+async function handleOracle(question, ctx) {
+  if (!ctx.submitOperatorNote) {
+    ctx.notice("error", "/oracle is not wired in this session; there is nowhere to put the answer");
+    return;
+  }
+  if (ctx.isTurnInFlight?.() === true) {
+    ctx.notice("warn", "a turn is in flight; /oracle is refused rather than queued");
+    return;
+  }
+  const sources = ctx.oracleBriefing?.();
+  if (!sources) {
+    ctx.notice("error", "/oracle needs the session record, which is not wired in this session");
+    return;
+  }
+  const digest = packOracleDigest({ ...sources, question });
+  const request = {
+    agentId: ORACLE_AGENT_ID,
+    task: ORACLE_TASK,
+    briefing: digest.text,
+    executionRole: requestExecutionRole({
+      agentId: ORACLE_AGENT_ID,
+      ...ctx.getAgentRoleFacts ? { resolveFacts: ctx.getAgentRoleFacts } : {}
+    }),
+    requestOrigin: "internal",
+    autonomy: "read-only"
+  };
+  const progressBus = ctx.dispatch.ownsProgressBus?.(ctx.bus) === true ? void 0 : ctx.bus;
+  try {
+    const handle = await ctx.dispatch.dispatch(request);
+    for await (const event of handle.events) {
+      const typed = event;
+      if (!typed.type || typed.type === "heartbeat") continue;
+      progressBus?.emit(BusChannels.DispatchProgress, { runId: handle.runId, agentId: ORACLE_AGENT_ID, event });
+    }
+    const receipt = await handle.finalPromise;
+    const parsed = parseOracleResult(receipt.output?.text ?? null);
+    if (parsed === null) {
+      ctx.notice("error", `/oracle run ${receipt.runId} returned no usable answer (${receipt.outcome})`);
+      return;
+    }
+    const note = formatWorkerShareNote({
+      agentId: ORACLE_AGENT_ID,
+      runId: receipt.runId,
+      outcome: receipt.outcome,
+      text: formatOracleAnswer(parsed)
+    });
+    if (note === null) {
+      ctx.notice("error", `/oracle run ${receipt.runId} produced no text to share`);
+      return;
+    }
+    ctx.submitOperatorNote(note);
+  } catch (err) {
+    ctx.notice("error", `/oracle failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function handleCouncil(task, options, ctx) {
+  if (ctx.isTurnInFlight?.() === true) {
+    ctx.notice("warn", "a turn is in flight; /council is refused rather than queued");
+    return;
+  }
+  if (!ctx.runCouncilDispatch) {
+    ctx.notice("error", "/council is not wired in this session");
+    return;
+  }
+  const rosters = ctx.getWorkerRosters?.();
+  if (rosters === void 0) {
+    ctx.notice("error", "/council needs workers.rosters, which is not wired in this session");
+    return;
+  }
+  const resolved = resolveCouncilRoster(options.roster, rosters);
+  if (!resolved.ok) {
+    ctx.notice("error", resolved.reason);
+    return;
+  }
+  try {
+    const outcome = await ctx.runCouncilDispatch(buildCouncilDispatchArgs(task, resolved.roster, options));
+    if (outcome.status === "blocked") ctx.notice("warn", `/council was not admitted: ${outcome.reason}`);
+    else if (outcome.status === "error") ctx.notice("error", `/council failed: ${outcome.message}`);
+  } catch (err) {
+    ctx.notice("error", `/council failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function councilAwareShareNote(facts, entry) {
+  const council = entry.council;
+  if (council === void 0) return formatWorkerShareNote(facts);
+  if (council.label !== COUNCIL_SYNTHESIS_LABEL) return formatCouncilMemberShareNote(facts, council.label);
+  const report = parseCouncilReport(facts.text);
+  return report === null ? formatWorkerShareNote(facts) : formatCouncilShareNote(facts, report);
+}
+function shareWorkerRun(runId, ctx) {
+  if (!ctx.submitOperatorNote) {
+    ctx.notice("error", "share is not wired; the worker transcript is unavailable in this session");
+    return;
+  }
+  const entry = selectWorkerRunToShare(ctx.listWorkerRuns?.() ?? [], runId);
+  if (!entry) {
+    ctx.notice(
+      "error",
+      runId === void 0 ? "no finished /run or /delegate result to share yet" : `no finished run ${runId} in this session`
+    );
+    return;
+  }
+  const facts = workerShareFactsFromEntry(entry);
+  const note = facts === null ? null : councilAwareShareNote(facts, entry);
+  if (note === null) {
+    ctx.notice("error", `run ${entry.runId} produced no text to share`);
+    return;
+  }
+  ctx.submitOperatorNote(note);
+}
+function formatReceiptVerificationBlock(runId, result) {
+  const status = result.ok ? result.compromised ? "compromised" : "ok" : result.retired ? "retired" : "fail";
+  const lines = [
+    `verify ${status} ${runId}`,
+    `receipt  ${result.receiptPath ?? "unavailable"}`,
+    `digest   ${result.sealedDigest ?? "unavailable"}`,
+    `evidence ${result.trustSummary ?? (!result.ok ? result.reason : "trust status unavailable")}`
+  ];
+  if (result.checks && result.checks.length > 0) {
+    lines.push("checks");
+    for (const check of result.checks) lines.push(`  ${check.ok ? "\u2713" : "\u2717"} ${check.name}: ${check.evidence}`);
+  }
+  return lines.join("\n");
+}
+var SLASH_COMMAND_GROUPS = ["Work", "Inspect", "Configure", "Session"];
+var RUN_THINKING_LEVELS = THINKING_LEVELS;
+function isRunThinkingLevel(value) {
+  return RUN_THINKING_LEVELS.some((level) => level === value);
+}
+function isSettingsAreaId(value) {
+  return SETTINGS_AREA_IDS.some((area) => area === value);
+}
+var COMPACT_POSITIONALS = [
+  { name: "instructions", required: false, rest: true }
+];
+var RECALL_POSITIONALS = [{ name: "ref", required: true }];
+function fromArgsOrUsage(name, command) {
+  return (parsed) => parsed.error ? { kind: "usage-error", command: name, reason: parsed.error } : command;
+}
+function usageNotice(entry, subcommand) {
+  return usageLine(entry, subcommand).trim();
+}
+function formatPanesStatus(status) {
+  const server = status.server ? `pane host ${status.server.version}, protocol ${status.server.protocol}` : "no server";
+  const lines = [
+    `panes: mode=${status.mode} ${status.available ? "available" : "unavailable"} (${server})`,
+    `  ${status.reason}`,
+    ...status.socketPath ? [`  socket ${status.socketPath}`] : [],
+    `  settings: enabled=${status.settings.enabled} notifications=${status.settings.notifications} layout=${status.settings.layout} journal=${status.settings.journal}`,
+    `  files: enabled=${status.settings.yazi.enabled} mode=${status.settings.yazi.mode} profile=${status.settings.yazi.profile} followCwd=${status.settings.yazi.followCwd}`,
+    `  file pane: mode=${status.yazi.mode} pane=${status.yazi.paneId ?? "none"} cwd=${status.yazi.paneCwd ?? "unknown"} lastLine=${status.yazi.lastLineAt === null ? "never" : new Date(status.yazi.lastLineAt).toISOString()} dropped=${status.yazi.droppedLines}`
+  ];
+  if (status.docks.length > 0) {
+    lines.push(
+      `  docks: ${status.docks.map((dock) => `${dock.slot}=${dock.paneId} @${(dock.targetShare * 100).toFixed(0)}%`).join(", ")}`
+    );
+  }
+  if (status.panes.length === 0) {
+    lines.push("  no Clio-owned panes");
+  } else {
+    lines.push(`  ${status.panes.length} Clio-owned pane(s):`);
+    for (const pane of status.panes) {
+      const adopted = pane.adopted ? " adopted" : "";
+      const pending = pane.pending ? " opening" : "";
+      lines.push(`    ${pane.paneId} ${pane.purpose} ${pane.label}${adopted}${pending}`);
+    }
+  }
+  lines.push(`  presets: ${PANES_PRESETS.map((preset) => `${preset.id} (${preset.summary})`).join(", ")}`);
+  return lines;
+}
+var BUILTIN_SLASH_COMMANDS = [
+  {
+    name: "background",
+    description: "Detach the newest eligible attached dispatch",
+    group: "Work",
+    kinds: ["background"],
+    args: {},
+    fromArgs: fromArgsOrUsage("background", { kind: "background" }),
+    handle(_command, ctx) {
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Background action requires an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.background();
+    }
+  },
+  {
+    name: "editor",
+    description: "Edit explicit text (or an empty buffer) externally",
+    group: "Work",
+    kinds: ["editor"],
+    args: { positionals: [{ name: "text", required: false, rest: true }] },
+    match(text) {
+      const match = /^\/editor(?:\s+([\s\S]*))?$/u.exec(text);
+      return match ? { kind: "editor", text: match[1] ?? "" } : null;
+    },
+    handle(command, ctx) {
+      if (command.kind !== "editor") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "External editing requires an interactive session");
+        return "rejected";
+      }
+      if (!ctx.keyboardActions.editor(command.text)) return "rejected";
+    }
+  },
+  {
+    name: "interrupt",
+    description: "Interrupt the active run and send this text",
+    group: "Work",
+    kinds: ["interrupt"],
+    args: { positionals: [{ name: "text", required: true, rest: true }] },
+    match(text) {
+      const match = /^\/interrupt(?:\s+([\s\S]*))?$/u.exec(text);
+      return match ? match[1]?.trim() ? { kind: "interrupt", text: match[1] } : { kind: "usage-error", command: "interrupt", reason: "Text is required" } : null;
+    },
+    handle(command, ctx) {
+      if (command.kind !== "interrupt") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Interrupt requires an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.interrupt(command.text);
+    }
+  },
+  {
+    name: "notifications",
+    description: "Dismiss the oldest notification or explicitly dismiss all",
+    group: "Inspect",
+    kinds: ["notifications-dismiss"],
+    args: { subcommands: { dismiss: { positionals: [{ name: "all", required: false }] } } },
+    match(text) {
+      if (!/^\/notifications(?:\s|$)/u.test(text)) return null;
+      const match = /^\/notifications\s+dismiss(?:\s+(all))?$/u.exec(text);
+      return match ? { kind: "notifications-dismiss", all: match[1] === "all" } : { kind: "usage-error", command: "notifications", reason: "Use /notifications dismiss [all]" };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "notifications-dismiss") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Notifications require an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.dismiss(command.all);
+    }
+  },
+  {
+    name: "quit",
+    description: "Exit Clio Coder",
+    group: "Session",
+    kinds: ["quit"],
+    args: {},
+    fromArgs: fromArgsOrUsage("quit", { kind: "quit" }),
+    handle(_command, ctx) {
+      ctx.shutdown();
+    }
+  },
+  {
+    name: "help",
+    description: "Open the interactive help center showing commands and keys",
+    group: "Inspect",
+    kinds: ["help"],
+    args: {
+      positionals: [{ name: "query", required: false, rest: true }]
+    },
+    fromArgs(parsed) {
+      return { kind: "help", ...parsed.rest ? { query: parsed.rest } : {} };
+    },
+    handle(command, ctx) {
+      ctx.openHelp(command.kind === "help" ? command.query : void 0);
+    }
+  },
+  {
+    name: "skill",
+    description: "Invoke a skill, or use `off` to clear its tool surface",
+    group: "Work",
+    kinds: ["skill-invocation", "skill-surface-clear"],
+    args: {
+      positionals: [
+        { name: "name", required: true },
+        { name: "task", required: false, rest: true }
+      ]
+    },
+    match(trimmed) {
+      if (trimmed === "/skill") {
+        return {
+          kind: "usage-error",
+          command: "skill",
+          reason: "Choose /skills to browse, /skill <name> to invoke, or /skill off to clear the active tool surface"
+        };
+      }
+      const command = parseSkillCommand(trimmed);
+      if (!command) return null;
+      if (command.name === SKILL_SURFACE_CLEAR_ARG && command.args.length === 0) {
+        return { kind: "skill-surface-clear" };
+      }
+      return { kind: "skill-invocation", text: trimmed };
+    },
+    handle(command, ctx) {
+      if (command.kind === "skill-invocation") {
+        ctx.submitChat(command.text);
+      } else if (command.kind === "skill-surface-clear") {
+        const cleared = ctx.clearSkillSurface?.() ?? [];
+        ctx.notice(
+          "info",
+          cleared.length > 0 ? `Skill tool surface cleared: ${cleared.join(", ")}.` : "No skill tool surface is active."
+        );
+      }
+    }
+  },
+  {
+    name: "library",
+    description: "Open the full-screen recipe library, review a package operation, or reload installed recipes",
+    group: "Inspect",
+    kinds: ["resources"],
+    subcommandDescriptions: {
+      inspect: "Open the Library on one package or recipe",
+      install: "Review installing one package, then apply it",
+      remove: "Review removing one package, then apply it",
+      import: "Review a plugin source from a path or URL",
+      reload: "Refresh installed recipe resources in this session"
+    },
+    args: {
+      subcommands: {
+        inspect: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        install: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        remove: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        import: {
+          positionals: [{ name: "path-or-url", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        reload: {}
+      }
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "library", reason: parsed.error };
+      if (parsed.flags.has("--user") && parsed.flags.has("--project"))
+        return { kind: "usage-error", command: "library", reason: "Choose one destination: --user or --project" };
+      const scope = parsed.flags.has("--project") ? "project" : parsed.flags.has("--user") ? "user" : void 0;
+      const subcommand = parsed.subcommand;
+      if (subcommand === "reload") return { kind: "resources", family: "plugins", action: "reload" };
+      if (subcommand === "import") {
+        const source = parsed.rest ?? parsed.positionals[0];
+        if (!source)
+          return {
+            kind: "usage-error",
+            command: "library",
+            reason: "/library import needs a directory path or a source URL to review"
+          };
+        return { kind: "resources", tab: "plugin", importSource: source, ...scope ? { scope } : {} };
+      }
+      if (subcommand === "inspect" || subcommand === "install" || subcommand === "remove") {
+        const ref = parsed.positionals[0];
+        if (!ref)
+          return {
+            kind: "usage-error",
+            command: "library",
+            reason: `/library ${subcommand} needs a kind:name reference, such as plugin:materio, or a recipe name`
+          };
+        const prefix = ref.split(":", 1)[0] ?? "";
+        return {
+          kind: "resources",
+          tab: isLibraryKind(prefix) && ref.includes(":") ? prefix : "plugin",
+          focus: ref,
+          ...subcommand === "inspect" ? {} : { intent: subcommand },
+          ...scope ? { scope } : {}
+        };
+      }
+      if (parsed.error || parsed.positionals.length > 0)
+        return {
+          kind: "usage-error",
+          command: "library",
+          reason: "Use /library to browse, /library inspect|install|remove <ref>, /library import <path-or-url>, or /library reload; /skills, /agents and /prompts open the same browser on their category"
+        };
+      return { kind: "resources", tab: "plugin" };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "resources") return;
+      if (command.family === "plugins") {
+        if (!ctx.reloadPlugins)
+          ctx.notice("warn", "library: reload is unavailable in this session; restart to refresh resources");
+        else {
+          try {
+            const snapshot = ctx.reloadPlugins();
+            ctx.notice("success", `library: generation ${snapshot.generation} committed`);
+          } catch (error) {
+            ctx.notice("error", `library: reload failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        return;
+      }
+      if (command.family === "extensions") {
+        if (command.action === "reload") reloadExtensionsCommand(ctx);
+        else ctx.openExtensions();
+        return;
+      }
+      ctx.openSkillsHub?.({
+        ...command.tab ? { tab: command.tab } : {},
+        ...command.focus ? { focus: command.focus } : {},
+        ...command.intent ? { intent: command.intent } : {},
+        ...command.importSource ? { importSource: command.importSource } : {},
+        ...command.scope ? { scope: command.scope } : {}
+      });
+    }
+  },
+  {
+    name: "skills",
+    description: "Open the Library on Skills",
+    group: "Inspect",
+    kinds: [],
+    args: {},
+    fromArgs: fromArgsOrUsage("skills", { kind: "resources", tab: "skill" }),
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "skill" });
+    }
+  },
+  {
+    name: "prompts",
+    description: "Open the Library on Prompts",
+    group: "Inspect",
+    kinds: [],
+    args: {},
+    fromArgs: fromArgsOrUsage("prompts", { kind: "resources", tab: "prompt" }),
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "prompt" });
+    }
+  },
+  {
+    name: "extensions",
+    description: "Inspect harness extensions or reload their commands, hooks and operator UI",
+    group: "Inspect",
+    // Harness navigation uses the shared overlay dispatcher, independently of recipe reload.
+    kinds: [],
+    args: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "extensions", reason: parsed.error };
+      if (parsed.positionals[0] && parsed.positionals[0] !== "reload")
+        return { kind: "usage-error", command: "extensions", reason: "extensions accepts only reload" };
+      return { kind: "resources", family: "extensions", ...parsed.positionals[0] ? { action: "reload" } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "resources" || command.family !== "extensions") return;
+      if (command.action === "reload") reloadExtensionsCommand(ctx);
+      else ctx.openExtensions();
+    }
+  },
+  {
+    name: "share",
+    description: "Share a worker result with the main agent",
+    group: "Work",
+    kinds: ["share"],
+    args: { positionals: [{ name: "run-id", required: false }] },
+    fromArgs(parsed) {
+      const retiredArchiveVerb = parsed.positionals[0];
+      if (retiredArchiveVerb === "export" || retiredArchiveVerb === "import") {
+        return {
+          kind: "usage-error",
+          command: "share",
+          reason: `/share ${retiredArchiveVerb} is retired and did not run; use /archive ${retiredArchiveVerb}`
+        };
+      }
+      if (parsed.error) return { kind: "usage-error", command: "share", reason: parsed.error };
+      return { kind: "share", ...parsed.positionals[0] ? { runId: parsed.positionals[0] } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind === "share") shareWorkerRun(command.runId, ctx);
+    }
+  },
+  {
+    name: "archive",
+    description: "Export or import a full Clio archive",
+    group: "Session",
+    kinds: ["archive-export", "archive-import", "archive-usage"],
+    subcommandDescriptions: { export: "Export a full Clio archive", import: "Import a full Clio archive" },
+    args: {
+      subcommands: {
+        export: {
+          positionals: [{ name: "path", required: true }]
+        },
+        import: {
+          flags: [{ name: "--dry-run" }, { name: "--force" }],
+          positionals: [{ name: "path", required: true }]
+        }
+      }
+    },
+    fromArgs(parsed) {
+      const subcommand = parsed.subcommand === "export" || parsed.subcommand === "import" ? parsed.subcommand : void 0;
+      if (parsed.error) {
+        return {
+          kind: "archive-usage",
+          ...subcommand !== void 0 ? { subcommand } : {},
+          error: parsed.error
+        };
+      }
+      const path = parsed.positionals[0];
+      if (subcommand === "export" && path !== void 0) return { kind: "archive-export", path };
+      if (subcommand === "import" && path !== void 0) {
+        return {
+          kind: "archive-import",
+          path,
+          dryRun: parsed.flags.has("--dry-run"),
+          force: parsed.flags.has("--force")
+        };
+      }
+      return { kind: "archive-usage", ...subcommand !== void 0 ? { subcommand } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind === "archive-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "archive");
+        if (!entry) return;
+        const usage = usageNotice(entry, command.subcommand);
+        ctx.notice("info", command.error ? `${command.error}
+${usage}` : usage);
+        return;
+      }
+      if (command.kind === "archive-export") {
+        if (!ctx.exportShareArchive) {
+          ctx.notice("error", "archive export is not wired");
+          return;
+        }
+        const result = ctx.exportShareArchive(command.path);
+        ctx.notice("success", `exported ${result.fileCount} item(s) to ${result.path}`);
+        return;
+      }
+      if (command.kind === "archive-import") {
+        if (!ctx.importShareArchive) {
+          ctx.notice("error", "archive import is not wired");
+          return;
+        }
+        const plan = ctx.importShareArchive(command.path, { dryRun: command.dryRun, force: command.force });
+        for (const diag of plan.diagnostics) {
+          const detail = diag.path ? `${diag.message}: ${diag.path}` : diag.message;
+          ctx.notice("warn", `${diag.type}: ${detail}`);
+        }
+        const write = plan.actions.filter((action) => action.action === "write").length;
+        const overwrite = plan.actions.filter((action) => action.action === "overwrite").length;
+        const skip = plan.actions.filter((action) => action.action === "skip").length;
+        ctx.notice(
+          command.dryRun ? "info" : "success",
+          `${command.dryRun ? "dry-run" : "import"} write=${write} overwrite=${overwrite} skip=${skip} settings=${plan.actions.filter((action) => action.action === "settings").length}`
+        );
+      }
+    }
+  },
+  {
+    name: "run",
+    description: "Run a fleet agent",
+    group: "Work",
+    kinds: ["run", "run-usage"],
+    args: {
+      parseFlagsBeforeRest: true,
+      flags: [
+        { name: "--agent-profile", takesValue: true, valueName: "profile" },
+        { name: "--runtime", takesValue: true, valueName: "runtimeId" },
+        { name: "--target", takesValue: true, valueName: "id" },
+        { name: "--model", takesValue: true, valueName: "id" },
+        { name: "--thinking", takesValue: true, values: RUN_THINKING_LEVELS, valueName: "level" },
+        { name: "--tool-profile", takesValue: true, values: TOOL_PROFILE_NAMES },
+        { name: "--require", takesValue: true, repeatable: true, valueName: "cap" },
+        { name: "--share" }
+      ],
+      positionals: [
+        { name: "agent", required: true },
+        { name: "task", required: true, rest: true }
+      ]
+    },
+    fromArgs(parsed, trimmed) {
+      if (parsed.error) return { kind: "run-usage" };
+      const options = {};
+      const workerProfile = parsed.flags.get("--agent-profile");
+      if (typeof workerProfile === "string") options.workerProfile = workerProfile;
+      const workerRuntime = parsed.flags.get("--runtime");
+      if (typeof workerRuntime === "string") options.workerRuntime = workerRuntime;
+      const target = parsed.flags.get("--target");
+      if (typeof target === "string") options.target = target;
+      const model = parsed.flags.get("--model");
+      if (typeof model === "string") options.model = model;
+      const thinking = parsed.flags.get("--thinking");
+      if (typeof thinking === "string") {
+        if (!isRunThinkingLevel(thinking)) return { kind: "run-usage" };
+        options.thinkingLevel = thinking;
+      }
+      const toolProfile = parsed.flags.get("--tool-profile");
+      if (typeof toolProfile === "string") {
+        if (!isToolProfileName(toolProfile)) return { kind: "run-usage" };
+        options.toolProfile = toolProfile;
+      }
+      const requiredCapabilities = parsed.flagValues.get("--require");
+      if (requiredCapabilities && requiredCapabilities.length > 0) {
+        options.requiredCapabilities = [...requiredCapabilities];
+      }
+      if (parsed.flags.has("--share")) options.share = true;
+      const agentId = parsed.positionals[0] ?? "";
+      const task = parsed.positionals[1] ?? "";
+      return { kind: "run", agentId, task, options, source: trimmed };
+    },
+    handle(command, ctx) {
+      if (command.kind === "run-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((e) => e.name === "run");
+        if (entry) {
+          ctx.notice("info", usageNotice(entry));
+        }
+        return;
+      }
+      if (command.kind !== "run") return;
+      const { agentId, task, options } = command;
+      ctx.echoOperatorCommand?.(command.source);
+      void (async () => {
+        await handleRun(
+          agentId,
+          task,
+          {
+            dispatch: ctx.dispatch,
+            ...ctx.getDecisionBoard ? { getDecisionBoard: ctx.getDecisionBoard } : {},
+            ...ctx.getAgentRoleFacts ? { getAgentRoleFacts: ctx.getAgentRoleFacts } : {},
+            io: ctx.io,
+            notice: ctx.notice,
+            bus: ctx.bus,
+            ...ctx.submitOperatorNote ? { submitOperatorNote: ctx.submitOperatorNote } : {}
+          },
+          options
+        );
+        ctx.render();
+      })();
+    }
+  },
+  {
+    name: "delegate",
+    description: "Run an ACP delegation agent",
+    group: "Work",
+    kinds: ["delegate", "delegate-usage"],
+    args: {
+      parseFlagsBeforeRest: true,
+      flags: [{ name: "--share" }],
+      positionals: [
+        { name: "agent-id", required: true },
+        { name: "task", required: true, rest: true }
+      ]
+    },
+    fromArgs(parsed, trimmed) {
+      if (parsed.error) return { kind: "delegate-usage" };
+      const agentId = parsed.positionals[0] ?? "";
+      const task = parsed.positionals[1] ?? "";
+      return { kind: "delegate", agentId, task, source: trimmed, ...parsed.flags.has("--share") ? { share: true } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind === "delegate-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((e) => e.name === "delegate");
+        if (entry) {
+          ctx.notice("info", usageNotice(entry));
+        }
+        return;
+      }
+      if (command.kind !== "delegate") return;
+      ctx.echoOperatorCommand?.(command.source);
+      const share = command.share === true;
+      void (async () => {
+        await handleDelegate(
+          command.agentId,
+          command.task,
+          {
+            dispatch: ctx.dispatch,
+            io: ctx.io,
+            notice: ctx.notice,
+            bus: ctx.bus,
+            ...ctx.submitOperatorNote ? { submitOperatorNote: ctx.submitOperatorNote } : {}
+          },
+          { share }
+        );
+        ctx.render();
+      })();
+    }
+  },
+  {
+    name: "btw",
+    description: "Ask a side question that never enters the session transcript",
+    group: "Work",
+    kinds: ["btw", "btw-usage"],
+    args: {
+      positionals: [{ name: "question", required: true, rest: true }]
+    },
+    fromArgs(parsed) {
+      const question = parsed.rest?.trim() ?? "";
+      if (parsed.error || question.length === 0) return { kind: "btw-usage" };
+      return { kind: "btw", question };
+    },
+    handle(command, ctx) {
+      if (command.kind === "btw-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "btw");
+        if (entry) ctx.notice("info", usageNotice(entry));
+        return;
+      }
+      if (command.kind !== "btw") return;
+      ctx.openSideQuestion(command.question);
+    }
+  },
+  {
+    name: "oracle",
+    description: "Ask a read-only advisor to challenge a question against this session's settled decisions",
+    group: "Work",
+    kinds: ["oracle", "oracle-usage"],
+    args: {
+      positionals: [{ name: "question", required: true, rest: true }]
+    },
+    fromArgs(parsed) {
+      const question = parsed.rest?.trim() ?? "";
+      if (parsed.error || question.length === 0) return { kind: "oracle-usage" };
+      return { kind: "oracle", question };
+    },
+    handle(command, ctx) {
+      if (command.kind === "oracle-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "oracle");
+        if (entry) ctx.notice("info", usageNotice(entry));
+        return;
+      }
+      if (command.kind !== "oracle") return;
+      void (async () => {
+        await handleOracle(command.question, ctx);
+        ctx.render();
+      })();
+    }
+  },
+  {
+    name: "council",
+    description: "Ask a roster of read-only members the same task, with an optional vote or judge synthesis",
+    group: "Work",
+    kinds: ["council", "council-usage"],
+    args: {
+      parseFlagsBeforeRest: true,
+      flags: [
+        { name: "--roster", takesValue: true, valueName: "name" },
+        { name: "--rounds", takesValue: true, valueName: "n" },
+        { name: "--synthesis", takesValue: true, values: COUNCIL_SYNTHESIS_MODES }
+      ],
+      positionals: [{ name: "task", required: true, rest: true }]
+    },
+    fromArgs(parsed) {
+      const task = parsed.rest?.trim() ?? "";
+      if (parsed.error) return { kind: "council-usage", reason: parsed.error };
+      if (task.length === 0) return { kind: "council-usage" };
+      const options = {};
+      const roster = parsed.flags.get("--roster");
+      if (typeof roster === "string") options.roster = roster;
+      const rounds = parsed.flags.get("--rounds");
+      if (typeof rounds === "string") {
+        const parsedRounds = Number(rounds);
+        if (!Number.isInteger(parsedRounds) || parsedRounds < 1 || parsedRounds > COUNCIL_MAX_ROUNDS) {
+          return { kind: "council-usage", reason: `--rounds must be an integer 1..${COUNCIL_MAX_ROUNDS}` };
+        }
+        options.rounds = parsedRounds;
+      }
+      const synthesis = parsed.flags.get("--synthesis");
+      if (typeof synthesis === "string") {
+        if (!isCouncilSynthesisMode(synthesis)) return { kind: "council-usage" };
+        options.synthesis = synthesis;
+      }
+      return { kind: "council", task, options };
+    },
+    handle(command, ctx) {
+      if (command.kind === "council-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "council");
+        const usage = entry ? usageNotice(entry) : "usage: /council <task>";
+        ctx.notice("info", command.reason ? `${command.reason}
+${usage}` : usage);
+        return;
+      }
+      if (command.kind !== "council") return;
+      void (async () => {
+        await handleCouncil(command.task, command.options, ctx);
+        ctx.render();
+      })();
+    }
+  },
+  {
+    name: "interop",
+    description: "Inspect coding agents and adopt safe resources",
+    group: "Inspect",
+    kinds: ["agents"],
+    args: {},
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "interop", reason: parsed.error };
+      return { kind: "agents", connect: true };
+    },
+    handle(_command, ctx) {
+      ctx.openInterop?.();
+    }
+  },
+  {
+    name: "agents",
+    description: "Open the Library on Agents",
+    group: "Inspect",
+    kinds: [],
+    args: {},
+    fromArgs(parsed) {
+      if (parsed.error)
+        return {
+          kind: "usage-error",
+          command: "agents",
+          reason: "Use /agents to browse recipes, or /interop to inspect another local agent's resources"
+        };
+      return { kind: "resources", tab: "agent" };
+    },
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "agent" });
+    }
+  },
+  {
+    name: "cost",
+    description: "Show session token and cost totals",
+    group: "Inspect",
+    kinds: ["cost"],
+    args: {},
+    fromArgs: fromArgsOrUsage("cost", { kind: "cost" }),
+    handle(_command, ctx) {
+      ctx.openCost();
+    }
+  },
+  {
+    name: "context",
+    description: "Context hub: window overlay plus compact, recall, init, refresh, and reset",
+    group: "Inspect",
+    kinds: ["context-view", "compact", "context-recall", "init", "context-clear", "context-refresh"],
+    subcommandDescriptions: {
+      compact: "Compact session context",
+      recall: "Recall an evicted result",
+      init: "Initialize project context",
+      refresh: "Refresh project context",
+      reset: "Reset project context"
+    },
+    args: {
+      subcommands: {
+        compact: { positionals: [...COMPACT_POSITIONALS] },
+        recall: { positionals: [...RECALL_POSITIONALS] },
+        init: {},
+        refresh: {},
+        reset: {}
+      }
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "context", reason: parsed.error };
+      switch (parsed.subcommand) {
+        case "compact":
+          return { kind: "compact", instructions: parsed.rest };
+        case "recall":
+          return { kind: "context-recall", ref: parsed.positionals[0] ?? "" };
+        case "init":
+          return { kind: "init", options: {} };
+        case "refresh":
+          return { kind: "context-refresh" };
+        case "reset":
+          return { kind: "context-clear", options: {} };
+        default:
+          return { kind: "context-view" };
+      }
+    },
+    handle(command, ctx) {
+      switch (command.kind) {
+        case "context-view":
+          ctx.openContextView();
+          return;
+        case "compact":
+          ctx.runCompact(command.instructions);
+          return;
+        case "context-recall":
+          if (ctx.runContextRecall) {
+            ctx.runContextRecall(command.ref);
+          } else {
+            ctx.notice("error", "context recall is not wired; no session is bound to this process");
+          }
+          return;
+        case "init":
+          ctx.runInit(command.options);
+          return;
+        case "context-clear":
+          ctx.runContextClear(command.options);
+          return;
+        case "context-refresh":
+          if (ctx.runContextRefresh) {
+            ctx.runContextRefresh();
+          } else {
+            ctx.notice("error", "context refresh is not wired; pass onContextRefresh to startInteractive");
+          }
+          return;
+        default:
+          return;
+      }
+    }
+  },
+  {
+    name: "fleet",
+    description: "Open Fleet Runs or run a fleet contract with an approval preview",
+    group: "Work",
+    kinds: ["fleet", "fleet-run", "fleet-run-usage"],
+    subcommandDescriptions: { run: "Preview and run a repo-owned fleet contract" },
+    args: {
+      subcommands: {
+        run: {
+          flags: [{ name: "--var", takesValue: true, repeatable: true, valueName: "key=value" }],
+          positionals: [{ name: "name", required: true }]
+        }
+      }
+    },
+    fromArgs(parsed) {
+      if (parsed.subcommand !== "run") {
+        return parsed.error ? { kind: "usage-error", command: "fleet", reason: parsed.error } : { kind: "fleet" };
+      }
+      if (parsed.error) return { kind: "fleet-run-usage", reason: parsed.error };
+      const name = parsed.positionals[0] ?? "";
+      if (name.length === 0) return { kind: "fleet-run-usage" };
+      const vars = {};
+      for (const pair of parsed.flagValues.get("--var") ?? []) {
+        const eq = pair.indexOf("=");
+        const key = eq < 0 ? "" : pair.slice(0, eq).trim();
+        if (key.length === 0) return { kind: "fleet-run-usage", reason: "--var requires key=value" };
+        vars[key] = pair.slice(eq + 1);
+      }
+      return { kind: "fleet-run", name, vars };
+    },
+    handle(command, ctx) {
+      if (command.kind === "fleet") {
+        if (ctx.openFleetRuns) ctx.openFleetRuns();
+        else ctx.notice("error", "Fleet Runs is not wired in this session");
+        return;
+      }
+      if (command.kind === "fleet-run-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "fleet");
+        const usage = entry ? usageNotice(entry, "run") : "usage: /fleet run <name> [--var key=value ...]";
+        ctx.notice("info", command.reason ? `${command.reason}
+${usage}` : usage);
+        return;
+      }
+      if (command.kind !== "fleet-run") return;
+      if (!ctx.startFleetRun) {
+        ctx.notice("error", "/fleet run is not wired in this session");
+        return;
+      }
+      ctx.startFleetRun(command.name, command.vars);
+    }
+  },
+  {
+    name: "decisions",
+    description: "Show settled interview decisions and operator revisions",
+    group: "Inspect",
+    kinds: ["decisions"],
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "decisions", reason: parsed.error };
+      return { kind: "decisions" };
+    },
+    handle(_command, ctx) {
+      ctx.openDecisions();
+    }
+  },
+  {
+    name: "tasks",
+    description: "Show the session board or manage project operator tasks",
+    group: "Inspect",
+    kinds: ["tasks", "tasks-add", "tasks-hand", "tasks-done", "tasks-drop"],
+    subcommandDescriptions: {
+      add: "Log a project task without notifying the agent",
+      hand: "Hand an operator task to the agent",
+      done: "Mark an operator task done",
+      drop: "Drop an operator task"
+    },
+    args: {
+      subcommands: {
+        add: {
+          parseFlagsInRest: true,
+          flags: [
+            { name: "--expect", takesValue: true, repeatable: true, valueName: "path" },
+            { name: "--verify", takesValue: true, repeatable: true, valueName: "checkId[:timeoutMs]" }
+          ],
+          positionals: [{ name: "text", required: true, rest: true }]
+        },
+        hand: { positionals: [{ name: "id", required: true }] },
+        done: { positionals: [{ name: "id", required: true }] },
+        drop: { positionals: [{ name: "id", required: true }] }
+      }
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "tasks", reason: parsed.error };
+      switch (parsed.subcommand) {
+        case "add":
+          return parsed.rest ? {
+            kind: "tasks-add",
+            text: parsed.rest,
+            ...parsed.flagValues.has("--expect") ? { expectedOutputs: parsed.flagValues.get("--expect") ?? [] } : {},
+            ...parsed.flagValues.has("--verify") ? { verification: parsed.flagValues.get("--verify") ?? [] } : {}
+          } : { kind: "usage-error", command: "tasks", reason: "add requires task text" };
+        case "hand":
+        case "done":
+        case "drop": {
+          const id = parsed.positionals[0];
+          if (!id || !/^u[1-9]\d*$/.test(id)) {
+            return { kind: "usage-error", command: "tasks", reason: `${parsed.subcommand} requires a uN id` };
+          }
+          if (parsed.subcommand === "hand") return { kind: "tasks-hand", id };
+          if (parsed.subcommand === "done") return { kind: "tasks-done", id };
+          return { kind: "tasks-drop", id };
+        }
+        default:
+          return { kind: "tasks" };
+      }
+    },
+    handle(command, ctx) {
+      if (command.kind === "tasks") {
+        ctx.openTasks();
+        return;
+      }
+      if (!ctx.userTasks) {
+        ctx.notice("error", "operator task inbox is not wired in this session");
+        return;
+      }
+      try {
+        if (command.kind === "tasks-add") {
+          const task = ctx.userTasks.add(
+            command.text,
+            acceptanceFromTaskFlags(process.cwd(), command.expectedOutputs ?? [], command.verification ?? [])
+          );
+          ctx.notice("success", `logged operator task ${task.id}: ${task.title}`);
+          return;
+        }
+        if (command.kind === "tasks-hand") {
+          const task = ctx.userTasks.hand(command.id);
+          ctx.submitChat(formatUserTaskHandoff(task));
+          return;
+        }
+        if (command.kind === "tasks-done") {
+          const task = ctx.userTasks.done(command.id);
+          ctx.notice("success", `marked operator task ${task.id} done`);
+          return;
+        }
+        if (command.kind === "tasks-drop") {
+          const task = ctx.userTasks.drop(command.id);
+          ctx.notice("success", `dropped operator task ${task.id}`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.notice("error", message);
+      }
+    }
+  },
+  {
+    name: "memory",
+    description: "Inspect, promote, or seed task memory",
+    group: "Inspect",
+    kinds: ["memory", "memory-seed"],
+    subcommandDescriptions: { seed: "Seed the task bank from the newest handoff" },
+    args: { subcommands: { seed: {} } },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "memory", reason: parsed.error };
+      return parsed.subcommand === "seed" ? { kind: "memory-seed" } : { kind: "memory" };
+    },
+    handle(command, ctx) {
+      if (command.kind === "memory") {
+        ctx.openMemory();
+        return;
+      }
+      if (command.kind !== "memory-seed") return;
+      const result = ctx.seedTaskMemory?.() ?? { status: "not-found" };
+      switch (result.status) {
+        case "seeded":
+          ctx.notice(
+            "success",
+            `task memory seeded ${result.seeded} entr${result.seeded === 1 ? "y" : "ies"} from ${result.source}${result.skipped > 0 ? `; skipped ${result.skipped} duplicate${result.skipped === 1 ? "" : "s"}` : ""}`
+          );
+          return;
+        case "disabled":
+          ctx.notice("warn", "task memory is disabled; enable memory.intervention before seeding");
+          return;
+        case "not-found":
+          ctx.notice("info", "no structured task-memory snapshot found in the newest handoff");
+      }
+    }
+  },
+  {
+    name: "view",
+    description: "Browse session artifacts and verify receipts",
+    group: "Inspect",
+    kinds: ["view", "view-verify", "view-usage"],
+    args: {
+      positionals: [{ name: "filter", required: false, rest: true }],
+      subcommands: {
+        verify: {
+          positionals: [{ name: "runId", required: true }]
+        }
+      }
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "view-usage" };
+      if (parsed.subcommand === "verify") {
+        const runId = parsed.positionals[0] ?? "";
+        return { kind: "view-verify", runId };
+      }
+      return parsed.rest ? { kind: "view", filter: parsed.rest } : { kind: "view" };
+    },
+    handle(command, ctx) {
+      const entry = BUILTIN_SLASH_COMMANDS.find((e) => e.name === "view");
+      if (!entry) return;
+      if (command.kind === "view") {
+        ctx.openView(command.filter);
+        return;
+      }
+      if (command.kind === "view-usage") {
+        ctx.notice("info", usageNotice(entry, "verify"));
+        return;
+      }
+      if (command.kind !== "view-verify") return;
+      const result = ctx.verifyReceipt(command.runId);
+      const block = formatReceiptVerificationBlock(command.runId, result);
+      if (result.ok) {
+        ctx.notice(result.compromised ? "warn" : "success", block);
+      } else if (result.retired !== void 0) {
+        ctx.notice("warn", block);
+      } else {
+        ctx.notice("error", block);
+      }
+    }
+  },
+  {
+    name: "panes",
+    description: "Inspect the pane layer, watch a live run in a pane, or open a utility pane",
+    group: "Inspect",
+    kinds: ["panes", "panes-show", "panes-open", "panes-zoom", "panes-close", "panes-usage"],
+    args: {
+      subcommands: {
+        show: { positionals: [{ name: "run-or-agent", required: true }] },
+        // A rest positional, so an argv pane keeps its own flags: the parser
+        // would otherwise refuse `--follow` as an unknown flag of `/panes`.
+        open: { positionals: [{ name: "preset-or-argv", required: true, rest: true }] },
+        zoom: { positionals: [{ name: "target", required: false }] },
+        close: { positionals: [{ name: "target", required: false }] }
+      }
+    },
+    subcommandDescriptions: {
+      show: "watch a live run or agent in the watch pane",
+      open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, \`files --once\` for one pick, or a command)`,
+      zoom: "toggle zoom on a Clio-owned pane (default: the watch pane)",
+      close: "close a Clio-owned pane, or all of them"
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "panes-usage", reason: parsed.error };
+      if (parsed.subcommand === "show") {
+        return { kind: "panes-show", target: parsed.positionals[0] ?? "" };
+      }
+      if (parsed.subcommand === "open") {
+        const rest = (parsed.rest ?? "").trim();
+        if (rest.length === 0) return { kind: "panes-usage", reason: "Missing required argument: preset-or-argv" };
+        const argv = rest.split(/\s+/).filter((token) => token.length > 0);
+        const first = argv[0] ?? "";
+        const preset = resolvePanesPresetId(first);
+        if (argv.length === 1 && preset !== null) return { kind: "panes-open", preset };
+        if (argv.length === 2 && preset === "files" && argv[1] === "--once") {
+          return { kind: "panes-open", preset: "files", once: true };
+        }
+        return { kind: "panes-open", argv };
+      }
+      if (parsed.subcommand === "zoom") {
+        return { kind: "panes-zoom", target: parsed.positionals[0] ?? "" };
+      }
+      if (parsed.subcommand === "close") {
+        return { kind: "panes-close", target: parsed.positionals[0] ?? "all" };
+      }
+      if (parsed.positionals.length > 0) {
+        return { kind: "panes-usage", reason: `Unexpected argument: ${parsed.positionals[0]}` };
+      }
+      return { kind: "panes" };
+    },
+    handle(command, ctx) {
+      const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "panes");
+      if (command.kind === "panes-usage") {
+        if (entry) ctx.notice("info", command.reason ? `${command.reason}
+${usageNotice(entry)}` : usageNotice(entry));
+        return;
+      }
+      const panes = ctx.panes;
+      if (!panes) {
+        ctx.notice(
+          "info",
+          "panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto"
+        );
+        return;
+      }
+      const runLocal = ctx.runLocalOperation ?? ((operation) => void operation());
+      if (command.kind === "panes") {
+        runLocal(async () => {
+          for (const line of formatPanesStatus(panes.status())) ctx.io.stdout(`${line}
+`);
+          ctx.render();
+        });
+        return;
+      }
+      if (command.kind === "panes-show") {
+        runLocal(async () => {
+          const result = await panes.show(command.target);
+          if (result.status === "watching") {
+            ctx.notice("success", `watching ${result.agentId} (${result.runId})${result.opened ? " in a new pane" : ""}`);
+          } else if (result.status === "not-found") {
+            const known = result.candidates.length > 0 ? `; live runs: ${result.candidates.join(", ")}` : "";
+            ctx.notice("warn", `no live run matches ${result.target}${known}`);
+          } else {
+            ctx.notice("warn", result.reason);
+          }
+        });
+        return;
+      }
+      if (command.kind === "panes-open") {
+        runLocal(async () => {
+          const result = await panes.open({
+            ...command.preset ? { preset: command.preset } : {},
+            ...command.argv ? { argv: command.argv } : {},
+            ...command.once ? { once: true } : {}
+          });
+          if (result.status === "opened") {
+            if (result.paneId !== null) {
+              ctx.notice(
+                "success",
+                result.existing ? `focused pane ${result.label} (${result.paneId})` : `opened pane ${result.label} (${result.paneId})`
+              );
+            }
+          } else if (result.status === "missing-binary") {
+            ctx.io.stdout(`${result.detail}
+`);
+            ctx.render();
+          } else {
+            ctx.notice("warn", result.reason);
+          }
+        });
+        return;
+      }
+      if (command.kind === "panes-zoom") {
+        runLocal(async () => {
+          const result = await panes.zoom(command.target);
+          if (result.status === "zoomed") {
+            ctx.notice("success", `toggled zoom on ${result.label} (${result.paneId})`);
+          } else if (result.status === "not-found") {
+            ctx.notice("warn", `no Clio-owned pane matches ${result.target}`);
+          } else {
+            ctx.notice("warn", result.reason);
+          }
+        });
+        return;
+      }
+      if (command.kind !== "panes-close") return;
+      runLocal(async () => {
+        const result = await panes.close(command.target);
+        if (result.status === "closed") {
+          const what = result.labels.length > 0 ? `: ${result.labels.join(", ")}` : "";
+          ctx.notice(result.closed > 0 ? "success" : "info", `closed ${result.closed} pane(s)${what}`);
+        } else if (result.status === "not-found") {
+          ctx.notice("warn", `no Clio-owned pane matches ${result.target}`);
+        } else {
+          ctx.notice("warn", result.reason);
+        }
+      });
+    }
+  },
+  {
+    name: "files",
+    description: "Toggle the files pane; picks land in the composer as @ mentions",
+    group: "Inspect",
+    kinds: ["files", "files-usage"],
+    args: { positionals: [{ name: "action", required: false }] },
+    subcommandDescriptions: {
+      open: "open the files pane, or focus it when it is already open",
+      close: "close the files pane",
+      pick: "borrow the files pane for one selection, then close it"
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "files-usage", reason: parsed.error };
+      const action = parsed.positionals[0];
+      if (action === void 0) return { kind: "files", action: "toggle" };
+      if (action === "open" || action === "close" || action === "pick" || action === "toggle") {
+        return { kind: "files", action };
+      }
+      return { kind: "files-usage", reason: `Unexpected argument: ${action}` };
+    },
+    handle(command, ctx) {
+      if (command.kind === "files-usage") {
+        ctx.notice("info", `${command.reason}
+usage: /files [open|close|pick]`);
+        return;
+      }
+      if (command.kind !== "files") return;
+      const panes = ctx.panes;
+      if (!panes) {
+        ctx.notice(
+          "info",
+          "the files pane is inactive: this session started without panes. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto"
+        );
+        return;
+      }
+      const runLocal = ctx.runLocalOperation ?? ((operation) => void operation());
+      runLocal(async () => {
+        const result = await panes.files(command.action);
+        if (result.status === "opened") {
+          if (result.paneId !== null) {
+            ctx.notice(
+              "success",
+              result.existing ? `files pane focused (${result.paneId})` : `files pane opened (${result.paneId})`
+            );
+          }
+        } else if (result.status === "closed") {
+          ctx.notice("info", "files pane closed");
+        } else if (result.status === "missing-binary") {
+          ctx.io.stdout(`${result.detail}
+`);
+          ctx.render();
+        } else {
+          ctx.notice("warn", result.reason);
+        }
+      });
+    }
+  },
+  {
+    name: "thinking",
+    description: "Set the chat thinking level",
+    group: "Configure",
+    kinds: ["thinking-set", "thinking-picker"],
+    args: { positionals: [{ name: "level", required: false }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "thinking", reason: parsed.error };
+      const level = parsed.positionals[0];
+      return level ? { kind: "thinking-set", level } : { kind: "thinking-picker" };
+    },
+    handle(command, ctx) {
+      if (command.kind === "thinking-picker") {
+        if (ctx.openThinkingPicker) ctx.openThinkingPicker();
+        else ctx.notice("error", "thinking picker is not wired in this session");
+        return;
+      }
+      if (command.kind !== "thinking-set") return;
+      const result = ctx.setThinkingLevel?.(command.level) ?? { status: "unavailable" };
+      if (result.status === "applied") {
+        ctx.notice("success", `thinking: ${result.display}`);
+      } else if (result.status === "unsupported") {
+        ctx.notice("error", `thinking level "${result.level}" is not available here; try ${result.supported.join(", ")}`);
+      } else {
+        ctx.notice("error", "thinking level cannot be set right now");
+      }
+      ctx.render();
+    }
+  },
+  {
+    name: "model",
+    description: "Open model selector or set a model",
+    group: "Configure",
+    kinds: ["model", "model-set"],
+    args: {
+      positionals: [{ name: "pattern", required: false, rest: true }]
+    },
+    fromArgs(parsed) {
+      const pattern = parsed.positionals[0];
+      if (pattern) {
+        return { kind: "model-set", pattern };
+      }
+      return { kind: "model" };
+    },
+    handle(command, ctx) {
+      if (command.kind === "model") {
+        ctx.openModel();
+        return;
+      }
+      if (command.kind !== "model-set") return;
+      void (async () => {
+        try {
+          await ctx.providers.probeAllLive();
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          ctx.notice("warn", `model refresh failed; resolving cached catalog: ${msg}`);
+        }
+        const result = resolveModelReference(command.pattern, ctx.providers);
+        if (!result.ref) {
+          ctx.notice("error", result.error ?? `no match for "${command.pattern}"`);
+          ctx.render();
+          return;
+        }
+        if (result.warning) ctx.notice("warn", result.warning);
+        if (ctx.applyModelRef(result.ref) === "applied") {
+          const suffix = result.ref.thinkingLevel ? ` thinking=${result.ref.thinkingLevel}` : "";
+          ctx.notice("success", `active this session: ${result.ref.target}/${result.ref.model}${suffix}`);
+        }
+        ctx.render();
+      })();
+    }
+  },
+  {
+    name: "settings",
+    description: "Open interactive settings",
+    group: "Configure",
+    kinds: ["settings"],
+    args: {
+      positionals: [
+        { name: "area", required: false },
+        { name: "group", required: false }
+      ]
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "settings", reason: parsed.error };
+      const area = parsed.positionals[0];
+      if (area === void 0) return { kind: "settings" };
+      if (!isSettingsAreaId(area)) {
+        return {
+          kind: "usage-error",
+          command: "settings",
+          reason: `Unknown area: ${area} (one of ${SETTINGS_AREA_IDS.join(", ")})`
+        };
+      }
+      return { kind: "settings", area, ...parsed.positionals[1] ? { group: parsed.positionals[1] } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind === "settings") ctx.openSettings(command.area, command.group);
+    }
+  },
+  {
+    name: "resume",
+    description: "Resume a past session",
+    group: "Session",
+    kinds: ["resume"],
+    args: {},
+    fromArgs: fromArgsOrUsage("resume", { kind: "resume" }),
+    handle(_command, ctx) {
+      ctx.openResume();
+    }
+  },
+  {
+    name: "new",
+    description: "Start a fresh session",
+    group: "Session",
+    kinds: ["new"],
+    args: {},
+    fromArgs: fromArgsOrUsage("new", { kind: "new" }),
+    handle(_command, ctx) {
+      ctx.startNewSession();
+    }
+  },
+  {
+    name: "handoff",
+    description: "Hand this session's working state to a fresh session for a stated goal",
+    group: "Session",
+    kinds: ["handoff", "handoff-usage"],
+    args: {
+      positionals: [{ name: "goal", required: true, rest: true }]
+    },
+    fromArgs(parsed) {
+      const goal = parsed.rest?.trim() ?? "";
+      if (parsed.error || goal.length === 0) return { kind: "handoff-usage" };
+      return { kind: "handoff", goal };
+    },
+    handle(command, ctx) {
+      if (command.kind === "handoff-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "handoff");
+        if (entry) ctx.notice("info", usageNotice(entry));
+        return;
+      }
+      if (command.kind !== "handoff") return;
+      ctx.startHandoff(command.goal);
+    }
+  },
+  {
+    name: "tree",
+    description: "Open session tree navigator",
+    group: "Session",
+    kinds: ["tree"],
+    args: {},
+    fromArgs: fromArgsOrUsage("tree", { kind: "tree" }),
+    handle(_command, ctx) {
+      ctx.openTree();
+    }
+  },
+  {
+    name: "fork",
+    description: "Fork from an assistant turn",
+    group: "Session",
+    kinds: ["fork"],
+    args: {},
+    fromArgs: fromArgsOrUsage("fork", { kind: "fork" }),
+    handle(_command, ctx) {
+      ctx.openMessagePicker();
+    }
+  },
+  {
+    name: "export",
+    description: "Export a self-contained HTML transcript by default; a .md path writes Markdown",
+    group: "Session",
+    kinds: ["export"],
+    args: {
+      positionals: [{ name: "path", required: false }]
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "export", reason: parsed.error };
+      return { kind: "export", path: parsed.positionals[0] };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "export") return;
+      ctx.exportTranscript(command.path);
+    }
+  }
+];
+var HANDLER_BY_KIND = /* @__PURE__ */ new Map();
+var COMMAND_NAMES = /* @__PURE__ */ new Set();
+for (const entry of BUILTIN_SLASH_COMMANDS) {
+  if (COMMAND_NAMES.has(entry.name)) {
+    throw new Error(`BUILTIN_SLASH_COMMANDS: command name "${entry.name}" is registered more than once`);
+  }
+  COMMAND_NAMES.add(entry.name);
+  for (const kind of entry.kinds) {
+    if (HANDLER_BY_KIND.has(kind)) {
+      throw new Error(`BUILTIN_SLASH_COMMANDS: kind "${kind}" is owned by multiple entries`);
+    }
+    HANDLER_BY_KIND.set(kind, entry);
+  }
+}
+var COMMAND_SHAPED_TOKEN = /^[A-Za-z][A-Za-z0-9:-]*$/u;
+var COMMAND_ESCAPE = "\\/";
+function formatExtensionReloadNotice(outcome) {
+  if (outcome.status !== "committed") {
+    return ["error", `extensions: reload rejected (${outcome.reason}); generation ${outcome.generation} stays active`];
+  }
+  const delta = outcome.changed ? `changed: +${outcome.added.length} -${outcome.removed.length} ~${outcome.modified.length}` : "unchanged";
+  const issueCount = outcome.hooks.fileIssues + outcome.hooks.issues;
+  const hookParts = [`${outcome.hooks.registered} registered`];
+  if (outcome.hooks.dropped > 0) hookParts.push(`${outcome.hooks.dropped} dropped`);
+  if (issueCount > 0) hookParts.push(`${issueCount} issue${issueCount === 1 ? "" : "s"}`);
+  if (outcome.hooks.overridden > 0) hookParts.push(`${outcome.hooks.overridden} overridden`);
+  const level = outcome.hooks.dropped > 0 || issueCount > 0 ? "warn" : "success";
+  return [level, `extensions: generation ${outcome.generation} committed (${delta}); hooks: ${hookParts.join(", ")}`];
+}
+function reloadExtensionsCommand(ctx) {
+  if (ctx.operatorExtensions) {
+    void ctx.operatorExtensions.reload().then((result) => {
+      if (result.status === "deferred") ctx.notice("info", result.message);
+    });
+    return;
+  }
+  if (!ctx.reloadExtensions) {
+    ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
+    return;
+  }
+  const outcome = ctx.reloadExtensions();
+  const [level, text] = formatExtensionReloadNotice(outcome);
+  ctx.notice(level, text);
+  for (const line of outcome.lines) ctx.notice("warn", line);
+  if (outcome.status === "committed") ctx.openExtensions();
+}
+function parseSlashCommand(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return { kind: "empty" };
+  const retiredLibrary = /^\/(resources|plugins)(?:\s|$)/u.exec(trimmed);
+  if (retiredLibrary) {
+    return {
+      kind: "usage-error",
+      command: retiredLibrary[1] ?? "library",
+      reason: "Use /library to browse and manage recipes; use /extensions for harness extensions"
+    };
+  }
+  if (/^\/output(?:\s|$)/u.test(trimmed)) {
+    return {
+      kind: "usage-error",
+      command: "output",
+      reason: "Use /help for the effective Output cycle keys, or /settings interface to save a default. Use /view for full details"
+    };
+  }
+  if (trimmed.startsWith(COMMAND_ESCAPE)) return { kind: "unknown", text: trimmed.slice(1) };
+  for (const entry of BUILTIN_SLASH_COMMANDS) {
+    const match = entry.match ? entry.match(trimmed) : matchFromSpec(entry, trimmed);
+    if (match) return match;
+  }
+  if (trimmed.startsWith("/")) {
+    const token = trimmed.slice(1).split(/\s+/u)[0] ?? "";
+    if (COMMAND_SHAPED_TOKEN.test(token) || isExtensionCommandToken(token))
+      return { kind: "unknown-command", token, text: trimmed };
+  }
+  return { kind: "unknown", text: trimmed };
+}
+function dispatchSlashCommand(command, ctx) {
+  if (command.kind === "empty") return "rejected";
+  if (command.kind === "unknown") {
+    ctx.submitChat(command.text);
+    return "accepted";
+  }
+  if (command.kind === "unknown-command") {
+    const expansion = ctx.expandPromptTemplate?.(command.text);
+    if (expansion?.expanded === true) {
+      ctx.submitChat(command.text);
+      return "accepted";
+    }
+    if (expansion?.expanded === false && expansion.display) {
+      const { template, text } = expansion.display;
+      const card = {
+        command: template.name,
+        source: promptSourceLabel(template.sourceInfo),
+        text
+      };
+      if (ctx.showReference) ctx.showReference(card);
+      else ctx.io.stdout(`/${card.command} (${card.source})
+${card.text}
+`);
+      ctx.render();
+      return "accepted";
+    }
+    const refusal = expansion?.expanded === false ? expansion.refusal : void 0;
+    if (!refusal && isExtensionCommandToken(command.token) && ctx.operatorExtensions) {
+      const runtime = ctx.operatorExtensions;
+      const promptNames = ctx.listPrompts().items.map((prompt) => prompt.name);
+      const row = runtime.commands(promptNames).find((row2) => row2.invocation === command.token);
+      if (!row?.available) {
+        ctx.notice("error", row?.reason ?? `/${command.token} is not an available extension command`);
+        ctx.render();
+        return "rejected";
+      }
+      const args = command.text.slice(command.token.length + 1).trim();
+      const runLocal = ctx.runLocalOperation ?? ((operation) => void operation());
+      runLocal(async () => {
+        try {
+          const output = await runtime.invoke(
+            command.token,
+            args,
+            ctx.listPrompts().items.map((prompt) => prompt.name)
+          );
+          if (ctx.showExtensionOutput) ctx.showExtensionOutput(command.token, output);
+          else ctx.io.stdout(`${output.text}
+`);
+        } catch (error) {
+          ctx.notice("error", `${command.token}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      });
+      return "accepted";
+    }
+    ctx.notice("error", refusal ? refusal.message : `/${command.token} is not a command. Type /help for the list.`);
+    ctx.render();
+    return "rejected";
+  }
+  if (command.kind === "usage-error") {
+    const entry2 = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === command.command);
+    const usage = entry2 ? ` ${usageNotice(entry2)}` : "";
+    const reason = command.command === "output" && ctx.keyboardActions ? `Use ${ctx.keyboardActions.outputLabel()} to cycle Output style, or /settings interface to save a default` : command.reason;
+    ctx.notice("error", `${reason}.${usage}`);
+    ctx.render();
+    return "rejected";
+  }
+  const entry = HANDLER_BY_KIND.get(command.kind);
+  if (!entry) return "rejected";
+  return entry.handle(command, ctx) === "rejected" ? "rejected" : "accepted";
+}
+var COMMAND_ORDER = [
+  "run",
+  "fleet",
+  "delegate",
+  "council",
+  "oracle",
+  "btw",
+  "share",
+  "skill",
+  "agents",
+  "interop",
+  "tasks",
+  "context",
+  "memory",
+  "view",
+  "panes",
+  "cost",
+  "decisions",
+  "library",
+  "skills",
+  "prompts",
+  "extensions",
+  "help",
+  "model",
+  "thinking",
+  "settings",
+  "new",
+  "resume",
+  "handoff",
+  "fork",
+  "tree",
+  "export",
+  "archive",
+  "quit"
+];
+var COMMAND_ORDER_INDEX = new Map(COMMAND_ORDER.map((name, index) => [name, index]));
+function commandReference() {
+  return BUILTIN_SLASH_COMMANDS.filter((entry) => entry.hidden !== true).slice().sort((a, b) => (COMMAND_ORDER_INDEX.get(a.name) ?? 99) - (COMMAND_ORDER_INDEX.get(b.name) ?? 99)).map((entry) => {
+    const usage = usageLine(entry).replace(/^\nusage:\s*/, "").replace(/\n$/, "");
+    return {
+      name: entry.name,
+      usage,
+      description: entry.description,
+      group: entry.group,
+      ...entry.args ? { args: entry.args } : {},
+      ...entry.subcommandDescriptions ? { subcommandDescriptions: entry.subcommandDescriptions } : {}
+    };
+  });
+}
+
+export {
+  COUNCIL_SYNTHESIS_LABEL,
+  workerAskedByModel,
+  workerTargetLabel,
+  workerReceiptSummary,
+  createWorkerStream,
+  isWorkerShareNote,
+  COMPLETION_SLOT_NAMES,
+  renderArgsSpec,
+  completeArgs,
+  SETTINGS_AREA_IDS,
+  handleRun,
+  SLASH_COMMAND_GROUPS,
+  BUILTIN_SLASH_COMMANDS,
+  formatExtensionReloadNotice,
+  parseSlashCommand,
+  dispatchSlashCommand,
+  commandReference
+};
+//# sourceMappingURL=chunk-EPYATQMG.js.map