agent-tempo 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/tools/gate.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowHandle } from '@temporalio/client';
+import { type TempoToolDescriptor } from './descriptor';
+/**
+ * Canonical `gate` tool. Dispatches on `action` (define | list); `evaluate_gate`
+ * is intentionally excluded (separate tool).
+ */
+export declare function buildGateTool(handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;
+/**
+ * Legacy forwarding aliases — `quality_gate` → define, `gates` → list. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. Explicit object literals (see §6 drift note).
+ */
+export declare function buildGateAliasTools(handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor[];

package/dist/tools/gate.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGateTool = buildGateTool;
+exports.buildGateAliasTools = buildGateAliasTools;
+/**
+ * `gate` — canonical multi-action quality-gate tool (#793 merge, PARTIAL).
+ *
+ * Merges the two gate-DEFINITION tools (`quality_gate` → define, `gates` → list)
+ * into ONE canonical tool. The canonical name is **net-new**, so `action` is
+ * REQUIRED.
+ *
+ * PARTIAL merge: `evaluate_gate` STAYS A SEPARATE TOOL and is NOT folded in.
+ * Rationale (brief §3⑤): evaluate is a distinct runtime *operation* — record
+ * pass/fail + notes against criteria — not CRUD on the gate *definition*. The
+ * define/list-the-gate vs act-on-the-gate line is the partial boundary.
+ *
+ * Legacy tools stay registered as forwarding aliases ({@link buildGateAliasTools});
+ * both paths reuse the legacy handler bodies. Conductor-only (gated in
+ * server-tools.ts alongside the other gate/stage tools).
+ */
+const zod_1 = require("zod");
+const descriptor_1 = require("./descriptor");
+const action_guard_1 = require("./action-guard");
+const validation_1 = require("../utils/validation");
+const quality_gate_1 = require("./quality-gate");
+const gates_1 = require("./gates");
+/**
+ * Canonical `gate` tool. Dispatches on `action` (define | list); `evaluate_gate`
+ * is intentionally excluded (separate tool).
+ */
+function buildGateTool(handle, getPlayerId) {
+    const define = (0, quality_gate_1.buildQualityGateTool)(handle, getPlayerId);
+    const list = (0, gates_1.buildGatesTool)(handle);
+    return {
+        name: 'gate',
+        description: 'Define and inspect quality gates for a task (conductor only). ' +
+            'action="define" sets/replaces a gate (task + criteria); ' +
+            'action="list" shows gates and per-criterion status (optional task/status filters). ' +
+            'To record pass/fail on criteria, use the separate `evaluate_gate` tool.',
+        params: {
+            action: zod_1.z.enum(['define', 'list']).describe('Which gate operation to perform'),
+            // define / list (filter):
+            task: zod_1.z.string().max(validation_1.GATE_TASK_MAX).optional().describe('define: the task this gate guards (required). list: optional task filter.'),
+            // define:
+            criteria: zod_1.z.array(zod_1.z.string().max(validation_1.GATE_CRITERION_TEXT_MAX)).min(1).max(validation_1.GATE_CRITERIA_MAX).optional().describe('define: the list of criteria that must pass (required)'),
+            // list:
+            status: zod_1.z.enum(['open', 'passed', 'failed']).optional().describe('list: optional status filter'),
+        },
+        handler: async (args) => {
+            const action = args.action;
+            switch (action) {
+                case 'define': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['task', 'criteria']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`gate action="define" requires "${m}".`);
+                    return define.handler(args);
+                }
+                case 'list':
+                    return list.handler(args);
+                default:
+                    return (0, descriptor_1.fail)(`Unknown gate action: ${String(action)}. Expected define | list.`);
+            }
+        },
+    };
+}
+/**
+ * Legacy forwarding aliases — `quality_gate` → define, `gates` → list. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. Explicit object literals (see §6 drift note).
+ */
+function buildGateAliasTools(handle, getPlayerId) {
+    const define = (0, quality_gate_1.buildQualityGateTool)(handle, getPlayerId);
+    const list = (0, gates_1.buildGatesTool)(handle);
+    return [
+        {
+            name: 'quality_gate',
+            description: 'DEPRECATED — use `gate` with action="define". ' + define.description,
+            params: define.params,
+            handler: define.handler,
+        },
+        {
+            name: 'gates',
+            description: 'DEPRECATED — use `gate` with action="list". ' + list.description,
+            params: list.params,
+            handler: list.handler,
+        },
+    ];
+}

package/dist/tools/schedule.d.ts

@@ -1,4 +1,22 @@
 import { Client } from '@temporalio/client';
 import { Config } from '../config';
 import { type TempoToolDescriptor } from './descriptor';
+/**
+ * Canonical `schedule` tool (#793 merge) — **reused** name, so `action` defaults
+ * to `'create'` for backward-compat (existing callers omit `action` → the legacy
+ * bare-`schedule` create behaviour). Actions: `create | cancel | list`.
+ *
+ * The rich one-of timing validation lives in the create handler (reused
+ * verbatim); `cancel` reuses `unschedule`, `list` reuses `schedules`. The legacy
+ * `unschedule` / `schedules` names stay registered as forwarding aliases
+ * ({@link buildScheduleAliasTools}); there is no alias for `create` — the bare
+ * `schedule` IS create.
+ */
 export declare function buildScheduleTool(client: Client, config: Config, getPlayerId: () => string): TempoToolDescriptor;
+/**
+ * Legacy forwarding aliases — `unschedule` → cancel, `schedules` → list. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. No alias for `create` — the bare `schedule` IS create. Explicit object
+ * literals (see #793 brief §6 drift note).
+ */
+export declare function buildScheduleAliasTools(client: Client, config: Config): TempoToolDescriptor[];

package/dist/tools/schedule.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildScheduleTool = buildScheduleTool;
+exports.buildScheduleAliasTools = buildScheduleAliasTools;
 const zod_1 = require("zod");
 const croner_1 = require("croner");
 const client_1 = require("@temporalio/client");
@@ -8,9 +9,18 @@ const config_1 = require("../config");
 const duration_1 = require("../utils/duration");
 const resolve_1 = require("./resolve");
 const descriptor_1 = require("./descriptor");
+const action_guard_1 = require("./action-guard");
+const unschedule_1 = require("./unschedule");
+const schedules_1 = require("./schedules");
 const validation_1 = require("../utils/validation");
 const log = (...args) => console.error('[agent-tempo:schedule]', ...args);
-function buildScheduleTool(client, config, getPlayerId) {
+/**
+ * Internal create-only descriptor (the legacy bare-`schedule` behaviour). Its
+ * `.handler` is reused verbatim by the canonical {@link buildScheduleTool}
+ * dispatch under `action="create"`. Not exported — the canonical tool is the
+ * public surface.
+ */
+function buildScheduleCreateTool(client, config, getPlayerId) {
     return {
         name: 'schedule',
         description: 'Schedule a message to be sent to a player at a specific time, after a delay, on a recurring interval, or via cron expression.',
@@ -155,3 +165,85 @@ function buildScheduleTool(client, config, getPlayerId) {
         },
     };
 }
+/**
+ * Canonical `schedule` tool (#793 merge) — **reused** name, so `action` defaults
+ * to `'create'` for backward-compat (existing callers omit `action` → the legacy
+ * bare-`schedule` create behaviour). Actions: `create | cancel | list`.
+ *
+ * The rich one-of timing validation lives in the create handler (reused
+ * verbatim); `cancel` reuses `unschedule`, `list` reuses `schedules`. The legacy
+ * `unschedule` / `schedules` names stay registered as forwarding aliases
+ * ({@link buildScheduleAliasTools}); there is no alias for `create` — the bare
+ * `schedule` IS create.
+ */
+function buildScheduleTool(client, config, getPlayerId) {
+    const create = buildScheduleCreateTool(client, config, getPlayerId);
+    const cancel = (0, unschedule_1.buildUnscheduleTool)(client, config);
+    const list = (0, schedules_1.buildSchedulesTool)(client, config);
+    return {
+        name: 'schedule',
+        description: 'Schedule messages to players (one-shot, delay, recurring, or cron). ' +
+            'action="create" (default) schedules a message (name+message+target + one timing of at/delay/every/cron); ' +
+            'action="cancel" removes a named schedule; ' +
+            'action="list" shows all active schedules.',
+        params: {
+            action: zod_1.z.enum(['create', 'cancel', 'list']).optional().describe('Which schedule operation to perform (defaults to "create" when omitted)'),
+            // create:
+            name: zod_1.z.string().max(validation_1.SCHEDULE_NAME_MAX).optional().describe('create/cancel: unique name for this schedule'),
+            message: zod_1.z.string().max(validation_1.SCHEDULE_MESSAGE_MAX).optional().describe('create: the message to deliver'),
+            target: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('create: player to deliver to ("self" = this session)'),
+            at: zod_1.z.string().optional().describe('create: ISO datetime for one-shot delivery'),
+            delay: zod_1.z.string().optional().describe('create: duration until first delivery (e.g. "10m", "2h", "1d")'),
+            every: zod_1.z.string().optional().describe('create: recurring interval (e.g. "5m", "1h")'),
+            cron: zod_1.z.string().max(validation_1.CRON_EXPRESSION_MAX).optional().describe('create: cron expression. Mutually exclusive with at/delay/every.'),
+            timezone: zod_1.z.string().optional().describe('create: IANA timezone for cron evaluation (default UTC). Only with cron.'),
+            until: zod_1.z.string().optional().describe('create: ISO datetime — stop recurring after this time'),
+            count: zod_1.z.number().optional().describe('create: max number of deliveries for recurring schedules'),
+        },
+        handler: async (args) => {
+            const action = args.action ?? 'create';
+            switch (action) {
+                case 'create': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['name', 'message', 'target']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`schedule action="create" requires "${m}".`);
+                    return create.handler(args);
+                }
+                case 'cancel': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['name']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`schedule action="cancel" requires "${m}".`);
+                    return cancel.handler(args);
+                }
+                case 'list':
+                    return list.handler(args);
+                default:
+                    return (0, descriptor_1.fail)(`Unknown schedule action: ${String(action)}. Expected create | cancel | list.`);
+            }
+        },
+    };
+}
+/**
+ * Legacy forwarding aliases — `unschedule` → cancel, `schedules` → list. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. No alias for `create` — the bare `schedule` IS create. Explicit object
+ * literals (see #793 brief §6 drift note).
+ */
+function buildScheduleAliasTools(client, config) {
+    const cancel = (0, unschedule_1.buildUnscheduleTool)(client, config);
+    const list = (0, schedules_1.buildSchedulesTool)(client, config);
+    return [
+        {
+            name: 'unschedule',
+            description: 'DEPRECATED — use `schedule` with action="cancel". ' + cancel.description,
+            params: cancel.params,
+            handler: cancel.handler,
+        },
+        {
+            name: 'schedules',
+            description: 'DEPRECATED — use `schedule` with action="list". ' + list.description,
+            params: list.params,
+            handler: list.handler,
+        },
+    ];
+}

package/dist/tools/stage.d.ts

@@ -1,3 +1,20 @@
 import { WorkflowHandle } from '@temporalio/client';
 import { type TempoToolDescriptor } from './descriptor';
+/**
+ * Canonical `stage` tool (#793 merge) — **reused** name, so `action` defaults to
+ * `'create'` for backward-compat. Actions: `create | list | cancel` (all CRUD
+ * peers on the same StageEntry — see #793 brief §4). Conductor-only (gated in
+ * server-tools.ts).
+ *
+ * The legacy `stages` / `cancel_stage` names stay registered as forwarding
+ * aliases ({@link buildStageAliasTools}); there is no alias for `create` — the
+ * bare `stage` IS create.
+ */
 export declare function buildStageTool(handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;
+/**
+ * Legacy forwarding aliases — `stages` → list, `cancel_stage` → cancel. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. No alias for `create` — the bare `stage` IS create. Explicit object
+ * literals (see #793 brief §6 drift note).
+ */
+export declare function buildStageAliasTools(handle: WorkflowHandle): TempoToolDescriptor[];

package/dist/tools/stage.js

@@ -1,10 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildStageTool = buildStageTool;
+exports.buildStageAliasTools = buildStageAliasTools;
 const zod_1 = require("zod");
 const descriptor_1 = require("./descriptor");
+const action_guard_1 = require("./action-guard");
+const stages_1 = require("./stages");
+const cancel_stage_1 = require("./cancel-stage");
 const validation_1 = require("../utils/validation");
-function buildStageTool(handle, getPlayerId) {
+/**
+ * Internal create-only descriptor (the legacy bare-`stage` behaviour). Its
+ * `.handler` is reused verbatim by the canonical {@link buildStageTool} under
+ * `action="create"`. Not exported — the canonical tool is the public surface.
+ */
+function buildStageCreateTool(handle, getPlayerId) {
     return {
         name: 'stage',
         description: 'Create a pipeline stage tracking N players. When all players report, a completion message is auto-injected. Conductor only.',
@@ -31,3 +40,78 @@ function buildStageTool(handle, getPlayerId) {
         },
     };
 }
+/**
+ * Canonical `stage` tool (#793 merge) — **reused** name, so `action` defaults to
+ * `'create'` for backward-compat. Actions: `create | list | cancel` (all CRUD
+ * peers on the same StageEntry — see #793 brief §4). Conductor-only (gated in
+ * server-tools.ts).
+ *
+ * The legacy `stages` / `cancel_stage` names stay registered as forwarding
+ * aliases ({@link buildStageAliasTools}); there is no alias for `create` — the
+ * bare `stage` IS create.
+ */
+function buildStageTool(handle, getPlayerId) {
+    const create = buildStageCreateTool(handle, getPlayerId);
+    const list = (0, stages_1.buildStagesTool)(handle);
+    const cancel = (0, cancel_stage_1.buildCancelStageTool)(handle);
+    return {
+        name: 'stage',
+        description: 'Track a fan-out/fan-in pipeline stage across N players (conductor only). ' +
+            'action="create" (default) opens a stage (name + players[, failurePolicy]); ' +
+            'action="list" shows all stages and per-player report status; ' +
+            'action="cancel" cancels a named stage.',
+        params: {
+            action: zod_1.z.enum(['create', 'list', 'cancel']).optional().describe('Which stage operation to perform (defaults to "create" when omitted)'),
+            // create / cancel:
+            name: zod_1.z.string().max(validation_1.STAGE_NAME_MAX).optional().describe('create/cancel: the stage name'),
+            // create:
+            players: zod_1.z.array(zod_1.z.string().regex(validation_1.PLAYER_NAME_REGEX)).min(1).max(validation_1.STAGE_PLAYERS_MAX).optional().describe('create: player names to track in this stage'),
+            failurePolicy: zod_1.z.enum(['halt', 'continue']).optional().describe('create: "halt" (default) fails the stage on a blocker; "continue" waits for all players.'),
+        },
+        handler: async (args) => {
+            const action = args.action ?? 'create';
+            switch (action) {
+                case 'create': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['name', 'players']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`stage action="create" requires "${m}".`);
+                    return create.handler(args);
+                }
+                case 'list':
+                    return list.handler(args);
+                case 'cancel': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['name']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`stage action="cancel" requires "${m}".`);
+                    return cancel.handler(args);
+                }
+                default:
+                    return (0, descriptor_1.fail)(`Unknown stage action: ${String(action)}. Expected create | list | cancel.`);
+            }
+        },
+    };
+}
+/**
+ * Legacy forwarding aliases — `stages` → list, `cancel_stage` → cancel. Each
+ * keeps its exact original schema + handler; description gains a deprecation
+ * note. No alias for `create` — the bare `stage` IS create. Explicit object
+ * literals (see #793 brief §6 drift note).
+ */
+function buildStageAliasTools(handle) {
+    const list = (0, stages_1.buildStagesTool)(handle);
+    const cancel = (0, cancel_stage_1.buildCancelStageTool)(handle);
+    return [
+        {
+            name: 'stages',
+            description: 'DEPRECATED — use `stage` with action="list". ' + list.description,
+            params: list.params,
+            handler: list.handler,
+        },
+        {
+            name: 'cancel_stage',
+            description: 'DEPRECATED — use `stage` with action="cancel". ' + cancel.description,
+            params: cancel.params,
+            handler: cancel.handler,
+        },
+    ];
+}

package/dist/tools/state.d.ts

@@ -0,0 +1,14 @@
+import { Client, WorkflowHandle } from '@temporalio/client';
+import { Config } from '../config';
+import { type TempoToolDescriptor } from './descriptor';
+/**
+ * Canonical `state` tool. Dispatches on `action`; per-action required fields are
+ * runtime-guarded.
+ */
+export declare function buildStateTool(client: Client, config: Config, handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor;
+/**
+ * Legacy forwarding aliases — `save_state` / `fetch_state` / `clear_state`.
+ * Each keeps its exact original schema + handler; description gains a
+ * deprecation note. Explicit object literals (see §6 drift note).
+ */
+export declare function buildStateAliasTools(client: Client, config: Config, handle: WorkflowHandle, getPlayerId: () => string): TempoToolDescriptor[];

package/dist/tools/state.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStateTool = buildStateTool;
+exports.buildStateAliasTools = buildStateAliasTools;
+/**
+ * `state` — canonical multi-action player saveable-state tool (#793 merge).
+ *
+ * Merges the three legacy tools (`save_state` / `fetch_state` / `clear_state`)
+ * into ONE canonical tool with a flat `{ action, ...optional fields }` shape
+ * (see docs/design/793-tool-family-merge-brief.md §2). The canonical name is
+ * **net-new**, so `action` is REQUIRED.
+ *
+ * Legacy tools stay registered as forwarding aliases
+ * ({@link buildStateAliasTools}); both paths reuse the legacy handler bodies, so
+ * behaviour (owner-only write, self-or-peer read, idempotent clear) is identical.
+ */
+const zod_1 = require("zod");
+const descriptor_1 = require("./descriptor");
+const action_guard_1 = require("./action-guard");
+const validation_1 = require("../utils/validation");
+const save_state_1 = require("./save-state");
+const fetch_state_1 = require("./fetch-state");
+const clear_state_1 = require("./clear-state");
+/**
+ * Canonical `state` tool. Dispatches on `action`; per-action required fields are
+ * runtime-guarded.
+ */
+function buildStateTool(client, config, handle, getPlayerId) {
+    const save = (0, save_state_1.buildSaveStateTool)(handle, getPlayerId);
+    const fetch = (0, fetch_state_1.buildFetchStateTool)(client, config, handle, getPlayerId);
+    const clear = (0, clear_state_1.buildClearStateTool)(handle);
+    return {
+        name: 'state',
+        description: 'Curated per-player state slots that survive restart (you choose what context persists). ' +
+            'action="save" writes your own slot (content[, key]); ' +
+            'action="fetch" reads a slot for yourself or a peer (key/playerId, defaults to your own "main"); ' +
+            'action="clear" empties one of your slots. save/clear are owner-only.',
+        params: {
+            action: zod_1.z.enum(['save', 'fetch', 'clear']).describe('Which state operation to perform'),
+            // save:
+            content: zod_1.z.string().min(1).max(validation_1.PLAYER_STATE_CONTENT_MAX).optional().describe('save: the state body to store (≤32 KiB)'),
+            // save / fetch / clear:
+            key: zod_1.z.string().regex(validation_1.PLAYER_STATE_KEY_REGEX).max(validation_1.PLAYER_STATE_KEY_MAX).optional().describe('Slot key (defaults to "main")'),
+            // fetch:
+            playerId: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('fetch: peer to read from (defaults to yourself)'),
+        },
+        handler: async (args) => {
+            const action = args.action;
+            switch (action) {
+                case 'save': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['content']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`state action="save" requires "${m}".`);
+                    return save.handler(args);
+                }
+                case 'fetch':
+                    return fetch.handler(args);
+                case 'clear':
+                    return clear.handler(args);
+                default:
+                    return (0, descriptor_1.fail)(`Unknown state action: ${String(action)}. Expected save | fetch | clear.`);
+            }
+        },
+    };
+}
+/**
+ * Legacy forwarding aliases — `save_state` / `fetch_state` / `clear_state`.
+ * Each keeps its exact original schema + handler; description gains a
+ * deprecation note. Explicit object literals (see §6 drift note).
+ */
+function buildStateAliasTools(client, config, handle, getPlayerId) {
+    const save = (0, save_state_1.buildSaveStateTool)(handle, getPlayerId);
+    const fetch = (0, fetch_state_1.buildFetchStateTool)(client, config, handle, getPlayerId);
+    const clear = (0, clear_state_1.buildClearStateTool)(handle);
+    return [
+        {
+            name: 'save_state',
+            description: 'DEPRECATED — use `state` with action="save". ' + save.description,
+            params: save.params,
+            handler: save.handler,
+        },
+        {
+            name: 'fetch_state',
+            description: 'DEPRECATED — use `state` with action="fetch". ' + fetch.description,
+            params: fetch.params,
+            handler: fetch.handler,
+        },
+        {
+            name: 'clear_state',
+            description: 'DEPRECATED — use `state` with action="clear". ' + clear.description,
+            params: clear.params,
+            handler: clear.handler,
+        },
+    ];
+}

package/dist/types.d.ts

@@ -57,6 +57,19 @@ export interface AdapterDescriptor {
     blocksOnLLMTurn: boolean;
     /** Heartbeat cadence in milliseconds. Interactive: 60_000; SDK: 30_000. */
     heartbeatMs: number;
+    /**
+     * #704 — True iff the adapter can park pre-attach on a blocking launch-time
+     * dialog (the interactive `claude-code` dev-channels acknowledgment, which
+     * requires a human click). When true, the booting attach-timeout watchdog is
+     * DISARMED for this adapter: a recruit waiting on a human is not a hang the
+     * watchdog should false-kill (an operator-away false-kill is worse than the
+     * hang — see docs/design/704-is-demo-companion-brief.md). Headless adapters
+     * (no dialog) omit this / set false → the watchdog arms. The property is the
+     * contract, not the adapter name: a future interactive adapter inherits the
+     * disarm by setting it. Interactive arming returns once #890 dissolves the
+     * dialog. Optional; absent ⇒ falsy ⇒ armed.
+     */
+    canBlockOnDialog?: boolean;
 }
 /**
  * Reason an attachment detached or was detached. Used for audit and UX messaging.
@@ -85,7 +98,7 @@ export interface AdapterDescriptor {
  * When not opted in, the base class fires the reason as terminal just like any
  * other non-recoverable lease loss.
  */
-export type DetachReason = 'user-stop' | 'restart' | 'heartbeat-timeout' | 'superseded' | 'agent-exited' | 'spawn-failed' | 'destroy' | 'force' | 'reconnect-exhausted' | 'continued-as-new';
+export type DetachReason = 'user-stop' | 'restart' | 'heartbeat-timeout' | 'superseded' | 'agent-exited' | 'spawn-failed' | 'destroy' | 'force' | 'reconnect-exhausted' | 'continued-as-new' | 'boot-timeout';
 /**
  * Workflow-emitted directive to the attached adapter. Delivered via {@link AttachmentInfo}
  * polling (no reverse-RPC surface in Temporal).
@@ -178,6 +191,23 @@ export interface SessionMetadata {
     playerTypeDescription?: string;
     /** Player ID of who recruited this player. */
     recruitedBy?: string;
+    /**
+     * #704 — resolved at spawn time from the adapter descriptor's
+     * {@link AdapterDescriptor.canBlockOnDialog}. Threaded onto durable metadata
+     * (and carried across continueAsNew) so the session workflow can decide
+     * whether to ARM the booting attach-timeout watchdog WITHOUT importing the
+     * client-side adapter registry (workflows are sandboxed). True ⇒ interactive
+     * adapter that can park on a launch dialog ⇒ watchdog DISARMED. Absent/false
+     * ⇒ headless ⇒ ARMED.
+     */
+    canBlockOnDialog?: boolean;
+    /**
+     * #704 — optional override (ms) for the booting attach-timeout deadline,
+     * resolved from `AGENT_TEMPO_BOOTING_DEADLINE_MS` at spawn time. Workflows
+     * can't read process.env, so the override rides durable metadata. Absent ⇒
+     * the workflow's 180s default applies.
+     */
+    bootingDeadlineMs?: number;
     /** Worktree path if this session was spawned in an isolated worktree. */
     worktreePath?: string;
     /**
@@ -874,6 +904,14 @@ export interface MaestroPlayerInfo {
      * surfaces that want to show "last active 12s ago" per player.
      */
     lastActivityAt?: string;
+    /**
+     * #886 slice 2 — `true` when this row came from a DEGRADED observation scan
+     * (the workflow was listed but its metadata extraction failed, so non-identity
+     * fields are best-effort blanks). Surfaces to the dashboard/board so the
+     * player renders as "uncertain" rather than vanishing — preventing roster
+     * flapping (contra #777). Absent / `false` on healthy rows.
+     */
+    degraded?: boolean;
 }
 /** A message relayed through the global Maestro for dashboard visibility. */
 export interface MaestroRelayMessage {

package/dist/utils/orphan-guard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * #704 Item 1b — late-orphan self-tombstone discriminator (pure).
+ *
+ * A recruited process can launch LONG after its recruit was cancelled (a slow /
+ * wedged cold start). When it finally boots and reaches the workflow-start site
+ * (`server.ts`), this predicate decides whether it is an ORPHAN of a cancelled
+ * recruit (→ self-exit, do not re-register) or a legitimate (re-)start (→ proceed).
+ *
+ * The discriminator is the **running-run × close-reason PAIR**:
+ *   - If a RUNNING run exists for the derived id, this process is NOT an orphan —
+ *     every managed re-creation (recruit / restart / migrate / up) pre-creates a
+ *     RUNNING run before its process boots, so a legit reuse is seen as RUNNING and
+ *     simply attaches via `USE_EXISTING`. Never self-exit.
+ *   - Otherwise, the most-recent run is CLOSED. Self-exit ONLY when it closed with a
+ *     typed tombstone reason (`destroyed` | `boot-timeout`) within a generous TTL.
+ *     The TTL bounds a stale tombstone so a much-later legit manual reuse of the
+ *     same name isn't blocked forever (the observed orphan spawn delay was ~100min).
+ *
+ * Pure + dependency-free so it unit-tests without a live Temporal env; `server.ts`
+ * supplies the `describe()`-derived inputs.
+ */
+export interface OrphanTombstoneInput {
+    /** `describe().status.name` — e.g. `'RUNNING'`, `'COMPLETED'`, `'TERMINATED'`. */
+    statusName: string;
+    /** `describe().memo?.[MEMO_KEYS.closeReason]` — the typed close reason, if any. */
+    closeReason: unknown;
+    /** `describe().closeTime?.getTime() ?? 0` — ms epoch of run close, `0` if open/unknown. */
+    closeTimeMs: number;
+}
+/**
+ * Returns true iff the booting process should self-exit as a late orphan.
+ *
+ * @param input      the `describe()`-derived run state for the derived workflow id
+ * @param ttlMs      how long a tombstone is honored (ms); `> 0`
+ * @param nowMs      current wall-clock ms (`Date.now()`)
+ */
+export declare function shouldSelfExitAsOrphan(input: OrphanTombstoneInput, ttlMs: number, nowMs: number): boolean;

package/dist/utils/orphan-guard.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldSelfExitAsOrphan = shouldSelfExitAsOrphan;
+/** Close reasons that tombstone a derived id against orphan re-registration. */
+const TOMBSTONE_REASONS = new Set(['destroyed', 'boot-timeout']);
+/**
+ * Returns true iff the booting process should self-exit as a late orphan.
+ *
+ * @param input      the `describe()`-derived run state for the derived workflow id
+ * @param ttlMs      how long a tombstone is honored (ms); `> 0`
+ * @param nowMs      current wall-clock ms (`Date.now()`)
+ */
+function shouldSelfExitAsOrphan(input, ttlMs, nowMs) {
+    // A running run means a legit (re-)creation already exists — attach, don't exit.
+    if (input.statusName === 'RUNNING')
+        return false;
+    // Only a typed tombstone close-reason qualifies.
+    if (typeof input.closeReason !== 'string' || !TOMBSTONE_REASONS.has(input.closeReason)) {
+        return false;
+    }
+    // Bound staleness: a tombstone older than the TTL is released so a legit
+    // much-later reuse of the same derived id isn't blocked.
+    if (!(input.closeTimeMs > 0))
+        return false;
+    return nowMs - input.closeTimeMs <= ttlMs;
+}

package/dist/utils/search-attributes.d.ts

@@ -61,6 +61,7 @@ export declare const MEMO_KEYS: {
     readonly agentType: "AgentTempoAgentType";
     readonly gitBranch: "AgentTempoGitBranch";
     readonly protocol: "AgentTempoProtocol";
+    readonly closeReason: "AgentTempoCloseReason";
 };
 /**
  * Escape a value for use in Temporal visibility query strings — strips

package/dist/utils/search-attributes.js

@@ -43,6 +43,15 @@ exports.MEMO_KEYS = {
     // Memo, not a search attribute: avoids a 6th Keyword (the #747 SA-diet keeps
     // us at 5/10) and needs no operator registration. See constants.PROTOCOL_VERSION.
     protocol: 'AgentTempoProtocol',
+    // #704 — typed terminal close-reason stamped on a workflow's memo when it
+    // COMPLETEs via `destroy` (`'destroyed'`) or the booting attach-timeout
+    // watchdog (`'boot-timeout'`). Survives completion and is readable via
+    // `describe().memo`. The bootstrap orphan-guard (`server.ts`) reads it to
+    // self-tombstone a late-launching orphan process whose run was cancelled,
+    // discriminated by the running-run × close-reason PAIR. A string memo (not a
+    // search attribute): avoids a 6th Keyword (the #747 SA-diet keeps us at 5/10)
+    // and needs no operator registration.
+    closeReason: 'AgentTempoCloseReason',
 };
 /**
  * Escape a value for use in Temporal visibility query strings — strips