@iowarp/clio-coder 0.4.6 → 0.4.7

package/dist/{chunk-HPTJF6DG.js → chunk-GVZFCJHE.js}

@@ -1,49 +1,55 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   createWorkerProgressFold
-} from "./chunk-3O2ZAUGQ.js";
+} from "./chunk-UA6W4XFJ.js";
 import {
   PANES_PRESETS,
   PANES_PRESET_IDS,
   resolvePanesPresetId
 } from "./chunk-QUIJZSDW.js";
+import {
+  isExtensionCommandToken
+} from "./chunk-RFCKPS2V.js";
 import {
   acceptanceFromTaskFlags,
   formatUserTaskHandoff
-} from "./chunk-GLYBJ4RQ.js";
-import {
-  SKILL_SURFACE_CLEAR_ARG,
-  parseSkillCommand
-} from "./chunk-536HXRFE.js";
+} from "./chunk-5AJPUR72.js";
 import {
   AdmissionCanceledError,
   WORKER_OUTPUT_MAX_BYTES,
   activeDecisionRefs,
   decisionRationale
-} from "./chunk-IGLVVNEG.js";
+} from "./chunk-CULVKYTK.js";
 import {
   TOOL_PROFILE_NAMES,
   isToolProfileName
-} from "./chunk-CBSKDFWL.js";
+} from "./chunk-GEVQNST4.js";
 import {
   requestExecutionRole
-} from "./chunk-LY4N4TTL.js";
-import {
-  parseCouncilReport,
-  parseOracleResult
-} from "./chunk-OQM5IVJY.js";
+} from "./chunk-3LXJOICS.js";
 import {
   resolveModelReference
-} from "./chunk-4U4TKZFR.js";
+} from "./chunk-WT5TRMO4.js";
 import {
   truncateUtf8
 } from "./chunk-MYI32N4R.js";
 import {
   BusChannels
-} from "./chunk-HL26ADLH.js";
+} from "./chunk-6CB2IL4N.js";
+import {
+  SKILL_SURFACE_CLEAR_ARG,
+  parseSkillCommand
+} from "./chunk-MZNWZUJM.js";
+import {
+  isLibraryKind
+} from "./chunk-YKRJTYNP.js";
+import {
+  parseCouncilReport,
+  parseOracleResult
+} from "./chunk-34XHRVKG.js";
 import {
   THINKING_LEVELS
-} from "./chunk-3BJGMT2D.js";
+} from "./chunk-3XE4NRLF.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -178,16 +184,19 @@ function formatOracleAnswer(result) {
   ].join("\n");
 }
 
-// src/interactive/overlays/library-tabs.ts
+// src/interactive/prompt-source-label.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);
+function promptSourceLabel(sourceInfo) {
+  const source = sourceInfo.source;
+  if (source === void 0) return `${sourceInfo.scope} prompts`;
+  const plugin = /^plugin:(?:[^:]+):(.+)$/u.exec(source);
+  if (plugin?.[1]) return `plugin ${plugin[1]}`;
+  if (source === "config") return "user prompts";
+  if (source === "project") return "project prompts";
+  if (source === "library") return "library";
+  const foreign = /^([a-z0-9-]+)-(user|project)$/u.exec(source);
+  if (foreign?.[1] && foreign[2]) return `${foreign[1]} ${foreign[2]} prompts`;
+  return source;
 }
 
 // src/interactive/slash-spec.ts
@@ -212,7 +221,6 @@ var COMPLETION_SLOT_NAMES = [
   "pane-runs-agents",
   "pane-presets",
   "pane-targets",
-  "library-tabs",
   "thinking-levels",
   "settings-areas",
   "settings-groups",
@@ -1158,6 +1166,79 @@ function formatPanesStatus(status) {
   return lines;
 }
 var BUILTIN_SLASH_COMMANDS = [
+  {
+    name: "background",
+    description: "Detach the newest eligible attached dispatch",
+    group: "Work",
+    kinds: ["background"],
+    args: {},
+    fromArgs: fromArgsOrUsage("background", { kind: "background" }),
+    handle(_command, ctx) {
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Background action requires an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.background();
+    }
+  },
+  {
+    name: "editor",
+    description: "Edit explicit text (or an empty buffer) externally",
+    group: "Work",
+    kinds: ["editor"],
+    args: { positionals: [{ name: "text", required: false, rest: true }] },
+    match(text) {
+      const match = /^\/editor(?:\s+([\s\S]*))?$/u.exec(text);
+      return match ? { kind: "editor", text: match[1] ?? "" } : null;
+    },
+    handle(command, ctx) {
+      if (command.kind !== "editor") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "External editing requires an interactive session");
+        return "rejected";
+      }
+      if (!ctx.keyboardActions.editor(command.text)) return "rejected";
+    }
+  },
+  {
+    name: "interrupt",
+    description: "Interrupt the active run and send this text",
+    group: "Work",
+    kinds: ["interrupt"],
+    args: { positionals: [{ name: "text", required: true, rest: true }] },
+    match(text) {
+      const match = /^\/interrupt(?:\s+([\s\S]*))?$/u.exec(text);
+      return match ? match[1]?.trim() ? { kind: "interrupt", text: match[1] } : { kind: "usage-error", command: "interrupt", reason: "Text is required" } : null;
+    },
+    handle(command, ctx) {
+      if (command.kind !== "interrupt") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Interrupt requires an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.interrupt(command.text);
+    }
+  },
+  {
+    name: "notifications",
+    description: "Dismiss the oldest notification or explicitly dismiss all",
+    group: "Inspect",
+    kinds: ["notifications-dismiss"],
+    args: { subcommands: { dismiss: { positionals: [{ name: "all", required: false }] } } },
+    match(text) {
+      if (!/^\/notifications(?:\s|$)/u.test(text)) return null;
+      const match = /^\/notifications\s+dismiss(?:\s+(all))?$/u.exec(text);
+      return match ? { kind: "notifications-dismiss", all: match[1] === "all" } : { kind: "usage-error", command: "notifications", reason: "Use /notifications dismiss [all]" };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "notifications-dismiss") return;
+      if (!ctx.keyboardActions) {
+        ctx.notice("warn", "Notifications require an interactive session");
+        return "rejected";
+      }
+      ctx.keyboardActions.dismiss(command.all);
+    }
+  },
   {
     name: "quit",
     description: "Exit Clio Coder",
@@ -1186,18 +1267,22 @@ var BUILTIN_SLASH_COMMANDS = [
   },
   {
     name: "skill",
-    description: "Open the Skills Hub, invoke a skill, or `off` to drop an active skill's tool surface",
+    description: "Invoke a skill, or use `off` to clear its tool surface",
     group: "Work",
-    kinds: ["skill-selector", "skill-invocation", "skill-surface-clear"],
+    kinds: ["skill-invocation", "skill-surface-clear"],
     args: {
       positionals: [
-        { name: "name", required: false },
+        { name: "name", required: true },
         { name: "task", required: false, rest: true }
       ]
     },
     match(trimmed) {
       if (trimmed === "/skill") {
-        return { kind: "skill-selector" };
+        return {
+          kind: "usage-error",
+          command: "skill",
+          reason: "Choose /skills to browse, /skill <name> to invoke, or /skill off to clear the active tool surface"
+        };
       }
       const command = parseSkillCommand(trimmed);
       if (!command) return null;
@@ -1207,9 +1292,7 @@ var BUILTIN_SLASH_COMMANDS = [
       return { kind: "skill-invocation", text: trimmed };
     },
     handle(command, ctx) {
-      if (command.kind === "skill-selector") {
-        ctx.openSkillsHub?.();
-      } else if (command.kind === "skill-invocation") {
+      if (command.kind === "skill-invocation") {
         ctx.submitChat(command.text);
       } else if (command.kind === "skill-surface-clear") {
         const cleared = ctx.clearSkillSurface?.() ?? [];
@@ -1221,50 +1304,148 @@ var BUILTIN_SLASH_COMMANDS = [
     }
   },
   {
-    name: "resources",
-    description: "Browse skills, prompts, libraries, and extensions",
+    name: "library",
+    description: "Open the full-screen recipe library, review a package operation, or reload installed recipes",
     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"
+      inspect: "Open the Library on one package or recipe",
+      install: "Review installing one package, then apply it",
+      remove: "Review removing one package, then apply it",
+      import: "Review a plugin source from a path or URL",
+      reload: "Refresh installed recipe resources in this session"
     },
     args: {
       subcommands: {
-        skills: {},
-        prompts: {},
-        library: { positionals: [{ name: "kind", required: false }] },
-        extensions: { positionals: [{ name: "action", required: false, values: ["reload"] }] }
+        inspect: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        install: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        remove: {
+          positionals: [{ name: "ref", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        import: {
+          positionals: [{ name: "path-or-url", required: true }],
+          flags: [{ name: "--user" }, { name: "--project" }]
+        },
+        reload: {}
       }
     },
     fromArgs(parsed) {
-      if (parsed.error) return { kind: "usage-error", command: "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: "resources" };
-      if (!isLibraryTab(tab)) {
-        const known = LIBRARY_TABS.map((entry) => entry.id).join(", ");
-        return { kind: "usage-error", command: "resources", reason: `Unknown kind: ${tab} (one of ${known})` };
-      }
-      return { kind: "resources", tab };
+      if (parsed.error) return { kind: "usage-error", command: "library", reason: parsed.error };
+      if (parsed.flags.has("--user") && parsed.flags.has("--project"))
+        return { kind: "usage-error", command: "library", reason: "Choose one destination: --user or --project" };
+      const scope = parsed.flags.has("--project") ? "project" : parsed.flags.has("--user") ? "user" : void 0;
+      const subcommand = parsed.subcommand;
+      if (subcommand === "reload") return { kind: "resources", family: "plugins", action: "reload" };
+      if (subcommand === "import") {
+        const source = parsed.rest ?? parsed.positionals[0];
+        if (!source)
+          return {
+            kind: "usage-error",
+            command: "library",
+            reason: "/library import needs a directory path or a source URL to review"
+          };
+        return { kind: "resources", tab: "plugin", importSource: source, ...scope ? { scope } : {} };
+      }
+      if (subcommand === "inspect" || subcommand === "install" || subcommand === "remove") {
+        const ref = parsed.positionals[0];
+        if (!ref)
+          return {
+            kind: "usage-error",
+            command: "library",
+            reason: `/library ${subcommand} needs a kind:name reference, such as plugin:materio, or a recipe name`
+          };
+        const prefix = ref.split(":", 1)[0] ?? "";
+        return {
+          kind: "resources",
+          tab: isLibraryKind(prefix) && ref.includes(":") ? prefix : "plugin",
+          focus: ref,
+          ...subcommand === "inspect" ? {} : { intent: subcommand },
+          ...scope ? { scope } : {}
+        };
+      }
+      if (parsed.error || parsed.positionals.length > 0)
+        return {
+          kind: "usage-error",
+          command: "library",
+          reason: "Use /library to browse, /library inspect|install|remove <ref>, /library import <path-or-url>, or /library reload; /skills, /agents and /prompts open the same browser on their category"
+        };
+      return { kind: "resources", tab: "plugin" };
     },
     handle(command, ctx) {
       if (command.kind !== "resources") return;
-      if (command.family === "prompts") ctx.openPrompts();
-      else if (command.family === "extensions") {
+      if (command.family === "plugins") {
+        if (!ctx.reloadPlugins)
+          ctx.notice("warn", "library: reload is unavailable in this session; restart to refresh resources");
+        else {
+          try {
+            const snapshot = ctx.reloadPlugins();
+            ctx.notice("success", `library: generation ${snapshot.generation} committed`);
+          } catch (error) {
+            ctx.notice("error", `library: reload failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        return;
+      }
+      if (command.family === "extensions") {
         if (command.action === "reload") reloadExtensionsCommand(ctx);
         else ctx.openExtensions();
-      } else ctx.openSkillsHub?.(command.tab);
+        return;
+      }
+      ctx.openSkillsHub?.({
+        ...command.tab ? { tab: command.tab } : {},
+        ...command.focus ? { focus: command.focus } : {},
+        ...command.intent ? { intent: command.intent } : {},
+        ...command.importSource ? { importSource: command.importSource } : {},
+        ...command.scope ? { scope: command.scope } : {}
+      });
+    }
+  },
+  {
+    name: "skills",
+    description: "Open the Library on Skills",
+    group: "Inspect",
+    kinds: [],
+    args: {},
+    fromArgs: fromArgsOrUsage("skills", { kind: "resources", tab: "skill" }),
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "skill" });
+    }
+  },
+  {
+    name: "prompts",
+    description: "Open the Library on Prompts",
+    group: "Inspect",
+    kinds: [],
+    args: {},
+    fromArgs: fromArgsOrUsage("prompts", { kind: "resources", tab: "prompt" }),
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "prompt" });
+    }
+  },
+  {
+    name: "extensions",
+    description: "Inspect harness extensions or reload their commands, hooks and operator UI",
+    group: "Inspect",
+    // Harness navigation uses the shared overlay dispatcher, independently of recipe reload.
+    kinds: [],
+    args: { positionals: [{ name: "action", required: false, values: ["reload"] }] },
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "extensions", reason: parsed.error };
+      if (parsed.positionals[0] && parsed.positionals[0] !== "reload")
+        return { kind: "usage-error", command: "extensions", reason: "extensions accepts only reload" };
+      return { kind: "resources", family: "extensions", ...parsed.positionals[0] ? { action: "reload" } : {} };
+    },
+    handle(command, ctx) {
+      if (command.kind !== "resources" || command.family !== "extensions") return;
+      if (command.action === "reload") reloadExtensionsCommand(ctx);
+      else ctx.openExtensions();
     }
   },
   {
@@ -1595,23 +1776,36 @@ ${usage}` : usage);
     }
   },
   {
-    name: "agents",
-    description: "List agents or connect a detected external agent",
+    name: "interop",
+    description: "Inspect coding agents and adopt safe resources",
     group: "Inspect",
     kinds: ["agents"],
-    subcommandDescriptions: {
-      list: "List native and external agents",
-      connect: "Review detected external-agent proposals"
+    args: {},
+    fromArgs(parsed) {
+      if (parsed.error) return { kind: "usage-error", command: "interop", reason: parsed.error };
+      return { kind: "agents", connect: true };
     },
-    args: { subcommands: { list: {}, connect: {} } },
+    handle(_command, ctx) {
+      ctx.openInterop?.();
+    }
+  },
+  {
+    name: "agents",
+    description: "Open the Library on Agents",
+    group: "Inspect",
+    kinds: [],
+    args: {},
     fromArgs(parsed) {
-      if (parsed.error) return { kind: "usage-error", command: "agents", reason: parsed.error };
-      return { kind: "agents", ...parsed.subcommand === "connect" ? { connect: true } : {} };
+      if (parsed.error)
+        return {
+          kind: "usage-error",
+          command: "agents",
+          reason: "Use /agents to browse recipes, or /interop to inspect another local agent's resources"
+        };
+      return { kind: "resources", tab: "agent" };
     },
-    handle(command, ctx) {
-      if (command.kind !== "agents") return;
-      if (command.connect) ctx.openInterop?.();
-      else ctx.openAgents();
+    handle(_command, ctx) {
+      ctx.openSkillsHub?.({ tab: "agent" });
     }
   },
   {
@@ -2336,6 +2530,12 @@ function formatExtensionReloadNotice(outcome) {
   return [level, `extensions: generation ${outcome.generation} committed (${delta}); hooks: ${hookParts.join(", ")}`];
 }
 function reloadExtensionsCommand(ctx) {
+  if (ctx.operatorExtensions) {
+    void ctx.operatorExtensions.reload().then((result) => {
+      if (result.status === "deferred") ctx.notice("info", result.message);
+    });
+    return;
+  }
   if (!ctx.reloadExtensions) {
     ctx.notice("warn", "extensions: reload is unavailable in this session; restart to pick up installed changes");
     return;
@@ -2349,11 +2549,19 @@ function reloadExtensionsCommand(ctx) {
 function parseSlashCommand(input) {
   const trimmed = input.trim();
   if (trimmed.length === 0) return { kind: "empty" };
+  const retiredLibrary = /^\/(resources|plugins)(?:\s|$)/u.exec(trimmed);
+  if (retiredLibrary) {
+    return {
+      kind: "usage-error",
+      command: retiredLibrary[1] ?? "library",
+      reason: "Use /library to browse and manage recipes; use /extensions for harness extensions"
+    };
+  }
   if (/^\/output(?:\s|$)/u.test(trimmed)) {
     return {
       kind: "usage-error",
       command: "output",
-      reason: "Use Alt+O to cycle Output style, or /settings interface to save a default. Use /view for full details"
+      reason: "Use /help for the effective Output cycle keys, or /settings interface to save a default. Use /view for full details"
     };
   }
   if (trimmed.startsWith(COMMAND_ESCAPE)) return { kind: "unknown", text: trimmed.slice(1) };
@@ -2363,7 +2571,8 @@ function parseSlashCommand(input) {
   }
   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 };
+    if (COMMAND_SHAPED_TOKEN.test(token) || isExtensionCommandToken(token))
+      return { kind: "unknown-command", token, text: trimmed };
   }
   return { kind: "unknown", text: trimmed };
 }
@@ -2379,7 +2588,48 @@ function dispatchSlashCommand(command, ctx) {
       ctx.submitChat(command.text);
       return "accepted";
     }
+    if (expansion?.expanded === false && expansion.display) {
+      const { template, text } = expansion.display;
+      const card = {
+        command: template.name,
+        source: promptSourceLabel(template.sourceInfo),
+        text
+      };
+      if (ctx.showReference) ctx.showReference(card);
+      else ctx.io.stdout(`/${card.command} (${card.source})
+${card.text}
+`);
+      ctx.render();
+      return "accepted";
+    }
     const refusal = expansion?.expanded === false ? expansion.refusal : void 0;
+    if (!refusal && isExtensionCommandToken(command.token) && ctx.operatorExtensions) {
+      const runtime = ctx.operatorExtensions;
+      const promptNames = ctx.listPrompts().items.map((prompt) => prompt.name);
+      const row = runtime.commands(promptNames).find((row2) => row2.invocation === command.token);
+      if (!row?.available) {
+        ctx.notice("error", row?.reason ?? `/${command.token} is not an available extension command`);
+        ctx.render();
+        return "rejected";
+      }
+      const args = command.text.slice(command.token.length + 1).trim();
+      const runLocal = ctx.runLocalOperation ?? ((operation) => void operation());
+      runLocal(async () => {
+        try {
+          const output = await runtime.invoke(
+            command.token,
+            args,
+            ctx.listPrompts().items.map((prompt) => prompt.name)
+          );
+          if (ctx.showExtensionOutput) ctx.showExtensionOutput(command.token, output);
+          else ctx.io.stdout(`${output.text}
+`);
+        } catch (error) {
+          ctx.notice("error", `${command.token}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      });
+      return "accepted";
+    }
     ctx.notice("error", refusal ? refusal.message : `/${command.token} is not a command. Type /help for the list.`);
     ctx.render();
     return "rejected";
@@ -2387,14 +2637,14 @@ function dispatchSlashCommand(command, ctx) {
   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}`);
+    const reason = command.command === "output" && ctx.keyboardActions ? `Use ${ctx.keyboardActions.outputLabel()} to cycle Output style, or /settings interface to save a default` : command.reason;
+    ctx.notice("error", `${reason}.${usage}`);
     ctx.render();
     return "rejected";
   }
   const entry = HANDLER_BY_KIND.get(command.kind);
   if (!entry) return "rejected";
-  entry.handle(command, ctx);
-  return "accepted";
+  return entry.handle(command, ctx) === "rejected" ? "rejected" : "accepted";
 }
 var COMMAND_ORDER = [
   "run",
@@ -2406,6 +2656,7 @@ var COMMAND_ORDER = [
   "share",
   "skill",
   "agents",
+  "interop",
   "tasks",
   "context",
   "memory",
@@ -2413,7 +2664,10 @@ var COMMAND_ORDER = [
   "panes",
   "cost",
   "decisions",
-  "resources",
+  "library",
+  "skills",
+  "prompts",
+  "extensions",
   "help",
   "model",
   "thinking",
@@ -2449,7 +2703,6 @@ export {
   workerReceiptSummary,
   createWorkerStream,
   isWorkerShareNote,
-  LIBRARY_TABS,
   COMPLETION_SLOT_NAMES,
   renderArgsSpec,
   completeArgs,
@@ -2462,4 +2715,4 @@ export {
   dispatchSlashCommand,
   commandReference
 };
-//# sourceMappingURL=chunk-HPTJF6DG.js.map
+//# sourceMappingURL=chunk-GVZFCJHE.js.map

package/dist/{chunk-ACCKVSHU.js → chunk-GXIWHXDB.js}

@@ -1,11 +1,11 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   inspectEvidence
-} from "./chunk-24T2YZ7A.js";
+} from "./chunk-WN552PKN.js";
 import {
   TRUST_STATUS_AXES,
   trustVerdict
-} from "./chunk-HZ2T2YED.js";
+} from "./chunk-IQCNVLO6.js";
 import {
   clioDataDir
 } from "./chunk-CTTI7G3T.js";
@@ -41,4 +41,4 @@ export {
   EVIDENCE_DETAIL_MAX_RUNS,
   evidenceDetailSnapshot
 };
-//# sourceMappingURL=chunk-ACCKVSHU.js.map
+//# sourceMappingURL=chunk-GXIWHXDB.js.map

package/dist/{chunk-LUL5Z66S.js → chunk-HOX4YZ2K.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   extractCommandCdTargets,
   extractCommandWriteTargets
-} from "./chunk-M6TAYK66.js";
+} from "./chunk-2O2LVQQK.js";
 import {
   canonicalizeExistingPath
 } from "./chunk-KQ6IDQIB.js";
@@ -10,8 +10,9 @@ import {
   artifactDefaultPath
 } from "./chunk-NTTS3O53.js";
 import {
-  ToolNames
-} from "./chunk-EHOSNVVM.js";
+  ToolNames,
+  isHarnessExtensionToolName
+} from "./chunk-WLHX3MM5.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -92,7 +93,7 @@ function baseClassify(tool) {
     case ToolNames.Steer:
       return "dispatch";
     default:
-      return null;
+      return isHarnessExtensionToolName(tool) ? "execute" : null;
   }
 }
 function scanStringOf(args) {
@@ -218,4 +219,4 @@ export {
   webFetchIsOutward,
   classify
 };
-//# sourceMappingURL=chunk-LUL5Z66S.js.map
+//# sourceMappingURL=chunk-HOX4YZ2K.js.map