agent-tempo 1.0.1

package/dist/workflows/attachment-math.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendAttachmentForCAN = extendAttachmentForCAN;
+/**
+ * Produce a new {@link Attachment} whose lease window is extended so an
+ * adapter that was beating normally at the moment of `continueAsNew` has room
+ * to land its next heartbeat before the new execution's first main-loop tick
+ * reaps the lease.
+ *
+ * **Design rationale (session-lifecycle-rebuild-v2.md §2.3):** the CAN
+ * transition is not instantaneous. If we were to write the pre-CAN
+ * `expiresAt` verbatim into the new execution, a transition that takes
+ * ~100-500ms could leave the new run's first deadline race observing an
+ * already-expired lease and reaping a healthy attachment. Pushing
+ * `expiresAt` out to `now + extendMs` guarantees the adapter has room to land
+ * its next heartbeat.
+ *
+ * Why this is a total function (returns a new object unconditionally,
+ * rather than accepting `null` and returning `undefined`): null-handling is
+ * the caller's business — a workflow that has no current attachment simply
+ * skips the call. Keeping this function non-nullable keeps the unit tests
+ * focused on math rather than null-propagation.
+ *
+ * @param attachment - the pre-CAN attachment record. All non-timestamp
+ *   fields (`attachmentId`, `hostname`, `adapterId`, `adapterClass`,
+ *   `claimedAt`, `leaseMs`, `runId`) are carried forward verbatim.
+ * @param extendMs - how far past `now` to push `expiresAt`, in milliseconds.
+ *   Post-#249 callers pass `attachment.leaseMs` (= 3 × heartbeatMs — covers one
+ *   full lease window and therefore at least one full heartbeat interval for
+ *   every adapter class). Pre-#249 callers passed a hardcoded 30_000 constant
+ *   which under-covered the claude-code adapter's 60s cadence — the rename
+ *   from `heartbeatMs` disambiguates that the parameter is a raw extension
+ *   duration, not a cadence. The function does not validate — any non-negative
+ *   integer is accepted.
+ * @param now - current time in epoch milliseconds. In workflow context
+ *   callers pass `new Date().getTime()` (the Temporal SDK intercepts `new
+ *   Date()` to return replay-consistent time). In unit tests callers pass
+ *   an arbitrary fixed value.
+ * @returns a new `Attachment` object — the input is not mutated.
+ */
+function extendAttachmentForCAN(attachment, extendMs, now) {
+    return {
+        ...attachment,
+        lastHeartbeatAt: new Date(now).toISOString(),
+        expiresAt: new Date(now + extendMs).toISOString(),
+    };
+}

package/dist/workflows/index.d.ts

@@ -0,0 +1,3 @@
+export { agentSessionWorkflow } from './session';
+export { agentSchedulerWorkflow } from './scheduler';
+export { agentMaestroWorkflow, agentGlobalMaestroWorkflow } from './maestro';

package/dist/workflows/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentGlobalMaestroWorkflow = exports.agentMaestroWorkflow = exports.agentSchedulerWorkflow = exports.agentSessionWorkflow = void 0;
+// Workflow entry point — re-exports all workflows for bundling.
+var session_1 = require("./session");
+Object.defineProperty(exports, "agentSessionWorkflow", { enumerable: true, get: function () { return session_1.agentSessionWorkflow; } });
+var scheduler_1 = require("./scheduler");
+Object.defineProperty(exports, "agentSchedulerWorkflow", { enumerable: true, get: function () { return scheduler_1.agentSchedulerWorkflow; } });
+var maestro_1 = require("./maestro");
+Object.defineProperty(exports, "agentMaestroWorkflow", { enumerable: true, get: function () { return maestro_1.agentMaestroWorkflow; } });
+Object.defineProperty(exports, "agentGlobalMaestroWorkflow", { enumerable: true, get: function () { return maestro_1.agentGlobalMaestroWorkflow; } });

package/dist/workflows/maestro-signals.d.ts

@@ -0,0 +1,217 @@
+import type { MaestroPlayerInfo, MaestroEvent, MaestroPendingCommand, MaestroRelayMessage, EnsembleChatResult, EnsembleChatQuery, Message, SentMessage, HostProfile, CoatCheckEntry, CoatCheckEntryHeader } from '../types';
+export type { MaestroPlayerInfo, MaestroEvent, MaestroPendingCommand, MaestroInput, MaestroRelayMessage, GlobalMaestroInput, EnsembleChatMessage, EnsembleChatResult, EnsembleChatQuery, ChatHighWater, } from '../types';
+export { ZERO_CHAT_HIGH_WATER } from '../types';
+/** Gracefully shut down the Maestro workflow. */
+export declare const maestroShutdownSignal: import("@temporalio/workflow").SignalDefinition<[], "maestroShutdown">;
+/** Set the ensemble-wide paused state. */
+export declare const maestroSetPausedSignal: import("@temporalio/workflow").SignalDefinition<[boolean], string>;
+/**
+ * #399 W1 (Q5.1) — set the ensemble's mission-flavor description.
+ *
+ * Surfaced on the dashboard EnsembleCard. Conductors are encouraged to
+ * keep this short (~80 chars, soft cap 100) and refresh at milestone
+ * boundaries — see the conductor agent definition for the responsibility
+ * note. Empty string clears the description.
+ */
+export declare const setEnsembleDescriptionSignal: import("@temporalio/workflow").SignalDefinition<[string], string>;
+/** Get the current snapshot of all players in the ensemble. */
+export declare const maestroPlayersQuery: import("@temporalio/workflow").QueryDefinition<MaestroPlayerInfo[], [], string>;
+/** Get the event log (ring buffer, max 200 entries). */
+export declare const maestroEventsQuery: import("@temporalio/workflow").QueryDefinition<MaestroEvent[], [], string>;
+/** Query whether the ensemble is paused. */
+export declare const maestroPausedQuery: import("@temporalio/workflow").QueryDefinition<boolean, [], string>;
+/** Get pending commands (queued but not yet relayed to conductor). */
+export declare const maestroPendingCommandsQuery: import("@temporalio/workflow").QueryDefinition<MaestroPendingCommand[], [], string>;
+/** Paginated ensemble chat from cached state (maestro + conductor traffic). */
+export declare const maestroEnsembleChatQuery: import("@temporalio/workflow").QueryDefinition<EnsembleChatResult, [EnsembleChatQuery], string>;
+/**
+ * #399 W1 (Q5.1) — current ensemble description (mission-flavor text).
+ * Empty string when no description has been set.
+ */
+export declare const getEnsembleDescriptionQuery: import("@temporalio/workflow").QueryDefinition<string, [], string>;
+/**
+ * #399 W1 (Q5.3a) — ISO timestamp of the maestro's first start
+ * (`workflowInfo().startTime`, preserved across continueAsNew via
+ * `MaestroInput.startTimeIso`). Dashboard derives uptime client-side.
+ */
+export declare const getEnsembleStartTimeQuery: import("@temporalio/workflow").QueryDefinition<string, [], string>;
+/**
+ * #399 W1 (Q5.6 Flavor B) — current ensemble BPM derived from the last
+ * minute of activity (the two most recent 30-second buckets). Returns
+ * `0` when activity hasn't yet accumulated a bucket.
+ */
+export declare const getCurrentBpmQuery: import("@temporalio/workflow").QueryDefinition<number, [], string>;
+/**
+ * #399 W1 (Q5.6 Flavor B) — most recent 60 finished 30-second activity
+ * buckets (oldest-first). Each entry is a count of player-activity
+ * deltas accumulated during that window. Used by the dashboard's
+ * `TempoStrip` sparkline.
+ */
+export declare const getTempoSeriesQuery: import("@temporalio/workflow").QueryDefinition<number[], [], string>;
+/** Queue a command to be relayed to the conductor. Returns the command ID. */
+export declare const maestroSendCommandUpdate: import("@temporalio/common").UpdateDefinition<string, [{
+    text: string;
+    source: string;
+    replyTo?: string;
+}], string>;
+export interface CoatCheckPutInput {
+    summary: string;
+    content: string;
+    contentType?: string;
+    ttlMs?: number;
+    /** Audit identity — set by the tool layer, NOT a caller-supplied MCP arg. */
+    putBy: string;
+}
+export interface CoatCheckPutResult {
+    ticket: string;
+    expiresAt: string;
+    slotsUsed: number;
+    slotsTotal: number;
+}
+export interface CoatCheckGetInput {
+    ticket: string;
+    /** Audit identity — set by the tool layer, NOT a caller-supplied MCP arg. */
+    fetchedBy: string;
+}
+export interface CoatCheckListInput {
+    /** Optional `putBy` filter — audit lens for "what did <player> stash?" */
+    putBy?: string;
+    /** Optional summary-prefix filter. */
+    prefix?: string;
+    /**
+     * When `true`, only return entries with `fetchCount === 0`. Owner cleanup
+     * workflow: "show me what nobody's picked up yet."
+     */
+    unfetchedOnly?: boolean;
+}
+export interface CoatCheckEvictInput {
+    ticket: string;
+    /**
+     * Audit identity — set by the tool layer. Workflow validator enforces
+     * `evictedBy === entry.putBy` OR `evictedBy === <conductor playerId>` so
+     * eviction is owner-or-conductor; everyone else gets a
+     * `CoatCheckEvictPermissionDenied` ApplicationFailure.
+     */
+    evictedBy: string;
+}
+/**
+ * Admit a new coat-check entry. Saturation (20-slot cap exhausted) rejects
+ * with `CoatCheckSlotsFull` ApplicationFailure carrying the oldest 3 ticket
+ * ids in the message. Oversize content rejects with `CoatCheckEntryTooLarge`.
+ * Re-export the entry-and-result types so workflow code and tools share one
+ * shape.
+ */
+export declare const coatCheckPutUpdate: import("@temporalio/common").UpdateDefinition<CoatCheckPutResult, [CoatCheckPutInput], string>;
+/**
+ * Fetch a coat-check entry by ticket. Returns the full entry (including
+ * content body) on success, or `null` when the ticket is missing / expired /
+ * evicted — no error class proliferation for the common "ticket already
+ * gone" case. Successful reads mutate `lastFetchedAt` / `lastFetchedBy` /
+ * `fetchCount` on the entry; failed reads do not.
+ */
+export declare const coatCheckGetUpdate: import("@temporalio/common").UpdateDefinition<CoatCheckEntry | null, [CoatCheckGetInput], string>;
+/**
+ * List coat-check entry headers (content omitted) newest-first. Read-only —
+ * does NOT bump fetch-audit counters. Optional `putBy` / `prefix` /
+ * `unfetchedOnly` filters narrow the result.
+ */
+export declare const coatCheckListQuery: import("@temporalio/workflow").QueryDefinition<CoatCheckEntryHeader[], [(CoatCheckListInput | undefined)?], string>;
+/**
+ * Evict a coat-check entry by ticket. Owner-or-conductor only — workflow
+ * validator rejects mismatched `evictedBy` with `CoatCheckEvictPermissionDenied`.
+ * `evicted: false` when the ticket was missing / already expired before the
+ * call landed.
+ */
+export declare const coatCheckEvictUpdate: import("@temporalio/common").UpdateDefinition<{
+    evicted: boolean;
+}, [CoatCheckEvictInput], string>;
+/** Notify the global Maestro of a relayed message (for Phase 2 push-based updates). */
+export declare const maestroNotifyMessageSignal: import("@temporalio/workflow").SignalDefinition<[MaestroRelayMessage], string>;
+/**
+ * #274 — daemon advertises its capability profile at boot.
+ *
+ * Payload typed as `Record<string, unknown>` at the wire boundary so the
+ * global maestro handler can accept additive fields from future daemon
+ * versions without breaking. Handler validates ONLY `hostname` (required,
+ * `PLAYER_NAME_REGEX`, ≤64 chars); all other fields stored opaquely. Per-
+ * field Zod validation happens at the `listHosts` join site in
+ * `src/utils/hosts.ts`, never here. See #274 architect delta AC3c (M9).
+ *
+ * Daemons MUST scrub PII before signaling (AC5c / M10) — claudeBin is
+ * basename only; availableAgentTypes is type names only; no absolute
+ * paths, env vars, or user-home fragments.
+ */
+export declare const hostProfileSignal: import("@temporalio/workflow").SignalDefinition<[Record<string, unknown>], string>;
+/** Get the list of known ensembles. */
+export declare const maestroEnsemblesQuery: import("@temporalio/workflow").QueryDefinition<string[], [], string>;
+/** Get players grouped by ensemble. */
+export declare const maestroPlayersByEnsembleQuery: import("@temporalio/workflow").QueryDefinition<Record<string, MaestroPlayerInfo[]>, [], string>;
+/** Get recent messages across all ensembles (ring buffer, max 500). */
+export declare const maestroRecentMessagesQuery: import("@temporalio/workflow").QueryDefinition<MaestroRelayMessage[], [], string>;
+/**
+ * #274 — the `hostname → HostProfile` map maintained by the global maestro.
+ *
+ * Returned as a plain `Record<string, HostProfile>` (not a `Map`) so the
+ * default Temporal payload converter serializes it without a codec tweak.
+ * The `src/utils/hosts.ts` join helper consumes this and reconstructs a
+ * `Map`-shaped view at the consumer boundary if callers find it useful.
+ *
+ * Consumers MUST treat the returned profiles as opaque beyond the
+ * `hostname` field — per-field validation happens at the join site, not
+ * at query time.
+ */
+export declare const hostProfilesQuery: import("@temporalio/workflow").QueryDefinition<Record<string, HostProfile>, [], string>;
+/**
+ * #280 — combined existence + profiles query.
+ *
+ * Saves a round-trip on the `listHosts` cache-miss path: the prior
+ * implementation called `handle.describe()` to confirm the workflow was
+ * `RUNNING` then `handle.query('hostProfiles')` to fetch the data — two
+ * sequential RPCs against the same handle. Callers can now hit a single
+ * query: success → `{ exists: true, profiles }`; transport failure
+ * (workflow not found, terminated, unreachable) → caller catches and
+ * treats as `null` (i.e. "missing"). The `exists: true` flag is set
+ * explicitly by the handler so future variants — e.g. an "I'm running
+ * but in degraded mode" signal — could carry `exists: false` over the
+ * wire without breaking older clients.
+ *
+ * Wire-protocol additive change (new query, no rename) — the legacy
+ * `hostProfiles` query stays for backwards compatibility.
+ */
+export declare const hostProfilesWithExistenceQuery: import("@temporalio/workflow").QueryDefinition<{
+    exists: boolean;
+    profiles: Record<string, HostProfile>;
+}, [], string>;
+/** Send a message to a player in a specific ensemble. Returns the message ID. */
+export declare const maestroSendMessageUpdate: import("@temporalio/common").UpdateDefinition<string, [{
+    ensemble: string;
+    to: string;
+    text: string;
+    source: string;
+}], string>;
+/** Fetch a player's message history (received + sent). Returns merged timeline. */
+export declare const maestroFetchPlayerMessagesUpdate: import("@temporalio/common").UpdateDefinition<(Message | (SentMessage & {
+    direction: "sent";
+}))[], [{
+    ensemble: string;
+    playerId: string;
+}], string>;
+/** Fetch a conductor's command/report history for an ensemble. */
+export declare const maestroFetchConductorHistoryUpdate: import("@temporalio/common").UpdateDefinition<{
+    success: boolean;
+    history: Array<{
+        type: string;
+        timestamp: string;
+        data: unknown;
+    }>;
+    error?: string;
+}, [{
+    ensemble: string;
+}], string>;
+/** Queue a command to be relayed to a specific ensemble's conductor. Returns the command ID. */
+export declare const maestroGlobalSendCommandUpdate: import("@temporalio/common").UpdateDefinition<string, [{
+    ensemble: string;
+    text: string;
+    source: string;
+    replyTo?: string;
+}], string>;

package/dist/workflows/maestro-signals.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maestroGlobalSendCommandUpdate = exports.maestroFetchConductorHistoryUpdate = exports.maestroFetchPlayerMessagesUpdate = exports.maestroSendMessageUpdate = exports.hostProfilesWithExistenceQuery = exports.hostProfilesQuery = exports.maestroRecentMessagesQuery = exports.maestroPlayersByEnsembleQuery = exports.maestroEnsemblesQuery = exports.hostProfileSignal = exports.maestroNotifyMessageSignal = exports.coatCheckEvictUpdate = exports.coatCheckListQuery = exports.coatCheckGetUpdate = exports.coatCheckPutUpdate = exports.maestroSendCommandUpdate = exports.getTempoSeriesQuery = exports.getCurrentBpmQuery = exports.getEnsembleStartTimeQuery = exports.getEnsembleDescriptionQuery = exports.maestroEnsembleChatQuery = exports.maestroPendingCommandsQuery = exports.maestroPausedQuery = exports.maestroEventsQuery = exports.maestroPlayersQuery = exports.setEnsembleDescriptionSignal = exports.maestroSetPausedSignal = exports.maestroShutdownSignal = exports.ZERO_CHAT_HIGH_WATER = void 0;
+const workflow_1 = require("@temporalio/workflow");
+var types_1 = require("../types");
+Object.defineProperty(exports, "ZERO_CHAT_HIGH_WATER", { enumerable: true, get: function () { return types_1.ZERO_CHAT_HIGH_WATER; } });
+// ── Per-Ensemble Maestro Signals (existing) ──
+/** Gracefully shut down the Maestro workflow. */
+exports.maestroShutdownSignal = (0, workflow_1.defineSignal)('maestroShutdown');
+/** Set the ensemble-wide paused state. */
+exports.maestroSetPausedSignal = (0, workflow_1.defineSignal)('maestroSetPaused');
+/**
+ * #399 W1 (Q5.1) — set the ensemble's mission-flavor description.
+ *
+ * Surfaced on the dashboard EnsembleCard. Conductors are encouraged to
+ * keep this short (~80 chars, soft cap 100) and refresh at milestone
+ * boundaries — see the conductor agent definition for the responsibility
+ * note. Empty string clears the description.
+ */
+exports.setEnsembleDescriptionSignal = (0, workflow_1.defineSignal)('setEnsembleDescription');
+// ── Per-Ensemble Maestro Queries (existing) ──
+/** Get the current snapshot of all players in the ensemble. */
+exports.maestroPlayersQuery = (0, workflow_1.defineQuery)('maestroPlayers');
+/** Get the event log (ring buffer, max 200 entries). */
+exports.maestroEventsQuery = (0, workflow_1.defineQuery)('maestroEvents');
+/** Query whether the ensemble is paused. */
+exports.maestroPausedQuery = (0, workflow_1.defineQuery)('maestroPaused');
+/** Get pending commands (queued but not yet relayed to conductor). */
+exports.maestroPendingCommandsQuery = (0, workflow_1.defineQuery)('maestroPendingCommands');
+/** Paginated ensemble chat from cached state (maestro + conductor traffic). */
+exports.maestroEnsembleChatQuery = (0, workflow_1.defineQuery)('maestroEnsembleChat');
+/**
+ * #399 W1 (Q5.1) — current ensemble description (mission-flavor text).
+ * Empty string when no description has been set.
+ */
+exports.getEnsembleDescriptionQuery = (0, workflow_1.defineQuery)('getEnsembleDescription');
+/**
+ * #399 W1 (Q5.3a) — ISO timestamp of the maestro's first start
+ * (`workflowInfo().startTime`, preserved across continueAsNew via
+ * `MaestroInput.startTimeIso`). Dashboard derives uptime client-side.
+ */
+exports.getEnsembleStartTimeQuery = (0, workflow_1.defineQuery)('getEnsembleStartTime');
+/**
+ * #399 W1 (Q5.6 Flavor B) — current ensemble BPM derived from the last
+ * minute of activity (the two most recent 30-second buckets). Returns
+ * `0` when activity hasn't yet accumulated a bucket.
+ */
+exports.getCurrentBpmQuery = (0, workflow_1.defineQuery)('getCurrentBpm');
+/**
+ * #399 W1 (Q5.6 Flavor B) — most recent 60 finished 30-second activity
+ * buckets (oldest-first). Each entry is a count of player-activity
+ * deltas accumulated during that window. Used by the dashboard's
+ * `TempoStrip` sparkline.
+ */
+exports.getTempoSeriesQuery = (0, workflow_1.defineQuery)('getTempoSeries');
+// ── Per-Ensemble Maestro Updates (existing) ──
+/** Queue a command to be relayed to the conductor. Returns the command ID. */
+exports.maestroSendCommandUpdate = (0, workflow_1.defineUpdate)('maestroSendCommand');
+/**
+ * Admit a new coat-check entry. Saturation (20-slot cap exhausted) rejects
+ * with `CoatCheckSlotsFull` ApplicationFailure carrying the oldest 3 ticket
+ * ids in the message. Oversize content rejects with `CoatCheckEntryTooLarge`.
+ * Re-export the entry-and-result types so workflow code and tools share one
+ * shape.
+ */
+exports.coatCheckPutUpdate = (0, workflow_1.defineUpdate)('coatCheckPut');
+/**
+ * Fetch a coat-check entry by ticket. Returns the full entry (including
+ * content body) on success, or `null` when the ticket is missing / expired /
+ * evicted — no error class proliferation for the common "ticket already
+ * gone" case. Successful reads mutate `lastFetchedAt` / `lastFetchedBy` /
+ * `fetchCount` on the entry; failed reads do not.
+ */
+exports.coatCheckGetUpdate = (0, workflow_1.defineUpdate)('coatCheckGet');
+/**
+ * List coat-check entry headers (content omitted) newest-first. Read-only —
+ * does NOT bump fetch-audit counters. Optional `putBy` / `prefix` /
+ * `unfetchedOnly` filters narrow the result.
+ */
+exports.coatCheckListQuery = (0, workflow_1.defineQuery)('coatCheckList');
+/**
+ * Evict a coat-check entry by ticket. Owner-or-conductor only — workflow
+ * validator rejects mismatched `evictedBy` with `CoatCheckEvictPermissionDenied`.
+ * `evicted: false` when the ticket was missing / already expired before the
+ * call landed.
+ */
+exports.coatCheckEvictUpdate = (0, workflow_1.defineUpdate)('coatCheckEvict');
+// ══════════════════════════════════════════════════════════════════════════════
+// Global Maestro — single instance handling ALL ensembles
+// ══════════════════════════════════════════════════════════════════════════════
+// ── Global Maestro Signals ──
+/** Notify the global Maestro of a relayed message (for Phase 2 push-based updates). */
+exports.maestroNotifyMessageSignal = (0, workflow_1.defineSignal)('maestroNotifyMessage');
+/**
+ * #274 — daemon advertises its capability profile at boot.
+ *
+ * Payload typed as `Record<string, unknown>` at the wire boundary so the
+ * global maestro handler can accept additive fields from future daemon
+ * versions without breaking. Handler validates ONLY `hostname` (required,
+ * `PLAYER_NAME_REGEX`, ≤64 chars); all other fields stored opaquely. Per-
+ * field Zod validation happens at the `listHosts` join site in
+ * `src/utils/hosts.ts`, never here. See #274 architect delta AC3c (M9).
+ *
+ * Daemons MUST scrub PII before signaling (AC5c / M10) — claudeBin is
+ * basename only; availableAgentTypes is type names only; no absolute
+ * paths, env vars, or user-home fragments.
+ */
+exports.hostProfileSignal = (0, workflow_1.defineSignal)('hostProfile');
+// ── Global Maestro Queries ──
+/** Get the list of known ensembles. */
+exports.maestroEnsemblesQuery = (0, workflow_1.defineQuery)('maestroEnsembles');
+/** Get players grouped by ensemble. */
+exports.maestroPlayersByEnsembleQuery = (0, workflow_1.defineQuery)('maestroPlayersByEnsemble');
+/** Get recent messages across all ensembles (ring buffer, max 500). */
+exports.maestroRecentMessagesQuery = (0, workflow_1.defineQuery)('maestroRecentMessages');
+/**
+ * #274 — the `hostname → HostProfile` map maintained by the global maestro.
+ *
+ * Returned as a plain `Record<string, HostProfile>` (not a `Map`) so the
+ * default Temporal payload converter serializes it without a codec tweak.
+ * The `src/utils/hosts.ts` join helper consumes this and reconstructs a
+ * `Map`-shaped view at the consumer boundary if callers find it useful.
+ *
+ * Consumers MUST treat the returned profiles as opaque beyond the
+ * `hostname` field — per-field validation happens at the join site, not
+ * at query time.
+ */
+exports.hostProfilesQuery = (0, workflow_1.defineQuery)('hostProfiles');
+/**
+ * #280 — combined existence + profiles query.
+ *
+ * Saves a round-trip on the `listHosts` cache-miss path: the prior
+ * implementation called `handle.describe()` to confirm the workflow was
+ * `RUNNING` then `handle.query('hostProfiles')` to fetch the data — two
+ * sequential RPCs against the same handle. Callers can now hit a single
+ * query: success → `{ exists: true, profiles }`; transport failure
+ * (workflow not found, terminated, unreachable) → caller catches and
+ * treats as `null` (i.e. "missing"). The `exists: true` flag is set
+ * explicitly by the handler so future variants — e.g. an "I'm running
+ * but in degraded mode" signal — could carry `exists: false` over the
+ * wire without breaking older clients.
+ *
+ * Wire-protocol additive change (new query, no rename) — the legacy
+ * `hostProfiles` query stays for backwards compatibility.
+ */
+exports.hostProfilesWithExistenceQuery = (0, workflow_1.defineQuery)('hostProfilesWithExistence');
+// ── Global Maestro Updates ──
+/** Send a message to a player in a specific ensemble. Returns the message ID. */
+exports.maestroSendMessageUpdate = (0, workflow_1.defineUpdate)('maestroSendMessage');
+/** Fetch a player's message history (received + sent). Returns merged timeline. */
+exports.maestroFetchPlayerMessagesUpdate = (0, workflow_1.defineUpdate)('maestroFetchPlayerMessages');
+/** Fetch a conductor's command/report history for an ensemble. */
+exports.maestroFetchConductorHistoryUpdate = (0, workflow_1.defineUpdate)('maestroFetchConductorHistory');
+/** Queue a command to be relayed to a specific ensemble's conductor. Returns the command ID. */
+exports.maestroGlobalSendCommandUpdate = (0, workflow_1.defineUpdate)('maestroGlobalSendCommand');

package/dist/workflows/maestro.d.ts

@@ -0,0 +1,3 @@
+import { MaestroInput, GlobalMaestroInput } from './maestro-signals';
+export declare function agentMaestroWorkflow(input: MaestroInput): Promise<void>;
+export declare function agentGlobalMaestroWorkflow(input: GlobalMaestroInput): Promise<void>;