@tt-a1i/hive 1.4.4 → 1.6.0

package/dist/src/cli/team.js

@@ -1,5 +1,5 @@
-import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { sameFilesystemPath } from '../server/path-canonicalization.js';
 const REQUIRED_ENV_KEYS = [
     'HIVE_PORT',
     'HIVE_PROJECT_ID',
@@ -9,7 +9,15 @@ const REQUIRED_ENV_KEYS = [
 const TEAM_USAGE = [
     'Usage:',
     '  team list',
+    '  team next   (tasks in .hive/tasks.md that are unblocked now — those whose [needs: #n] deps are all done)',
     '  team send <worker-name> "<task>"',
+    '  team spawn <role> [--name <name>] [--cli <claude|codex|opencode|gemini>] [--ephemeral]',
+    '  team dismiss <worker-name>',
+    "  team workflow run --stdin [--args '<JSON>']   (script from stdin — for multi-line scripts)",
+    '  team workflow run --inline "<source>" [--args \'<JSON>\']',
+    '  team workflow stop <run-id>',
+    '  team workflow show <run-id>   (full per-agent transcript for one run)',
+    '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)',
     '  team cancel --dispatch <dispatch-id> "<reason>"',
     '  team report "<result>" [--dispatch <dispatch-id>] [--artifact <path>]',
     '  team report --stdin [--dispatch <dispatch-id>] [--artifact <path>]',
@@ -35,6 +43,15 @@ const getHiveEnv = () => {
     return values;
 };
 const getBaseUrl = (env) => `http://127.0.0.1:${env.HIVE_PORT}`;
+// Read `--flag value` from an argv slice; returns undefined when absent or
+// when the flag is the last token with no following value.
+const readFlag = (args, flag) => {
+    const index = args.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    return value && !value.startsWith('--') ? value : undefined;
+};
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const describeFetchError = (baseUrl, error) => {
     const cause = error instanceof Error && error.cause instanceof Error ? ` (${error.cause.message})` : '';
@@ -177,6 +194,20 @@ export const parseCancelArgs = (args) => {
     }
     return { dispatchId, reason };
 };
+export const decodeStdinBuffer = (buffer) => {
+    if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+        return buffer.subarray(3).toString('utf8');
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xff && buffer[1] === 0xfe) {
+        return buffer.subarray(2).toString('utf16le');
+    }
+    if (buffer.length >= 2 && buffer[0] === 0xfe && buffer[1] === 0xff) {
+        const swapped = Buffer.from(buffer.subarray(2));
+        swapped.swap16();
+        return swapped.toString('utf16le');
+    }
+    return buffer.toString('utf8');
+};
 export const readStdinToString = async (command = 'report') => {
     if (process.stdin.isTTY) {
         throw new Error(withUsage('--stdin requires piped input, but stdin is a TTY. Did you forget to pipe content in?', command));
@@ -185,7 +216,7 @@ export const readStdinToString = async (command = 'report') => {
     for await (const chunk of process.stdin) {
         chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
     }
-    const content = Buffer.concat(chunks).toString('utf8');
+    const content = decodeStdinBuffer(Buffer.concat(chunks));
     if (!content.trim()) {
         throw new Error(withUsage('--stdin received empty input', command));
     }
@@ -213,6 +244,22 @@ export const runTeamCommand = async (argv) => {
         console.log(JSON.stringify(await response.json()));
         return;
     }
+    if (command === 'next') {
+        const env = getHiveEnv();
+        const baseUrl = getBaseUrl(env);
+        const response = await fetchRuntime(baseUrl, `/api/workspaces/${env.HIVE_PROJECT_ID}/tasks/next`, {
+            method: 'GET',
+            headers: {
+                'x-hive-agent-id': env.HIVE_AGENT_ID,
+                'x-hive-agent-token': env.HIVE_AGENT_TOKEN,
+            },
+        });
+        if (!response.ok) {
+            await throwHttpError(response);
+        }
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
     if (command === 'send') {
         const [workerName, ...taskParts] = args;
         const task = taskParts.join(' ').trim();
@@ -241,6 +288,172 @@ export const runTeamCommand = async (argv) => {
         console.log(JSON.stringify(payload));
         return;
     }
+    if (command === 'spawn') {
+        const role = args[0];
+        if (!role || role.startsWith('--')) {
+            throw new Error('Usage: team spawn <role> [--name <name>] [--cli <claude|codex|opencode|gemini>] [--ephemeral]\n' +
+                '  Default: persistent member (lives until you `team dismiss` it).\n' +
+                '  --ephemeral: auto-dismiss after the next dispatch report (one-shot worker).');
+        }
+        const name = readFlag(args, '--name');
+        const cli = readFlag(args, '--cli');
+        const ephemeral = args.includes('--ephemeral');
+        const env = getHiveEnv();
+        const response = await postJson(getBaseUrl(env), '/api/team/spawn', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            role,
+            ...(name ? { name } : {}),
+            ...(cli ? { cli } : {}),
+            ...(ephemeral ? { ephemeral: true } : {}),
+        });
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'dismiss') {
+        const workerName = args[0];
+        if (!workerName || workerName.startsWith('--')) {
+            throw new Error('Usage: team dismiss <worker-name>');
+        }
+        const env = getHiveEnv();
+        const response = await postJson(getBaseUrl(env), '/api/team/dismiss', {
+            project_id: env.HIVE_PROJECT_ID,
+            from_agent_id: env.HIVE_AGENT_ID,
+            token: env.HIVE_AGENT_TOKEN,
+            name: workerName,
+        });
+        console.log(JSON.stringify(await response.json()));
+        return;
+    }
+    if (command === 'workflow') {
+        const sub = args[0];
+        const rest = args.slice(1);
+        if (sub === 'run') {
+            const inlineFlag = rest.indexOf('--inline');
+            const stdinFlag = rest.includes('--stdin');
+            const name = readFlag(rest, '--name');
+            // TIER 2 #8 — `--args '<JSON>'` makes the script's `args` global a
+            // real value instead of always undefined. Parses lazily so a bad
+            // JSON gives a clear local error before the HTTP round-trip.
+            const rawArgs = readFlag(rest, '--args');
+            let parsedArgs;
+            if (rawArgs !== undefined) {
+                try {
+                    parsedArgs = JSON.parse(rawArgs);
+                }
+                catch (error) {
+                    throw new Error(`Usage: team workflow run … --args '<JSON>'\n  --args must be valid JSON; got: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            let source;
+            if (inlineFlag !== -1) {
+                const literal = rest[inlineFlag + 1];
+                if (!literal)
+                    throw new Error('Usage: team workflow run --inline "<script-source>"');
+                source = literal;
+            }
+            else if (stdinFlag) {
+                source = await readStdinToString('workflow run');
+            }
+            else {
+                throw new Error('Usage: team workflow run --stdin   |   team workflow run --inline "<script-source>"\n' +
+                    '  Pass workflow source via stdin (POSIX heredoc / `type x.ts |`) or as one inline arg.\n' +
+                    "  Optional: --args '<JSON>' makes the script's `args` global a real value.");
+            }
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/run', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                source,
+                ...(name ? { name } : {}),
+                ...(parsedArgs !== undefined ? { args: parsedArgs } : {}),
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'stop') {
+            const runId = rest[0];
+            if (!runId)
+                throw new Error('Usage: team workflow stop <run-id>');
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/stop', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: runId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'show') {
+            const runId = rest[0];
+            if (!runId)
+                throw new Error('Usage: team workflow show <run-id>');
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/show', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                run_id: runId,
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        if (sub === 'schedule') {
+            const usage = 'Usage: team workflow schedule --cron "<5-field cron>" --name <name> --stdin\n' +
+                '       team workflow schedule --cron "<cron>" --name <name> --inline "<source>" [--args \'<JSON>\']\n' +
+                '  Registers a recurring run. Source is persisted so cron can fire it with no orchestrator present.';
+            const inlineFlag = rest.indexOf('--inline');
+            const stdinFlag = rest.includes('--stdin');
+            const cron = readFlag(rest, '--cron');
+            const name = readFlag(rest, '--name');
+            if (!cron || !name)
+                throw new Error(usage);
+            const rawArgs = readFlag(rest, '--args');
+            let parsedArgs;
+            if (rawArgs !== undefined) {
+                try {
+                    parsedArgs = JSON.parse(rawArgs);
+                }
+                catch (error) {
+                    throw new Error(`Usage: team workflow schedule … --args '<JSON>'\n  --args must be valid JSON; got: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            let source;
+            if (inlineFlag !== -1) {
+                const literal = rest[inlineFlag + 1];
+                if (!literal)
+                    throw new Error(usage);
+                source = literal;
+            }
+            else if (stdinFlag) {
+                source = await readStdinToString('workflow schedule');
+            }
+            else {
+                throw new Error(usage);
+            }
+            const env = getHiveEnv();
+            const response = await postJson(getBaseUrl(env), '/api/team/workflow/schedule', {
+                project_id: env.HIVE_PROJECT_ID,
+                from_agent_id: env.HIVE_AGENT_ID,
+                token: env.HIVE_AGENT_TOKEN,
+                source,
+                name,
+                cron,
+                ...(parsedArgs !== undefined ? { args: parsedArgs } : {}),
+            });
+            console.log(JSON.stringify(await response.json()));
+            return;
+        }
+        throw new Error('Usage:\n' +
+            "  team workflow run --stdin [--args '<JSON>']     (read script from stdin)\n" +
+            '  team workflow run --inline "<source>" [--args ...]  (one-arg form)\n' +
+            '  team workflow stop <run-id>                     (cancel a running workflow)\n' +
+            '  team workflow show <run-id>                     (full per-agent transcript)\n' +
+            '  team workflow schedule --cron "<cron>" --name <n> --stdin   (register a recurring run)');
+    }
     if (command === 'cancel') {
         const cancel = parseCancelArgs(args);
         const env = getHiveEnv();
@@ -294,7 +507,7 @@ export const runTeamCommand = async (argv) => {
     throw new Error('Unsupported team command');
 };
 const isMainModule = process.argv[1]
-    ? fileURLToPath(import.meta.url) === realpathSync(process.argv[1])
+    ? sameFilesystemPath(fileURLToPath(import.meta.url), process.argv[1])
     : false;
 if (isMainModule) {
     void runTeamCommand(process.argv.slice(2)).catch((error) => {

package/dist/src/server/agent-command-resolver.js

@@ -1,5 +1,6 @@
 import { accessSync, constants } from 'node:fs';
 import { basename, delimiter, extname, isAbsolute, join } from 'node:path';
+import { buildCmdCallCommand } from './windows-command-line.js';
 const hasPathSeparator = (command) => command.includes('/') || command.includes('\\');
 const canExecute = (path, platform = process.platform) => {
     try {
@@ -54,28 +55,11 @@ const isWindowsBatchFile = (command) => {
     const extension = extname(command).toLowerCase();
     return extension === '.cmd' || extension === '.bat';
 };
-/**
- * cmd.exe-style escape: doubles inner `"` (cmd's only literal-quote idiom)
- * and only wraps in `"..."` when the token contains whitespace or a cmd
- * metachar. Plain alnum/path tokens stay unquoted, which is the form
- * cmd.exe parses most predictably.
- *
- * Crucially, we do NOT use the `\"` form that the previous implementation
- * used and that node-pty's `argsToCommandLine` produces: cmd doesn't honor
- * backslash-quote escapes in its own command-line parsing.
- */
-const escapeCmdToken = (value) => {
-    if (value.length === 0)
-        return '""';
-    const doubled = value.replace(/"/g, '""');
-    return /[\s"&<>|^()]/.test(value) ? `"${doubled}"` : doubled;
-};
 const buildWindowsBatchCommandLine = (command, args) => {
-    const tokens = [command, ...args].map(escapeCmdToken).join(' ');
     // `call` is cmd's built-in batch invocation; it handles quoted .cmd / .bat
     // paths reliably (this is the same pattern Node.js's child_process uses
     // internally on Windows since the CVE-2024-27980 fix).
-    return `/d /s /c call ${tokens}`;
+    return `/d /s /c ${buildCmdCallCommand(command, args)}`;
 };
 /**
  * Recognize the exact shape that `createStartupCommandLaunch` produces on
@@ -93,7 +77,7 @@ const isCmdExeShellLaunch = (resolvedCommand, args) => basename(resolvedCommand)
     args.length === 4 &&
     args[0] === '/d' &&
     args[1] === '/s' &&
-    args[2] === '/c';
+    (args[2] === '/c' || args[2] === '/k');
 export const resolveSpawnCommand = (command, cwd, env, args = [], platform = process.platform) => {
     const resolvedCommand = resolveCommandPath(command, cwd, env, platform);
     if (platform === 'win32' && isWindowsBatchFile(resolvedCommand)) {

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

@@ -6,6 +6,7 @@ import type { AgentSessionStorePort } from './agent-runtime-ports.js';
 import type { LiveAgentRun } from './agent-runtime-types.js';
 import type { AgentTokenRegistry } from './agent-tokens.js';
 import type { CommandPresetRecord } from './command-preset-store.js';
+import { type FeatureFlags } from './feature-flags.js';
 import type { LiveRunRegistry } from './live-run-registry.js';
 import type { RestartPolicy } from './restart-policy.js';
 interface AgentRunStarterInput {
@@ -18,6 +19,10 @@ interface AgentRunStarterInput {
     getCommandPreset: (id: string) => CommandPresetRecord | undefined;
     getAgent: ((workspaceId: string, agentId: string) => AgentSummary | undefined) | undefined;
     restartPolicy: RestartPolicy;
+    /** Resolves the live experimental flags for the orchestrator's startup
+     *  prompt (`workflowsEnabled` gates the `team workflow` line + authoring
+     *  rule; `autostaffEnabled` gates the team-sizing rule). */
+    getFlags?: () => FeatureFlags;
 }
-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, getFlags, }: AgentRunStarterInput) => (workspace: WorkspaceSummary, agentId: string, config: AgentLaunchConfigInput, hivePort: string) => Promise<LiveAgentRun>;
 export {};

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

@@ -1,8 +1,9 @@
 import { buildAgentRunBootstrap, startAgentRunCapture } from './agent-run-bootstrap.js';
 import { handleAgentRunExit } from './agent-run-exit-handler.js';
 import { buildAgentStartupInstructions } from './agent-startup-instructions.js';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.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, getFlags, }) => 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 +100,13 @@ 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,
+                    flags: getFlags?.() ?? FEATURE_FLAGS_ALL_OFF,
+                })).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,21 @@ 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;
+    /** Awaitable report delivery — rejects if the orchestrator PTY write fails,
+     *  so the caller can persist the report to the redelivery outbox. */
+    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 resolves. */
+    deliverSystemMessageToAgent: (workspaceId: string, agentId: string, text: string, input?: {
+        requireActiveRun?: boolean;
+    }) => Promise<void>;
 }
 export type { StartAgentOptions };