@iowarp/clio-coder 0.3.9 → 0.4.1

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-WXCJ7VME.js → chunk-AKB4GYDL.js}

@@ -4,25 +4,25 @@ import {
   READONLY_SCOPE,
   WORKSPACE_SCOPE,
   isSubset
-} from "./chunk-HAY4ZE2P.js";
+} from "./chunk-5PSMVOLM.js";
 import {
   createLoopState,
   observe
 } from "./chunk-UOV2BYIW.js";
 import {
   createSafetyPolicyEngine
-} from "./chunk-N3PBVRTZ.js";
+} from "./chunk-IXJT6DCX.js";
 import {
   classify
-} from "./chunk-S4COXYBG.js";
+} from "./chunk-IG7BCQBA.js";
 import {
   BusChannels,
   isRunAbortedPayload
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-HLW2MRKE.js";
 import {
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -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-WXCJ7VME.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-4LJX2PUC.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-NQ6UCCOD.js";
+} from "./chunk-PJJ6MY27.js";
 import {
   discoverDeclaredChecksAtRoot,
   discoverDeclaredProjectEntriesAtRoot
-} from "./chunk-P3JGPQFL.js";
+} from "./chunk-N5UK64DP.js";
 import {
   parseTomlDocument,
   tomlTableAt
@@ -16,14 +16,14 @@ import {
   PROJECT_VERIFIER_CATALOG_VERSION,
   compareCodepoints,
   parseProjectVerifierCatalogText
-} from "./chunk-A2NJGIB3.js";
+} from "./chunk-VN3SHNBN.js";
 import {
   isVerificationScriptName
 } from "./chunk-UL3WSD3F.js";
 import {
   SAFE_EXEC_DEFAULT_TIMEOUT_MS,
   resolveSafeCwd
-} from "./chunk-B5CSFE7B.js";
+} from "./chunk-HJWWJ6IL.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -960,4 +960,4 @@ export {
   previewVerifierDraft,
   runVerifierAuthoringWorkflow
 };
-//# sourceMappingURL=chunk-4LJX2PUC.js.map
+//# sourceMappingURL=chunk-BBTJOK6Y.js.map

package/dist/{chunk-QQ7EKM72.js → chunk-BDPT6GTK.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-EIMVLWB3.js";
+import {
+  runCommandVector
+} from "./chunk-HJWWJ6IL.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();
 
@@ -174,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);
@@ -190,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"
     });
   }
@@ -251,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));
@@ -263,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);
     }
   });
@@ -434,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);
@@ -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-BDPT6GTK.js.map