@tt-a1i/hive 1.4.4 → 1.6.0

package/dist/src/server/agent-runtime-stop-run.d.ts

@@ -1,4 +1,4 @@
 import type { AgentManager } from './agent-manager.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
 import type { LiveRunRegistry } from './live-run-registry.js';
-export declare const stopLiveRun: (agentManager: AgentManager | undefined, registry: LiveRunRegistry, syncRun: (run: LiveAgentRun) => LiveAgentRun, runId: string) => void;
+export declare const stopLiveRun: (agentManager: AgentManager | undefined, registry: LiveRunRegistry, syncRun: (run: LiveAgentRun) => LiveAgentRun, runId: string, onUserStop?: (runId: string) => void) => void;

package/dist/src/server/agent-runtime-stop-run.js

@@ -1,4 +1,4 @@
-export const stopLiveRun = (agentManager, registry, syncRun, runId) => {
+export const stopLiveRun = (agentManager, registry, syncRun, runId, onUserStop) => {
     if (!agentManager) {
         throw new Error('Agent manager is required to stop agents');
     }
@@ -12,5 +12,8 @@ export const stopLiveRun = (agentManager, registry, syncRun, runId) => {
     else if (['error', 'exited'].includes(agentManager.getRun(runId).status)) {
         return;
     }
+    // Reaching here means the run was genuinely live and we are about to kill it
+    // at the user's request — distinct from a crash that already ended the run.
+    onUserStop?.(runId);
     agentManager.stopRun(runId);
 };

package/dist/src/server/agent-runtime.d.ts

@@ -3,6 +3,7 @@ import type { AgentManager } from './agent-manager.js';
 import type { AgentRuntime } from './agent-runtime-contract.js';
 import type { AgentRunStorePort, AgentSessionStorePort } from './agent-runtime-ports.js';
 import type { CommandPresetRecord } from './command-preset-store.js';
+import type { FeatureFlags } from './feature-flags.js';
 import { type RestartPolicy } from './restart-policy.js';
-export declare const createAgentRuntime: (agentManager: AgentManager | undefined, agentRunStore: AgentRunStorePort, sessionStore: AgentSessionStorePort, getCommandPreset: (id: string) => CommandPresetRecord | undefined, onAgentExit: (workspaceId: string, agentId: string) => void, restartPolicy?: RestartPolicy, getAgent?: (workspaceId: string, agentId: string) => AgentSummary | undefined) => AgentRuntime;
+export declare const createAgentRuntime: (agentManager: AgentManager | undefined, agentRunStore: AgentRunStorePort, sessionStore: AgentSessionStorePort, getCommandPreset: (id: string) => CommandPresetRecord | undefined, onAgentExit: (workspaceId: string, agentId: string) => void, restartPolicy?: RestartPolicy, getAgent?: (workspaceId: string, agentId: string) => AgentSummary | undefined, getFlags?: () => FeatureFlags) => AgentRuntime;
 export type { AgentRuntime };

package/dist/src/server/agent-runtime.js

@@ -10,7 +10,7 @@ import { createAgentStdinDispatcher } from './agent-stdin-dispatcher.js';
 import { createAgentTokenRegistry } from './agent-tokens.js';
 import { createLiveRunRegistry } from './live-run-registry.js';
 import { createNoopRestartPolicy } from './restart-policy.js';
-export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, getCommandPreset, onAgentExit, restartPolicy = createNoopRestartPolicy(), getAgent) => {
+export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, getCommandPreset, onAgentExit, restartPolicy = createNoopRestartPolicy(), getAgent, getFlags) => {
     const registry = createLiveRunRegistry();
     const launchCache = createAgentLaunchCache(agentRunStore);
     const tokenRegistry = createAgentTokenRegistry();
@@ -29,6 +29,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         getWorkspaceId: launchCache.getWorkspaceId,
         registry,
         syncRun,
+        ...(getFlags ? { getFlags } : {}),
     });
     const startLiveRun = createAgentRunStarter({
         agentManager,
@@ -40,6 +41,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         getCommandPreset,
         getAgent,
         restartPolicy,
+        ...(getFlags ? { getFlags } : {}),
     });
     return {
         async close() {
@@ -103,7 +105,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             return startPromise;
         },
         stopAgentRun(runId) {
-            stopLiveRun(agentManager, registry, syncRun, runId);
+            stopLiveRun(agentManager, registry, syncRun, runId, (stoppedRunId) => restartPolicy.markUserStopped(stoppedRunId));
         },
         validateAgentToken: tokenRegistry.validate,
         writeReportPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
@@ -113,7 +115,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             stdinDispatcher.writeStatusPrompt(workspaceId, workerName, text, artifacts, input);
         },
         writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
-            stdinDispatcher.writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text);
+            return stdinDispatcher.writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text);
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
             stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
@@ -121,5 +123,14 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         writeUserInputPrompt(workspaceId, text) {
             stdinDispatcher.writeUserInputPrompt(workspaceId, text);
         },
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            stdinDispatcher.writeSystemMessageToAgent(workspaceId, agentId, text);
+        },
+        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
+            return stdinDispatcher.deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input);
+        },
+        deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
+            return stdinDispatcher.deliverSystemMessageToAgent(workspaceId, agentId, text, input);
+        },
     };
 };

package/dist/src/server/agent-startup-instructions.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSummary, WorkspaceSummary } from '../shared/types.js';
+import { type FeatureFlags } from './feature-flags.js';
 export declare const buildAgentSessionBindingMarker: ({ agent, workspace, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
@@ -7,7 +8,12 @@ export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
 }) => string;
-export declare const buildAgentStartupInstructions: ({ agent, workspace, }: {
+export declare const buildAgentStartupInstructions: ({ agent, workspace, flags, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
+    /** Live experimental flags. `workflowsEnabled` gates the `team workflow`
+     *  command line + the workflow-authoring rule (so a fresh orchestrator isn't
+     *  told to run a command the runtime rejects); `autostaffEnabled` gates the
+     *  team-sizing rule. Omitted → all off. */
+    flags?: FeatureFlags;
 }) => string;

package/dist/src/server/agent-startup-instructions.js

@@ -1,25 +1,33 @@
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { getHiveTeamRules } from './hive-team-guidance.js';
 import { TASKS_RELATIVE_PATH } from './tasks-file.js';
 export const buildAgentSessionBindingMarker = ({ agent, workspace, }) => `Hive session binding: workspace_id=${workspace.id}; agent_id=${agent.id}`;
-export const buildAgentLegacyIdentityMarker = ({ agent, workspace, }) => `你是 ${workspace.name} 的 ${agent.name}（${agent.role}）。`;
-export const buildAgentStartupInstructions = ({ agent, workspace, }) => {
+export const buildAgentLegacyIdentityMarker = ({ agent, workspace, }) => `You are ${agent.name} (${agent.role}) in workspace ${workspace.name}.`;
+export const buildAgentStartupInstructions = ({ agent, workspace, flags = FEATURE_FLAGS_ALL_OFF, }) => {
+    const { workflowsEnabled } = flags;
     const lines = [
-        '[Hive 系统消息：启动说明]',
+        '<hive-message kind="startup">',
         '',
         buildAgentLegacyIdentityMarker({ agent, workspace }),
-        `当前 workspace: ${workspace.name}`,
-        `项目路径: ${workspace.path}`,
+        `Current workspace: ${workspace.name}`,
+        `Project path: ${workspace.path}`,
         buildAgentSessionBindingMarker({ agent, workspace }),
         '',
-        `你的角色：${agent.description}`,
+        // agent.description is the role contract — it follows the user's chosen
+        // language / custom edit and is intentionally left as authored.
+        `Your role: ${agent.description}`,
         '',
     ];
     if (agent.role === 'orchestrator') {
-        lines.push('你的职责：', '- 直接响应 user，澄清需求并拆解任务', `- 维护 ${TASKS_RELATIVE_PATH}`, '- 按 worker 名称派单，并根据汇报推进下一步', '', '可用 team 命令：', '- team list', '- team send <worker-name> "<task>"', '- team cancel --dispatch <id> "<reason>"', '', '派单时必须使用 worker name，不要使用 worker id。', '取消未完成派单时必须使用 dispatch id。', '', 'Hive worker 派单规则：', ...getHiveTeamRules(agent));
+        lines.push('Your responsibilities:', '- Respond to the user directly; clarify the goal and break it into dispatchable tasks', `- Maintain ${TASKS_RELATIVE_PATH}`, '- Dispatch by worker name and drive the next step from each report', '', 'Available team commands:', '- team list', '- team send "<worker-name>" "<task>"', '- team spawn <role> [--name <n>] [--cli claude|codex|opencode|gemini] [--ephemeral]', '- team cancel --dispatch <id> "<reason>"', ...(workflowsEnabled
+            ? [
+                '- team workflow run --stdin   (fan-out / staged work — see .hive/PROTOCOL.md for the DSL)',
+            ]
+            : []), '', 'Always dispatch by worker name, never by worker id.', 'Always cancel an open dispatch by its dispatch id.', '', 'Hive worker dispatch rules:', ...getHiveTeamRules(agent, flags));
     }
     else {
-        lines.push('可用 team 命令：', '- team report "<完整汇报>" [--dispatch <id>] [--artifact <path>]    完成/失败/阻塞汇报', '- team report --stdin [--dispatch <id>] [--artifact <path>]         同上，从 stdin 读正文（适合多行/含引号/特殊字符）', '- team status "<当前状态>" [--artifact <path>]                       中段进度/待命/接入状态', '- team status --stdin [--artifact <path>]                          同上，从 stdin 读正文', '- team list                                                        查看 workspace 内的 worker（含状态）', '- team --help                                                      仅查命令用法；**不是**汇报手段', '', '语法要点：', '- 正文是第一个 positional argument，flag 顺序任意：`team report "结论" --dispatch X` 和 `team report --dispatch X "结论"` 都成立。', '- 长正文（多行 / 含引号 / shell 特殊字符）一律走 `--stdin`，通过你所在 shell 的管道喂给它（POSIX 用 quoted heredoc `<<\'EOF\' … EOF` 防止 $var/反引号展开，Windows cmd 用 `type body.txt |` 或临时文件 `< body.txt`）。`--stdin` 自己只负责"从 stdin 读"，不依赖任何 shell 语法。', '- CLI 报错会同时打印 USAGE，可直接对照修正参数。', '', '完成任务后必须执行 `team report "<结论>"`。', '失败、阻塞或部分完成也用 `team report "<当前状态与原因>"` 汇报。', '没有进行中的任务时，用 `team status "<当前状态>"` 汇报接入、待命或阻塞状态。', '不要调用 team send；worker 之间不能直接派单。', '', 'Hive worker 边界：', ...getHiveTeamRules(agent));
+        lines.push('Available team commands:', '- team report "<result>" [--dispatch <id>] [--artifact <path>]    report done / failed / blocked', '- team report --stdin [--dispatch <id>] [--artifact <path>]       same, body read from stdin (multi-line / quotes / special chars)', '- team status "<state>" [--artifact <path>]                       mid-task progress / standby / connected status', '- team status --stdin [--artifact <path>]                         same, body read from stdin', '- team list                                                       list the workspace workers (with status)', '- team --help                                                     command syntax only; NOT a way to report', '', 'Syntax notes:', '- The body is the first positional argument; flag order is free: `team report "result" --dispatch X` and `team report --dispatch X "result"` are both valid.', "- Long bodies (multi-line / quotes / shell metacharacters) always go through `--stdin`, piped in via your shell (POSIX: a quoted heredoc `<<'EOF' … EOF` to stop $var / backtick expansion; Windows cmd: `type body.txt |` or `< body.txt`). `--stdin` only reads from stdin and relies on no shell syntax of its own.", '- On error the CLI also prints USAGE — fix the arguments against it.', '', 'When a task is done you MUST run `team report "<result>"`.', 'Failure, blocked, or partial completion are also reported with `team report "<current state and reason>"`.', 'When no task is in progress, report connection / standby / blocked state with `team status "<state>"`.', 'Do not call team send; workers cannot dispatch to each other.', '', 'Hive worker boundaries:', ...getHiveTeamRules(agent, flags));
     }
-    lines.push('');
+    lines.push('', '</hive-message>', '');
     return lines.join('\n');
 };

package/dist/src/server/agent-stdin-dispatcher.d.ts

@@ -1,6 +1,7 @@
 import type { AgentManager } from './agent-manager.js';
 import type { AgentLaunchConfigInput } from './agent-run-store.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
+import { type FeatureFlags } from './feature-flags.js';
 import type { LiveRunRegistry } from './live-run-registry.js';
 interface AgentStdinDispatcherInput {
     agentManager: AgentManager | undefined;
@@ -8,23 +9,42 @@ interface AgentStdinDispatcherInput {
     getWorkspaceId: (agentId: string) => string | undefined;
     registry: LiveRunRegistry;
     syncRun: (run: LiveAgentRun) => LiveAgentRun;
+    /** Resolves the live experimental flags. The orchestrator reminder tail
+     *  appended to every injected message reads `workflowsEnabled` from it.
+     *  Optional; omitted → all flags off. */
+    getFlags?: () => FeatureFlags;
 }
-export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[]) => string;
-export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[]) => string;
-export declare const buildOrchestratorUserInputPayload: (text: string) => string;
+export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorUserInputPayload: (text: string, flags?: FeatureFlags) => string;
 export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string) => string;
 export declare const buildWorkerCancelPayload: (dispatchId: string, reason: string) => string;
-export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, }: AgentStdinDispatcherInput) => {
+export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getFlags, }: AgentStdinDispatcherInput) => {
     writeReportPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }): void;
     writeStatusPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }): void;
-    writeSendPrompt(workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string): void;
+    writeSendPrompt(workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string): Promise<void>;
     writeCancelPrompt(workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
         requireActiveRun?: boolean;
     }): void;
     writeUserInputPrompt(workspaceId: string, text: string): void;
+    /** Generic: deliver an opaque text block to a specific agent's PTY.
+     *  Used by the workflow runner to notify the triggering orchestrator
+     *  when a run finishes (mirrors Claude Code's <task-notification>). */
+    writeSystemMessageToAgent(workspaceId: string, agentId: string, text: string): void;
+    /** Awaitable report delivery — same payload as writeReportPrompt but the
+     *  promise is returned so the caller can persist the report to the
+     *  redelivery outbox if the orchestrator PTY write rejects. */
+    deliverReportToOrchestrator(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
+        requireActiveRun?: boolean;
+    }): Promise<void>;
+    /** Awaitable opaque delivery — used to drain the report outbox so an entry
+     *  is marked delivered only after the PTY write actually resolves. */
+    deliverSystemMessageToAgent(workspaceId: string, agentId: string, text: string, input?: {
+        requireActiveRun?: boolean;
+    }): Promise<void>;
 };
 export {};

package/dist/src/server/agent-stdin-dispatcher.js

@@ -1,91 +1,192 @@
-import { buildWorkerReminderTail, ORCHESTRATOR_REMINDER_TAIL } from './hive-team-guidance.js';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-team-guidance.js';
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
-export const buildOrchestratorReportPayload = (workerName, text, artifacts) => {
-    const lines = [`[Hive 系统消息：来自 @${workerName} 的汇报]`, text];
+export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+    const lines = [`<hive-message kind="report" from="@${workerName}">`, text];
     for (const artifact of artifacts)
         lines.push(`artifact: ${artifact}`);
-    lines.push('', ORCHESTRATOR_REMINDER_TAIL, '');
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(flags), '');
     return lines.join('\n');
 };
-export const buildOrchestratorStatusPayload = (workerName, text, artifacts) => {
-    const lines = [`[Hive 系统消息：来自 @${workerName} 的状态更新]`, text];
+export const buildOrchestratorStatusPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+    const lines = [`<hive-message kind="status" from="@${workerName}">`, text];
     for (const artifact of artifacts)
         lines.push(`artifact: ${artifact}`);
-    lines.push('', ORCHESTRATOR_REMINDER_TAIL, '');
+    lines.push('</hive-message>', '', buildOrchestratorReminderTail(flags), '');
     return lines.join('\n');
 };
-export const buildOrchestratorUserInputPayload = (text) => [text, '', ORCHESTRATOR_REMINDER_TAIL, ''].join('\n');
+export const buildOrchestratorUserInputPayload = (text, flags = FEATURE_FLAGS_ALL_OFF) => [text, '', buildOrchestratorReminderTail(flags), ''].join('\n');
 export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text) => [
-    `[Hive 系统消息：来自 @${fromAgentName} 的派单]`,
+    `<hive-message kind="dispatch" from="@${fromAgentName}">`,
     '',
-    `你的角色：${workerDescription}`,
+    `Your role: ${workerDescription}`,
     '',
-    '你必须遵守：',
-    `- 完成、失败、阻塞或部分完成后，执行 \`team report "<result>" --dispatch ${dispatchId}\``,
-    '- 不要做无关的事，做完就 report',
+    'You must:',
+    `- When the task is done, failed, blocked, or partially done, run \`team report "<result>" --dispatch ${dispatchId}\``,
+    '- Do not do unrelated work; report as soon as you are done',
     '',
     `dispatch_id: ${dispatchId}`,
     '',
-    '任务内容：',
+    'Task:',
     text,
+    '</hive-message>',
     '',
     buildWorkerReminderTail(dispatchId),
     '',
 ].join('\n');
 export const buildWorkerCancelPayload = (dispatchId, reason) => [
-    `[Hive 系统消息：dispatch ${dispatchId} 已取消]`,
+    `<hive-message kind="cancel" dispatch="${dispatchId}">`,
     '',
-    '请停止执行这条派单，不要再为它调用 team report。',
+    'Stop working on this dispatch and do not call team report for it.',
     '',
-    '取消原因：',
+    'Cancellation reason:',
     reason,
+    '</hive-message>',
     '',
 ].join('\n');
-export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, }) => {
-    const writeToActiveAgentRun = (workspaceId, agentId, text, input = {}) => {
-        const run = registry
-            .list()
-            .filter((item) => item.agentId === agentId && getWorkspaceId(item.agentId) === workspaceId)
-            .sort((left, right) => right.startedAt - left.startedAt)
-            .find((item) => {
-            const status = syncRun(item).status;
-            return status === 'starting' || status === 'running';
-        });
-        if (!run) {
+export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getFlags, }) => {
+    const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
+    const chains = new Map();
+    const getChain = (agentId) => {
+        let chain = chains.get(agentId);
+        if (!chain) {
+            chain = { busy: false, queue: [] };
+            chains.set(agentId, chain);
+        }
+        return chain;
+    };
+    const resolveActiveRun = (workspaceId, agentId) => registry
+        .list()
+        .filter((item) => item.agentId === agentId && getWorkspaceId(item.agentId) === workspaceId)
+        .sort((left, right) => right.startedAt - left.startedAt)
+        .find((item) => {
+        const status = syncRun(item).status;
+        return status === 'starting' || status === 'running';
+    });
+    // Synchronously enforce requireActiveRun (so writeSendPrompt still throws in
+    // the caller's stack when there is no live run), then return a thunk that
+    // re-resolves the run at EXECUTION time and performs the actual write,
+    // returning a promise that settles when the paste→submit sequence is done.
+    const prepareWrite = (workspaceId, agentId, text, input) => {
+        if (!resolveActiveRun(workspaceId, agentId)) {
             if (input.requireActiveRun) {
                 throw new PtyInactiveError(`No active run for agent: ${agentId}`);
             }
-            return;
+            return () => Promise.resolve();
         }
-        try {
-            const config = getLaunchConfig(workspaceId, agentId);
-            if (agentManager && config) {
-                createPostStartInputWriter(agentManager, config.interactiveCommand ?? config.command)(run.runId, text);
+        return () => {
+            const run = resolveActiveRun(workspaceId, agentId);
+            if (!run) {
+                if (input.requireActiveRun) {
+                    throw new PtyInactiveError(`No active run for agent: ${agentId}`);
+                }
+                return Promise.resolve();
             }
-            else {
+            try {
+                const config = getLaunchConfig(workspaceId, agentId);
+                if (agentManager && config) {
+                    return (createPostStartInputWriter(agentManager, config.interactiveCommand ?? config.command)(run.runId, text).catch((error) => {
+                        throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+                    }) ?? Promise.resolve());
+                }
                 agentManager?.writeInput(run.runId, text);
+                return Promise.resolve();
+            }
+            catch (error) {
+                throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
             }
+        };
+    };
+    const settle = (agentId, promise) => promise.finally(() => {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        chain.busy = false;
+        drain(agentId);
+    });
+    const runQueuedWrite = (agentId, write) => {
+        try {
+            void settle(agentId, write.run()).then(write.resolve, write.reject);
+        }
+        catch (error) {
+            write.reject(error);
+            const chain = chains.get(agentId);
+            if (chain)
+                chain.busy = false;
+            drain(agentId);
+        }
+    };
+    function drain(agentId) {
+        const chain = chains.get(agentId);
+        if (!chain)
+            return;
+        if (chain.busy)
+            return;
+        const next = chain.queue.shift();
+        if (!next) {
+            chains.delete(agentId);
+            return;
+        }
+        chain.busy = true;
+        runQueuedWrite(agentId, next);
+    }
+    const writeToActiveAgentRun = (workspaceId, agentId, text, input = {}) => {
+        const thunk = prepareWrite(workspaceId, agentId, text, input);
+        const chain = getChain(agentId);
+        if (chain.busy) {
+            return new Promise((resolve, reject) => {
+                chain.queue.push({ reject, resolve, run: thunk });
+            });
+        }
+        chain.busy = true;
+        try {
+            return settle(agentId, thunk()); // uncontended: run now; immediate failures still throw
         }
         catch (error) {
-            throw new PtyInactiveError(error instanceof Error ? error.message : String(error));
+            chain.busy = false;
+            drain(agentId);
+            throw error;
         }
     };
+    const swallowQueuedFailure = (promise) => {
+        void promise.catch(() => {
+            // Deferred prompt writes can fail if the PTY exits while queued. Calls
+            // that require foreground error reporting use writeSendPrompt's promise.
+        });
+    };
     return {
         writeReportPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input));
         },
         writeStatusPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
         },
         writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
-            writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
+            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input);
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));
         },
         writeUserInputPrompt(workspaceId, text) {
-            writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text));
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags())));
+        },
+        /** Generic: deliver an opaque text block to a specific agent's PTY.
+         *  Used by the workflow runner to notify the triggering orchestrator
+         *  when a run finishes (mirrors Claude Code's <task-notification>). */
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, agentId, text));
+        },
+        /** Awaitable report delivery — same payload as writeReportPrompt but the
+         *  promise is returned so the caller can persist the report to the
+         *  redelivery outbox if the orchestrator PTY write rejects. */
+        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
+            return writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input);
+        },
+        /** Awaitable opaque delivery — used to drain the report outbox so an entry
+         *  is marked delivered only after the PTY write actually resolves. */
+        deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
+            return writeToActiveAgentRun(workspaceId, agentId, text, input);
         },
     };
 };

package/dist/src/server/cron-util.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export declare const validateCronNextRunAt: (cron: string) => number;

package/dist/src/server/cron-util.js

@@ -0,0 +1,19 @@
+import { CronExpressionParser } from 'cron-parser';
+import { BadRequestError } from './http-errors.js';
+/**
+ * Validate a 5-field cron string and return its next fire time (ms-epoch).
+ * Throws BadRequestError on an unparseable expression. Shared by the UI
+ * schedule PATCH route and the agent `team workflow schedule` route so cron
+ * validation behaves identically on both paths. UTC, like the scheduler.
+ */
+export const validateCronNextRunAt = (cron) => {
+    try {
+        return CronExpressionParser.parse(cron, { currentDate: new Date(), tz: 'UTC' })
+            .next()
+            .toDate()
+            .getTime();
+    }
+    catch (error) {
+        throw new BadRequestError(`Invalid cron expression: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};

package/dist/src/server/dispatch-ledger-store.d.ts

@@ -6,19 +6,27 @@ export interface DispatchRecord {
     deliveredAt: number | null;
     fromAgentId: string | null;
     id: string;
+    label: string | null;
+    phase: string | null;
     reportedAt: number | null;
     reportText: string | null;
     sequence: number | null;
     status: DispatchStatus;
+    stepIndex: number | null;
     submittedAt: number | null;
     text: string;
     toAgentId: string;
+    workflowRunId: string | null;
     workspaceId: string;
 }
 interface CreateDispatchInput {
     fromAgentId?: string;
+    label?: string;
+    phase?: string;
+    stepIndex?: number;
     text: string;
     toAgentId: string;
+    workflowRunId?: string;
     workspaceId: string;
 }
 interface ReportDispatchInput {
@@ -50,6 +58,12 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         worker_id: string;
         workspace_id: string;
     }>;
+    listOpenDispatchIdsForRun: (runId: string) => string[];
+    listOpenWorkflowDispatchesForWorker: (workspaceId: string, workerId: string) => Array<{
+        dispatchId: string;
+        runId: string;
+    }>;
+    listWorkflowRunDispatches: (runId: string) => DispatchRecord[];
     listWorkspaceDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     markCancelled: (input: CancelDispatchInput) => {
         reportedAt: number;
@@ -60,10 +74,14 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         deliveredAt: number | null;
         fromAgentId: string | null;
         id: string;
+        label: string | null;
+        phase: string | null;
         sequence: number | null;
+        stepIndex: number | null;
         submittedAt: number | null;
         text: string;
         toAgentId: string;
+        workflowRunId: string | null;
         workspaceId: string;
     } | undefined;
     markReportedByWorker: (input: ReportDispatchInput) => {
@@ -75,10 +93,14 @@ export declare const createDispatchLedgerStore: (db: Database) => {
         deliveredAt: number | null;
         fromAgentId: string | null;
         id: string;
+        label: string | null;
+        phase: string | null;
         sequence: number | null;
+        stepIndex: number | null;
         submittedAt: number | null;
         text: string;
         toAgentId: string;
+        workflowRunId: string | null;
         workspaceId: string;
     } | undefined;
     markSubmitted: (dispatchId: string) => void;