@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/chunk-C2LTL2W6.js

@@ -0,0 +1,2447 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESETS,
+  PANES_PRESET_IDS,
+  isPanesPresetId
+} from "./chunk-YJX4SHTD.js";
+import {
+  AdmissionCanceledError,
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent
+} from "./chunk-T56WDKA5.js";
+import {
+  parseSkillCommand
+} from "./chunk-VYMXRQI6.js";
+import {
+  TOOL_PROFILE_NAMES,
+  isToolProfileName
+} from "./chunk-42FMPA75.js";
+import {
+  requestExecutionRole
+} from "./chunk-H7IXIC72.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  parseCouncilReport,
+  parseOracleResult
+} from "./chunk-DYJP44XW.js";
+import {
+  resolveModelReference
+} from "./chunk-DQITNCXG.js";
+import {
+  BusChannels
+} from "./chunk-HLW2MRKE.js";
+import {
+  THINKING_LEVELS
+} from "./chunk-GXNLGKAB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.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 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}]`;
+  }
+  return `- ${decision.key}${label}: ${decision.value}`;
+}
+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/overlays/library-tabs.ts
+init_esm_shims();
+var LIBRARY_TABS = [
+  { id: "skill", label: "Skills" },
+  { id: "agent", label: "Agents" },
+  { id: "prompt", label: "Prompts" },
+  { id: "fleet", label: "Fleets" }
+];
+function isLibraryTab(value) {
+  return LIBRARY_TABS.some((tab) => tab.id === value);
+}
+
+// src/interactive/overlays/settings-sections.ts
+init_esm_shims();
+var SETTINGS_SECTIONS = [
+  { id: "safety", label: "Autonomy & Safety", group: "CORE" },
+  { id: "orchestrator", label: "Orchestrator", group: "CORE" },
+  { id: "fleet", label: "Fleet", group: "ROUTING" },
+  { id: "targets", label: "Targets", group: "ROUTING" },
+  { id: "models", label: "Models", group: "ROUTING" },
+  { id: "budget", label: "Budget", group: "RUNTIME" },
+  { id: "compaction", label: "Compaction", group: "RUNTIME" },
+  { id: "retry", label: "Retry", group: "RUNTIME" },
+  { id: "terminal", label: "Terminal", group: "EXPERIENCE" },
+  { id: "watchdog", label: "Watchdog", group: "EXPERIENCE" },
+  { id: "advanced", label: "Advanced", group: "EXPERIENCE" }
+];
+
+// src/interactive/slash-spec.ts
+init_esm_shims();
+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.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 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 rows = available.filter((flag) => flag.name.startsWith(current)).map((flag) => ({ flag, name: flag.name }));
+  return rows.map(({ flag, name }) => ({
+    token: name,
+    ...flag.takesValue ? { hint: `<${getFlagValuePlaceholder(flag)}>` } : {}
+  }));
+}
+function completeArgs(spec, argumentText) {
+  const trailing = argumentText.match(/\S*$/)?.[0] ?? "";
+  const tokenStart = argumentText.length - trailing.length;
+  const current = trailing;
+  const completed = argumentText.slice(0, tokenStart).split(/\s+/).filter((token) => token.length > 0);
+  const completions = [];
+  let active = spec;
+  let walkTokens = completed;
+  if (spec.subcommands) {
+    const first = completed[0];
+    if (first === void 0) {
+      for (const [name, subSpec] of Object.entries(spec.subcommands)) {
+        if (!name.startsWith(current)) continue;
+        const hint = renderArgsSpec(subSpec);
+        completions.push({ token: name, ...hint.length > 0 ? { hint } : {} });
+      }
+    } 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, tokenStart } : null;
+  }
+  if (walk.awaitingValue) {
+    for (const value of walk.awaitingValue.values ?? []) {
+      if (value.startsWith(current)) completions.push({ token: value });
+    }
+    return completions.length > 0 ? { completions, tokenStart } : null;
+  }
+  const atRest = (active.positionals ?? [])[walk.positionalIndex]?.rest === true;
+  const flagsParseable = !atRest || active.parseFlagsBeforeRest === true;
+  if (flagsParseable && (current.length === 0 || current.startsWith("-"))) {
+    completions.push(...flagCompletions(active, walk, current));
+  }
+  return completions.length > 0 ? { completions, tokenStart } : 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();
+
+// src/interactive/worker-progress.ts
+init_esm_shims();
+var WORKER_LIVE_TAIL_LINES = 40;
+var WORKER_LIVE_TAIL_MAX_BYTES = 4096;
+var WORKER_TOOL_NAME_LIMIT = 8;
+var WORKER_ACTION_TRAIL_LIMIT = 4;
+var WORKER_PROGRESS_WINDOW_MS = 250;
+var WORKER_PROGRESS_WINDOW_BYTES = 16384;
+var TAIL_TRUNCATION_MARKER = "";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function workerTextDelta(event) {
+  if (!isRecord(event)) return "";
+  if (event.type === "message_update") {
+    const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+    if (assistantEvent?.type !== "text_delta") return "";
+    return typeof assistantEvent.delta === "string" ? assistantEvent.delta : "";
+  }
+  if (event.type !== "text_delta") return "";
+  if (typeof event.delta === "string") return event.delta;
+  return typeof event.text === "string" ? event.text : "";
+}
+function isThinkingEvent(event) {
+  if (event.type === "thinking_delta") return true;
+  if (event.type !== "message_update") return false;
+  const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+  return assistantEvent?.type === "thinking_delta";
+}
+function toolEventAction(event) {
+  if (event.type !== "clio_tool_start" && event.type !== "clio_tool_finish") return null;
+  const payload = isRecord(event.payload) ? event.payload : null;
+  const tool = nonEmptyString(payload?.tool);
+  if (tool === void 0) return null;
+  const toolCallId = nonEmptyString(payload?.toolCallId);
+  const raw = isRecord(payload?.action) ? payload.action : void 0;
+  const verb = nonEmptyString(raw?.verb);
+  if (verb === void 0) return { tool, ...toolCallId !== void 0 ? { toolCallId } : {} };
+  const object = nonEmptyString(raw?.object);
+  return {
+    tool,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    descriptor: {
+      verb,
+      ...object !== void 0 ? { object } : {},
+      ...raw?.truncated === true ? { truncated: true } : {}
+    }
+  };
+}
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") lines += 1;
+  }
+  return lines;
+}
+function keepTailBytes(text, maxBytes) {
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.byteLength <= maxBytes) return text;
+  let cut = buffer.byteLength - maxBytes;
+  while (cut < buffer.byteLength) {
+    const byte = buffer[cut];
+    if (byte === void 0 || (byte & 192) !== 128) break;
+    cut += 1;
+  }
+  return buffer.subarray(cut).toString("utf8");
+}
+function boundLiveTail(text) {
+  const lines = text.split("\n");
+  let droppedLines = 0;
+  if (lines.length > WORKER_LIVE_TAIL_LINES) {
+    droppedLines = lines.length - WORKER_LIVE_TAIL_LINES;
+    lines.splice(0, droppedLines);
+  }
+  while (lines.length > 1 && Buffer.byteLength(lines.join("\n"), "utf8") > WORKER_LIVE_TAIL_MAX_BYTES) {
+    lines.shift();
+    droppedLines += 1;
+  }
+  const joined = lines.join("\n");
+  const bytes = Buffer.byteLength(joined, "utf8");
+  if (bytes <= WORKER_LIVE_TAIL_MAX_BYTES) return { text: joined, droppedLines, droppedBytes: 0 };
+  const kept = keepTailBytes(joined, WORKER_LIVE_TAIL_MAX_BYTES);
+  return { text: kept, droppedLines, droppedBytes: bytes - Buffer.byteLength(kept, "utf8") };
+}
+function boundSettledText(text) {
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, TAIL_TRUNCATION_MARKER);
+  if (bounded === text) return { text, dropped: 0 };
+  return { text: bounded, dropped: Math.max(0, lineCount(text) - lineCount(bounded)) };
+}
+var EMPTY_SNAPSHOT = {
+  revision: 0,
+  phase: "starting",
+  tailText: "",
+  droppedLines: 0,
+  droppedBytes: 0,
+  currentAction: null,
+  recentActions: [],
+  toolNames: [],
+  settled: false
+};
+function createWorkerProgressFold() {
+  let revision = 0;
+  let phase = "starting";
+  let tailText = "";
+  let droppedLines = 0;
+  let droppedBytes = 0;
+  let currentAction = null;
+  const recentActions = [];
+  const toolNames = [];
+  let settled = false;
+  let durable = "";
+  let betweenAssistantMessages = false;
+  const pendingActions = [];
+  const pendingActionsById = /* @__PURE__ */ new Map();
+  let windowStartMs = 0;
+  let windowBytes = 0;
+  let cached = EMPTY_SNAPSHOT;
+  const touch = () => {
+    revision += 1;
+    cached = null;
+    return true;
+  };
+  const setPhase = (next) => {
+    if (phase === next) return false;
+    phase = next;
+    return touch();
+  };
+  const admitDelta = (delta, nowMs) => {
+    if (nowMs - windowStartMs >= WORKER_PROGRESS_WINDOW_MS) {
+      windowStartMs = nowMs;
+      windowBytes = 0;
+    }
+    const bytes = Buffer.byteLength(delta, "utf8");
+    if (windowBytes + bytes <= WORKER_PROGRESS_WINDOW_BYTES) {
+      windowBytes += bytes;
+      return delta;
+    }
+    windowBytes = WORKER_PROGRESS_WINDOW_BYTES;
+    droppedBytes += bytes;
+    return "";
+  };
+  const appendTail = (text) => {
+    if (text.length === 0) return false;
+    const bounded = boundLiveTail(tailText + text);
+    tailText = bounded.text;
+    droppedLines += bounded.droppedLines;
+    droppedBytes += bounded.droppedBytes;
+    return touch();
+  };
+  const noteToolName = (tool) => {
+    if (toolNames.includes(tool) || toolNames.length >= WORKER_TOOL_NAME_LIMIT) return false;
+    toolNames.push(tool);
+    return touch();
+  };
+  const removePendingAction = (action) => {
+    const index = pendingActions.lastIndexOf(action);
+    if (index >= 0) pendingActions.splice(index, 1);
+    if (action.toolCallId !== void 0 && pendingActionsById.get(action.toolCallId) === action) {
+      pendingActionsById.delete(action.toolCallId);
+    }
+  };
+  const lastPendingActionForTool = (tool) => {
+    for (let index = pendingActions.length - 1; index >= 0; index -= 1) {
+      const candidate = pendingActions[index];
+      if (candidate?.tool === tool) return candidate;
+    }
+    return void 0;
+  };
+  return {
+    observe(event, nowMs = Date.now()) {
+      if (!isRecord(event) || settled) return false;
+      let changed = false;
+      const delta = workerTextDelta(event);
+      if (delta.length > 0) {
+        const separator = betweenAssistantMessages && tailText.length > 0 && !tailText.endsWith("\n") ? "\n\n" : "";
+        betweenAssistantMessages = false;
+        changed = appendTail(admitDelta(`${separator}${delta}`, nowMs)) || changed;
+        changed = setPhase("writing") || changed;
+      } else if (isThinkingEvent(event)) {
+        changed = setPhase("thinking") || changed;
+      }
+      const durableText = durableAssistantTextFromEvent(event);
+      if (durableText.trim().length > 0) {
+        durable = durableText;
+        if (delta.length === 0 && tailText.trim().length === 0) {
+          changed = appendTail(durableText) || changed;
+        }
+        betweenAssistantMessages = true;
+      }
+      const action = toolEventAction(event);
+      if (action !== null && event.type === "clio_tool_start") {
+        if (action.toolCallId !== void 0) {
+          const duplicate = pendingActionsById.get(action.toolCallId);
+          if (duplicate !== void 0) removePendingAction(duplicate);
+          pendingActionsById.set(action.toolCallId, action);
+        }
+        pendingActions.push(action);
+        currentAction = action;
+        noteToolName(action.tool);
+        touch();
+        setPhase("tool");
+        changed = true;
+      } else if (action !== null && event.type === "clio_tool_finish") {
+        const finished = (action.toolCallId !== void 0 ? pendingActionsById.get(action.toolCallId) : void 0) ?? lastPendingActionForTool(action.tool) ?? action;
+        removePendingAction(finished);
+        currentAction = pendingActions[pendingActions.length - 1] ?? null;
+        recentActions.unshift(finished);
+        if (recentActions.length > WORKER_ACTION_TRAIL_LIMIT) recentActions.length = WORKER_ACTION_TRAIL_LIMIT;
+        noteToolName(finished.tool);
+        touch();
+        setPhase(currentAction === null ? "waiting" : "tool");
+        changed = true;
+      }
+      if (event.type === "agent_start") changed = setPhase("starting") || changed;
+      return changed;
+    },
+    settle(text) {
+      const sealed = nonEmptyString(text) ?? nonEmptyString(durable);
+      if (sealed !== void 0) {
+        const bounded = boundSettledText(sealed);
+        tailText = bounded.text;
+        droppedLines = bounded.dropped;
+      }
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      settled = true;
+      phase = "settled";
+      touch();
+      return true;
+    },
+    restart() {
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      durable = "";
+      betweenAssistantMessages = false;
+      settled = false;
+      phase = "starting";
+      touch();
+    },
+    snapshot() {
+      if (cached !== null) return cached;
+      cached = {
+        revision,
+        phase,
+        tailText,
+        droppedLines,
+        droppedBytes,
+        currentAction: currentAction === null ? null : { ...currentAction },
+        recentActions: recentActions.map((entry) => ({ ...entry })),
+        toolNames: [...toolNames],
+        settled
+      };
+      return cached;
+    },
+    durableText() {
+      return durable;
+    }
+  };
+}
+
+// src/interactive/worker-stream.ts
+function workerAskedByModel(state) {
+  return state.parentToolCallId !== void 0 || state.origin === "agent";
+}
+function nonEmptyString2(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 = nonEmptyString2(payload.agentId);
+    return { kind, ...peerId !== void 0 ? { peerId } : {} };
+  }
+  const targetId = nonEmptyString2(payload.targetId);
+  const wireModelId = nonEmptyString2(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 = nonEmptyString2(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 = nonEmptyString2(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(nonEmptyString2(facts.text));
+      applyProgress(entry, fold);
+    }
+    return { kind: "updated", entry };
+  };
+  return {
+    started(payload) {
+      const runId = nonEmptyString2(payload.runId);
+      const assignmentId = nonEmptyString2(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 = nonEmptyString2(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
+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 = {}) {
+  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",
+      ...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");
+}
+function formatUserTaskHandoff(task) {
+  const note = task.note ? ` ${task.note}.` : "";
+  return `Operator task ${task.id}: ${task.title}.${note} Pick it up with tasks action="pick" id="${task.id}" and work it when appropriate.`;
+}
+var SLASH_COMMAND_GROUPS = ["Run", "Inspect", "Configure", "Sessions"];
+var RUN_THINKING_LEVELS = THINKING_LEVELS;
+function isRunThinkingLevel(value) {
+  return RUN_THINKING_LEVELS.some((level) => level === value);
+}
+function isSettingsSectionId(value) {
+  return SETTINGS_SECTIONS.some((section) => section.id === 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 settingsDeepLink(name, section, description, rowId) {
+  return {
+    name,
+    description,
+    group: "Configure",
+    kinds: [],
+    args: {},
+    fromArgs: fromArgsOrUsage(name, { kind: "settings", section, ...rowId ? { rowId } : {} }),
+    handle: () => void 0
+  };
+}
+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} 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.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: "quit",
+    description: "Exit Clio Coder",
+    group: "Sessions",
+    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: "Open the Skills Hub or invoke a skill",
+    group: "Run",
+    kinds: ["skill-selector", "skill-invocation"],
+    args: {
+      positionals: [
+        { name: "name", required: false },
+        { name: "task", required: false, rest: true }
+      ]
+    },
+    match(trimmed) {
+      if (trimmed === "/skill") {
+        return { kind: "skill-selector" };
+      }
+      const command = parseSkillCommand(trimmed);
+      if (command) {
+        return { kind: "skill-invocation", text: trimmed };
+      }
+      return null;
+    },
+    handle(command, ctx) {
+      if (command.kind === "skill-selector") {
+        ctx.openSkillsHub?.();
+      } else if (command.kind === "skill-invocation") {
+        ctx.submitChat(command.text);
+      }
+    }
+  },
+  {
+    name: "library",
+    description: "Open the Skills Hub on a resource library tab",
+    group: "Run",
+    kinds: ["library"],
+    args: { positionals: [{ name: "kind", required: false }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "library", reason: parsed.error };
+      const tab = parsed.positionals[0];
+      if (tab === void 0) return { kind: "library" };
+      if (!isLibraryTab(tab)) {
+        const known = LIBRARY_TABS.map((entry) => entry.id).join(", ");
+        return { kind: "usage-error", command: "library", reason: `Unknown kind: ${tab} (one of ${known})` };
+      }
+      return { kind: "library", tab };
+    },
+    handle(command, ctx) {
+      if (command.kind === "library") ctx.openSkillsHub?.(command.tab);
+    }
+  },
+  {
+    name: "prompts",
+    description: "List prompt templates",
+    group: "Inspect",
+    kinds: ["prompts"],
+    args: {},
+    fromArgs: fromArgsOrUsage("prompts", { kind: "prompts" }),
+    handle(_command, ctx) {
+      ctx.openPrompts();
+    }
+  },
+  {
+    name: "extensions",
+    description: "List installed extensions",
+    group: "Inspect",
+    kinds: ["extensions"],
+    args: {},
+    fromArgs: fromArgsOrUsage("extensions", { kind: "extensions" }),
+    handle(_command, ctx) {
+      ctx.openExtensions?.();
+    }
+  },
+  {
+    name: "interop",
+    description: "Review other coding agents detected on this machine",
+    group: "Inspect",
+    kinds: ["interop"],
+    args: {},
+    fromArgs: fromArgsOrUsage("interop", { kind: "interop" }),
+    handle(_command, ctx) {
+      ctx.openInterop?.();
+    }
+  },
+  {
+    name: "share",
+    description: "Share a worker result with the main agent, or export and import Clio archives",
+    group: "Sessions",
+    kinds: ["share"],
+    args: {
+      positionals: [{ name: "runId", required: false }],
+      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: "share",
+          action: "usage",
+          ...subcommand !== void 0 ? { subcommand } : {},
+          error: parsed.error
+        };
+      }
+      const path = parsed.positionals[0];
+      if (subcommand === "export" && path !== void 0) return { kind: "share", action: "export", path };
+      if (subcommand === "import" && path !== void 0) {
+        return {
+          kind: "share",
+          action: "import",
+          path,
+          dryRun: parsed.flags.has("--dry-run"),
+          force: parsed.flags.has("--force")
+        };
+      }
+      if (subcommand === void 0) {
+        return { kind: "share", action: "worker-run", ...path !== void 0 ? { runId: path } : {} };
+      }
+      return { kind: "share", action: "usage", ...subcommand !== void 0 ? { subcommand } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "share") return;
+      if (command.action === "worker-run") {
+        shareWorkerRun(command.runId, ctx);
+        return;
+      }
+      if (command.action === "usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "share");
+        if (!entry) return;
+        const usage = usageNotice(entry, command.subcommand);
+        ctx.notice("info", command.error ? `${command.error}
+${usage}` : usage);
+        return;
+      }
+      if (command.action === "export") {
+        if (!ctx.exportShareArchive) {
+          ctx.notice("error", "share 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.action === "import") {
+        if (!ctx.importShareArchive) {
+          ctx.notice("error", "share 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: "Run",
+    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.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: "Run",
+    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: "Run",
+    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: "Run",
+    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: "Run",
+    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: "agents",
+    description: "List Clio agents and ACP delegation agents",
+    group: "Inspect",
+    kinds: ["agents"],
+    args: {},
+    fromArgs: fromArgsOrUsage("agents", { kind: "agents" }),
+    handle(_command, ctx) {
+      ctx.openAgents();
+    }
+  },
+  settingsDeepLink("targets", "targets", "Open Settings \u2192 Targets: health, use, connect, probe, remove"),
+  {
+    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 Settings \u2192 Fleet, or run a fleet contract with an approval preview",
+    group: "Configure",
+    kinds: ["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 }]
+        }
+      }
+    },
+    /**
+     * `/fleet` alone keeps the settings deep link it has always been, and
+     * only `run` parses as a command of its own, so an operator who types
+     * `/fleet` out of habit still lands in Settings → Fleet. Anything else
+     * on the line stays the usage error every other deep link reports.
+     */
+    fromArgs(parsed) {
+      if (parsed.subcommand !== "run") {
+        return parsed.error ? { kind: "usage-error", command: "fleet", reason: parsed.error } : { kind: "settings", section: "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-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: { 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 } : { 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);
+          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-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 }] },
+        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(", ")}, or a command)`,
+      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] ?? "";
+        if (argv.length === 1 && isPanesPresetId(first)) return { kind: "panes-open", preset: first };
+        if (argv.length === 2 && first === "yazi" && argv[1] === "--once") {
+          return { kind: "panes-open", preset: "yazi", once: true };
+        }
+        return { kind: "panes-open", argv };
+      }
+      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 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", `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-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: "thinking",
+    description: "Set the chat thinking level, or open Settings \u2192 Orchestrator",
+    group: "Configure",
+    kinds: ["thinking-set"],
+    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: "settings", section: "orchestrator", rowId: "orchestrator.thinkingLevel" };
+    },
+    handle(command, ctx) {
+      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: "output",
+    description: "Set transcript detail (minimal, default, verbose), or open Settings \u2192 Terminal",
+    group: "Configure",
+    kinds: ["output-set"],
+    args: { positionals: [{ name: "verbosity", required: false }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "output", reason: parsed.error };
+      const verbosity = parsed.positionals[0];
+      return verbosity ? { kind: "output-set", verbosity } : { kind: "settings", section: "terminal", rowId: "terminal.outputVerbosity" };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "output-set") return;
+      const result = ctx.setOutputVerbosity?.(command.verbosity) ?? { status: "unavailable" };
+      if (result.status === "applied") {
+        ctx.notice("success", `output detail: ${result.verbosity}`);
+      } else if (result.status === "unsupported") {
+        ctx.notice("error", `output detail "${result.verbosity}" is not one of ${result.supported.join(", ")}`);
+      } else {
+        ctx.notice("error", "output detail 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();
+      })();
+    }
+  },
+  settingsDeepLink(
+    "scoped-models",
+    "models",
+    "Open Settings \u2192 Models: the Alt+J / Alt+K cycle set and favorites",
+    "scope"
+  ),
+  {
+    name: "settings",
+    description: "Open interactive settings",
+    group: "Configure",
+    kinds: ["settings"],
+    args: { positionals: [{ name: "section", required: false }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "settings", reason: parsed.error };
+      const section = parsed.positionals[0];
+      if (section === void 0) return { kind: "settings" };
+      if (!isSettingsSectionId(section)) {
+        const known = SETTINGS_SECTIONS.map((entry) => entry.id).join(", ");
+        return { kind: "usage-error", command: "settings", reason: `Unknown section: ${section} (one of ${known})` };
+      }
+      return { kind: "settings", section };
+    },
+    handle(command, ctx) {
+      if (command.kind === "settings") ctx.openSettings(command.section, command.rowId);
+    }
+  },
+  {
+    name: "resume",
+    description: "Resume a past session",
+    group: "Sessions",
+    kinds: ["resume"],
+    args: {},
+    fromArgs: fromArgsOrUsage("resume", { kind: "resume" }),
+    handle(_command, ctx) {
+      ctx.openResume();
+    }
+  },
+  {
+    name: "new",
+    description: "Start a fresh session",
+    group: "Sessions",
+    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: "Sessions",
+    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: "Sessions",
+    kinds: ["tree"],
+    args: {},
+    fromArgs: fromArgsOrUsage("tree", { kind: "tree" }),
+    handle(_command, ctx) {
+      ctx.openTree();
+    }
+  },
+  {
+    name: "fork",
+    description: "Fork from an assistant turn",
+    group: "Sessions",
+    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: "Sessions",
+    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 parseSlashCommand(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return { kind: "empty" };
+  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)) 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";
+    }
+    const refusal = expansion?.expanded === false ? expansion.refusal : void 0;
+    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)}` : "";
+    ctx.notice("error", `${command.reason}.${usage}`);
+    ctx.render();
+    return "rejected";
+  }
+  const entry = HANDLER_BY_KIND.get(command.kind);
+  if (!entry) return "rejected";
+  entry.handle(command, ctx);
+  return "accepted";
+}
+function commandReference() {
+  return BUILTIN_SLASH_COMMANDS.filter((entry) => entry.hidden !== true).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,
+  boundSettledText,
+  createWorkerProgressFold,
+  workerAskedByModel,
+  workerTargetLabel,
+  workerReceiptSummary,
+  createWorkerStream,
+  isWorkerShareNote,
+  LIBRARY_TABS,
+  SETTINGS_SECTIONS,
+  renderArgsSpec,
+  completeArgs,
+  handleRun,
+  formatReceiptVerificationBlock,
+  formatUserTaskHandoff,
+  SLASH_COMMAND_GROUPS,
+  formatPanesStatus,
+  BUILTIN_SLASH_COMMANDS,
+  parseSlashCommand,
+  dispatchSlashCommand,
+  commandReference
+};
+//# sourceMappingURL=chunk-C2LTL2W6.js.map