@relay-baton/cli 1.0.0

package/dist/commands/run.js

@@ -0,0 +1,323 @@
+"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.resolveChain = resolveChain;
+exports.runCommand = runCommand;
+const core_1 = require("@relay-baton/core");
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const projectOptions_1 = require("./projectOptions");
+const agentFor_1 = require("./agentFor");
+const auditApiKeyEnv_1 = require("./auditApiKeyEnv");
+/** Confirmation prompt for a bounded continue step. Resolves true on y/yes. */
+function confirm(question) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(/^\s*y(es)?\s*$/i.test(answer));
+        });
+    });
+}
+/**
+ * Deterministic "who's next" policy (v2.3): the relay chain is an ordered list
+ * of agents. `--chain` wins; otherwise it is [primary, fallback] resolved from
+ * flags > project overrides > config. Supports reverse (claude->codex) and
+ * longer chains, not just codex->claude.
+ */
+function resolveChain(opts, project, config, assignedAgent) {
+    let ids;
+    if (opts.chain) {
+        ids = opts.chain.split(",").map(s => s.trim()).filter(Boolean);
+    }
+    else {
+        // v2.6: a work item's assigned agent beats project/config defaults, but loses
+        // to explicit --primary/--chain flags.
+        const primary = opts.primary ?? assignedAgent ?? project?.primaryAgent ?? config.primaryAgent;
+        const fallback = opts.fallback ?? project?.fallbackAgent ?? config.fallbackAgent;
+        ids = fallback && fallback !== primary ? [primary, fallback] : [primary];
+    }
+    for (const id of ids) {
+        if (!(0, core_1.isAgentId)(id)) {
+            console.error(`[relay-baton] unknown agent in relay chain: ${id}`);
+            process.exit(2);
+        }
+    }
+    // Collapse immediate duplicates (a,a -> a); keep distinct relay hops.
+    const chain = [];
+    for (const id of ids)
+        if (chain[chain.length - 1] !== id)
+            chain.push(id);
+    return chain;
+}
+async function runCommand(task, opts) {
+    const projectContext = (0, projectOptions_1.resolveProjectContext)(opts, true);
+    const mainRoot = projectContext.repoRoot;
+    // v2.6 item 3: if the active work item is backed by a git worktree, execute in
+    // that isolated checkout (own working tree + own .ai-session) so parallel work
+    // items never clobber each other's git state. The workspace registry stays in
+    // the main repo.
+    const activeItem = new core_1.WorkspaceManager(mainRoot).activeSession();
+    const repoRoot = activeItem?.worktree && fs.existsSync(activeItem.worktree) ? activeItem.worktree : mainRoot;
+    if (repoRoot !== mainRoot)
+        console.log(`[relay-baton] session "${activeItem.name}" → worktree ${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);
+    }
+    // v2.6: honor the active work item's assigned agent as the default primary.
+    const assignedAgent = activeItem?.assignedAgent;
+    const chain = resolveChain(opts, projectContext.project, config, assignedAgent);
+    console.log(`[relay-baton] relay chain: ${chain.join(" → ")}${assignedAgent && !opts.primary && !opts.chain ? ` (session "${activeItem.name}" → ${assignedAgent})` : ""}`);
+    const startedAt = new Date().toISOString();
+    sm.updateMeta({
+        task,
+        status: "running",
+        primaryAgent: chain[0],
+        fallbackAgent: chain[1] ?? chain[0],
+        activeAgent: chain[0],
+        tokenDietProfile: profileName,
+        fallbackReason: null,
+        startedAt,
+        endedAt: undefined,
+        durationMs: undefined,
+    });
+    const finalize = (status, lastAgent, lastError) => {
+        const endedAt = new Date().toISOString();
+        sm.updateMeta({
+            status, lastAgent, activeAgent: "none", lastError,
+            endedAt, durationMs: Date.parse(endedAt) - Date.parse(startedAt),
+        });
+    };
+    // v2.5 project hooks (opt-in, local-only). No-op when unconfigured.
+    const hooks = new core_1.HookRunner(repoRoot, config);
+    const runHooks = (phase) => {
+        for (const r of hooks.run(phase, {
+            allowApiKeyEnv: opts.allowApiKeyEnv,
+            onStdout: l => process.stdout.write(l + "\n"),
+            onStderr: l => process.stderr.write(l + "\n"),
+        })) {
+            if (!r.ok)
+                console.error(`[relay-baton] hook failed (${phase}): ${r.command} → ${r.exitCode ?? r.error}`);
+        }
+    };
+    for (let hop = 0; hop < chain.length; hop++) {
+        const agent = chain[hop];
+        const isFirst = hop === 0;
+        const nextAgent = hop + 1 < chain.length ? chain[hop + 1] : null;
+        const adapter = (0, agentFor_1.adapterFor)(agent, config);
+        // First hop runs the task fresh; later hops continue from the handoff. Pass
+        // the continuation in both task+prompt so task- and prompt-oriented adapters
+        // alike launch with the handoff framing.
+        const continuation = core_1.PromptBuilder.continuation();
+        const cmd = isFirst
+            ? adapter.buildCommand({ task, repoRoot, sessionDir: sm.files.dir, dietProfile: profileName })
+            : adapter.buildCommand({ task: continuation, prompt: continuation, repoRoot, sessionDir: sm.files.dir, dietProfile: profileName });
+        // Only watch for fallback signals when there is a next agent to relay to.
+        const detector = nextAgent
+            ? new core_1.FallbackDetector((0, core_1.resolveFallbackPatterns)([...config.fallbackPatterns, ...(0, core_1.agentFallbackPatterns)(agent)], projectContext.project?.fallbackPatterns))
+            : undefined;
+        sm.updateMeta({ status: isFirst ? "running" : "running_fallback", activeAgent: agent });
+        console.log(`[relay-baton] running ${cmd.command} ${cmd.args.join(" ")}`);
+        const r = await (0, core_1.runAgent)({
+            command: cmd,
+            logFile: sm.files.p("commandsLog"),
+            authPolicy: config.authPolicy,
+            allowApiKeyEnv: opts.allowApiKeyEnv,
+            fallbackDetector: detector,
+            onStdout: l => process.stdout.write(l + "\n"),
+            onStderr: l => process.stderr.write(l + "\n"),
+            onFallback: hit => console.error(`[relay-baton] fallback pattern detected: ${hit.pattern}`),
+        });
+        (0, auditApiKeyEnv_1.auditApiKeyEnv)(repoRoot, r.passedThroughEnvVars, sm.getMeta()?.id);
+        if (r.error) {
+            console.error(r.error);
+            finalize("failed", agent, r.error);
+            process.exit(1);
+        }
+        const wantsFallback = r.fallbackReason !== null && nextAgent !== null;
+        if (!wantsFallback) {
+            // Terminal: either finished cleanly, or hit a limit with no one left to relay to.
+            if (r.fallbackReason !== null) {
+                sm.updateMeta({ fallbackReason: r.fallbackReason });
+                console.log(`[relay-baton] ${agent} hit a fallback signal but the relay chain is exhausted.`);
+            }
+            // v2.5: bounded auto-orchestration. Only when the agent finished cleanly
+            // and --until is set. Strictly capped, guardrail-gated, confirmation-first.
+            if (r.exitCode === 0 && r.fallbackReason === null && opts.until) {
+                await runUntilLoop(agent, { repoRoot, sm, config, profileName, opts, startedAt, finalize, runHooks });
+                return;
+            }
+            if (r.exitCode === 0)
+                runHooks("postExecute");
+            finalize(r.exitCode === 0 ? "completed" : "failed", agent, r.exitCode === 0 ? null : `${agent} exited with ${r.exitCode}`);
+            console.log(`[relay-baton] ${agent} finished. exiting.`);
+            return;
+        }
+        // Relay to the next agent: record fallback, (optionally) compress, build+gate handoff.
+        sm.updateMeta({ lastAgent: agent, activeAgent: "none", fallbackReason: r.fallbackReason, status: "fallback_detected", lastError: null });
+        if (config.contextCompression?.enabled && config.contextCompression?.auto) {
+            const cc = new core_1.ContextCompressor(repoRoot, config);
+            const res = cc.compressIfNeeded(config.tokenDiet.profiles[profileName], {});
+            if (res.compressed) {
+                sm.updateMeta({ status: "compressing" });
+                console.log(`[relay-baton] context compressed: ${res.before.total} -> ${res.after?.total} chars`);
+                sm.updateMeta({ status: "fallback_detected" });
+            }
+        }
+        runHooks("preHandoff");
+        console.log(`[relay-baton] building handoff for ${nextAgent}...`);
+        const wf = new core_1.BatonWorkflow(sm, config);
+        const h = wf.buildHandoff({ profileName, fallbackReason: r.fallbackReason, previousAgent: agent, nextAgent: nextAgent });
+        sm.updateMeta({ handoffCount: (sm.getMeta()?.handoffCount ?? 0) + 1 });
+        // v2.4 local usage insight (token proxy; never transmitted).
+        new core_1.UsageLedger(repoRoot).record("handoff", nextAgent, h.usedChars, `${agent}→${nextAgent}`);
+        const gate = new core_1.HandoffQualityGate(repoRoot).check();
+        const dietGate = new core_1.TokenDietQualityGate(repoRoot, profileName, config.tokenDiet.profiles[profileName]).check({ wasTruncated: h.truncated });
+        let blocked = false;
+        if (!gate.ok) {
+            console.error("Handoff Quality Gate failed:");
+            for (const f of gate.failures)
+                console.error("  - " + f);
+            blocked = true;
+        }
+        if (!dietGate.ok) {
+            console.error("Token Diet Quality Gate failed:");
+            for (const f of dietGate.failures)
+                console.error("  - " + f);
+            blocked = true;
+        }
+        for (const w of dietGate.warnings)
+            console.error("warn: " + w);
+        const highFindings = h.redaction.findings.filter(f => f.severity === "high");
+        if (highFindings.length > 0) {
+            console.error("Redaction Gate failed (handoff would leak secrets to the next agent):");
+            for (const f of highFindings)
+                console.error(`  - ${f.category}: ${f.file}${f.line ? ":" + f.line : ""} (${f.hint})`);
+            blocked = true;
+        }
+        for (const f of h.redaction.findings.filter(f => f.severity !== "high")) {
+            console.error(`warn: redaction ${f.category} in ${f.file}${f.line ? ":" + f.line : ""} (${f.hint})`);
+        }
+        if (blocked && !opts.force) {
+            console.error("[relay-baton] aborting fallback launch. Use --force to override.");
+            process.exit(3);
+        }
+        // loop continues to nextAgent
+    }
+}
+/**
+ * v2.5 bounded auto-orchestration. STRICTLY bounded: capped by --until (and the
+ * guardrail step cap), gated by GuardrailPolicy each step, and confirmation-first
+ * unless --yes. Never a daemon, never unattended without explicit pre-approval.
+ */
+async function runUntilLoop(agent, ctx) {
+    const { repoRoot, sm, config, profileName, opts, startedAt, finalize, runHooks } = ctx;
+    const maxSteps = Math.max(1, Math.floor(Number(opts.until)) || 0);
+    if (maxSteps < 1) {
+        finalize("completed", agent, null);
+        return;
+    }
+    const budgetCeiling = config.guardrails?.maxBudgetRatio ?? 0.9;
+    const orch = new core_1.BoundedOrchestrator({
+        maxSteps,
+        budgetCeiling,
+        evaluateGuardrail: () => new core_1.GuardrailPolicy(repoRoot, config).evaluate(),
+    });
+    const checkpoints = new core_1.ExecutionCheckpoints(repoRoot, config);
+    const ledger = new core_1.UsageLedger(repoRoot);
+    const adapter = (0, agentFor_1.adapterFor)(agent, config);
+    console.log(`[relay-baton] bounded auto-orchestration: up to ${maxSteps} extra step(s) on ${agent} (guardrail-gated${opts.yes ? "" : ", confirm each"})`);
+    let obs = {};
+    for (;;) {
+        const d = orch.next(obs);
+        if (!d.proceed) {
+            console.log(`[relay-baton] bounded loop stopped: ${d.reason ?? "done"}`);
+            if (d.guardrail?.blocked)
+                for (const v of d.guardrail.violations)
+                    console.log(`  - ${v.message}`);
+            break;
+        }
+        if (d.requireConfirmation && !opts.yes) {
+            const ok = await confirm(`[relay-baton] continue step ${d.step}/${maxSteps} on ${agent}? [y/N] `);
+            if (!ok) {
+                console.log("[relay-baton] declined — stopping bounded loop.");
+                break;
+            }
+        }
+        sm.updateMeta({ status: "running", activeAgent: agent });
+        const continuation = core_1.PromptBuilder.continuation();
+        const cmd = adapter.buildCommand({ task: continuation, prompt: continuation, repoRoot, sessionDir: sm.files.dir, dietProfile: profileName });
+        console.log(`[relay-baton] [until ${d.step}/${maxSteps}] running ${cmd.command} ${cmd.args.join(" ")}`);
+        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"),
+        });
+        (0, auditApiKeyEnv_1.auditApiKeyEnv)(repoRoot, r.passedThroughEnvVars, sm.getMeta()?.id);
+        if (r.error || r.exitCode !== 0) {
+            finalize("failed", agent, r.error ?? `${agent} exited with ${r.exitCode}`);
+            console.error(`[relay-baton] bounded step failed; stopping.`);
+            process.exit(1);
+        }
+        checkpoints.append({ step: d.step, command: `run --until step ${d.step}`, result: "ok" });
+        const handoffChars = (() => { try {
+            return require("fs").statSync(sm.files.p("handoff")).size;
+        }
+        catch {
+            return 0;
+        } })();
+        ledger.record("run", agent, handoffChars, `until ${d.step}/${maxSteps}`);
+        const summary = new core_1.GitService(repoRoot).summary(0);
+        obs = { budgetRatio: undefined, progressKey: `${summary.head}:${summary.changed}` };
+    }
+    runHooks("postExecute");
+    finalize("completed", agent, null);
+    console.log(`[relay-baton] ${agent} bounded loop finished. exiting.`);
+}

package/dist/commands/session.d.ts

@@ -0,0 +1,40 @@
+export interface SessionArchiveOpts {
+    project?: string;
+    path?: string;
+    json?: boolean;
+    dryRun?: boolean;
+    out?: string;
+}
+export declare function sessionArchiveCommand(opts?: SessionArchiveOpts): Promise<void>;
+export interface SessionListOpts {
+    json?: boolean;
+    out?: string;
+}
+export declare function sessionListCommand(opts?: SessionListOpts): Promise<void>;
+export interface SessionPruneOpts {
+    json?: boolean;
+    out?: string;
+    maxAgeDays?: string;
+    maxCount?: string;
+    apply?: boolean;
+}
+export declare function sessionPruneCommand(opts?: SessionPruneOpts): Promise<void>;
+export interface SessionExportOpts {
+    json?: boolean;
+    out?: string;
+    to?: string;
+    overwrite?: boolean;
+}
+export declare function sessionExportCommand(archive: string, opts?: SessionExportOpts): Promise<void>;
+export interface SessionInspectOpts {
+    json?: boolean;
+    out?: string;
+}
+export declare function sessionInspectCommand(archive: string, opts?: SessionInspectOpts): Promise<void>;
+export interface SessionResumeOpts {
+    project?: string;
+    path?: string;
+    json?: boolean;
+    staleHours?: string;
+}
+export declare function sessionResumeCommand(opts?: SessionResumeOpts): Promise<void>;

package/dist/commands/session.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionArchiveCommand = sessionArchiveCommand;
+exports.sessionListCommand = sessionListCommand;
+exports.sessionPruneCommand = sessionPruneCommand;
+exports.sessionExportCommand = sessionExportCommand;
+exports.sessionInspectCommand = sessionInspectCommand;
+exports.sessionResumeCommand = sessionResumeCommand;
+const core_1 = require("@relay-baton/core");
+const projectOptions_1 = require("./projectOptions");
+async function sessionArchiveCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const result = new core_1.SessionArchiver(repoRoot).archive({
+        archiveRoot: opts.out,
+        dryRun: opts.dryRun,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.available) {
+        console.log(`[relay-baton] session archive unavailable: ${result.reason}`);
+        return;
+    }
+    const count = result.manifest?.files.length ?? 0;
+    const prefix = result.dryRun ? "would archive" : "archived";
+    console.log(`[relay-baton] ${prefix} ${count} file(s)`);
+    console.log(`archive: ${result.archiveDir}`);
+    if (!result.dryRun)
+        console.log("manifest: manifest.json");
+}
+async function sessionListCommand(opts = {}) {
+    const result = new core_1.SessionArchiveStore({ archiveRoot: opts.out }).list();
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.available) {
+        console.log(`[relay-baton] no session archives: ${result.reason}`);
+        console.log(`archive root: ${result.archiveRoot}`);
+        return;
+    }
+    if (result.archives.length === 0) {
+        console.log("[relay-baton] no session archives found");
+        console.log(`archive root: ${result.archiveRoot}`);
+        return;
+    }
+    console.log(`[relay-baton] ${result.archives.length} session archive(s) in ${result.archiveRoot}`);
+    for (const a of result.archives) {
+        const flag = a.valid ? "" : " (invalid)";
+        const when = a.createdAt ?? "unknown";
+        console.log(`- ${a.id}${flag}  ${a.fileCount} file(s), ${a.totalBytes} bytes, ${when}`);
+    }
+}
+async function sessionPruneCommand(opts = {}) {
+    const maxAgeDays = opts.maxAgeDays != null ? Number.parseFloat(opts.maxAgeDays) : undefined;
+    const maxCount = opts.maxCount != null ? Number.parseInt(opts.maxCount, 10) : undefined;
+    for (const [flag, v] of [["--max-age-days", maxAgeDays], ["--max-count", maxCount]]) {
+        if (v !== undefined && (!Number.isFinite(v) || v < 0)) {
+            console.error(`[relay-baton] ${flag} must be a non-negative number`);
+            process.exit(2);
+        }
+    }
+    const result = new core_1.SessionArchiveStore({ archiveRoot: opts.out }).prune({
+        maxAgeDays,
+        maxCount,
+        dryRun: !opts.apply,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.available) {
+        console.log(`[relay-baton] cannot prune: ${result.reason}`);
+        return;
+    }
+    if (result.policy.maxAgeDays === null && result.policy.maxCount === null) {
+        console.log("[relay-baton] no retention policy — pass --max-age-days and/or --max-count. Nothing pruned.");
+        return;
+    }
+    const verb = result.dryRun ? "would prune" : "pruned";
+    console.log(`[relay-baton] ${verb} ${result.pruned.length} archive(s), keeping ${result.kept.length}${result.dryRun ? " (dry-run)" : ""}`);
+    for (const p of result.pruned)
+        console.log(`- ${p.id} (${p.createdAt ?? "unknown"}) — ${p.reason}`);
+    if (result.dryRun && result.pruned.length > 0)
+        console.log("re-run with --apply to delete the above.");
+}
+async function sessionExportCommand(archive, opts = {}) {
+    if (!opts.to) {
+        console.error("[relay-baton] missing required option: --to <dir>");
+        process.exit(2);
+    }
+    const result = new core_1.SessionArchiveStore({ archiveRoot: opts.out }).exportArchive(archive, opts.to, { overwrite: opts.overwrite });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.available) {
+        console.log(`[relay-baton] cannot export: ${result.reason}`);
+        return;
+    }
+    console.log(`[relay-baton] exported ${result.id}`);
+    console.log(`to: ${result.dest}`);
+}
+async function sessionInspectCommand(archive, opts = {}) {
+    const result = new core_1.SessionArchiveStore({ archiveRoot: opts.out }).inspect(archive);
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (!result.available) {
+        console.log(`[relay-baton] cannot inspect archive: ${result.reason}`);
+        return;
+    }
+    console.log(`[relay-baton] archive ${result.id}`);
+    console.log(`repoRoot: ${result.repoRoot ?? "unknown"}`);
+    console.log(`createdAt: ${result.createdAt ?? "unknown"}`);
+    console.log(`files: ${result.fileCount}, total ${result.totalBytes} bytes`);
+    console.log(`integrity: ${result.intact ? "intact" : "DAMAGED"}`);
+    console.log(`trust: ${result.safe ? "safe" : "UNSAFE — do not import"}`);
+    if (result.missing.length > 0)
+        console.log(`missing: ${result.missing.join(", ")}`);
+    if (result.corrupt.length > 0)
+        console.log(`corrupt: ${result.corrupt.join(", ")}`);
+    if (result.unsafe.length > 0) {
+        console.log(`⚠ unsafe targets (path traversal / oversized): ${result.unsafe.length}`);
+        for (const f of result.files.filter(x => !x.safe)) {
+            console.log(`  - [${f.unsafeReason}] ${f.target}`);
+        }
+    }
+}
+async function sessionResumeCommand(opts = {}) {
+    const repoRoot = (0, projectOptions_1.resolveRepoRoot)(opts);
+    core_1.ConfigLoader.load(repoRoot);
+    const staleHours = opts.staleHours != null ? Number.parseFloat(opts.staleHours) : undefined;
+    const result = new core_1.ResumeDiagnostics(repoRoot).diagnose({
+        staleHours: Number.isFinite(staleHours) ? staleHours : undefined,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`[relay-baton] session resume diagnosis: ${result.status}`);
+    if (result.meta?.task)
+        console.log(`task: ${result.meta.task}`);
+    if (result.findings.length > 0) {
+        console.log("findings:");
+        for (const f of result.findings)
+            console.log(`- ${f}`);
+    }
+    else {
+        console.log("findings: none");
+    }
+    console.log("suggested next:");
+    for (const s of result.suggestions)
+        console.log(`- relay-baton ${s.command}  (${s.reason})`);
+}

package/dist/commands/sessionWorkspace.d.ts

@@ -0,0 +1,25 @@
+import { ProjectOpts } from "./projectOptions";
+export interface SessionWorkOpts extends ProjectOpts {
+    json?: boolean;
+    switch?: boolean;
+    agent?: string;
+    init?: boolean;
+    deleteFiles?: boolean;
+    branch?: string;
+    worktreePath?: string;
+    force?: boolean;
+}
+/** `session new <name>` — create a named work item (optionally switch + init). */
+export declare function sessionNewCommand(name: string, opts?: SessionWorkOpts): Promise<void>;
+/** `session switch|use <name>` — set the active work item. */
+export declare function sessionSwitchCommand(name: string, opts?: SessionWorkOpts): Promise<void>;
+/** `session items` — list work items in this repo (read-only). */
+export declare function sessionItemsCommand(opts?: SessionWorkOpts): Promise<void>;
+/** `session assign <name> <agent>` — pin a work item to an agent (v2.6 item 2 groundwork). */
+export declare function sessionAssignCommand(name: string, agent: string, opts?: SessionWorkOpts): Promise<void>;
+/** `session worktree add <name>` — back a work item with an isolated git worktree. */
+export declare function sessionWorktreeAddCommand(name: string, opts?: SessionWorkOpts): Promise<void>;
+/** `session worktree remove <name>` — detach + remove the work item's worktree. */
+export declare function sessionWorktreeRemoveCommand(name: string, opts?: SessionWorkOpts): Promise<void>;
+/** `session remove <name>` — drop a named work item (never default). */
+export declare function sessionRemoveCommand(name: string, opts?: SessionWorkOpts): Promise<void>;