@iowarp/clio-coder 0.4.1 → 0.4.2

package/dist/chunk-2X4RYJTJ.js

@@ -0,0 +1,39 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESET_IDS
+} from "./chunk-35MSIRKH.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-K6BSR66V.js";
+import {
+  StringEnum
+} from "./chunk-VXMFAE2W.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/panes-surface.ts
+init_esm_shims();
+var panesToolSurface = {
+  name: ToolNames.Panes,
+  description: "Manage the terminal panes Clio owns beside this session: show focuses a dispatched run's viewer pane, open starts a fixed utility preset (files, logs, or shell; never an arbitrary command) or focuses it when it is already open, close removes a Clio-created pane, list reports the inventory and the pane layer's health.",
+  parameters: typebox_exports.Object({
+    action: StringEnum(["show", "open", "close", "list"], { description: "Pane action." }),
+    target: typebox_exports.Optional(
+      typebox_exports.String({
+        description: 'show: an agent id or run id prefix, most recent match wins. close: a pane id, label, agent id, or "all".'
+      })
+    ),
+    preset: typebox_exports.Optional(StringEnum([...PANES_PRESET_IDS], { description: "open: which utility pane to start." }))
+  }),
+  baseActionClass: "read",
+  executionMode: "sequential"
+};
+
+export {
+  panesToolSurface
+};
+//# sourceMappingURL=chunk-2X4RYJTJ.js.map

package/dist/{chunk-Y45G3AXC.js → chunk-2Z2IKEXI.js}

@@ -9,10 +9,10 @@ import {
   detectInteropAgents,
   interopProposals,
   renderProposalEntry
-} from "./chunk-BDPT6GTK.js";
+} from "./chunk-JWJGP5DQ.js";
 import {
   initializeClioHome
-} from "./chunk-7PWAODYW.js";
+} from "./chunk-I7XBWTYH.js";
 import {
   createDelayedManualCodeInput,
   promptOAuthSelection
@@ -37,7 +37,7 @@ import {
   probeCapabilitiesForModel,
   readTargetModelSnapshot,
   recordTargetModelSnapshot
-} from "./chunk-UEDMSP56.js";
+} from "./chunk-BYMNWQ7O.js";
 import {
   credentialsPresent
 } from "./chunk-72GZI5EV.js";
@@ -46,11 +46,11 @@ import {
   removeTargetFromSettings,
   settingsPath,
   updateSettings
-} from "./chunk-EIMVLWB3.js";
+} from "./chunk-34BHNEE3.js";
 import {
   greetLmStudio,
   registerBuiltinRuntimes
-} from "./chunk-QKIFBZKT.js";
+} from "./chunk-IMXMHHMQ.js";
 import {
   buildProviderSupportEntry,
   configuredTargetsForRuntime,
@@ -426,15 +426,12 @@ function parseSetupArgs(argv) {
         out.backgroundModel = need();
         break;
       case "--fleet-model":
-      case "--worker-model":
         out.workerModel = need();
         break;
       case "--agent-profile":
-      case "--worker-profile":
         out.workerProfile = need();
         break;
       case "--agent-profile-model":
-      case "--worker-profile-model":
         out.workerProfileModel = need();
         break;
       case "--api-key-env":
@@ -464,7 +461,6 @@ function parseSetupArgs(argv) {
         out.setBackground = true;
         break;
       case "--set-fleet-default":
-      case "--set-worker-default":
         out.setWorkerDefault = true;
         break;
       case "--context-window": {
@@ -1555,4 +1551,4 @@ export {
   runTargetRename,
   runConfigureCommand
 };
-//# sourceMappingURL=chunk-Y45G3AXC.js.map
+//# sourceMappingURL=chunk-2Z2IKEXI.js.map

package/dist/{chunk-EIMVLWB3.js → chunk-34BHNEE3.js}

@@ -13,7 +13,7 @@ import {
   DEFAULT_SETTINGS,
   THEME_NAMED_COLORS,
   THINKING_LEVELS
-} from "./chunk-BWW4HLO4.js";
+} from "./chunk-UXCU4E3T.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
@@ -1278,7 +1278,11 @@ function validateSettings(raw) {
     if (!isPlainObject(raw.context)) issues.add("context", `expected a map, got ${describe(raw.context)}`);
     else {
       const context = raw.context;
-      issues.unknownKeys("context", context, ["workingSet", "compaction", "memory"]);
+      issues.unknownKeys("context", context, ["toolResultMaxBytes", "workingSet", "compaction", "memory"]);
+      if ("toolResultMaxBytes" in context) {
+        const parsed = expectInteger(issues, "context.toolResultMaxBytes", context.toolResultMaxBytes, { min: 4096 });
+        if (parsed !== void 0) settings.context.toolResultMaxBytes = parsed;
+      }
       if ("workingSet" in context) {
         if (!isPlainObject(context.workingSet))
           issues.add("context.workingSet", `expected a map, got ${describe(context.workingSet)}`);
@@ -1839,4 +1843,4 @@ export {
   removeFleetProfileFromSettings,
   bindAgentProfileInSettings
 };
-//# sourceMappingURL=chunk-EIMVLWB3.js.map
+//# sourceMappingURL=chunk-34BHNEE3.js.map

package/dist/{chunk-GIZNH63R.js → chunk-35MSIRKH.js}

@@ -7,10 +7,10 @@ import {
 init_esm_shims();
 var PANES_PRESETS = [
   {
-    id: "yazi",
+    id: "files",
     /** Probed through the toolchain resolution ladder before the pane is split. */
     binary: "yazi",
-    summary: "file manager rooted at the workspace",
+    summary: "file view rooted at the workspace; picks land in the composer",
     /** Printed verbatim when the probe finds nothing. */
     installHint: "clio-coder tools install yazi"
   },
@@ -31,10 +31,15 @@ var PANES_PRESET_IDS = PANES_PRESETS.map((preset) => preset.id);
 function isPanesPresetId(value) {
   return PANES_PRESETS.some((preset) => preset.id === value);
 }
+var PANES_PRESET_ALIASES = { yazi: "files" };
+function resolvePanesPresetId(value) {
+  if (isPanesPresetId(value)) return value;
+  return PANES_PRESET_ALIASES[value] ?? null;
+}
 
 export {
   PANES_PRESETS,
   PANES_PRESET_IDS,
-  isPanesPresetId
+  resolvePanesPresetId
 };
-//# sourceMappingURL=chunk-GIZNH63R.js.map
+//# sourceMappingURL=chunk-35MSIRKH.js.map

package/dist/chunk-3EBYEESD.js

@@ -0,0 +1,314 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESETS,
+  resolvePanesPresetId
+} from "./chunk-35MSIRKH.js";
+import {
+  newestRunEventJournalRunId,
+  runEventJournalPath,
+  runEventJournalRoot
+} from "./chunk-VIA6RFQZ.js";
+import {
+  resolveBinary
+} from "./chunk-BMS5RKQY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/interactive/panes-runtime.ts
+init_esm_shims();
+
+// src/interactive/pane-policy.ts
+init_esm_shims();
+var WATCHABLE_STATUSES = /* @__PURE__ */ new Set(["running", "stale", "cancelling", "enqueued", "retrying"]);
+function paneWatchDecision(request) {
+  if (request.source === "dispatch") {
+    return { open: false, reason: "dispatches run headless; watch a run from the workers view or /panes show" };
+  }
+  if (!WATCHABLE_STATUSES.has(request.runStatus)) {
+    return {
+      open: false,
+      reason: `run is ${request.runStatus}; use \`clio-coder fleet view <runId>\` for the post-mortem`
+    };
+  }
+  return { open: true };
+}
+
+// src/interactive/panes-runtime.ts
+function unavailableReason(mux) {
+  const reason = mux.detection().reason;
+  return `the pane layer is not available in this session: ${reason}. Start Clio inside a herdr session with \`clio-coder --with-panes\` to get panes`;
+}
+function matchOwnedPane(owned, target) {
+  const needle = target.trim().toLowerCase();
+  const newestFirst = [...owned].reverse();
+  return newestFirst.find((record) => record.ref.paneId.toLowerCase() === needle) ?? newestFirst.find((record) => record.label.toLowerCase().includes(needle)) ?? newestFirst.find((record) => record.purpose === needle) ?? null;
+}
+function inventory(records) {
+  return records.map((record) => ({
+    paneId: record.ref.paneId,
+    tabId: record.ref.tabId,
+    purpose: record.purpose,
+    label: record.label,
+    adopted: record.adopted === true
+  }));
+}
+function describePanesLeftBehind(mux) {
+  const dockIds = new Set(mux.docks().map((dock) => dock.paneId));
+  const left = mux.list().filter((record) => !dockIds.has(record.ref.paneId));
+  if (left.length === 0) return null;
+  const named = left.map((record) => `${record.label} (${record.ref.paneId})`).join(", ");
+  return `Clio left ${left.length} ${left.length === 1 ? "pane" : "panes"} open in herdr: ${named}. Utility panes stay when a session ends; the docks closed with it. Next time run \`/panes close all\` before \`/quit\` to take them with you, or close ${left.length === 1 ? "it" : "them"} now with \`herdr pane close <paneId>\`.`;
+}
+function createPanesRuntime(deps) {
+  const probe = deps.resolveBinaryPath ?? resolveBinary;
+  const journalRoot = deps.journalRoot ?? runEventJournalRoot;
+  let yaziController = null;
+  let watchController = null;
+  let nextPendingOpen = 0;
+  const pendingOpens = /* @__PURE__ */ new Map();
+  const beginPendingOpen = (label) => {
+    nextPendingOpen += 1;
+    const id = `pending:${nextPendingOpen}`;
+    pendingOpens.set(id, {
+      paneId: id,
+      tabId: "pending",
+      purpose: "utility",
+      label,
+      adopted: false,
+      pending: true
+    });
+    return id;
+  };
+  const closedYaziStatus = () => ({
+    mode: "closed",
+    paneId: null,
+    paneCwd: null,
+    lastLineAt: null,
+    droppedLines: 0
+  });
+  const matchRun = (target) => {
+    const needle = target.trim().toLowerCase();
+    if (needle.length === 0) return null;
+    const snapshot = deps.getDispatchSnapshot();
+    const live = [
+      ...snapshot.running.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "running" })),
+      ...snapshot.retrying.map((run) => ({ runId: run.runId, agentId: run.agentId, status: "retrying" }))
+    ];
+    const newestFirst = [...live].reverse();
+    const byAgent = newestFirst.find((run) => run.agentId.toLowerCase().includes(needle));
+    if (byAgent) return byAgent;
+    return newestFirst.find((run) => run.runId.toLowerCase().startsWith(needle)) ?? null;
+  };
+  const presetArgv = (presetId, binaryPath) => {
+    if (presetId === "shell") return [binaryPath, "-l"];
+    if (presetId === "logs") {
+      const runId = (deps.newestJournalRunId ?? (() => newestRunEventJournalRunId(journalRoot())))();
+      if (runId === null) return null;
+      return [binaryPath, "-n", "200", "-F", runEventJournalPath(runId, journalRoot())];
+    }
+    return null;
+  };
+  const show = async (target, source) => {
+    if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+    const match = matchRun(target);
+    if (match === null) {
+      const snapshot = deps.getDispatchSnapshot();
+      const candidates = [
+        .../* @__PURE__ */ new Set([...snapshot.running.map((run) => run.agentId), ...snapshot.retrying.map((run) => run.agentId)])
+      ];
+      return { status: "not-found", target, candidates };
+    }
+    const decision = paneWatchDecision({ source, runStatus: match.status });
+    if (!decision.open) return { status: "refused", reason: decision.reason };
+    if (watchController === null) {
+      return { status: "unavailable", reason: "the watch pane is not wired in this session" };
+    }
+    const watched = await watchController.watch(match.runId);
+    if (watched.status !== "watching") return { status: "unavailable", reason: watched.reason };
+    return { status: "watching", runId: match.runId, agentId: match.agentId, opened: watched.opened };
+  };
+  const openFiles = async (once) => {
+    const preset = PANES_PRESETS[0];
+    if (!deps.getSettings().interface.panes.files.enabled) {
+      return { status: "refused", reason: "the files pane is disabled by interface.panes.files.enabled" };
+    }
+    if (!yaziController) {
+      return { status: "unavailable", reason: "the files pane return path is not ready" };
+    }
+    const pendingId = beginPendingOpen(preset.id);
+    try {
+      const result = await yaziController.open(once ? { once: true } : void 0);
+      if (result.status === "opened") {
+        return { status: "opened", paneId: result.paneId, existing: result.existing };
+      }
+      if (result.status === "missing-binary") {
+        return {
+          status: "missing-binary",
+          binary: result.binary,
+          installHint: preset.installHint,
+          // The engine's own resolution sentence, prefixed with the surface it
+          // serves: an operator who typed `/files` should not have to know the
+          // name of the program to read the answer.
+          detail: `the files pane engine is not available: ${result.detail}`
+        };
+      }
+      return {
+        status: result.status === "profile-error" ? "refused" : "unavailable",
+        reason: result.reason
+      };
+    } finally {
+      pendingOpens.delete(pendingId);
+    }
+  };
+  return {
+    async files(action) {
+      if (action === "close") {
+        await yaziController?.close();
+        return { status: "closed" };
+      }
+      if (action === "toggle" && yaziController?.isOpen()) {
+        await yaziController.close();
+        return { status: "closed" };
+      }
+      return openFiles(action === "pick");
+    },
+    status() {
+      const detection = deps.mux.detection();
+      const settings = deps.getSettings();
+      const panes = settings.interface.panes;
+      return {
+        mode: deps.mux.mode,
+        available: deps.mux.available(),
+        reason: detection.reason,
+        socketPath: detection.socketPath,
+        server: detection.server,
+        settings: {
+          enabled: panes.enabled,
+          notifications: panes.notifications,
+          layout: panes.layout,
+          journal: settings.fleet.history.journal,
+          yazi: { ...panes.files }
+        },
+        yazi: yaziController?.status() ?? closedYaziStatus(),
+        docks: deps.mux.docks().map((dock) => ({
+          slot: dock.slot,
+          paneId: dock.paneId,
+          targetShare: dock.targetShare
+        })),
+        panes: [...inventory(deps.mux.list()), ...pendingOpens.values()]
+      };
+    },
+    show(target) {
+      return show(target, "slash");
+    },
+    async open(request) {
+      const cwd = deps.getCwd();
+      if (request.preset !== void 0) {
+        const presetId = resolvePanesPresetId(request.preset);
+        const preset = presetId === null ? void 0 : PANES_PRESETS.find((entry) => entry.id === presetId);
+        if (!preset) {
+          return { status: "refused", reason: `unknown preset: ${request.preset}` };
+        }
+        if (preset.id === "files") {
+          const result = await openFiles(request.once === true);
+          if (result.status === "opened") {
+            return { status: "opened", label: preset.id, paneId: result.paneId, existing: result.existing };
+          }
+          if (result.status === "missing-binary") {
+            return { ...result, preset: preset.id };
+          }
+          return result;
+        }
+        if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+        const live = deps.mux.list().find((record) => record.purpose === "utility" && record.label === preset.id);
+        if (live) {
+          await deps.mux.unzoomSelf();
+          await deps.mux.focusPane(live.ref.paneId);
+          return { status: "opened", label: preset.id, paneId: live.ref.paneId, existing: true };
+        }
+        const binaryPath = probe(preset.binary);
+        if (binaryPath === null) {
+          return {
+            status: "missing-binary",
+            preset: preset.id,
+            binary: preset.binary,
+            installHint: preset.installHint,
+            detail: `${preset.binary} was not found (install with \`${preset.installHint}\`)`
+          };
+        }
+        const argv2 = presetArgv(preset.id, binaryPath);
+        if (argv2 === null) {
+          return {
+            status: "refused",
+            reason: `no dispatched run has written a journal under ${journalRoot()} yet; the logs pane follows the newest run once one starts`
+          };
+        }
+        const pendingId2 = beginPendingOpen(preset.id);
+        try {
+          const ref = await deps.mux.openUtilityPane({ argv: argv2, cwd, label: preset.id });
+          if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${preset.id}` };
+          return { status: "opened", label: preset.id, paneId: ref.paneId };
+        } finally {
+          pendingOpens.delete(pendingId2);
+        }
+      }
+      if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+      const argv = request.argv ?? [];
+      if (argv.length === 0) return { status: "refused", reason: "nothing to run" };
+      const label = argv[0] ?? "pane";
+      const pendingId = beginPendingOpen(label);
+      try {
+        const ref = await deps.mux.openUtilityPane({ argv, cwd, label });
+        if (ref === null) return { status: "unavailable", reason: `pane host refused to open ${label}` };
+        return { status: "opened", label, paneId: ref.paneId };
+      } finally {
+        pendingOpens.delete(pendingId);
+      }
+    },
+    async zoom(target) {
+      if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+      const match = matchOwnedPane(deps.mux.list(), target.trim().length === 0 ? "watch" : target);
+      if (!match) return { status: "not-found", target: target.trim().length === 0 ? "watch" : target };
+      const changed = await deps.mux.zoomPane(match.ref.paneId, "toggle");
+      if (!changed) {
+        return { status: "unavailable", reason: "the pane host does not support zoom (protocol below pane.zoom)" };
+      }
+      return { status: "zoomed", paneId: match.ref.paneId, label: match.label };
+    },
+    async close(target) {
+      if (!deps.mux.available()) return { status: "unavailable", reason: unavailableReason(deps.mux) };
+      const owned = deps.mux.list();
+      if (target === "all") {
+        const labels = [];
+        for (const record of [...owned]) {
+          if (await deps.mux.closePane(record.ref.paneId)) labels.push(record.label);
+        }
+        return { status: "closed", closed: labels.length, labels };
+      }
+      const match = matchOwnedPane(owned, target);
+      if (!match) return { status: "not-found", target };
+      const closed = await deps.mux.closePane(match.ref.paneId);
+      return closed ? { status: "closed", closed: 1, labels: [match.label] } : { status: "not-found", target };
+    },
+    attachYazi(controller) {
+      yaziController = controller;
+      return () => {
+        if (yaziController === controller) yaziController = null;
+      };
+    },
+    attachWatch(controller) {
+      watchController = controller;
+      return () => {
+        if (watchController === controller) watchController = null;
+      };
+    }
+  };
+}
+
+export {
+  paneWatchDecision,
+  describePanesLeftBehind,
+  createPanesRuntime
+};
+//# sourceMappingURL=chunk-3EBYEESD.js.map

package/dist/{chunk-CTJ4RNAA.js → chunk-3F7VUY77.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RKKLTLYB.js";
 import {
   enabledExtensionResourceRoots
-} from "./chunk-SUW5DORT.js";
+} from "./chunk-HLAFFSEK.js";
 import {
   PATH_BOUNDARY_MAX_ENTRIES,
   normalizePathBoundary,
@@ -5073,4 +5073,4 @@ export {
   listFleetContracts,
   renderFleetPrompt
 };
-//# sourceMappingURL=chunk-CTJ4RNAA.js.map
+//# sourceMappingURL=chunk-3F7VUY77.js.map

package/dist/{chunk-AP73CFDC.js → chunk-3KIPBMUA.js}

@@ -4,7 +4,7 @@ import {
   settingsPath,
   validateSettings,
   withSettingsLock
-} from "./chunk-EIMVLWB3.js";
+} from "./chunk-34BHNEE3.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -305,4 +305,4 @@ export {
   migrateSettingsV1Document,
   settings_v2_default
 };
-//# sourceMappingURL=chunk-AP73CFDC.js.map
+//# sourceMappingURL=chunk-3KIPBMUA.js.map