@relay-baton/cli 1.0.0

package/dist/commands/sessionWorkspace.js

@@ -0,0 +1,193 @@
+"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.sessionNewCommand = sessionNewCommand;
+exports.sessionSwitchCommand = sessionSwitchCommand;
+exports.sessionItemsCommand = sessionItemsCommand;
+exports.sessionAssignCommand = sessionAssignCommand;
+exports.sessionWorktreeAddCommand = sessionWorktreeAddCommand;
+exports.sessionWorktreeRemoveCommand = sessionWorktreeRemoveCommand;
+exports.sessionRemoveCommand = sessionRemoveCommand;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const core_2 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+/** Default isolated worktree location: `<parent>/<repo>.worktrees/<name>`. */
+function defaultWorktreePath(repoRoot, name) {
+    return path.join(path.dirname(repoRoot), `${path.basename(repoRoot)}.worktrees`, name);
+}
+/** `session new <name>` — create a named work item (optionally switch + init). */
+async function sessionNewCommand(name, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    if (opts.agent && !(0, core_2.isAgentId)(opts.agent)) {
+        console.error(`[relay-baton] unknown agent: ${opts.agent}`);
+        process.exit(2);
+    }
+    try {
+        wm.create(name, { assignedAgent: opts.agent, activate: opts.switch });
+    }
+    catch (e) {
+        console.error(`[relay-baton] ${e?.message ?? e}`);
+        process.exit(2);
+    }
+    // Initialize the new work item's .ai-session artifacts (default: yes).
+    if (opts.init !== false)
+        new core_1.SessionManager(repoRoot, config, name).init("");
+    if (opts.json) {
+        console.log(JSON.stringify(wm.load(), null, 2));
+        return;
+    }
+    console.log(`[relay-baton] created session "${name}"${opts.agent ? ` (agent: ${opts.agent})` : ""}${opts.switch ? " and switched to it" : ""}.`);
+    if (!opts.switch)
+        console.log(`  → activate with: relay-baton session switch ${name}`);
+}
+/** `session switch|use <name>` — set the active work item. */
+async function sessionSwitchCommand(name, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    try {
+        wm.switchTo(name);
+    }
+    catch (e) {
+        console.error(`[relay-baton] ${e?.message ?? e}`);
+        process.exit(2);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(wm.load(), null, 2));
+        return;
+    }
+    console.log(`[relay-baton] active session → ${name}`);
+}
+/** `session items` — list work items in this repo (read-only). */
+async function sessionItemsCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    const ws = wm.load();
+    if (opts.json) {
+        console.log(JSON.stringify(ws, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] sessions (active: ${ws.active})`);
+    for (const s of ws.sessions) {
+        const mark = s.name === ws.active ? "*" : " ";
+        const agent = s.assignedAgent ? ` [${s.assignedAgent}]` : "";
+        console.log(`  ${mark} ${s.name}${agent}`);
+    }
+}
+/** `session assign <name> <agent>` — pin a work item to an agent (v2.6 item 2 groundwork). */
+async function sessionAssignCommand(name, agent, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    if (agent !== "none" && !(0, core_2.isAgentId)(agent)) {
+        console.error(`[relay-baton] unknown agent: ${agent} (use an agent id or "none")`);
+        process.exit(2);
+    }
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    try {
+        wm.assignAgent(name, agent === "none" ? undefined : agent);
+    }
+    catch (e) {
+        console.error(`[relay-baton] ${e?.message ?? e}`);
+        process.exit(2);
+    }
+    console.log(`[relay-baton] session "${name}" agent → ${agent}`);
+}
+/** `session worktree add <name>` — back a work item with an isolated git worktree. */
+async function sessionWorktreeAddCommand(name, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    if (!wm.has(name)) {
+        console.error(`[relay-baton] unknown session: ${name} (create it first with \`session new ${name}\`)`);
+        process.exit(2);
+    }
+    const git = new core_1.GitService(repoRoot);
+    if (!git.isGitRepo()) {
+        console.error("[relay-baton] not a git repository. worktrees require git.");
+        process.exit(2);
+    }
+    const dir = opts.worktreePath ? path.resolve(opts.worktreePath) : defaultWorktreePath(repoRoot, name);
+    if (fs.existsSync(dir)) {
+        console.error(`[relay-baton] worktree path already exists: ${dir}`);
+        process.exit(2);
+    }
+    const branch = opts.branch ?? `relay/${name}`;
+    const res = git.addWorktree(dir, branch);
+    if (!res.ok) {
+        console.error(`[relay-baton] git worktree add failed: ${res.error}`);
+        process.exit(1);
+    }
+    wm.setWorktree(name, dir);
+    console.log(`[relay-baton] worktree for "${name}" → ${dir} (branch ${branch})`);
+    console.log(`  run/handoff for "${name}" now execute in this isolated checkout.`);
+}
+/** `session worktree remove <name>` — detach + remove the work item's worktree. */
+async function sessionWorktreeRemoveCommand(name, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    const entry = wm.load().sessions.find(s => s.name === name);
+    if (!entry?.worktree) {
+        console.error(`[relay-baton] session "${name}" has no worktree.`);
+        process.exit(2);
+    }
+    const res = new core_1.GitService(repoRoot).removeWorktree(entry.worktree, opts.force);
+    if (!res.ok) {
+        console.error(`[relay-baton] git worktree remove failed: ${res.error}`);
+        console.error("  (commit/stash changes in the worktree, or pass --force)");
+        process.exit(1);
+    }
+    wm.setWorktree(name, undefined);
+    console.log(`[relay-baton] removed worktree for "${name}".`);
+}
+/** `session remove <name>` — drop a named work item (never default). */
+async function sessionRemoveCommand(name, opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const wm = new core_1.WorkspaceManager(repoRoot);
+    try {
+        wm.remove(name, { deleteFiles: opts.deleteFiles });
+    }
+    catch (e) {
+        console.error(`[relay-baton] ${e?.message ?? e}`);
+        process.exit(2);
+    }
+    console.log(`[relay-baton] removed session "${name}"${opts.deleteFiles ? " (files deleted)" : ""}. active → ${wm.activeName()}`);
+}

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,116 @@
+"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.statusCommand = statusCommand;
+const fs = __importStar(require("fs"));
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function statusCommand(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();
+    if (!meta) {
+        if (opts.json) {
+            console.log(JSON.stringify({ session: false }, null, 2));
+            return;
+        }
+        console.log("[relay-baton] no session. Run `relay-baton init`.");
+        return;
+    }
+    const handoff = sm.files.p("handoff");
+    const budget = sm.files.p("contextBudget");
+    const changed = sm.files.p("changedFiles");
+    const git = new core_1.GitService(repoRoot);
+    const gitSummary = git.summary(20);
+    const gitTracking = git.compareBaseline(readGitBaseline(sm.files.p("gitBaseline")));
+    let changedCount = 0;
+    try {
+        const txt = fs.readFileSync(changed, "utf8");
+        changedCount = txt.split("\n").filter(l => l.startsWith("- ")).length;
+    }
+    catch { /**/ }
+    if (opts.json) {
+        console.log(JSON.stringify({
+            session: true,
+            task: meta.task || null,
+            status: meta.status,
+            activeAgent: meta.activeAgent,
+            lastAgent: meta.lastAgent,
+            primaryAgent: meta.primaryAgent,
+            fallbackAgent: meta.fallbackAgent,
+            fallbackReason: meta.fallbackReason ?? null,
+            tokenDietProfile: meta.tokenDietProfile,
+            changedFiles: changedCount,
+            handoffExists: fs.existsSync(handoff),
+            contextBudgetExists: fs.existsSync(budget),
+            git: {
+                available: gitSummary.available,
+                branch: gitSummary.branch,
+                head: gitSummary.head,
+                clean: gitSummary.clean,
+                changed: gitSummary.changed,
+                staged: gitSummary.staged,
+                unstaged: gitSummary.unstaged,
+                untracked: gitSummary.untracked,
+                tracking: gitTracking,
+            },
+            lastError: meta.lastError ?? null,
+        }, null, 2));
+        return;
+    }
+    console.log("task:", meta.task || "(none)");
+    console.log("status:", meta.status);
+    console.log("activeAgent:", meta.activeAgent);
+    console.log("lastAgent:", meta.lastAgent);
+    console.log("primaryAgent:", meta.primaryAgent);
+    console.log("fallbackAgent:", meta.fallbackAgent);
+    console.log("fallbackReason:", meta.fallbackReason ?? "(none)");
+    console.log("tokenDietProfile:", meta.tokenDietProfile);
+    console.log("changed files:", changedCount);
+    console.log("git:", gitSummary.available ? `${gitSummary.branch ?? "(detached)"} · ${gitSummary.changed} changed` : "unavailable");
+    console.log("git changed since session start:", gitTracking.changedSinceBaseline == null ? "(no baseline)" : (gitTracking.changedSinceBaseline ? "yes" : "no"));
+    console.log("handoff.md exists:", fs.existsSync(handoff));
+    console.log("context-budget.json exists:", fs.existsSync(budget));
+    console.log("lastError:", meta.lastError ?? "(none)");
+}
+function readGitBaseline(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/commands/tui.d.ts

@@ -0,0 +1,4 @@
+export declare function tuiCommand(opts?: {
+    project?: string;
+    path?: string;
+}): Promise<void>;

package/dist/commands/tui.js

@@ -0,0 +1,46 @@
+"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.tuiCommand = tuiCommand;
+async function tuiCommand(opts = {}) {
+    try {
+        const mod = await Promise.resolve().then(() => __importStar(require("@relay-baton/tui")));
+        await mod.startTui(opts);
+    }
+    catch (e) {
+        console.error("[relay-baton] failed to start TUI:", e?.message ?? e);
+        process.exit(1);
+    }
+}

package/dist/commands/usage.d.ts

@@ -0,0 +1,11 @@
+import { ProjectOpts } from "./projectOptions";
+export interface UsageOpts extends ProjectOpts {
+    json?: boolean;
+}
+/**
+ * v2.4 — local usage insight. Aggregates the per-session usage ledger
+ * (`.ai-session/usage.jsonl`) into a token-proxy summary for budgeting. Read-only
+ * and local: nothing is transmitted, and the proxy is ceil(chars/4), not a real
+ * tokenizer.
+ */
+export declare function usageCommand(opts?: UsageOpts): Promise<void>;

package/dist/commands/usage.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usageCommand = usageCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+/**
+ * v2.4 — local usage insight. Aggregates the per-session usage ledger
+ * (`.ai-session/usage.jsonl`) into a token-proxy summary for budgeting. Read-only
+ * and local: nothing is transmitted, and the proxy is ceil(chars/4), not a real
+ * tokenizer.
+ */
+async function usageCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const sm = new core_1.SessionManager(repoRoot, config);
+    const activeProfile = (sm.getMeta()?.tokenDietProfile ?? config.tokenDiet.profile);
+    const maxHandoffChars = config.tokenDiet.profiles[activeProfile]?.maxHandoffChars;
+    const summary = new core_1.UsageLedger(repoRoot).summarize(maxHandoffChars);
+    if (opts.json) {
+        console.log(JSON.stringify({ activeProfile, maxHandoffChars, ...summary }, null, 2));
+        return;
+    }
+    if (!summary.available) {
+        console.log("[relay-baton] no usage recorded yet (run a relay/handoff first).");
+        return;
+    }
+    console.log(`[relay-baton] usage (local only — ${summary.proxyNote})`);
+    console.log(`active profile: ${activeProfile} (maxHandoffChars=${maxHandoffChars})`);
+    console.log(`events: ${summary.events} · handoffs: ${summary.handoffCount}`);
+    console.log(`total: ${summary.totalChars} chars ≈ ${summary.totalTokensProxy} tokens (proxy)`);
+    if (summary.budgetRatio !== null) {
+        console.log(`budget ratio vs one handoff budget: ${summary.budgetRatio}×`);
+    }
+    console.log("by type:");
+    for (const [k, v] of Object.entries(summary.byType))
+        console.log(`  - ${k}: ${v} tokens`);
+    console.log("by agent:");
+    for (const [k, v] of Object.entries(summary.byAgent))
+        console.log(`  - ${k}: ${v} tokens`);
+}

package/dist/commands/verify.d.ts

@@ -0,0 +1,15 @@
+import type { DietProfileName } from "@relay-baton/shared";
+import { ProjectOpts } from "./projectOptions";
+export interface VerifyOpts extends ProjectOpts {
+    diet?: DietProfileName;
+    realAgents?: boolean;
+    keepTemp?: boolean;
+    verbose?: boolean;
+}
+/**
+ * `verify` runs a deterministic, simulated end-to-end pass over the relay-baton
+ * pipeline WITHOUT calling any real model. It proves the wiring works: repo
+ * resolution, environment, fallback detection, handoff generation (no-run),
+ * token budget, and the API-key env block.
+ */
+export declare function verifyCommand(opts?: VerifyOpts): Promise<void>;

package/dist/commands/verify.js

@@ -0,0 +1,197 @@
+"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.verifyCommand = verifyCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+const diagnostics_1 = require("./diagnostics");
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+function mark(status) {
+    return status === "pass" ? `${GREEN}PASS${RESET}`
+        : status === "warn" ? `${YELLOW}WARN${RESET}`
+            : `${RED}FAIL${RESET}`;
+}
+/**
+ * `verify` runs a deterministic, simulated end-to-end pass over the relay-baton
+ * pipeline WITHOUT calling any real model. It proves the wiring works: repo
+ * resolution, environment, fallback detection, handoff generation (no-run),
+ * token budget, and the API-key env block.
+ */
+async function verifyCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const { config } = core_1.ConfigLoader.load(repoRoot);
+    const results = [];
+    const log = (s) => { if (opts.verbose)
+        console.log(`${DIM}  ${s}${RESET}`); };
+    console.log(`${BOLD}relay-baton verify${RESET}  ${DIM}${repoRoot}${RESET}`);
+    if (opts.realAgents) {
+        console.log(`${YELLOW}--real-agents is experimental scaffolding and is NOT executed; running simulated checks only.${RESET}`);
+    }
+    // 1) repoRoot resolution + doctor core checks.
+    const core = (0, diagnostics_1.coreChecks)(repoRoot, config);
+    const coreFail = core.filter(c => c.status === "fail");
+    results.push({
+        name: "environment (doctor core)",
+        status: coreFail.length > 0 ? "fail" : "pass",
+        detail: coreFail.length > 0 ? `failing: ${coreFail.map(c => c.label).join(", ")}` : `${core.length} checks ok`,
+    });
+    // 2) Fallback phrase simulation: real phrases detected, grep/result-like lines ignored.
+    const detector = new core_1.FallbackDetector(config.fallbackPatterns);
+    const realPhrase = config.fallbackPatterns[0] ?? "usage limit reached";
+    const simulatedOutput = [
+        "Working on the task...",
+        "src/foo.ts:42:  // mentions rate limit exceeded in a comment", // grep-like: must be ignored
+        `Error: ${realPhrase} — please try again later.`, // real: must be detected
+    ];
+    let detectedReal = false;
+    let detectedNoise = false;
+    for (const line of simulatedOutput) {
+        const hit = detector.feed(line);
+        if (!hit)
+            continue;
+        if (line.includes(":42:"))
+            detectedNoise = true;
+        else
+            detectedReal = true;
+        log(`fallback hit: ${hit.pattern}`);
+    }
+    results.push({
+        name: "fallback detection",
+        status: detectedReal && !detectedNoise ? "pass" : "fail",
+        detail: detectedReal
+            ? (detectedNoise ? "detected real phrase but also matched a grep-like line" : "detected real phrase, ignored grep-like line")
+            : "did not detect the simulated fallback phrase",
+    });
+    // 3) Handoff no-run workflow against a throwaway temp repo (never touches the real .ai-session).
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "relay-baton-verify-"));
+    let handoffOk = false;
+    let handoffDetail = "";
+    try {
+        // Real git init + empty commit so GitService.diff("HEAD") is clean (no noise).
+        const g = (args) => (0, child_process_1.spawnSync)("git", args, { cwd: tmpRoot, encoding: "utf8", stdio: "ignore" });
+        g(["init"]);
+        g(["config", "user.email", "verify@relay-baton.local"]);
+        g(["config", "user.name", "relay-baton verify"]);
+        g(["commit", "--allow-empty", "-m", "verify base"]);
+        const sm = new core_1.SessionManager(tmpRoot, config);
+        sm.init("verify: simulated handoff (no real agent)");
+        sm.updateMeta({ fallbackReason: `simulated fallback: ${realPhrase}`, lastAgent: "codex" });
+        const diet = (opts.diet ?? config.tokenDiet.profile);
+        const wf = new core_1.BatonWorkflow(sm, config);
+        const result = wf.buildHandoff({
+            profileName: diet,
+            fallbackReason: `simulated fallback: ${realPhrase}`,
+            previousAgent: "codex",
+            nextAgent: "claude",
+        });
+        handoffOk = fs.existsSync(result.handoffPath) && fs.readFileSync(result.handoffPath, "utf8").trim().length > 0;
+        handoffDetail = handoffOk ? `wrote ${path.basename(result.handoffPath)} (diet=${diet}, ${result.usedChars} chars)` : "handoff.md missing or empty";
+        log(`temp handoff: ${result.handoffPath}`);
+    }
+    catch (e) {
+        handoffDetail = `error: ${e?.message ?? e}`;
+    }
+    results.push({ name: "handoff (no-run)", status: handoffOk ? "pass" : "fail", detail: handoffDetail });
+    // 4) Token budget check on the generated handoff.
+    let budgetOk = false;
+    let budgetDetail = "";
+    try {
+        const sm = new core_1.SessionManager(tmpRoot, config);
+        const handoff = fs.readFileSync(sm.files.p("handoff"), "utf8");
+        const diet = opts.diet ?? config.tokenDiet.profile;
+        const max = config.tokenDiet.profiles[diet]?.maxHandoffChars ?? 0;
+        budgetOk = max === 0 || handoff.length <= max;
+        budgetDetail = `${handoff.length} chars / ${max} budget (${diet})`;
+    }
+    catch (e) {
+        budgetDetail = `error: ${e?.message ?? e}`;
+    }
+    results.push({ name: "token budget", status: budgetOk ? "pass" : "warn", detail: budgetDetail });
+    // 5) API key env block check (default policy strips blocked vars).
+    let envOk = true;
+    let envDetail = "blocked vars stripped from child env";
+    try {
+        const fakeEnv = { ...process.env };
+        for (const ev of config.authPolicy.blockedEnvVars)
+            fakeEnv[ev] = "test-secret-should-be-stripped";
+        const { env: childEnv } = (0, core_1.createAgentEnv)(fakeEnv, config.authPolicy, false);
+        const leaked = config.authPolicy.blockedEnvVars.filter(ev => childEnv[ev] != null);
+        envOk = leaked.length === 0;
+        envDetail = envOk ? "blocked vars stripped from child env" : `LEAKED: ${leaked.join(", ")}`;
+    }
+    catch (e) {
+        envOk = false;
+        envDetail = `error: ${e?.message ?? e}`;
+    }
+    results.push({ name: "api-key env block", status: envOk ? "pass" : "fail", detail: envDetail });
+    // Cleanup temp repo.
+    if (!opts.keepTemp) {
+        try {
+            fs.rmSync(tmpRoot, { recursive: true, force: true });
+        }
+        catch { /* best effort */ }
+    }
+    else {
+        console.log(`${DIM}  kept temp repo: ${tmpRoot}${RESET}`);
+    }
+    // Summary.
+    console.log(`\n${CYAN}${BOLD}Verification steps${RESET}`);
+    for (const r of results) {
+        console.log(`  ${mark(r.status)}  ${r.name.padEnd(28)} ${DIM}${r.detail}${RESET}`);
+    }
+    const fails = results.filter(r => r.status === "fail").length;
+    const warns = results.filter(r => r.status === "warn").length;
+    console.log("");
+    if (fails > 0) {
+        console.log(`${RED}verify FAILED — ${fails} failing step(s), ${warns} warning(s).${RESET}`);
+        process.exitCode = 1;
+    }
+    else if (warns > 0) {
+        console.log(`${YELLOW}verify passed with ${warns} warning(s).${RESET}`);
+    }
+    else {
+        console.log(`${GREEN}verify passed — pipeline wiring is healthy (no real model calls).${RESET}`);
+    }
+}

package/dist/commands/workspace.d.ts

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

package/dist/commands/workspace.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceCommand = workspaceCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function workspaceCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    const map = new core_1.WorkspaceMap(repoRoot).generate();
+    if (opts.json) {
+        console.log(JSON.stringify(map, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] workspace map: ${repoRoot}`);
+    console.log(`package managers: ${map.packageManagers.join(", ") || "-"}`);
+    console.log(`languages: ${map.languages.join(", ") || "-"}`);
+    console.log(`monorepo: ${map.monorepo ? "yes" : "no"}${map.packages.length ? ` (${map.packages.length} package(s))` : ""}`);
+    for (const p of map.packages)
+        console.log(`  - ${p.name} (${p.path})`);
+    console.log(`build: ${map.scripts.build ?? "-"}`);
+    console.log(`test: ${map.scripts.test ?? "-"}`);
+    console.log(`lint: ${map.scripts.lint ?? "-"}`);
+    if (map.scripts.others.length)
+        console.log(`other scripts: ${map.scripts.others.join(", ")}`);
+    console.log(`entry points: ${map.entryPoints.join(", ") || "-"}`);
+    console.log(`docs: ${map.docs.join(", ") || "-"}`);
+    console.log(`agents files: ${map.agentsFiles.join(", ") || "-"}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};