@tt-a1i/hive 1.4.3 → 1.5.0

package/dist/src/server/agent-run-bootstrap.js

@@ -1,4 +1,4 @@
-import { delimiter, dirname, resolve, sep } from 'node:path';
+import { dirname, posix, resolve, sep, win32 } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { buildAgentLegacyIdentityMarker, buildAgentSessionBindingMarker, } from './agent-startup-instructions.js';
 import { withPresetResumeArgs } from './preset-launch-support.js';
@@ -12,6 +12,34 @@ const resolveHiveBinDir = () => {
 };
 const HIVE_BIN_DIR = resolveHiveBinDir();
 const SESSION_CAPTURE_TIMEOUT_MS = 30_000;
+/**
+ * Builds a `{ <PATH-key>: <new-value> }` object for the spawn env override.
+ * Critical on Windows: the OS env block reports PATH under its native casing
+ * (typically `Path`). Writing to a literal `PATH` key would, after spread
+ * with `process.env`, leave two entries — `Path` carrying the original value
+ * and `PATH` carrying our prepend. CreateProcess then sees both and the
+ * effective lookup order is undefined; in practice the child PTY often falls
+ * back to the original `Path` and never sees `HIVE_BIN_DIR`, breaking every
+ * `team` shim resolution.
+ *
+ * We detect the existing key (case-insensitive on Windows) and overwrite IT,
+ * so the merge produces exactly one PATH entry.
+ *
+ * Exported for unit testing — `buildAgentRunBootstrap` is the only in-tree
+ * caller.
+ */
+export const buildSpawnPathEnvEntry = (parentEnv, hiveBinDir, platform) => {
+    const existingKey = platform === 'win32'
+        ? Object.keys(parentEnv).find((key) => key.toLowerCase() === 'path')
+        : undefined;
+    const key = existingKey ?? 'PATH';
+    const existingValue = existingKey ? parentEnv[existingKey] : parentEnv.PATH;
+    // Target platform's delimiter — Windows uses `;`, POSIX `:` — independent
+    // of where this function is running (tests on macOS verify the win32 path).
+    const platformDelimiter = platform === 'win32' ? win32.delimiter : posix.delimiter;
+    const value = existingValue ? `${hiveBinDir}${platformDelimiter}${existingValue}` : hiveBinDir;
+    return { [key]: value };
+};
 const resolveLaunchPreset = (config, getCommandPreset) => {
     if (config.presetAugmentationDisabled)
         return undefined;
@@ -52,7 +80,7 @@ export const buildAgentRunBootstrap = (workspace, agentId, config, sessionStore,
             HIVE_PROJECT_ID: workspace.id,
             HIVE_AGENT_ID: agentId,
             HIVE_AGENT_TOKEN: '',
-            PATH: `${HIVE_BIN_DIR}${delimiter}${process.env.PATH ?? ''}`,
+            ...buildSpawnPathEnvEntry(process.env, HIVE_BIN_DIR, process.platform),
         },
     };
 };

package/dist/src/server/agent-run-starter.d.ts

@@ -18,6 +18,12 @@ interface AgentRunStarterInput {
     getCommandPreset: (id: string) => CommandPresetRecord | undefined;
     getAgent: ((workspaceId: string, agentId: string) => AgentSummary | undefined) | undefined;
     restartPolicy: RestartPolicy;
+    /** Experimental workflow gate — gates the `team workflow` line + the
+     *  workflow-authoring rule in the orchestrator's startup prompt. */
+    getWorkflowsEnabled?: () => boolean;
+    /** Experimental auto-staff gate (default on) — gates the team-sizing rule
+     *  in the orchestrator's startup prompt. */
+    getAutostaffEnabled?: () => boolean;
 }
-export declare const createAgentRunStarter: ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, }: AgentRunStarterInput) => (workspace: WorkspaceSummary, agentId: string, config: AgentLaunchConfigInput, hivePort: string) => Promise<LiveAgentRun>;
+export declare const createAgentRunStarter: ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getWorkflowsEnabled, getAutostaffEnabled, }: AgentRunStarterInput) => (workspace: WorkspaceSummary, agentId: string, config: AgentLaunchConfigInput, hivePort: string) => Promise<LiveAgentRun>;
 export {};

package/dist/src/server/agent-run-starter.js

@@ -2,7 +2,7 @@ import { buildAgentRunBootstrap, startAgentRunCapture } from './agent-run-bootst
 import { handleAgentRunExit } from './agent-run-exit-handler.js';
 import { buildAgentStartupInstructions } from './agent-startup-instructions.js';
 import { createPostStartInputWriter, isInteractiveAgentCommand } from './post-start-input-writer.js';
-export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, }) => async (workspace, agentId, config, hivePort) => {
+export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, store, sessionStore, tokenRegistry, getCommandPreset, getAgent, restartPolicy, getWorkflowsEnabled, getAutostaffEnabled, }) => async (workspace, agentId, config, hivePort) => {
     if (!agentManager)
         throw new Error('Agent manager is required to start agents');
     const agent = getAgent?.(workspace.id, agentId);
@@ -99,7 +99,14 @@ export const createAgentRunStarter = ({ agentManager, registry, onAgentExit, sto
                 !injectedRestartMessage &&
                 agent &&
                 isInteractiveAgentCommand(startConfig.interactiveCommand ?? startConfig.command)) {
-                postStartWriter(run.runId, buildAgentStartupInstructions({ agent, workspace }));
+                void postStartWriter(run.runId, buildAgentStartupInstructions({
+                    agent,
+                    workspace,
+                    workflowsEnabled: getWorkflowsEnabled?.() ?? false,
+                    autostaffEnabled: getAutostaffEnabled?.() ?? false,
+                })).catch(() => {
+                    // The agent may have exited before post-start guidance could be written.
+                });
             }
         }
         catch {

package/dist/src/server/agent-run-store.d.ts

@@ -27,7 +27,7 @@ export declare const createAgentRunStore: (db: Database) => {
         runId: string;
         agentId: string;
         pid: number | null;
-        status: "error" | "starting" | "running" | "exited";
+        status: "starting" | "running" | "exited" | "error";
         exitCode: number | null;
         startedAt: number;
         endedAt: number | null;

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

@@ -1,4 +1,5 @@
 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 AGENT_RUNTIME_CLOSE_TIMEOUT_MS = 5000;
 export declare const closeAgentRuntime: (agentManager: AgentManager | undefined, registry: LiveRunRegistry, syncRun: (run: LiveAgentRun) => LiveAgentRun) => Promise<void>;

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

@@ -1,10 +1,34 @@
+export const AGENT_RUNTIME_CLOSE_TIMEOUT_MS = 5000;
+const waitForExitEntries = async (entries, timeoutMs = AGENT_RUNTIME_CLOSE_TIMEOUT_MS) => {
+    if (entries.length === 0)
+        return;
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        const result = await Promise.race([
+            Promise.all(entries.map((entry) => entry.promise)).then(() => 'done'),
+            timeout,
+        ]);
+        if (result === 'timeout') {
+            const runIds = entries.map((entry) => entry.runId).join(', ');
+            console.error(`[hive] timed out waiting for agent exit during shutdown: ${runIds}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+};
 export const closeAgentRuntime = async (agentManager, registry, syncRun) => {
     const runs = registry.list();
     for (const run of runs) {
         syncRun(run);
         agentManager?.stopRun(run.runId);
     }
-    await Promise.all(registry.listExitEntries().map((entry) => entry.promise));
+    await waitForExitEntries(registry.listExitEntries());
     for (const run of registry.list()) {
         agentManager?.removeRun(run.runId);
         registry.remove(run.runId);

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

@@ -28,10 +28,11 @@ export interface AgentRuntime {
     writeStatusPrompt: (workspaceId: string, workerName: string, workerId: 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;
+    writeSystemMessageToAgent: (workspaceId: string, agentId: string, text: string) => void;
 }
 export type { StartAgentOptions };

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

@@ -4,5 +4,5 @@ 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 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, getWorkflowsEnabled?: () => boolean, getAutostaffEnabled?: () => boolean) => 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, getWorkflowsEnabled, getAutostaffEnabled) => {
     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,
+        ...(getWorkflowsEnabled ? { getWorkflowsEnabled } : {}),
     });
     const startLiveRun = createAgentRunStarter({
         agentManager,
@@ -40,6 +41,8 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         getCommandPreset,
         getAgent,
         restartPolicy,
+        ...(getWorkflowsEnabled ? { getWorkflowsEnabled } : {}),
+        ...(getAutostaffEnabled ? { getAutostaffEnabled } : {}),
     });
     return {
         async close() {
@@ -113,7 +116,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 +124,8 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         writeUserInputPrompt(workspaceId, text) {
             stdinDispatcher.writeUserInputPrompt(workspaceId, text);
         },
+        writeSystemMessageToAgent(workspaceId, agentId, text) {
+            stdinDispatcher.writeSystemMessageToAgent(workspaceId, agentId, text);
+        },
     };
 };

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

@@ -7,7 +7,14 @@ export declare const buildAgentLegacyIdentityMarker: ({ agent, workspace, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
 }) => string;
-export declare const buildAgentStartupInstructions: ({ agent, workspace, }: {
+export declare const buildAgentStartupInstructions: ({ agent, workspace, workflowsEnabled, autostaffEnabled, }: {
     agent: AgentSummary;
     workspace: WorkspaceSummary;
+    /** Experimental workflow gate. When off, the startup prompt omits the
+     *  `team workflow` command + the workflow-authoring rule so a fresh
+     *  orchestrator isn't told to run a command the runtime rejects. */
+    workflowsEnabled?: boolean;
+    /** Experimental auto-staff gate (default on). When on, the orchestrator is
+     *  told it may size the team to the task up front. */
+    autostaffEnabled?: boolean;
 }) => string;

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

@@ -1,25 +1,31 @@
 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, workflowsEnabled = false, autostaffEnabled = false, }) => {
     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, workflowsEnabled, autostaffEnabled));
     }
     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 特殊字符 / heredoc）一律走 `--stdin`，并用 *quoted* heredoc（`<<'EOF'`）防止 shell 展开 $vars / 反引号 / 命令替换：", "  例：`team report --stdin --dispatch <id> <<'EOF'`", '       `... 长报告（含 $VAR、`backtick`、"引号" 都按字面量保留）...`', '       `EOF`', '- 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, workflowsEnabled, autostaffEnabled));
     }
-    lines.push('');
+    lines.push('', '</hive-message>', '');
     return lines.join('\n');
 };

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

@@ -8,23 +8,30 @@ interface AgentStdinDispatcherInput {
     getWorkspaceId: (agentId: string) => string | undefined;
     registry: LiveRunRegistry;
     syncRun: (run: LiveAgentRun) => LiveAgentRun;
+    /** Whether the experimental workflow feature is on. Controls whether the
+     *  orchestrator reminder tail mentions `team workflow`. Defaults to off. */
+    getWorkflowsEnabled?: () => boolean;
 }
-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[], workflowsEnabled?: boolean) => string;
+export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], workflowsEnabled?: boolean) => string;
+export declare const buildOrchestratorUserInputPayload: (text: string, workflowsEnabled?: boolean) => 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, getWorkflowsEnabled, }: 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;
 };
 export {};

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

@@ -1,91 +1,180 @@
-import { buildWorkerReminderTail, ORCHESTRATOR_REMINDER_TAIL } from './hive-team-guidance.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, workflowsEnabled = false) => {
+    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(workflowsEnabled), '');
     return lines.join('\n');
 };
-export const buildOrchestratorStatusPayload = (workerName, text, artifacts) => {
-    const lines = [`[Hive 系统消息：来自 @${workerName} 的状态更新]`, text];
+export const buildOrchestratorStatusPayload = (workerName, text, artifacts, workflowsEnabled = false) => {
+    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(workflowsEnabled), '');
     return lines.join('\n');
 };
-export const buildOrchestratorUserInputPayload = (text) => [text, '', ORCHESTRATOR_REMINDER_TAIL, ''].join('\n');
+export const buildOrchestratorUserInputPayload = (text, workflowsEnabled = false) => [text, '', buildOrchestratorReminderTail(workflowsEnabled), ''].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, getWorkflowsEnabled, }) => {
+    const workflowsEnabled = () => getWorkflowsEnabled?.() ?? false;
+    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, workflowsEnabled()), 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, workflowsEnabled()), 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, workflowsEnabled())));
+        },
+        /** 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));
         },
     };
 };

package/dist/src/server/app.d.ts

@@ -15,5 +15,6 @@ interface CreateAppOptions {
 export declare const createApp: ({ store, pickFolderService, openWorkspaceService, packageVersionReader, tasksFileService, versionService, }: CreateAppOptions) => {
     server: import("http").Server<typeof IncomingMessage, typeof ServerResponse>;
     store: RuntimeStore;
+    closeWebSockets: () => void;
 };
 export type { CreateAppOptions };

package/dist/src/server/app.js

@@ -196,6 +196,16 @@ export const createApp = ({ store, pickFolderService = pickFolder, openWorkspace
             sendJson(response, 500, { error: message });
         }
     });
-    createTerminalWebSocketServer(server, store, tasksFileService);
-    return { server, store };
+    const wsServer = createTerminalWebSocketServer(server, store, tasksFileService);
+    return {
+        server,
+        store,
+        // Tear-down for the WebSocket layer. Callers must invoke this
+        // BEFORE awaiting `server.close()` if they want a prompt return:
+        // `server.close()` waits on every existing socket, and Node's
+        // `closeAllConnections()` does NOT terminate already-upgraded
+        // WebSocket clients. Without this hook a Ctrl+C in the Hive
+        // runtime hangs as long as any browser tab is connected.
+        closeWebSockets: wsServer.close,
+    };
 };

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)}`);
+    }
+};