agent-tempo 1.0.1

package/dist/cli/legacy-migration.js

@@ -0,0 +1,335 @@
+"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.MIGRATION_MARKER_FILENAME = void 0;
+exports.migrateLegacyHome = migrateLegacyHome;
+exports.formatMigrationResult = formatMigrationResult;
+/**
+ * Legacy home migration — `~/.claude-tempo/` → `~/.agent-tempo/`.
+ *
+ * PR-2 of the v1.0 rebrand renames the on-disk profile directory. This
+ * helper performs a one-shot copy on first boot of the new binary so
+ * users don't lose their saved config / lineups / state.
+ *
+ * Contract (see brief):
+ *   1. **Idempotent.** Re-running on a migrated home is `'already-migrated'`.
+ *   2. **Copy, not move.** Legacy `~/.claude-tempo/` stays untouched as a
+ *      safety net for one release.
+ *   3. **Marker file.** Writes `~/.agent-tempo/.migrated-from-claude-tempo`
+ *      with `{ migratedAt, copiedFromHash, files }`.
+ *   4. **Conflict policy.** If `~/.agent-tempo/` exists AND has no marker,
+ *      refuse with `'skipped'`; user must pass `force: true` or delete.
+ *      Don't clobber a user-initiated new home.
+ *   5. **Partial-copy resume.** Per-file SHA-256 in the marker — re-running
+ *      a partially-completed run finishes only the missing/changed files.
+ *   6. **Files copied.** Allowlist — `config.json`, `.bootstrap-cache.json`,
+ *      any `*.yaml` user-stashed lineup files, plus subdirs `lineups/`,
+ *      `state/`, `coat-check/` (forward-compat — fine if absent). The
+ *      volatile runtime trio (`daemon.pid`, `daemon.port`, `daemon.log`)
+ *      is intentionally skipped — let the daemon recreate them.
+ *   7. **Volatile-state guard.** If `daemon.pid` is present in the legacy
+ *      home (likely-running daemon), refuses unless `force: true`.
+ *
+ * Single owner file — narrow blast radius. The CLI verb in `src/cli.ts`
+ * and the bootstrap step in `src/cli/startup.ts` are the only callers.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const os_1 = require("os");
+const config_1 = require("../config");
+/** Legacy POSIX/macOS/Windows home dir name (pre-v1.0 rebrand). */
+const LEGACY_PROD_HOME_DIR_NAME = '.claude-tempo';
+const LEGACY_DEV_HOME_DIR_NAME = '.claude-tempo-dev';
+/** Marker file name dropped in the new home post-migration. */
+exports.MIGRATION_MARKER_FILENAME = '.migrated-from-claude-tempo';
+/** Volatile runtime state — never copied (daemon recreates on boot). */
+const VOLATILE_FILES = new Set(['daemon.pid', 'daemon.port', 'daemon.log']);
+/** Allowlisted top-level files. `*.yaml` is matched as a glob. */
+const ALLOWLIST_FILES = new Set(['config.json', '.bootstrap-cache.json']);
+/** Allowlisted top-level subdirs (recursive copy). Forward-compat — fine if absent. */
+const ALLOWLIST_SUBDIRS = ['lineups', 'state', 'coat-check'];
+function legacyHomeFor(profile, home) {
+    return path.join(home, profile === 'dev' ? LEGACY_DEV_HOME_DIR_NAME : LEGACY_PROD_HOME_DIR_NAME);
+}
+function newHomeFor(profile, home) {
+    return path.join(home, profile === 'dev' ? config_1.DEV_HOME_DIR_NAME : config_1.PROD_HOME_DIR_NAME);
+}
+/** SHA-256 hex digest of a file's contents. */
+function hashFile(absPath) {
+    const hash = crypto.createHash('sha256');
+    hash.update(fs.readFileSync(absPath));
+    return hash.digest('hex');
+}
+/** Aggregate hash of a whole tree — order-stable by sorting relative paths. */
+function hashTree(root, files) {
+    const hash = crypto.createHash('sha256');
+    for (const f of files.slice().sort((a, b) => a.rel.localeCompare(b.rel))) {
+        hash.update(f.rel + ':' + hashFile(f.abs) + '\n');
+    }
+    return hash.digest('hex');
+}
+/** Read the migration marker, returning `null` if absent / malformed. */
+function readMarker(newHome) {
+    const markerPath = path.join(newHome, exports.MIGRATION_MARKER_FILENAME);
+    if (!fs.existsSync(markerPath))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+        if (typeof parsed.copiedFromHash !== 'string' || !Array.isArray(parsed.files))
+            return null;
+        return {
+            migratedAt: parsed.migratedAt ?? '',
+            copiedFromHash: parsed.copiedFromHash,
+            files: parsed.files,
+            fileHashes: parsed.fileHashes ?? {},
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Walk a directory tree, yielding `{ rel, abs }` entries for files matching
+ * the allowlist. Returns `[]` if `legacyHome` doesn't exist.
+ *
+ * Allowlist:
+ *   - top-level files in {@link ALLOWLIST_FILES}
+ *   - top-level `*.yaml` / `*.yml` files
+ *   - everything (recursively) under top-level subdirs in {@link ALLOWLIST_SUBDIRS}
+ *
+ * The volatile trio (`daemon.pid`/`.port`/`.log`) is excluded everywhere.
+ */
+function walkLegacyTree(legacyHome) {
+    if (!fs.existsSync(legacyHome))
+        return [];
+    const out = [];
+    // Top-level entries
+    let entries;
+    try {
+        entries = fs.readdirSync(legacyHome, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (VOLATILE_FILES.has(entry.name))
+            continue;
+        if (entry.name === exports.MIGRATION_MARKER_FILENAME)
+            continue;
+        const abs = path.join(legacyHome, entry.name);
+        if (entry.isFile()) {
+            if (ALLOWLIST_FILES.has(entry.name) || /\.ya?ml$/i.test(entry.name)) {
+                out.push({ rel: entry.name, abs });
+            }
+            continue;
+        }
+        if (entry.isDirectory() && ALLOWLIST_SUBDIRS.includes(entry.name)) {
+            walkSubtree(abs, entry.name, out);
+        }
+    }
+    return out;
+}
+function walkSubtree(absRoot, relRoot, out) {
+    let entries;
+    try {
+        entries = fs.readdirSync(absRoot, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const abs = path.join(absRoot, entry.name);
+        const rel = path.posix.join(relRoot, entry.name);
+        if (entry.isFile()) {
+            out.push({ rel, abs });
+        }
+        else if (entry.isDirectory()) {
+            walkSubtree(abs, rel, out);
+        }
+    }
+}
+/**
+ * One-shot legacy home migration. See module doc-comment for the full
+ * contract. Never throws — all error paths return a structured
+ * {@link LegacyMigrationResult}.
+ */
+async function migrateLegacyHome(opts = {}) {
+    const profile = opts.profile ?? 'prod';
+    const home = opts.homeDir ?? (0, os_1.homedir)();
+    const legacyHome = legacyHomeFor(profile, home);
+    const newHome = newHomeFor(profile, home);
+    // 1. No legacy → nothing to do.
+    if (!fs.existsSync(legacyHome)) {
+        return { status: 'no-legacy', legacyHome, newHome };
+    }
+    // 2. Volatile state guard — daemon.pid likely means a running daemon.
+    const pidPath = path.join(legacyHome, 'daemon.pid');
+    if (!opts.force && fs.existsSync(pidPath)) {
+        return {
+            status: 'skipped',
+            legacyHome,
+            newHome,
+            reason: `Legacy daemon.pid present at ${pidPath}. The daemon may still be running — ` +
+                `stop it first (\`agent-tempo daemon stop\` or \`claude-tempo daemon stop\`) ` +
+                `and re-run, or pass \`--force\` to migrate anyway.`,
+        };
+    }
+    // 3. Conflict policy — new home exists without our marker = user-initiated, refuse.
+    const newHomeExists = fs.existsSync(newHome);
+    const existingMarker = newHomeExists ? readMarker(newHome) : null;
+    if (newHomeExists && !existingMarker && !opts.force) {
+        return {
+            status: 'skipped',
+            legacyHome,
+            newHome,
+            reason: `Refusing to overwrite ${newHome} — directory exists and was not created ` +
+                `by a previous migration (no \`${exports.MIGRATION_MARKER_FILENAME}\` marker found). ` +
+                `Pass \`--force\` to migrate anyway, or delete the directory first.`,
+        };
+    }
+    // 4. Enumerate legacy files + hash the source tree.
+    const legacyFiles = walkLegacyTree(legacyHome);
+    if (legacyFiles.length === 0) {
+        // Legacy dir exists but holds only volatile state / nothing to migrate.
+        return { status: 'no-legacy', legacyHome, newHome };
+    }
+    const sourceHash = hashTree(legacyHome, legacyFiles);
+    // 5. Idempotency — same source content + valid marker = already migrated.
+    if (existingMarker && existingMarker.copiedFromHash === sourceHash) {
+        return {
+            status: 'already-migrated',
+            legacyHome,
+            newHome,
+            copiedFiles: [],
+        };
+    }
+    // 6. Plan the copy. Partial-copy resume: skip files whose dest already has the right SHA.
+    const plan = [];
+    const errors = [];
+    for (const f of legacyFiles) {
+        let srcHash;
+        try {
+            srcHash = hashFile(f.abs);
+        }
+        catch (err) {
+            errors.push(`hash failed for ${f.rel}: ${err.message}`);
+            continue;
+        }
+        const destAbs = path.join(newHome, f.rel);
+        if (existingMarker?.fileHashes?.[f.rel] === srcHash && fs.existsSync(destAbs)) {
+            try {
+                if (hashFile(destAbs) === srcHash)
+                    continue; // already copied with right content
+            }
+            catch { /* fall through and re-copy */ }
+        }
+        plan.push({ rel: f.rel, abs: f.abs, destAbs, sourceHash: srcHash });
+    }
+    if (opts.dryRun) {
+        return {
+            status: 'migrated',
+            legacyHome,
+            newHome,
+            copiedFiles: plan.map((p) => p.rel),
+        };
+    }
+    // 7. Execute the copy.
+    const copied = [];
+    const fileHashes = { ...(existingMarker?.fileHashes ?? {}) };
+    try {
+        fs.mkdirSync(newHome, { recursive: true });
+    }
+    catch (err) {
+        errors.push(`mkdir ${newHome}: ${err.message}`);
+        return { status: 'failed', legacyHome, newHome, errors };
+    }
+    for (const p of plan) {
+        try {
+            fs.mkdirSync(path.dirname(p.destAbs), { recursive: true });
+            fs.copyFileSync(p.abs, p.destAbs);
+            copied.push(p.rel);
+            fileHashes[p.rel] = p.sourceHash;
+        }
+        catch (err) {
+            errors.push(`copy ${p.rel}: ${err.message}`);
+        }
+    }
+    if (errors.length > 0 && copied.length === 0) {
+        return { status: 'failed', legacyHome, newHome, errors };
+    }
+    // 8. Drop the marker — captures final state for idempotency.
+    const allFiles = legacyFiles.map((f) => f.rel).sort();
+    const marker = {
+        migratedAt: new Date().toISOString(),
+        copiedFromHash: sourceHash,
+        files: allFiles,
+        fileHashes,
+    };
+    try {
+        fs.writeFileSync(path.join(newHome, exports.MIGRATION_MARKER_FILENAME), JSON.stringify(marker, null, 2) + '\n');
+    }
+    catch (err) {
+        errors.push(`marker write: ${err.message}`);
+    }
+    return {
+        status: 'migrated',
+        legacyHome,
+        newHome,
+        copiedFiles: copied,
+        ...(errors.length > 0 ? { errors } : {}),
+    };
+}
+/**
+ * Format a {@link LegacyMigrationResult} for human display (CLI verb output
+ * + bootstrap step `notes`).
+ */
+function formatMigrationResult(r) {
+    switch (r.status) {
+        case 'no-legacy':
+            return `No legacy home at ${r.legacyHome} — nothing to migrate.`;
+        case 'already-migrated':
+            return `Already migrated — ${r.newHome} is up-to-date with ${r.legacyHome}.`;
+        case 'migrated': {
+            const n = r.copiedFiles?.length ?? 0;
+            const errSuffix = r.errors?.length ? ` (${r.errors.length} error(s) recorded)` : '';
+            return `Migrated ${n} file(s) ${r.legacyHome} → ${r.newHome}${errSuffix}.`;
+        }
+        case 'skipped':
+            return r.reason ?? 'Migration skipped.';
+        case 'failed':
+            return `Migration failed: ${(r.errors ?? []).join('; ')}`;
+    }
+}

package/dist/cli/mcp.d.ts

@@ -0,0 +1,8 @@
+/** Check if agent-tempo is registered in `claude mcp list` (global user scope). */
+export declare function isGlobalMcpRegistered(): boolean;
+/** Register agent-tempo globally via `claude mcp add`. */
+export declare function addGlobalMcp(): boolean;
+/** Remove agent-tempo from global MCP config via `claude mcp remove`. */
+export declare function removeGlobalMcp(): boolean;
+/** Check if agent-tempo MCP is configured (global or project-level). */
+export declare function isMcpConfigured(projectDir: string): boolean;

package/dist/cli/mcp.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGlobalMcpRegistered = isGlobalMcpRegistered;
+exports.addGlobalMcp = addGlobalMcp;
+exports.removeGlobalMcp = removeGlobalMcp;
+exports.isMcpConfigured = isMcpConfigured;
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+/** Check if agent-tempo is registered in `claude mcp list` (global user scope). */
+function isGlobalMcpRegistered() {
+    try {
+        const output = (0, child_process_1.execFileSync)('claude', ['mcp', 'list', '-s', 'user'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        // Match either the new (`agent-tempo`) or legacy (`agent-tempo`) registration —
+        // dual-bin in `package.json` keeps the old name working through the migration window.
+        return /\bagent-tempo\b/.test(output) || /\bagent-tempo\b/.test(output);
+    }
+    catch {
+        return false;
+    }
+}
+/** Register agent-tempo globally via `claude mcp add`. */
+function addGlobalMcp() {
+    try {
+        (0, child_process_1.execFileSync)('claude', [
+            'mcp', 'add', 'agent-tempo', '-s', 'user',
+            '--', 'agent-tempo-server',
+        ], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Remove agent-tempo from global MCP config via `claude mcp remove`. */
+function removeGlobalMcp() {
+    try {
+        (0, child_process_1.execFileSync)('claude', [
+            'mcp', 'remove', 'agent-tempo', '-s', 'user',
+        ], { stdio: ['ignore', 'ignore', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if agent-tempo MCP is configured (global or project-level). */
+function isMcpConfigured(projectDir) {
+    if (isGlobalMcpRegistered())
+        return true;
+    const mcpPath = (0, path_1.join)(projectDir, '.mcp.json');
+    if ((0, fs_1.existsSync)(mcpPath)) {
+        try {
+            const mcp = JSON.parse((0, fs_1.readFileSync)(mcpPath, 'utf8'));
+            return !!mcp?.mcpServers?.['agent-tempo'];
+        }
+        catch { /* invalid json */ }
+    }
+    return false;
+}

package/dist/cli/output.d.ts

@@ -0,0 +1,12 @@
+export declare const bold: (s: string) => string;
+export declare const dim: (s: string) => string;
+export declare const red: (s: string) => string;
+export declare const green: (s: string) => string;
+export declare const yellow: (s: string) => string;
+export declare const cyan: (s: string) => string;
+export declare function log(msg: string): void;
+export declare function error(msg: string): void;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function heading(msg: string): void;
+export declare function check(label: string, ok: boolean, detail?: string): void;

package/dist/cli/output.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cyan = exports.yellow = exports.green = exports.red = exports.dim = exports.bold = void 0;
+exports.log = log;
+exports.error = error;
+exports.success = success;
+exports.warn = warn;
+exports.heading = heading;
+exports.check = check;
+const isColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const ansi = (code) => (s) => isColor ? `\x1b[${code}m${s}\x1b[0m` : s;
+exports.bold = ansi('1');
+exports.dim = ansi('2');
+exports.red = ansi('31');
+exports.green = ansi('32');
+exports.yellow = ansi('33');
+exports.cyan = ansi('36');
+function log(msg) {
+    console.log(msg);
+}
+function error(msg) {
+    console.error(`${(0, exports.red)('error')} ${msg}`);
+}
+function success(msg) {
+    console.log(`${(0, exports.green)('ok')} ${msg}`);
+}
+function warn(msg) {
+    console.log(`${(0, exports.yellow)('warn')} ${msg}`);
+}
+function heading(msg) {
+    console.log(`\n${(0, exports.bold)(msg)}`);
+}
+function check(label, ok, detail) {
+    const icon = ok ? (0, exports.green)('pass') : (0, exports.red)('FAIL');
+    const suffix = detail ? ` ${(0, exports.dim)(`(${detail})`)}` : '';
+    console.log(`  ${icon} ${label}${suffix}`);
+}

package/dist/cli/preflight.d.ts

@@ -0,0 +1,9 @@
+import { CliOverrides } from '../config';
+export interface PreflightResult {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function runPreflight(opts: CliOverrides & {
+    dir: string;
+}): Promise<PreflightResult>;

package/dist/cli/preflight.js

@@ -0,0 +1,96 @@
+"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.runPreflight = runPreflight;
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const connection_1 = require("../connection");
+const spawn_1 = require("../spawn");
+const mcp_1 = require("./mcp");
+const out = __importStar(require("./output"));
+function whichSync(cmd) {
+    const bin = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        return (0, child_process_1.execFileSync)(bin, [cmd], { encoding: 'utf8' }).trim().split('\n')[0];
+    }
+    catch {
+        return null;
+    }
+}
+async function runPreflight(opts) {
+    const config = (0, config_1.getConfig)(opts);
+    const errors = [];
+    const warnings = [];
+    out.heading('Preflight checks');
+    // 1. Node.js version
+    const major = parseInt(process.version.slice(1), 10);
+    const nodeOk = major >= 20;
+    out.check('Node.js >= 20', nodeOk, process.version);
+    if (!nodeOk)
+        errors.push(`Node.js 20+ required, found ${process.version}`);
+    // 2. Temporal reachable
+    let temporalOk = false;
+    try {
+        const conn = await Promise.race([
+            (0, connection_1.createTemporalConnection)(config),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 3000)),
+        ]);
+        await conn.close();
+        temporalOk = true;
+    }
+    catch { /* unreachable */ }
+    out.check('Temporal reachable', temporalOk, config.temporalAddress);
+    if (!temporalOk)
+        errors.push(`Cannot connect to Temporal at ${config.temporalAddress}. Run: temporal server start-dev`);
+    // 3. claude binary
+    const claudePath = (0, spawn_1.resolveClaudePath)();
+    const claudeOk = claudePath !== 'claude';
+    out.check('claude binary found', claudeOk, claudeOk ? claudePath : 'not on PATH');
+    if (!claudeOk)
+        errors.push('claude binary not found on PATH. Install Claude Code first.');
+    // 4. agent-tempo-server binary (the MCP server)
+    const serverPath = whichSync('agent-tempo-server');
+    const serverOk = !!serverPath;
+    out.check('agent-tempo-server found', serverOk, serverOk ? serverPath : 'not on PATH');
+    if (!serverOk)
+        errors.push('agent-tempo-server not found on PATH. Run: npm install -g agent-tempo');
+    // 5. MCP config (global or project-level)
+    const mcpOk = (0, mcp_1.isMcpConfigured)(opts.dir);
+    out.check('MCP configured', mcpOk, mcpOk ? 'global or project' : 'not found');
+    if (!mcpOk)
+        warnings.push('No agent-tempo MCP config found. Run: agent-tempo init');
+    console.log();
+    return { ok: errors.length === 0, errors, warnings };
+}

package/dist/cli/removed-verbs.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Short hints completing "Use the TUI: agent-tempo → …". Keys are the
+ * removed CLI verbs; values name the TUI equivalent.
+ */
+export declare const REMOVED_VERBS: Record<string, string>;
+/** Format the error message for a single removed verb. */
+export declare function removedVerbMessage(verb: string): string;
+/** Print the removed-verb error to stderr via the shared output helpers. */
+export declare function printRemovedVerbMessage(verb: string): void;

package/dist/cli/removed-verbs.js

@@ -0,0 +1,78 @@
+"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.REMOVED_VERBS = void 0;
+exports.removedVerbMessage = removedVerbMessage;
+exports.printRemovedVerbMessage = printRemovedVerbMessage;
+/**
+ * Lookup table + helper for the CLI verbs removed in #288 (design #285).
+ *
+ * Kept in its own module so `src/cli.ts` can dispatch removed-verb errors
+ * BEFORE loading the Temporal-touching command surface (crash-proof
+ * pattern, same as `help-text.ts`) and so the mapping can be unit-tested
+ * without spinning up the dispatch loop.
+ *
+ * Any change to this table should ship alongside matching edits in
+ * `src/cli/help-text.ts` and `src/cli.ts` (no `case` for any key here).
+ *
+ * Dev-mode verbs (#432) are intercepted before this table — a verb is
+ * either dev-mode-live or removed-with-a-hint, never both. The
+ * mechanical test in `test/cli-dev-verbs.test.ts` enforces this.
+ */
+const out = __importStar(require("./output"));
+/**
+ * Short hints completing "Use the TUI: agent-tempo → …". Keys are the
+ * removed CLI verbs; values name the TUI equivalent.
+ */
+exports.REMOVED_VERBS = {
+    stop: '/destroy',
+    conduct: 'launch directly (the TUI auto-provisions the conductor)',
+    start: '/recruit <name>',
+    disband: '/destroy',
+    detach: '/shutdown (ensemble-wide) — detach is no longer a user-facing verb',
+    restart: '/restart <player>',
+    recruit: '/recruit <name>',
+    migrate: '/migrate <player> <host>',
+    resume: '/play',
+};
+/** Format the error message for a single removed verb. */
+function removedVerbMessage(verb) {
+    const hint = exports.REMOVED_VERBS[verb];
+    return `"${verb}" is no longer a CLI verb. Use the TUI: agent-tempo → ${hint}. See https://github.com/vinceblank/agent-tempo/issues/285 for details.`;
+}
+/** Print the removed-verb error to stderr via the shared output helpers. */
+function printRemovedVerbMessage(verb) {
+    out.error(removedVerbMessage(verb));
+}