agent-tempo 1.7.0 → 2.0.0-beta.2

package/dist/server-tools.js

@@ -11,9 +11,8 @@ const listen_1 = require("./tools/listen");
 const recruit_1 = require("./tools/recruit");
 const report_1 = require("./tools/report");
 const set_name_1 = require("./tools/set-name");
+// #793 — canonical `schedule` (action create|cancel|list) + unschedule/schedules aliases.
 const schedule_1 = require("./tools/schedule");
-const unschedule_1 = require("./tools/unschedule");
-const schedules_1 = require("./tools/schedules");
 const save_lineup_1 = require("./tools/save-lineup");
 const load_lineup_1 = require("./tools/load-lineup");
 const agent_types_1 = require("./tools/agent-types");
@@ -25,13 +24,13 @@ const pause_1 = require("./tools/pause");
 const play_1 = require("./tools/play");
 const shutdown_1 = require("./tools/shutdown");
 const restore_1 = require("./tools/restore");
-const quality_gate_1 = require("./tools/quality-gate");
+// #793 — canonical `gate` (action define|list) + quality_gate/gates aliases.
+// `evaluate_gate` stays a SEPARATE tool (partial merge — runtime op, not CRUD).
+const gate_1 = require("./tools/gate");
 const evaluate_gate_1 = require("./tools/evaluate-gate");
-const gates_1 = require("./tools/gates");
 const worktree_1 = require("./tools/worktree");
+// #793 — canonical `stage` (action create|list|cancel) + stages/cancel_stage aliases.
 const stage_1 = require("./tools/stage");
-const stages_1 = require("./tools/stages");
-const cancel_stage_1 = require("./tools/cancel-stage");
 const restart_1 = require("./tools/restart");
 const destroy_1 = require("./tools/destroy");
 const reset_1 = require("./tools/reset");
@@ -39,15 +38,12 @@ const migrate_1 = require("./tools/migrate");
 const attachment_info_1 = require("./tools/attachment-info");
 const hosts_1 = require("./tools/hosts");
 const set_ensemble_description_1 = require("./tools/set-ensemble-description");
-// #334 PR-1 — player saveable state (save_state / fetch_state / clear_state).
-const save_state_1 = require("./tools/save-state");
-const fetch_state_1 = require("./tools/fetch-state");
-const clear_state_1 = require("./tools/clear-state");
-// #318 — ensemble-shared coat-check (put / get / list / evict).
-const coat_check_put_1 = require("./tools/coat-check-put");
-const coat_check_get_1 = require("./tools/coat-check-get");
-const coat_check_list_1 = require("./tools/coat-check-list");
-const coat_check_evict_1 = require("./tools/coat-check-evict");
+// #334 PR-1 / #793 — canonical `state` (action save|fetch|clear) + save_state/
+// fetch_state/clear_state aliases.
+const state_1 = require("./tools/state");
+// #318 / #793 — canonical `coat_check` (action put|get|list|evict) +
+// coat_check_put/get/list/evict aliases.
+const coat_check_1 = require("./tools/coat-check");
 const respond_1 = require("./tools/respond");
 /**
  * Register every tempo MCP tool onto `server`. Single source of truth — the
@@ -69,9 +65,10 @@ function buildAllTempoTools(opts) {
         (0, listen_1.buildListenTool)(handle),
         (0, recruit_1.buildRecruitTool)(client, config, getPlayerId, handle, ownAgentType, defaultAgentSource),
         (0, report_1.buildReportTool)(handle),
+        // #793 — canonical `schedule` (action defaults to "create") + legacy
+        // unschedule/schedules forwarding aliases.
         (0, schedule_1.buildScheduleTool)(client, config, getPlayerId),
-        (0, unschedule_1.buildUnscheduleTool)(client, config),
-        (0, schedules_1.buildSchedulesTool)(client, config),
+        ...(0, schedule_1.buildScheduleAliasTools)(client, config),
         (0, save_lineup_1.buildSaveLineupTool)(client, config, getPlayerId, isConductor),
         (0, load_lineup_1.buildLoadLineupTool)(client, config, getPlayerId, ownAgentType, handle, setPlayerId, isConductor),
         (0, agent_types_1.buildAgentTypesTool)(),
@@ -90,23 +87,27 @@ function buildAllTempoTools(opts) {
         (0, attachment_info_1.buildAttachmentInfoTool)(client, config),
         (0, hosts_1.buildHostsTool)(client, config),
         (0, set_ensemble_description_1.buildSetEnsembleDescriptionTool)(client, config),
-        // #334 PR-1 — owner-write / peer-read player saveable state.
-        (0, save_state_1.buildSaveStateTool)(handle, getPlayerId),
-        (0, fetch_state_1.buildFetchStateTool)(client, config, handle, getPlayerId),
-        (0, clear_state_1.buildClearStateTool)(handle),
-        // #318 — ensemble-shared coat-check (put/get/list/evict). Any player can put;
-        // any player can get/list; owner-or-conductor can evict. Audit identity is
-        // set at the tool layer via getPlayerId() — no playerId arg on any schema.
-        (0, coat_check_put_1.buildCoatCheckPutTool)(client, config, getPlayerId),
-        (0, coat_check_get_1.buildCoatCheckGetTool)(client, config, getPlayerId),
-        (0, coat_check_list_1.buildCoatCheckListTool)(client, config),
-        (0, coat_check_evict_1.buildCoatCheckEvictTool)(client, config, getPlayerId),
+        // #334 PR-1 / #793 — canonical `state` (owner-write / peer-read) + legacy
+        // save_state/fetch_state/clear_state forwarding aliases.
+        (0, state_1.buildStateTool)(client, config, handle, getPlayerId),
+        ...(0, state_1.buildStateAliasTools)(client, config, handle, getPlayerId),
+        // #318 / #793 — canonical `coat_check` (put/get/list/evict) + legacy
+        // coat_check_* forwarding aliases. Any player can put/get/list;
+        // owner-or-conductor can evict. Audit identity is set at the tool layer via
+        // getPlayerId() — no playerId arg on any schema.
+        (0, coat_check_1.buildCoatCheckTool)(client, config, getPlayerId),
+        ...(0, coat_check_1.buildCoatCheckAliasTools)(client, config, getPlayerId),
         // #700 P2 — answer a planner's correlated `[Q <id>]` question (writes the
         // maestro Q&A mailbox directly; from = getPlayerId(), no spoofable arg).
         (0, respond_1.buildRespondTool)(client, config, getPlayerId),
     ];
     if (isConductor) {
-        tools.push((0, quality_gate_1.buildQualityGateTool)(handle, getPlayerId), (0, evaluate_gate_1.buildEvaluateGateTool)(handle, getPlayerId), (0, gates_1.buildGatesTool)(handle), (0, worktree_1.buildWorktreeTool)(client, config, handle, getPlayerId), (0, stage_1.buildStageTool)(handle, getPlayerId), (0, stages_1.buildStagesTool)(handle), (0, cancel_stage_1.buildCancelStageTool)(handle));
+        tools.push(
+        // #793 — canonical `gate` (define|list) + quality_gate/gates aliases.
+        // `evaluate_gate` stays a separate tool (partial-merge boundary).
+        (0, gate_1.buildGateTool)(handle, getPlayerId), (0, evaluate_gate_1.buildEvaluateGateTool)(handle, getPlayerId), ...(0, gate_1.buildGateAliasTools)(handle, getPlayerId), (0, worktree_1.buildWorktreeTool)(client, config, handle, getPlayerId), 
+        // #793 — canonical `stage` (create|list|cancel) + stages/cancel_stage aliases.
+        (0, stage_1.buildStageTool)(handle, getPlayerId), ...(0, stage_1.buildStageAliasTools)(handle));
     }
     return tools;
 }

package/dist/server.js

@@ -59,6 +59,7 @@ const parent_death_watchdog_1 = require("./utils/parent-death-watchdog");
 const grpc_shutdown_guard_1 = require("./utils/grpc-shutdown-guard");
 const action_counters_1 = require("./utils/action-counters");
 const search_attributes_1 = require("./utils/search-attributes");
+const orphan_guard_1 = require("./utils/orphan-guard");
 const log = (...args) => console.error('[agent-tempo]', ...args);
 async function main() {
     (0, parent_death_watchdog_1.installParentDeathWatchdog)();
@@ -157,6 +158,12 @@ async function main() {
             isConductor,
             agentType: isBridgeMode ? 'copilot' : 'claude',
             adapterId,
+            // #704 — thread the adapter descriptor's dialog-blocking property onto
+            // durable metadata so the session workflow can ARM/DISARM the booting
+            // watchdog without importing the client-side registry. This self-bootstrap
+            // path is interactive `claude-code` (or the Copilot bridge), so it resolves
+            // to disarmed; recruited headless sessions arm via `startRecruitedSession`.
+            canBlockOnDialog: adapterDescriptor?.canBlockOnDialog === true,
         },
         // Issue #450 — self-bootstrap path has no resolved player type, so
         // this falls through to `'Conductor session'` for conductors and
@@ -170,6 +177,41 @@ async function main() {
             taskQueue: config.taskQueue,
         },
     };
+    // #704 Item 1b — late-orphan self-tombstone guard. A recruited process can
+    // launch LONG after its recruit was cancelled (slow / wedged cold start). If
+    // this derived id's latest run is CLOSED with a destroy / boot-timeout tombstone
+    // MEMO and NO newer RUNNING run exists, this process is that orphan — exit before
+    // `start(USE_EXISTING)` bootstraps a brand-new run that collides with whoever took
+    // over the worktree. The running-run × close-reason PAIR is the discriminator:
+    // every managed re-creation (recruit / restart / migrate / up) pre-creates a
+    // RUNNING run, so a legit reuse is seen as RUNNING and simply attaches — it never
+    // reaches this branch. Gated `!isConductor` (conductors are operator-driven via
+    // `up`, never a recruited orphan). A generous wall-clock TTL bounds a stale
+    // tombstone so a much-later legit manual reuse of the same name isn't blocked
+    // forever (observed orphan delay ~100min; default 6h, env-overridable).
+    if (!isConductor) {
+        const ttlMsRaw = Number(process.env[config_1.ENV.ORPHAN_TOMBSTONE_TTL_MS]);
+        const orphanTombstoneTtlMs = Number.isFinite(ttlMsRaw) && ttlMsRaw > 0 ? ttlMsRaw : 6 * 60 * 60 * 1000;
+        try {
+            const desc = await client.workflow.getHandle(workflowId).describe();
+            const closeReason = desc.memo?.[search_attributes_1.MEMO_KEYS.closeReason];
+            const orphan = (0, orphan_guard_1.shouldSelfExitAsOrphan)({
+                statusName: desc.status.name,
+                closeReason,
+                closeTimeMs: desc.closeTime ? desc.closeTime.getTime() : 0,
+            }, orphanTombstoneTtlMs, Date.now());
+            if (orphan) {
+                log(`recruit was cancelled (close-reason: ${closeReason}) — exiting to avoid ` +
+                    `re-registering an orphan session for ${workflowId}`);
+                process.exit(0);
+            }
+        }
+        catch {
+            // No prior run (NotFound) → first-ever start for this id → proceed. Any other
+            // describe() failure is non-fatal: the guard is a best-effort backstop, not a
+            // correctness gate — fall through and let the start proceed.
+        }
+    }
     const startedHandle = await client.workflow.start('agentSessionWorkflow', {
         workflowId,
         taskQueue: config.taskQueue,

package/dist/tools/action-guard.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Per-action runtime field guard for the canonical multi-action tools (#793).
+ *
+ * The tool-family merge (#793) collapses each family into one canonical tool
+ * with a flat `{ action, ...per-action optional fields }` param shape. Because
+ * the union makes every per-action field optional at the zod boundary (we do
+ * NOT use `z.discriminatedUnion` — see docs/design/793-tool-family-merge-brief.md
+ * §2), cross-field "this action requires that field" rules are enforced at
+ * RUNTIME inside the handler, before dispatch.
+ *
+ * {@link firstMissing} returns the first required field that is absent so the
+ * handler can return a friendly, actionable `fail(...)` message naming the
+ * exact tool, action, and field — instead of a cryptic downstream error.
+ */
+/**
+ * Return the first field name in `fields` whose value in `args` is "missing"
+ * (`undefined`, `null`, or an empty string), or `null` when all are present.
+ *
+ * Empty-string counts as missing so a canonical handler rejects e.g.
+ * `coat_check{action:'get', ticket:''}` with the same friendly error a wholly
+ * omitted ticket would produce.
+ */
+export declare function firstMissing(args: Record<string, unknown>, fields: readonly string[]): string | null;

package/dist/tools/action-guard.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Per-action runtime field guard for the canonical multi-action tools (#793).
+ *
+ * The tool-family merge (#793) collapses each family into one canonical tool
+ * with a flat `{ action, ...per-action optional fields }` param shape. Because
+ * the union makes every per-action field optional at the zod boundary (we do
+ * NOT use `z.discriminatedUnion` — see docs/design/793-tool-family-merge-brief.md
+ * §2), cross-field "this action requires that field" rules are enforced at
+ * RUNTIME inside the handler, before dispatch.
+ *
+ * {@link firstMissing} returns the first required field that is absent so the
+ * handler can return a friendly, actionable `fail(...)` message naming the
+ * exact tool, action, and field — instead of a cryptic downstream error.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstMissing = firstMissing;
+/**
+ * Return the first field name in `fields` whose value in `args` is "missing"
+ * (`undefined`, `null`, or an empty string), or `null` when all are present.
+ *
+ * Empty-string counts as missing so a canonical handler rejects e.g.
+ * `coat_check{action:'get', ticket:''}` with the same friendly error a wholly
+ * omitted ticket would produce.
+ */
+function firstMissing(args, fields) {
+    for (const field of fields) {
+        const v = args[field];
+        if (v === undefined || v === null || v === '')
+            return field;
+    }
+    return null;
+}

package/dist/tools/coat-check.d.ts

@@ -0,0 +1,20 @@
+import { Client } from '@temporalio/client';
+import { Config } from '../config';
+import { type TempoToolDescriptor } from './descriptor';
+/**
+ * Canonical `coat_check` tool. Dispatches on `action` to the same per-action
+ * logic the legacy tools used. Per-action required fields are runtime-guarded
+ * (the flat union makes them optional at the zod boundary).
+ */
+export declare function buildCoatCheckTool(client: Client, config: Config, getPlayerId: () => string): TempoToolDescriptor;
+/**
+ * Legacy forwarding aliases — `coat_check_put` / `coat_check_get` /
+ * `coat_check_list` / `coat_check_evict`. Each keeps its EXACT original param
+ * schema and handler (reused verbatim from the legacy descriptor); only the
+ * description gains a deprecation note pointing at the canonical tool.
+ *
+ * Authored as explicit object literals (not loop-generated) so the
+ * surface-drift name scrape and any future static analysis see each alias name
+ * adjacent to its description (docs/design/793-tool-family-merge-brief.md §6).
+ */
+export declare function buildCoatCheckAliasTools(client: Client, config: Config, getPlayerId: () => string): TempoToolDescriptor[];

package/dist/tools/coat-check.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCoatCheckTool = buildCoatCheckTool;
+exports.buildCoatCheckAliasTools = buildCoatCheckAliasTools;
+/**
+ * `coat_check` — canonical multi-action coat-check tool (#793 tool-family merge).
+ *
+ * Merges the four legacy per-action tools (`coat_check_put` / `coat_check_get` /
+ * `coat_check_list` / `coat_check_evict`) into ONE canonical tool with a flat
+ * `{ action, ...per-action optional fields }` param shape (NOT a discriminated
+ * union — see docs/design/793-tool-family-merge-brief.md §2). The canonical name
+ * is **net-new**, so `action` is REQUIRED (no legacy caller to keep compatible).
+ *
+ * The legacy tools stay registered as thin forwarding aliases
+ * ({@link buildCoatCheckAliasTools}) so every existing caller keeps its exact
+ * original schema and behaviour — the alias-not-remove invariant (#793). Both the
+ * canonical handler and the aliases reuse the legacy descriptors' handler bodies
+ * verbatim, so there is a single implementation per action.
+ */
+const zod_1 = require("zod");
+const descriptor_1 = require("./descriptor");
+const action_guard_1 = require("./action-guard");
+const validation_1 = require("../utils/validation");
+const coat_check_put_1 = require("./coat-check-put");
+const coat_check_get_1 = require("./coat-check-get");
+const coat_check_list_1 = require("./coat-check-list");
+const coat_check_evict_1 = require("./coat-check-evict");
+/**
+ * Canonical `coat_check` tool. Dispatches on `action` to the same per-action
+ * logic the legacy tools used. Per-action required fields are runtime-guarded
+ * (the flat union makes them optional at the zod boundary).
+ */
+function buildCoatCheckTool(client, config, getPlayerId) {
+    const put = (0, coat_check_put_1.buildCoatCheckPutTool)(client, config, getPlayerId);
+    const get = (0, coat_check_get_1.buildCoatCheckGetTool)(client, config, getPlayerId);
+    const list = (0, coat_check_list_1.buildCoatCheckListTool)(client, config);
+    const evict = (0, coat_check_evict_1.buildCoatCheckEvictTool)(client, config, getPlayerId);
+    return {
+        name: 'coat_check',
+        description: 'Ensemble-shared transient store (stash large artifacts past the cue size cap). ' +
+            'action="put" stashes content (summary+content[, contentType, ttlMs]) and returns a ticket; ' +
+            'action="get" redeems a ticket (bumps fetch audit); ' +
+            'action="list" surveys entry headers (putBy/prefix/unfetchedOnly filters); ' +
+            'action="evict" removes an entry early (owner-or-conductor).',
+        params: {
+            action: zod_1.z.enum(['put', 'get', 'list', 'evict']).describe('Which coat-check operation to perform'),
+            // put:
+            summary: zod_1.z.string().min(1).max(validation_1.COAT_CHECK_SUMMARY_MAX).optional().describe('put: short human-readable label for the entry'),
+            content: zod_1.z.string().min(1).max(validation_1.COAT_CHECK_CONTENT_MAX).optional().describe('put: the body to stash (≤32 KiB)'),
+            contentType: zod_1.z.string().max(validation_1.COAT_CHECK_CONTENT_TYPE_MAX).optional().describe('put: optional MIME/content-type hint'),
+            ttlMs: zod_1.z.number().int().min(validation_1.COAT_CHECK_TTL_MIN_MS).max(validation_1.COAT_CHECK_TTL_MAX_MS).optional().describe('put: optional time-to-live in ms (default 7d)'),
+            // get / evict:
+            ticket: zod_1.z.string().regex(validation_1.COAT_CHECK_TICKET_REGEX).max(validation_1.COAT_CHECK_TICKET_MAX).optional().describe('get/evict: the ticket id returned by put'),
+            // list:
+            putBy: zod_1.z.string().max(validation_1.PLAYER_NAME_MAX).optional().describe('list: filter to entries stashed by this player'),
+            prefix: zod_1.z.string().max(validation_1.COAT_CHECK_SUMMARY_MAX).optional().describe('list: filter to entries whose summary starts with this prefix'),
+            unfetchedOnly: zod_1.z.boolean().optional().describe('list: only entries that have never been fetched'),
+        },
+        handler: async (args) => {
+            const action = args.action;
+            switch (action) {
+                case 'put': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['summary', 'content']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`coat_check action="put" requires "${m}".`);
+                    return put.handler(args);
+                }
+                case 'get': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['ticket']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`coat_check action="get" requires "${m}".`);
+                    return get.handler(args);
+                }
+                case 'list':
+                    return list.handler(args);
+                case 'evict': {
+                    const m = (0, action_guard_1.firstMissing)(args, ['ticket']);
+                    if (m)
+                        return (0, descriptor_1.fail)(`coat_check action="evict" requires "${m}".`);
+                    return evict.handler(args);
+                }
+                default:
+                    return (0, descriptor_1.fail)(`Unknown coat_check action: ${String(action)}. Expected put | get | list | evict.`);
+            }
+        },
+    };
+}
+/**
+ * Legacy forwarding aliases — `coat_check_put` / `coat_check_get` /
+ * `coat_check_list` / `coat_check_evict`. Each keeps its EXACT original param
+ * schema and handler (reused verbatim from the legacy descriptor); only the
+ * description gains a deprecation note pointing at the canonical tool.
+ *
+ * Authored as explicit object literals (not loop-generated) so the
+ * surface-drift name scrape and any future static analysis see each alias name
+ * adjacent to its description (docs/design/793-tool-family-merge-brief.md §6).
+ */
+function buildCoatCheckAliasTools(client, config, getPlayerId) {
+    const put = (0, coat_check_put_1.buildCoatCheckPutTool)(client, config, getPlayerId);
+    const get = (0, coat_check_get_1.buildCoatCheckGetTool)(client, config, getPlayerId);
+    const list = (0, coat_check_list_1.buildCoatCheckListTool)(client, config);
+    const evict = (0, coat_check_evict_1.buildCoatCheckEvictTool)(client, config, getPlayerId);
+    return [
+        {
+            name: 'coat_check_put',
+            description: 'DEPRECATED — use `coat_check` with action="put". ' + put.description,
+            params: put.params,
+            handler: put.handler,
+        },
+        {
+            name: 'coat_check_get',
+            description: 'DEPRECATED — use `coat_check` with action="get". ' + get.description,
+            params: get.params,
+            handler: get.handler,
+        },
+        {
+            name: 'coat_check_list',
+            description: 'DEPRECATED — use `coat_check` with action="list". ' + list.description,
+            params: list.params,
+            handler: list.handler,
+        },
+        {
+            name: 'coat_check_evict',
+            description: 'DEPRECATED — use `coat_check` with action="evict". ' + evict.description,
+            params: evict.params,
+            handler: evict.handler,
+        },
+    ];
+}

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[];