@tt-a1i/hive 1.4.3 → 1.5.0

package/dist/src/server/tasks-file.js

@@ -9,18 +9,39 @@ export const PROTOCOL_RELATIVE_PATH = `${HIVE_DIR_NAME}/${PROTOCOL_FILE_NAME}`;
 export const getTasksFilePath = (workspacePath) => join(workspacePath, HIVE_DIR_NAME, TASKS_FILE_NAME);
 export const getProtocolFilePath = (workspacePath) => join(workspacePath, HIVE_DIR_NAME, PROTOCOL_FILE_NAME);
 const getLegacyTasksFilePath = (workspacePath) => join(workspacePath, TASKS_FILE_NAME);
+const RETRYABLE_TASKS_FS_ERROR_CODES = new Set(['EACCES', 'EBUSY', 'EPERM']);
+const TASKS_FS_RETRY_DELAYS_MS = [20, 50, 100];
+const sleepSync = (ms) => {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+const runRetryableTasksFileOperation = (operation) => {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            const code = error?.code;
+            const delay = TASKS_FS_RETRY_DELAYS_MS[attempt];
+            if (!code || !RETRYABLE_TASKS_FS_ERROR_CODES.has(code) || delay === undefined)
+                throw error;
+            sleepSync(delay);
+        }
+    }
+};
 const ensureTasksDir = (workspacePath) => {
-    mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true });
+    runRetryableTasksFileOperation(() => mkdirSync(dirname(getTasksFilePath(workspacePath)), { recursive: true }));
 };
 export const ensureTasksFile = (workspacePath) => {
     ensureTasksDir(workspacePath);
     const tasksFilePath = getTasksFilePath(workspacePath);
     if (existsSync(tasksFilePath)) {
-        return readFileSync(tasksFilePath, 'utf8');
+        return runRetryableTasksFileOperation(() => readFileSync(tasksFilePath, 'utf8'));
     }
     const legacyTasksFilePath = getLegacyTasksFilePath(workspacePath);
-    const content = existsSync(legacyTasksFilePath) ? readFileSync(legacyTasksFilePath, 'utf8') : '';
-    writeFileSync(tasksFilePath, content, 'utf8');
+    const content = existsSync(legacyTasksFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(legacyTasksFilePath, 'utf8'))
+        : '';
+    runRetryableTasksFileOperation(() => writeFileSync(tasksFilePath, content, 'utf8'));
     return content;
 };
 /**
@@ -29,14 +50,16 @@ export const ensureTasksFile = (workspacePath) => {
  * on every workspace open means a Hive version bump that changes the rules
  * propagates without manual intervention.
  */
-export const ensureProtocolFile = (workspacePath) => {
+export const ensureProtocolFile = (workspacePath, cliPolicy, workflowsEnabled = false, autostaffEnabled = false) => {
     ensureTasksDir(workspacePath);
     const protocolFilePath = getProtocolFilePath(workspacePath);
-    const desired = buildProtocolDoc();
-    const current = existsSync(protocolFilePath) ? readFileSync(protocolFilePath, 'utf8') : null;
+    const desired = buildProtocolDoc(cliPolicy, workflowsEnabled, autostaffEnabled);
+    const current = existsSync(protocolFilePath)
+        ? runRetryableTasksFileOperation(() => readFileSync(protocolFilePath, 'utf8'))
+        : null;
     if (current === desired)
         return desired;
-    writeFileSync(protocolFilePath, desired, 'utf8');
+    runRetryableTasksFileOperation(() => writeFileSync(protocolFilePath, desired, 'utf8'));
     return desired;
 };
 export const createTasksFileService = () => {
@@ -46,7 +69,7 @@ export const createTasksFileService = () => {
         },
         writeTasks(workspacePath, content) {
             ensureTasksDir(workspacePath);
-            writeFileSync(getTasksFilePath(workspacePath), content, 'utf8');
+            runRetryableTasksFileOperation(() => writeFileSync(getTasksFilePath(workspacePath), content, 'utf8'));
         },
     };
 };

package/dist/src/server/tasks-websocket-server.js

@@ -1,17 +1,15 @@
 import { WebSocketServer } from 'ws';
 import { getLocalRequestRejection } from './local-request-guard.js';
 import { readCookie } from './ui-auth-helpers.js';
+import { attachRawSocketErrorHandler, attachWebSocketErrorHandler, attachWebSocketServerErrorHandler, rejectWebSocketUpgrade, sendWebSocketMessage, } from './websocket-upgrade-safety.js';
 const matchTasksPath = (pathname) => {
     const match = /^\/ws\/tasks\/(?<workspaceId>[^/]+)$/.exec(pathname);
     const workspaceId = match?.groups?.workspaceId;
     return workspaceId ? decodeURIComponent(workspaceId) : null;
 };
-const rejectUpgrade = (socket, status) => {
-    socket.write(`HTTP/1.1 ${status}\r\n\r\n`);
-    socket.destroy();
-};
 export const createTasksWebSocketServer = (server, store, tasksFileService) => {
     const wss = new WebSocketServer({ noServer: true });
+    attachWebSocketServerErrorHandler(wss, 'tasks');
     const socketsByWorkspaceId = new Map();
     const validateUpgradeSession = (request) => {
         const cookieHeader = Array.isArray(request.headers.cookie)
@@ -25,12 +23,13 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
         const workspaceId = matchTasksPath(url.pathname);
         if (!workspaceId)
             return;
+        const detachRawSocketErrorHandler = attachRawSocketErrorHandler(socket, 'tasks upgrade');
         if (getLocalRequestRejection(request)) {
-            rejectUpgrade(socket, '403 Forbidden');
+            rejectWebSocketUpgrade(socket, '403 Forbidden');
             return;
         }
         if (!validateUpgradeSession(request)) {
-            rejectUpgrade(socket, '401 Unauthorized');
+            rejectWebSocketUpgrade(socket, '401 Unauthorized');
             return;
         }
         let workspacePath = '';
@@ -38,10 +37,12 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
             workspacePath = store.getWorkspaceSnapshot(workspaceId).summary.path;
         }
         catch {
-            rejectUpgrade(socket, '404 Not Found');
+            rejectWebSocketUpgrade(socket, '404 Not Found');
             return;
         }
         wss.handleUpgrade(request, socket, head, (ws) => {
+            detachRawSocketErrorHandler();
+            attachWebSocketErrorHandler(ws, `tasks ${workspaceId}`);
             const sockets = socketsByWorkspaceId.get(workspaceId) ?? new Set();
             sockets.add(ws);
             socketsByWorkspaceId.set(workspaceId, sockets);
@@ -55,14 +56,14 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
                 if (ws.readyState !== ws.OPEN)
                     return;
                 try {
-                    ws.send(JSON.stringify({
+                    sendWebSocketMessage(ws, JSON.stringify({
                         type: 'tasks-snapshot',
                         content: tasksFileService.readTasks(workspacePath),
-                    }));
+                    }), `tasks ${workspaceId} snapshot`);
                 }
                 catch {
                     if (ws.readyState === ws.OPEN) {
-                        ws.send(JSON.stringify({ type: 'tasks-snapshot', content: '' }));
+                        sendWebSocketMessage(ws, JSON.stringify({ type: 'tasks-error', error: 'Failed to read tasks file' }), `tasks ${workspaceId} snapshot error`);
                     }
                 }
             });
@@ -72,7 +73,7 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
         close: () => {
             for (const sockets of socketsByWorkspaceId.values()) {
                 for (const socket of sockets)
-                    socket.close();
+                    socket.terminate();
             }
             socketsByWorkspaceId.clear();
             wss.close();
@@ -83,9 +84,7 @@ export const createTasksWebSocketServer = (server, store, tasksFileService) => {
                 return;
             const payload = JSON.stringify({ type: 'tasks-updated', content });
             for (const socket of sockets) {
-                if (socket.readyState === socket.OPEN) {
-                    socket.send(payload);
-                }
+                sendWebSocketMessage(socket, payload, `tasks ${workspaceId} publish`);
             }
         },
     };

package/dist/src/server/team-authz.d.ts

@@ -1,5 +1,5 @@
 import type { AgentSummary } from '../shared/types.js';
-export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'cancel' | 'help';
+export type TeamCommand = 'send' | 'list' | 'report' | 'status' | 'cancel' | 'help' | 'spawn' | 'dismiss' | 'workflow';
 export declare const commandAllowedForRole: (role: AgentSummary["role"], command: TeamCommand) => boolean;
 interface AuthenticateInput {
     fromAgentId: string | undefined;

package/dist/src/server/team-authz.js

@@ -1,5 +1,13 @@
 import { ForbiddenError, UnauthorizedError } from './http-errors.js';
-const ORCHESTRATOR_COMMANDS = new Set(['send', 'list', 'cancel', 'help']);
+const ORCHESTRATOR_COMMANDS = new Set([
+    'send',
+    'list',
+    'cancel',
+    'help',
+    'spawn',
+    'dismiss',
+    'workflow',
+]);
 const WORKER_COMMANDS = new Set(['report', 'status', 'help']);
 const WORKER_ROLES = new Set(['coder', 'reviewer', 'tester', 'custom']);
 export const commandAllowedForRole = (role, command) => {

package/dist/src/server/team-autostaff.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Auto-staff experimental feature gate.
+ *
+ * The orchestrator can already create workers (`team spawn`); auto-staff is a
+ * guidance layer that grants + encourages it to size the team to the task up
+ * front (e.g. 2 coders + 1 reviewer + 1 tester in one go) rather than adding
+ * workers one at a time. It's purely additive orchestrator guidance — no new
+ * execution path — so unlike workflows it ships ON by default; a user opts
+ * OUT from Settings.
+ *
+ * Stored GLOBALLY in `app_state` under AUTOSTAFF_ENABLED_KEY. Only the exact
+ * string "false" disables it; absent / anything else reads back as enabled.
+ */
+export declare const AUTOSTAFF_ENABLED_KEY = "team.autostaff";
+export declare const readAutostaffEnabled: (raw: string | null | undefined) => boolean;
+export declare const serializeAutostaffEnabled: (enabled: boolean) => string;

package/dist/src/server/team-autostaff.js

@@ -0,0 +1,16 @@
+/**
+ * Auto-staff experimental feature gate.
+ *
+ * The orchestrator can already create workers (`team spawn`); auto-staff is a
+ * guidance layer that grants + encourages it to size the team to the task up
+ * front (e.g. 2 coders + 1 reviewer + 1 tester in one go) rather than adding
+ * workers one at a time. It's purely additive orchestrator guidance — no new
+ * execution path — so unlike workflows it ships ON by default; a user opts
+ * OUT from Settings.
+ *
+ * Stored GLOBALLY in `app_state` under AUTOSTAFF_ENABLED_KEY. Only the exact
+ * string "false" disables it; absent / anything else reads back as enabled.
+ */
+export const AUTOSTAFF_ENABLED_KEY = 'team.autostaff';
+export const readAutostaffEnabled = (raw) => raw !== 'false';
+export const serializeAutostaffEnabled = (enabled) => (enabled ? 'true' : 'false');

package/dist/src/server/team-list-serializer.d.ts

@@ -1,2 +1,2 @@
 import type { TeamListItem, TeamListItemPayload } from '../shared/types.js';
-export declare const serializeTeamListItem: ({ commandPresetId, id, lastPtyLine, name, pendingTaskCount, role, status, }: TeamListItem) => TeamListItemPayload;
+export declare const serializeTeamListItem: ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }: TeamListItem) => TeamListItemPayload;

package/dist/src/server/team-list-serializer.js

@@ -1,4 +1,4 @@
-export const serializeTeamListItem = ({ commandPresetId, id, lastPtyLine, name, pendingTaskCount, role, status, }) => ({
+export const serializeTeamListItem = ({ commandPresetId, ephemeral, id, lastPtyLine, name, pendingTaskCount, role, spawnedBy, status, }) => ({
     id,
     name,
     role,
@@ -6,4 +6,6 @@ export const serializeTeamListItem = ({ commandPresetId, id, lastPtyLine, name,
     pending_task_count: pendingTaskCount,
     last_pty_line: lastPtyLine ?? null,
     command_preset_id: commandPresetId ?? null,
+    ...(ephemeral === true ? { ephemeral: true } : {}),
+    ...(spawnedBy ? { spawned_by: spawnedBy } : {}),
 });

package/dist/src/server/team-operations.d.ts

@@ -1,13 +1,20 @@
+import type { TeamListItem } from '../shared/types.js';
 import type { AgentRuntime } from './agent-runtime.js';
 import type { DispatchRecord } from './dispatch-ledger-store.js';
 import type { MessageLogHandle, MessageLogRecord } from './message-log-store.js';
+import type { WorkflowDispatchAwaiter } from './workflow-dispatch-awaiter.js';
 import type { WorkspaceStore } from './workspace-store.js';
+export declare const formatUnknownWorkerError: (workerName: string, roster: readonly TeamListItem[]) => string;
 export interface TeamOperationsInput {
     agentRuntime: AgentRuntime;
     createDispatch: (input: {
         fromAgentId?: string;
+        label?: string;
+        phase?: string;
+        stepIndex?: number;
         text: string;
         toAgentId: string;
+        workflowRunId?: string;
         workspaceId: string;
     }) => DispatchRecord;
     deleteDispatch: (dispatchId: string) => void;
@@ -28,11 +35,20 @@ export interface TeamOperationsInput {
         workspaceId: string;
     }) => DispatchRecord | undefined;
     markDispatchSubmitted: (dispatchId: string) => void;
+    workflowDispatchAwaiter: WorkflowDispatchAwaiter;
     workspaceStore: WorkspaceStore;
+    /** Auto-dismiss an ephemeral orchestrator-spawned worker after its
+     *  dispatch report. Wired in runtime-store-helpers to remove the worker
+     *  completely (stop run, drop launch config, drop the row). M11. */
+    dismissEphemeralWorker?: (workspaceId: string, workerId: string) => void;
 }
 export interface DispatchTaskInput {
     fromAgentId?: string;
     hivePort?: string;
+    workflowRunId?: string;
+    stepIndex?: number;
+    phase?: string;
+    label?: string;
 }
 export interface ReportTaskInput {
     artifacts?: string[];
@@ -55,14 +71,16 @@ export interface ReportTaskResult {
     forwardError: string | null;
     forwarded: boolean;
 }
-export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, workspaceStore, }: TeamOperationsInput) => {
+export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }: TeamOperationsInput) => {
     cancelTask(workspaceId: string, dispatchId: string, input: CancelTaskInput): {
         dispatch: DispatchRecord;
         forwardError: string | null;
         forwarded: boolean;
     };
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
-    dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord>;
+    dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord & {
+        restartedWorker: boolean;
+    }>;
     recordUserInput(workspaceId: string, orchestratorId: string, text: string): void;
     statusTask(workspaceId: string, workerId: string, input?: StatusTaskInput): {
         dispatch: null;

package/dist/src/server/team-operations.js

@@ -1,7 +1,30 @@
 import { ConflictError, PtyInactiveError } from './http-errors.js';
 import { createReportMessage, createSendMessage, createStatusMessage, createUserInputMessage, } from './runtime-message-builders.js';
+import { getWorkflowAgentId } from './workspace-store-support.js';
+/* Roster snapshot embedded in the 409 the orchestrator sees when it
+   dispatches to a missing name. Format prioritizes the orchestrator's
+   parsing path: bullet-per-member with role + live status + pending
+   count, plus an explicit retry hint that names both fix-up paths
+   (direct send to a listed name, or re-`team list` if it doubts the
+   snapshot). Keeping role/status/pending inline saves a follow-up
+   `team list` round-trip — the orchestrator can re-pick in the same
+   turn. */
+export const formatUnknownWorkerError = (workerName, roster) => {
+    if (roster.length === 0) {
+        return [
+            `Unknown worker "${workerName}": this workspace currently has no workers.`,
+            'Ask the user to add a worker in the Hive UI (Add Worker), then run `team list` and retry.',
+        ].join('\n');
+    }
+    const lines = roster.map((entry) => `  - ${entry.name} (${entry.role}, ${entry.status}, ${entry.pendingTaskCount} pending)`);
+    return [
+        `Unknown worker "${workerName}" in this workspace. Current members:`,
+        ...lines,
+        'Retry with `team send "<one of the names above>" "<task>"`, or run `team list` to refresh the roster.',
+    ].join('\n');
+};
 const reportForwardErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, workspaceStore, }) => {
+export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
     const ensureWorkerRun = async (workspaceId, workerId, hivePort) => {
         if (agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
             return;
@@ -23,10 +46,25 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             throw error;
         }
     };
+    const cancelUndeliveredDispatch = (workspaceId, workerId, dispatchId, reason, workflowRunId) => {
+        const cancelled = markDispatchCancelled({ dispatchId, reason, workspaceId });
+        if (!cancelled)
+            return;
+        try {
+            workspaceStore.markTaskCancelled(workspaceId, workerId);
+        }
+        catch (error) {
+            console.error('[hive] swallowed:teamDispatch.markTaskCancelled', error);
+        }
+        if (workflowRunId !== undefined) {
+            workflowDispatchAwaiter.notifyCancel(dispatchId, reason);
+        }
+    };
     const dispatchTask = async (workspaceId, workerId, text, input = {}) => {
         const message = createSendMessage(workspaceId, workerId, text, input.fromAgentId);
         const messageHandle = insertMessage(message);
         let dispatch;
+        let pendingMarked = false;
         try {
             const dispatchInput = {
                 text,
@@ -35,18 +73,69 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             };
             if (input.fromAgentId)
                 dispatchInput.fromAgentId = input.fromAgentId;
+            if (input.workflowRunId !== undefined)
+                dispatchInput.workflowRunId = input.workflowRunId;
+            if (input.stepIndex !== undefined)
+                dispatchInput.stepIndex = input.stepIndex;
+            if (input.phase !== undefined)
+                dispatchInput.phase = input.phase;
+            if (input.label !== undefined)
+                dispatchInput.label = input.label;
             dispatch = createDispatch(dispatchInput);
+            const dispatchId = dispatch.id;
             if (input.fromAgentId) {
                 const sender = workspaceStore.getAgent(workspaceId, input.fromAgentId);
                 await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
                 const worker = workspaceStore.getWorker(workspaceId, workerId);
-                markDispatchSubmitted(dispatch.id);
-                agentRuntime.writeSendPrompt(workspaceId, workerId, dispatch.id, sender.name, worker.description, text);
+                const isWorkflowDispatch = input.workflowRunId !== undefined || input.fromAgentId === getWorkflowAgentId(workspaceId);
+                markDispatchSubmitted(dispatchId);
+                workspaceStore.markTaskDispatched(workspaceId, workerId);
+                pendingMarked = true;
+                try {
+                    const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, dispatchId, sender.name, worker.description, text);
+                    void writePrompt.catch((error) => {
+                        // `team send` is intentionally asynchronous (§3.3). A worker that
+                        // exits during paste-submit did not receive actionable work, so
+                        // close the open dispatch instead of leaving a fake pending task.
+                        try {
+                            cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId);
+                        }
+                        catch (cancelError) {
+                            if (!isWorkflowDispatch)
+                                console.error('[hive] swallowed:teamDispatch.cancelUndelivered', cancelError);
+                        }
+                        if (!isWorkflowDispatch)
+                            console.error('[hive] swallowed:teamDispatch.writePrompt', error);
+                    });
+                }
+                catch (error) {
+                    try {
+                        cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId);
+                    }
+                    catch (cancelError) {
+                        if (!isWorkflowDispatch)
+                            console.error('[hive] swallowed:teamDispatch.cancelUndelivered', cancelError);
+                    }
+                    if (!isWorkflowDispatch)
+                        console.error('[hive] swallowed:teamDispatch.writePrompt', error);
+                }
+            }
+            else {
+                workspaceStore.markTaskDispatched(workspaceId, workerId);
+                pendingMarked = true;
             }
-            workspaceStore.markTaskDispatched(workspaceId, workerId);
             return dispatch;
         }
         catch (error) {
+            if (pendingMarked) {
+                try {
+                    workspaceStore.markTaskCancelled(workspaceId, workerId);
+                }
+                catch {
+                    // Best-effort compensation for the in-memory pending count; the
+                    // durable send message is deleted below.
+                }
+            }
             if (dispatch)
                 deleteDispatch(dispatch.id);
             deleteMessage(messageHandle);
@@ -82,9 +171,28 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             return { dispatch, forwardError, forwarded };
         },
         dispatchTask,
-        dispatchTaskByWorkerName(workspaceId, workerName, text, input = {}) {
-            const worker = workspaceStore.getWorkerByName(workspaceId, workerName);
-            return dispatchTask(workspaceId, worker.id, text, input);
+        async dispatchTaskByWorkerName(workspaceId, workerName, text, input = {}) {
+            /* Build the roster once so a missing-name path can surface it without
+               a second store call. We deliberately don't go through
+               `getWorkerByName` because its underlying record helper throws a
+               bare Error — that bubbles as HTTP 500 and looks like a server bug
+               to the orchestrator, instead of the self-healing 409 we want. */
+            const roster = workspaceStore.listWorkers(workspaceId);
+            const worker = roster.find((entry) => entry.name === workerName);
+            if (!worker) {
+                throw new ConflictError(formatUnknownWorkerError(workerName, roster));
+            }
+            /* Capture the active-run state *before* dispatchTask runs, because
+               dispatchTask calls ensureWorkerRun on authenticated team-send calls
+               and may silently auto-start a stopped worker. Surfacing
+               `restartedWorker=true` to the orchestrator turns that silent state
+               change into a transparent one. Internal calls without `fromAgentId`
+               only queue work and do not wake a PTY, so they must not report a
+               restart. */
+            const restartedWorker = input.fromAgentId !== undefined &&
+                !agentRuntime.getActiveRunByAgentId(workspaceId, worker.id);
+            const dispatch = await dispatchTask(workspaceId, worker.id, text, input);
+            return Object.assign(dispatch, { restartedWorker });
         },
         recordUserInput(workspaceId, orchestratorId, text) {
             workspaceStore.getAgent(workspaceId, orchestratorId);
@@ -123,17 +231,19 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             const status = input.status;
             const artifacts = input.artifacts ?? [];
             const worker = workspaceStore.getWorker(workspaceId, workerId);
-            if (input.requireActiveRun === true &&
-                !agentRuntime.getActiveRunByAgentId(workspaceId, `${workspaceId}:orchestrator`)) {
-                throw new PtyInactiveError(`No active run for agent: ${workspaceId}:orchestrator`);
-            }
             const openDispatch = findOpenDispatch(workspaceId, workerId, input.dispatchId);
-            if (!openDispatch && input.dispatchId) {
-                throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
-            }
             if (!openDispatch) {
                 throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
             }
+            const isWorkflowDispatch = openDispatch.fromAgentId === getWorkflowAgentId(workspaceId);
+            // Pre-check the orchestrator PTY only when the report is heading there.
+            // Workflow-sourced dispatches don't need an orchestrator: the runner
+            // is in-process and will resolve its awaiter directly.
+            if (input.requireActiveRun === true && !isWorkflowDispatch) {
+                if (!agentRuntime.getActiveRunByAgentId(workspaceId, `${workspaceId}:orchestrator`)) {
+                    throw new PtyInactiveError(`No active run for agent: ${workspaceId}:orchestrator`);
+                }
+            }
             const messageHandle = insertMessage(createReportMessage(workspaceId, workerId, text, status, artifacts));
             try {
                 const dispatch = markDispatchReportedByWorker({
@@ -149,6 +259,24 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 workspaceStore.markTaskReported(workspaceId, workerId);
                 let forwardError = null;
                 let forwarded = false;
+                // Workflow-sourced dispatches: the source is the in-process runner, not a
+                // PTY. Resolve its awaiting Promise instead of injecting into orchestrator
+                // stdin (which would do nothing — `__workflow__` has no PTY).
+                if (dispatch.fromAgentId === getWorkflowAgentId(workspaceId)) {
+                    try {
+                        workflowDispatchAwaiter.notifyReport(dispatch.id, {
+                            artifacts,
+                            text,
+                            ...(status ? { status } : {}),
+                        });
+                        forwarded = true;
+                    }
+                    catch (error) {
+                        forwardError = reportForwardErrorMessage(error);
+                        console.error('[hive] swallowed:teamReport.workflowForward', error);
+                    }
+                    return { dispatch, forwardError, forwarded };
+                }
                 if (input.requireActiveRun === true) {
                     try {
                         agentRuntime.writeReportPrompt(workspaceId, worker.name, workerId, text, artifacts, {
@@ -161,6 +289,24 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         console.error('[hive] swallowed:teamReport.forward', error);
                     }
                 }
+                // M11: if this worker was spawned with `team spawn --ephemeral`, this
+                // first successful report is its trigger to auto-dismiss. Deferred via
+                // queueMicrotask so the orchestrator's forward write lands BEFORE the
+                // worker's PTY is torn down (otherwise the inject + dismiss race).
+                // Skipped for workflow dispatches — workflow workers are managed by
+                // the runner's own finally block.
+                if (worker.ephemeral === true &&
+                    worker.spawnedBy === 'orchestrator' &&
+                    dismissEphemeralWorker) {
+                    queueMicrotask(() => {
+                        try {
+                            dismissEphemeralWorker(workspaceId, workerId);
+                        }
+                        catch (error) {
+                            console.error('[hive] swallowed:teamReport.ephemeralDismiss', error);
+                        }
+                    });
+                }
                 return { dispatch, forwardError, forwarded };
             }
             catch (error) {

package/dist/src/server/terminal-input-profile.js

@@ -1,15 +1,9 @@
-import { basename } from 'node:path';
-const normalizeExecutable = (value) => {
-    if (!value)
-        return null;
-    const normalized = basename(value).toLowerCase();
-    return normalized.replace(/\.(cmd|exe)$/u, '');
-};
+import { normalizeExecutableToken } from './startup-command-parser.js';
 export const resolveTerminalInputProfile = (config) => {
     if (!config)
         return 'default';
     if (config.commandPresetId === 'opencode')
         return 'opencode';
-    const executable = normalizeExecutable(config.interactiveCommand) ?? normalizeExecutable(config.command);
+    const executable = normalizeExecutableToken(config.interactiveCommand) ?? normalizeExecutableToken(config.command);
     return executable === 'opencode' ? 'opencode' : 'default';
 };

package/dist/src/server/terminal-protocol.js

@@ -14,7 +14,11 @@ export const parseTerminalControlMessage = (raw) => {
     }
     const resizeCols = asInteger(cols);
     const resizeRows = asInteger(rows);
-    if (parsed.type === 'resize' && resizeCols !== undefined && resizeRows !== undefined) {
+    if (parsed.type === 'resize' &&
+        resizeCols !== undefined &&
+        resizeRows !== undefined &&
+        resizeCols > 0 &&
+        resizeRows > 0) {
         const message = {
             type: 'resize',
             cols: resizeCols,
@@ -22,10 +26,12 @@ export const parseTerminalControlMessage = (raw) => {
         };
         const parsedPixelWidth = asInteger(pixelWidth);
         const parsedPixelHeight = asInteger(pixelHeight);
-        if (parsedPixelWidth !== undefined)
+        if (parsedPixelWidth !== undefined && parsedPixelWidth >= 0) {
             message.pixelWidth = parsedPixelWidth;
-        if (parsedPixelHeight !== undefined)
+        }
+        if (parsedPixelHeight !== undefined && parsedPixelHeight >= 0) {
             message.pixelHeight = parsedPixelHeight;
+        }
         return message;
     }
     throw new Error('Invalid terminal control message');