@kal-elsam/kairo-runtime 0.14.0 → 0.15.0

package/src/global/fleet-set.js

@@ -0,0 +1,219 @@
+/**
+ * Consent-gated fleet model writes (OpenCode / Claude / Codex).
+ * Plan by default; --yes applies with backup. Never touches Cursor Auto / state.vscdb.
+ */
+import { copyFile, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveHomeDir } from "./paths.js";
+import { writeAtomicJson } from "./runtime/write-atomic-json.js";
+import { printJson } from "./json-output.js";
+import { commandHeader } from "./brand/index.js";
+import { formatCliCommand } from "./brand/cli.js";
+import {
+  parseFrontmatterModel,
+  replaceFrontmatterModel,
+  replaceCodexDefaultModel
+} from "./observability/fleet-platforms.js";
+
+const PLATFORMS = new Set(["opencode", "claude", "codex"]);
+
+function backupPath(path, stamp = Date.now()) {
+  return `${path}.kairo-backup.${stamp}`;
+}
+
+function requirePlatform(platform) {
+  const p = String(platform ?? "").toLowerCase();
+  if (!PLATFORMS.has(p)) {
+    throw new Error(`Unsupported platform "${platform}". Use opencode, claude, or codex.`);
+  }
+  return p;
+}
+
+function requireAgent(agent) {
+  const id = String(agent ?? "").trim();
+  if (!id) throw new Error("Missing --agent <id>.");
+  return id;
+}
+
+function requireModel(model) {
+  const m = String(model ?? "").trim();
+  if (!m) throw new Error("Missing --model <id>.");
+  return m;
+}
+
+export function buildOpenCodeFleetSetPlan({ config, agent, model, configPath }) {
+  const agents = config?.agent ?? config?.agents;
+  if (!agents || typeof agents !== "object" || !(agent in agents)) {
+    throw new Error(`OpenCode agent "${agent}" not found in ${configPath}.`);
+  }
+  const prev = agents[agent];
+  const previousModel = typeof prev?.model === "string" ? prev.model : (config?.model ?? null);
+  const nextAgents = {
+    ...agents,
+    [agent]: { ...prev, model }
+  };
+  const next = { ...config, agent: nextAgents };
+  if (config.agents && !config.agent) {
+    delete next.agent;
+    next.agents = nextAgents;
+  }
+  return {
+    platform: "opencode",
+    agent,
+    model,
+    previousModel,
+    path: configPath,
+    wouldWrite: previousModel !== model,
+    next,
+    note: `Set OpenCode agent.${agent}.model → ${model}`
+  };
+}
+
+export async function runFleetSet({
+  platform,
+  agent,
+  model,
+  yes = false,
+  json = false,
+  dryRun = false,
+  homeDir = resolveHomeDir(),
+  read = readFile,
+  writeText = writeFile,
+  copyFileFn = copyFile,
+  writeAtomicJsonFn = writeAtomicJson,
+  now = () => Date.now()
+} = {}) {
+  const p = requirePlatform(platform);
+  const nextModel = requireModel(model);
+  const agentId = p === "codex"
+    ? (String(agent ?? "default").trim() || "default")
+    : requireAgent(agent);
+  const apply = yes === true && dryRun !== true;
+
+  let plan;
+  let path;
+  let applyFn;
+
+  if (p === "opencode") {
+    path = join(homeDir, ".config", "opencode", "opencode.json");
+    const raw = await read(path, "utf8");
+    const config = JSON.parse(raw);
+    plan = buildOpenCodeFleetSetPlan({
+      config, agent: agentId, model: nextModel, configPath: path
+    });
+    applyFn = async () => {
+      await writeAtomicJsonFn(path, plan.next);
+    };
+  } else if (p === "claude") {
+    if (agentId === "default") {
+      path = join(homeDir, ".claude", "settings.json");
+      const existing = JSON.parse(await read(path, "utf8"));
+      const previousModel = typeof existing.model === "string" ? existing.model : null;
+      plan = {
+        platform: "claude",
+        agent: agentId,
+        model: nextModel,
+        previousModel,
+        path,
+        wouldWrite: previousModel !== nextModel,
+        next: { ...existing, model: nextModel },
+        note: `Set Claude settings.model → ${nextModel}`
+      };
+      applyFn = async () => {
+        await writeAtomicJsonFn(path, plan.next);
+      };
+    } else {
+      path = join(homeDir, ".claude", "agents", `${agentId}.md`);
+      const raw = await read(path, "utf8");
+      const previousModel = parseFrontmatterModel(raw).model;
+      const nextText = replaceFrontmatterModel(raw, nextModel);
+      plan = {
+        platform: "claude",
+        agent: agentId,
+        model: nextModel,
+        previousModel,
+        path,
+        wouldWrite: previousModel !== nextModel,
+        nextText,
+        note: `Set Claude agent ${agentId} frontmatter model → ${nextModel}`
+      };
+      applyFn = async () => {
+        await writeText(path, plan.nextText, "utf8");
+      };
+    }
+  } else {
+    path = join(homeDir, ".codex", "config.toml");
+    const raw = await read(path, "utf8");
+    const previousMatch = raw.match(/^\s*model\s*=\s*"([^"]+)"/m);
+    const previousModel = previousMatch ? previousMatch[1] : null;
+    const nextText = replaceCodexDefaultModel(raw, nextModel);
+    plan = {
+      platform: "codex",
+      agent: "default",
+      model: nextModel,
+      previousModel,
+      path,
+      wouldWrite: previousModel !== nextModel,
+      nextText,
+      note: `Set Codex config.toml model → ${nextModel}`
+    };
+    applyFn = async () => {
+      await writeText(path, plan.nextText, "utf8");
+    };
+  }
+
+  plan.backupPath = backupPath(path, now());
+  plan.applyWith = formatCliCommand(
+    `fleet set --platform ${p} --agent ${plan.agent} --model ${nextModel} --yes`
+  );
+
+  if (!apply) {
+    const payload = {
+      ok: true,
+      applied: false,
+      plan: {
+        platform: plan.platform,
+        agent: plan.agent,
+        model: plan.model,
+        previousModel: plan.previousModel,
+        path: plan.path,
+        wouldWrite: plan.wouldWrite,
+        note: plan.note,
+        applyWith: plan.applyWith
+      }
+    };
+    if (json) printJson(payload);
+    else {
+      console.log(commandHeader("Fleet set"));
+      console.log(plan.note);
+      console.log(`Path · ${plan.path}`);
+      console.log(`Was · ${plan.previousModel ?? "—"}`);
+      console.log(`Now · ${plan.model}`);
+      console.log(`Apply · ${plan.applyWith}`);
+    }
+    return payload;
+  }
+
+  await copyFileFn(path, plan.backupPath);
+  await applyFn();
+
+  const receipt = {
+    ok: true,
+    applied: true,
+    platform: plan.platform,
+    agent: plan.agent,
+    model: plan.model,
+    previousModel: plan.previousModel,
+    path: plan.path,
+    backupPath: plan.backupPath,
+    note: "Model assignment updated. Refresh Kairo Fleet to see declared changes."
+  };
+  if (json) printJson(receipt);
+  else {
+    console.log(commandHeader("Fleet set"));
+    console.log(`Wrote · ${receipt.path}`);
+    console.log(`Backup · ${receipt.backupPath}`);
+    console.log(receipt.note);
+  }
+  return receipt;
+}

package/src/global/fleet-shared.js

@@ -0,0 +1,38 @@
+/**
+ * Shared fleet constants + Gentle assignment loader (no circular imports).
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export const SDD_PHASES = Object.freeze([
+  "sdd-apply", "sdd-archive", "sdd-design", "sdd-explore", "sdd-init",
+  "sdd-onboard", "sdd-propose", "sdd-spec", "sdd-tasks", "sdd-verify"
+]);
+
+/** Map Gentle/Claude tier names → OpenCode provider/model ids. */
+export const CLAUDE_TO_OPENCODE = Object.freeze({
+  opus: "opencode-go/deepseek-v4-pro",
+  sonnet: "opencode-go/qwen3.5-plus",
+  haiku: "opencode-go/deepseek-v4-flash"
+});
+
+export async function loadGentleClaudeAssignments(homeDir, read = readFile) {
+  try {
+    const state = JSON.parse(await read(join(homeDir, ".gentle-ai", "state.json"), "utf8"));
+    const map = state?.claude_model_assignments;
+    if (!map || typeof map !== "object") return null;
+    return { ...map };
+  } catch {
+    return null;
+  }
+}
+
+export function mapClaudeAssignmentsToOpenCode(assignments = {}) {
+  const out = {};
+  for (const [agent, tier] of Object.entries(assignments)) {
+    if (agent === "default" || agent === "codex_default") continue;
+    const key = String(tier ?? "").toLowerCase();
+    out[agent] = CLAUDE_TO_OPENCODE[key] ?? CLAUDE_TO_OPENCODE.sonnet;
+  }
+  return out;
+}

package/src/global/ink/cockpit-controller.js

@@ -29,7 +29,7 @@ export {
 export function createCockpitUiState({
   layoutMode = LAYOUT_MODES.COMPACT,
   view = ORCHESTRATOR_VIEWS.HOME,
-  region = COCKPIT_REGIONS.NAV,
+  region = null,
   navIndex = 0,
   listIndex = 0,
   helpOpen = false,

package/src/global/ink/cockpit-models.js

@@ -328,8 +328,11 @@ export function buildFooterModel({
 
   // HOME footer must stay on one line at 80 cols (frame already near 24 rows).
   if (view === ORCHESTRATOR_VIEWS.HOME) {
+    const homeParts = region === COCKPIT_REGIONS.NAV
+      ? ["↑↓ Section", "Enter Open", "? Help", "Esc Exit"]
+      : ["1·2 Select", "Enter Run", "? Help", "Esc Exit"];
     return {
-      text: ["↑↓", "Enter", "Tab", "Space", "R", "?", "/", "Esc"].join(` ${glyphs.bullet} `),
+      text: homeParts.join(` ${glyphs.bullet} `),
       columns: footerColumns
     };
   }

package/src/global/ink/orchestrator-app.js

@@ -63,8 +63,7 @@ export function OrchestratorApp({
   const [ui, dispatch] = useReducer(
     reduceCockpitUi,
     createCockpitUiState({
-      layoutMode: layoutMode ?? LAYOUT_MODES.COMPACT,
-      region: COCKPIT_REGIONS.NAV
+      layoutMode: layoutMode ?? LAYOUT_MODES.COMPACT
     })
   );
   const data = useOrchestratorData({
@@ -166,6 +165,26 @@ export function OrchestratorApp({
       return;
     }
 
+    if (ui.view === ORCHESTRATOR_VIEWS.HOME && !ui.paletteOpen) {
+      const digit = inputKey === "1" ? 0 : inputKey === "2" ? 1 : -1;
+      if (digit >= 0) {
+        const buttons = buildOverviewButtons({
+          hasGlobalState,
+          snapshot: data.snapshot,
+          diagnostics: data.diagnostics,
+          dashboard: data.dashboard
+        });
+        const selected = buttons[digit];
+        const intent = selected?.intent ?? null;
+        if (intent === "setup") {
+          finish({ cancelled: false, action: "setup" });
+          return;
+        }
+        if (intent && openDestination(intent)) return;
+        return;
+      }
+    }
+
     if (inputKey === " " && ui.view === ORCHESTRATOR_VIEWS.HOME && !ui.paletteOpen) {
       dispatch({ type: "toggle-overview-details" });
       return;

package/src/global/ink/ux/live-overview.js

@@ -94,12 +94,6 @@ export function adaptControlCenterToOverview(model = {}, options = {}) {
       label: `Alerts · ${model.alerts.headline ?? `${model.alerts.count} open`}`
     });
   }
-  if (rest.length > 0) {
-    metrics.push({
-      id: "more",
-      label: `${rest.length} more in Details · Space`
-    });
-  }
   if (metrics.length === 0) {
     metrics.push({ id: "quiet", label: "Nothing else needs you right now" });
   }
@@ -201,13 +195,13 @@ export function SemanticOverviewPanel({
           marginBottom: index === view.buttons.length - 1 ? 0 : 1
         },
           React.createElement(Text, {
-            bold: true,
-            color: focused && colorEnabled ? COCKPIT_COLORS.interactive : undefined
-          }, `${focused ? glyphs.focus : " "} ${button.label}`),
+            bold: selected,
+            color: colorEnabled && selected ? COCKPIT_COLORS.interactive : undefined
+          }, `${selected ? glyphs.focus : " "} [${index + 1}] ${button.label}${focused ? "  ← Press Enter" : ""}`),
           button.detail
             ? React.createElement(Text, {
               color: colorEnabled ? COCKPIT_COLORS.muted : undefined
-            }, `  ${button.detail}`)
+            }, `      ${button.detail}`)
             : null
         );
       })
@@ -223,7 +217,7 @@ export function SemanticOverviewPanel({
     ),
     React.createElement(Details, {
       open: detailsOpen,
-      summary: "More info",
+      summary: `More info (${view.details.length})`,
       lines: view.details,
       colorEnabled,
       focused: false,

package/src/global/ink/ux/overview-needs.js

@@ -4,7 +4,7 @@
 import { CONTROL_PLANE_HEALTH } from "../../control-plane-snapshot.js";
 import { formatCliCommand } from "../../brand/cli.js";
 
-export const OVERVIEW_NEED_LIMIT = 3;
+export const OVERVIEW_NEED_LIMIT = 2;
 
 /** Prefixes that never belong on the first screen (machine / internals). */
 export const DETAILS_ONLY_PREFIXES = [

package/src/global/integrations/engram-evidence.js

@@ -215,12 +215,17 @@ function jsonKeyEvidence(path, keyPath, kind) {
   try {
     let cursor = JSON.parse(readFileSync(path, "utf8"));
     for (const key of keyPath) {
-      if (cursor == null || typeof cursor !== "object") {
+      if (cursor == null || typeof cursor !== "object" || Array.isArray(cursor)) {
         return { path, kind, present: false, conflict: true, keyPath, detail: "invalid structure" };
       }
+      // Missing key = unconfigured evidence, not a conflict (file may use another MCP path).
+      if (!Object.prototype.hasOwnProperty.call(cursor, key)) {
+        return { path, kind, present: false, conflict: false, keyPath };
+      }
       cursor = cursor[key];
     }
-    return { path, kind, present: cursor != null && typeof cursor === "object", conflict: false, keyPath };
+    const present = cursor != null && typeof cursor === "object" && !Array.isArray(cursor);
+    return { path, kind, present, conflict: false, keyPath };
   } catch {
     return { path, kind, present: false, conflict: true, keyPath, detail: "unreadable json" };
   }

package/src/global/integrations/sdd-apply.js

@@ -17,7 +17,8 @@ const APPLYING_ACTIONS = new Set([SDD_PLAN_ACTIONS.CREATE, SDD_PLAN_ACTIONS.UPDA
 
 export async function applySddConfigure({
   requestedAgentIds = null, detectedAgentIds = [], homeDir, packageRoot, persona = "off",
-  personaAgentIds = [], trackedFiles = {}, preservePersona = false, dryRun = false, yes = false,
+  personaAgentIds = [], trackedFiles = {}, adoptedFiles = {}, overwriteConflicts = false,
+  preservePersona = false, dryRun = false, yes = false,
   json = false, interactive = null, receiptId = null, plan = planSddConfigure,
   confirm = promptApplyConfirmation, saveReceipt = saveSddReceipt,
   now = () => new Date().toISOString()
@@ -28,14 +29,16 @@ export async function applySddConfigure({
 
   const planned = await plan({
     requestedAgentIds, detectedAgentIds, homeDir, packageRoot, persona, personaAgentIds,
-    trackedFiles, preservePersona, dryRun: true
+    trackedFiles, adoptedFiles, overwriteConflicts, preservePersona, dryRun: true
   });
   if (dryRun) return { ...planned, applied: false, cancelled: false, receipt: null };
 
   if (shouldPromptApplyConfirmation({ applying: true, dryRun, json, confirm: yes, interactive })) {
     const accepted = await confirm({
       command: "components configure sdd-core",
-      question: "Materialize SDD skills for the planned agents? [Y/n]: "
+      question: overwriteConflicts
+        ? "Overwrite conflicting SDD skills with canonical Kairo copies (backups first)? [Y/n]: "
+        : "Materialize SDD skills for the planned agents? [Y/n]: "
     });
     if (!accepted) return { ...planned, applied: false, cancelled: true, receipt: null };
   }
@@ -66,7 +69,8 @@ export async function applySddConfigure({
     try {
       const managedRoot = resolveSddSkillRoot(action.agentIds[0], homeDir);
       const outcome = await materializeOne(action, {
-        homeDir, packageRoot, managedRoot, receiptId: resolvedReceiptId
+        homeDir, packageRoot, managedRoot, receiptId: resolvedReceiptId,
+        overwriteConflicts: Boolean(action.overwrote || overwriteConflicts)
       });
       if (outcome.conflict) {
         files.push({
@@ -78,7 +82,8 @@ export async function applySddConfigure({
       if (outcome.backup) backups.push(outcome.backup);
       files.push({
         ...record, applied: true, skipped: false, outcome: SDD_FILE_OUTCOMES.APPLIED,
-        afterHash: outcome.afterHash, parentRealpath: outcome.parentRealpath
+        afterHash: outcome.afterHash, parentRealpath: outcome.parentRealpath,
+        overwrote: Boolean(action.overwrote)
       });
     } catch (error) {
       failed = { skillId: action.skillId, destinationPath: action.destinationPath, error: error.message };
@@ -141,7 +146,9 @@ async function readCanonicalBytes(action, packageRoot) {
   ));
 }
 
-async function materializeOne(action, { homeDir, packageRoot, managedRoot, receiptId }) {
+async function materializeOne(action, {
+  homeDir, packageRoot, managedRoot, receiptId, overwriteConflicts = false
+}) {
   const chain = await assertSafePathChain(action.destinationPath, managedRoot, homeDir);
   if (!chain.ok) return { conflict: chain.reason };
 
@@ -169,7 +176,10 @@ async function materializeOne(action, { homeDir, packageRoot, managedRoot, recei
     return { conflict: "Managed destination disappeared after planning; preserving byte-for-byte." };
   }
   const snap = await snapshotRegularFile(action.destinationPath);
-  if (snap.hash !== action.trackedHash) {
+  const expectedHash = overwriteConflicts || action.overwrote
+    ? snap.hash
+    : action.trackedHash;
+  if (snap.hash !== expectedHash) {
     return { conflict: "Managed file changed after planning; preserving byte-for-byte." };
   }
   const parent = await parentRealpath(action.destinationPath);

package/src/global/integrations/sdd-evidence.js

@@ -16,6 +16,7 @@ export const SDD_FILE_OUTCOMES = Object.freeze({
 
 export const SDD_HEALTH = Object.freeze({
   CONFIGURED: "configured",
+  ADOPTED: "adopted",
   MISSING: "missing",
   DRIFTED: "drifted",
   CONFLICT: "conflict"
@@ -23,13 +24,16 @@ export const SDD_HEALTH = Object.freeze({
 
 /**
  * Classify one destination file against canonical bytes and optional tracked hash.
- * Untracked or user-modified files are conflicts and must never be overwritten.
+ * Untracked or user-modified files are conflicts and must never be overwritten
+ * unless overwriteConflicts is requested at apply time.
+ * adoptedHash (disk content accepted as-is) yields NOOP without claiming managed.
  */
 export function classifySddSkillFile({
   exists,
   canonicalHash,
   diskHash = null,
-  trackedHash = null
+  trackedHash = null,
+  adoptedHash = null
 } = {}) {
   if (!exists) {
     return {
@@ -38,6 +42,13 @@ export function classifySddSkillFile({
     };
   }
 
+  if (adoptedHash != null && adoptedHash === diskHash) {
+    return {
+      action: SDD_PLAN_ACTIONS.NOOP,
+      reason: "Adopted disk bytes; preserving byte-for-byte."
+    };
+  }
+
   if (trackedHash == null) {
     return {
       action: SDD_PLAN_ACTIONS.CONFLICT,
@@ -70,11 +81,19 @@ export function classifySddVerifyHealth({
   exists,
   canonicalHash,
   diskHash = null,
-  trackedHash = null
+  trackedHash = null,
+  adoptedHash = null
 } = {}) {
   if (!exists) {
     return { status: SDD_HEALTH.MISSING, drift: null, reason: "Destination missing on disk." };
   }
+  if (adoptedHash != null && adoptedHash === diskHash) {
+    return {
+      status: SDD_HEALTH.ADOPTED,
+      drift: null,
+      reason: "Disk matches adopted hash (not Kairo-managed)."
+    };
+  }
   if (trackedHash == null) {
     return { status: SDD_HEALTH.CONFLICT, drift: null, reason: "Pre-existing untracked file." };
   }

package/src/global/integrations/sdd-plan.js

@@ -25,6 +25,8 @@ export async function planSddConfigure({
   persona = "off",
   personaAgentIds = [],
   trackedFiles = {},
+  adoptedFiles = {},
+  overwriteConflicts = false,
   preservePersona = false,
   dryRun = true,
   exists = existsSync,
@@ -50,16 +52,31 @@ export async function planSddConfigure({
       for (const group of destinationGroups) {
         const destinationPath = join(group.root, skillId, ...file.relativePath.split("/"));
         const trackedHash = trackedFiles[destinationPath] ?? null;
+        const adoptedHash = adoptedFiles[destinationPath] ?? null;
         const fileExists = exists(destinationPath);
         const diskHash = fileExists ? hashBuffer(await readFileImpl(destinationPath)) : null;
-        const classification = classifySddSkillFile({
-          exists: fileExists, canonicalHash, diskHash, trackedHash
+        let classification = classifySddSkillFile({
+          exists: fileExists, canonicalHash, diskHash, trackedHash, adoptedHash
         });
+        let overwrote = false;
+        if (
+          overwriteConflicts
+          && classification.action === SDD_PLAN_ACTIONS.CONFLICT
+          && fileExists
+        ) {
+          classification = {
+            action: SDD_PLAN_ACTIONS.UPDATE,
+            reason: "Overwrite conflicts requested; backup then replace with canonical."
+          };
+          overwrote = true;
+        }
         actions.push({
           skillId, relativePath: file.relativePath, destinationPath,
           agentIds: [...group.agentIds], kind: group.kind,
           action: classification.action, reason: classification.reason,
-          canonicalHash, skillHash, diskHash, trackedHash, writes: false, executes: false
+          canonicalHash, skillHash, diskHash, trackedHash, adoptedHash,
+          overwrote, overwriteConflicts: Boolean(overwriteConflicts),
+          writes: false, executes: false
         });
       }
     }
@@ -78,6 +95,7 @@ export async function planSddConfigure({
   return {
     provider: "sdd-core", componentId: "sdd-core", dryRun: Boolean(dryRun),
     executes: false, writes: false, requestedPersona: persona, preservePersona,
+    overwriteConflicts: Boolean(overwriteConflicts),
     persona: personaTransition.persona,
     personaPath: resolveCanonicalTeachingPersonaPath(packageRoot),
     personaActive: personaTransition.after.length > 0, personaTransition, agentIds, actions,

package/src/global/integrations/sdd-resolutions.js

@@ -0,0 +1,73 @@
+import { formatCliCommand } from "../brand/cli.js";
+import { resolution, RESOLUTION_KIND, RESOLUTION_SAFETY } from "../check-resolutions.js";
+import { SDD_HEALTH } from "./sdd-evidence.js";
+
+/**
+ * Build panel/CLI resolution buttons for sdd-core:skills from verify findings.
+ * Agent list is derived from conflict/drifted findings so buttons scope correctly.
+ */
+export function buildSddSkillResolutions(verification = {}) {
+  const summary = verification.summary ?? {};
+  const conflictCount = summary.conflict ?? 0;
+  const driftedCount = summary.drifted ?? 0;
+  if (conflictCount === 0 && driftedCount === 0) return [];
+
+  const agentIds = conflictAgentIds(verification.findings ?? []);
+  const agentsFlag = agentIds.length ? ` --agents ${agentIds.join(",")}` : "";
+
+  return [
+    resolution(
+      "sdd-diff",
+      "Ver diff",
+      formatCliCommand(`components diff sdd-core${agentsFlag}`),
+      {
+        kind: RESOLUTION_KIND.RUN,
+        safety: RESOLUTION_SAFETY.READ_ONLY,
+        detail: "Read-only: canonical Kairo skills vs disk."
+      }
+    ),
+    resolution(
+      "sdd-adopt",
+      "Conservar el mío",
+      formatCliCommand(`components adopt sdd-core${agentsFlag} --yes`),
+      {
+        kind: RESOLUTION_KIND.CONFIGURE,
+        safety: RESOLUTION_SAFETY.CONSENT,
+        detail: "Adopt disk bytes into Kairo state without overwriting files. Button click is consent."
+      }
+    ),
+    resolution(
+      "sdd-overwrite",
+      "Usar versión Kairo",
+      formatCliCommand(`components configure sdd-core${agentsFlag} --overwrite-conflicts --yes`),
+      {
+        kind: RESOLUTION_KIND.CONFIGURE,
+        safety: RESOLUTION_SAFETY.DESTRUCTIVE,
+        detail: "Backup then replace conflicting files with canonical Kairo skills."
+      }
+    ),
+    resolution(
+      "doctor",
+      "Doctor",
+      formatCliCommand("doctor"),
+      { kind: RESOLUTION_KIND.RUN, safety: RESOLUTION_SAFETY.READ_ONLY }
+    ),
+    resolution(
+      "refresh",
+      "Refresh",
+      null,
+      { kind: RESOLUTION_KIND.REFRESH, safety: RESOLUTION_SAFETY.READ_ONLY }
+    )
+  ];
+}
+
+function conflictAgentIds(findings) {
+  const ids = new Set();
+  for (const finding of findings) {
+    if (finding?.status !== SDD_HEALTH.CONFLICT && finding?.status !== SDD_HEALTH.DRIFTED) {
+      continue;
+    }
+    for (const id of finding.agentIds ?? []) ids.add(id);
+  }
+  return [...ids].sort();
+}