@relay-baton/cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DongGeon Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/commands/agentFor.d.ts

@@ -0,0 +1,8 @@
+import type { AgentAdapter } from "@relay-baton/core";
+import type { AgentId, RelayBatonConfig } from "@relay-baton/shared";
+/**
+ * Resolve an AgentAdapter for a given agent id, honoring config.agents overrides.
+ * codex / claude are first-class; opencode / gemini / aider / cursor are v2.3
+ * supported adapters (see AgentRegistry for tiers).
+ */
+export declare function adapterFor(id: AgentId, config: RelayBatonConfig): AgentAdapter;

package/dist/commands/agentFor.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterFor = adapterFor;
+const core_1 = require("@relay-baton/core");
+/**
+ * Resolve an AgentAdapter for a given agent id, honoring config.agents overrides.
+ * codex / claude are first-class; opencode / gemini / aider / cursor are v2.3
+ * supported adapters (see AgentRegistry for tiers).
+ */
+function adapterFor(id, config) {
+    switch (id) {
+        case "codex":
+            return new core_1.CodexAdapter(config.agents.codex);
+        case "claude":
+            return new core_1.ClaudeCodeAdapter(config.agents.claude);
+        case "opencode":
+            return new core_1.OpenCodeAdapter(config.agents.opencode);
+        case "gemini":
+            return new core_1.GeminiAdapter(config.agents.gemini);
+        case "aider":
+            return new core_1.AiderAdapter(config.agents.aider);
+        case "cursor":
+            return new core_1.CursorAdapter(config.agents.cursor);
+        default:
+            console.error(`[relay-baton] unsupported agent: ${id} (supported: ${core_1.ALL_AGENT_IDS.join(", ")})`);
+            process.exit(2);
+    }
+}

package/dist/commands/auditApiKeyEnv.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Record an audit trail when blocked provider key env vars were intentionally
+ * passed through to a child agent (via `--allow-api-key-env`). Names only — the
+ * values are never read, logged, or stored.
+ */
+export declare function auditApiKeyEnv(repoRoot: string, passedThrough: string[] | undefined, sessionId?: string): void;

package/dist/commands/auditApiKeyEnv.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditApiKeyEnv = auditApiKeyEnv;
+const core_1 = require("@relay-baton/core");
+/**
+ * Record an audit trail when blocked provider key env vars were intentionally
+ * passed through to a child agent (via `--allow-api-key-env`). Names only — the
+ * values are never read, logged, or stored.
+ */
+function auditApiKeyEnv(repoRoot, passedThrough, sessionId) {
+    if (!passedThrough || passedThrough.length === 0)
+        return;
+    const names = passedThrough.join(", ");
+    console.error(`[relay-baton] audit: passed API key env to child (names only): ${names}`);
+    try {
+        new core_1.ConversationLog(repoRoot).append({
+            role: "relay-baton",
+            kind: "status",
+            text: `audit: API key env passed to child via --allow-api-key-env: ${names} (names only; values never logged)`,
+            sessionId,
+            meta: { confirmed: true },
+        });
+    }
+    catch {
+        /* audit logging is best-effort */
+    }
+}

package/dist/commands/budget.d.ts

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

package/dist/commands/budget.js

@@ -0,0 +1,86 @@
+"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.budgetCommand = budgetCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function budgetCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    const meta = sm.getMeta();
+    const activeProfile = meta?.tokenDietProfile ?? config.tokenDiet.profile;
+    const profile = config.tokenDiet.profiles[activeProfile];
+    const read = (p) => { try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return "";
+    } };
+    const handoff = read(sm.files.p("handoff"));
+    const repoMap = read(sm.files.p("repoMap"));
+    const fullDiff = read(sm.files.p("fullDiff"));
+    const log = read(sm.files.p("commandsLog"));
+    const compactState = read(sm.files.p("compactState"));
+    let budgetSnap = null;
+    try {
+        budgetSnap = JSON.parse(read(sm.files.p("contextBudget")));
+    }
+    catch { /**/ }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            activeProfile,
+            maxHandoffChars: profile.maxHandoffChars,
+            used: {
+                handoff: handoff.length,
+                repoMap: repoMap.length,
+                fullDiff: fullDiff.length,
+                commandsLog: log.length,
+                compactState: compactState.length,
+            },
+            truncated: budgetSnap?.truncated ?? false,
+        }, null, 2));
+        return;
+    }
+    console.log("active profile:", activeProfile);
+    console.log("maxHandoffChars:", profile.maxHandoffChars);
+    console.log("handoff.md chars:", handoff.length);
+    console.log("repo-map.md chars:", repoMap.length);
+    console.log("full-diff.patch chars:", fullDiff.length);
+    console.log("commands.log chars:", log.length);
+    console.log("compact-state.md chars:", compactState.length);
+    console.log("truncated:", budgetSnap?.truncated ?? false);
+}

package/dist/commands/chat.d.ts

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

package/dist/commands/chat.js

@@ -0,0 +1,218 @@
+"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.chatCommand = chatCommand;
+const readline = __importStar(require("readline"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const agentFor_1 = require("./agentFor");
+const review_1 = require("./review");
+const doctor_1 = require("./doctor");
+const budget_1 = require("./budget");
+const status_1 = require("./status");
+const plan_1 = require("./plan");
+const execute_1 = require("./execute");
+const handoff_1 = require("./handoff");
+const LABELS = {
+    user: "you",
+    claude: "claude",
+    codex: "codex",
+    "relay-baton": "relay-baton",
+};
+function say(role, text) {
+    console.log(`[${LABELS[role] ?? role}] ${text}`);
+}
+/**
+ * Build a model-free prompt PREVIEW for a run-type command. This shows exactly
+ * what would be spawned; it never executes. Confirmation-first by design.
+ */
+function buildPreview(command, args, agent, repoRoot, sessionDir, config, maxSteps = 3) {
+    if (command === "plan" || command === "replan") {
+        const prompt = core_1.PromptBuilder.planner(args);
+        const c = (0, agentFor_1.adapterFor)(agent, config).buildCommand({ task: prompt, prompt, repoRoot, sessionDir });
+        const note = command === "replan" ? " (current plan.md is backed up first)" : "";
+        return `${c.command} ${c.args.slice(0, -1).join(" ")} "<planner prompt, ${prompt.length} chars>"${note}`;
+    }
+    if (command === "continue") {
+        const prompt = core_1.PromptBuilder.executor();
+        const c = (0, agentFor_1.adapterFor)(agent, config).buildCommand({ task: prompt, prompt, repoRoot, sessionDir });
+        return `bounded loop: up to ${maxSteps} execute step(s), each: ${c.command} ${c.args.slice(0, -1).join(" ")} "<executor prompt>" — stops on no-progress or budget`;
+    }
+    if (command === "execute") {
+        const prompt = core_1.PromptBuilder.executor();
+        const c = (0, agentFor_1.adapterFor)(agent, config).buildCommand({ task: prompt, prompt, repoRoot, sessionDir });
+        return `${c.command} ${c.args.slice(0, -1).join(" ")} "<executor prompt, ${prompt.length} chars>"`;
+    }
+    if (command === "handoff") {
+        return `relay-baton handoff --to ${agent} (builds handoff.md, then launches ${agent})`;
+    }
+    return null;
+}
+function ask(rl, q) {
+    return new Promise(resolve => rl.question(q, a => resolve(a)));
+}
+async function chatCommand(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("");
+    const sessionId = sm.getMeta()?.id;
+    const sessionDir = sm.files.dir;
+    const git = new core_1.GitService(repoRoot);
+    if (!git.isGitRepo()) {
+        console.error("[relay-baton] not a git repository. aborting.");
+        process.exit(2);
+    }
+    const engine = new core_1.RoomEngine(repoRoot, sessionId, "claude");
+    console.log("relay-baton room (v0.8 first cut). Turn-based, confirmation-first.");
+    console.log("This is NOT a realtime autopilot — every real agent run asks first.");
+    console.log("Type /help for commands, /exit to leave.\n");
+    say("relay-baton", `addressing ${engine.currentAgent} (planner/reviewer = claude, executor = codex).`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const passthrough = {
+        project: opts.project,
+        path: opts.path,
+        allowApiKeyEnv: opts.allowApiKeyEnv,
+    };
+    let running = true;
+    while (running) {
+        const line = await ask(rl, `\n${engine.currentAgent}› `);
+        const action = engine.handle(line);
+        switch (action.kind) {
+            case "noop":
+                break;
+            case "exit":
+                running = false;
+                break;
+            case "help":
+                console.log("commands:\n" + action.text);
+                break;
+            case "error":
+                say("relay-baton", action.message);
+                break;
+            case "switch-agent":
+                say("relay-baton", `now addressing ${action.agent}.`);
+                break;
+            case "chat":
+                // Confirmation-first: a plain message is recorded but never auto-runs an
+                // agent. The user drives real work with explicit slash commands.
+                say("relay-baton", `noted (logged to conversation.jsonl). Use /plan, /execute, /review, or /handoff to act with ${action.agent}.`);
+                break;
+            case "run": {
+                await runAction(action, rl, { repoRoot, sessionDir, config, passthrough });
+                break;
+            }
+        }
+    }
+    rl.close();
+    console.log("\n[relay-baton] left the room.");
+}
+async function runAction(action, rl, ctx) {
+    const { command, args, agent } = action;
+    const maxSteps = action.maxSteps ?? 3;
+    // Read-only / no-model commands run immediately.
+    if (command === "review")
+        return void (await (0, review_1.reviewCommand)({ ...ctx.passthrough }));
+    if (command === "diagnose")
+        return void (await (0, doctor_1.doctorCommand)({ ...ctx.passthrough, deep: true }));
+    if (command === "budget")
+        return void (await (0, budget_1.budgetCommand)({ ...ctx.passthrough }));
+    if (command === "status")
+        return void (await (0, status_1.statusCommand)({ ...ctx.passthrough }));
+    if (command === "replay") {
+        for (const l of new core_1.ConversationReplay(ctx.repoRoot).renderLines())
+            console.log(l);
+        return;
+    }
+    // Real agent runs: show a prompt preview, then require explicit confirmation.
+    const preview = buildPreview(command, args, agent, ctx.repoRoot, ctx.sessionDir, ctx.config, maxSteps);
+    say("relay-baton", `prompt preview for /${command} (${agent}):`);
+    console.log("  " + (preview ?? "(no preview available)"));
+    const answer = (await ask(rl, "  run this? [y/N] ")).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+        say("relay-baton", "cancelled. nothing ran.");
+        return;
+    }
+    if (command === "plan") {
+        await (0, plan_1.planCommand)(args, { ...ctx.passthrough, with: agent });
+    }
+    else if (command === "replan") {
+        try {
+            (0, core_1.backupPlan)(ctx.repoRoot, new Date());
+        }
+        catch { /* best-effort */ }
+        await (0, plan_1.planCommand)(args, { ...ctx.passthrough, with: agent });
+    }
+    else if (command === "execute") {
+        await (0, execute_1.executeCommand)({ ...ctx.passthrough, with: agent });
+    }
+    else if (command === "handoff") {
+        await (0, handoff_1.handoffCommand)({ ...ctx.passthrough, to: agent });
+    }
+    else if (command === "continue") {
+        await runBoundedContinue(maxSteps, agent, ctx);
+    }
+}
+/**
+ * Bounded plan↔execute continuation. Runs at most `maxSteps` execute passes,
+ * each gated by LoopController. Stops early on no-progress (divergence) using a
+ * git working-tree signature as the progress key. Never unbounded; never
+ * auto-commits. One confirmation already happened upstream.
+ */
+async function runBoundedContinue(maxSteps, agent, ctx) {
+    const loop = new core_1.LoopController({ maxSteps });
+    const git = new core_1.GitService(ctx.repoRoot);
+    const progressKey = () => {
+        try {
+            return git.diff().length + ":" + git.changedFiles().length;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    let obs = {};
+    for (;;) {
+        const d = loop.next(obs);
+        if (!d.proceed) {
+            say("relay-baton", `continue stopped after step ${d.step} (${d.reason ?? "done"}).`);
+            break;
+        }
+        say("relay-baton", `continue step ${d.step}/${maxSteps} (execute via ${agent})…`);
+        await (0, execute_1.executeCommand)({ ...ctx.passthrough, with: agent });
+        obs = { progressKey: progressKey() };
+    }
+}

package/dist/commands/checkpoint.d.ts

@@ -0,0 +1,10 @@
+import { ProjectOpts } from "./projectOptions";
+export interface CheckpointOpts extends ProjectOpts {
+    command?: string;
+    result?: string;
+    note?: string;
+    json?: boolean;
+}
+export declare function checkpointCommand(step: string, opts?: CheckpointOpts): Promise<void>;
+export declare function checkpointSummaryCommand(opts?: CheckpointOpts): Promise<void>;
+export declare function checkpointListCommand(opts?: CheckpointOpts): Promise<void>;

package/dist/commands/checkpoint.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkpointCommand = checkpointCommand;
+exports.checkpointSummaryCommand = checkpointSummaryCommand;
+exports.checkpointListCommand = checkpointListCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const RESULTS = ["ok", "fail", "pending"];
+async function checkpointCommand(step, opts = {}) {
+    const n = Number(step);
+    if (!Number.isInteger(n) || n < 1) {
+        console.error(`[relay-baton] step must be a positive integer, got: ${step}`);
+        process.exit(2);
+    }
+    const result = (opts.result ?? "pending");
+    if (!RESULTS.includes(result)) {
+        console.error(`[relay-baton] result must be one of ${RESULTS.join("|")}, got: ${opts.result}`);
+        process.exit(2);
+    }
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const meta = new core_1.SessionManager(repoRoot, config).getMeta();
+    const checkpoint = new core_1.ExecutionCheckpoints(repoRoot, config).append({
+        step: n,
+        command: opts.command,
+        result,
+        note: opts.note,
+    });
+    new core_1.ConversationLog(repoRoot).append({
+        role: "relay-baton",
+        kind: "execute",
+        text: `checkpoint: step ${n} [${result}]${checkpoint.note ? " — " + checkpoint.note : ""}`,
+        sessionId: meta?.id,
+        meta: { stepRefs: [`step-${n}`], confirmed: true },
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(checkpoint, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] checkpoint recorded [${result}] for step ${n}.`);
+    console.log(`git: ${checkpoint.git.branch ?? "(no git)"} · ${checkpoint.git.changed} changed file(s)`);
+}
+async function checkpointSummaryCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const summary = new core_1.ExecutionCheckpoints(repoRoot).summarize();
+    if (opts.json) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    if (summary.total === 0) {
+        console.log("[relay-baton] no execution checkpoints recorded.");
+        return;
+    }
+    const { results } = summary;
+    console.log(`[relay-baton] execution receipt: ${summary.total} checkpoint(s)`);
+    console.log(`results: ${results.ok} ok · ${results.fail} fail · ${results.pending} pending`);
+    console.log(`last: step ${summary.lastStep} [${summary.lastResult}]${summary.lastCommand ? " — " + summary.lastCommand : ""}`);
+    console.log(`max changed files in a step: ${summary.maxChangedFiles}`);
+    if (summary.latestBudget) {
+        console.log(`latest budget: ${summary.latestBudget.handoffChars}/${summary.latestBudget.maxHandoffChars} chars (${summary.latestBudget.activeProfile})`);
+    }
+}
+async function checkpointListCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const checkpoints = new core_1.ExecutionCheckpoints(repoRoot).list();
+    if (opts.json) {
+        console.log(JSON.stringify(checkpoints, null, 2));
+        return;
+    }
+    if (checkpoints.length === 0) {
+        console.log("[relay-baton] no execution checkpoints recorded.");
+        return;
+    }
+    for (const c of checkpoints) {
+        const cmd = c.command ? ` — ${c.command}` : "";
+        console.log(`[${c.result}] step ${c.step}${cmd} (${c.changedFiles.length} files, ${c.ts})`);
+    }
+}

package/dist/commands/compact.d.ts

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

package/dist/commands/compact.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactCommand = compactCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function compactCommand(opts) {
+    const projectContext = (0, projectOptions_1.resolveProjectContext)(opts);
+    const repoRoot = projectContext.repoRoot;
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    if (!sm.getMeta())
+        sm.init("");
+    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 wf = new core_1.BatonWorkflow(sm, config);
+    wf.refreshArtifacts(profileName);
+    sm.updateMeta({ tokenDietProfile: profileName });
+    console.log(`[relay-baton] compacted session with profile=${profileName}`);
+}

package/dist/commands/compress.d.ts

@@ -0,0 +1,4 @@
+export declare function compressCommand(file: string, opts: {
+    write?: boolean;
+    out?: string;
+}): Promise<void>;

package/dist/commands/compress.js

@@ -0,0 +1,61 @@
+"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.compressCommand = compressCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const core_1 = require("@relay-baton/core");
+async function compressCommand(file, opts) {
+    const repoRoot = process.cwd();
+    const target = path.isAbsolute(file) ? file : path.join(repoRoot, file);
+    if (!fs.existsSync(target)) {
+        console.error(`file not found: ${target}`);
+        process.exit(2);
+    }
+    const src = fs.readFileSync(target, "utf8");
+    const out = (0, core_1.deterministicCompress)(src);
+    if (opts.out) {
+        fs.writeFileSync(opts.out, out, "utf8");
+        console.log(`[relay-baton] wrote ${opts.out} (${src.length} -> ${out.length} chars)`);
+    }
+    else if (opts.write) {
+        fs.writeFileSync(target, out, "utf8");
+        console.log(`[relay-baton] rewrote ${target} (${src.length} -> ${out.length} chars)`);
+    }
+    else {
+        process.stdout.write(out);
+        process.stderr.write(`\n[relay-baton] preview only (${src.length} -> ${out.length} chars). Use --write or --out.\n`);
+    }
+}

package/dist/commands/compressContext.d.ts

@@ -0,0 +1,8 @@
+import { ProjectOpts } from "./projectOptions";
+export interface CompressContextOpts extends ProjectOpts {
+    diet?: string;
+    threshold?: string;
+    dryRun?: boolean;
+    force?: boolean;
+}
+export declare function compressContextCommand(opts: CompressContextOpts): Promise<void>;

package/dist/commands/compressContext.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressContextCommand = compressContextCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function compressContextCommand(opts) {
+    const projectContext = (0, projectOptions_1.resolveProjectContext)(opts);
+    const repoRoot = projectContext.repoRoot;
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    if (!sm.getMeta()) {
+        console.log("[relay-baton] no session. Run `relay-baton init`.");
+        return;
+    }
+    const meta = sm.getMeta();
+    const profileName = (opts.diet ?? meta.tokenDietProfile ?? projectContext.project?.defaultDiet ?? config.tokenDiet.profile);
+    const profile = config.tokenDiet.profiles[profileName];
+    if (!profile) {
+        console.error(`unknown diet profile: ${profileName}`);
+        process.exit(2);
+    }
+    const threshold = opts.threshold != null ? Number(opts.threshold) : undefined;
+    if (threshold != null && (Number.isNaN(threshold) || threshold < 0 || threshold > 1)) {
+        console.error(`--threshold must be between 0 and 1 (got ${opts.threshold})`);
+        process.exit(2);
+    }
+    const compressor = new core_1.ContextCompressor(repoRoot, config);
+    const before = compressor.weigh(profile);
+    console.log(`[relay-baton] context weight: ${before.total}/${before.budget} chars (ratio ${before.ratio.toFixed(2)})`);
+    const result = compressor.compressIfNeeded(profile, { force: opts.force, threshold, dryRun: opts.dryRun });
+    if (opts.dryRun) {
+        console.log(`[relay-baton] dry-run: ${result.reason}`);
+        return;
+    }
+    if (!result.compressed) {
+        if (result.rolledBack) {
+            console.error("[relay-baton] compression rolled back (gate failed):");
+            for (const f of result.gateFailures ?? [])
+                console.error("  - " + f);
+            process.exit(3);
+        }
+        console.log(`[relay-baton] skipped: ${result.reason}`);
+        return;
+    }
+    sm.updateMeta({ status: "compressing" });
+    console.log(`[relay-baton] compressed: ${result.before.total} -> ${result.after?.total} chars`);
+    if (result.rotatedLog)
+        console.log(`[relay-baton] raw log rotated to ${result.rotatedLog}`);
+    // Compression is a transient phase; leave the prior status semantics intact.
+    sm.updateMeta({ status: meta.status });
+}