@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/{chunk-ECUO3KDP.js → chunk-TD3PGPQA.js}

@@ -4,17 +4,17 @@ import {
   normalizeWriteBoundary,
   normalizeWriteBoundaryEntry,
   writeBoundaryCovers
-} from "./chunk-HPCTNZM2.js";
+} from "./chunk-CTJ4RNAA.js";
 import {
   asDirectoryPathBoundary,
   pathBoundaryEntryCovers
-} from "./chunk-S4COXYBG.js";
+} from "./chunk-HHV2GANA.js";
 import {
   atomicWrite
-} from "./chunk-KV2AOLDF.js";
+} from "./chunk-MQXIVJ35.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -28,7 +28,7 @@ import {
   lstatSync,
   mkdirSync as mkdirSync2,
   readdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   realpathSync as realpathSync2,
   renameSync,
   rmdirSync,
@@ -43,11 +43,13 @@ import { join as join2, relative as relative2, resolve as resolve2 } from "node:
 init_esm_shims();
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 var OWNER_FILE_SUFFIX = ".task-owner.json";
-var COMMIT_IDENTITY = "clio-task";
+var TASK_WORKTREE_KIND = "clio-coder-task-worktree";
+var LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
+var COMMIT_IDENTITY = "clio-coder-task";
 function gitBytes(root, args) {
   return execFileSync("git", ["-C", root, ...args], {
     stdio: ["ignore", "pipe", "pipe"],
@@ -155,7 +157,7 @@ function createTaskWorktree(root, runId, base) {
   const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
   const parent = join(canonical, ".clio-coder", "worktrees");
   const path = join(parent, runId);
-  const branch = `clio/task/${runId}`;
+  const branch = `clio-coder/task/${runId}`;
   mkdirSync(parent, { recursive: true });
   if (!isCanonicalWorktreePathInside(parent, path))
     throw new Error(`task worktree path escapes its parent for run ${runId}`);
@@ -163,7 +165,7 @@ function createTaskWorktree(root, runId, base) {
   const ownerToken = randomBytes(16).toString("hex");
   writeFileSync(
     `${path}${OWNER_FILE_SUFFIX}`,
-    `${JSON.stringify({ version: 1, kind: "clio-task-worktree", root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}
+    `${JSON.stringify({ version: 1, kind: TASK_WORKTREE_KIND, root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}
 `,
     { encoding: "utf8", flag: "wx" }
   );
@@ -174,10 +176,21 @@ function assertOwnership(worktree) {
   if (resolve(worktree.path) !== resolve(expected) || !isCanonicalWorktreePathInside(join(worktree.root, ".clio-coder", "worktrees"), worktree.path)) {
     throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
   }
-  if (!existsSync(`${worktree.path}${OWNER_FILE_SUFFIX}`))
-    throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+  const ownerPath = `${worktree.path}${OWNER_FILE_SUFFIX}`;
+  if (!existsSync(ownerPath)) throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+  let marker;
+  try {
+    const value = JSON.parse(readFileSync(ownerPath, "utf8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("not an object");
+    marker = value;
+  } catch {
+    throw new Error(`task worktree ${worktree.runId} has an invalid ownership file`);
+  }
+  if (marker.version !== 1 || marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND || marker.root !== worktree.root || marker.runId !== worktree.runId || marker.branch !== worktree.branch || marker.base !== worktree.base || marker.ownerToken !== worktree.ownerToken) {
+    throw new Error(`task worktree ${worktree.runId} ownership facts do not match`);
+  }
 }
-function commitTaskWorktree(worktree, message = `Clio task ${worktree.runId}`) {
+function commitTaskWorktree(worktree, message = `Clio Coder task ${worktree.runId}`) {
   assertOwnership(worktree);
   return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
 }
@@ -220,8 +233,9 @@ function cleanupTaskWorktree(worktree, deleteBranch) {
 // src/tools/compete-worktrees.ts
 var COMPETE_PARENT_SEGMENTS = [".clio-coder", "worktrees"];
 var COMPETE_MANIFEST_FILE = ".clio-coder-compete-owner.json";
-var COMPETE_MANIFEST_KIND = "clio-compete-group";
-var COMPETE_COMMIT_IDENTITY = "clio-compete";
+var COMPETE_MANIFEST_KIND = "clio-coder-compete-group";
+var LEGACY_COMPETE_MANIFEST_KIND = "clio-compete-group";
+var COMPETE_COMMIT_IDENTITY = "clio-coder-compete";
 var SAFE_GROUP = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var PROCESS_EXIT_GRACE_MS = 750;
 var PROCESS_POLL_MS = 25;
@@ -243,7 +257,7 @@ function processSnapshot(pid) {
     if (err.code !== "EPERM") return { alive: false, birthToken: null };
   }
   try {
-    const stat = readFileSync(`/proc/${pid}/stat`, "utf8").trim();
+    const stat = readFileSync2(`/proc/${pid}/stat`, "utf8").trim();
     const close = stat.lastIndexOf(")");
     if (close > 0) {
       const fields = stat.slice(close + 1).trim().split(/\s+/u);
@@ -363,7 +377,7 @@ function isCanonicalPathInside(parent, candidate) {
 function manifestFromUnknown(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
   const manifest = value;
-  if (manifest.version !== 2 || manifest.kind !== COMPETE_MANIFEST_KIND || typeof manifest.root !== "string" || typeof manifest.group !== "string" || typeof manifest.token !== "string" || manifest.token.length === 0 || manifest.state !== "active" && manifest.state !== "cleanup-ready" && manifest.state !== "winner-preserved" || typeof manifest.createdAt !== "string" || typeof manifest.updatedAt !== "string") {
+  if (manifest.version !== 2 || manifest.kind !== COMPETE_MANIFEST_KIND && manifest.kind !== LEGACY_COMPETE_MANIFEST_KIND || typeof manifest.root !== "string" || typeof manifest.group !== "string" || typeof manifest.token !== "string" || manifest.token.length === 0 || manifest.state !== "active" && manifest.state !== "cleanup-ready" && manifest.state !== "winner-preserved" || typeof manifest.createdAt !== "string" || typeof manifest.updatedAt !== "string") {
     return null;
   }
   if (!validProcessLease(manifest.owner) || !Array.isArray(manifest.runs) || !manifest.runs.every(validRunLease) || new Set(manifest.runs.map((run) => run.runId)).size !== manifest.runs.length) {
@@ -379,7 +393,7 @@ function readManifest(root, group) {
   const directory = groupDirectory(canonical, group);
   if (!isCanonicalDirectoryAt(directory)) return null;
   try {
-    const parsed = JSON.parse(readFileSync(manifestPath(directory), "utf8"));
+    const parsed = JSON.parse(readFileSync2(manifestPath(directory), "utf8"));
     const manifest = manifestFromUnknown(parsed);
     if (manifest === null || manifest.root !== canonical || manifest.group !== group) return null;
     return manifest;
@@ -426,10 +440,13 @@ function isGitRepository(root) {
     return false;
   }
 }
-function competeBranch(group, index) {
+function competeBranch(group, index, legacy = false) {
   validateGroup(group);
   if (!Number.isInteger(index) || index < 1) throw new Error(`invalid compete candidate index ${index}`);
-  return `clio/compete/${group}/${index}`;
+  return `${legacy ? "clio" : "clio-coder"}/compete/${group}/${index}`;
+}
+function competeBranchMatches(branch, group, index) {
+  return branch === competeBranch(group, index) || branch === competeBranch(group, index, true);
 }
 function claimCompeteGroup(root, group) {
   const canonical = canonicalRoot(root);
@@ -542,6 +559,39 @@ function createCandidateWorktree(ownership, index, baseline) {
   git2(ownership.root, ["worktree", "add", "-b", branch, path, baseline]);
   return { index, branch, path };
 }
+async function createCandidateWorktreeMapped(ownership, index, baseline, mux) {
+  assertOwnership2(ownership);
+  const branch = competeBranch(ownership.group, index);
+  const path = join2(ownership.directory, `candidate-${index}`);
+  if (!isCanonicalPathInside(ownership.directory, path)) {
+    throw new Error(`candidate ${index} path escapes compete group ${ownership.group}`);
+  }
+  let fallback = "mux-unavailable";
+  if (mux?.available()) {
+    const created = await mux.worktreeCreate({
+      cwd: ownership.root,
+      branch,
+      base: baseline,
+      path,
+      label: `clio-coder compete ${ownership.group} candidate ${index}`,
+      focus: false
+    }).catch(() => null);
+    if (created !== null) {
+      if (resolve2(created.worktree.path) !== resolve2(path) || created.worktree.branch !== branch) {
+        throw new Error(`herdr created candidate ${index} at an unexpected path or branch`);
+      }
+      return {
+        index,
+        branch,
+        path,
+        provenance: { backend: "herdr", path, branch, workspaceId: created.workspaceId }
+      };
+    }
+    fallback = "mux-operation-failed";
+  }
+  const native = createCandidateWorktree(ownership, index, baseline);
+  return { ...native, provenance: { backend: "native", path, branch, fallback } };
+}
 function commitCandidateWork(worktree, message) {
   return commitWorktreePath(worktree.path, COMPETE_COMMIT_IDENTITY, message);
 }
@@ -558,9 +608,13 @@ function registeredWorktreePaths(root) {
 function exactGroupBranches(root, group) {
   return git2(root, ["branch", "--list", "--format=%(refname:short)"]).split("\n").filter((branch) => {
     const parts = branch.split("/");
-    return parts.length === 4 && parts[0] === "clio" && parts[1] === "compete" && parts[2] === group && /^\d+$/.test(parts[3] ?? "");
+    return parts.length === 4 && (parts[0] === "clio-coder" || parts[0] === "clio") && parts[1] === "compete" && parts[2] === group && /^\d+$/.test(parts[3] ?? "");
   });
 }
+function competeBranchForCandidate(root, group, index) {
+  const branches = exactGroupBranches(root, group);
+  return branches.find((branch) => branch === competeBranch(group, index)) ?? branches.find((branch) => branch === competeBranch(group, index, true)) ?? competeBranch(group, index);
+}
 function removeRegisteredWorktree(root, path) {
   try {
     git2(root, ["worktree", "remove", "--force", path]);
@@ -572,8 +626,7 @@ function removeRegisteredWorktree(root, path) {
 function removeCandidateWorktree(ownership, worktree, deleteBranch) {
   assertOwnership2(ownership);
   const expectedPath = join2(ownership.directory, `candidate-${worktree.index}`);
-  const expectedBranch = competeBranch(ownership.group, worktree.index);
-  if (resolve2(worktree.path) !== resolve2(expectedPath) || worktree.branch !== expectedBranch || !isCanonicalPathInside(ownership.directory, worktree.path)) {
+  if (resolve2(worktree.path) !== resolve2(expectedPath) || !competeBranchMatches(worktree.branch, ownership.group, worktree.index) || !isCanonicalPathInside(ownership.directory, worktree.path)) {
     throw new Error(`candidate ${worktree.index} does not belong to compete group ${ownership.group}`);
   }
   removeRegisteredWorktree(ownership.root, worktree.path);
@@ -588,6 +641,13 @@ function removeCandidateWorktree(ownership, worktree, deleteBranch) {
     throw new Error(`failed to remove candidate ${worktree.index} from compete group ${ownership.group}`);
   }
 }
+async function removeCandidateWorktreeMapped(ownership, worktree, deleteBranch, mux) {
+  const workspaceId = worktree.provenance?.backend === "herdr" ? worktree.provenance.workspaceId : void 0;
+  if (workspaceId && mux?.available()) {
+    await mux.worktreeRemove(workspaceId, { force: true }).catch(() => false);
+  }
+  removeCandidateWorktree(ownership, worktree, deleteBranch);
+}
 function mergeWinnerBranch(root, branch) {
   return mergeWorktreeBranch(root, branch, COMPETE_COMMIT_IDENTITY);
 }
@@ -657,8 +717,8 @@ function settleRecoveredCompeteDecision(root, group, winnerIndex) {
     cleanupWorktreeGroup(ownership);
     return null;
   }
-  const winnerBranch = competeBranch(group, winnerIndex);
   const branches = exactGroupBranches(ownership.root, group);
+  const winnerBranch = competeBranchForCandidate(ownership.root, group, winnerIndex);
   const winnerPath = join2(ownership.directory, `candidate-${winnerIndex}`);
   if (!branches.includes(winnerBranch) || !registeredWorktreePaths(ownership.root).some((path) => resolve2(path) === resolve2(winnerPath))) {
     throw new Error(`recovered winner ${winnerBranch} has no intact candidate worktree`);
@@ -1123,11 +1183,12 @@ export {
   settleCompeteGroupRun,
   markCompeteGroupCleanupReady,
   markCompeteGroupWinnerPreserved,
-  createCandidateWorktree,
+  createCandidateWorktreeMapped,
   commitCandidateWork,
   candidateDiffStat,
   protectedPathsChangedByCompeteBranch,
-  removeCandidateWorktree,
+  competeBranchForCandidate,
+  removeCandidateWorktreeMapped,
   mergeWinnerBranch,
   cleanupCompeteGroup,
   settleRecoveredCompeteDecision,
@@ -1138,4 +1199,4 @@ export {
   preflightWriteBoundaries,
   createWriteBoundaryEnforcer
 };
-//# sourceMappingURL=chunk-ECUO3KDP.js.map
+//# sourceMappingURL=chunk-TD3PGPQA.js.map

package/dist/{chunk-HKO36JWF.js → chunk-THYWACCR.js}

@@ -3,7 +3,10 @@ import {
   fleetLoopCheckStepId,
   fleetLoopRepairStepId,
   fleetStepWriteBoundary
-} from "./chunk-HPCTNZM2.js";
+} from "./chunk-CTJ4RNAA.js";
+import {
+  resultContractShape
+} from "./chunk-IG7BCQBA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -212,6 +215,31 @@ function spliceExecutionPlan(plan, parentId, tasks) {
 
 // src/domains/dispatch/fleet-plan.ts
 init_esm_shims();
+
+// src/domains/dispatch/fleet-node-prompt.ts
+init_esm_shims();
+function fleetNodeAnswerDirective(kind) {
+  if (kind === "architect-plan") return null;
+  return [
+    `Your result contract for this step is \`${kind}\`.`,
+    "The task above describes the whole chain. Any result shape it states belongs to the step that produces it, and does not apply to you.",
+    `End with exactly this shape and nothing else: ${resultContractShape({ kind })}`,
+    // The wire example carries literal names and evidence, and a small model
+    // handed one on a first attempt copies them: the first run of this
+    // directive came back claiming `npm run typecheck` / `exit 0` in the same
+    // breath as admitting it could not run a command. The fields are the
+    // contract; the values in the example are not.
+    "Its field values are an example. Fill them with what this run actually produced or observed, and never report a name or evidence you did not."
+  ].join("\n");
+}
+function renderFleetNodeTask(task, kind) {
+  const directive = fleetNodeAnswerDirective(kind);
+  return directive === null ? task : `${task}
+
+${directive}`;
+}
+
+// src/domains/dispatch/fleet-plan.ts
 function expandDependencies(dependencies, loopMembers) {
   return dependencies.flatMap((id) => {
     const loop = loopMembers.get(id);
@@ -260,7 +288,7 @@ function compileFleetExecutionPlan(input) {
       agentId: context.agentId,
       scope: context.scope,
       dependencies: [...dependencies],
-      task,
+      task: renderFleetNodeTask(task, resolved.expectedResultContract),
       expectedResultContract: resolved.expectedResultContract,
       requestedAuthority: resolved.requestedAuthority,
       approvedAuthority: resolved.approvedAuthority,
@@ -407,4 +435,4 @@ export {
   spliceExecutionPlan,
   compileFleetExecutionPlan
 };
-//# sourceMappingURL=chunk-HKO36JWF.js.map
+//# sourceMappingURL=chunk-THYWACCR.js.map

package/dist/{chunk-LXPJXFM5.js → chunk-TVH4ONAM.js}

@@ -5,19 +5,16 @@ import {
 import {
   probeWorkspace
 } from "./chunk-HVDIIIQW.js";
-import {
-  protectArtifact
-} from "./chunk-MV3K5QF2.js";
 import {
   isSessionEntry,
   isSessionHeader
-} from "./chunk-RAPCMZL4.js";
+} from "./chunk-FSP7CMNU.js";
+import {
+  protectArtifact
+} from "./chunk-GCSMB2KY.js";
 import {
   stripTokenizerSentinels
 } from "./chunk-CFGTUFWB.js";
-import {
-  BusChannels
-} from "./chunk-RKRLDWD3.js";
 import {
   CURRENT_SESSION_FORMAT_VERSION,
   appendSessionFileEntry,
@@ -29,11 +26,14 @@ import {
   readSessionMeta,
   resumeSession,
   sessionPaths
-} from "./chunk-KV2AOLDF.js";
+} from "./chunk-MQXIVJ35.js";
+import {
+  BusChannels
+} from "./chunk-HLW2MRKE.js";
 import {
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1139,7 +1139,7 @@ function createSessionBundle(context) {
         await performCheckpoint(state, "shutdown");
       } catch (err) {
         process.stderr.write(
-          `[clio:session] shutdown checkpoint failed: ${err instanceof Error ? err.message : String(err)}
+          `[clio-coder:session] shutdown checkpoint failed: ${err instanceof Error ? err.message : String(err)}
 `
         );
       }
@@ -1311,6 +1311,12 @@ var SessionDomainModule = {
 };
 
 // src/domains/session/archive-readers.ts
+var ROUTING_NOTICE_CUSTOM_TYPE = "clio-coder.routing-notice";
+var LEGACY_ROUTING_NOTICE_CUSTOM_TYPE = "clio.routing-notice";
+function normalizeReleasedCustomType(entry) {
+  if (entry.kind !== "custom" || entry.customType !== LEGACY_ROUTING_NOTICE_CUSTOM_TYPE) return entry;
+  return { ...entry, customType: ROUTING_NOTICE_CUSTOM_TYPE };
+}
 async function readAuditRows(stateDir) {
   const root = join3(stateDir, "audit");
   let files;
@@ -1415,7 +1421,7 @@ function parseSessionEntries(raw, source) {
     }
     if (isSessionHeader(parsed)) continue;
     if (isSessionEntry(parsed)) {
-      entries.push(parsed);
+      entries.push(normalizeReleasedCustomType(parsed));
       continue;
     }
     errors.push(
@@ -1475,4 +1481,4 @@ export {
   ledgerUsageCalls,
   SessionDomainModule
 };
-//# sourceMappingURL=chunk-LXPJXFM5.js.map
+//# sourceMappingURL=chunk-TVH4ONAM.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