@tt-a1i/hive 1.4.4 → 1.6.0

package/dist/src/server/tasks-file.d.ts

@@ -1,3 +1,5 @@
+import { type FeatureFlags } from './feature-flags.js';
+import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 interface TasksFileService {
     readTasks: (workspacePath: string) => string;
     writeTasks: (workspacePath: string, content: string) => void;
@@ -16,6 +18,6 @@ export declare const ensureTasksFile: (workspacePath: string) => string;
  * on every workspace open means a Hive version bump that changes the rules
  * propagates without manual intervention.
  */
-export declare const ensureProtocolFile: (workspacePath: string) => string;
+export declare const ensureProtocolFile: (workspacePath: string, cliPolicy?: WorkflowCliPolicy, flags?: FeatureFlags) => string;
 export declare const createTasksFileService: () => TasksFileService;
 export type { TasksFileService };

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

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { buildProtocolDoc } from './hive-team-guidance.js';
 export const HIVE_DIR_NAME = '.hive';
 export const TASKS_FILE_NAME = 'tasks.md';
@@ -9,18 +10,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 +51,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, flags = FEATURE_FLAGS_ALL_OFF) => {
     ensureTasksDir(workspacePath);
     const protocolFilePath = getProtocolFilePath(workspacePath);
-    const desired = buildProtocolDoc();
-    const current = existsSync(protocolFilePath) ? readFileSync(protocolFilePath, 'utf8') : null;
+    const desired = buildProtocolDoc(cliPolicy, flags);
+    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 +70,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' | 'next' | '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,14 @@
 import { ForbiddenError, UnauthorizedError } from './http-errors.js';
-const ORCHESTRATOR_COMMANDS = new Set(['send', 'list', 'cancel', 'help']);
+const ORCHESTRATOR_COMMANDS = new Set([
+    'send',
+    'list',
+    'next',
+    '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

@@ -2,14 +2,21 @@ 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 { ReportOutboxStore } from './report-outbox-store.js';
+import type { WebhookEvent } from './webhook-notifier.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;
@@ -30,11 +37,23 @@ export interface TeamOperationsInput {
         workspaceId: string;
     }) => DispatchRecord | undefined;
     markDispatchSubmitted: (dispatchId: string) => void;
+    reportOutbox: ReportOutboxStore;
+    /** Fire an outbound completion webhook (best-effort) when a worker reports. */
+    notifyWebhook?: (event: WebhookEvent) => 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[];
@@ -57,13 +76,14 @@ 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, reportOutbox, notifyWebhook, 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>;
+    drainReportOutbox: (workspaceId: string) => void;
     dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord & {
         restartedWorker: boolean;
     }>;

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

@@ -1,5 +1,7 @@
-import { ConflictError, PtyInactiveError } from './http-errors.js';
+import { buildOrchestratorReportPayload } from './agent-stdin-dispatcher.js';
+import { ConflictError } 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
@@ -23,7 +25,27 @@ export const formatUnknownWorkerError = (workerName, 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, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
+    // Best-effort redelivery of reports a prior orchestrator outage stranded.
+    // Called when a fresh report confirms the orchestrator is reachable and
+    // when the orchestrator polls `team list` (its natural post-restart wakeup).
+    // An entry is marked delivered only after its PTY write actually resolves,
+    // so a still-down orchestrator just leaves the backlog pending.
+    const drainReportOutbox = (workspaceId) => {
+        const orchestratorId = `${workspaceId}:orchestrator`;
+        if (!agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId))
+            return;
+        for (const entry of reportOutbox.listPending(workspaceId, orchestratorId)) {
+            void agentRuntime
+                .deliverSystemMessageToAgent(workspaceId, orchestratorId, entry.payload, {
+                requireActiveRun: true,
+            })
+                .then(() => reportOutbox.markDelivered(entry.id))
+                .catch((error) => {
+                console.error('[hive] swallowed:teamReport.outboxDrain', error);
+            });
+        }
+    };
     const ensureWorkerRun = async (workspaceId, workerId, hivePort) => {
         if (agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
             return;
@@ -45,10 +67,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,
@@ -57,18 +94,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);
@@ -104,6 +192,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             return { dispatch, forwardError, forwarded };
         },
         dispatchTask,
+        drainReportOutbox,
         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
@@ -164,14 +253,7 @@ 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}`);
             }
@@ -190,17 +272,102 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 workspaceStore.markTaskReported(workspaceId, workerId);
                 let forwardError = null;
                 let forwarded = false;
-                if (input.requireActiveRun === true) {
+                // 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 {
-                        agentRuntime.writeReportPrompt(workspaceId, worker.name, workerId, text, artifacts, {
-                            requireActiveRun: input.requireActiveRun,
+                        workflowDispatchAwaiter.notifyReport(dispatch.id, {
+                            artifacts,
+                            text,
+                            ...(status ? { status } : {}),
                         });
                         forwarded = true;
                     }
                     catch (error) {
                         forwardError = reportForwardErrorMessage(error);
-                        console.error('[hive] swallowed:teamReport.forward', error);
+                        console.error('[hive] swallowed:teamReport.workflowForward', error);
                     }
+                    return { dispatch, forwardError, forwarded };
+                }
+                // Real worker reported (not a workflow-internal step) — fire the
+                // outbound completion webhook. Best-effort; never blocks the report.
+                notifyWebhook?.({
+                    type: 'report_received',
+                    workspaceId,
+                    agentId: workerId,
+                    agentName: worker.name,
+                    summary: text.slice(0, 280),
+                    at: Date.now(),
+                });
+                if (input.requireActiveRun === true) {
+                    const orchestratorId = `${workspaceId}:orchestrator`;
+                    // A fresh report proves the orchestrator is reachable — flush any
+                    // backlog a prior outage stranded first, in arrival order, before
+                    // this one (both ride the dispatcher's per-agent serial queue).
+                    drainReportOutbox(workspaceId);
+                    const payload = buildOrchestratorReportPayload(worker.name, text, artifacts);
+                    if (agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
+                        try {
+                            const delivery = agentRuntime.deliverReportToOrchestrator(workspaceId, worker.name, text, artifacts, { requireActiveRun: true });
+                            forwarded = true;
+                            // The dispatch is already marked reported. If the PTY dies
+                            // mid-write the ledger would say "reported" while the
+                            // orchestrator never received it — persist for redelivery so it
+                            // isn't silently lost.
+                            void delivery.catch((error) => {
+                                console.error('[hive] swallowed:teamReport.forward', error);
+                                reportOutbox.enqueue({
+                                    workspaceId,
+                                    targetAgentId: orchestratorId,
+                                    dispatchId: dispatch.id,
+                                    payload,
+                                });
+                            });
+                        }
+                        catch (error) {
+                            // TOCTOU: orchestrator vanished between the active-run check and
+                            // the write. Same fix — queue it.
+                            console.error('[hive] swallowed:teamReport.forward', error);
+                            forwardError = reportForwardErrorMessage(error);
+                            reportOutbox.enqueue({
+                                workspaceId,
+                                targetAgentId: orchestratorId,
+                                dispatchId: dispatch.id,
+                                payload,
+                            });
+                        }
+                    }
+                    else {
+                        // Orchestrator is down. Queue the report instead of dropping it;
+                        // the CLI surfaces forwarded:false and the backlog drains on the
+                        // orchestrator's next `team list` after it restarts.
+                        forwardError = 'Orchestrator is not running; report queued for delivery.';
+                        reportOutbox.enqueue({
+                            workspaceId,
+                            targetAgentId: orchestratorId,
+                            dispatchId: dispatch.id,
+                            payload,
+                        });
+                    }
+                }
+                // 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 };
             }

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');