@iowarp/clio-coder 0.4.0 → 0.4.2

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

@@ -2,8 +2,8 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   PANES_PRESETS,
   PANES_PRESET_IDS,
-  isPanesPresetId
-} from "./chunk-YJX4SHTD.js";
+  resolvePanesPresetId
+} from "./chunk-35MSIRKH.js";
 import {
   AdmissionCanceledError,
   WORKER_OUTPUT_MAX_BYTES,
@@ -11,7 +11,7 @@ import {
 } from "./chunk-T56WDKA5.js";
 import {
   parseSkillCommand
-} from "./chunk-VYMXRQI6.js";
+} from "./chunk-O3YUNJZ2.js";
 import {
   TOOL_PROFILE_NAMES,
   isToolProfileName
@@ -25,16 +25,16 @@ import {
 import {
   parseCouncilReport,
   parseOracleResult
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-PGF63K6I.js";
 import {
   resolveModelReference
-} from "./chunk-DQITNCXG.js";
+} from "./chunk-BYMNWQ7O.js";
 import {
   BusChannels
-} from "./chunk-HLW2MRKE.js";
+} from "./chunk-F4EKGO4N.js";
 import {
   THINKING_LEVELS
-} from "./chunk-GXNLGKAB.js";
+} from "./chunk-UXCU4E3T.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,81 @@ 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; `reload` commits a new extension generation"
+    },
+    args: {
+      subcommands: {
+        skills: {},
+        prompts: {},
+        library: { positionals: [{ name: "kind", required: false }] },
+        extensions: { positionals: [{ name: "action", required: false, values: ["reload"] }] }
+      }
+    },
     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") return { kind: "resources", family: "prompts" };
+      if (parsed.subcommand === "extensions") {
+        const action = parsed.positionals[0];
+        if (action === void 0) return { kind: "resources", family: "extensions" };
+        if (action === "reload") return { kind: "resources", family: "extensions", action: "reload" };
+        return { kind: "usage-error", command: "resources", reason: `Unknown action: ${action} (one of reload)` };
+      }
       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);
+      if (command.kind !== "resources") return;
+      if (command.family === "prompts") ctx.openPrompts();
+      else if (command.family === "extensions") {
+        if (command.action === "reload") reloadExtensionsCommand(ctx);
+        else ctx.openExtensions();
+      } else 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",
+    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 +1535,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 +1593,7 @@ ${usage}` : usage);
   {
     name: "run",
     description: "Run a fleet agent",
-    group: "Run",
+    group: "Work",
     kinds: ["run", "run-usage"],
     args: {
       parseFlagsBeforeRest: true,
@@ -1578,7 +1674,7 @@ ${usage}` : usage);
   {
     name: "delegate",
     description: "Run an ACP delegation agent",
-    group: "Run",
+    group: "Work",
     kinds: ["delegate", "delegate-usage"],
     args: {
       parseFlagsBeforeRest: true,
@@ -1625,7 +1721,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 +1744,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 +1770,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 +1820,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 +1922,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 +1934,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 +1951,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 +2139,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)`,
+      open: `open a utility pane (${PANES_PRESET_IDS.join(", ")}, \`files --once\` for one pick, or a command)`,
+      zoom: "toggle zoom on a Clio-owned pane (default: the watch pane)",
       close: "close a Clio-owned pane, or all of them"
     },
     fromArgs(parsed) {
@@ -2061,12 +2166,16 @@ ${usage}` : usage);
         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 };
+        const preset = resolvePanesPresetId(first);
+        if (argv.length === 1 && preset !== null) return { kind: "panes-open", preset };
+        if (argv.length === 2 && preset === "files" && argv[1] === "--once") {
+          return { kind: "panes-open", preset: "files", once: true };
         }
         return { kind: "panes-open", argv };
       }
+      if (parsed.subcommand === "zoom") {
+        return { kind: "panes-zoom", target: parsed.positionals[0] ?? "" };
+      }
       if (parsed.subcommand === "close") {
         return { kind: "panes-close", target: parsed.positionals[0] ?? "all" };
       }
@@ -2086,7 +2195,7 @@ ${usageNotice(entry)}` : usageNotice(entry));
       if (!panes) {
         ctx.notice(
           "info",
-          "panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set panes.enabled=auto"
+          "panes are inactive: this session started without them. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto"
         );
         return;
       }
@@ -2121,7 +2230,12 @@ ${usageNotice(entry)}` : usageNotice(entry));
             ...command.once ? { once: true } : {}
           });
           if (result.status === "opened") {
-            if (result.paneId !== null) ctx.notice("success", `opened pane ${result.label} (${result.paneId})`);
+            if (result.paneId !== null) {
+              ctx.notice(
+                "success",
+                result.existing ? `focused pane ${result.label} (${result.paneId})` : `opened pane ${result.label} (${result.paneId})`
+              );
+            }
           } else if (result.status === "missing-binary") {
             ctx.io.stdout(`${result.detail}
 `);
@@ -2132,6 +2246,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);
@@ -2146,18 +2273,80 @@ ${usageNotice(entry)}` : usageNotice(entry));
       });
     }
   },
+  {
+    name: "files",
+    description: "Toggle the files pane; picks land in the composer as @ mentions",
+    group: "Inspect",
+    kinds: ["files", "files-usage"],
+    args: { positionals: [{ name: "action", required: false }] },
+    subcommandDescriptions: {
+      open: "open the files pane, or focus it when it is already open",
+      close: "close the files pane",
+      pick: "borrow the files pane for one selection, then close it"
+    },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "files-usage", reason: parsed.error };
+      const action = parsed.positionals[0];
+      if (action === void 0) return { kind: "files", action: "toggle" };
+      if (action === "open" || action === "close" || action === "pick" || action === "toggle") {
+        return { kind: "files", action };
+      }
+      return { kind: "files-usage", reason: `Unexpected argument: ${action}` };
+    },
+    handle(command, ctx) {
+      if (command.kind === "files-usage") {
+        ctx.notice("info", `${command.reason}
+usage: /files [open|close|pick]`);
+        return;
+      }
+      if (command.kind !== "files") return;
+      const panes = ctx.panes;
+      if (!panes) {
+        ctx.notice(
+          "info",
+          "the files pane is inactive: this session started without panes. Restart with `clio-coder --with-panes`, or set interface.panes.enabled=auto"
+        );
+        return;
+      }
+      const runLocal = ctx.runLocalOperation ?? ((operation) => void operation());
+      runLocal(async () => {
+        const result = await panes.files(command.action);
+        if (result.status === "opened") {
+          if (result.paneId !== null) {
+            ctx.notice(
+              "success",
+              result.existing ? `files pane focused (${result.paneId})` : `files pane opened (${result.paneId})`
+            );
+          }
+        } else if (result.status === "closed") {
+          ctx.notice("info", "files pane closed");
+        } else if (result.status === "missing-binary") {
+          ctx.io.stdout(`${result.detail}
+`);
+          ctx.render();
+        } else {
+          ctx.notice("warn", result.reason);
+        }
+      });
+    }
+  },
   {
     name: "thinking",
-    description: "Set the chat thinking level, 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 +2361,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 +2431,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 +2473,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 +2484,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 +2507,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 +2518,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 +2529,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 +2560,54 @@ 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 formatExtensionReloadNotice(outcome) {
+  if (outcome.status !== "committed") {
+    return ["error", `extensions: reload rejected (${outcome.reason}); generation ${outcome.generation} stays active`];
+  }
+  const delta = outcome.changed ? `changed: +${outcome.added.length} -${outcome.removed.length} ~${outcome.modified.length}` : "unchanged";
+  const issueCount = outcome.hooks.fileIssues + outcome.hooks.issues;
+  const hookParts = [`${outcome.hooks.registered} registered`];
+  if (outcome.hooks.dropped > 0) hookParts.push(`${outcome.hooks.dropped} dropped`);
+  if (issueCount > 0) hookParts.push(`${issueCount} issue${issueCount === 1 ? "" : "s"}`);
+  if (outcome.hooks.overridden > 0) hookParts.push(`${outcome.hooks.overridden} overridden`);
+  const level = outcome.hooks.dropped > 0 || issueCount > 0 ? "warn" : "success";
+  return [level, `extensions: generation ${outcome.generation} committed (${delta}); hooks: ${hookParts.join(", ")}`];
+}
+function reloadExtensionsCommand(ctx) {
+  if (!ctx.reloadExtensions) {
+    ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
+    return;
+  }
+  const outcome = ctx.reloadExtensions();
+  const [level, text] = formatExtensionReloadNotice(outcome);
+  ctx.notice(level, text);
+  for (const line of outcome.lines) ctx.notice("warn", line);
+  if (outcome.status === "committed") ctx.openExtensions();
+}
 function parseSlashCommand(input) {
   const trimmed = input.trim();
   if (trimmed.length === 0) return { kind: "empty" };
@@ -2385,6 +2629,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 +2657,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 +2714,17 @@ 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,
+  formatExtensionReloadNotice,
   parseSlashCommand,
   dispatchSlashCommand,
   commandReference
 };
-//# sourceMappingURL=chunk-C2LTL2W6.js.map
+//# sourceMappingURL=chunk-RLYRBIYQ.js.map