@kal-elsam/kairo-runtime 0.14.0 → 0.16.0

package/src/global/control-plane/review-status.js

@@ -0,0 +1,115 @@
+/**
+ * Official Gentle review status v2/v3 only. Never read authority inventory.
+ */
+import { isAbsolute } from "node:path";
+import { SUPPORTED_CONTRACT } from "../observability/gentle-probe.js";
+
+export const REVIEW_STATUS_SCHEMAS = Object.freeze([
+  "gentle-ai.review-integration.status/v2",
+  "gentle-ai.review-integration.status/v3"
+]);
+
+const INVENTORY_SCHEMA = "gentle-ai.review-authority-status/v1";
+const UNSAFE_TOKEN = /[|;&$`\n\r]/;
+const PLACEHOLDER = /^<[^>]+>$/;
+
+export const GENTLE_224_BOOTSTRAP =
+  "gentle-ai review status --cwd <repo> --contract gentle-ai.review-integration/v2 --next-transition";
+export const GENTLE_230_BOOTSTRAP =
+  "gentle-ai review status --cwd <repo> --contract gentle-ai.review-integration/v2 --agent claude-code --next-transition";
+
+const failArgv = () => ({ ok: false, error: "gentle_incompatible", binary: null, argv: null });
+
+export function bootstrapCommandFromProbe(probe) {
+  return probe?.evidence?.find((row) => row?.kind === "bootstrap" && row.command)?.command ?? null;
+}
+
+export function argvFromBootstrap(command, { repo, binaryPath }) {
+  if (typeof command !== "string" || !command.trim() || UNSAFE_TOKEN.test(command)) return failArgv();
+  if (typeof binaryPath !== "string" || !isAbsolute(binaryPath)) return failArgv();
+  if (typeof repo !== "string" || !repo) return failArgv();
+  const tokens = command.trim().split(/\s+/);
+  if (tokens[0] !== "gentle-ai") return failArgv();
+  const args = [];
+  const rest = tokens.slice(1);
+  for (let i = 0; i < rest.length; i += 1) {
+    const tok = rest[i];
+    if (UNSAFE_TOKEN.test(tok)) return failArgv();
+    if (tok === "--cwd") {
+      const next = rest[i + 1];
+      const needsRepo = next === "<repo>" || next == null || next.startsWith("-");
+      args.push("--cwd", needsRepo ? repo : next);
+      if (!needsRepo || next === "<repo>") i += 1;
+      continue;
+    }
+    if (PLACEHOLDER.test(tok)) return failArgv();
+    args.push(tok);
+  }
+  if (args[0] !== "review" || args[1] !== "status") return failArgv();
+  return { ok: true, error: null, binary: binaryPath, argv: args };
+}
+
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+function publishedReceipt(receiptField) {
+  if (typeof receiptField === "string" && receiptField) return receiptField;
+  if (!isObject(receiptField)) return null;
+  if (typeof receiptField.id === "string" && receiptField.id) return receiptField.id;
+  if (typeof receiptField.digest === "string" && receiptField.digest) return receiptField.digest;
+  return null;
+}
+
+function publishedGate(payload) {
+  if (typeof payload.gate === "string" && payload.gate) return payload.gate;
+  if (isObject(payload.receipt) && typeof payload.receipt.gate === "string" && payload.receipt.gate) {
+    return payload.receipt.gate;
+  }
+  return null;
+}
+
+/**
+ * Fail closed unless schema/contract are official. Pass next_transition through unaltered.
+ */
+export function mapOfficialReviewStatus(payload) {
+  if (!isObject(payload)) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (
+    payload.schema === INVENTORY_SCHEMA
+    || payload.authoritative === true
+    || Array.isArray(payload.entries)
+  ) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (!REVIEW_STATUS_SCHEMAS.includes(payload.schema)) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+  if (payload.contract != null && payload.contract !== SUPPORTED_CONTRACT) {
+    return { ok: false, error: "gentle_incompatible", review: null, nextTransition: null };
+  }
+
+  const nextTransition = Object.prototype.hasOwnProperty.call(payload, "next_transition")
+    ? payload.next_transition
+    : null;
+  const receipt = publishedReceipt(payload.receipt);
+  const gate = publishedGate(payload);
+  const applicability = typeof payload.applicability === "string" ? payload.applicability : null;
+  const action = typeof payload.action === "string" ? payload.action : null;
+  const receiptStatus = isObject(payload.receipt) && typeof payload.receipt.status === "string"
+    ? payload.receipt.status
+    : null;
+
+  const review = (receipt || gate || applicability || action)
+    ? {
+        lineageId: null,
+        state: applicability ?? action,
+        status: receiptStatus,
+        receipt,
+        gate
+      }
+    : null;
+
+  return { ok: true, error: null, review, nextTransition };
+}

package/src/global/control-plane/sdd-status.js

@@ -0,0 +1,49 @@
+/**
+ * Official `sdd-status --json` projection. No inferred phase/route/next.
+ */
+import { NO_ACTIVE_WORKFLOW, WORKFLOW_KIND } from "./constants.js";
+
+export const SDD_STATUS_SCHEMA_PREFIX = "gentle-ai.sdd-status";
+export const SDD_STATUS_ARGS = Object.freeze(["sdd-status", "--json"]);
+
+function isObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function mapOfficialSddStatus(payload) {
+  if (!isObject(payload)) {
+    return { ok: false, error: "gentle_incompatible", projection: null };
+  }
+  const schemaName = typeof payload.schemaName === "string"
+    ? payload.schemaName
+    : (typeof payload.schema === "string" ? payload.schema : null);
+  if (!schemaName || !schemaName.startsWith(SDD_STATUS_SCHEMA_PREFIX)) {
+    return { ok: false, error: "gentle_incompatible", projection: null };
+  }
+  const changeName = typeof payload.changeName === "string" && payload.changeName
+    ? payload.changeName
+    : null;
+  const nextRecommended = typeof payload.nextRecommended === "string" && payload.nextRecommended
+    ? payload.nextRecommended
+    : null;
+  return {
+    ok: true,
+    error: null,
+    projection: { schemaName, changeName, nextRecommended }
+  };
+}
+
+export function applySddProjection(workflow, projection) {
+  workflow.sdd = projection;
+  workflow.changeName = projection.changeName;
+  workflow.phase = null;
+  if (projection.changeName) {
+    workflow.kind = WORKFLOW_KIND.SDD;
+    workflow.active = true;
+    workflow.label = "SDD";
+  } else if (workflow.kind !== WORKFLOW_KIND.REVIEW) {
+    workflow.kind = WORKFLOW_KIND.NONE;
+    workflow.active = false;
+    workflow.label = NO_ACTIVE_WORKFLOW;
+  }
+}

package/src/global/control-plane/team.js

@@ -0,0 +1,63 @@
+/**
+ * Normalize declared fleets into honest control-plane team nodes.
+ * Live requires OpenCode active-agent evidence — never idle sessions.
+ */
+import { HONESTY } from "./constants.js";
+
+function honestyForNode(node, { platform, hasLiveActivity }) {
+  if (node?.opaque === true) return HONESTY.OPAQUE;
+  if (platform === "opencode" && hasLiveActivity) return HONESTY.LIVE;
+  return HONESTY.DECLARED;
+}
+
+export function normalizeTeam(connectionsReport = {}) {
+  const fleets = Array.isArray(connectionsReport.fleets) ? connectionsReport.fleets : [];
+  const activity = connectionsReport.activity ?? null;
+  const hasLiveActivity = Boolean(
+    activity
+    && (
+      (Array.isArray(activity.agents) && activity.agents.some((a) => a?.state === "active"))
+      || (typeof activity.activeCount === "number" && activity.activeCount > 0)
+      || activity.active === true
+    )
+  );
+
+  // Cursor configured agents are declared topology (not live); only opaque nodes stay opaque.
+  const platforms = fleets.map((fleet) => {
+    const platform = fleet?.platform ?? "unknown";
+    const orch = fleet?.orchestrator ?? null;
+    return {
+      platform,
+      honesty: honestyForNode(fleet, { platform, hasLiveActivity }),
+      source: fleet?.source ?? null,
+      orchestrator: orch
+        ? {
+            id: orch.id ?? null,
+            model: orch.modelShort ?? orch.model ?? null,
+            honesty: honestyForNode(orch, { platform, hasLiveActivity }),
+            role: orch.mode ?? "orchestrator"
+          }
+        : null,
+      agents: (Array.isArray(fleet?.minions) ? fleet.minions : []).map((m) => ({
+        id: m.id,
+        model: m.modelShort ?? m.model ?? null,
+        role: m.role ?? null,
+        honesty: m?.opaque === true && platform === "cursor"
+          ? HONESTY.DECLARED
+          : honestyForNode(m, { platform, hasLiveActivity: false })
+      }))
+    };
+  });
+
+  return {
+    platforms,
+    // Only surface activity when there is live evidence (active workers).
+    activity: hasLiveActivity ? activity : null,
+    fleetNote: connectionsReport.fleetNote
+      ?? "Declared config topology — not live token usage.",
+    orchestratorAuthority: connectionsReport.orchestratorAuthority ?? null,
+    connections: Array.isArray(connectionsReport.connections)
+      ? connectionsReport.connections
+      : []
+  };
+}

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;
+}