@iowarp/clio-coder 0.4.0 → 0.4.1

package/dist/{chunk-QLFS5GO2.js → chunk-AFKWHWXF.js}

@@ -15,14 +15,11 @@ import {
   parseBulkFrame,
   parseControlFrame,
   toolSignatureOf
-} from "./chunk-CMZWFGD2.js";
+} from "./chunk-VAVR4IJY.js";
 import {
   enableClioCompileCache,
   workerCompileCacheEnvironment
-} from "./chunk-PQEFIJ36.js";
-import {
-  atomicWrite
-} from "./chunk-76ONBSIA.js";
+} from "./chunk-2LEAKD4C.js";
 import {
   AI_AGENT_NAME,
   withClioAgentEnvironment
@@ -154,7 +151,7 @@ import { performance } from "node:perf_hooks";
 init_esm_shims();
 import { createHash } from "node:crypto";
 function computeSettingsFingerprint(settings) {
-  return createHash("sha256").update(`clio.settings:${canonicalJson(settings)}`, "utf8").digest("hex");
+  return createHash("sha256").update(`clio-coder.settings:${canonicalJson(settings)}`, "utf8").digest("hex");
 }
 function verifyWorkerAttestation(attestation, approved) {
   if (attestation.protocolVersion !== WORKER_PROTOCOL_VERSION) {
@@ -199,7 +196,7 @@ function approvedIdentityForSpec(spec) {
   };
 }
 function workerSpecDigestOf(spec) {
-  return createHash("sha256").update(`clio.workerSpec:${canonicalJson(spec)}`, "utf8").digest("hex");
+  return createHash("sha256").update(`clio-coder.workerSpec:${canonicalJson(spec)}`, "utf8").digest("hex");
 }
 function resourceOrNull(value) {
   return value.known ? value.value : null;
@@ -720,14 +717,6 @@ function readFleetPreflightRecords() {
     return [];
   }
 }
-function recordFleetPreflight(records) {
-  const existing = readFleetPreflightRecords();
-  const merged = /* @__PURE__ */ new Map();
-  for (const record of existing) merged.set(`${record.nodeId}\0${record.projectRoot}`, record);
-  for (const record of records) merged.set(`${record.nodeId}\0${record.projectRoot}`, record);
-  const file = { version: 2, records: [...merged.values()] };
-  atomicWrite(storePath(), JSON.stringify(file, null, 2));
-}
 function fleetPreflightVerdict(node, projectRoot, records = readFleetPreflightRecords()) {
   const record = records.find((entry) => entry.nodeId === node.id && entry.projectRoot === projectRoot);
   if (!record) {
@@ -765,12 +754,13 @@ function routeFactVerdict(requirement, records = readFleetPreflightRecords(), op
   }
   return evaluateRouteFacts(targets, resources, requirement, options);
 }
-var PREFLIGHT_MARKER = "clio-preflight/1";
+var PREFLIGHT_MARKER = "clio-coder-preflight/1";
+var LEGACY_PREFLIGHT_MARKER = "clio-preflight/1";
 var DEFAULT_PREFLIGHT_TIMEOUT_MS = 2e4;
 function buildPreflightScript(node, projectRoot, targets = []) {
   const entry = node.clioCoderEntry !== void 0 && node.clioCoderEntry.trim().length > 0 ? node.clioCoderEntry.trim() : "clio-coder worker";
   const cliBase = entry.endsWith(" worker") ? entry.slice(0, -" worker".length) : null;
-  const versionProbe = cliBase !== null ? `v=$(${cliBase} --version 2>/dev/null | head -n 1); if [ -n "$v" ]; then echo "clio=$v"; else echo clio=missing; fi` : `echo clio=custom-entry`;
+  const versionProbe = cliBase !== null ? `v=$(${cliBase} --version 2>/dev/null | head -n 1); if [ -n "$v" ]; then echo "clioCoder=$v"; else echo clioCoder=missing; fi` : `echo clioCoder=custom-entry`;
   const lines = [
     `echo ${shellQuote(PREFLIGHT_MARKER)}`,
     `if cd ${shellQuote(projectRoot)} 2>/dev/null; then echo cwd=ok; else echo cwd=missing; fi`,
@@ -871,7 +861,7 @@ async function runFleetNodePreflight(node, projectRoot, options) {
   const probeStartedAt = performance2.now();
   const result = await runSsh(sshBinary, buildSshArgs(node, script), timeoutMs);
   const probeDurationMs = Math.round(performance2.now() - probeStartedAt);
-  if (!result.stdout.includes(PREFLIGHT_MARKER)) {
+  if (!result.stdout.includes(PREFLIGHT_MARKER) && !result.stdout.includes(LEGACY_PREFLIGHT_MARKER)) {
     const stderr = result.stderr.trim().split("\n").slice(-1)[0] ?? "";
     record.detail = `unreachable (ssh exit ${result.code}${stderr.length > 0 ? `: ${stderr}` : ""})`;
     return record;
@@ -893,8 +883,9 @@ async function runFleetNodePreflight(node, projectRoot, options) {
   };
   checks.pathParity = lines.includes("cwd=ok");
   checks.stateDirWritable = lines.includes("state=ok");
-  const clioLine = lines.find((line) => line.startsWith("clio="));
-  const clioValue = clioLine?.slice("clio=".length) ?? "missing";
+  const clioCoderLine = lines.find((line) => line.startsWith("clioCoder="));
+  const legacyClioLine = lines.find((line) => line.startsWith("clio="));
+  const clioValue = clioCoderLine?.slice("clioCoder=".length) ?? legacyClioLine?.slice("clio=".length) ?? "missing";
   if (clioValue === "custom-entry") {
     checks.clioPresent = true;
     checks.versionMatch = true;
@@ -928,9 +919,8 @@ export {
   localNodeIdentity,
   createSshWorkerTransport,
   readFleetPreflightRecords,
-  recordFleetPreflight,
   fleetPreflightVerdict,
   routeFactVerdict,
   runFleetNodePreflight
 };
-//# sourceMappingURL=chunk-QLFS5GO2.js.map
+//# sourceMappingURL=chunk-AFKWHWXF.js.map

package/dist/{chunk-FWDFM5ZU.js → chunk-AK5XEFVZ.js}

@@ -86,7 +86,7 @@ function appendOutOfTurnUsageRow(stateDir, row) {
       closeSync(fd);
     }
   } catch (error) {
-    process.stderr.write(`[clio:usage] out-of-turn usage row not written: ${messageOf(error)}
+    process.stderr.write(`[clio-coder:usage] out-of-turn usage row not written: ${messageOf(error)}
 `);
     return;
   }
@@ -96,7 +96,7 @@ function appendOutOfTurnUsageRow(stateDir, row) {
   try {
     boundOutOfTurnUsageFile(path);
   } catch (error) {
-    process.stderr.write(`[clio:usage] out-of-turn usage ring not bounded: ${messageOf(error)}
+    process.stderr.write(`[clio-coder:usage] out-of-turn usage ring not bounded: ${messageOf(error)}
 `);
   }
 }
@@ -213,4 +213,4 @@ export {
   appendOutOfTurnUsageRow,
   readOutOfTurnUsageRows
 };
-//# sourceMappingURL=chunk-FWDFM5ZU.js.map
+//# sourceMappingURL=chunk-AK5XEFVZ.js.map

package/dist/{chunk-O6TL7WWY.js → chunk-AKB4GYDL.js}

@@ -11,10 +11,10 @@ import {
 } from "./chunk-UOV2BYIW.js";
 import {
   createSafetyPolicyEngine
-} from "./chunk-32KWKNSF.js";
+} from "./chunk-IXJT6DCX.js";
 import {
   classify
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-IG7BCQBA.js";
 import {
   BusChannels,
   isRunAbortedPayload
@@ -190,7 +190,7 @@ function buildCompletionContractAuditRecord(input) {
 function logAuditError(err, path) {
   const msg = err instanceof Error ? err.message : String(err);
   const where = path ? ` (${path})` : "";
-  process.stderr.write(`[clio:audit] ${msg}${where}
+  process.stderr.write(`[clio-coder:audit] ${msg}${where}
 `);
 }
 var AUDIT_FLUSH_INTERVAL_MS = 5e3;
@@ -608,4 +608,4 @@ var SafetyDomainModule = {
 export {
   SafetyDomainModule
 };
-//# sourceMappingURL=chunk-O6TL7WWY.js.map
+//# sourceMappingURL=chunk-AKB4GYDL.js.map

package/dist/chunk-AP73CFDC.js

@@ -0,0 +1,308 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SettingsValidationError,
+  settingsPath,
+  validateSettings,
+  withSettingsLock
+} from "./chunk-EIMVLWB3.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/lifecycle/migrations/2026-09-01-settings-v2.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var SETTINGS_V2_MIGRATION_ID = "2026-09-01-settings-v2";
+var SettingsV2CollisionError = class extends Error {
+  collisions;
+  constructor(collisions) {
+    super(
+      "settings v1 to v2 migration refused source/destination collisions:\n" + collisions.map((collision) => `  ${collision}`).join("\n") + "\nThe original settings.yaml was left untouched. Remove either each v1 source or its v2 destination, then re-run `clio-coder upgrade`."
+    );
+    this.name = "SettingsV2CollisionError";
+    this.collisions = collisions;
+  }
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue(value) {
+  return structuredClone(value);
+}
+function segments(path) {
+  return path.split(".");
+}
+function hasPath(root, path) {
+  let current = root;
+  for (const segment of segments(path)) {
+    if (!isPlainObject(current) || !(segment in current)) return false;
+    current = current[segment];
+  }
+  return true;
+}
+function getPath(root, path) {
+  let current = root;
+  for (const segment of segments(path)) {
+    if (!isPlainObject(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setPath(root, path, value) {
+  const parts = segments(path);
+  let current = root;
+  for (const segment of parts.slice(0, -1)) {
+    const child = current[segment];
+    if (isPlainObject(child)) current = child;
+    else {
+      const created = {};
+      current[segment] = created;
+      current = created;
+    }
+  }
+  const leaf = parts.at(-1);
+  if (leaf !== void 0) current[leaf] = value;
+}
+function deletePath(root, path) {
+  const parts = segments(path);
+  const parents = [];
+  let current = root;
+  for (const segment of parts.slice(0, -1)) {
+    const child = current[segment];
+    if (!isPlainObject(child)) return false;
+    parents.push({ parent: current, key: segment });
+    current = child;
+  }
+  const leaf = parts.at(-1);
+  if (leaf === void 0 || !(leaf in current)) return false;
+  delete current[leaf];
+  for (let index = parents.length - 1; index >= 0; index -= 1) {
+    const entry = parents[index];
+    if (entry === void 0) continue;
+    const child = entry.parent[entry.key];
+    if (isPlainObject(child) && Object.keys(child).length === 0) delete entry.parent[entry.key];
+    else break;
+  }
+  return true;
+}
+function destinationConflict(root, path) {
+  const parts = segments(path);
+  let current = root;
+  let traversed = "";
+  for (let index = 0; index < parts.length; index += 1) {
+    const segment = parts[index];
+    if (segment === void 0) return null;
+    traversed = traversed ? `${traversed}.${segment}` : segment;
+    if (!(segment in current)) return null;
+    const child = current[segment];
+    if (index === parts.length - 1) return traversed;
+    if (!isPlainObject(child)) return traversed;
+    current = child;
+  }
+  return null;
+}
+function move(transform, from, to, valueTransform = cloneValue) {
+  if (!hasPath(transform.document, from)) return;
+  const conflict = destinationConflict(transform.document, to);
+  if (conflict !== null) {
+    transform.collisions.push(`${from} collides with ${conflict}`);
+    return;
+  }
+  setPath(transform.document, to, valueTransform(getPath(transform.document, from), transform));
+  deletePath(transform.document, from);
+  transform.moved.push(`${from} -> ${to}`);
+}
+function drop(transform, path, reason) {
+  if (!deletePath(transform.document, path)) return;
+  transform.dropped.push(`${path}: ${reason}`);
+}
+function migrateRosters(value, transform) {
+  const rosters = cloneValue(value);
+  if (!isPlainObject(rosters)) return rosters;
+  for (const [rosterName, roster] of Object.entries(rosters)) {
+    if (!isPlainObject(roster) || !Array.isArray(roster.members)) continue;
+    for (let index = 0; index < roster.members.length; index += 1) {
+      const member = roster.members[index];
+      if (!isPlainObject(member) || !("thinking" in member)) continue;
+      const from = `workers.rosters.${rosterName}.members[${index}].thinking`;
+      const to = `fleet.rosters.${rosterName}.members[${index}].thinkingLevel`;
+      if ("thinkingLevel" in member) {
+        transform.collisions.push(`${from} collides with ${to}`);
+        continue;
+      }
+      member.thinkingLevel = member.thinking;
+      delete member.thinking;
+      transform.moved.push(`${from} -> ${to}`);
+    }
+  }
+  return rosters;
+}
+function migrateFleetNodeAliases(transform) {
+  const nodes = getPath(transform.document, "fleet.nodes");
+  if (!Array.isArray(nodes)) return;
+  for (let index = 0; index < nodes.length; index += 1) {
+    const node = nodes[index];
+    if (!isPlainObject(node) || !("clioEntry" in node)) continue;
+    const from = `fleet.nodes[${index}].clioEntry`;
+    const to = `fleet.nodes[${index}].clioCoderEntry`;
+    if ("clioCoderEntry" in node) {
+      delete node.clioEntry;
+      transform.dropped.push(`${from}: discarded because canonical ${to} was also present and wins`);
+      continue;
+    }
+    node.clioCoderEntry = node.clioEntry;
+    delete node.clioEntry;
+    transform.moved.push(`${from} -> ${to}`);
+  }
+}
+function migrateSettingsV1Document(raw) {
+  if (!isPlainObject(raw)) throw new Error("settings v1 to v2 migration expected a YAML map at the document root");
+  const version = raw.version;
+  if (version !== void 0 && version !== 1) {
+    throw new Error(`settings v1 to v2 migration expected version 1, got ${String(version)}`);
+  }
+  const transform = {
+    document: cloneValue(raw),
+    moved: [],
+    dropped: [],
+    notes: version === void 0 ? ["version was absent; interpreted using the pre-v2 schema"] : [],
+    collisions: []
+  };
+  const moves = [
+    ["autonomy", "safety.autonomy"],
+    ["orchestrator.target", "chat.target"],
+    ["orchestrator.model", "chat.model"],
+    ["orchestrator.thinkingLevel", "chat.thinkingLevel"],
+    ["scope", "chat.modelPicker.cycleSet"],
+    ["modelSelector.favorites", "chat.modelPicker.favorites"],
+    ["modelSelector.recentLimit", "chat.modelPicker.recentLimit"],
+    ["defaults.maxTokens", "chat.maxOutputTokens"],
+    ["prewarm.enabled", "chat.prewarm"],
+    ["retry", "chat.retry"],
+    ["workers.default", "fleet.default"],
+    ["workers.profiles", "fleet.profiles"],
+    ["workers.rosters", "fleet.rosters", migrateRosters],
+    ["workers.agentBindings", "fleet.agentProfiles"],
+    ["routing.activeRoles", "fleet.adaptiveRouting.roles"],
+    ["routing.activePostures", "fleet.adaptiveRouting.postures"],
+    ["routing.agentAutomation.activeAgentRoles", "fleet.adaptiveRouting.agentRoles"],
+    ["budget.concurrency", "fleet.concurrency"],
+    ["workers.maxRetries", "fleet.retry.maxRetries"],
+    ["workers.resilienceCooldownMs", "fleet.retry.routeCooldownMs"],
+    ["workers.onPermission", "fleet.permissions.mode"],
+    ["workers.escalation", "fleet.permissions.escalation"],
+    ["guardrails.workerToolCallCap", "fleet.limits.toolCallsPerRun"],
+    ["guardrails.internalDispatchTimeoutMs", "fleet.limits.internalRunTimeoutMs"],
+    ["guardrails.maxDispatchRuns", "fleet.history.maxRuns"],
+    ["compaction.auto", "context.compaction.auto"],
+    ["compaction.threshold", "context.compaction.threshold"],
+    ["compaction.model", "context.compaction.model"],
+    ["compaction.systemPrompt", "context.compaction.systemPrompt"],
+    ["background.target", "context.memory.target"],
+    ["background.model", "context.memory.model"],
+    ["memory.intervention.enabled", "context.memory.enabled"],
+    ["memory.intervention.everyNTools", "context.memory.cadenceToolCalls"],
+    ["memory.intervention.windowSteps", "context.memory.trajectorySteps"],
+    ["memory.intervention.maxTokens", "context.memory.maxOutputTokens"],
+    ["memory.intervention.timeoutMs", "context.memory.timeoutMs"],
+    ["budget.sessionCeilingUsd", "safety.limits.sessionCostUsd"],
+    ["guardrails.turnToolCallBudget", "safety.limits.chatToolCallsPerTurn"],
+    ["guardrails.readMaxBytes", "safety.limits.readBytesPerCall"],
+    ["guardrails.observationTurnBudgetBytes", "safety.limits.observationBytesPerTurn"],
+    ["watchdog", "safety.review"],
+    ["terminal.outputVerbosity", "interface.outputDetail"],
+    ["terminal.smoothStreaming", "interface.smoothStreaming"],
+    ["terminal.tuiMode", "interface.mode"],
+    ["terminal.fullscreenScrollbar", "interface.fullscreenScrollbar"],
+    ["terminal.showTerminalProgress", "interface.terminalProgress"],
+    ["terminal.notify", "interface.desktopNotifications"],
+    ["panes.enabled", "interface.panes.enabled"],
+    ["panes.notifications", "interface.panes.notifications"],
+    ["panes.journal", "fleet.history.journal"],
+    ["panes.yazi.enabled", "interface.panes.files.enabled"],
+    ["panes.yazi.mode", "interface.panes.files.mode"],
+    ["panes.yazi.profile", "interface.panes.files.profile"],
+    ["panes.yazi.followCwd", "interface.panes.files.followCwd"],
+    ["keybindings", "interface.keybindings"],
+    ["skills.trustProjectCompatRoots", "integrations.projectResources.trustProjectImports"],
+    ["delegation.defaults", "integrations.externalAgents.defaults"],
+    ["delegation.agents", "integrations.externalAgents.entries"],
+    ["runtimePlugins", "integrations.runtimePlugins"],
+    ["library", "integrations.library"],
+    ["attribution.gitCommits", "integrations.git.commitAttribution"]
+  ];
+  for (const [from, to, valueTransform] of moves) move(transform, from, to, valueTransform);
+  drop(transform, "identity", "accepted and ignored; no behavior was lost");
+  drop(transform, "background.thinkingLevel", "unused; proactive memory always resolves thinking off");
+  drop(transform, "theme", "inactive; runtime rendering did not read it");
+  drop(transform, "compaction.excludeLastTurns", "legacy-mask only; context.workingSet.protectLastTurns remains");
+  drop(
+    transform,
+    "panes",
+    "remaining panes keys have no v2 successor; the shipped keys moved to interface.panes.* and fleet.history.journal"
+  );
+  migrateFleetNodeAliases(transform);
+  if (transform.collisions.length > 0) throw new SettingsV2CollisionError(transform.collisions);
+  transform.document.version = 2;
+  const validated = validateSettings(transform.document);
+  if (validated.issues.length > 0) throw new SettingsValidationError(validated.issues);
+  return transform;
+}
+function reportPath(stateDir) {
+  return join(stateDir, "migration-reports", `${SETTINGS_V2_MIGRATION_ID}.json`);
+}
+var migration = {
+  id: SETTINGS_V2_MIGRATION_ID,
+  async up(stateDir) {
+    withSettingsLock(() => {
+      const path = settingsPath();
+      if (!existsSync(path)) return;
+      let rawText;
+      let parsed;
+      try {
+        rawText = readFileSync(path, "utf8");
+        parsed = (0, import_yaml.parse)(rawText);
+      } catch (error) {
+        throw new Error(
+          `settings v1 to v2 migration could not read and parse ${path}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (isPlainObject(parsed) && parsed.version === 2) return;
+      const transformed = migrateSettingsV1Document(parsed);
+      const backupPath = `${path}.v1.bak`;
+      safeResourceWrite(path, (0, import_yaml.stringify)(transformed.document), {
+        encoding: "utf8",
+        mode: 420,
+        backup: { path: backupPath }
+      });
+      const report = {
+        fromVersion: 1,
+        toVersion: 2,
+        backupPath,
+        moved: transformed.moved,
+        dropped: transformed.dropped,
+        notes: transformed.notes
+      };
+      const target = reportPath(stateDir);
+      mkdirSync(join(stateDir, "migration-reports"), { recursive: true });
+      safeResourceWrite(target, `${JSON.stringify(report, null, 2)}
+`, { encoding: "utf8", mode: 420 });
+    });
+  }
+};
+var settings_v2_default = migration;
+
+export {
+  migrateSettingsV1Document,
+  settings_v2_default
+};
+//# sourceMappingURL=chunk-AP73CFDC.js.map

package/dist/{chunk-JDG2WCRO.js → chunk-BBTJOK6Y.js}

@@ -1,11 +1,11 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   verifyTool
-} from "./chunk-3URVFKWK.js";
+} from "./chunk-PJJ6MY27.js";
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-YDFRH54B.js";
+} from "./chunk-N5UK64DP.js";
 import {
   parseTomlDocument,
   tomlTableAt
@@ -16,14 +16,14 @@ import {
   PROJECT_VERIFIER_CATALOG_VERSION,
   compareCodepoints,
   parseProjectVerifierCatalogText
-} from "./chunk-5LXZXPKX.js";
+} from "./chunk-VN3SHNBN.js";
 import {
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-BBVJUZHB.js";
+} from "./chunk-HJWWJ6IL.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -960,4 +960,4 @@ export {
   previewVerifierDraft,
   runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=chunk-JDG2WCRO.js.map
+//# sourceMappingURL=chunk-BBTJOK6Y.js.map

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

@@ -6,10 +6,10 @@ import {
 import {
   readSettings,
   updateSettings
-} from "./chunk-VFA6GDY5.js";
+} from "./chunk-EIMVLWB3.js";
 import {
   runCommandVector
-} from "./chunk-BBVJUZHB.js";
+} from "./chunk-HJWWJ6IL.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
@@ -127,11 +127,11 @@ function delegationEntryForKind(kind, defaults) {
     connectTimeoutMs: defaults.connectTimeoutMs,
     turnTimeoutMs: defaults.turnTimeoutMs,
     permissionTimeoutMs: defaults.permissionTimeoutMs,
-    toolGovernance: "clio-policy"
+    toolGovernance: "clio-coder-policy"
   };
 }
 function interopProposals(report, settings) {
-  const configured = new Set(settings.delegation.agents.map((agent) => agent.id));
+  const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
   const proposals = [];
   for (const record of report.agents) {
     const kind = interopAgentKind(record.kind);
@@ -143,7 +143,7 @@ function interopProposals(report, settings) {
       kind: kind.id,
       label: kind.label,
       fingerprint: record.fingerprint,
-      entry: delegationEntryForKind(kind, settings.delegation.defaults),
+      entry: delegationEntryForKind(kind, settings.integrations.externalAgents.defaults),
       needsNetworkInstall: record.adapter !== "present"
     });
   }
@@ -204,7 +204,7 @@ function interopBootHint(report, settings) {
     (record) => ({ ...record, hintedFingerprint: record.fingerprint })
   );
   const names = fresh.map((proposal) => proposal.entry.id).join(", ");
-  return `clio: ${names} detected on PATH and not configured. Run /interop to review.`;
+  return `clio-coder: ${names} detected on PATH and not configured. Run /interop to review.`;
 }
 function acceptInteropAgents(ids, report) {
   const proposals = interopProposals(report, readSettings()).filter((proposal) => ids.includes(proposal.kind));
@@ -216,8 +216,8 @@ function acceptInteropAgents(ids, report) {
   const wired = [];
   updateSettings((settings) => {
     for (const proposal of proposals) {
-      if (settings.delegation.agents.some((agent) => agent.id === proposal.entry.id)) continue;
-      settings.delegation.agents.push({ ...proposal.entry, args: [...proposal.entry.args] });
+      if (settings.integrations.externalAgents.entries.some((agent) => agent.id === proposal.entry.id)) continue;
+      settings.integrations.externalAgents.entries.push({ ...proposal.entry, args: [...proposal.entry.args] });
       wired.push(proposal.entry.id);
     }
   });
@@ -387,7 +387,7 @@ function createInteropBundle(_context) {
     // from the proposals, which read the file, and not yet in the configured
     // list, which read the snapshot, so it was in neither until a reopen.
     configured() {
-      return readSettings().delegation.agents;
+      return readSettings().integrations.externalAgents.entries;
     },
     accept(ids) {
       const result = acceptInteropAgents(ids, detected2 ?? readInteropReport() ?? EMPTY_REPORT);
@@ -430,4 +430,4 @@ export {
   detectInteropAgents,
   InteropDomainModule
 };
-//# sourceMappingURL=chunk-SP2RXXYO.js.map
+//# sourceMappingURL=chunk-BDPT6GTK.js.map

package/dist/{chunk-NQQH3YT7.js → chunk-BJGUKIG4.js}

@@ -3,12 +3,12 @@ import {
   describeYaziProfile,
   inspectCurrentYaziProfile,
   resetYaziProfile
-} from "./chunk-HZHHCK24.js";
+} from "./chunk-J5LZHVIT.js";
 import {
   installTool,
   installedToolVersions,
   removeTool
-} from "./chunk-BKFM6EJV.js";
+} from "./chunk-D4CJV46V.js";
 import {
   describeFloorRejection,
   describeResolution,
@@ -299,4 +299,4 @@ function jsonShape(status) {
 export {
   runToolsCommand
 };
-//# sourceMappingURL=chunk-NQQH3YT7.js.map
+//# sourceMappingURL=chunk-BJGUKIG4.js.map