@iowarp/clio-coder 0.4.0 → 0.4.2

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

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

package/dist/chunk-3EBYEESD.js

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

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

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

package/dist/chunk-3KIPBMUA.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-34BHNEE3.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-3KIPBMUA.js.map