agent-tempo 1.7.0 → 2.0.0-beta.1

package/dashboard/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-tempo-dashboard",
   "private": true,
-  "version": "1.7.0",
+  "version": "2.0.0-beta.1",
   "type": "module",
   "description": "Web dashboard for agent-tempo. Bundled into the npm package; served by the daemon at /dashboard/*.",
   "scripts": {

package/dist/activities/hard-terminate.d.ts

@@ -12,9 +12,9 @@ export interface HardTerminateInput {
     playerName: string;
     /** Adapter type — controls PID-file lookup and expected process-name verification. */
     agent: AgentType;
-    /** Session's workDir — used to locate the copilot bridge PID file (`<workDir>/logs/<playerName>.pid`). */
+    /** Session's workDir — carried on the activity input as a session attribute. */
     workDir: string;
-    /** Optional explicit logDir override; falls back to `<workDir>/logs`. */
+    /** Optional explicit logDir override for the central bridge log path. */
     logDir?: string;
 }
 export interface HardTerminateResult {

package/dist/activities/hard-terminate.js

@@ -29,7 +29,6 @@ exports.hardTerminateAttachment = hardTerminateAttachment;
  */
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
-const path_1 = require("path");
 const config_1 = require("../config");
 const constants_1 = require("../constants");
 const log = (...args) => console.error('[agent-tempo:hard-terminate]', ...args);
@@ -38,19 +37,14 @@ const log = (...args) => console.error('[agent-tempo:hard-terminate]', ...args);
  * what happened so callers can record it in workflow history without blocking state flips.
  */
 async function hardTerminateAttachment(input) {
-    const { ensemble, playerName, agent, workDir, logDir } = input;
+    const { ensemble, playerName, agent, logDir } = input;
     const notes = [];
     const killedPids = [];
     log(`hardTerminate start — ensemble=${ensemble} player=${playerName} agent=${agent}`);
     // ── Copilot bridge: PID file is authoritative ──
     if (agent === 'copilot') {
-        // #690 — pid lives at the CENTRAL ~/.agent-tempo/logs/<ensemble>/ path now.
-        // Transitional (one version, v1.6.2) READ-ONLY fallback to the legacy per-cwd
-        // <workDir>/logs so we can still find+kill an orphan from a pre-upgrade spawn.
-        // TODO(v1.7): drop the legacy fallback.
-        const centralPid = (0, config_1.bridgeLogPaths)(ensemble, playerName, logDir).pidPath;
-        const legacyPid = (0, path_1.join)(logDir || (0, path_1.join)(workDir, 'logs'), `${playerName}.pid`);
-        const pidPath = (0, fs_1.existsSync)(centralPid) ? centralPid : legacyPid;
+        // #690 — pid lives at the CENTRAL ~/.agent-tempo/logs/<ensemble>/ path.
+        const pidPath = (0, config_1.bridgeLogPaths)(ensemble, playerName, logDir).pidPath;
         if ((0, fs_1.existsSync)(pidPath)) {
             try {
                 const pidStr = (0, fs_1.readFileSync)(pidPath, 'utf8').trim();

package/dist/activities/maestro.d.ts

@@ -86,19 +86,14 @@ export interface MaestroActivityOptions {
 /** Activity interface — used by proxyActivities in the Maestro workflow. */
 export interface MaestroActivities {
     /**
-     * Legacy V1 refresh — the `costProfile: 'local'` path AND the replay
-     * path for every maestro started before #748.
-     * TODO(next major, #748): remove once the minimum deployment age
-     * exceeds the longest-lived pre-#748 maestro history (they replay V1);
-     * remove together with the V1 branch in workflows/maestro.ts.
-     */
-    refreshEnsembleState(ensemble: string): Promise<MaestroPlayerInfo[]>;
-    /**
-     * T0.1 (#748) — additive V2: called only by maestros started with
-     * `costProfile: 'cloud'` in their input. SA/memo-based ensemble-scoped
-     * scan + in-process observer presence for workflow-side cadence
-     * stretching. V1 stays for in-flight pre-#748 maestros (replay safety)
-     * and the local profile.
+     * Ensemble-scoped player scan. Returns the player rows plus `observersPresent`
+     * (SSE subscriber presence) for workflow-side cadence stretching on the cloud
+     * profile. Honors the daemon's cost profile internally: cloud → SA/memo
+     * ensemble-scoped scan, local → the legacy visibility scan.
+     *
+     * 2.0 (#788): the only refresh activity — the former V1 `refreshEnsembleState`
+     * was removed; both profiles call this (the A2 cutover means no pre-#748
+     * maestro survives to need the V1 replay path).
      */
     refreshEnsembleStateV2(input: {
         ensemble: string;

package/dist/activities/maestro.js

@@ -55,16 +55,6 @@ function createMaestroActivities(client, opts = {}) {
         }
     };
     return (0, action_counters_1.tagActionSource)(maestroSource, {
-        async refreshEnsembleState(ensemble) {
-            try {
-                const sessions = await (0, resolve_1.scanEnsembleSessions)(client, ensemble);
-                return sessions.map(toPlayerInfo(ensemble));
-            }
-            catch (err) {
-                log('refreshEnsembleState failed:', err);
-                throw activity_1.ApplicationFailure.nonRetryable(`Failed to scan ensemble: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        },
         async refreshEnsembleStateV2(input) {
             try {
                 // Honor the DAEMON's configured profile for the scan strategy: a

package/dist/activities/outbox.js

@@ -764,8 +764,9 @@ function createOutboxActivities(client, config, ingestTokens, doorbells) {
         /**
          * D14 `deliverReset` — set a `pendingReset` flag on the target via
          * `setPendingResetSignal` (a signal, like deliverCue — NOT a direct
-         * subprocess call). The Pi extension polls `pendingResetQuery`, performs the
-         * clean-wipe (`newSession`), then clears it via `ackResetSignal(resetId)`.
+         * subprocess call). The Pi extension reads the pending reset off the
+         * combined `pendingIntake` query, performs the clean-wipe (`newSession`),
+         * then clears it via `ackResetSignal(resetId)`.
          */
         async deliverReset(input) {
             const { ensemble, targetPlayerId, resetId, fresh, reason, requestedBy } = input;
@@ -892,6 +893,7 @@ function createOutboxActivities(client, config, ingestTokens, doorbells) {
                             adapterId,
                             adapterClass,
                             leaseMs: validation_1.DEFAULT_RESTART_LEASE_MS,
+                            protocolVersion: constants_1.PROTOCOL_VERSION, // #786 — 2.0 wire handshake
                         }],
                 });
                 // Step 5 — context seed (saved state and/or transcript replay).

package/dist/adapters/base.js

@@ -6,6 +6,7 @@ exports.installProcessLifecycleTelemetry = installProcessLifecycleTelemetry;
 exports._resetProcessLifecycleTelemetryForTest = _resetProcessLifecycleTelemetryForTest;
 exports._liveAdaptersForTest = _liveAdaptersForTest;
 const signals_1 = require("../workflows/signals");
+const constants_1 = require("../constants");
 const terminal_error_1 = require("./terminal-error");
 const action_counters_1 = require("../utils/action-counters");
 const log = (...args) => console.error('[agent-tempo:adapter]', ...args);
@@ -389,6 +390,7 @@ class BaseAttachment {
                     adapterId: this.descriptor.adapterId,
                     adapterClass: this.descriptor.adapterClass,
                     leaseMs: 3 * this.descriptor.heartbeatMs,
+                    protocolVersion: constants_1.PROTOCOL_VERSION, // #786 — 2.0 wire handshake
                     ...(expectedAttachmentId ? { expectedAttachmentId } : {}),
                 }],
         });
@@ -1147,6 +1149,7 @@ class BaseAttachment {
                                 adapterId: this.descriptor.adapterId,
                                 adapterClass: this.descriptor.adapterClass,
                                 leaseMs: 3 * this.descriptor.heartbeatMs,
+                                protocolVersion: constants_1.PROTOCOL_VERSION, // #786 — 2.0 wire handshake
                             }],
                     });
                     // Success — rebuild pinned handle from the NEW runId and hand it to the subclass.

package/dist/cli/commands.d.ts

@@ -50,6 +50,14 @@ interface UpOpts extends CliOverrides {
      * can't exist there anyway (gate 3 in recruit pre-flight).
      */
     scenario?: string;
+    /**
+     * #786 — `up --from-upgrade`. Recreate protocol-2 workflows from the
+     * `upgrade-snapshot-v1.json` left by `upgrade-to-2`, instead of starting a
+     * fresh ensemble. Recreates the roster (structural essentials only),
+     * surfaces undelivered cues for review, and archives the snapshot on
+     * success. Ignores `--lineup` / conductor-spawn flags.
+     */
+    fromUpgrade?: boolean;
 }
 /**
  * #832 — the operator-facing "ensemble ready" lines for `up` / `conduct`.

package/dist/cli/commands.js

@@ -1060,6 +1060,71 @@ function formatEnsembleReadyLines(ensemble, lineupName, playerCount) {
         `Connect: agent-tempo command-center ${ensemble}`,
     ];
 }
+/**
+ * #786 — `up --from-upgrade` orchestration. Opens a Temporal client, recreates
+ * protocol-2 workflows from `upgrade-snapshot-v1.json`, prints the outcome
+ * (incl. undelivered cues surfaced for review — NEVER redelivered), and
+ * archives the snapshot on success. Separated from `up()` so the I/O is in one
+ * place; the recreation logic itself lives (testably) in
+ * `src/upgrade/from-upgrade.ts`.
+ */
+async function runFromUpgradeFlow(config) {
+    const { runFromUpgrade } = await Promise.resolve().then(() => __importStar(require('../upgrade/from-upgrade')));
+    const { SnapshotValidationError } = await Promise.resolve().then(() => __importStar(require('../upgrade/snapshot-v1')));
+    out.heading('agent-tempo up --from-upgrade');
+    const connection = await (0, connection_1.createTemporalConnection)(config);
+    const client = new client_1.Client({ connection, namespace: config.temporalNamespace });
+    try {
+        const result = await runFromUpgrade(client, {
+            home: config_1.AGENT_TEMPO_HOME,
+            taskQueue: config.taskQueue,
+            temporalAddress: config.temporalAddress,
+            temporalNamespace: config.temporalNamespace,
+            log: (...args) => out.dim('  ' + args.map(String).join(' ')),
+        });
+        if (!result.snapshotFound) {
+            out.warn(`No upgrade snapshot found in ${config_1.AGENT_TEMPO_HOME}.`);
+            out.log(`  Run \`agent-tempo upgrade-to-2\` on the 1.x install first.`);
+            return;
+        }
+        out.success(`Recreated ${result.workflowsCreated} protocol-2 workflow(s) across ` +
+            `${result.ensemblesRecreated} ensemble(s).`);
+        if (result.undeliveredCues.length > 0) {
+            out.log('');
+            out.warn(`${result.undeliveredCues.length} undelivered cue(s) — review (NOT redelivered):`);
+            for (const c of result.undeliveredCues) {
+                const preview = c.text.length > 120 ? c.text.slice(0, 117) + '…' : c.text;
+                out.log(`  [${c.ensemble}] ${c.from} → ${c.playerId} (${c.timestamp}): ${preview}`);
+            }
+        }
+        if (result.failures.length > 0) {
+            out.log('');
+            out.error(`${result.failures.length} workflow(s) failed to recreate — snapshot left in place for retry:`);
+            for (const f of result.failures)
+                out.log(`  ${f.workflowId}: ${f.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (result.archived) {
+            out.dim(`  Snapshot archived → ${result.archivePath}`);
+        }
+        out.log('');
+        out.log('  Continuity seeding (state slots / schedules / sessionId / model) is a');
+        out.log('  tracked #786 fast-follow — recreated sessions are structural skeletons.');
+    }
+    catch (err) {
+        // A malformed snapshot is a LOUD failure (never a silent skip).
+        if (err instanceof SnapshotValidationError) {
+            out.error(`Upgrade snapshot is corrupt — refusing to proceed: ${err.message}`);
+            process.exitCode = 1;
+            return;
+        }
+        throw err;
+    }
+    finally {
+        await connection.close().catch(() => { });
+    }
+}
 async function up(opts) {
     const config = (0, config_1.getConfig)(opts);
     // #689 — best-effort sweep of stale 0600 secret env files (residual from a shell
@@ -1111,6 +1176,16 @@ async function up(opts) {
         out.log(`  ${out.dim('You can start it manually: agent-tempo daemon start')}`);
         process.exit(1);
     }
+    // #786 — `up --from-upgrade`: recreate protocol-2 workflows from the snapshot
+    // left by `upgrade-to-2`, then stop. Runs AFTER ensureInfra (Temporal + daemon
+    // up, so the recreated workflows have live workers AND the daemon's boot guard
+    // has already verified a clean cutover) but instead of the lineup/conductor
+    // spawn flow. Continuity seeding (#334 state / schedules / sessionId / model)
+    // is a tracked #786 fast-follow — this MVP recreates structural skeletons only.
+    if (opts.fromUpgrade) {
+        await runFromUpgradeFlow(config);
+        return;
+    }
     // Step 4: Register MCP server if needed
     if ((0, mcp_1.isMcpConfigured)(process.cwd())) {
         out.check('MCP configured', true);
@@ -1907,12 +1982,8 @@ async function down(opts) {
  * Returns a formatted string like " (pid 12345)" or "" if no PID file found.
  */
 function getBridgePidInfo(ensemble, name) {
-    // #690 — pid lives at the CENTRAL ~/.agent-tempo/logs/<ensemble>/ path; transitional
-    // READ-ONLY fallback to the legacy per-cwd ./logs for a pre-upgrade bridge.
-    // TODO(v1.7): drop the legacy fallback.
-    const centralPid = (0, config_1.bridgeLogPaths)(ensemble, name).pidPath;
-    const legacyPid = (0, path_1.join)(process.cwd(), 'logs', `${name}.pid`);
-    const pidPath = (0, fs_1.existsSync)(centralPid) ? centralPid : legacyPid;
+    // #690 — pid lives at the CENTRAL ~/.agent-tempo/logs/<ensemble>/ path.
+    const pidPath = (0, config_1.bridgeLogPaths)(ensemble, name).pidPath;
     if (!(0, fs_1.existsSync)(pidPath))
         return '';
     try {
@@ -1946,13 +2017,10 @@ function getBridgePidInfo(ensemble, name) {
  * — do NOT reuse this global scan-all from a scoped op: it would kill OTHER live
  * ensembles' bridges. The param is intentionally NOT added now (no caller needs it
  * = speculative; backlogged per the architect's deviation ruling).
- *
- * Plus a transitional READ of the legacy per-cwd `./logs` for a pre-upgrade
- * bridge. TODO(v1.7): drop the legacy `./logs` dir.
  */
 function killBridgeProcesses() {
     const centralRoot = (0, config_1.bridgeLogsRoot)();
-    const dirs = [(0, path_1.join)(process.cwd(), 'logs')]; // legacy (transitional)
+    const dirs = [];
     try {
         for (const ent of (0, fs_1.readdirSync)(centralRoot, { withFileTypes: true })) {
             if (ent.isDirectory())
@@ -1960,7 +2028,7 @@ function killBridgeProcesses() {
         }
     }
     catch {
-        // no central logs root yet — nothing central to scan
+        // no central logs root yet — nothing to scan
     }
     for (const logsDir of dirs) {
         if (!(0, fs_1.existsSync)(logsDir))

package/dist/cli/daemon-command.js

@@ -371,28 +371,20 @@ async function daemonInstall() {
 async function daemonUninstall() {
     const platform = process.platform;
     if (platform === 'linux') {
-        // Backward-compat: clean up either the new (`agent-tempo.service`) or
-        // legacy (`agent-tempo.service`) unit so v0.x installs migrate cleanly.
         const dirSystemd = (0, path_1.join)((0, os_1.homedir)(), '.config', 'systemd', 'user');
-        const dstNew = (0, path_1.join)(dirSystemd, 'agent-tempo.service');
-        const dstLegacy = (0, path_1.join)(dirSystemd, 'agent-tempo.service');
-        for (const svc of ['agent-tempo', 'agent-tempo']) {
-            try {
-                (0, child_process_1.execFileSync)('systemctl', ['--user', 'disable', '--now', svc], { stdio: 'ignore' });
-            }
-            catch { /* may not be running */ }
+        const dst = (0, path_1.join)(dirSystemd, 'agent-tempo.service');
+        try {
+            (0, child_process_1.execFileSync)('systemctl', ['--user', 'disable', '--now', 'agent-tempo'], { stdio: 'ignore' });
         }
-        let removed = false;
+        catch { /* may not be running */ }
         try {
-            for (const dst of [dstNew, dstLegacy]) {
-                if ((0, fs_1.existsSync)(dst)) {
-                    (0, fs_1.unlinkSync)(dst);
-                    out.success(`Removed ${dst}`);
-                    removed = true;
-                }
+            if ((0, fs_1.existsSync)(dst)) {
+                (0, fs_1.unlinkSync)(dst);
+                out.success(`Removed ${dst}`);
             }
-            if (!removed)
+            else {
                 out.log('No systemd unit file found.');
+            }
         }
         catch (err) {
             out.error(`Failed to remove systemd unit: ${err?.message ?? err}`);
@@ -401,24 +393,18 @@ async function daemonUninstall() {
         return;
     }
     if (platform === 'darwin') {
-        // Backward-compat: clean up either the new (`com.agent.tempo.plist`) or
-        // legacy (`com.claude.tempo.plist`) plist so v0.x installs migrate cleanly.
-        const dstNew = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents', 'com.agent.tempo.plist');
-        const dstLegacy = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents', 'com.claude.tempo.plist');
-        let removed = false;
-        for (const dst of [dstNew, dstLegacy]) {
-            try {
-                (0, child_process_1.execFileSync)('launchctl', ['unload', dst], { stdio: 'ignore' });
-            }
-            catch { /* may not be loaded */ }
-            if ((0, fs_1.existsSync)(dst)) {
-                (0, fs_1.unlinkSync)(dst);
-                out.success(`Removed ${dst}`);
-                removed = true;
-            }
+        const dst = (0, path_1.join)((0, os_1.homedir)(), 'Library', 'LaunchAgents', 'com.agent.tempo.plist');
+        try {
+            (0, child_process_1.execFileSync)('launchctl', ['unload', dst], { stdio: 'ignore' });
         }
-        if (!removed)
+        catch { /* may not be loaded */ }
+        if ((0, fs_1.existsSync)(dst)) {
+            (0, fs_1.unlinkSync)(dst);
+            out.success(`Removed ${dst}`);
+        }
+        else {
             out.log('No launchd plist found.');
+        }
         return;
     }
     if (platform === 'win32') {

package/dist/cli/help-text.js

@@ -61,11 +61,11 @@ function printHelp() {
 ${out.bold('agent-tempo')} — Multi-session Claude Code coordination via Temporal
 
 ${out.bold('Getting started:')}
-  ${out.cyan('agent-tempo up')}                  Start infrastructure, then launch the TUI with ${out.dim('agent-tempo')}
+  ${out.cyan('agent-tempo up')}                  Start infrastructure, then run ${out.dim('agent-tempo')} for status + operator hints
 
 ${out.bold('Usage:')}
-  agent-tempo                         Launch the TUI (auto-provisions + opens home view)
-  agent-tempo <ensemble>              Launch the TUI directly into an ensemble view
+  agent-tempo                         Auto-provision, show status, and print operator hints
+  agent-tempo <ensemble>              Same, scoped to one ensemble's status
   agent-tempo <command> [options]
 
 ${out.bold('Commands:')}
@@ -95,10 +95,10 @@ ${out.bold('Commands:')}
   ${out.cyan('preflight')}                Run preflight checks only
   ${out.cyan('help')}                     Show this help message
 
-${out.bold('Removed — use the TUI:')}
-  ${out.dim('stop / restart / detach / migrate')}   → ${out.dim('/destroy · /restart · /shutdown')}
-  ${out.dim('conduct / start / recruit / disband')} → ${out.dim('launch `agent-tempo` · /recruit · /destroy')}
-  ${out.dim('resume')}                              → ${out.dim('/play')}
+${out.bold('Removed — use the command-center board')} ${out.dim('(agent-tempo command-center)')}:
+  ${out.dim('stop / restart / detach / migrate')}   → ${out.dim('/destroy · /restart · /shutdown · /migrate')}
+  ${out.dim('conduct / start / recruit / disband')} → ${out.dim('agent-tempo up · /recruit · /destroy')}
+  ${out.dim('resume / tui')}                        → ${out.dim('/play · run `agent-tempo` (status) or `command-center` (board)')}
   See https://github.com/vinceblank/agent-tempo/issues/285 for the full migration table.
 
 ${out.bold('Connection options (all commands):')}

package/dist/cli/home-command.d.ts

@@ -0,0 +1,26 @@
+import type { BootstrapResult } from './startup';
+export interface RenderHomeOpts {
+    /** Whether the Pi operator seat is installed (drives the command-center hint). */
+    piAvailable: boolean;
+    /** This binary's version (header line). */
+    version: string;
+    /** Hostname for the header (injectable for tests). */
+    hostname?: string;
+}
+/**
+ * Pure renderer: BootstrapResult → status lines + next-step hints. `result`
+ * may be undefined when bootstrap threw outside its step boundaries — the
+ * home still renders with a degraded note (mirrors the old TUI's tolerance).
+ */
+export declare function renderHome(result: BootstrapResult | undefined, opts: RenderHomeOpts): string[];
+/**
+ * The `home` (bare-command) handler: bootstrap → render → exit. Bootstrap is
+ * best-effort exactly as the TUI treated it — a throw outside step
+ * boundaries degrades to the no-result rendering, never a crash.
+ */
+export declare function runHome(opts: {
+    /** `null` = bootstrap skipped (`--skip-preflight`) — render the degraded home. */
+    bootstrap: (() => Promise<BootstrapResult>) | null;
+    piAvailable: boolean;
+    version: string;
+}): Promise<void>;

package/dist/cli/home-command.js

@@ -0,0 +1,156 @@
+"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.renderHome = renderHome;
+exports.runHome = runHome;
+/**
+ * Bare-command home (E.8, #789) — what `agent-tempo` with no verb does now
+ * that the Ink TUI is gone: run the #289 six-step auto-provisioning
+ * bootstrap, then print a STATUS snapshot + contextual next-step hints and
+ * exit. No alternate screen, no event loop — the live operator surfaces are
+ * mission-control (`agent-tempo command-center`, when the Pi seat is
+ * available) and the zero-dependency web dashboard.
+ *
+ * `renderHome` is PURE (BootstrapResult + flags → lines) so the hint logic
+ * unit-tests without a daemon, npm, or Pi install.
+ */
+const os = __importStar(require("os"));
+const out = __importStar(require("./output"));
+const probe_1 = require("../pi/probe");
+/** Friendly labels for the bootstrap steps. */
+const STEP_LABELS = {
+    preflight: 'preflight',
+    mcpConfig: 'MCP registration',
+    temporalReach: 'Temporal reachability',
+    searchAttrs: 'search attributes',
+    daemonBoot: 'daemon',
+    badgeCollection: 'badges',
+};
+const STEP_GLYPH = {
+    ok: '✓',
+    skipped: '·',
+    'action-taken': '＋',
+    failed: '✗',
+};
+/**
+ * Pure renderer: BootstrapResult → status lines + next-step hints. `result`
+ * may be undefined when bootstrap threw outside its step boundaries — the
+ * home still renders with a degraded note (mirrors the old TUI's tolerance).
+ */
+function renderHome(result, opts) {
+    const lines = [];
+    const host = opts.hostname ?? os.hostname();
+    lines.push(`agent-tempo v${opts.version} — ${host}`);
+    lines.push('');
+    // ── Bootstrap status (one line per non-quiet step) ──
+    if (result) {
+        const parts = [];
+        for (const [step, outcome] of Object.entries(result.steps)) {
+            if (outcome.status === 'skipped' || outcome.status === 'ok')
+                continue; // quiet steady state
+            parts.push(`${STEP_GLYPH[outcome.status]} ${STEP_LABELS[step]}${outcome.detail ? ` (${outcome.detail})` : ''}`);
+        }
+        lines.push(parts.length === 0
+            ? `bootstrap ✓ all steps healthy (${result.durationMs}ms)`
+            : `bootstrap: ${parts.join(' · ')}`);
+        // ── Badges ──
+        const b = result.badges;
+        if (b.orphanCount > 0) {
+            lines.push(`⚠ ${b.orphanCount} orphaned session${b.orphanCount === 1 ? '' : 's'} on this host — \`agent-tempo restore\` to re-attach`);
+        }
+        if (b.daemonLogErrors) {
+            lines.push(`⚠ ${b.daemonLogErrors.count} recent daemon-log error${b.daemonLogErrors.count === 1 ? '' : 's'} — see ${b.daemonLogErrors.logPath}`);
+        }
+        if (b.outdatedVersion) {
+            lines.push(`↑ v${b.outdatedVersion.latest} available (${b.outdatedVersion.severity}) — \`agent-tempo upgrade\``);
+        }
+        // ── Ensembles ──
+        lines.push('');
+        if (result.ensembles.length === 0) {
+            lines.push('No ensembles running.');
+        }
+        else {
+            lines.push(`Ensembles (${result.ensembles.length}):`);
+            for (const e of result.ensembles) {
+                const state = e.state ? ` — ${e.state}` : '';
+                lines.push(`  ${e.name}: ${e.playerCount} player${e.playerCount === 1 ? '' : 's'}${e.hasConductor ? '' : ', no conductor'}${state}`);
+            }
+        }
+    }
+    else {
+        lines.push('bootstrap unavailable — run `agent-tempo daemon status` to diagnose.');
+        lines.push('');
+    }
+    // ── Next steps (contextual) ──
+    lines.push('');
+    lines.push('Next steps:');
+    const hasEnsembles = (result?.ensembles.length ?? 0) > 0;
+    if (!hasEnsembles) {
+        lines.push('  agent-tempo up                  start an ensemble here (--lineup <name> for a preset)');
+    }
+    if (opts.piAvailable) {
+        const desc = hasEnsembles
+            ? 'live board + operator seat (Pi)'
+            : 'operator seat once an ensemble is up (Pi)';
+        lines.push(`  agent-tempo command-center      ${desc}`);
+    }
+    lines.push('  agent-tempo dashboard           web dashboard (zero-dependency fallback)');
+    if (hasEnsembles) {
+        lines.push('  agent-tempo status <ensemble>   one-shot ensemble detail');
+    }
+    if (!opts.piAvailable) {
+        lines.push(`  npm install -g ${probe_1.PI_PACKAGE}   unlock the command-center seat (Node ≥ ${probe_1.PI_NODE_FLOOR})`);
+    }
+    return lines;
+}
+/**
+ * The `home` (bare-command) handler: bootstrap → render → exit. Bootstrap is
+ * best-effort exactly as the TUI treated it — a throw outside step
+ * boundaries degrades to the no-result rendering, never a crash.
+ */
+async function runHome(opts) {
+    let result;
+    if (opts.bootstrap) {
+        try {
+            result = await opts.bootstrap();
+        }
+        catch (err) {
+            out.warn(`Bootstrap hit an unexpected error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    for (const line of renderHome(result, { piAvailable: opts.piAvailable, version: opts.version })) {
+        out.log(line);
+    }
+}

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

@@ -1,7 +1,3 @@
-/**
- * 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;

package/dist/cli/removed-verbs.js

@@ -53,24 +53,35 @@ exports.printRemovedVerbMessage = printRemovedVerbMessage;
  */
 const out = __importStar(require("./output"));
 /**
- * Short hints completing "Use the TUI: agent-tempo → …". Keys are the
- * removed CLI verbs; values name the TUI equivalent.
+ * Hints for removed CLI verbs. Keys are the removed verbs; values complete
+ * the "Use …" sentence in {@link removedVerbMessage}.
+ *
+ * #789 (E.8): the Ink TUI is gone, so the #288-era "Use the TUI: …" hints
+ * were rewritten against the surviving operator surfaces — mission-control
+ * (`agent-tempo command-center`, slash commands) with the web dashboard as
+ * the zero-dependency fallback. Per the v2 scoping plan (§C.3), this WHOLE
+ * file — every entry including the new `tui` one — ships for one 2.0
+ * release as migration hints and is then deleted as a unit.
  */
+const CC = 'the command-center: agent-tempo command-center → ';
 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',
+    stop: `${CC}/destroy <player>`,
+    conduct: '`agent-tempo up` (auto-provisions the conductor), then `agent-tempo command-center`',
+    start: `${CC}/recruit <name>`,
+    disband: `${CC}/destroy <player> (or /ensemble-down)`,
+    detach: `${CC}/ensemble-down (detach is no longer a user-facing verb)`,
+    restart: `${CC}/restart <player>`,
+    recruit: `${CC}/recruit <name>`,
+    migrate: `${CC}/migrate <player> <host>`,
+    resume: `${CC}/play`,
+    // #789 — the TUI launch verb itself. Bare `agent-tempo` is now the status
+    // home; the live surfaces are the command-center and the web dashboard.
+    tui: 'bare `agent-tempo` for status, `agent-tempo command-center` for the live board (Pi seat), or `agent-tempo dashboard`',
 };
 /** 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.`;
+    return `"${verb}" is no longer a CLI verb. Use ${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) {