@tt-a1i/hive 1.4.4 → 1.5.0

package/dist/src/server/agent-manager-support.d.ts

@@ -2,7 +2,7 @@ import type { IPty } from 'node-pty';
 import type { AgentRunRecord, AgentRunSnapshot } from './agent-manager.js';
 import type { PtyOutputBus } from './pty-output-bus.js';
 export declare const MAX_RUN_OUTPUT_LENGTH = 1000000;
-type ExecRunner = (cmd: string, args: readonly string[]) => void;
+type ExecRunner = (cmd: string, args: readonly string[], done: (success: boolean) => void) => void;
 /**
  * Windows analogue of POSIX `process.kill(-pgid, SIGKILL)`. node-pty on
  * Windows hands `pty.kill()` to TerminateProcess against the PTY's main
@@ -28,7 +28,7 @@ type ExecRunner = (cmd: string, args: readonly string[]) => void;
  * Exported for unit testing — the `runner` parameter lets tests assert
  * the exact argv without mocking node:child_process.
  */
-export declare const taskkillProcessTree: (pid: number, platform?: NodeJS.Platform, runner?: ExecRunner) => boolean;
+export declare const taskkillProcessTree: (pid: number, platform?: NodeJS.Platform, runner?: ExecRunner, onFailure?: () => void) => boolean;
 export declare const toAgentRunSnapshot: (run: AgentRunRecord) => AgentRunSnapshot;
 export declare const finishAgentRun: (run: AgentRunRecord, exitCode: number | null, ptyOutputBus: PtyOutputBus) => void;
 export declare const attachAgentPty: (run: AgentRunRecord, pty: IPty, ptyOutputBus: PtyOutputBus) => void;

package/dist/src/server/agent-manager-support.js

@@ -1,8 +1,23 @@
-import { execFileSync } from 'node:child_process';
+import { execFile, execFileSync } from 'node:child_process';
 export const MAX_RUN_OUTPUT_LENGTH = 1_000_000;
 const FORCE_KILL_DELAY_MS = 750;
-const defaultExecRunner = (cmd, args) => {
-    execFileSync(cmd, [...args], { stdio: 'ignore', windowsHide: true });
+const TASKKILL_TIMEOUT_MS = 3000;
+const PTY_READ_EOF_EXIT_GRACE_MS = 1000;
+const isPtyReadEofError = (error) => {
+    const candidate = error;
+    return process.platform !== 'win32' && candidate?.code === 'EIO' && candidate.syscall === 'read';
+};
+const serializePtyInput = (input) => Buffer.isBuffer(input) ? input.toString('latin1') : input;
+const defaultExecRunner = (cmd, args, done) => {
+    let settled = false;
+    const settle = (success) => {
+        if (settled)
+            return;
+        settled = true;
+        done(success);
+    };
+    const child = execFile(cmd, [...args], { maxBuffer: 64 * 1024, timeout: TASKKILL_TIMEOUT_MS, windowsHide: true }, (error) => settle(!error));
+    child.once('error', () => settle(false));
 };
 /**
  * Windows analogue of POSIX `process.kill(-pgid, SIGKILL)`. node-pty on
@@ -29,11 +44,14 @@ const defaultExecRunner = (cmd, args) => {
  * Exported for unit testing — the `runner` parameter lets tests assert
  * the exact argv without mocking node:child_process.
  */
-export const taskkillProcessTree = (pid, platform = process.platform, runner = defaultExecRunner) => {
+export const taskkillProcessTree = (pid, platform = process.platform, runner = defaultExecRunner, onFailure) => {
     if (platform !== 'win32' || pid <= 0)
         return false;
     try {
-        runner('taskkill', ['/pid', String(pid), '/t', '/f']);
+        runner('taskkill', ['/pid', String(pid), '/t', '/f'], (success) => {
+            if (!success)
+                onFailure?.();
+        });
         return true;
     }
     catch {
@@ -61,6 +79,7 @@ export const finishAgentRun = (run, exitCode, ptyOutputBus) => {
 export const attachAgentPty = (run, pty, ptyOutputBus) => {
     let stdinClosed = false;
     let forceKillTimer;
+    let ptyReadEofTimer;
     const resolveProcessGroupId = () => {
         if (process.platform === 'win32' || pty.pid <= 0)
             return null;
@@ -99,26 +118,29 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
             ignoreBestEffortGroupKillError(error);
         }
     };
-    const killPty = (signal) => {
+    const killPtyDirect = (signal) => {
         try {
-            if (process.platform === 'win32') {
-                // taskkill /pid <pid> /t /f walks the parent's process tree
-                // BEFORE terminating it — so we have to run it while the parent
-                // is still alive. Calling pty.kill() first (the previous
-                // ordering) detaches the children: taskkill /T then fails with
-                // "process not found" and the npm-installs / build scripts
-                // become orphans. taskkill /f also terminates the parent, so
-                // pty.kill() is the fallback for the rare case where taskkill
-                // is missing from PATH or refused (e.g. restricted PowerShell).
-                if (!taskkillProcessTree(pty.pid))
-                    pty.kill();
-            }
-            else
-                pty.kill(signal);
+            pty.kill(signal);
         }
         catch (error) {
             ignoreMissingProcess(error);
         }
+    };
+    const killPty = (signal) => {
+        if (process.platform === 'win32') {
+            // taskkill /pid <pid> /t /f walks the parent's process tree
+            // BEFORE terminating it — so we have to run it while the parent
+            // is still alive. Calling pty.kill() first (the previous
+            // ordering) detaches the children: taskkill /T then fails with
+            // "process not found" and the npm-installs / build scripts
+            // become orphans. taskkill /f also terminates the parent, so
+            // pty.kill() is the fallback for the rare case where taskkill
+            // is missing from PATH or refused (e.g. restricted PowerShell).
+            if (!taskkillProcessTree(pty.pid, process.platform, defaultExecRunner, () => killPtyDirect()))
+                killPtyDirect();
+        }
+        else
+            killPtyDirect(signal);
         killProcessGroup(signal);
     };
     const clearForceKillTimer = () => {
@@ -127,8 +149,34 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
         clearTimeout(forceKillTimer);
         forceKillTimer = undefined;
     };
+    const clearPtyReadEofTimer = () => {
+        if (!ptyReadEofTimer)
+            return;
+        clearTimeout(ptyReadEofTimer);
+        ptyReadEofTimer = undefined;
+    };
+    const schedulePtyReadEofExitGuard = (error) => {
+        if (ptyReadEofTimer)
+            return;
+        ptyReadEofTimer = setTimeout(() => {
+            ptyReadEofTimer = undefined;
+            if (stopped())
+                return;
+            console.error(`[hive] PTY read EOF without exit for run ${run.runId}`, error);
+            finishAgentRun(run, null, ptyOutputBus);
+            try {
+                killPty('SIGTERM');
+                scheduleForceKill();
+            }
+            catch (killError) {
+                ignoreMissingProcess(killError);
+            }
+        }, PTY_READ_EOF_EXIT_GRACE_MS);
+        ptyReadEofTimer.unref?.();
+    };
     const cleanupProcessGroup = () => {
         clearForceKillTimer();
+        clearPtyReadEofTimer();
         killProcessGroup('SIGKILL');
     };
     const scheduleForceKill = () => {
@@ -141,11 +189,11 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
                     // Same ordering as killPty(): tree-kill before terminating the
                     // parent, so taskkill /T can still enumerate the process tree.
                     // pty.kill() is the fallback for taskkill-missing hosts.
-                    if (!taskkillProcessTree(pty.pid))
-                        pty.kill();
+                    if (!taskkillProcessTree(pty.pid, process.platform, defaultExecRunner, () => killPtyDirect()))
+                        killPtyDirect();
                 }
                 else
-                    pty.kill('SIGKILL');
+                    killPtyDirect('SIGKILL');
             }
             catch (error) {
                 ignoreMissingProcess(error);
@@ -163,6 +211,9 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
         },
         pid: pty.pid,
         resize(cols, rows) {
+            if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols <= 0 || rows <= 0) {
+                throw new Error(`Invalid terminal size for run: ${run.runId}`);
+            }
             pty.resize(cols, rows);
         },
         resume() {
@@ -173,6 +224,7 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
                 cleanupProcessGroup();
                 return;
             }
+            clearPtyReadEofTimer();
             killPty('SIGTERM');
             stdinClosed = true;
             scheduleForceKill();
@@ -181,7 +233,7 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
             if (stdinClosed || run.status === 'exited' || run.status === 'error') {
                 throw new Error(`PTY is not active for run: ${run.runId}`);
             }
-            pty.write(text);
+            pty.write(serializePtyInput(text));
         },
     };
     pty.onData((chunk) => {
@@ -192,8 +244,30 @@ export const attachAgentPty = (run, pty, ptyOutputBus) => {
             run.output = run.output.slice(-MAX_RUN_OUTPUT_LENGTH);
         ptyOutputBus.publish(run.runId, chunk);
     });
+    pty.on?.('error', (error) => {
+        if (stopped())
+            return;
+        if (isPtyReadEofError(error)) {
+            // Unix PTYs can surface a closed slave as read/EIO just before
+            // node-pty delivers the real onExit event. Treat it as EOF, not
+            // as the run's terminal status.
+            stdinClosed = true;
+            schedulePtyReadEofExitGuard(error);
+            return;
+        }
+        console.error(`[hive] PTY error for run ${run.runId}`, error);
+        stdinClosed = true;
+        finishAgentRun(run, null, ptyOutputBus);
+        try {
+            killPty('SIGTERM');
+        }
+        catch (killError) {
+            ignoreMissingProcess(killError);
+        }
+    });
     pty.onExit((event) => {
         stdinClosed = true;
+        clearPtyReadEofTimer();
         cleanupProcessGroup();
         finishAgentRun(run, event.exitCode, ptyOutputBus);
     });

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 特殊字符）一律走 `--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, 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 {};