agent-tempo 1.7.0 → 2.0.0-beta.2

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

@@ -1,4 +1,4 @@
-import type { AnswerEntry } from '../../types';
+import type { AnswerEntry, HostInfo, AttachmentInfo, ScheduleEntry, Message, SentMessage } from '../../types';
 import type { EnsembleSummary } from '../../client/interface';
 /** Env var holding the daemon admin (T3) token (writes + inner tail). */
 export declare const ADMIN_TOKEN_ENV = "AGENT_TEMPO_HTTP_ADMIN_TOKEN";
@@ -104,9 +104,75 @@ export declare class MissionControlActions {
         ok: false;
         error: string;
     }>;
+    /**
+     * List connected hosts (`GET /v1/hosts`, Tier-1 read) — the cluster host
+     * registry + freshness + capability profile, the same payload the dashboard
+     * `/hosts` view and the CLI `agent-tempo hosts` consume. NOT ensemble-scoped
+     * (the host registry is cluster-global), so it ignores the bound ensemble.
+     */
+    listHosts(): Promise<{
+        ok: true;
+        hosts: HostInfo[];
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * A player's V2 attachment-lifecycle snapshot (`GET /v1/ensembles/:e/attachment-info`,
+     * Tier-1 read). Thin shim over `client.attachmentInfo` — the same payload the
+     * MCP `attachment_info` tool and CLI `attachment-info` render via the shared
+     * `formatAttachmentInfoForDisplay`. The player is a `?playerId=` query param.
+     */
+    attachmentInfo(playerId: string): Promise<{
+        ok: true;
+        info: AttachmentInfo;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * A player's full message timeline (received + sent). Hits the existing
+     * `POST /v1/ensembles/:e/recall` route with `{ full: true }` so the daemon
+     * returns the raw `{ received, sent }` arrays (the default count-only shape
+     * stays for the dashboard). Thin shim over `client.recall`; the caller feeds
+     * the result through the shared `buildTimeline`/`formatRecall` helpers. POST
+     * (not GET) because recall groups with the per-player action surface (T2).
+     */
+    recall(playerId: string): Promise<{
+        ok: true;
+        received: Message[];
+        sent: SentMessage[];
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * Active schedules for the bound ensemble (`GET /v1/ensembles/:e/schedules`,
+     * Tier-1 read). Thin shim over `client.getSchedules` — the same `ScheduleEntry[]`
+     * the MCP `schedules` tool and CLI render. Empty when no scheduler is running.
+     */
+    listSchedules(): Promise<{
+        ok: true;
+        schedules: ScheduleEntry[];
+    } | {
+        ok: false;
+        error: string;
+    }>;
     cue(to: string, message: string): Promise<ActionResult>;
     pause(): Promise<ActionResult>;
     play(release?: boolean): Promise<ActionResult>;
+    /**
+     * Free HELD players via the dedicated `POST /v1/ensembles/:e/release` route
+     * (#742 gap 8 — `/go`). Optional `playerId` releases ONE held player; omitted
+     * releases all held in the ensemble. Distinct from `play(release:true)`, which
+     * ALSO clears the PAUSE axis — `/go` frees holds without touching pause.
+     */
+    release(playerId?: string): Promise<ActionResult>;
+    /**
+     * Cancel a named schedule (`POST /v1/ensembles/:e/unschedule`, #742 gap —
+     * `/unschedule` & `/schedule delete`). Thin shim over `client.cancelSchedule`.
+     */
+    unschedule(name: string): Promise<ActionResult>;
     restart(playerId: string, reason?: string): Promise<ActionResult>;
     destroy(playerId: string, reason?: string): Promise<ActionResult>;
     reset(playerId: string, reason?: string): Promise<ActionResult>;

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

@@ -211,6 +211,51 @@ class MissionControlActions {
         const res = await this.getJson('/v1/ensembles');
         return res.ok ? { ok: true, ensembles: res.data } : res;
     }
+    // ── Read surface: hosts (#742 gap 5) ──
+    /**
+     * List connected hosts (`GET /v1/hosts`, Tier-1 read) — the cluster host
+     * registry + freshness + capability profile, the same payload the dashboard
+     * `/hosts` view and the CLI `agent-tempo hosts` consume. NOT ensemble-scoped
+     * (the host registry is cluster-global), so it ignores the bound ensemble.
+     */
+    async listHosts() {
+        const res = await this.getJson('/v1/hosts');
+        return res.ok ? { ok: true, hosts: res.data } : res;
+    }
+    // ── Read surface: attachment-info (#742 gap — /attachment-info) ──
+    /**
+     * A player's V2 attachment-lifecycle snapshot (`GET /v1/ensembles/:e/attachment-info`,
+     * Tier-1 read). Thin shim over `client.attachmentInfo` — the same payload the
+     * MCP `attachment_info` tool and CLI `attachment-info` render via the shared
+     * `formatAttachmentInfoForDisplay`. The player is a `?playerId=` query param.
+     */
+    async attachmentInfo(playerId) {
+        const res = await this.getJson(`/v1/ensembles/${this.ens()}/attachment-info?playerId=${encodeURIComponent(playerId)}`);
+        return res.ok ? { ok: true, info: res.data } : res;
+    }
+    // ── Read surface: recall (#742 gap — /recall) ──
+    /**
+     * A player's full message timeline (received + sent). Hits the existing
+     * `POST /v1/ensembles/:e/recall` route with `{ full: true }` so the daemon
+     * returns the raw `{ received, sent }` arrays (the default count-only shape
+     * stays for the dashboard). Thin shim over `client.recall`; the caller feeds
+     * the result through the shared `buildTimeline`/`formatRecall` helpers. POST
+     * (not GET) because recall groups with the per-player action surface (T2).
+     */
+    async recall(playerId) {
+        const res = await this.postJson(`/v1/ensembles/${this.ens()}/recall`, { playerId, full: true });
+        return res.ok ? { ok: true, received: res.data.received, sent: res.data.sent } : res;
+    }
+    // ── Read surface: schedules (#742 gap — /schedule list) ──
+    /**
+     * Active schedules for the bound ensemble (`GET /v1/ensembles/:e/schedules`,
+     * Tier-1 read). Thin shim over `client.getSchedules` — the same `ScheduleEntry[]`
+     * the MCP `schedules` tool and CLI render. Empty when no scheduler is running.
+     */
+    async listSchedules() {
+        const res = await this.getJson(`/v1/ensembles/${this.ens()}/schedules`);
+        return res.ok ? { ok: true, schedules: res.data } : res;
+    }
     // ── Ensemble write surface (T2) ──
     cue(to, message) {
         // #822 — parse the deliverability hint so the board warns on a detached/gone
@@ -223,6 +268,22 @@ class MissionControlActions {
     play(release) {
         return this.post(`/v1/ensembles/${this.ens()}/play`, release ? { release } : {});
     }
+    /**
+     * Free HELD players via the dedicated `POST /v1/ensembles/:e/release` route
+     * (#742 gap 8 — `/go`). Optional `playerId` releases ONE held player; omitted
+     * releases all held in the ensemble. Distinct from `play(release:true)`, which
+     * ALSO clears the PAUSE axis — `/go` frees holds without touching pause.
+     */
+    release(playerId) {
+        return this.post(`/v1/ensembles/${this.ens()}/release`, playerId ? { playerId } : {});
+    }
+    /**
+     * Cancel a named schedule (`POST /v1/ensembles/:e/unschedule`, #742 gap —
+     * `/unschedule` & `/schedule delete`). Thin shim over `client.cancelSchedule`.
+     */
+    unschedule(name) {
+        return this.post(`/v1/ensembles/${this.ens()}/unschedule`, { name });
+    }
     restart(playerId, reason) {
         return this.post(`/v1/ensembles/${this.ens()}/restart`, { playerId, ...(reason ? { reason } : {}) });
     }

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

@@ -194,6 +194,83 @@ export declare class Controller {
     /** First whitespace-delimited token + the remainder. */
     private static splitFirst;
     cmdPlayers(ctx: McExtensionContext): Promise<void>;
+    /**
+     * Connected-host listing — reuses the shared `formatHostList` formatter (the
+     * same text the CLI `hosts` and MCP `hosts` tool render). `includeStale`
+     * surfaces hosts past their liveness window (`/hosts --all`). Returns the
+     * text so a future planner tool can reuse it (same shape as
+     * {@link ensemblesText}). NOT ensemble-scoped — the host registry is global.
+     */
+    hostsText(includeStale: boolean): Promise<{
+        ok: true;
+        text: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    cmdHosts(args: string, ctx: McExtensionContext): Promise<void>;
+    /**
+     * Full board detail — the human counterpart to the `observe_board` planner
+     * tool. Renders the live `BoardModel` (already kept current by the coarse SSE
+     * stream), so there's no extra fetch: the board IS the snapshot. Richer than
+     * the TUI `/status` overlay (phase glyphs + currentTool + context% + tail).
+     */
+    cmdStatus(ctx: McExtensionContext): void;
+    /**
+     * `/go [player]` — free HELD players. Uses the dedicated `release` route so
+     * it frees holds WITHOUT clearing the PAUSE axis (that's `/play` / `/unpause`).
+     * No arg → release all held in the ensemble; `/go <player>` releases one.
+     */
+    cmdGo(args: string, ctx: McExtensionContext): Promise<void>;
+    /**
+     * A player's attachment-lifecycle snapshot — reuses the shared
+     * `formatAttachmentInfoForDisplay` (the same text the CLI `attachment-info`
+     * and MCP `attachment_info` tool render). Returns the text so a future planner
+     * tool can reuse it (same shape as {@link hostsText}).
+     */
+    attachmentInfoText(playerId: string): Promise<{
+        ok: true;
+        text: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    cmdAttachmentInfo(args: string, ctx: McExtensionContext): Promise<void>;
+    /**
+     * A player's message timeline — reuses the shared `buildTimeline`/`formatRecall`
+     * helpers (the same render the CLI `recall` and MCP `recall` tool produce).
+     * Includes sent messages (operator wants the full picture). Pulls the full
+     * timeline via the `{ full: true }` recall route, NOT the count-only default.
+     */
+    recallText(playerId: string): Promise<{
+        ok: true;
+        text: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    cmdRecall(args: string, ctx: McExtensionContext): Promise<void>;
+    /**
+     * Active-schedule listing — renders each {@link ScheduleEntry} in the same
+     * shape the MCP `schedules` tool produces (name → target | recurrence | next).
+     */
+    schedulesText(): Promise<{
+        ok: true;
+        text: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * `/schedule [list | delete <name>]` — list active schedules (default) or
+     * cancel one. CREATE is intentionally NOT here: there is no thin-shim create
+     * method on the client (the MCP `schedule` tool signals the scheduler workflow
+     * directly), so create stays on the MCP tool / CLI per the architect's
+     * thin-shim ruling.
+     */
+    cmdSchedule(args: string, ctx: McExtensionContext): Promise<void>;
+    /** `/unschedule <name>` — alias for `/schedule delete <name>`. */
+    cmdUnschedule(args: string, ctx: McExtensionContext): Promise<void>;
     /**
      * One-line ensembles listing — `▶` marks the board's current binding. Shared
      * by the `/ensembles` command and the `list_ensembles` planner tool. Returns

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

@@ -74,6 +74,9 @@ const inner_tail_1 = require("./inner-tail");
 const ensure_infra_1 = require("../../cli/ensure-infra");
 const zod_to_typebox_1 = require("../zod-to-typebox");
 const validation_1 = require("../../utils/validation");
+const format_hosts_1 = require("../../utils/format-hosts");
+const attachment_format_1 = require("../../utils/attachment-format");
+const recall_format_1 = require("../../utils/recall-format");
 /** The durable conductor a `/handoff` targets by default (matches catalog's conductorName default). */
 const DEFAULT_CONDUCTOR = 'conductor';
 /**
@@ -96,6 +99,34 @@ const ASK_POLL_INTERVAL_MS = 1_000;
 function mintQuestionId() {
     return `q-${crypto.randomUUID()}`;
 }
+/** Compact recurrence label for a schedule (ms interval → "5m"/"1h"/…). */
+function formatScheduleInterval(ms) {
+    if (ms >= 86_400_000)
+        return `${ms / 86_400_000}d`;
+    if (ms >= 3_600_000)
+        return `${ms / 3_600_000}h`;
+    if (ms >= 60_000)
+        return `${ms / 60_000}m`;
+    return `${ms / 1000}s`;
+}
+/**
+ * #742 — render one {@link ScheduleEntry} for the board, mirroring the MCP
+ * `schedules` tool line shape (name → target | recurrence (bounds) | next + msg
+ * preview). Kept module-local + pure so the controller test can assert it.
+ */
+function formatScheduleLine(s) {
+    const recur = s.cronExpression
+        ? `cron: ${s.cronExpression} (${s.timezone || 'UTC'})`
+        : s.interval ? `every ${formatScheduleInterval(s.interval)}` : 'one-shot';
+    const bounds = [];
+    if (s.until)
+        bounds.push(`until ${s.until}`);
+    if (s.remainingCount != null)
+        bounds.push(`${s.firedCount}/${s.firedCount + s.remainingCount} fired`);
+    const boundsStr = bounds.length ? ` (${bounds.join(', ')})` : '';
+    const msgPreview = s.message.length > 60 ? s.message.slice(0, 57) + '...' : s.message;
+    return `• ${s.name} → ${s.target} | ${recur}${boundsStr} | next: ${s.nextFireAt}\n  msg: ${msgPreview}`;
+}
 /**
  * #700 P2 — build the planner-wake injection from a resolved `answer` SSE event.
  * Pure (testable). The planner has no inbox; the SSE `answer` event is turned
@@ -344,6 +375,139 @@ class Controller {
         const ids = (0, board_1.sortedPlayerIds)(this.model);
         this.notify(ctx, ids.length ? `Players (${ids.length}): ${ids.join(', ')}` : 'No players in the ensemble.');
     }
+    // ── Hosts (#742 gap 5) ──
+    /**
+     * Connected-host listing — reuses the shared `formatHostList` formatter (the
+     * same text the CLI `hosts` and MCP `hosts` tool render). `includeStale`
+     * surfaces hosts past their liveness window (`/hosts --all`). Returns the
+     * text so a future planner tool can reuse it (same shape as
+     * {@link ensemblesText}). NOT ensemble-scoped — the host registry is global.
+     */
+    async hostsText(includeStale) {
+        const r = await this.actions.listHosts();
+        if (!r.ok)
+            return r;
+        return { ok: true, text: (0, format_hosts_1.formatHostList)(r.hosts, { includeStale }) };
+    }
+    async cmdHosts(args, ctx) {
+        const includeStale = /(?:^|\s)(?:--all|-a)(?:\s|$)/.test(args);
+        const r = await this.hostsText(includeStale);
+        this.notify(ctx, r.ok ? r.text : `hosts failed: ${r.error}`);
+    }
+    // ── Status (#742 gap 9) ──
+    /**
+     * Full board detail — the human counterpart to the `observe_board` planner
+     * tool. Renders the live `BoardModel` (already kept current by the coarse SSE
+     * stream), so there's no extra fetch: the board IS the snapshot. Richer than
+     * the TUI `/status` overlay (phase glyphs + currentTool + context% + tail).
+     */
+    cmdStatus(ctx) {
+        this.notify(ctx, (0, render_1.renderBoard)(this.model, this.localHost).join('\n'));
+    }
+    // ── Release / go (#742 gap 8) ──
+    /**
+     * `/go [player]` — free HELD players. Uses the dedicated `release` route so
+     * it frees holds WITHOUT clearing the PAUSE axis (that's `/play` / `/unpause`).
+     * No arg → release all held in the ensemble; `/go <player>` releases one.
+     */
+    async cmdGo(args, ctx) {
+        const player = args.trim().split(/\s+/).filter(Boolean)[0];
+        const label = player ? `go (release ${player})` : 'go (release held)';
+        this.report(ctx, label, await this.actions.release(player || undefined));
+    }
+    // ── Attachment-info (#742 — /attachment-info) ──
+    /**
+     * A player's attachment-lifecycle snapshot — reuses the shared
+     * `formatAttachmentInfoForDisplay` (the same text the CLI `attachment-info`
+     * and MCP `attachment_info` tool render). Returns the text so a future planner
+     * tool can reuse it (same shape as {@link hostsText}).
+     */
+    async attachmentInfoText(playerId) {
+        const r = await this.actions.attachmentInfo(playerId);
+        if (!r.ok)
+            return r;
+        return { ok: true, text: (0, attachment_format_1.formatAttachmentInfoForDisplay)(playerId, r.info).join('\n') };
+    }
+    async cmdAttachmentInfo(args, ctx) {
+        const player = args.trim().split(/\s+/).filter(Boolean)[0];
+        if (!player) {
+            this.notify(ctx, 'Usage: /attachment-info <player>');
+            return;
+        }
+        const r = await this.attachmentInfoText(player);
+        this.notify(ctx, r.ok ? r.text : `attachment-info failed: ${r.error}`);
+    }
+    // ── Recall (#742 — /recall) ──
+    /**
+     * A player's message timeline — reuses the shared `buildTimeline`/`formatRecall`
+     * helpers (the same render the CLI `recall` and MCP `recall` tool produce).
+     * Includes sent messages (operator wants the full picture). Pulls the full
+     * timeline via the `{ full: true }` recall route, NOT the count-only default.
+     */
+    async recallText(playerId) {
+        const r = await this.actions.recall(playerId);
+        if (!r.ok)
+            return r;
+        const timeline = (0, recall_format_1.buildTimeline)(r.received, r.sent, true);
+        return { ok: true, text: (0, recall_format_1.formatRecall)(timeline).text };
+    }
+    async cmdRecall(args, ctx) {
+        const player = args.trim().split(/\s+/).filter(Boolean)[0];
+        if (!player) {
+            this.notify(ctx, 'Usage: /recall <player>');
+            return;
+        }
+        const r = await this.recallText(player);
+        this.notify(ctx, r.ok ? r.text : `recall failed: ${r.error}`);
+    }
+    // ── Schedules (#742 — /schedule, /unschedule) ──
+    /**
+     * Active-schedule listing — renders each {@link ScheduleEntry} in the same
+     * shape the MCP `schedules` tool produces (name → target | recurrence | next).
+     */
+    async schedulesText() {
+        const r = await this.actions.listSchedules();
+        if (!r.ok)
+            return r;
+        if (r.schedules.length === 0)
+            return { ok: true, text: 'No active schedules.' };
+        return { ok: true, text: r.schedules.map(formatScheduleLine).join('\n') };
+    }
+    /**
+     * `/schedule [list | delete <name>]` — list active schedules (default) or
+     * cancel one. CREATE is intentionally NOT here: there is no thin-shim create
+     * method on the client (the MCP `schedule` tool signals the scheduler workflow
+     * directly), so create stays on the MCP tool / CLI per the architect's
+     * thin-shim ruling.
+     */
+    async cmdSchedule(args, ctx) {
+        const [sub, rest] = Controller.splitFirst(args);
+        if (sub === 'delete' || sub === 'rm') {
+            const name = rest.trim().split(/\s+/).filter(Boolean)[0];
+            if (!name) {
+                this.notify(ctx, 'Usage: /schedule delete <name>');
+                return;
+            }
+            this.report(ctx, `unschedule ${name}`, await this.actions.unschedule(name));
+            return;
+        }
+        if (sub === 'create' || sub === 'new' || sub === 'add') {
+            this.notify(ctx, 'Schedule creation runs through the MCP `schedule` tool / `agent-tempo schedule` CLI — the board lists and deletes only.');
+            return;
+        }
+        // Default (no arg or `list`) → list.
+        const r = await this.schedulesText();
+        this.notify(ctx, r.ok ? r.text : `schedules failed: ${r.error}`);
+    }
+    /** `/unschedule <name>` — alias for `/schedule delete <name>`. */
+    async cmdUnschedule(args, ctx) {
+        const name = args.trim().split(/\s+/).filter(Boolean)[0];
+        if (!name) {
+            this.notify(ctx, 'Usage: /unschedule <name>');
+            return;
+        }
+        this.report(ctx, `unschedule ${name}`, await this.actions.unschedule(name));
+    }
     // ── Multi-ensemble home (#790) ──
     /**
      * One-line ensembles listing — `▶` marks the board's current binding. Shared
@@ -1086,6 +1250,13 @@ function createMissionControlExtension(deps = {}) {
         pi.on('session_shutdown', () => teardown());
         // Operator commands (display-only widget → slash-commands drive everything).
         pi.registerCommand('players', { description: 'List ensemble players', handler: (_a, ctx) => ctrl.cmdPlayers(ctx) });
+        pi.registerCommand('hosts', { description: 'List connected hosts (/hosts [--all])', handler: (a, ctx) => ctrl.cmdHosts(a, ctx) });
+        pi.registerCommand('status', { description: 'Show the full board detail', handler: (_a, ctx) => ctrl.cmdStatus(ctx) });
+        pi.registerCommand('go', { description: 'Release HELD players (/go [player])', handler: (a, ctx) => ctrl.cmdGo(a, ctx) });
+        pi.registerCommand('attachment-info', { description: 'Show a player\'s attachment lifecycle (/attachment-info <player>)', handler: (a, ctx) => ctrl.cmdAttachmentInfo(a, ctx) });
+        pi.registerCommand('recall', { description: 'Show a player\'s message timeline (/recall <player>)', handler: (a, ctx) => ctrl.cmdRecall(a, ctx) });
+        pi.registerCommand('schedule', { description: 'List or delete schedules (/schedule [list | delete <name>])', handler: (a, ctx) => ctrl.cmdSchedule(a, ctx) });
+        pi.registerCommand('unschedule', { description: 'Cancel a schedule (/unschedule <name>)', handler: (a, ctx) => ctrl.cmdUnschedule(a, ctx) });
         // #790 — multi-ensemble home: list + re-bind.
         pi.registerCommand('ensembles', { description: 'List all ensembles (▶ marks the bound one)', handler: (_a, ctx) => ctrl.cmdEnsembles(ctx) });
         pi.registerCommand('ensemble', { description: 'Switch the board to another ensemble (/ensemble <name> [--force])', handler: (a, ctx) => ctrl.cmdEnsemble(a, ctx) });

package/dist/pi/workflow-client.d.ts

@@ -153,26 +153,24 @@ export declare class PiWorkflowClient {
     fetchPending(): Promise<Message[]>;
     /** Acknowledge delivered cue ids so the workflow stops re-serving them. */
     ackDelivered(messageIds: string[]): Promise<void>;
-    /**
-     * `true` until a `pendingIntake` query is rejected as unregistered — i.e.
-     * the session workflow predates #750. Cached so the pump pays the failed
-     * probe ONCE, not every tick, then sticks to the legacy two-query path for
-     * the lifetime of this client. Known cost-only staleness: the Pi client
-     * handle follows continueAsNew transparently, so a pre-#750 workflow that
-     * CANs onto a #750+ worker bundle MID-SESSION keeps paying 2 queries/tick
-     * here until the extension process restarts (fresh client → fresh probe).
-     * Benign and self-healing — correctness is unaffected either way.
-     */
-    private combinedIntakeSupported;
     /**
      * One-query intake: undelivered cues + the pending reset together —
-     * halves the pump's idle Temporal actions (2 → 1 query/tick). Falls back
-     * to the legacy `pendingMessages` + `pendingReset` pair when the workflow
-     * lacks the combined handler (pre-#750 build); genuine failures (timeouts,
-     * connection errors) propagate to the pump's existing per-tick handling.
+     * halves the pump's idle Temporal actions (2 → 1 query/tick).
+     *
+     * 2.0 (#788): the pre-#750 two-query fallback (`combinedIntakeSupported`
+     * probe + the legacy `pendingMessages` + `pendingReset` pair) is gone — the
+     * A2 clean cutover (guarded by #786) guarantees every 2.0 session workflow
+     * serves the `pendingIntake` handler, so the fallback was dead.
      */
     fetchIntake(): Promise<PendingIntake>;
-    /** Poll the workflow's single-slot pending reset (null = none). */
+    /**
+     * Poll the workflow's single-slot pending reset (null = none).
+     *
+     * 2.0 (#788): the standalone `pendingReset` query was removed — derive the
+     * reset from the combined `pendingIntake` query. Only the cue-pump's
+     * no-`intakeSource` fallback path reaches this; the primary pump path reads
+     * `pendingReset` straight off `fetchIntake`'s result.
+     */
     fetchPendingReset(): Promise<PendingReset | null>;
     /**
      * Ack a performed reset by id — the workflow clears the slot ONLY if the id

package/dist/pi/workflow-client.js

@@ -23,6 +23,7 @@ const action_counters_1 = require("../utils/action-counters");
 const search_attributes_1 = require("../utils/search-attributes");
 const config_1 = require("../config");
 const signals_1 = require("../workflows/signals");
+const constants_1 = require("../constants");
 /** Adapter identity advertised on claim. Pi interactive players are `interactive`-class. */
 const PI_ADAPTER_ID = 'pi';
 /**
@@ -160,6 +161,7 @@ class PiWorkflowClient {
                     adapterId: PI_ADAPTER_ID,
                     adapterClass: 'interactive',
                     leaseMs: this.leaseMs,
+                    protocolVersion: constants_1.PROTOCOL_VERSION, // #786 — 2.0 wire handshake
                     ...(this.expectedAttachmentId ? { expectedAttachmentId: this.expectedAttachmentId } : {}),
                 },
             ],
@@ -286,57 +288,29 @@ class PiWorkflowClient {
         await handle.signal(signals_1.markDeliveredSignal, messageIds);
     }
     // ── Combined intake (T0.3 of #747, #750) ──
-    /**
-     * `true` until a `pendingIntake` query is rejected as unregistered — i.e.
-     * the session workflow predates #750. Cached so the pump pays the failed
-     * probe ONCE, not every tick, then sticks to the legacy two-query path for
-     * the lifetime of this client. Known cost-only staleness: the Pi client
-     * handle follows continueAsNew transparently, so a pre-#750 workflow that
-     * CANs onto a #750+ worker bundle MID-SESSION keeps paying 2 queries/tick
-     * here until the extension process restarts (fresh client → fresh probe).
-     * Benign and self-healing — correctness is unaffected either way.
-     */
-    combinedIntakeSupported = true;
     /**
      * One-query intake: undelivered cues + the pending reset together —
-     * halves the pump's idle Temporal actions (2 → 1 query/tick). Falls back
-     * to the legacy `pendingMessages` + `pendingReset` pair when the workflow
-     * lacks the combined handler (pre-#750 build); genuine failures (timeouts,
-     * connection errors) propagate to the pump's existing per-tick handling.
+     * halves the pump's idle Temporal actions (2 → 1 query/tick).
+     *
+     * 2.0 (#788): the pre-#750 two-query fallback (`combinedIntakeSupported`
+     * probe + the legacy `pendingMessages` + `pendingReset` pair) is gone — the
+     * A2 clean cutover (guarded by #786) guarantees every 2.0 session workflow
+     * serves the `pendingIntake` handler, so the fallback was dead.
      */
     async fetchIntake() {
-        if (this.combinedIntakeSupported) {
-            const handle = this.requireHandle();
-            try {
-                const intake = await handle.query(signals_1.pendingIntakeQuery);
-                // Shape-guard: a real server either serves the query or rejects it
-                // as unregistered, but belt-and-braces against converter quirks /
-                // test doubles — a malformed result downgrades to the legacy pair
-                // rather than crashing the pump tick.
-                if (intake && Array.isArray(intake.messages))
-                    return intake;
-                this.combinedIntakeSupported = false;
-                log('pendingIntake returned a malformed result — falling back to the legacy pair');
-            }
-            catch (err) {
-                if (!isQueryNotRegisteredError(err))
-                    throw err;
-                this.combinedIntakeSupported = false;
-                log('pendingIntake query not registered on this workflow (pre-#750 build) — ' +
-                    'falling back to the legacy pendingMessages + pendingReset pair');
-            }
-        }
-        const [messages, pendingReset] = await Promise.all([
-            this.fetchPending(),
-            this.fetchPendingReset(),
-        ]);
-        return { messages, pendingReset };
+        return this.requireHandle().query(signals_1.pendingIntakeQuery);
     }
     // ── Reset intake (3d D14) ──
-    /** Poll the workflow's single-slot pending reset (null = none). */
+    /**
+     * Poll the workflow's single-slot pending reset (null = none).
+     *
+     * 2.0 (#788): the standalone `pendingReset` query was removed — derive the
+     * reset from the combined `pendingIntake` query. Only the cue-pump's
+     * no-`intakeSource` fallback path reaches this; the primary pump path reads
+     * `pendingReset` straight off `fetchIntake`'s result.
+     */
     async fetchPendingReset() {
-        const handle = this.requireHandle();
-        return handle.query(signals_1.pendingResetQuery);
+        return (await this.requireHandle().query(signals_1.pendingIntakeQuery)).pendingReset;
     }
     /**
      * Ack a performed reset by id — the workflow clears the slot ONLY if the id