@kal-elsam/kairo-runtime 0.13.1 → 0.15.0

package/src/global/connections.js

@@ -0,0 +1,269 @@
+/**
+ * Connection chips for IDE panel / CLI — companion probes + agent MCP registration.
+ * Read-only; never mutates configs.
+ */
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { resolveHomeDir } from "./paths.js";
+import { buildCompanionSnapshot } from "./observability/build-companion-snapshot.js";
+import { runPassiveObservabilitySnapshot } from "./observability/passive-snapshot-flight.js";
+import { inspectEngramIntegration } from "./integrations/engram-evidence.js";
+import { resolveGitHeadSha } from "./observability/graphify-probe.js";
+import { enrichConnection } from "./connection-actions.js";
+import { buildFleetReport } from "./observability/fleet-probe.js";
+
+export const CONNECTION_ACCESS = Object.freeze({
+  gentle: "Probe contract; export/import review bundles (import needs consent).",
+  hermes: "Read-only: sessions via loopback API. Never runs hermes doctor/status.",
+  engram: "Disk evidence + engram version; setup needs consent.",
+  graphify: "Read-only: query, path, explain on workspace graph.",
+  agent: "MCP tools for Cursor agents (status, runs, alerts, graph)."
+});
+
+export const MCP_CLIENTS = Object.freeze({
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    configRelativePath: join(".cursor", "mcp.json")
+  }
+});
+
+function chip(id, label, state, access, detail) {
+  return enrichConnection({
+    id,
+    label,
+    state: typeof state === "string" && state ? state : "unknown",
+    access,
+    detail: typeof detail === "string" && detail ? detail : ""
+  });
+}
+
+function gentleDetail(state) {
+  switch (state) {
+    case "available":
+      return "Gentle AI is available for review-bundle export/import.";
+    case "missing":
+      return "Install gentle-ai separately, then Refresh.";
+    case "incompatible":
+      return "Gentle is present but the review contract is incompatible.";
+    case "error":
+      return "Gentle probe failed. Check PATH and try Doctor.";
+    default:
+      return `Gentle state: ${state}.`;
+  }
+}
+
+function hermesDetail(state) {
+  switch (state) {
+    case "available":
+      return "Hermes loopback API is reachable; sessions are read-only.";
+    case "missing":
+      return "Install Hermes Agent separately, then Refresh.";
+    case "auth_required":
+      return "Hermes API requires auth (KAIRO_HERMES_API_KEY).";
+    case "incompatible":
+      return "Hermes is present but the local API contract is incompatible.";
+    case "unavailable":
+    case "error":
+      return "Hermes binary found, but loopback API (http://127.0.0.1:8642) is down. Everyday chat is `hermes` (see https://hermes-ai.net/es/docs/quickstart/). For the Kairo chip: set API_SERVER_ENABLED=true in ~/.hermes/.env, run hermes gateway run, then Refresh. Optional.";
+    default:
+      return `Hermes state: ${state}.`;
+  }
+}
+
+function engramDetail(status) {
+  switch (status) {
+    case "configured":
+      return "Engram integration evidence looks configured on disk.";
+    case "available":
+      return "Engram binary found; some agents still need configure.";
+    case "unconfigured":
+      return "Engram binary found; configure via Settings or components configure.";
+    case "missing":
+      return "Engram not detected. Optional memory — governance still works.";
+    case "conflict":
+      return "Engram config conflict. Open Settings → Engram.";
+    case "restart_required":
+      return "Engram config written; restart the agent to activate MCP tools.";
+    case "unsupported":
+      return "Engram version unsupported by this Kairo contract.";
+    case "error":
+      return "Engram inspection failed.";
+    default:
+      return `Engram status: ${status}.`;
+  }
+}
+
+function graphifyDetail(state, graphStatus) {
+  if (graphStatus === "stale") {
+    return "Graph exists but may be stale vs git HEAD. Run graphify update .";
+  }
+  if (graphStatus === "missing") {
+    return "No graphify-out/graph.json. Run graphify update . in the workspace.";
+  }
+  if (state === "available" && (graphStatus === "ok" || graphStatus == null)) {
+    return "Graphify CLI available; graph ready for query/path/explain.";
+  }
+  if (state === "missing") {
+    return "Install graphify separately, then Refresh.";
+  }
+  if (state === "error" || graphStatus === "error" || graphStatus === "malformed") {
+    return "Graphify probe failed or graph is malformed.";
+  }
+  return `Graphify state: ${state}${graphStatus ? ` / ${graphStatus}` : ""}.`;
+}
+
+export function resolveMcpConfigPath(client = "cursor", { homeDir = resolveHomeDir() } = {}) {
+  const entry = MCP_CLIENTS[client] ?? MCP_CLIENTS.cursor;
+  return join(homeDir, entry.configRelativePath);
+}
+
+/** Healthy Cursor entry must include cwd: "." (legacy without cwd → Repair).
+ * Runtime workspace identity still prefers VSCODE_CWD when Cursor spawns under $HOME.
+ */
+export function isHealthyKairoMcpEntry(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+  if (entry.command !== "kairo") return false;
+  if (!Array.isArray(entry.args) || entry.args.length !== 1 || entry.args[0] !== "mcp") {
+    return false;
+  }
+  return entry.cwd === ".";
+}
+
+/**
+ * Read-only: is Kairo registered under mcpServers.kairo for the client?
+ * Entries without cwd: "." are broken (Repair), not connected.
+ */
+export async function detectAgentMcpRegistration({
+  client = "cursor",
+  homeDir = resolveHomeDir(),
+  readFileFn = readFile
+} = {}) {
+  const path = resolveMcpConfigPath(client, { homeDir });
+  try {
+    const raw = await readFileFn(path, "utf8");
+    const parsed = JSON.parse(raw);
+    const entry = parsed?.mcpServers?.kairo;
+    if (entry && typeof entry === "object") {
+      if (isHealthyKairoMcpEntry(entry)) {
+        return {
+          connected: true,
+          state: "connected",
+          path,
+          detail: `Kairo MCP registered in ${path}. Reload Cursor MCP if tools are missing.`
+        };
+      }
+      return {
+        connected: false,
+        state: "error",
+        path,
+        detail: "Kairo MCP entry is unhealthy (require command kairo, args [mcp], cwd \".\"). Re-run kairo mcp install --yes."
+      };
+    }
+    return {
+      connected: false,
+      state: "not_connected",
+      path,
+      detail: "Kairo MCP is not registered. Click Connect Agent (opens kairo mcp install)."
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return {
+        connected: false,
+        state: "not_connected",
+        path,
+        detail: "No Cursor MCP config yet. Click Connect Agent to create one."
+      };
+    }
+    return {
+      connected: false,
+      state: "error",
+      path,
+      detail: `Could not read ${path}: ${error?.message ?? error}`
+    };
+  }
+}
+
+/**
+ * Pure adapter: companion snapshot (+ optional agent registration) → connection chips.
+ */
+export function mapCompanionToConnections(companion = {}, agent = null) {
+  const gentleState = companion?.signals?.gentle?.state ?? "missing";
+  const hermesState = companion?.signals?.hermes?.activity?.state
+    ?? companion?.signals?.hermes?.state
+    ?? "missing";
+  const engramStatus = companion?.engram?.status ?? "missing";
+  const graphifyState = companion?.signals?.graphify?.state ?? "missing";
+  const graphStatus = companion?.signals?.graphify?.graphStatus ?? null;
+
+  const connections = [
+    chip("gentle", "Gentle", gentleState, CONNECTION_ACCESS.gentle, gentleDetail(gentleState)),
+    chip("hermes", "Hermes", hermesState, CONNECTION_ACCESS.hermes, hermesDetail(hermesState)),
+    chip("engram", "Engram", engramStatus, CONNECTION_ACCESS.engram, engramDetail(engramStatus)),
+    chip(
+      "graphify",
+      "Graphify",
+      graphStatus === "stale" ? "stale" : graphifyState,
+      CONNECTION_ACCESS.graphify,
+      graphifyDetail(graphifyState, graphStatus)
+    )
+  ];
+
+  if (agent) {
+    connections.push(chip(
+      "agent",
+      "Agent",
+      agent.state ?? (agent.connected ? "connected" : "not_connected"),
+      CONNECTION_ACCESS.agent,
+      agent.detail ?? ""
+    ));
+  }
+
+  return connections;
+}
+
+export async function buildConnectionsReport({
+  homeDir = resolveHomeDir(),
+  workspaceRoot = process.cwd(),
+  client = "cursor",
+  packageRoot = null,
+  packageName = null,
+  cliVersion = null,
+  buildCompanion = buildCompanionSnapshot,
+  buildObservability = (ctx) => runPassiveObservabilitySnapshot(ctx),
+  inspectEngram = inspectEngramIntegration,
+  detectAgent = detectAgentMcpRegistration,
+  resolveHead = resolveGitHeadSha,
+  buildFleet = buildFleetReport
+} = {}) {
+  const cwd = workspaceRoot ?? process.cwd();
+  const headSha = typeof resolveHead === "function" ? resolveHead(cwd) : null;
+  const companion = await buildCompanion({
+    inspectEngram: (ctx) => inspectEngram({ homeDir, ...(ctx ?? {}) }),
+    buildObservability,
+    observabilityContext: {
+      cwd,
+      homeDir,
+      workspaceRoot: cwd,
+      headSha,
+      packageRoot,
+      packageName,
+      cliVersion
+    }
+  });
+  const agent = await detectAgent({ client, homeDir });
+  const connections = mapCompanionToConnections(companion, agent);
+  const fleet = typeof buildFleet === "function"
+    ? await buildFleet({ homeDir })
+    : { ok: true, fleets: [] };
+  return {
+    ok: companion?.ok !== false,
+    generatedAt: companion?.generatedAt ?? new Date().toISOString(),
+    client,
+    connections,
+    fleets: fleet?.fleets ?? [],
+    activity: fleet?.activity ?? null,
+    fleetNote: fleet?.note ?? "Declared config topology — not live token usage.",
+    orchestratorAuthority: fleet?.orchestratorAuthority ?? null
+  };
+}

package/src/global/fleet-configure-plan.js

@@ -0,0 +1,123 @@
+/**
+ * Plan builders for fleet configure (kept separate to stay under file size budget).
+ */
+import { join } from "node:path";
+import {
+  parseFrontmatterModel,
+  replaceFrontmatterModel,
+  replaceCodexDefaultModel,
+  parseCodexDefaultModel
+} from "./observability/fleet-platforms.js";
+import { buildOpenCodeFleetSetPlan } from "./fleet-set.js";
+import { SDD_PHASES } from "./fleet-shared.js";
+
+export async function planClaudeChanges(source, homeDir, pathExists, read) {
+  const changes = [];
+  const settingsPath = join(homeDir, ".claude", "settings.json");
+  if (await pathExists(settingsPath)) {
+    const settings = JSON.parse(await read(settingsPath, "utf8"));
+    const nextDefault = source.default ?? settings.model ?? "sonnet";
+    if (settings.model !== nextDefault) {
+      changes.push({
+        platform: "claude",
+        agent: "default",
+        path: settingsPath,
+        previousModel: settings.model ?? null,
+        model: nextDefault,
+        kind: "json",
+        next: { ...settings, model: nextDefault }
+      });
+    }
+  }
+  for (const phase of SDD_PHASES) {
+    if (!source[phase]) continue;
+    const path = join(homeDir, ".claude", "agents", `${phase}.md`);
+    if (!(await pathExists(path))) continue;
+    const raw = await read(path, "utf8");
+    const previousModel = parseFrontmatterModel(raw).model;
+    const model = source[phase];
+    if (previousModel === model) continue;
+    changes.push({
+      platform: "claude",
+      agent: phase,
+      path,
+      previousModel,
+      model,
+      kind: "text",
+      nextText: replaceFrontmatterModel(raw, model)
+    });
+  }
+  return changes;
+}
+
+export async function planOpenCodeChanges(opencodeMap, homeDir, pathExists, read) {
+  const configPath = join(homeDir, ".config", "opencode", "opencode.json");
+  if (!(await pathExists(configPath))) return [];
+  const config = JSON.parse(await read(configPath, "utf8"));
+  let nextConfig = config;
+  const detail = [];
+  for (const [agent, model] of Object.entries(opencodeMap)) {
+    try {
+      const step = buildOpenCodeFleetSetPlan({
+        config: nextConfig, agent, model, configPath
+      });
+      if (step.wouldWrite) {
+        detail.push(`${agent}: ${step.previousModel ?? "—"} → ${model}`);
+        nextConfig = step.next;
+      }
+    } catch {
+      /* agent missing — skip */
+    }
+  }
+  if (!detail.length) return [];
+  return [{
+    platform: "opencode",
+    agent: "batch",
+    path: configPath,
+    previousModel: `${detail.length} agents`,
+    model: `${detail.length} agents`,
+    kind: "json",
+    next: nextConfig,
+    detail
+  }];
+}
+
+export async function planCursorChanges(cursorModel, homeDir, pathExists, read) {
+  const changes = [];
+  const model = cursorModel || "inherit";
+  for (const phase of SDD_PHASES) {
+    const path = join(homeDir, ".cursor", "agents", `${phase}.md`);
+    if (!(await pathExists(path))) continue;
+    const raw = await read(path, "utf8");
+    const previousModel = parseFrontmatterModel(raw).model;
+    if (previousModel === model) continue;
+    changes.push({
+      platform: "cursor",
+      agent: phase,
+      path,
+      previousModel,
+      model,
+      kind: "text",
+      nextText: replaceFrontmatterModel(raw, model)
+    });
+  }
+  return changes;
+}
+
+export async function planCodexChange(codexModel, homeDir, pathExists, read) {
+  if (!codexModel) return [];
+  const configPath = join(homeDir, ".codex", "config.toml");
+  if (!(await pathExists(configPath))) return [];
+  const raw = await read(configPath, "utf8");
+  const previousModel = parseCodexDefaultModel(raw);
+  if (previousModel === codexModel) return [];
+  return [{
+    platform: "codex",
+    agent: "default",
+    path: configPath,
+    previousModel,
+    model: codexModel,
+    kind: "text",
+    nextText: replaceCodexDefaultModel(raw, codexModel)
+  }];
+}

package/src/global/fleet-configure.js

@@ -0,0 +1,303 @@
+/**
+ * Cross-platform fleet model configure (Gentle-style assignments).
+ * Default: one plan for all multi-agent platforms (claude + opencode + cursor).
+ * Codex is single-model — pass --codex-model separately (never mixed into phase map).
+ * Plan by default; --yes applies with backups. Never Cursor Auto / state.vscdb.
+ */
+import { copyFile, readFile, writeFile, access, mkdir } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+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 {
+  SDD_PHASES,
+  CLAUDE_TO_OPENCODE,
+  loadGentleClaudeAssignments,
+  mapClaudeAssignmentsToOpenCode
+} from "./fleet-shared.js";
+import {
+  loadFleetProfile,
+  saveFleetProfile,
+  seedFleetProfile,
+  profileToPlatformAssignments
+} from "./fleet-models.js";
+import {
+  planClaudeChanges,
+  planOpenCodeChanges,
+  planCursorChanges,
+  planCodexChange
+} from "./fleet-configure-plan.js";
+
+export {
+  SDD_PHASES,
+  CLAUDE_TO_OPENCODE,
+  loadGentleClaudeAssignments,
+  mapClaudeAssignmentsToOpenCode
+};
+export { runFleetModels } from "./fleet-models.js";
+
+/** Multi-agent fleet — Codex is opt-in via --codex-model / --platforms codex. */
+const DEFAULT_PLATFORMS = Object.freeze(["claude", "opencode", "cursor"]);
+const MULTI_PLATFORMS = Object.freeze(["claude", "opencode", "cursor"]);
+
+function backupPath(path, stamp = Date.now()) {
+  return `${path}.kairo-backup.${stamp}`;
+}
+
+async function exists(path) {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function parseAssignmentList(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "string") return out;
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq <= 0) throw new Error(`Invalid assignment "${trimmed}". Use agent=model.`);
+    const agent = trimmed.slice(0, eq).trim();
+    const model = trimmed.slice(eq + 1).trim();
+    if (!agent || !model) throw new Error(`Invalid assignment "${trimmed}". Use agent=model.`);
+    out[agent] = model;
+  }
+  return out;
+}
+
+export function parsePlatformList(raw) {
+  if (!raw || typeof raw !== "string") return [...DEFAULT_PLATFORMS];
+  const list = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  for (const p of list) {
+    if (!["opencode", "claude", "codex", "cursor"].includes(p)) {
+      throw new Error(`Unsupported platform "${p}". Use opencode,claude,cursor,codex.`);
+    }
+  }
+  return list.length ? list : [...DEFAULT_PLATFORMS];
+}
+
+/**
+ * Build a multi-platform configure plan.
+ * Prefer --from profile (disk-seeded) so OpenCode keeps tuned models;
+ * --from gentle remaps OpenCode via Claude tiers.
+ */
+export async function buildFleetConfigurePlan({
+  homeDir = resolveHomeDir(),
+  platforms = DEFAULT_PLATFORMS,
+  from = "profile",
+  assignments = null,
+  codexModel = null,
+  remapOpenCode = null,
+  read = readFile,
+  pathExists = exists
+} = {}) {
+  const platformSet = new Set(platforms);
+  let sourceLabel = "explicit";
+  let claudeSource = null;
+  let opencodeMap = {};
+  let cursorAgentModel = "inherit";
+  let profileSnapshot = null;
+  let nextCodex = codexModel;
+
+  if (assignments && Object.keys(assignments).length) {
+    sourceLabel = "explicit";
+    claudeSource = { ...assignments };
+    opencodeMap = mapClaudeAssignmentsToOpenCode(claudeSource);
+    if (assignments.codex_default) nextCodex = nextCodex || assignments.codex_default;
+  } else if (from === "gentle") {
+    sourceLabel = "gentle";
+    claudeSource = await loadGentleClaudeAssignments(homeDir, read);
+    if (!claudeSource) {
+      throw new Error(
+        "No Gentle assignments found. Pass --assignments …, use --from profile, or configure Gentle first."
+      );
+    }
+    opencodeMap = remapOpenCode !== false ? mapClaudeAssignmentsToOpenCode(claudeSource) : {};
+  } else {
+    sourceLabel = "profile";
+    const { profile } = await loadFleetProfile({ homeDir, read, seedIfMissing: true });
+    profileSnapshot = profile;
+    const maps = profileToPlatformAssignments(profile);
+    claudeSource = maps.claude;
+    opencodeMap = maps.opencode;
+    cursorAgentModel = maps.cursorAgentModel;
+    if (platformSet.has("codex") && !nextCodex && profile.codexDefault) {
+      nextCodex = profile.codexDefault;
+    }
+  }
+
+  if (!claudeSource || !Object.keys(claudeSource).length) {
+    if (!platformSet.has("codex") || !nextCodex) {
+      throw new Error(
+        "No model assignments found. Use --from profile|gentle, --assignments, or --codex-model."
+      );
+    }
+    claudeSource = {};
+  }
+
+  const changes = [];
+  if (platformSet.has("claude") && Object.keys(claudeSource).length) {
+    changes.push(...await planClaudeChanges(claudeSource, homeDir, pathExists, read));
+  }
+  if (platformSet.has("opencode") && Object.keys(opencodeMap).length) {
+    changes.push(...await planOpenCodeChanges(opencodeMap, homeDir, pathExists, read));
+  }
+  if (platformSet.has("cursor")) {
+    changes.push(...await planCursorChanges(cursorAgentModel, homeDir, pathExists, read));
+  }
+  if (platformSet.has("codex") || nextCodex) {
+    changes.push(...await planCodexChange(nextCodex, homeDir, pathExists, read));
+  }
+
+  const multi = [...platformSet].filter((p) => MULTI_PLATFORMS.includes(p));
+  return {
+    ok: true,
+    applied: false,
+    source: sourceLabel,
+    platforms: [...platformSet],
+    multiAgentPlatforms: multi,
+    assignments: claudeSource,
+    opencodeMap,
+    codexModel: nextCodex ?? null,
+    cursorAgentModel,
+    profile: profileSnapshot,
+    changes,
+    note: [
+      "Default: one plan for multi-agent tools (Claude + OpenCode + Cursor agents).",
+      "Codex is single-model — use --codex-model <id> (or --platforms codex).",
+      "Cursor Auto chat model stays IDE-managed; agents use inherit.",
+      "See also: kairo fleet models"
+    ].join(" "),
+    applyWith: formatCliCommand(
+      nextCodex
+        ? `fleet configure --yes --codex-model ${nextCodex}`
+        : "fleet configure --yes"
+    )
+  };
+}
+
+export async function runFleetConfigure({
+  yes = false,
+  json = false,
+  platforms = null,
+  from = "profile",
+  assignmentsRaw = null,
+  codexModel = null,
+  remapOpenCode = null,
+  homeDir = resolveHomeDir(),
+  read = readFile,
+  writeText = writeFile,
+  copyFileFn = copyFile,
+  writeAtomicJsonFn = writeAtomicJson,
+  mkdirFn = mkdir,
+  now = () => Date.now()
+} = {}) {
+  let finalPlatforms;
+  if (platforms != null && String(platforms).trim() !== "") {
+    finalPlatforms = parsePlatformList(platforms);
+    if (codexModel && !finalPlatforms.includes("codex")) {
+      finalPlatforms = [...finalPlatforms, "codex"];
+    }
+  } else if (codexModel && !assignmentsRaw) {
+    finalPlatforms = ["codex"];
+  } else {
+    finalPlatforms = [...DEFAULT_PLATFORMS];
+  }
+
+  const assignments = assignmentsRaw ? parseAssignmentList(assignmentsRaw) : null;
+  const plan = await buildFleetConfigurePlan({
+    homeDir,
+    platforms: finalPlatforms,
+    from: assignments ? "explicit" : from,
+    assignments,
+    codexModel,
+    remapOpenCode,
+    read
+  });
+
+  if (!yes) {
+    if (json) printJson(plan);
+    else {
+      console.log(commandHeader("Fleet configure"));
+      console.log(`Source · ${plan.source}`);
+      console.log(`Multi-agent · ${(plan.multiAgentPlatforms ?? []).join(", ") || "—"}`);
+      console.log(`Platforms · ${plan.platforms.join(", ")}`);
+      if (plan.codexModel) console.log(`Codex · ${plan.codexModel}`);
+      if (plan.changes.length === 0) {
+        console.log("No changes needed — assignments already match disk.");
+      } else {
+        for (const c of plan.changes) {
+          if (c.detail) {
+            console.log(`${c.platform} · ${c.path}`);
+            for (const line of c.detail) console.log(`  ${line}`);
+          } else {
+            console.log(`${c.platform} · ${c.agent}: ${c.previousModel ?? "—"} → ${c.model}`);
+          }
+        }
+      }
+      console.log(plan.note);
+      console.log(`Apply · ${plan.applyWith}`);
+    }
+    return plan;
+  }
+
+  const stamp = now();
+  const receipts = [];
+  const written = new Set();
+  for (const change of plan.changes) {
+    if (written.has(change.path)) continue;
+    written.add(change.path);
+    const bak = backupPath(change.path, stamp);
+    await copyFileFn(change.path, bak);
+    if (change.kind === "json") {
+      await writeAtomicJsonFn(change.path, change.next);
+    } else {
+      await writeText(change.path, change.nextText, "utf8");
+    }
+    receipts.push({ path: change.path, backupPath: bak, platform: change.platform });
+  }
+
+  let profilePath = null;
+  let profile = plan.profile ?? await seedFleetProfile({ homeDir, read });
+  if (plan.assignments?.default) profile.claudeDefault = plan.assignments.default;
+  for (const id of SDD_PHASES) {
+    if (plan.assignments?.[id]) {
+      profile.phases[id] = profile.phases[id] ?? {};
+      profile.phases[id].claude = plan.assignments[id];
+    }
+    if (plan.opencodeMap?.[id]) {
+      profile.phases[id] = profile.phases[id] ?? {};
+      profile.phases[id].opencode = plan.opencodeMap[id];
+    }
+  }
+  if (plan.codexModel) profile.codexDefault = plan.codexModel;
+  profile.cursorAgentModel = plan.cursorAgentModel ?? "inherit";
+  const saved = await saveFleetProfile(profile, { homeDir, writeAtomicJsonFn, mkdirFn });
+  profilePath = saved.path;
+
+  const result = {
+    ok: true,
+    applied: true,
+    source: plan.source,
+    platforms: plan.platforms,
+    changeCount: plan.changes.length,
+    receipts,
+    profilePath,
+    note: "Applied. Multi-agent tools share the phase map; Codex is single-default. Refresh Fleet. kairo fleet models shows available/enabled."
+  };
+  if (json) printJson(result);
+  else {
+    console.log(commandHeader("Fleet configure"));
+    console.log(`Wrote · ${receipts.length} file(s)`);
+    for (const r of receipts) console.log(`  ${r.path} (backup ${r.backupPath})`);
+    if (profilePath) console.log(`Profile · ${profilePath}`);
+    console.log(result.note);
+  }
+  return result;
+}