@iowarp/clio-coder 0.4.0 → 0.4.1

package/dist/{chunk-C2LTL2W6.js → chunk-J4HBWF6Y.js}

@@ -3,7 +3,7 @@ import {
   PANES_PRESETS,
   PANES_PRESET_IDS,
   isPanesPresetId
-} from "./chunk-YJX4SHTD.js";
+} from "./chunk-GIZNH63R.js";
 import {
   AdmissionCanceledError,
   WORKER_OUTPUT_MAX_BYTES,
@@ -11,7 +11,7 @@ import {
 } from "./chunk-T56WDKA5.js";
 import {
   parseSkillCommand
-} from "./chunk-VYMXRQI6.js";
+} from "./chunk-HUAS7ITX.js";
 import {
   TOOL_PROFILE_NAMES,
   isToolProfileName
@@ -25,16 +25,16 @@ import {
 import {
   parseCouncilReport,
   parseOracleResult
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-IG7BCQBA.js";
 import {
   resolveModelReference
-} from "./chunk-DQITNCXG.js";
+} from "./chunk-UEDMSP56.js";
 import {
   BusChannels
 } from "./chunk-HLW2MRKE.js";
 import {
   THINKING_LEVELS
-} from "./chunk-GXNLGKAB.js";
+} from "./chunk-BWW4HLO4.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -178,24 +178,35 @@ 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();
+var COMPLETION_SLOT_NAMES = [
+  "agents",
+  "agent-profiles",
+  "worker-runtimes",
+  "targets",
+  "models",
+  "capabilities",
+  "external-agents",
+  "rosters",
+  "shareable-runs",
+  "skills",
+  "fleet-contracts",
+  "fleet-vars",
+  "fleet-var-values",
+  "tasks",
+  "context-refs",
+  "receipts",
+  "pane-runs-agents",
+  "pane-presets",
+  "pane-targets",
+  "library-tabs",
+  "thinking-levels",
+  "settings-areas",
+  "settings-groups",
+  "help-queries",
+  "paths"
+];
 function getFlagValuePlaceholder(flag) {
   if (flag.valueName) return flag.valueName;
   if (flag.values && flag.values.length > 0) {
@@ -426,6 +437,54 @@ function parseArgs(spec, argsLine) {
     ...rest !== void 0 ? { rest } : {}
   };
 }
+function completionTokens(text) {
+  const tokens = [];
+  let index = 0;
+  while (index < text.length) {
+    while (index < text.length && /\s/.test(text[index] ?? "")) index++;
+    if (index >= text.length) break;
+    const start = index;
+    let quote;
+    if (text[index] === '"' || text[index] === "'") {
+      quote = text[index];
+      index++;
+    }
+    const contentStart = index;
+    let value = "";
+    while (index < text.length) {
+      const char = text[index] ?? "";
+      if (quote) {
+        if (char === quote) break;
+      } else if (/\s/.test(char)) {
+        break;
+      } else if (char === '"' || char === "'") {
+        const embedded = char;
+        index++;
+        while (index < text.length && text[index] !== embedded) value += text[index++] ?? "";
+        if (text[index] === embedded) index++;
+        continue;
+      }
+      value += char;
+      index++;
+    }
+    const contentEnd = index;
+    if (quote && text[index] === quote) index++;
+    tokens.push({ value, start, end: index, contentStart, contentEnd, ...quote ? { quote } : {} });
+  }
+  return tokens;
+}
+function tokenAtCursor(text, cursor) {
+  const safeCursor = Math.max(0, Math.min(cursor, text.length));
+  const tokens = completionTokens(text);
+  const containing = tokens.find((token) => safeCursor >= token.start && safeCursor <= token.end);
+  if (containing) {
+    return { current: containing, completed: tokens.filter((token) => token.end <= containing.start) };
+  }
+  return {
+    current: { value: "", start: safeCursor, end: safeCursor, contentStart: safeCursor, contentEnd: safeCursor },
+    completed: tokens.filter((token) => token.end <= safeCursor)
+  };
+}
 function walkCompletedTokens(spec, tokens) {
   const flagSpecs = spec.flags ?? [];
   const positionalSpecs = spec.positionals ?? [];
@@ -453,28 +512,40 @@ function walkCompletedTokens(spec, tokens) {
 }
 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 }));
+  const lower = current.toLowerCase();
+  const rows = available.filter((flag) => flag.name.toLowerCase().startsWith(lower)).map((flag) => ({ flag, name: flag.name }));
   return rows.map(({ flag, name }) => ({
     token: name,
-    ...flag.takesValue ? { hint: `<${getFlagValuePlaceholder(flag)}>` } : {}
+    ...flag.takesValue ? { hint: `<${getFlagValuePlaceholder(flag)}>` } : {},
+    hasNextSlot: flag.takesValue === true
   }));
 }
-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);
+function completeArgs(spec, argumentText, cursor = argumentText.length) {
+  const { current: currentToken, completed: completedTokens } = tokenAtCursor(argumentText, cursor);
+  const current = currentToken.value.slice(0, Math.max(0, cursor - currentToken.contentStart));
+  const completed = completedTokens.map((token) => token.value);
+  const range = {
+    tokenStart: currentToken.contentStart,
+    tokenEnd: currentToken.contentEnd,
+    ...currentToken.quote ? { quote: currentToken.quote } : {}
+  };
   const completions = [];
   let active = spec;
   let walkTokens = completed;
+  let submenu;
   if (spec.subcommands) {
     const first = completed[0];
     if (first === void 0) {
       for (const [name, subSpec] of Object.entries(spec.subcommands)) {
-        if (!name.startsWith(current)) continue;
+        if (!name.toLowerCase().startsWith(current.toLowerCase())) continue;
         const hint = renderArgsSpec(subSpec);
-        completions.push({ token: name, ...hint.length > 0 ? { hint } : {} });
+        completions.push({
+          token: name,
+          ...hint.length > 0 ? { hint } : {},
+          hasNextSlot: hint.length > 0
+        });
       }
+      submenu = { parent: "", canGoBack: true };
     } else if (spec.subcommands[first]) {
       active = spec.subcommands[first];
       walkTokens = completed.slice(1);
@@ -482,20 +553,36 @@ function completeArgs(spec, argumentText) {
   }
   const walk = walkCompletedTokens(active, walkTokens);
   if (walk.restBegun) {
-    return completions.length > 0 ? { completions, tokenStart } : null;
+    return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
   }
   if (walk.awaitingValue) {
     for (const value of walk.awaitingValue.values ?? []) {
-      if (value.startsWith(current)) completions.push({ token: value });
+      if (value.toLowerCase().startsWith(current.toLowerCase())) completions.push({ token: value, hasNextSlot: true });
+    }
+    if (walk.awaitingValue.completionSlot) {
+      completions.push({ token: current, completionSlot: walk.awaitingValue.completionSlot, hasNextSlot: true });
     }
-    return completions.length > 0 ? { completions, tokenStart } : null;
+    return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
   }
   const atRest = (active.positionals ?? [])[walk.positionalIndex]?.rest === true;
+  const positional = (active.positionals ?? [])[walk.positionalIndex];
+  for (const value of positional?.values ?? []) {
+    if (value.toLowerCase().startsWith(current.toLowerCase())) {
+      completions.push({ token: value, hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0) });
+    }
+  }
+  if (positional?.completionSlot && !current.startsWith("-")) {
+    completions.push({
+      token: current,
+      completionSlot: positional.completionSlot,
+      hasNextSlot: walk.positionalIndex + 1 < (active.positionals?.length ?? 0)
+    });
+  }
   const flagsParseable = !atRest || active.parseFlagsBeforeRest === true;
   if (flagsParseable && (current.length === 0 || current.startsWith("-"))) {
     completions.push(...flagCompletions(active, walk, current));
   }
-  return completions.length > 0 ? { completions, tokenStart } : null;
+  return completions.length > 0 ? { completions, ...range, ...submenu ? { submenu } : {} } : null;
 }
 function matchFromSpec(entry, trimmed) {
   const matchedPrefix = `/${entry.name}`;
@@ -547,7 +634,7 @@ function isThinkingEvent(event) {
   return assistantEvent?.type === "thinking_delta";
 }
 function toolEventAction(event) {
-  if (event.type !== "clio_tool_start" && event.type !== "clio_tool_finish") return null;
+  if (event.type !== "clio_coder_tool_start" && event.type !== "clio_coder_tool_finish") return null;
   const payload = isRecord(event.payload) ? event.payload : null;
   const tool = nonEmptyString(payload?.tool);
   if (tool === void 0) return null;
@@ -708,7 +795,7 @@ function createWorkerProgressFold() {
         betweenAssistantMessages = true;
       }
       const action = toolEventAction(event);
-      if (action !== null && event.type === "clio_tool_start") {
+      if (action !== null && event.type === "clio_coder_tool_start") {
         if (action.toolCallId !== void 0) {
           const duplicate = pendingActionsById.get(action.toolCallId);
           if (duplicate !== void 0) removePendingAction(duplicate);
@@ -720,7 +807,7 @@ function createWorkerProgressFold() {
         touch();
         setPhase("tool");
         changed = true;
-      } else if (action !== null && event.type === "clio_tool_finish") {
+      } else if (action !== null && event.type === "clio_coder_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;
@@ -1032,6 +1119,15 @@ function selectWorkerRunToShare(entries, id) {
 }
 
 // src/interactive/slash-commands.ts
+var SETTINGS_AREA_IDS = [
+  "chat",
+  "fleet",
+  "targets",
+  "context",
+  "safety",
+  "interface",
+  "integrations"
+];
 function shareReceipt(agentId, receipt, deps) {
   if (!deps.submitOperatorNote) {
     deps.notice("error", "--share is not wired in this session; the result stayed local");
@@ -1247,13 +1343,13 @@ 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 SLASH_COMMAND_GROUPS = ["Work", "Inspect", "Configure", "Session"];
 var RUN_THINKING_LEVELS = THINKING_LEVELS;
 function isRunThinkingLevel(value) {
   return RUN_THINKING_LEVELS.some((level) => level === value);
 }
-function isSettingsSectionId(value) {
-  return SETTINGS_SECTIONS.some((section) => section.id === value);
+function isSettingsAreaId(value) {
+  return SETTINGS_AREA_IDS.some((area) => area === value);
 }
 var COMPACT_POSITIONALS = [
   { name: "instructions", required: false, rest: true }
@@ -1262,17 +1358,6 @@ 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();
 }
@@ -1282,10 +1367,15 @@ function formatPanesStatus(status) {
     `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}`,
+    `  settings: enabled=${status.settings.enabled} notifications=${status.settings.notifications} layout=${status.settings.layout} journal=${status.settings.journal}`,
     `  files: enabled=${status.settings.yazi.enabled} mode=${status.settings.yazi.mode} profile=${status.settings.yazi.profile} followCwd=${status.settings.yazi.followCwd}`,
     `  file pane: mode=${status.yazi.mode} pane=${status.yazi.paneId ?? "none"} cwd=${status.yazi.paneCwd ?? "unknown"} lastLine=${status.yazi.lastLineAt === null ? "never" : new Date(status.yazi.lastLineAt).toISOString()} dropped=${status.yazi.droppedLines}`
   ];
+  if (status.docks.length > 0) {
+    lines.push(
+      `  docks: ${status.docks.map((dock) => `${dock.slot}=${dock.paneId} @${(dock.targetShare * 100).toFixed(0)}%`).join(", ")}`
+    );
+  }
   if (status.panes.length === 0) {
     lines.push("  no Clio-owned panes");
   } else {
@@ -1303,7 +1393,7 @@ var BUILTIN_SLASH_COMMANDS = [
   {
     name: "quit",
     description: "Exit Clio Coder",
-    group: "Sessions",
+    group: "Session",
     kinds: ["quit"],
     args: {},
     fromArgs: fromArgsOrUsage("quit", { kind: "quit" }),
@@ -1329,7 +1419,7 @@ var BUILTIN_SLASH_COMMANDS = [
   {
     name: "skill",
     description: "Open the Skills Hub or invoke a skill",
-    group: "Run",
+    group: "Work",
     kinds: ["skill-selector", "skill-invocation"],
     args: {
       positionals: [
@@ -1356,65 +1446,74 @@ var BUILTIN_SLASH_COMMANDS = [
     }
   },
   {
-    name: "library",
-    description: "Open the Skills Hub on a resource library tab",
-    group: "Run",
-    kinds: ["library"],
-    args: { positionals: [{ name: "kind", required: false }] },
+    name: "resources",
+    description: "Browse skills, prompts, libraries, and extensions",
+    group: "Inspect",
+    kinds: ["resources"],
+    subcommandDescriptions: {
+      skills: "Browse installed skills",
+      prompts: "Browse prompt templates",
+      library: "Browse resource libraries",
+      extensions: "Browse installed extensions"
+    },
+    args: {
+      subcommands: {
+        skills: {},
+        prompts: {},
+        library: { positionals: [{ name: "kind", required: false }] },
+        extensions: {}
+      }
+    },
     fromArgs(parsed) {
-      if (parsed.error) return { kind: "usage-error", command: "library", reason: parsed.error };
+      if (parsed.error) return { kind: "usage-error", command: "resources", reason: parsed.error };
+      if (parsed.subcommand === void 0 || parsed.subcommand === "skills")
+        return { kind: "resources", family: "skills" };
+      if (parsed.subcommand === "prompts" || parsed.subcommand === "extensions")
+        return { kind: "resources", family: parsed.subcommand };
       const tab = parsed.positionals[0];
-      if (tab === void 0) return { kind: "library" };
+      if (tab === void 0) return { kind: "resources" };
       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: "usage-error", command: "resources", reason: `Unknown kind: ${tab} (one of ${known})` };
       }
-      return { kind: "library", tab };
+      return { kind: "resources", 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?.();
+      if (command.kind !== "resources") return;
+      if (command.family === "prompts") ctx.openPrompts();
+      else if (command.family === "extensions") ctx.openExtensions();
+      else ctx.openSkillsHub?.(command.tab);
     }
   },
   {
-    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",
+    group: "Work",
+    kinds: ["share"],
+    args: { positionals: [{ name: "run-id", required: false }] },
+    fromArgs(parsed) {
+      const retiredArchiveVerb = parsed.positionals[0];
+      if (retiredArchiveVerb === "export" || retiredArchiveVerb === "import") {
+        return {
+          kind: "usage-error",
+          command: "share",
+          reason: `/share ${retiredArchiveVerb} is retired and did not run; use /archive ${retiredArchiveVerb}`
+        };
+      }
+      if (parsed.error) return { kind: "usage-error", command: "share", reason: parsed.error };
+      return { kind: "share", ...parsed.positionals[0] ? { runId: parsed.positionals[0] } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind === "share") shareWorkerRun(command.runId, ctx);
     }
   },
   {
-    name: "share",
-    description: "Share a worker result with the main agent, or export and import Clio archives",
-    group: "Sessions",
-    kinds: ["share"],
+    name: "archive",
+    description: "Export or import a full Clio archive",
+    group: "Session",
+    kinds: ["archive-export", "archive-import", "archive-usage"],
+    subcommandDescriptions: { export: "Export a full Clio archive", import: "Import a full Clio archive" },
     args: {
-      positionals: [{ name: "runId", required: false }],
       subcommands: {
         export: {
           positionals: [{ name: "path", required: true }]
@@ -1429,54 +1528,44 @@ var BUILTIN_SLASH_COMMANDS = [
       const subcommand = parsed.subcommand === "export" || parsed.subcommand === "import" ? parsed.subcommand : void 0;
       if (parsed.error) {
         return {
-          kind: "share",
-          action: "usage",
+          kind: "archive-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 === "export" && path !== void 0) return { kind: "archive-export", path };
       if (subcommand === "import" && path !== void 0) {
         return {
-          kind: "share",
-          action: "import",
+          kind: "archive-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 } : {} };
+      return { kind: "archive-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 (command.kind === "archive-usage") {
+        const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "archive");
         if (!entry) return;
         const usage = usageNotice(entry, command.subcommand);
         ctx.notice("info", command.error ? `${command.error}
 ${usage}` : usage);
         return;
       }
-      if (command.action === "export") {
+      if (command.kind === "archive-export") {
         if (!ctx.exportShareArchive) {
-          ctx.notice("error", "share export is not wired");
+          ctx.notice("error", "archive export is not wired");
           return;
         }
         const result = ctx.exportShareArchive(command.path);
         ctx.notice("success", `exported ${result.fileCount} item(s) to ${result.path}`);
         return;
       }
-      if (command.action === "import") {
+      if (command.kind === "archive-import") {
         if (!ctx.importShareArchive) {
-          ctx.notice("error", "share import is not wired");
+          ctx.notice("error", "archive import is not wired");
           return;
         }
         const plan = ctx.importShareArchive(command.path, { dryRun: command.dryRun, force: command.force });
@@ -1497,7 +1586,7 @@ ${usage}` : usage);
   {
     name: "run",
     description: "Run a fleet agent",
-    group: "Run",
+    group: "Work",
     kinds: ["run", "run-usage"],
     args: {
       parseFlagsBeforeRest: true,
@@ -1578,7 +1667,7 @@ ${usage}` : usage);
   {
     name: "delegate",
     description: "Run an ACP delegation agent",
-    group: "Run",
+    group: "Work",
     kinds: ["delegate", "delegate-usage"],
     args: {
       parseFlagsBeforeRest: true,
@@ -1625,7 +1714,7 @@ ${usage}` : usage);
   {
     name: "btw",
     description: "Ask a side question that never enters the session transcript",
-    group: "Run",
+    group: "Work",
     kinds: ["btw", "btw-usage"],
     args: {
       positionals: [{ name: "question", required: true, rest: true }]
@@ -1648,7 +1737,7 @@ ${usage}` : usage);
   {
     name: "oracle",
     description: "Ask a read-only advisor to challenge a question against this session's settled decisions",
-    group: "Run",
+    group: "Work",
     kinds: ["oracle", "oracle-usage"],
     args: {
       positionals: [{ name: "question", required: true, rest: true }]
@@ -1674,7 +1763,7 @@ ${usage}` : usage);
   {
     name: "council",
     description: "Ask a roster of read-only members the same task, with an optional vote or judge synthesis",
-    group: "Run",
+    group: "Work",
     kinds: ["council", "council-usage"],
     args: {
       parseFlagsBeforeRest: true,
@@ -1724,16 +1813,24 @@ ${usage}` : usage);
   },
   {
     name: "agents",
-    description: "List Clio agents and ACP delegation agents",
+    description: "List agents or connect a detected external agent",
     group: "Inspect",
     kinds: ["agents"],
-    args: {},
-    fromArgs: fromArgsOrUsage("agents", { kind: "agents" }),
-    handle(_command, ctx) {
-      ctx.openAgents();
+    subcommandDescriptions: {
+      list: "List native and external agents",
+      connect: "Review detected external-agent proposals"
+    },
+    args: { subcommands: { list: {}, connect: {} } },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "agents", reason: parsed.error };
+      return { kind: "agents", ...parsed.subcommand === "connect" ? { connect: true } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "agents") return;
+      if (command.connect) ctx.openInterop?.();
+      else ctx.openAgents();
     }
   },
-  settingsDeepLink("targets", "targets", "Open Settings \u2192 Targets: health, use, connect, probe, remove"),
   {
     name: "cost",
     description: "Show session token and cost totals",
@@ -1818,9 +1915,9 @@ ${usage}` : usage);
   },
   {
     name: "fleet",
-    description: "Open Settings \u2192 Fleet, or run a fleet contract with an approval preview",
-    group: "Configure",
-    kinds: ["fleet-run", "fleet-run-usage"],
+    description: "Open Fleet Runs or run a fleet contract with an approval preview",
+    group: "Work",
+    kinds: ["fleet", "fleet-run", "fleet-run-usage"],
     subcommandDescriptions: { run: "Preview and run a repo-owned fleet contract" },
     args: {
       subcommands: {
@@ -1830,15 +1927,9 @@ ${usage}` : usage);
         }
       }
     },
-    /**
-     * `/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" };
+        return parsed.error ? { kind: "usage-error", command: "fleet", reason: parsed.error } : { kind: "fleet" };
       }
       if (parsed.error) return { kind: "fleet-run-usage", reason: parsed.error };
       const name = parsed.positionals[0] ?? "";
@@ -1853,6 +1944,11 @@ ${usage}` : usage);
       return { kind: "fleet-run", name, vars };
     },
     handle(command, ctx) {
+      if (command.kind === "fleet") {
+        if (ctx.openFleetRuns) ctx.openFleetRuns();
+        else ctx.notice("error", "Fleet Runs is not wired in this session");
+        return;
+      }
       if (command.kind === "fleet-run-usage") {
         const entry = BUILTIN_SLASH_COMMANDS.find((candidate) => candidate.name === "fleet");
         const usage = entry ? usageNotice(entry, "run") : "usage: /fleet run <name> [--var key=value ...]";
@@ -2036,19 +2132,21 @@ ${usage}` : usage);
     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"],
+    kinds: ["panes", "panes-show", "panes-open", "panes-zoom", "panes-close", "panes-usage"],
     args: {
       subcommands: {
         show: { positionals: [{ name: "run-or-agent", required: true }] },
         // A rest positional, so an argv pane keeps its own flags: the parser
         // would otherwise refuse `--follow` as an unknown flag of `/panes`.
         open: { positionals: [{ name: "preset-or-argv", required: true, rest: true }] },
+        zoom: { positionals: [{ name: "target", required: false }] },
         close: { positionals: [{ name: "target", required: false }] }
       }
     },
     subcommandDescriptions: {
       show: "watch a live run or agent in the watch pane",
       open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, or a command)`,
+      zoom: "toggle zoom on a Clio-owned pane (default: the watch pane)",
       close: "close a Clio-owned pane, or all of them"
     },
     fromArgs(parsed) {
@@ -2067,6 +2165,9 @@ ${usage}` : usage);
         }
         return { kind: "panes-open", argv };
       }
+      if (parsed.subcommand === "zoom") {
+        return { kind: "panes-zoom", target: parsed.positionals[0] ?? "" };
+      }
       if (parsed.subcommand === "close") {
         return { kind: "panes-close", target: parsed.positionals[0] ?? "all" };
       }
@@ -2132,6 +2233,19 @@ ${usageNotice(entry)}` : usageNotice(entry));
         });
         return;
       }
+      if (command.kind === "panes-zoom") {
+        runLocal(async () => {
+          const result = await panes.zoom(command.target);
+          if (result.status === "zoomed") {
+            ctx.notice("success", `toggled zoom on ${result.label} (${result.paneId})`);
+          } else if (result.status === "not-found") {
+            ctx.notice("warn", `no Clio-owned pane matches ${result.target}`);
+          } else {
+            ctx.notice("warn", result.reason);
+          }
+        });
+        return;
+      }
       if (command.kind !== "panes-close") return;
       runLocal(async () => {
         const result = await panes.close(command.target);
@@ -2148,16 +2262,21 @@ ${usageNotice(entry)}` : usageNotice(entry));
   },
   {
     name: "thinking",
-    description: "Set the chat thinking level, or open Settings \u2192 Orchestrator",
+    description: "Set the chat thinking level",
     group: "Configure",
-    kinds: ["thinking-set"],
+    kinds: ["thinking-set", "thinking-picker"],
     args: { positionals: [{ name: "level", required: false }] },
     fromArgs(parsed) {
       if (parsed.error) return { kind: "usage-error", command: "thinking", reason: parsed.error };
       const level = parsed.positionals[0];
-      return level ? { kind: "thinking-set", level } : { kind: "settings", section: "orchestrator", rowId: "orchestrator.thinkingLevel" };
+      return level ? { kind: "thinking-set", level } : { kind: "thinking-picker" };
     },
     handle(command, ctx) {
+      if (command.kind === "thinking-picker") {
+        if (ctx.openThinkingPicker) ctx.openThinkingPicker();
+        else ctx.notice("error", "thinking picker is not wired in this session");
+        return;
+      }
       if (command.kind !== "thinking-set") return;
       const result = ctx.setThinkingLevel?.(command.level) ?? { status: "unavailable" };
       if (result.status === "applied") {
@@ -2172,16 +2291,21 @@ ${usageNotice(entry)}` : usageNotice(entry));
   },
   {
     name: "output",
-    description: "Set transcript detail (minimal, default, verbose), or open Settings \u2192 Terminal",
+    description: "Set transcript detail to minimal, default, or verbose",
     group: "Configure",
-    kinds: ["output-set"],
+    kinds: ["output-set", "output-picker"],
     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" };
+      return verbosity ? { kind: "output-set", verbosity } : { kind: "output-picker" };
     },
     handle(command, ctx) {
+      if (command.kind === "output-picker") {
+        if (ctx.openOutputPicker) ctx.openOutputPicker();
+        else ctx.notice("error", "output picker is not wired in this session");
+        return;
+      }
       if (command.kind !== "output-set") return;
       const result = ctx.setOutputVerbosity?.(command.verbosity) ?? { status: "unavailable" };
       if (result.status === "applied") {
@@ -2237,36 +2361,38 @@ ${usageNotice(entry)}` : usageNotice(entry));
       })();
     }
   },
-  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 }] },
+    args: {
+      positionals: [
+        { name: "area", required: false },
+        { name: "group", required: false }
+      ]
+    },
     fromArgs(parsed) {
       if (parsed.error) return { kind: "usage-error", command: "settings", reason: parsed.error };
-      const 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})` };
+      const area = parsed.positionals[0];
+      if (area === void 0) return { kind: "settings" };
+      if (!isSettingsAreaId(area)) {
+        return {
+          kind: "usage-error",
+          command: "settings",
+          reason: `Unknown area: ${area} (one of ${SETTINGS_AREA_IDS.join(", ")})`
+        };
       }
-      return { kind: "settings", section };
+      return { kind: "settings", area, ...parsed.positionals[1] ? { group: parsed.positionals[1] } : {} };
     },
     handle(command, ctx) {
-      if (command.kind === "settings") ctx.openSettings(command.section, command.rowId);
+      if (command.kind === "settings") ctx.openSettings(command.area, command.group);
     }
   },
   {
     name: "resume",
     description: "Resume a past session",
-    group: "Sessions",
+    group: "Session",
     kinds: ["resume"],
     args: {},
     fromArgs: fromArgsOrUsage("resume", { kind: "resume" }),
@@ -2277,7 +2403,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
   {
     name: "new",
     description: "Start a fresh session",
-    group: "Sessions",
+    group: "Session",
     kinds: ["new"],
     args: {},
     fromArgs: fromArgsOrUsage("new", { kind: "new" }),
@@ -2288,7 +2414,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
   {
     name: "handoff",
     description: "Hand this session's working state to a fresh session for a stated goal",
-    group: "Sessions",
+    group: "Session",
     kinds: ["handoff", "handoff-usage"],
     args: {
       positionals: [{ name: "goal", required: true, rest: true }]
@@ -2311,7 +2437,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
   {
     name: "tree",
     description: "Open session tree navigator",
-    group: "Sessions",
+    group: "Session",
     kinds: ["tree"],
     args: {},
     fromArgs: fromArgsOrUsage("tree", { kind: "tree" }),
@@ -2322,7 +2448,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
   {
     name: "fork",
     description: "Fork from an assistant turn",
-    group: "Sessions",
+    group: "Session",
     kinds: ["fork"],
     args: {},
     fromArgs: fromArgsOrUsage("fork", { kind: "fork" }),
@@ -2333,7 +2459,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
   {
     name: "export",
     description: "Export a self-contained HTML transcript by default; a .md path writes Markdown",
-    group: "Sessions",
+    group: "Session",
     kinds: ["export"],
     args: {
       positionals: [{ name: "path", required: false }]
@@ -2364,6 +2490,30 @@ for (const entry of BUILTIN_SLASH_COMMANDS) {
 }
 var COMMAND_SHAPED_TOKEN = /^[A-Za-z][A-Za-z0-9:-]*$/u;
 var COMMAND_ESCAPE = "\\/";
+var RETIRED_COMMAND_HINTS = Object.freeze({
+  status: "Use the footer or Alt+U for status; /cost, /context, and /fleet inspect their own domains.",
+  receipts: "Use /view or /view verify <run-id>.",
+  "context-init": "Use /context init.",
+  "context-clear": "Use /context reset for project context or /new for a fresh session.",
+  "context-view": "Use /context.",
+  compact: "Use /context compact [instructions].",
+  skills: "Use /skill or /resources skills.",
+  exit: "Use /quit.",
+  config: "Use /settings.",
+  ctx: "Use /context.",
+  models: "Use /model.",
+  clear: "Use /new for a fresh session or /context reset for project context.",
+  library: "Use /resources library [kind].",
+  prompts: "Use /resources prompts.",
+  extensions: "Use /resources extensions.",
+  interop: "Use /agents connect.",
+  targets: "Use /settings targets.",
+  "scoped-models": "Use /settings chat model-picker."
+});
+function retiredCommandHint(token) {
+  if (/^skills?:[^\s]+$/u.test(token)) return "Use /skill <name> [task].";
+  return RETIRED_COMMAND_HINTS[token];
+}
 function parseSlashCommand(input) {
   const trimmed = input.trim();
   if (trimmed.length === 0) return { kind: "empty" };
@@ -2385,6 +2535,12 @@ function dispatchSlashCommand(command, ctx) {
     return "accepted";
   }
   if (command.kind === "unknown-command") {
+    const retiredHint = retiredCommandHint(command.token);
+    if (retiredHint) {
+      ctx.notice("error", `/${command.token} is retired and did not run. ${retiredHint}`);
+      ctx.render();
+      return "rejected";
+    }
     const expansion = ctx.expandPromptTemplate?.(command.text);
     if (expansion?.expanded === true) {
       ctx.submitChat(command.text);
@@ -2407,8 +2563,41 @@ function dispatchSlashCommand(command, ctx) {
   entry.handle(command, ctx);
   return "accepted";
 }
+var COMMAND_ORDER = [
+  "run",
+  "fleet",
+  "delegate",
+  "council",
+  "oracle",
+  "btw",
+  "share",
+  "skill",
+  "agents",
+  "tasks",
+  "context",
+  "memory",
+  "view",
+  "panes",
+  "cost",
+  "decisions",
+  "resources",
+  "help",
+  "model",
+  "thinking",
+  "output",
+  "settings",
+  "new",
+  "resume",
+  "handoff",
+  "fork",
+  "tree",
+  "export",
+  "archive",
+  "quit"
+];
+var COMMAND_ORDER_INDEX = new Map(COMMAND_ORDER.map((name, index) => [name, index]));
 function commandReference() {
-  return BUILTIN_SLASH_COMMANDS.filter((entry) => entry.hidden !== true).map((entry) => {
+  return BUILTIN_SLASH_COMMANDS.filter((entry) => entry.hidden !== true).slice().sort((a, b) => (COMMAND_ORDER_INDEX.get(a.name) ?? 99) - (COMMAND_ORDER_INDEX.get(b.name) ?? 99)).map((entry) => {
     const usage = usageLine(entry).replace(/^\nusage:\s*/, "").replace(/\n$/, "");
     return {
       name: entry.name,
@@ -2431,17 +2620,16 @@ export {
   createWorkerStream,
   isWorkerShareNote,
   LIBRARY_TABS,
-  SETTINGS_SECTIONS,
+  COMPLETION_SLOT_NAMES,
   renderArgsSpec,
   completeArgs,
+  SETTINGS_AREA_IDS,
   handleRun,
-  formatReceiptVerificationBlock,
   formatUserTaskHandoff,
   SLASH_COMMAND_GROUPS,
-  formatPanesStatus,
   BUILTIN_SLASH_COMMANDS,
   parseSlashCommand,
   dispatchSlashCommand,
   commandReference
 };
-//# sourceMappingURL=chunk-C2LTL2W6.js.map
+//# sourceMappingURL=chunk-J4HBWF6Y.js.map