@relay-baton/cli 1.0.0

package/dist/commands/handoffHistory.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstNonEmptyLine = firstNonEmptyLine;
+exports.collectHandoffHistory = collectHandoffHistory;
+exports.handoffHistoryCommand = handoffHistoryCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@relay-baton/core");
+const shared_1 = require("@relay-baton/shared");
+const projectOptions_1 = require("./projectOptions");
+/**
+ * Returns the first non-empty line of `content`, trimmed and clipped to
+ * `maxLen` characters. Skips the leading `#` heading markers so the label
+ * is more descriptive (e.g. "Relay Baton Handoff" instead of "#").
+ */
+function firstNonEmptyLine(content, maxLen = 80) {
+    for (const raw of content.split(/\r?\n/)) {
+        const trimmed = raw.replace(/^#+\s*/, "").trim();
+        if (trimmed.length === 0)
+            continue;
+        return trimmed.length > maxLen ? trimmed.slice(0, maxLen - 1) + "…" : trimmed;
+    }
+    return "(empty)";
+}
+// SessionManager.backupHandoffIfExists writes:
+//   handoff.<ISO-with-:-and-.-replaced-by-->.md
+// e.g.  handoff.2026-05-27T05-58-13-213Z.md
+// So the timestamp piece can contain digits, dashes, and a trailing 'Z'.
+const BACKUP_NAME_RE = /^handoff\.\d{4}-\d{2}-\d{2}T[\dZ-]+\.md$/;
+const CURRENT_NAME = "handoff.md";
+function collectHandoffHistory(repoRoot) {
+    const files = new core_1.SessionFiles(repoRoot);
+    if (!fs.existsSync(files.dir))
+        return [];
+    const entries = [];
+    for (const name of fs.readdirSync(files.dir)) {
+        const isCurrent = name === CURRENT_NAME;
+        const isBackup = BACKUP_NAME_RE.test(name);
+        if (!isCurrent && !isBackup)
+            continue;
+        const full = path.join(files.dir, name);
+        let stat;
+        try {
+            stat = fs.statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isFile())
+            continue;
+        let label = "(unreadable)";
+        try {
+            label = firstNonEmptyLine(fs.readFileSync(full, "utf8"));
+        }
+        catch { /* keep default */ }
+        entries.push({
+            name,
+            path: full,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+            label,
+            current: isCurrent,
+        });
+    }
+    // newest first
+    entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return entries;
+}
+function fmtSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}K`;
+    return `${(bytes / 1024 / 1024).toFixed(1)}M`;
+}
+function fmtTimestamp(mtimeMs) {
+    // ISO-like compact form, no milliseconds.
+    return new Date(mtimeMs).toISOString().replace(/\.\d+Z$/, "Z");
+}
+async function handoffHistoryCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const entries = collectHandoffHistory(repoRoot);
+    if (entries.length === 0) {
+        console.log(`[relay-baton] no handoff history under ${shared_1.SESSION_DIR}/`);
+        return;
+    }
+    // Print a small header so the columns are obvious.
+    console.log("  TIMESTAMP             SIZE   FILE                                 LABEL");
+    for (const e of entries) {
+        const marker = e.current ? "*" : " ";
+        const ts = fmtTimestamp(e.mtimeMs).padEnd(20);
+        const sz = fmtSize(e.size).padStart(6);
+        const name = e.name.length > 36 ? e.name.slice(0, 35) + "…" : e.name.padEnd(36);
+        console.log(`${marker} ${ts}  ${sz}  ${name}  ${e.label}`);
+    }
+}

package/dist/commands/handoffShow.d.ts

@@ -0,0 +1,12 @@
+import { ProjectOpts } from "./projectOptions";
+export interface HandoffShowOpts extends ProjectOpts {
+    json?: boolean;
+    /** Show a specific history file (name from `handoff history`) instead of the current handoff.md. */
+    file?: string;
+}
+/**
+ * Read-only view of a handoff document. This exists so display surfaces
+ * (desktop webview, scripts) can render the handoff through the CLI instead
+ * of reaching into `.ai-session/` themselves — the UI never touches files.
+ */
+export declare function handoffShowCommand(opts?: HandoffShowOpts): Promise<void>;

package/dist/commands/handoffShow.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handoffShowCommand = handoffShowCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const shared_1 = require("@relay-baton/shared");
+const projectOptions_1 = require("./projectOptions");
+const handoffHistory_1 = require("./handoffHistory");
+/**
+ * Read-only view of a handoff document. This exists so display surfaces
+ * (desktop webview, scripts) can render the handoff through the CLI instead
+ * of reaching into `.ai-session/` themselves — the UI never touches files.
+ */
+async function handoffShowCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const files = new core_1.SessionFiles(repoRoot);
+    let target = files.p("handoff");
+    let name = "handoff.md";
+    if (opts.file) {
+        // Only allow names that `handoff history` itself lists — no path traversal.
+        const entry = (0, handoffHistory_1.collectHandoffHistory)(repoRoot).find((e) => e.name === opts.file);
+        if (!entry) {
+            console.error(`[relay-baton] unknown handoff file: ${opts.file} (see \`handoff history\`)`);
+            process.exit(2);
+        }
+        target = entry.path;
+        name = entry.name;
+    }
+    const exists = fs.existsSync(target);
+    const content = exists ? fs.readFileSync(target, "utf8") : null;
+    if (opts.json) {
+        console.log(JSON.stringify({ name, path: target, exists, content }, null, 2));
+        return;
+    }
+    if (!exists) {
+        console.log(`[relay-baton] no handoff found at ${shared_1.SESSION_DIR}/${name}`);
+        return;
+    }
+    console.log(content);
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { ProjectOpts } from "./projectOptions";
+export declare function initCommand(opts?: ProjectOpts): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function initCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    const r = sm.init("");
+    if (r.alreadyExisted && r.createdFiles.length === 0) {
+        console.log(`[relay-baton] .ai-session already exists at ${r.dir}. Nothing to do.`);
+    }
+    else {
+        console.log(`[relay-baton] initialized ${r.dir}`);
+        for (const f of r.createdFiles)
+            console.log(`  + ${f}`);
+    }
+}

package/dist/commands/inventory.d.ts

@@ -0,0 +1,5 @@
+import { ProjectOpts } from "./projectOptions";
+export interface InventoryOpts extends ProjectOpts {
+    json?: boolean;
+}
+export declare function inventoryCommand(opts?: InventoryOpts): Promise<void>;

package/dist/commands/inventory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inventoryCommand = inventoryCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function inventoryCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const inv = new core_1.DependencyInventory(repoRoot).generate();
+    if (opts.json) {
+        console.log(JSON.stringify(inv, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] inventory: ${inv.repoRoot}`);
+    console.log(`dependency manifests: ${inv.dependencyManifests.join(", ") || "-"}`);
+    console.log(`root scripts: ${inv.rootScripts.join(", ") || "-"}`);
+    if (inv.packages.length) {
+        console.log(`workspace packages (${inv.packages.length}):`);
+        for (const p of inv.packages)
+            console.log(`  - ${p.name}: ${p.scripts.join(", ") || "(no scripts)"}`);
+    }
+    console.log(`CI workflows: ${inv.ciWorkflows.join(", ") || "-"}`);
+    console.log(`release files: ${inv.releaseFiles.join(", ") || "-"}`);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,3 @@
+export declare function loginCommand(agent: string | undefined, opts: {
+    allowApiKeyEnv?: boolean;
+}): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const core_1 = require("@relay-baton/core");
+function bin(cmd) {
+    const r = (0, core_1.safeSpawnSync)(cmd, ["--version"], { encoding: "utf8" });
+    return r.error == null;
+}
+function header(title) {
+    const line = "─".repeat(Math.max(8, title.length + 4));
+    process.stdout.write(`\n\x1b[36m┌${line}┐\n│  \x1b[1m${title}\x1b[22m\x1b[36m  │\n└${line}┘\x1b[0m\n`);
+}
+async function spawnInteractive(command, args, env) {
+    return new Promise((resolve) => {
+        const child = (0, core_1.safeSpawn)(command, args, { stdio: "inherit", env, shell: false });
+        child.on("error", (e) => {
+            console.error(`\x1b[31m[relay-baton] failed to spawn ${command}: ${e?.message ?? e}\x1b[0m`);
+            if (e?.code === "ENOENT") {
+                console.error(`\x1b[33mInstall the ${command} CLI and ensure it is on PATH.\x1b[0m`);
+            }
+            resolve(127);
+        });
+        child.on("close", (code) => resolve(code ?? 0));
+    });
+}
+/** Run the registry-described login flow for a single agent; returns 0 on success. */
+async function loginAgent(id, command, env) {
+    const desc = (0, core_1.getAgentDescriptor)(id);
+    header(`${desc.displayName} login  [${desc.tier}]`);
+    if (!bin(command)) {
+        console.error(`\x1b[31m✗ ${command} command not found on PATH.\x1b[0m`);
+        console.error(`  Install ${desc.displayName} first: ${desc.installUrl}`);
+        return 1;
+    }
+    for (const line of desc.login.instructions)
+        console.log(`\x1b[2m${line}\x1b[0m`);
+    // No login subcommand (e.g. Aider uses provider API keys via env) — instructions only.
+    if (desc.login.kind === "env") {
+        console.log(`\x1b[32m✓ ${desc.displayName}: nothing to run here (see above).\x1b[0m`);
+        return 0;
+    }
+    const args = desc.login.kind === "subcommand" ? desc.login.subcommand ?? [] : [];
+    const code = await spawnInteractive(command, args, env);
+    // Interactive sessions exit non-zero on Ctrl+C (130) — treat as benign.
+    if (code !== 0 && !(desc.login.kind === "interactive" && code === 130)) {
+        console.error(`\x1b[31m✗ ${command} login exited with ${code}\x1b[0m`);
+        return 1;
+    }
+    console.log(`\x1b[32m✓ ${desc.displayName} login finished. \`relay-baton doctor\`로 상태를 확인하세요.\x1b[0m`);
+    return 0;
+}
+async function loginCommand(agent, opts) {
+    const which = agent ?? "all";
+    if (which !== "all" && !(0, core_1.isAgentId)(which)) {
+        console.error(`unknown agent: ${which}. Use one of: ${core_1.ALL_AGENT_IDS.join(", ")} | all`);
+        process.exit(2);
+    }
+    const repoRoot = process.cwd();
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const { env, removed } = (0, core_1.createAgentEnv)(process.env, config.authPolicy, opts.allowApiKeyEnv);
+    if (removed.length > 0) {
+        console.log(`\x1b[2m[relay-baton] blocked env from child: ${removed.join(", ")}\x1b[0m`);
+    }
+    // Default `all` logs in just the first-class pair (codex + claude); explicit
+    // agent ids reach the supported adapters (opencode/gemini/aider/cursor).
+    const targets = which === "all"
+        ? core_1.ALL_AGENT_IDS.filter((id) => core_1.AGENT_REGISTRY[id].tier === "first-class")
+        : [which];
+    let totalFail = 0;
+    for (const id of targets) {
+        const command = config.agents[id]?.command ?? core_1.AGENT_REGISTRY[id].command;
+        totalFail += await loginAgent(id, command, env);
+    }
+    if (which === "all") {
+        const supported = core_1.ALL_AGENT_IDS.filter((id) => core_1.AGENT_REGISTRY[id].tier === "supported");
+        console.log(`\n\x1b[2m지원 어댑터 로그인: ${supported.map((s) => `relay-baton login ${s}`).join("  ·  ")}\x1b[0m`);
+    }
+    if (totalFail > 0)
+        process.exit(1);
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,8 @@
+import { ProjectOpts } from "./projectOptions";
+export interface MigrateOpts extends ProjectOpts {
+    check?: boolean;
+    apply?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+}
+export declare function migrateCommand(opts?: MigrateOpts): Promise<void>;

package/dist/commands/migrate.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCommand = migrateCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function migrateCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    // Apply path is opt-in (--apply). Default and --check are read-only detection.
+    if (opts.apply) {
+        const dryRun = opts.dryRun === true;
+        const result = new core_1.SchemaMigrator(repoRoot).migrate({ dryRun });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (!result.exists) {
+            console.log("[relay-baton] no .ai-session to migrate.");
+            return;
+        }
+        const verb = dryRun ? "would migrate" : "migrated";
+        const acted = result.actions.filter(a => a.kind !== "skip");
+        if (acted.length === 0) {
+            console.log("[relay-baton] nothing to migrate; all artifacts are current.");
+        }
+        else {
+            console.log(`[relay-baton] ${verb} ${acted.length} artifact(s)${dryRun ? " (dry-run)" : ""}`);
+            for (const a of result.actions)
+                console.log(`- ${a.file}: ${a.kind} — ${a.note}`);
+            if (result.backups.length)
+                console.log(`backups: ${result.backups.length} written (.bak.<ts>)`);
+        }
+        return;
+    }
+    const report = new core_1.SchemaInspector(repoRoot).inspect();
+    if (opts.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    if (!report.exists) {
+        console.log("[relay-baton] no .ai-session to check.");
+        return;
+    }
+    console.log(`[relay-baton] artifact schemas: ${report.ok ? "ok" : "ATTENTION"}`);
+    for (const c of report.checks) {
+        const found = c.foundVersion == null ? "-" : `v${c.foundVersion}`;
+        console.log(`- ${c.file}: ${c.status} (${found}/v${c.currentVersion}) — ${c.guidance}`);
+    }
+    if (report.migratable) {
+        console.log("run `relay-baton migrate --apply --dry-run` to preview, then `--apply` to normalize (writes a .bak backup).");
+    }
+    else {
+        console.log("nothing to migrate.");
+    }
+}

package/dist/commands/plan.d.ts

@@ -0,0 +1,13 @@
+import { ProjectOpts } from "./projectOptions";
+export interface PlanOpts extends ProjectOpts {
+    diet?: string;
+    with?: string;
+    planner?: string;
+    executor?: string;
+    force?: boolean;
+    run?: boolean;
+    noRun?: boolean;
+    thenExecute?: boolean;
+    allowApiKeyEnv?: boolean;
+}
+export declare function planCommand(task: string, opts: PlanOpts): Promise<void>;

package/dist/commands/plan.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planCommand = planCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const agentFor_1 = require("./agentFor");
+const execute_1 = require("./execute");
+async function planCommand(task, opts) {
+    const projectContext = (0, projectOptions_1.resolveProjectContext)(opts, true);
+    const repoRoot = projectContext.repoRoot;
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    if (!sm.getMeta())
+        sm.init(task);
+    sm.writeTask(task);
+    const git = new core_1.GitService(repoRoot);
+    if (!git.isGitRepo()) {
+        console.error("[relay-baton] not a git repository. aborting.");
+        process.exit(2);
+    }
+    const profileName = (opts.diet ?? projectContext.project?.defaultDiet ?? config.tokenDiet.profile);
+    if (!config.tokenDiet.profiles[profileName]) {
+        console.error(`unknown diet profile: ${profileName}`);
+        process.exit(2);
+    }
+    const planner = (opts.planner ?? opts.with ?? config.planExecute?.defaultPlanner ?? "claude");
+    // Refresh artifacts so the planner can read repo-map / compact-state by reference.
+    new core_1.BatonWorkflow(sm, config).refreshArtifacts(profileName);
+    sm.updateMeta({
+        task,
+        workflowMode: "plan-execute",
+        status: "planning",
+        planAuthor: planner,
+        activeAgent: planner,
+        tokenDietProfile: profileName,
+    });
+    // --no-run: scaffold an empty plan template for manual authoring, then stop.
+    if (opts.run === false || opts.noRun) {
+        if (!fs.existsSync(sm.files.p("plan"))) {
+            fs.writeFileSync(sm.files.p("plan"), (0, core_1.planTemplate)(task), "utf8");
+            console.log(`[relay-baton] wrote plan template: ${sm.files.p("plan")}`);
+            console.log("[relay-baton] fill it in, then run 'relay-baton execute'.");
+        }
+        else {
+            console.log("[relay-baton] plan.md already exists; left untouched (--no-run).");
+        }
+        sm.updateMeta({ status: "plan_ready", activeAgent: "none" });
+        return;
+    }
+    // Plan diffing (v0.7): back up the existing plan so we can report a
+    // deterministic section-level delta after the planner rewrites it.
+    const prevPlan = fs.existsSync(sm.files.p("plan")) ? fs.readFileSync(sm.files.p("plan"), "utf8") : "";
+    const backupPath = (0, core_1.backupPlan)(repoRoot);
+    if (backupPath)
+        console.log(`[relay-baton] backed up previous plan: ${backupPath}`);
+    // Launch the planner agent with the planner prompt.
+    const adapter = (0, agentFor_1.adapterFor)(planner, config);
+    const prompt = core_1.PromptBuilder.planner(task);
+    const cmd = adapter.buildCommand({ task: prompt, prompt, repoRoot, sessionDir: sm.files.dir, dietProfile: profileName });
+    console.log(`[relay-baton] planning with ${cmd.command} (${planner}) ...`);
+    const r = await (0, core_1.runAgent)({
+        command: cmd,
+        logFile: sm.files.p("commandsLog"),
+        authPolicy: config.authPolicy,
+        allowApiKeyEnv: opts.allowApiKeyEnv,
+        onStdout: l => process.stdout.write(l + "\n"),
+        onStderr: l => process.stderr.write(l + "\n"),
+    });
+    if (r.error) {
+        console.error(r.error);
+        sm.updateMeta({ status: "failed", lastError: r.error, lastAgent: planner, activeAgent: "none" });
+        process.exit(1);
+    }
+    // Validate the plan the planner wrote.
+    const gate = new core_1.PlanQualityGate(repoRoot, config.tokenDiet.profiles[profileName]).check();
+    if (!gate.ok) {
+        console.error("[relay-baton] Plan Quality Gate failed:");
+        for (const f of gate.failures)
+            console.error("  - " + f);
+        if (!opts.force) {
+            sm.updateMeta({ status: "failed", lastAgent: planner, activeAgent: "none", lastError: "plan quality gate failed" });
+            console.error("[relay-baton] aborting. Fix plan.md or use --force.");
+            process.exit(3);
+        }
+    }
+    for (const w of gate.warnings)
+        console.error("[relay-baton] warn: " + w);
+    sm.updateMeta({
+        status: "plan_ready",
+        lastAgent: planner,
+        activeAgent: "none",
+        planFinalizedAt: new Date().toISOString(),
+        lastError: null,
+    });
+    console.log(`[relay-baton] plan ready: ${sm.files.p("plan")}`);
+    // Report the section-level delta vs the previous plan, if there was one.
+    if (prevPlan.trim()) {
+        const newPlan = fs.readFileSync(sm.files.p("plan"), "utf8");
+        const delta = (0, core_1.diffPlans)(prevPlan, newPlan);
+        if (delta.changed) {
+            console.log("[relay-baton] plan delta vs previous:");
+            for (const s of delta.sections) {
+                if (s.change !== "unchanged")
+                    console.log(`  - ${s.section}: ${s.change}`);
+            }
+        }
+        else {
+            console.log("[relay-baton] plan unchanged vs previous.");
+        }
+    }
+    if (opts.thenExecute) {
+        console.log("[relay-baton] --then-execute: starting execute phase...");
+        await (0, execute_1.executeCommand)({
+            diet: opts.diet,
+            with: opts.executor,
+            force: opts.force,
+            allowApiKeyEnv: opts.allowApiKeyEnv,
+            project: opts.project,
+            path: opts.path,
+        });
+    }
+    else {
+        console.log("[relay-baton] run 'relay-baton execute' to implement it.");
+    }
+}

package/dist/commands/profile.d.ts

@@ -0,0 +1,5 @@
+import { ProjectOpts } from "./projectOptions";
+export interface ProfileOpts extends ProjectOpts {
+    json?: boolean;
+}
+export declare function profileCommand(opts?: ProfileOpts): Promise<void>;

package/dist/commands/profile.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profileCommand = profileCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function profileCommand(opts = {}) {
+    const ctx = (0, projectOptions_1.resolveProjectContext)(opts);
+    const { config } = core_1.ConfigLoader.load(ctx.repoRoot);
+    const profile = new core_1.ProjectProfile(ctx.repoRoot, config, ctx.project).generate();
+    if (opts.json) {
+        console.log(JSON.stringify(profile, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] project profile: ${profile.repoRoot}`);
+    console.log(`tags: ${profile.tags.join(", ") || "-"}`);
+    console.log(`frameworks: ${profile.frameworks.join(", ") || "-"}`);
+    console.log(`monorepo: ${profile.monorepo ? `yes (${profile.packageCount})` : "no"}`);
+    const r = profile.recommended;
+    console.log(`recommended build: ${r.build ?? "-"}`);
+    console.log(`recommended test: ${r.test ?? "-"}`);
+    console.log(`diet: ${r.diet} · agents: ${r.primaryAgent} -> ${r.fallbackAgent}`);
+    console.log(`entry points: ${profile.entryPoints.join(", ") || "-"}`);
+}

package/dist/commands/project.d.ts

@@ -0,0 +1,18 @@
+import type { AgentId, DietProfileName } from "@relay-baton/shared";
+interface AddOpts {
+    name?: string;
+    diet?: DietProfileName;
+    primary?: AgentId;
+    fallback?: AgentId;
+    json?: boolean;
+}
+export declare function projectAddCommand(projectPath: string, opts: AddOpts): Promise<void>;
+export interface JsonOpts {
+    json?: boolean;
+}
+export declare function projectListCommand(opts?: JsonOpts): Promise<void>;
+export declare function projectSwitchCommand(nameOrId: string): Promise<void>;
+export declare function projectCurrentCommand(opts?: JsonOpts): Promise<void>;
+export declare function projectRemoveCommand(nameOrId: string, opts?: JsonOpts): Promise<void>;
+export declare function projectDoctorCommand(): Promise<void>;
+export {};