agent-tempo 1.7.0-beta.10 → 1.7.0-beta.11

package/README.md

@@ -148,7 +148,7 @@ agent-tempo                    # launch TUI (auto-provisions on first run)
 agent-tempo up [ensemble]      # provision infrastructure and launch conductor
 agent-tempo down [--destroy]   # tear down infrastructure (--destroy also terminates workflows)
 agent-tempo status [ensemble]  # list active sessions
-agent-tempo destroy <ensemble> # terminate all sessions in an ensemble
+agent-tempo destroy [ensemble] # terminate all sessions in an ensemble (defaults to "default")
 agent-tempo restore <ensemble> # restore orphaned sessions on this host
 agent-tempo hosts              # list daemons polling this Temporal namespace (--all/--json)
 agent-tempo recall <name>      # read a player's message history (--limit/--offset/--preview/--json)

package/dashboard/package.json

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

package/dist/cli/commands.d.ts

@@ -51,6 +51,19 @@ interface UpOpts extends CliOverrides {
      */
     scenario?: string;
 }
+/**
+ * #832 — the operator-facing "ensemble ready" lines for `up` / `conduct`.
+ *
+ * Keyed on the RESOLVED ensemble name (what `command-center` / `status` take —
+ * `--ensemble` flag > positional > env > `default`), NOT the lineup's `name:`
+ * field. The two diverge whenever any of those overrides the lineup name, so the
+ * old `Ensemble <lineup-name> is ready` line named a thing the operator can't
+ * actually `connect` to. Surfaces the connect command so the next step is one
+ * copy-paste away. Pure + exported for unit testing (the surrounding `up` does
+ * I/O and isn't unit-testable). The shared markdown {@link ensembleReadyBanner}
+ * stays lineup-keyed for the conductor's seeded directive (a different surface).
+ */
+export declare function formatEnsembleReadyLines(ensemble: string, lineupName: string, playerCount: number): [readyLine: string, connectLine: string];
 export declare function up(opts: UpOpts): Promise<void>;
 /**
  * Format a `ScheduleEntry` recurrence for the `status` display.

package/dist/cli/commands.js

@@ -37,6 +37,7 @@ exports.status = status;
 exports.init = init;
 exports.initProject = initProject;
 exports.server = server;
+exports.formatEnsembleReadyLines = formatEnsembleReadyLines;
 exports.up = up;
 exports.formatScheduleRecurrence = formatScheduleRecurrence;
 exports.lineupScheduleToEntry = lineupScheduleToEntry;
@@ -710,7 +711,10 @@ async function start(opts) {
     out.log(`\nCheck status: ${out.dim('agent-tempo status ' + opts.ensemble)}`);
     if (startLineup && startInitialStartup) {
         console.log();
-        out.log(`  ${(0, constants_1.ensembleReadyBanner)(startLineup.name, startLineup.players.length)}`);
+        // #832 — name the RESOLVED ensemble (opts.ensemble), not the lineup's `name:`.
+        const [readyLine, connectLine] = formatEnsembleReadyLines(opts.ensemble, startLineup.name, startLineup.players.length);
+        out.success(readyLine);
+        out.log(`  ${out.dim(connectLine)}`);
     }
 }
 async function status(opts) {
@@ -1036,6 +1040,25 @@ async function server(opts) {
         out.success('Temporal ready');
     }
 }
+/**
+ * #832 — the operator-facing "ensemble ready" lines for `up` / `conduct`.
+ *
+ * Keyed on the RESOLVED ensemble name (what `command-center` / `status` take —
+ * `--ensemble` flag > positional > env > `default`), NOT the lineup's `name:`
+ * field. The two diverge whenever any of those overrides the lineup name, so the
+ * old `Ensemble <lineup-name> is ready` line named a thing the operator can't
+ * actually `connect` to. Surfaces the connect command so the next step is one
+ * copy-paste away. Pure + exported for unit testing (the surrounding `up` does
+ * I/O and isn't unit-testable). The shared markdown {@link ensembleReadyBanner}
+ * stays lineup-keyed for the conductor's seeded directive (a different surface).
+ */
+function formatEnsembleReadyLines(ensemble, lineupName, playerCount) {
+    const plural = playerCount === 1 ? '' : 's';
+    return [
+        `Ensemble "${ensemble}" is ready (from lineup ${lineupName}). ${playerCount} player${plural} on standby.`,
+        `Connect: agent-tempo command-center ${ensemble}`,
+    ];
+}
 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
@@ -1383,7 +1406,10 @@ async function up(opts) {
     // nothing is deferred — we only surface the banner on initial-startup paths.
     if (lineup && initialStartup) {
         console.log();
-        out.log(`  ${(0, constants_1.ensembleReadyBanner)(lineup.name, lineup.players.length)}`);
+        // #832 — name the RESOLVED ensemble (opts.ensemble), not the lineup's `name:`.
+        const [readyLine, connectLine] = formatEnsembleReadyLines(opts.ensemble, lineup.name, lineup.players.length);
+        out.success(readyLine);
+        out.log(`  ${out.dim(connectLine)}`);
     }
     console.log();
 }

package/dist/cli.js

@@ -544,10 +544,18 @@ async function main() {
             });
             break;
         case 'destroy': {
-            const target = args.positional[1] || args.ensemble || process.env[config_1.ENV.ENSEMBLE];
-            if (!target) {
-                out.error('Usage: agent-tempo destroy <ensemble> [-y]');
-                process.exit(1);
+            // #835 — use the SHARED resolver (flag > positional > env > default) so
+            // `destroy` matches every other verb. It previously hand-rolled INVERTED
+            // precedence (`positional || ensemble || env`), so `destroy foo --ensemble
+            // bar` destroyed `foo` — the lone outlier. `destroy` is gated by a typed
+            // confirmation (or `--yes`), so the resolver's `default` fallback is safe.
+            const target = (0, resolve_ensemble_1.resolveEnsemble)(args);
+            // #835 — surface a flag-over-positional override as a non-fatal note so the
+            // flag silently winning over a DIFFERENT positional isn't a silent mask
+            // (flag wins by design — this only warns, never errors).
+            const positional = args.positional[1];
+            if (args.ensemble && positional && args.ensemble !== positional) {
+                out.warn(`note: --ensemble "${args.ensemble}" overrides positional "${positional}"`);
             }
             await destroy({
                 ensemble: target,

package/dist/http/writes.js

@@ -276,6 +276,17 @@ function mapWriteError(res, action, ensemble, err) {
     if (/no session found|no maestro|workflow not found/i.test(message)) {
         return (0, responses_1.errorResponse)(res, 404, { error: 'session-not-found', action, ensemble, detail: message });
     }
+    // #834 — a cue/ask to a player whose workflow is ABSENT (destroyed / never
+    // existed) throws `Player "<to>" not found in ensemble "<ens>"` from
+    // `sendAsMaestro` (core.ts). That's a 404, not a 500 — the operator typo'd a
+    // name or the player was destroyed. NOTE: a detached/gone-but-Running player
+    // never reaches here — its workflow still matches the `ExecutionStatus =
+    // "Running"` query, so `sendAsMaestro` signals it and the soft-fail 202/queued
+    // path (checkDeliverability) handles it (no throw). So this 404 cannot
+    // regress the #822/#827 warn-but-queue contract.
+    if (/player ".*" not found in ensemble/i.test(message)) {
+        return (0, responses_1.errorResponse)(res, 404, { error: 'player-not-found', action, ensemble, detail: message });
+    }
     if (/Unknown agent type/i.test(message)) {
         return (0, responses_1.errorResponse)(res, 400, { error: 'unknown-agent-type', action, ensemble, detail: message });
     }

package/dist/pi/mission-control/actions.js

@@ -63,6 +63,28 @@ class MissionControlActions {
      * the daemon's own body detail (it already returns good 403/503 hints).
      */
     httpError(status, detail) {
+        // #834 — the daemon returns a structured `player-not-found` 404 (a cue/ask to
+        // a destroyed / never-existed player). Surface a clean operator string rather
+        // than leaking the raw JSON blob the user saw. The `⚠ cue <name> — ` prefix
+        // is the extension footer formatter's job; actions.ts just stops leaking JSON.
+        let parsedError;
+        let parsedDetail;
+        try {
+            const j = JSON.parse(detail);
+            if (typeof j.error === 'string')
+                parsedError = j.error;
+            if (typeof j.detail === 'string')
+                parsedDetail = j.detail;
+        }
+        catch {
+            /* not JSON (or truncated past the 200-char slice) — fall back to raw match */
+        }
+        if (parsedError === 'player-not-found' || /"player-not-found"/.test(detail)) {
+            // Handles both the unescaped parsed detail (`Player "bob" ...`) and the raw
+            // JSON body where the quotes are escaped (`Player \"bob\" ...`).
+            const who = /Player \\?"([^"\\]+)\\?"/.exec(parsedDetail ?? detail)?.[1];
+            return who ? `no such player "${who}"` : 'no such player';
+        }
         if (!this.adminToken && (status === 401 || status === 403 || status === 503)) {
             return (`HTTP ${status}: operator actions need ${exports.ADMIN_TOKEN_ENV} for a remote / 0.0.0.0 daemon ` +
                 `(a local loopback daemon needs none)${detail ? ` — ${detail}` : ''}`);

package/dist/pi/mission-control/extension.d.ts

@@ -177,8 +177,11 @@ export declare class Controller {
      * operator who just wants to un-suspend the ensemble has a single action,
      * without overloading `/play`'s sources-only meaning (the two axes stay
      * distinct at the primitive/daemon level).
+     *
+     * #833 — exposed as `/unpause` (NOT `/resume` — that collides with a Pi
+     * built-in interactive command and gets skipped from autocomplete).
      */
-    cmdResume(_args: string, ctx: McExtensionContext): Promise<void>;
+    cmdUnpause(_args: string, ctx: McExtensionContext): Promise<void>;
     cmdRestart(args: string, ctx: McExtensionContext): Promise<void>;
     cmdDestroy(args: string, ctx: McExtensionContext): Promise<void>;
     cmdReset(args: string, ctx: McExtensionContext): Promise<void>;

package/dist/pi/mission-control/extension.js

@@ -406,9 +406,9 @@ class Controller {
         const r = await this.actions.play(release);
         // #821 — the two-axis wart: a sources-only `/play` that leaves players HELD
         // reads as "nothing happened" (the real #821). Name the residual axis so the
-        // operator knows to clear it — `/resume` does both in one shot.
+        // operator knows to clear it — `/unpause` does both in one shot.
         const extra = r.ok && !release && this.model.held
-            ? 'ensemble resumed, but players are still HELD — use /resume (or /play release) to free them'
+            ? 'ensemble resumed, but players are still HELD — use /unpause (or /play release) to free them'
             : undefined;
         this.report(ctx, 'play', r, extra);
     }
@@ -418,9 +418,12 @@ class Controller {
      * operator who just wants to un-suspend the ensemble has a single action,
      * without overloading `/play`'s sources-only meaning (the two axes stay
      * distinct at the primitive/daemon level).
+     *
+     * #833 — exposed as `/unpause` (NOT `/resume` — that collides with a Pi
+     * built-in interactive command and gets skipped from autocomplete).
      */
-    async cmdResume(_args, ctx) {
-        this.report(ctx, 'resume', await this.actions.play(true));
+    async cmdUnpause(_args, ctx) {
+        this.report(ctx, 'unpause', await this.actions.play(true));
     }
     async cmdRestart(args, ctx) {
         const [p, reason] = Controller.splitFirst(args);
@@ -922,7 +925,8 @@ function createMissionControlExtension(deps = {}) {
         pi.registerCommand('pause', { description: 'Pause the ensemble', handler: (a, ctx) => ctrl.cmdPause(a, ctx) });
         pi.registerCommand('play', { description: 'Clear the PAUSE axis (/play [release] also frees held players)', handler: (a, ctx) => ctrl.cmdPlay(a, ctx) });
         // #821 — the one obvious "resume everything" (clears PAUSE + HELD).
-        pi.registerCommand('resume', { description: 'Resume everything — clears PAUSE + frees HELD players', handler: (a, ctx) => ctrl.cmdResume(a, ctx) });
+        // #833 — registered as `/unpause`, NOT `/resume` (collides with a Pi built-in).
+        pi.registerCommand('unpause', { description: 'Resume everything — clears PAUSE + frees HELD players', handler: (a, ctx) => ctrl.cmdUnpause(a, ctx) });
         pi.registerCommand('restart', { description: 'Restart a player (/restart <player> [reason])', handler: (a, ctx) => ctrl.cmdRestart(a, ctx) });
         pi.registerCommand('destroy', { description: 'Destroy a player (/destroy <player> [reason])', handler: (a, ctx) => ctrl.cmdDestroy(a, ctx) });
         pi.registerCommand('reset', { description: 'Clean-wipe a player (/reset <player> [reason])', handler: (a, ctx) => ctrl.cmdReset(a, ctx) });

package/dist/pi/mission-control/render.d.ts

@@ -1,4 +1,17 @@
 import { type BoardModel } from './board';
+/**
+ * #836 — Pi's `InteractiveMode` hard-caps a widget at this many lines and, beyond
+ * it, naively slices the top N and appends its own dev-speak `... (widget
+ * truncated)` (mirrors `InteractiveMode.MAX_WIDGET_LINES`, verified 0.78.0). That
+ * is doubly bad for us: (1) operators see internal "widget truncated" copy, and
+ * (2) the slice keeps the TOP and drops the BOTTOM — which is exactly the
+ * command-log acks (#821) the operator most needs to see. So we clamp to this
+ * budget OURSELVES with {@link assembleWidget}, keeping the header/banner (top)
+ * AND the command-log footer (bottom) and trimming the expendable middle
+ * (roster/tail) under an operator-friendly `⋯ N … hidden` marker. If Pi ever
+ * raises its cap this only clamps a touch early — it can never over-run it.
+ */
+export declare const MAX_WIDGET_LINES = 10;
 /**
  * Render the full board. Header + player rows (conductor first), then — when a
  * player is selected — a fine inner-loop tail (last {@link TAIL_RENDER_LINES}).

package/dist/pi/mission-control/render.js

@@ -1,9 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_WIDGET_LINES = void 0;
 exports.renderBoard = renderBoard;
 const board_1 = require("./board");
 /** How many recent fine-tail frames to show under the selected player. */
 const TAIL_RENDER_LINES = 12;
+/**
+ * #836 — Pi's `InteractiveMode` hard-caps a widget at this many lines and, beyond
+ * it, naively slices the top N and appends its own dev-speak `... (widget
+ * truncated)` (mirrors `InteractiveMode.MAX_WIDGET_LINES`, verified 0.78.0). That
+ * is doubly bad for us: (1) operators see internal "widget truncated" copy, and
+ * (2) the slice keeps the TOP and drops the BOTTOM — which is exactly the
+ * command-log acks (#821) the operator most needs to see. So we clamp to this
+ * budget OURSELVES with {@link assembleWidget}, keeping the header/banner (top)
+ * AND the command-log footer (bottom) and trimming the expendable middle
+ * (roster/tail) under an operator-friendly `⋯ N … hidden` marker. If Pi ever
+ * raises its cap this only clamps a touch early — it can never over-run it.
+ */
+exports.MAX_WIDGET_LINES = 10;
+/**
+ * #836 — assemble `[head, body, foot]` into a widget that fits {@link
+ * MAX_WIDGET_LINES}. `head` (header + suspension/connection banner) and `foot`
+ * (the #821 command-log acks) are always kept; only the middle `body` (roster +
+ * inner tail) is trimmed, with one line spent on a friendly hidden-count marker
+ * that replaces Pi's `... (widget truncated)` dev-speak. Pure + total — never
+ * returns more than `MAX_WIDGET_LINES` lines (head+foot is ≤ 7 by construction).
+ */
+function assembleWidget(head, body, foot) {
+    const budget = exports.MAX_WIDGET_LINES - head.length - foot.length;
+    if (body.length <= budget)
+        return [...head, ...body, ...foot];
+    // Spend one line on the marker; keep as much of the body top as fits.
+    const keep = Math.max(budget - 1, 0);
+    const hidden = body.length - keep;
+    const marker = hidden > 0 ? `  ⋯ ${hidden} more line${hidden === 1 ? '' : 's'} hidden` : '  ⋯ (older entries hidden)';
+    return [...head, ...body.slice(0, keep), marker, ...foot];
+}
 /**
  * #821 — render the persistent command-log footer (recent acks/⚠/failures). Folds
  * write-command results into the widget so feedback doesn't vanish like the old
@@ -81,7 +113,11 @@ function oneLine(s, max) {
  */
 function renderBoard(model, localHost) {
     const ids = (0, board_1.sortedPlayerIds)(model);
-    const lines = [];
+    // #836 — three bands so the widget clamp keeps the high-value top (header +
+    // banner) and bottom (command-log acks) and only trims the expendable middle.
+    const head = [];
+    const body = [];
+    const foot = renderCommandLog(model);
     // #823 — a GONE ensemble (hard 404 — the maestro is torn down) is the most
     // urgent signal and makes the player list + suspension flags meaningless:
     // render the loud teardown banner and stop, so a destructive
@@ -89,13 +125,12 @@ function renderBoard(model, localHost) {
     // staring at the stale pre-destroy roster (the reported symptom). Players are
     // already cleared by `setConnection('gone')`.
     if (model.connection === 'gone') {
-        lines.push(`MISSION CONTROL · ${model.ensemble} · ENSEMBLE GONE`);
-        lines.push('!! ENSEMBLE DESTROYED — no active players. ' +
+        head.push(`MISSION CONTROL · ${model.ensemble} · ENSEMBLE GONE`);
+        head.push('!! ENSEMBLE DESTROYED — no active players. ' +
             '/ensemble <name> to observe another, or /ensemble-up to re-create.');
         // #821 — keep the command log visible so the `ensemble-down --destroy ✓`
         // ack that produced this state is still on screen (the #823 scenario).
-        lines.push(...renderCommandLog(model));
-        return lines;
+        return assembleWidget(head, body, foot);
     }
     // #752/#823 — the header marker rides one loud line so a paused/held/
     // stream-ended ensemble can't sit unnoticed (the 5h silent-wedge incident).
@@ -128,39 +163,40 @@ function renderBoard(model, localHost) {
         marker = ' · [HELD]';
         what = 'HELD players';
     }
-    lines.push(`MISSION CONTROL · ${model.ensemble} · ${ids.length} player${ids.length === 1 ? '' : 's'}${marker}`);
+    head.push(`MISSION CONTROL · ${model.ensemble} · ${ids.length} player${ids.length === 1 ? '' : 's'}${marker}`);
     if (what) {
         if (model.connection === 'reconnecting') {
             // Informational — no resume hint (the issue is the stream, not a suspend).
-            lines.push(`!! ${what}`);
+            head.push(`!! ${what}`);
         }
         else {
-            // #821 — the one obvious resume is `/resume` (clears PAUSE + HELD); `/play`
+            // #821 — the one obvious resume is `/unpause` (clears PAUSE + HELD); `/play`
             // (sources only) and `/play release` remain for the two-axis primitive.
-            lines.push(`!! ${what} — cues queue silently; resume: /resume (or /play release)`);
+            // #833 — `/unpause`, NOT `/resume` (the latter collides with a Pi built-in).
+            head.push(`!! ${what} — cues queue silently; resume: /unpause (or /play release)`);
         }
     }
     if (ids.length === 0) {
-        lines.push('  (no players — waiting for the ensemble…)');
+        body.push('  (no players — waiting for the ensemble…)');
     }
     else {
         for (const id of ids) {
             const row = model.players.get(id);
-            lines.push(renderRow(row, id === model.selected, localHost));
+            body.push(renderRow(row, id === model.selected, localHost));
         }
     }
     if (model.selected) {
-        lines.push(`── tail: ${model.selected} ──`);
+        body.push(`── tail: ${model.selected} ──`);
         const recent = model.innerTail.slice(-TAIL_RENDER_LINES);
         if (recent.length === 0) {
-            lines.push('  (no inner-loop activity yet)');
+            body.push('  (no inner-loop activity yet)');
         }
         else {
             for (const f of recent)
-                lines.push(renderInnerFrame(f));
+                body.push(renderInnerFrame(f));
         }
     }
-    // #821 — persistent command-result footer (recent acks/⚠/failures).
-    lines.push(...renderCommandLog(model));
-    return lines;
+    // #821 — persistent command-result footer (recent acks/⚠/failures) lives in
+    // `foot` (already computed) so the #836 clamp keeps it visible.
+    return assembleWidget(head, body, foot);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-tempo",
-  "version": "1.7.0-beta.10",
+  "version": "1.7.0-beta.11",
   "description": "Many agents, one tempo. Durable coordination for multi-agent work via Temporal.",
   "keywords": [
     "mcp",