@tt-a1i/hive 2.0.1 → 2.1.0

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

@@ -1,6 +1,9 @@
 import { buildOrchestratorReportPayload } from './agent-stdin-dispatcher.js';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
+import { escapeHiveEnvelopeText } from './hive-envelope-escape.js';
 import { ConflictError } from './http-errors.js';
 import { createReportMessage, createSendMessage, createStatusMessage, createUserInputMessage, } from './runtime-message-builders.js';
+import { assertWorkerDispatchable } from './team-authz.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
@@ -14,7 +17,7 @@ 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.',
+            'Run `team spawn <role> [--name <name>] [--ephemeral]`, then `team list` and retry with the spawned worker name. Do not ask the user to add workers unless a real role decision is missing.',
         ].join('\n');
     }
     const lines = roster.map((entry) => `  - ${entry.name} (${entry.role}, ${entry.status}, ${entry.pendingTaskCount} pending)`);
@@ -24,12 +27,30 @@ export const formatUnknownWorkerError = (workerName, roster) => {
         'Retry with `team send "<one of the names above>" "<task>"`, or run `team list` to refresh the roster.',
     ].join('\n');
 };
+/* Worker-facing 409 for `team report`. The same generic "no open dispatch"
+   used to cover two very different states: (a) the worker passed a --dispatch
+   id that is wrong or already closed while OTHER dispatches are still open —
+   recoverable in one retry if we list the real ids; (b) the worker truly has
+   nothing open — the right move is `team status`, not a report retry loop. */
+export const formatNoOpenDispatchError = (workerName, requestedDispatchId, openDispatches) => {
+    if (requestedDispatchId !== undefined && openDispatches.length > 0) {
+        const lines = openDispatches.map((dispatch) => `  - ${dispatch.id} (${dispatch.status}): ${dispatch.text.slice(0, 60)}${dispatch.text.length > 60 ? '…' : ''}`);
+        return [
+            `Dispatch ${requestedDispatchId} is not open for worker ${workerName}. Your open dispatches:`,
+            ...lines,
+            'Re-run `team report --dispatch <one of the ids above>`, or omit --dispatch to close the oldest.',
+        ].join('\n');
+    }
+    return (`No open dispatch for worker: ${workerName}. Nothing is awaiting your report — ` +
+        'if you have progress or standby info to share, use `team status "<state>"` instead.');
+};
 const reportForwardErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 const buildPendingWarning = (workerName, pendingTaskCount, action) => pendingTaskCount > 0
     ? `Hive recorded the ${action}, but ${workerName} still has ${pendingTaskCount} open dispatch${pendingTaskCount === 1 ? '' : 'es'}. ` +
         'A worker stays working until every dispatch is closed with `team report --dispatch <id>` or `team cancel --dispatch <id>`.'
     : undefined;
-export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, markDispatchSubmitted, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
+export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, listOpenWorkspaceDispatches, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, claimQueuedDispatch, reparkClaimedDispatch, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, recordProtocolEvent, getFlags, }) => {
+    const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
     // 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).
@@ -71,7 +92,10 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             throw error;
         }
     };
-    const cancelUndeliveredDispatch = (workspaceId, workerId, dispatchId, reason, workflowRunId) => {
+    const cancelUndeliveredDispatch = (workspaceId, workerId, dispatchId, reason, workflowRunId, 
+    /** Non-workflow issuer to notify — without this the orchestrator already
+     *  holds an ok:true for a dispatch that silently died (audit #34). */
+    notifyAgentId) => {
         const cancelled = markDispatchCancelled({ dispatchId, reason, workspaceId });
         if (!cancelled)
             return;
@@ -84,11 +108,141 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         if (workflowRunId !== undefined) {
             workflowDispatchAwaiter.notifyCancel(dispatchId, reason);
         }
+        if (notifyAgentId !== undefined) {
+            notifyIssuerDurably(workspaceId, notifyAgentId, dispatchId, `Dispatch ${dispatchId} to @${workerNameOrId(workspaceId, workerId)} was CANCELLED: delivery failed (${reason}). ` +
+                'The worker likely exited before receiving it — re-send after the worker is started, or dispatch to another worker.');
+        }
+    };
+    const workerNameOrId = (workspaceId, workerId) => {
+        try {
+            return workspaceStore.getWorker(workspaceId, workerId).name;
+        }
+        catch {
+            // Worker row already gone (e.g. dismissed) — fall back to the id.
+            return workerId;
+        }
+    };
+    /** Issuer notification that survives the issuer being down: try the live
+     *  PTY first; if the issuer has no active run (or the write rejects), park
+     *  the notice in the report outbox — it drains on the issuer's next
+     *  `team list` / start, the same redelivery path worker reports use.
+     *  (A fire-and-forget writeSystemMessageToAgent silently no-ops without an
+     *  active run, which is exactly when failures cluster — post-restart.) */
+    const notifyIssuerDurably = (workspaceId, issuerAgentId, dispatchId, text) => {
+        const payload = `<hive-system-reminder>\n${escapeHiveEnvelopeText(text)}\n</hive-system-reminder>\n`;
+        const park = () => {
+            try {
+                reportOutbox.enqueue({
+                    workspaceId,
+                    targetAgentId: issuerAgentId,
+                    dispatchId,
+                    payload,
+                });
+            }
+            catch (error) {
+                console.error('[hive] swallowed:teamDispatch.notifyOutbox', error);
+            }
+        };
+        try {
+            agentRuntime
+                .deliverSystemMessageToAgent(workspaceId, issuerAgentId, payload, {
+                requireActiveRun: true,
+            })
+                .catch(park);
+        }
+        catch {
+            park();
+        }
+    };
+    /** Called before a worker (and its dispatch rows) are deleted: open
+     *  non-workflow dispatches would otherwise vanish without the issuer ever
+     *  hearing — a third silent outcome next to delivered/cancelled. */
+    const notifyIssuersOfDroppedDispatches = (workspaceId, workerId, reason) => {
+        let open;
+        try {
+            open = listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId &&
+                item.workflowRunId === null &&
+                item.fromAgentId !== null &&
+                item.fromAgentId !== getWorkflowAgentId(workspaceId));
+        }
+        catch (error) {
+            console.error('[hive] swallowed:teamDismiss.listOpen', error);
+            return;
+        }
+        const workerName = workerNameOrId(workspaceId, workerId);
+        for (const item of open) {
+            if (!item.fromAgentId)
+                continue;
+            notifyIssuerDurably(workspaceId, item.fromAgentId, item.id, `Dispatch ${item.id} to @${workerName} was DROPPED: ${reason}. ` +
+                'It will not run and cannot be reported — re-dispatch the task to another worker if it still matters.');
+        }
+    };
+    /** #33: deliver dispatches parked while their worker was stopped. Called on
+     *  worker run start (lifecycle) and after dispatchTask auto-starts a worker.
+     *  `claimQueuedDispatch` makes each delivery single-shot under races (UI
+     *  start vs auto-start send); failures compensate via
+     *  cancelUndeliveredDispatch and notify the issuer. Workflow dispatches are
+     *  excluded — the runner owns their lifecycle and its awaiters must not see
+     *  a late delivery after the run already ended. */
+    const replayQueuedDispatches = (workspaceId, workerId, options = {}) => {
+        if (!agentRuntime.getActiveRunByAgentId(workspaceId, workerId))
+            return;
+        const queued = listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId &&
+            item.status === 'queued' &&
+            item.workflowRunId === null &&
+            item.fromAgentId !== getWorkflowAgentId(workspaceId) &&
+            item.id !== options.excludeDispatchId);
+        if (queued.length === 0)
+            return;
+        let worker;
+        try {
+            worker = workspaceStore.getWorker(workspaceId, workerId);
+        }
+        catch {
+            return;
+        }
+        /* A replay write only fails when the fresh run is already dead
+           (PtyInactive) — nothing reached a live CLI, so the dispatch goes BACK
+           to parked for the next start instead of being cancelled: one bad start
+           must not destroy parked work. If the row is no longer 'submitted'
+           (reported/cancelled meanwhile), the repark loses and we leave it be. */
+        const failDispatch = (dispatchId, error) => {
+            try {
+                if (!reparkClaimedDispatch(dispatchId)) {
+                    console.error('[hive] swallowed:teamReplay.reparkLost', dispatchId);
+                }
+            }
+            catch (reparkError) {
+                console.error('[hive] swallowed:teamReplay.repark', reparkError);
+            }
+            console.error('[hive] swallowed:teamReplay.writePrompt', error);
+        };
+        for (const item of queued) {
+            if (!claimQueuedDispatch(item.id))
+                continue;
+            let senderName = 'Orchestrator';
+            if (item.fromAgentId) {
+                try {
+                    senderName = workspaceStore.getAgent(workspaceId, item.fromAgentId).name;
+                }
+                catch {
+                    // Issuer gone; the default label is still actionable for the worker.
+                }
+            }
+            try {
+                const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, item.id, senderName, worker.description, item.text);
+                void writePrompt.catch((error) => failDispatch(item.id, error));
+            }
+            catch (error) {
+                failDispatch(item.id, error);
+            }
+        }
     };
     const dispatchTask = async (workspaceId, workerId, text, input = {}) => {
         const fromAgentId = input.fromAgentId;
         const sender = fromAgentId ? workspaceStore.getAgent(workspaceId, fromAgentId) : undefined;
         const worker = workspaceStore.getWorker(workspaceId, workerId);
+        assertWorkerDispatchable(worker);
         const message = createSendMessage(workspaceId, workerId, text, input.fromAgentId);
         const messageHandle = insertMessage(message);
         let dispatch;
@@ -110,30 +264,57 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             if (input.label !== undefined)
                 dispatchInput.label = input.label;
             dispatch = createDispatch(dispatchInput);
+            recordProtocolEvent?.('send');
             const dispatchId = dispatch.id;
             if (fromAgentId && sender) {
                 const shouldAutoStartWorker = input.autoStartWorker !== false;
                 const hadActiveRun = Boolean(agentRuntime.getActiveRunByAgentId(workspaceId, workerId));
                 if (!hadActiveRun && shouldAutoStartWorker) {
                     await ensureWorkerRun(workspaceId, workerId, input.hivePort ?? '');
+                    // The fresh run may also have OLDER parked dispatches waiting —
+                    // deliver them ahead of this one. Claims keep delivery single-shot;
+                    // the current dispatch is claimed by this same path just below.
+                    replayQueuedDispatches(workspaceId, workerId, { excludeDispatchId: dispatchId });
                 }
                 if (!shouldAutoStartWorker && !agentRuntime.getActiveRunByAgentId(workspaceId, workerId)) {
                     workspaceStore.markTaskDispatched(workspaceId, workerId);
                     pendingMarked = true;
-                    return dispatch;
+                    // Parked for a stopped worker: replayQueuedDispatches delivers it on
+                    // the next worker start. Tag the record so the route/CLI can say so.
+                    return Object.assign(dispatch, { queuedForStoppedWorker: true });
                 }
                 const isWorkflowDispatch = input.workflowRunId !== undefined || input.fromAgentId === getWorkflowAgentId(workspaceId);
-                markDispatchSubmitted(dispatchId);
+                // Revalidate the worker before claiming: it may have been deleted
+                // while ensureWorkerRun was awaited (R2 hardening) — a vanished worker
+                // must not leave a claimed-but-undeliverable dispatch behind.
+                workspaceStore.getWorker(workspaceId, workerId);
+                // Claim (queued → submitted) instead of a blind mark: a UI-initiated
+                // start can replay-deliver this dispatch while ensureWorkerRun above
+                // was awaited — losing the claim means delivery is already owned.
+                const claimed = claimQueuedDispatch(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.
+                if (claimed)
+                    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, isWorkflowDispatch ? undefined : fromAgentId);
+                            }
+                            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);
+                            cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId, isWorkflowDispatch ? undefined : fromAgentId);
                         }
                         catch (cancelError) {
                             if (!isWorkflowDispatch)
@@ -141,19 +322,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         }
                         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);
@@ -193,6 +362,13 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                 throw new ConflictError(`No open dispatch: ${dispatchId}`);
             }
             workspaceStore.markTaskCancelled(workspaceId, dispatch.toAgentId);
+            recordProtocolEvent?.('cancel');
+            // A workflow-owned dispatch cancelled from outside the runner (e.g. an
+            // orchestrator that got hold of the id) must still resolve the runner's
+            // awaiter — otherwise the run wedges until its step timeout.
+            if (dispatch.workflowRunId !== null) {
+                workflowDispatchAwaiter.notifyCancel(dispatch.id, input.reason);
+            }
             let forwardError = null;
             let forwarded = false;
             try {
@@ -207,6 +383,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         },
         dispatchTask,
         drainReportOutbox,
+        replayQueuedDispatches,
+        notifyIssuersOfDroppedDispatches,
         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
@@ -238,6 +416,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             const artifacts = input.artifacts ?? [];
             const worker = workspaceStore.getWorker(workspaceId, workerId);
             const messageHandle = insertMessage(createStatusMessage(workspaceId, workerId, text, artifacts));
+            recordProtocolEvent?.('status');
             try {
                 let forwardError = null;
                 let forwarded = false;
@@ -273,7 +452,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             const worker = workspaceStore.getWorker(workspaceId, workerId);
             const openDispatch = findOpenDispatch(workspaceId, workerId, input.dispatchId);
             if (!openDispatch) {
-                throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
+                throw new ConflictError(formatNoOpenDispatchError(worker.name, input.dispatchId, listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId)));
             }
             const messageHandle = insertMessage(createReportMessage(workspaceId, workerId, text, status, artifacts));
             try {
@@ -285,9 +464,12 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     workspaceId,
                 });
                 if (!dispatch) {
-                    throw new ConflictError(`No open dispatch for worker: ${worker.name}`);
+                    // Post-race recheck: the dispatch closed between the precheck and
+                    // the ledger write — re-query so the 409 lists what is still open.
+                    throw new ConflictError(formatNoOpenDispatchError(worker.name, input.dispatchId, listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId)));
                 }
                 workspaceStore.markTaskReported(workspaceId, workerId);
+                recordProtocolEvent?.('report');
                 const remainingPendingTaskCount = workspaceStore.getWorker(workspaceId, workerId).pendingTaskCount;
                 let forwardError = null;
                 let forwarded = false;
@@ -331,7 +513,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     // 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);
+                    const payload = buildOrchestratorReportPayload(worker.name, text, artifacts, flags());
                     if (agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
                         try {
                             const delivery = agentRuntime.deliverReportToOrchestrator(workspaceId, worker.name, text, artifacts, { requireActiveRun: true });
@@ -376,14 +558,21 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                         });
                     }
                 }
-                // 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.
+                // M11: if this worker was spawned with `team spawn --ephemeral`, the
+                // report that closes its LAST open dispatch triggers auto-dismiss.
+                // Gating on remainingPendingTaskCount === 0 keeps the one-shot
+                // semantics for the normal single-dispatch case while not deleting
+                // still-queued dispatches un-reported when the orchestrator stacked
+                // several sends. (If the last dispatch closes via `team cancel`
+                // instead, the worker lingers until the orchestrator-exit cascade /
+                // boot cleanup collects it.) 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' &&
+                    remainingPendingTaskCount === 0 &&
                     dismissEphemeralWorker) {
                     queueMicrotask(() => {
                         try {

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

@@ -0,0 +1,10 @@
+import type { TeamListItem } from '../shared/types.js';
+import type { DispatchRecord } from './dispatch-ledger-store.js';
+export interface TeamRecapInput {
+    /** Recent dispatches, newest first (listRecentWorkspaceDispatches order). */
+    dispatches: DispatchRecord[];
+    now: number;
+    workers: TeamListItem[];
+    workspaceName: string;
+}
+export declare const buildTeamRecapMarkdown: (input: TeamRecapInput) => string;

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

@@ -0,0 +1,73 @@
+// Privacy note — recap vs. support bundle: dispatch label/phase/reportText are
+// workflow-authored free text (the first-party guidance even puts file paths
+// in labels). The shareable support bundle therefore reduces them to presence
+// flags (see action-center-summary.ts `includeTextEvidence === false`). The
+// recap is the opposite case on purpose: the user explicitly clicks "Copy
+// recap" to share their own team's progress, so the verbatim text IS the
+// product. Do not "sanitize" this output to match the bundle.
+const REPORT_PREVIEW_MAX = 200;
+/** Markdown table cells cannot contain raw pipes or newlines. */
+const tableCell = (text) => text.replace(/\s+/gu, ' ').trim().replace(/\|/gu, '\\|');
+const truncate = (text, max) => {
+    const normalized = text.replace(/\s+/gu, ' ').trim();
+    return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
+};
+const dispatchTimestamp = (dispatch) => dispatch.reportedAt ?? dispatch.submittedAt ?? dispatch.deliveredAt ?? dispatch.createdAt;
+const formatAge = (timestamp, now) => {
+    const seconds = Math.max(0, Math.floor((now - timestamp) / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h`;
+    return `${Math.floor(seconds / 86400)}d`;
+};
+export const buildTeamRecapMarkdown = (input) => {
+    const workersById = new Map(input.workers.map((worker) => [worker.id, worker]));
+    const workerName = (agentId) => workersById.get(agentId)?.name ?? agentId;
+    const lines = [];
+    lines.push(`# Team recap — ${input.workspaceName}`);
+    lines.push('');
+    lines.push(`Generated at ${new Date(input.now).toISOString()}`);
+    lines.push('');
+    lines.push('## Team');
+    lines.push('');
+    if (input.workers.length === 0) {
+        lines.push('_No team members._');
+    }
+    else {
+        for (const worker of input.workers) {
+            lines.push(`- **${worker.name}** — ${worker.role} · ${worker.status}`);
+        }
+    }
+    lines.push('');
+    lines.push('## Recent dispatches');
+    lines.push('');
+    if (input.dispatches.length === 0) {
+        lines.push('_No dispatches yet._');
+    }
+    else {
+        lines.push('| Label | Status | Worker | Age |');
+        lines.push('| --- | --- | --- | --- |');
+        for (const dispatch of input.dispatches) {
+            const label = dispatch.label ?? dispatch.phase ?? truncate(dispatch.text, 60);
+            const age = formatAge(dispatchTimestamp(dispatch), input.now);
+            lines.push(`| ${tableCell(label)} | ${dispatch.status} | ${tableCell(workerName(dispatch.toAgentId))} | ${age} |`);
+        }
+    }
+    lines.push('');
+    const reported = input.dispatches.filter((dispatch) => dispatch.status === 'reported' && dispatch.reportText);
+    if (reported.length > 0) {
+        lines.push('## Reports');
+        lines.push('');
+        for (const dispatch of reported) {
+            const heading = dispatch.label ?? dispatch.phase ?? workerName(dispatch.toAgentId);
+            lines.push(`### ${truncate(heading, 80)}`);
+            lines.push('');
+            lines.push(truncate(dispatch.reportText ?? '', REPORT_PREVIEW_MAX));
+            lines.push('');
+        }
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+};

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

@@ -1,4 +1,91 @@
-import { normalizeExecutableToken } from './startup-command-parser.js';
+import { getStartupCommandExecutable, normalizeExecutableToken } from './startup-command-parser.js';
+const PROFILE_BY_BRAND = {
+    codex: 'codex',
+    grok: 'grok',
+    opencode: 'opencode',
+};
+// Shells whose spawn shape wraps the real command line in their final
+// argument (`cmd /d /s /c <line>`, `zsh -lic <line>`). Legacy launch configs
+// persisted before interactiveCommand existed only have this shape, so the
+// profile must see through it or those rows degrade to 'default' forever.
+const SHELL_WRAPPERS = new Set(['bash', 'cmd', 'fish', 'ksh', 'powershell', 'pwsh', 'sh', 'zsh']);
+const NPX_WRAPPERS = new Set(['bunx', 'npx', 'pnpx']);
+const isCodexNpmEntrypoint = (arg) => {
+    if (!arg)
+        return false;
+    const normalized = arg.replace(/\\/gu, '/');
+    return /(?:^|\/)@openai\/codex\/bin\/codex\.js$/iu.test(normalized);
+};
+const brandFromToken = (token) => normalizeExecutableToken(token);
+const stripNpmScope = (pkg) => pkg.startsWith('@') ? (pkg.split('/').at(-1) ?? pkg) : pkg;
+const tokenizeCommandLine = (line) => line.match(/"[^"]*"|'[^']*'|[^\s'"]+/gu)?.map((token) => token.replace(/^["']|["']$/gu, '')) ?? [];
+/**
+ * Walk a token list and resolve the CLI brand of the command that will
+ * actually own the terminal, seeing through shell wrappers (skipping their
+ * flag tokens), npx-style runners, and `node <entrypoint>` launches.
+ */
+const profileFromTokens = (tokens) => {
+    let index = 0;
+    while (index < tokens.length) {
+        const executable = brandFromToken(tokens[index]);
+        if (!executable)
+            return undefined;
+        const direct = PROFILE_BY_BRAND[executable];
+        if (direct)
+            return direct;
+        if (SHELL_WRAPPERS.has(executable)) {
+            index += 1;
+            while (index < tokens.length && /^[-/]/u.test(tokens[index] ?? ''))
+                index += 1;
+            continue;
+        }
+        if (NPX_WRAPPERS.has(executable)) {
+            index += 1;
+            while (index < tokens.length && tokens[index]?.startsWith('-'))
+                index += 1;
+            const pkg = tokens[index];
+            if (!pkg)
+                return undefined;
+            const brand = brandFromToken(stripNpmScope(pkg));
+            return brand ? PROFILE_BY_BRAND[brand] : undefined;
+        }
+        if (executable === 'node') {
+            return tokens.slice(index + 1).some(isCodexNpmEntrypoint) ? 'codex' : undefined;
+        }
+        return undefined;
+    }
+    return undefined;
+};
+const profileFromCommandText = (text) => {
+    if (!text?.trim())
+        return undefined;
+    // Fast paths: the first (possibly quoted) token, and the whole text as one
+    // token — the latter covers unquoted Windows paths with spaces such as
+    // `C:\Program Files\nodejs\opencode.cmd`.
+    for (const candidate of [getStartupCommandExecutable(text), text]) {
+        const brand = brandFromToken(candidate ?? undefined);
+        const profile = brand ? PROFILE_BY_BRAND[brand] : undefined;
+        if (profile)
+            return profile;
+    }
+    return profileFromTokens(tokenizeCommandLine(text));
+};
+const profileFromSpawnArgs = (config) => {
+    const executable = brandFromToken(config.command);
+    if (!executable || !config.args?.length)
+        return undefined;
+    if (SHELL_WRAPPERS.has(executable)) {
+        // The wrapped command line rides in the shell's final argument.
+        return profileFromCommandText(config.args.at(-1));
+    }
+    if (NPX_WRAPPERS.has(executable)) {
+        return profileFromTokens([executable, ...config.args]);
+    }
+    if (executable === 'node') {
+        return config.args.some(isCodexNpmEntrypoint) ? 'codex' : undefined;
+    }
+    return undefined;
+};
 export const resolveTerminalInputProfile = (config) => {
     if (!config)
         return 'default';
@@ -8,10 +95,12 @@ export const resolveTerminalInputProfile = (config) => {
         return 'grok';
     if (config.commandPresetId === 'opencode')
         return 'opencode';
-    const executable = normalizeExecutableToken(config.interactiveCommand) ?? normalizeExecutableToken(config.command);
-    if (executable === 'codex')
+    if (config.sessionIdCapture?.source === 'codex_session_jsonl_dir')
         return 'codex';
-    if (executable === 'grok')
-        return 'grok';
-    return executable === 'opencode' ? 'opencode' : 'default';
+    if (config.sessionIdCapture?.source === 'opencode_session_db')
+        return 'opencode';
+    return (profileFromCommandText(config.interactiveCommand) ??
+        profileFromCommandText(config.command) ??
+        profileFromSpawnArgs(config) ??
+        'default');
 };

package/dist/src/server/upload-limits.d.ts

@@ -0,0 +1,2 @@
+export declare const WORKSPACE_UPLOAD_MAX_BYTES: number;
+export declare const WORKSPACE_UPLOAD_JSON_BODY_LIMIT_BYTES: number;

package/dist/src/server/upload-limits.js

@@ -0,0 +1,2 @@
+export const WORKSPACE_UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+export const WORKSPACE_UPLOAD_JSON_BODY_LIMIT_BYTES = 140 * 1024 * 1024;

package/dist/src/server/workflow-cli-policy.d.ts

@@ -12,8 +12,13 @@
  * unrestricted and defaults to `claude` — i.e. exactly the old behavior, so
  * upgrading without configuring anything changes nothing.
  */
-/** Canonical CLI set — mirrors the built-in command preset ids. The allowlist is a subset of these. */
-export declare const CANONICAL_WORKFLOW_CLIS: readonly ["claude", "codex", "opencode", "gemini", "hermes", "qwen", "agy", "cursor", "grok"];
+/**
+ * Canonical workflow-capable CLIs. This is intentionally narrower than every
+ * built-in command preset: editor/assistant presets that do not support the
+ * Hive worker report loop should not become workflow agent targets merely by
+ * existing in settings.
+ */
+export declare const CANONICAL_WORKFLOW_CLIS: readonly ["claude", "codex", "opencode", "gemini", "hermes", "qwen", "agy"];
 export type WorkflowCli = (typeof CANONICAL_WORKFLOW_CLIS)[number];
 export declare const WORKFLOW_CLI_POLICY_KEY = "workflow.cli-policy";
 export interface WorkflowCliPolicy {

package/dist/src/server/workflow-cli-policy.js

@@ -12,9 +12,21 @@
  * unrestricted and defaults to `claude` — i.e. exactly the old behavior, so
  * upgrading without configuring anything changes nothing.
  */
-import { BUILTIN_COMMAND_PRESET_IDS } from './command-preset-defaults.js';
-/** Canonical CLI set — mirrors the built-in command preset ids. The allowlist is a subset of these. */
-export const CANONICAL_WORKFLOW_CLIS = BUILTIN_COMMAND_PRESET_IDS;
+/**
+ * Canonical workflow-capable CLIs. This is intentionally narrower than every
+ * built-in command preset: editor/assistant presets that do not support the
+ * Hive worker report loop should not become workflow agent targets merely by
+ * existing in settings.
+ */
+export const CANONICAL_WORKFLOW_CLIS = [
+    'claude',
+    'codex',
+    'opencode',
+    'gemini',
+    'hermes',
+    'qwen',
+    'agy',
+];
 export const WORKFLOW_CLI_POLICY_KEY = 'workflow.cli-policy';
 export const DEFAULT_WORKFLOW_CLI_POLICY = {
     default: 'claude',

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

@@ -45,6 +45,7 @@ export declare const createWorkflowRunStore: (db: Database) => {
     updateRun: (id: string, input: UpdateRunInput) => void;
     getRun: (id: string) => WorkflowRunRecord | undefined;
     listWorkspaceRuns: (workspaceId: string) => WorkflowRunRecord[];
+    listChildRuns: (parentRunId: string) => WorkflowRunRecord[];
     markUnfinishedRunsInterrupted: () => void;
 };
 export {};