@iowarp/clio-coder 0.3.9 → 0.4.0

package/dist/chunk-R346GLFC.js

@@ -0,0 +1,31 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/safe-id.ts
+init_esm_shims();
+var InvalidIdError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidIdError";
+  }
+};
+function isSafeId(id) {
+  if (id.length === 0) return false;
+  if (id.includes("/") || id.includes("\\")) return false;
+  if (id.includes("\0")) return false;
+  if (id === "." || id === "..") return false;
+  return true;
+}
+function assertSafeId(id, kind) {
+  if (!isSafeId(id)) {
+    throw new InvalidIdError(`invalid ${kind} id '${id}': must not contain path separators or path segments`);
+  }
+}
+
+export {
+  InvalidIdError,
+  assertSafeId
+};
+//# sourceMappingURL=chunk-R346GLFC.js.map

package/dist/{chunk-VPTUJU4P.js → chunk-SJ5ZKQ4S.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-S4COXYBG.js";
+} from "./chunk-DYJP44XW.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-VPTUJU4P.js.map
+//# sourceMappingURL=chunk-SJ5ZKQ4S.js.map

package/dist/{chunk-QQ7EKM72.js → chunk-SP2RXXYO.js}

@@ -3,13 +3,13 @@ import {
   INTEROP_AGENT_KINDS,
   interopAgentKind
 } from "./chunk-IHXBNWMM.js";
-import {
-  runCommandVector
-} from "./chunk-B5CSFE7B.js";
 import {
   readSettings,
   updateSettings
-} from "./chunk-PNY46YEY.js";
+} from "./chunk-VFA6GDY5.js";
+import {
+  runCommandVector
+} from "./chunk-BBVJUZHB.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-APJ265NV.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -27,53 +27,6 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/providers/probe/fingerprint.ts
-init_esm_shims();
-async function fetchWithTimeout(url, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { signal: controller.signal });
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function fingerprintNativeRuntime(baseUrl) {
-  const normalized = baseUrl.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:");
-  const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-  const greeting = await fetchWithTimeout(`${trimmed}/lmstudio-greeting`, 750);
-  if (greeting?.ok) {
-    try {
-      const data = await greeting.json();
-      if (data.lmstudio === true) return { runtimeId: "lmstudio", displayName: "LM Studio" };
-    } catch {
-    }
-  }
-  const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750);
-  if (lmStudioV0?.ok) {
-    try {
-      const data = await lmStudioV0.json();
-      if (Array.isArray(data.data) && data.data.some((entry) => typeof entry === "object" && entry !== null && "compatibility_type" in entry)) {
-        return { runtimeId: "lmstudio", displayName: "LM Studio" };
-      }
-    } catch {
-    }
-  }
-  const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750);
-  if (ollama?.ok) {
-    try {
-      const data = await ollama.json();
-      if (typeof data.version === "string") {
-        return { runtimeId: "ollama-native", displayName: "Ollama" };
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-
 // src/domains/interop/index.ts
 init_esm_shims();
 
@@ -467,7 +420,6 @@ var InteropDomainModule = {
 };
 
 export {
-  fingerprintNativeRuntime,
   INHERITED_PROJECT_CONTEXT,
   delegationEntryForKind,
   interopProposals,
@@ -478,4 +430,4 @@ export {
   detectInteropAgents,
   InteropDomainModule
 };
-//# sourceMappingURL=chunk-QQ7EKM72.js.map
+//# sourceMappingURL=chunk-SP2RXXYO.js.map

package/dist/chunk-SUCTJL45.js

@@ -0,0 +1,45 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESET_IDS
+} from "./chunk-YJX4SHTD.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-K6BSR66V.js";
+import {
+  StringEnum
+} from "./chunk-UOSL25KY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/panes-surface.ts
+init_esm_shims();
+var panesToolSurface = {
+  name: ToolNames.Panes,
+  description: `Look at, focus, and manage the terminal panes Clio owns beside this session. Use show to bring a dispatched run's live viewer pane to the front when the operator asks to see an agent ("show me the tester"). open starts one of the fixed utility presets; there is no way to run an arbitrary command. close removes a pane Clio created. list reports the current inventory and the pane layer's health.`,
+  parameters: typebox_exports.Object({
+    action: StringEnum(["show", "open", "close", "list"], {
+      description: "show focuses a run's viewer pane; open starts a preset utility pane; close removes a Clio-owned pane; list reports the inventory."
+    }),
+    target: typebox_exports.Optional(
+      typebox_exports.String({
+        description: 'action=show: an agent id or run id prefix, most recent match wins. action=close: a pane id, a pane label, an agent id, or "all".'
+      })
+    ),
+    preset: typebox_exports.Optional(
+      StringEnum([...PANES_PRESET_IDS], {
+        description: "action=open: which fixed utility pane to start."
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "sequential"
+};
+
+export {
+  panesToolSurface
+};
+//# sourceMappingURL=chunk-SUCTJL45.js.map

package/dist/{chunk-5QKCQQ3E.js → chunk-SUW5DORT.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -816,4 +816,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-5QKCQQ3E.js.map
+//# sourceMappingURL=chunk-SUW5DORT.js.map

package/dist/chunk-T56WDKA5.js

@@ -0,0 +1,183 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/event-pump.ts
+init_esm_shims();
+var EVENT_TEE_LIMIT = 1024;
+function startDispatchEventPump(source, fold, options = {}) {
+  const limit = options.limit ?? EVENT_TEE_LIMIT;
+  const pending = [...options.prelude ?? []];
+  const waiters = [];
+  let finished = false;
+  let abandoned = false;
+  let dropped = 0;
+  const push = (value) => {
+    if (abandoned) return;
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    pending.push(value);
+    while (pending.length > limit) {
+      pending.shift();
+      dropped += 1;
+    }
+  };
+  const end = () => {
+    finished = true;
+    while (waiters.length > 0) {
+      waiters.shift()?.({ value: void 0, done: true });
+    }
+  };
+  const notify = (event) => {
+    try {
+      options.onEvent?.(event);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const done = (async () => {
+    try {
+      for (const event of options.prelude ?? []) notify(event);
+      for await (const event of source) {
+        try {
+          fold(event);
+        } catch (error) {
+          options.onError?.(error);
+        }
+        notify(event);
+        push(event);
+      }
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      end();
+    }
+  })();
+  const events = {
+    next() {
+      if (pending.length > 0) {
+        return Promise.resolve({ value: pending.shift(), done: false });
+      }
+      if (finished || abandoned) return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+      });
+    },
+    return() {
+      abandoned = true;
+      pending.length = 0;
+      while (waiters.length > 0) {
+        waiters.shift()?.({ value: void 0, done: true });
+      }
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  return { events, done, droppedEvents: () => dropped };
+}
+var WORKER_OUTPUT_MAX_BYTES = 8192;
+var WORKER_OUTPUT_TRUNCATION_MARKER = "\n[worker output truncated]";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assistantTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    if (typeof block === "string") return block;
+    if (!isRecord(block)) return "";
+    return typeof block.text === "string" ? block.text : "";
+  }).join("");
+}
+function isDurableAssistantMessage(message) {
+  const stopReason = message.stopReason;
+  if (stopReason === "toolUse" || stopReason === "error" || stopReason === "aborted" || stopReason === "cancelled") {
+    return false;
+  }
+  if (!Array.isArray(message.content)) return true;
+  return !message.content.some((block) => isRecord(block) && block.type === "toolCall");
+}
+function durableAssistantTextFromEvent(event) {
+  if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) return "";
+  if (event.message.role !== "assistant" || !isDurableAssistantMessage(event.message)) return "";
+  return assistantTextFromContent(event.message.content);
+}
+function boundedOutput(state, text) {
+  const bytes = Buffer.byteLength(text, "utf8");
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+  return { state, text: bounded, bytes, truncated: bounded !== text };
+}
+function createWorkerOutputCapture() {
+  let finalText = null;
+  let partialText = "";
+  let partialBytes = 0;
+  let partialStored = 0;
+  return {
+    observe(event) {
+      if (!isRecord(event)) return;
+      if (event.type === "message_end") {
+        const message = isRecord(event.message) ? event.message : null;
+        partialText = "";
+        partialBytes = 0;
+        partialStored = 0;
+        if (message === null || message.role !== "assistant") return;
+        if (!isDurableAssistantMessage(message)) return;
+        const text = assistantTextFromContent(message.content).trim();
+        if (text.length > 0) finalText = text;
+        return;
+      }
+      if (event.type !== "message_update") return;
+      const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+      if (assistantEvent === null || assistantEvent.type !== "text_delta") return;
+      const delta = assistantEvent.delta;
+      if (typeof delta !== "string" || delta.length === 0) return;
+      partialBytes += Buffer.byteLength(delta, "utf8");
+      if (partialStored < WORKER_OUTPUT_MAX_BYTES) {
+        partialText += delta;
+        partialStored += Buffer.byteLength(delta, "utf8");
+      }
+    },
+    snapshot() {
+      if (partialBytes > 0 && partialText.trim().length > 0) {
+        const bounded = truncateUtf8(partialText.trim(), WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+        return {
+          state: "partial",
+          text: bounded,
+          bytes: partialBytes,
+          truncated: bounded !== partialText.trim() || partialBytes > partialStored
+        };
+      }
+      if (finalText !== null) return boundedOutput("final", finalText);
+      return void 0;
+    }
+  };
+}
+
+// src/domains/dispatch/admission-error.ts
+init_esm_shims();
+var AdmissionCanceledError = class extends Error {
+  code = "admission_canceled";
+  constructor(message = "dispatch: admission canceled before a capacity slot opened") {
+    super(message);
+    this.name = "AdmissionCanceledError";
+  }
+};
+
+export {
+  EVENT_TEE_LIMIT,
+  startDispatchEventPump,
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent,
+  createWorkerOutputCapture,
+  AdmissionCanceledError
+};
+//# sourceMappingURL=chunk-T56WDKA5.js.map

package/dist/chunk-TVHHYFHE.js

@@ -0,0 +1,255 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/safety/call-target.ts
+init_esm_shims();
+
+// src/domains/safety/redaction.ts
+init_esm_shims();
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var SECRET_KEY_RE = /(?:api[-_]?key|access[-_]?key|auth(?:orization)?|credential|password|private[-_]?key|secret|token)/iu;
+var ENV_KEY_RE = /^env(?:ironment)?$/iu;
+var SECRET_STRING_RE = /(https?:\/\/[^\s/@]+:)[^\s/@]+@/giu;
+var SECRET_URL_PARAM_RE = /([?&](?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[^=\s]*=)[^&#\s]+/giu;
+var SECRET_ASSIGNMENT_RE = /(?<![A-Z0-9_])((?:[A-Z0-9_]*(?:ACCESS|API|AUTH|CREDENTIAL|KEY|PASS(?:WORD)?|PRIVATE|SECRET|TOKEN)[A-Z0-9_]*)=)[^\s;&|]+/giu;
+var SECRET_FLAG_RE = /(--?(?:[a-z0-9-]*(?:api[-_]?key|access[-_]?token|auth(?:orization)?|credential|password|secret|token)[a-z0-9-]*))(=|\s+)([^\s;&|]+)/giu;
+function redactSecretString(value) {
+  return value.replace(SECRET_STRING_RE, "$1[redacted]@").replace(SECRET_URL_PARAM_RE, "$1[redacted]").replace(SECRET_ASSIGNMENT_RE, "$1[redacted]").replace(SECRET_FLAG_RE, "$1$2[redacted]");
+}
+function isSecretArgKey(key) {
+  return SECRET_KEY_RE.test(key);
+}
+function isEnvironmentArgKey(key) {
+  return ENV_KEY_RE.test(key);
+}
+function redactEnvironmentValue(value, depth) {
+  if (depth > 8) return "[redacted nested values]";
+  if (typeof value === "string") return "[redacted]";
+  if (Array.isArray(value)) return value.map((item) => redactEnvironmentValue(item, depth + 1));
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactEnvironmentValue(childValue, depth + 1);
+  }
+  return out;
+}
+function redactToolArgs(value, key = "", depth = 0) {
+  if (isSecretArgKey(key)) return "[redacted]";
+  if (isEnvironmentArgKey(key)) return redactEnvironmentValue(value, depth);
+  if (typeof value === "string") return redactSecretString(value);
+  if (depth > 8) return "[redacted nested values]";
+  if (Array.isArray(value)) return value.map((item) => redactToolArgs(item, key, depth + 1));
+  if (!isPlainObject(value)) return value;
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactToolArgs(childValue, childKey, depth + 1);
+  }
+  return out;
+}
+
+// src/domains/safety/call-target.ts
+var ESC_CHAR = String.fromCharCode(27);
+var BEL_CHAR = String.fromCharCode(7);
+var OSC_PATTERN = new RegExp(`${ESC_CHAR}\\][\\s\\S]*?(?:${BEL_CHAR}|${ESC_CHAR}\\\\|$)`, "g");
+var CSI_PATTERN = new RegExp(`${ESC_CHAR}\\[[0-9;?]*[0-9A-Za-z]`, "g");
+function sanitizeForDisplay(value) {
+  const stripped = value.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+  let out = "";
+  for (const ch of stripped) {
+    const code = ch.codePointAt(0) ?? 0;
+    out += code < 32 || code === 127 ? " " : ch;
+  }
+  return out;
+}
+function oneLine(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+var DISPLAY_TAB_WIDTH = 4;
+var CONTROL_BYTE_PLACEHOLDER = "\xB7";
+function sanitizeMultilineDisplayText(value) {
+  const escapesStripped = value.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+  let neutralized = escapesStripped.length !== value.length;
+  const stripped = escapesStripped.replace(/\r\n/g, "\n");
+  let tabsExpanded = false;
+  let out = "";
+  for (const ch of stripped) {
+    if (ch === "\n") {
+      out += ch;
+      continue;
+    }
+    if (ch === "	") {
+      out += " ".repeat(DISPLAY_TAB_WIDTH);
+      tabsExpanded = true;
+      continue;
+    }
+    const code = ch.codePointAt(0) ?? 0;
+    if (code < 32 || code === 127) {
+      out += CONTROL_BYTE_PLACEHOLDER;
+      neutralized = true;
+      continue;
+    }
+    out += ch;
+  }
+  return { text: out, neutralized, tabsExpanded };
+}
+function sanitizeCallTargetText(value) {
+  return oneLine(sanitizeForDisplay(value));
+}
+var CALL_ACTION_OBJECT_MAX_CHARS = 64;
+var CALL_TARGET_MAX_CHARS = 120;
+var CALL_ACTION_VOCABULARY = {
+  read: { verb: "reading", field: "path" },
+  edit: { verb: "editing", field: "path" },
+  write: { verb: "writing", field: "path" },
+  ls: { verb: "listing", field: "path" },
+  bash: { verb: "running", field: "command" },
+  grep: { verb: "searching", field: "pattern" },
+  find: { verb: "finding", field: "pattern" },
+  web_fetch: { verb: "fetching", field: "url" },
+  git: { verb: "git", field: "op" },
+  verify: { verb: "verifying", field: "check" },
+  code_nav: { verb: "navigating", field: "query" },
+  context: { verb: "context", field: "scope" },
+  artifact: { verb: "writing", field: "kind" },
+  monitor: { verb: "monitoring", field: "run_id" },
+  steer: { verb: "steering", field: "run_id" },
+  tasks: { verb: "tasks", field: "action" },
+  dispatch: { verb: "dispatching", field: "agent" },
+  // ACP tool kinds. A peer names its own argument fields, so these rely on
+  // the shared allowlist below rather than on a field this side can predict.
+  execute: { verb: "running", field: "command" },
+  search: { verb: "searching", field: "query" },
+  fetch: { verb: "fetching", field: "url" },
+  delete: { verb: "deleting", field: "path" },
+  move: { verb: "moving", field: "path" },
+  think: { verb: "thinking", field: "" }
+};
+var CALL_ACTION_OBJECT_FIELDS = ["path", "file_path", "command", "pattern", "query", "url"];
+var CALL_TARGET_FIELDS = {
+  read: ["path", "offset", "limit", "tail"],
+  grep: ["pattern", "path", "mode", "glob", "ignore_case", "literal", "context", "limit", "include_ignored"],
+  find: ["pattern", "path", "order", "limit", "include_ignored"],
+  ls: ["path", "limit"],
+  code_nav: ["mode", "query", "limit"],
+  context: ["scope", "query", "name", "limit", "ref", "include_tree"],
+  credential_present: ["name", "source", "file"],
+  write: ["path"],
+  edit: ["path"],
+  bash: ["command", "cwd", "timeout_ms", "output_policy"],
+  git: ["op", "path", "cached", "stat", "name_only", "limit", "cwd", "timeout_ms", "max_output_bytes"],
+  verify: ["check", "path", "browser", "cwd", "timeout_ms", "max_output_bytes"],
+  dispatch: [
+    "list",
+    "mode",
+    "agent",
+    "target",
+    "model",
+    "node",
+    "autonomy",
+    "tool_profile",
+    "thinking_level",
+    "detach",
+    "timeout_ms"
+  ],
+  monitor: ["run_id", "mode"],
+  steer: ["run_id", "action"],
+  tasks: ["action", "id"],
+  ledger: ["action", "kind", "path", "line", "target", "passed", "since"],
+  web_fetch: ["url", "method", "timeout_ms", "max_bytes", "format"],
+  ask_user: ["action", "mode", "max_rounds", "exposure"],
+  artifact: ["kind", "path", "title"],
+  // ACP tool kinds use only fields whose meaning the protocol defines.
+  execute: ["command", "cwd"],
+  search: ["query", "path"],
+  fetch: ["url", "method"],
+  delete: ["path"],
+  move: ["path", "target"]
+};
+function boundActionObject(value) {
+  if (typeof value !== "string") return null;
+  const clean = sanitizeCallTargetText(redactSecretString(value));
+  if (clean.length === 0) return null;
+  if (clean.length <= CALL_ACTION_OBJECT_MAX_CHARS) return { object: clean, truncated: false };
+  return { object: clean.slice(0, CALL_ACTION_OBJECT_MAX_CHARS), truncated: true };
+}
+function describeCallAction(tool, args) {
+  const known = CALL_ACTION_VOCABULARY[tool];
+  const candidates = known?.field ? [known.field, ...CALL_ACTION_OBJECT_FIELDS] : [...CALL_ACTION_OBJECT_FIELDS];
+  let bounded = null;
+  if (args) {
+    for (const field of candidates) {
+      if (isSecretArgKey(field)) continue;
+      bounded = boundActionObject(args[field]);
+      if (bounded !== null) break;
+    }
+  }
+  if (known === void 0 && bounded === null) return null;
+  const verb = known?.verb ?? "calling";
+  if (bounded === null) return { verb };
+  return { verb, object: bounded.object, ...bounded.truncated ? { truncated: true } : {} };
+}
+function renderAllowedTargetValue(value) {
+  if (typeof value === "string") {
+    const rendered = sanitizeCallTargetText(redactSecretString(value));
+    return rendered.length > 0 ? rendered : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return String(value);
+  return null;
+}
+function countLabel(count, singular, plural) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function summarizeUnlistedTargetValue(value) {
+  if (typeof value === "string") {
+    return `<string ${countLabel(Buffer.byteLength(value, "utf8"), "byte", "bytes")}>`;
+  }
+  if (Array.isArray(value)) return `<array ${countLabel(value.length, "item", "items")}>`;
+  if (value !== null && typeof value === "object") {
+    return `<object ${countLabel(Object.keys(value).length, "field", "fields")}>`;
+  }
+  if (value === null) return "<null 0 values>";
+  if (typeof value === "undefined") return "<undefined 0 values>";
+  return `<${typeof value} 1 value>`;
+}
+function targetFieldName(value) {
+  return sanitizeCallTargetText(value).slice(0, 32) || "field";
+}
+function describeCallTarget(tool, args) {
+  if (!args) return "";
+  const allowedFields = CALL_TARGET_FIELDS[tool] ?? [];
+  const allowed = new Set(allowedFields);
+  const parts = [];
+  for (const field of allowedFields) {
+    if (!(field in args)) continue;
+    if (isSecretArgKey(field)) {
+      parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(args[field])}`);
+      continue;
+    }
+    const rendered = renderAllowedTargetValue(args[field]);
+    if (rendered === null) {
+      parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(args[field])}`);
+      continue;
+    }
+    parts.push(parts.length === 0 ? rendered : `${targetFieldName(field)}=${rendered}`);
+  }
+  for (const [field, value] of Object.entries(args)) {
+    if (allowed.has(field)) continue;
+    parts.push(`${targetFieldName(field)}=${summarizeUnlistedTargetValue(value)}`);
+  }
+  return sanitizeCallTargetText(parts.join(" \xB7 ")).slice(0, CALL_TARGET_MAX_CHARS);
+}
+
+export {
+  redactSecretString,
+  redactToolArgs,
+  sanitizeMultilineDisplayText,
+  sanitizeCallTargetText,
+  describeCallAction,
+  describeCallTarget
+};
+//# sourceMappingURL=chunk-TVHHYFHE.js.map

package/dist/{chunk-IHKBWSXF.js → chunk-TZ3SGWZZ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   StringEnum
 } from "./chunk-UOSL25KY.js";
@@ -45,4 +45,4 @@ var monitorToolSurface = {
 export {
   monitorToolSurface
 };
-//# sourceMappingURL=chunk-IHKBWSXF.js.map
+//# sourceMappingURL=chunk-TZ3SGWZZ.js.map