@tt-a1i/hive 1.5.0 → 1.7.0

package/dist/src/server/runtime-store-helpers.js

@@ -2,21 +2,22 @@ import { createAgentRunStore } from './agent-run-store.js';
 import { createAgentRuntime } from './agent-runtime.js';
 import { createAgentSessionStore } from './agent-session-store.js';
 import { createDispatchLedgerStore } from './dispatch-ledger-store.js';
+import { readFeatureFlags } from './feature-flags.js';
 import { createMessageLogStore } from './message-log-store.js';
 import { seedOrchestratorLaunchConfig } from './orchestrator-launch.js';
+import { createReportOutboxStore } from './report-outbox-store.js';
 import { openRuntimeDatabase } from './runtime-database.js';
 import { buildRuntimeRestartPolicy } from './runtime-restart-policy.js';
 import { createSettingsStore } from './settings-store.js';
 import { createTasksFileService } from './tasks-file.js';
 import { createTasksFileWatcher } from './tasks-file-watcher.js';
-import { AUTOSTAFF_ENABLED_KEY, readAutostaffEnabled } from './team-autostaff.js';
 import { createTeamOperations } from './team-operations.js';
 import { resolveTerminalInputProfile } from './terminal-input-profile.js';
 import { createUiAuth } from './ui-auth.js';
+import { createWebhookNotifier, WEBHOOK_URL_KEY } from './webhook-notifier.js';
 import { createWorkerOutputTracker } from './worker-output-tracker.js';
 import { readWorkflowCliPolicy, WORKFLOW_CLI_POLICY_KEY } from './workflow-cli-policy.js';
 import { createWorkflowDispatchAwaiter, } from './workflow-dispatch-awaiter.js';
-import { readWorkflowEnabled, WORKFLOW_ENABLED_KEY } from './workflow-feature.js';
 import { createWorkflowRunLogStore } from './workflow-run-log-store.js';
 import { createWorkflowRunStore } from './workflow-run-store.js';
 import { createWorkflowScheduleStore } from './workflow-schedule-store.js';
@@ -35,6 +36,7 @@ export const createRuntimeStoreServices = (options = {}) => {
     const db = openRuntimeDatabase(options.dataDir);
     const messageLogStore = createMessageLogStore(db);
     const dispatchLedgerStore = createDispatchLedgerStore(db);
+    const reportOutbox = createReportOutboxStore(db);
     const workflowDispatchAwaiter = createWorkflowDispatchAwaiter();
     const workflowRunStore = createWorkflowRunStore(db);
     const workflowRunLogStore = createWorkflowRunLogStore(db);
@@ -42,8 +44,10 @@ export const createRuntimeStoreServices = (options = {}) => {
     const agentRunStore = createAgentRunStore(db);
     const agentSessionStore = createAgentSessionStore(db);
     const settings = createSettingsStore(db);
-    const getWorkflowsEnabled = () => readWorkflowEnabled(settings.getAppState(WORKFLOW_ENABLED_KEY)?.value ?? null);
-    const getAutostaffEnabled = () => readAutostaffEnabled(settings.getAppState(AUTOSTAFF_ENABLED_KEY)?.value ?? null);
+    const getFlags = () => readFeatureFlags(settings);
+    const webhookNotifier = createWebhookNotifier({
+        getUrl: () => settings.getAppState(WEBHOOK_URL_KEY)?.value ?? null,
+    });
     const tasksFileService = createTasksFileService();
     const tasksFileWatchCallbacks = new Set();
     const tasksFileWatcher = createTasksFileWatcher({
@@ -51,8 +55,7 @@ export const createRuntimeStoreServices = (options = {}) => {
             notifyTasksUpdated(tasksFileWatchCallbacks, workspaceId, content);
         },
         getWorkflowCliPolicy: () => readWorkflowCliPolicy(settings.getAppState(WORKFLOW_CLI_POLICY_KEY)?.value ?? null),
-        getWorkflowsEnabled,
-        getAutostaffEnabled,
+        getFlags,
     });
     const uiAuth = createUiAuth();
     const shellRuntime = createWorkspaceShellRuntime(options.agentManager);
@@ -71,8 +74,7 @@ export const createRuntimeStoreServices = (options = {}) => {
         messageLogStore,
         tasksFileService,
         workspaceStore,
-        getWorkflowsEnabled,
-        getAutostaffEnabled,
+        getFlags,
     });
     const workerOutputTracker = options.agentManager
         ? createWorkerOutputTracker(options.agentManager.getOutputBus())
@@ -119,7 +121,7 @@ export const createRuntimeStoreServices = (options = {}) => {
             for (const child of children)
                 removeWorkerCompletely(workspaceId, child.id);
         }
-    }, restartPolicy, (workspaceId, agentId) => workspaceStore.getAgent(workspaceId, agentId), getWorkflowsEnabled, getAutostaffEnabled);
+    }, restartPolicy, (workspaceId, agentId) => workspaceStore.getAgent(workspaceId, agentId), getFlags);
     // Mirrors runtime-store.deleteWorker (stop run → drop launch config → drop
     // dispatches → drop worker row, transactionally). Hoisted `function` so the
     // onAgentExit closure above can reference it; only invoked at runtime, after
@@ -157,6 +159,8 @@ export const createRuntimeStoreServices = (options = {}) => {
         markDispatchCancelled: dispatchLedgerStore.markCancelled,
         markDispatchReportedByWorker: dispatchLedgerStore.markReportedByWorker,
         markDispatchSubmitted: dispatchLedgerStore.markSubmitted,
+        reportOutbox,
+        notifyWebhook: webhookNotifier.notify,
         workflowDispatchAwaiter,
         workspaceStore,
         dismissEphemeralWorker: (workspaceId, workerId) => removeWorkerCompletely(workspaceId, workerId),
@@ -176,6 +180,7 @@ export const createRuntimeStoreServices = (options = {}) => {
         tasksFileService,
         teamOps,
         uiAuth,
+        webhookNotifier,
         workerOutputTracker,
         workflowDispatchAwaiter,
         workflowRunLogStore,

package/dist/src/server/runtime-store-workflows.js

@@ -78,6 +78,14 @@ export const createRuntimeStoreWorkflowRuntime = (services, store) => {
             catch (error) {
                 console.error('[hive] workflow.notifyTrigger failed', error);
             }
+            // Outbound completion webhook (best-effort) so the user is pinged when a
+            // long fan-out finishes without watching the drawer.
+            services.webhookNotifier.notify({
+                type: 'workflow_finished',
+                workspaceId,
+                summary: `${finalRecord.name}: ${finalRecord.status}${finalRecord.error ? ` — ${finalRecord.error}` : ''}`,
+                at: Date.now(),
+            });
         },
         store: {
             addWorkerWithLaunch: (ws, input, launch) => store.addWorkerWithLaunch(ws, input, launch),

package/dist/src/server/runtime-store.js

@@ -93,6 +93,7 @@ export const createRuntimeStore = (options = {}) => {
         dispatchTask: services.teamOps.dispatchTask,
         dispatchTaskByWorkerName: services.teamOps.dispatchTaskByWorkerName,
         reportTask: services.teamOps.reportTask,
+        drainReportOutbox: services.teamOps.drainReportOutbox,
         statusTask: services.teamOps.statusTask,
         listDispatches: services.dispatchLedgerStore.listWorkspaceDispatches,
         listWorkers: (workspaceId) => services.workspaceStore.listWorkers(workspaceId),

package/dist/src/server/session-capture.d.ts

@@ -21,6 +21,7 @@ export interface SessionCaptureSnapshot {
     discriminator?: {
         contentIncludes: string | readonly string[];
     };
+    getOutput?: () => string | null;
     knownSessionIds: Set<string>;
     env?: Record<string, string>;
     root?: string;
@@ -65,7 +66,12 @@ export declare const snapshotSessionIdsForCapture: (cwd: string, capture: Sessio
     };
     knownSessionIds: Set<string>;
     root: string;
+} | {
+    knownSessionIds: Set<string>;
+    env?: never;
+    root?: never;
 } | undefined;
 export declare const getSessionCaptureEnvironment: (snapshot: SessionCaptureSnapshot | undefined) => Record<string, string>;
 export declare const captureSessionIdForCapture: (cwd: string, capture: SessionIdCaptureConfig, snapshot: SessionCaptureSnapshot, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number) => Promise<void>;
 export declare const doesCapturedSessionExist: (cwd: string, capture: SessionIdCaptureConfig, sessionId: string, discriminator?: SessionCaptureSnapshot["discriminator"]) => boolean;
+export declare const captureStdoutRegexSessionId: (pattern: string, getOutput: (() => string | null) | undefined, knownSessionIds: Set<string>, onCapture: (sessionId: string) => void, timeoutMs?: number, intervalMs?: number) => Promise<void>;

package/dist/src/server/session-capture.js

@@ -57,6 +57,11 @@ export const snapshotSessionIdsForCapture = (cwd, capture, discriminator) => {
             root: dbPath,
         };
     }
+    if (capture.source === 'stdout_regex') {
+        return {
+            knownSessionIds: new Set(),
+        };
+    }
     return undefined;
 };
 export const getSessionCaptureEnvironment = (snapshot) => snapshot?.env ?? {};
@@ -73,6 +78,9 @@ export const captureSessionIdForCapture = async (cwd, capture, snapshot, onCaptu
     if (capture.source === 'opencode_session_db') {
         await captureOpenCodeSessionId(cwd, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs, snapshot.root);
     }
+    if (capture.source === 'stdout_regex') {
+        await captureStdoutRegexSessionId(capture.pattern, snapshot.getOutput, snapshot.knownSessionIds, onCapture, timeoutMs, intervalMs);
+    }
 };
 export const doesCapturedSessionExist = (cwd, capture, sessionId, discriminator) => {
     if (capture.source === 'claude_project_jsonl_dir') {
@@ -89,3 +97,27 @@ export const doesCapturedSessionExist = (cwd, capture, sessionId, discriminator)
     }
     return false;
 };
+const compileCaptureRegex = (pattern) => {
+    try {
+        return new RegExp(pattern, 'u');
+    }
+    catch {
+        return null;
+    }
+};
+export const captureStdoutRegexSessionId = async (pattern, getOutput, knownSessionIds, onCapture, timeoutMs = 5000, intervalMs = 100) => {
+    const regex = compileCaptureRegex(pattern);
+    if (!regex || !getOutput)
+        return;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        const output = getOutput();
+        const match = output ? regex.exec(output) : null;
+        const sessionId = match?.[1];
+        if (sessionId && !knownSessionIds.has(sessionId)) {
+            onCapture(sessionId);
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+};

package/dist/src/server/sqlite-schema-v22.d.ts

@@ -0,0 +1,2 @@
+import type { Database } from 'better-sqlite3';
+export declare const applySchemaVersion22: (db: Database) => void;

package/dist/src/server/sqlite-schema-v22.js

@@ -0,0 +1,27 @@
+const HERMES_SESSION_ID_CAPTURE = {
+    pattern: String.raw `Session:\s*([A-Za-z0-9_-]+)`,
+    source: 'stdout_regex',
+};
+const HERMES_YOLO_ARGS = ['--yolo'];
+export const applySchemaVersion22 = (db) => {
+    const hasCommandPresets = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'command_presets'")
+        .get();
+    if (!hasCommandPresets)
+        return;
+    const now = Date.now();
+    db.prepare(`INSERT INTO command_presets (
+       id, display_name, command, args, env, resume_args_template, session_id_capture,
+       yolo_args_template, is_builtin, created_at, updated_at
+     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       display_name = excluded.display_name,
+       command = excluded.command,
+       args = excluded.args,
+       env = excluded.env,
+       resume_args_template = excluded.resume_args_template,
+       session_id_capture = excluded.session_id_capture,
+       yolo_args_template = excluded.yolo_args_template,
+       updated_at = excluded.updated_at
+    WHERE command_presets.is_builtin = 1`).run('hermes', 'Hermes', 'hermes', '[]', '{}', '--resume {session_id}', JSON.stringify(HERMES_SESSION_ID_CAPTURE), JSON.stringify(HERMES_YOLO_ARGS), now, now);
+};

package/dist/src/server/sqlite-schema.d.ts

@@ -1,3 +1,3 @@
 import type { Database } from 'better-sqlite3';
-export declare const CURRENT_SCHEMA_VERSION = 21;
+export declare const CURRENT_SCHEMA_VERSION = 22;
 export declare const initializeRuntimeDatabase: (db: Database) => void;

package/dist/src/server/sqlite-schema.js

@@ -14,7 +14,8 @@ import { applySchemaVersion18 } from './sqlite-schema-v18.js';
 import { applySchemaVersion19 } from './sqlite-schema-v19.js';
 import { applySchemaVersion20 } from './sqlite-schema-v20.js';
 import { applySchemaVersion21 } from './sqlite-schema-v21.js';
-export const CURRENT_SCHEMA_VERSION = 21;
+import { applySchemaVersion22 } from './sqlite-schema-v22.js';
+export const CURRENT_SCHEMA_VERSION = 22;
 // Idempotent column-add helper. SQLite doesn't have `ALTER TABLE … ADD COLUMN
 // IF NOT EXISTS`, so PRAGMA-check first. Safe to call on every init; required
 // for foreign-built DBs where the version-gated migration is skipped.
@@ -118,6 +119,19 @@ export const initializeRuntimeDatabase = (db) => {
     CREATE INDEX IF NOT EXISTS idx_dispatches_open_by_worker
       ON dispatches (workspace_id, to_agent_id, status, sequence);
 
+    CREATE TABLE IF NOT EXISTS report_outbox (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      workspace_id TEXT NOT NULL,
+      target_agent_id TEXT NOT NULL,
+      dispatch_id TEXT NOT NULL UNIQUE,
+      payload TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      delivered_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_report_outbox_pending
+      ON report_outbox (workspace_id, target_agent_id, delivered_at, created_at);
+
     CREATE TABLE IF NOT EXISTS workflow_runs (
       id TEXT PRIMARY KEY,
       workspace_id TEXT NOT NULL,
@@ -299,4 +313,8 @@ export const initializeRuntimeDatabase = (db) => {
         applySchemaVersion21(db);
         db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(21, Date.now());
     }
+    if (!appliedVersions.has(22)) {
+        applySchemaVersion22(db);
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(22, Date.now());
+    }
 };

package/dist/src/server/task-deps.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Optional, read-only task-dependency support for `.hive/tasks.md`.
+ *
+ * A task line may carry a trailing `[needs: #2, #5]` annotation declaring that
+ * it depends on other tasks (referenced by their 1-based position among the
+ * GFM task-list items). `team next` uses this to surface the tasks that are
+ * currently runnable — not done, and with every dependency already checked off.
+ *
+ * Deliberately scoped: parsing happens here on the server only and is purely a
+ * READ — Hive never auto-dispatches a runnable task and never writes the
+ * annotation back into tasks.md (that file stays a human/orchestrator-edited,
+ * git-mergeable artifact). The web task renderer is intentionally left
+ * untouched, so the annotation just shows as literal text in the UI.
+ */
+export interface ParsedTaskLine {
+    /** 1-based position among task-list items — the `#n` that `[needs:]` uses. */
+    index: number;
+    done: boolean;
+    text: string;
+    needs: number[];
+}
+export interface RunnableTask {
+    index: number;
+    text: string;
+}
+export declare const parseTasksWithDeps: (markdown: string) => ParsedTaskLine[];
+/**
+ * Tasks that can be worked right now: not yet done, and every `[needs:]`
+ * dependency is a task that exists AND is checked off. A dependency on a
+ * non-existent `#n`, or on a task that isn't done, withholds the task.
+ */
+export declare const computeRunnableTasks: (markdown: string) => RunnableTask[];

package/dist/src/server/task-deps.js

@@ -0,0 +1,40 @@
+const TASK_LINE = /^\s*[-*]\s+\[([ xX])\]\s+(.*)$/;
+const NEEDS = /\[needs:\s*([#\d,\s]+)\]\s*$/i;
+export const parseTasksWithDeps = (markdown) => {
+    const tasks = [];
+    let index = 0;
+    for (const line of markdown.split('\n')) {
+        const match = TASK_LINE.exec(line);
+        if (!match)
+            continue;
+        index += 1;
+        const done = (match[1] ?? ' ').toLowerCase() === 'x';
+        let text = (match[2] ?? '').trim();
+        const needs = [];
+        const needsMatch = NEEDS.exec(text);
+        if (needsMatch) {
+            for (const token of (needsMatch[1] ?? '').split(',')) {
+                const parsed = Number.parseInt(token.replace('#', '').trim(), 10);
+                if (Number.isInteger(parsed) && parsed > 0)
+                    needs.push(parsed);
+            }
+            // Drop the trailing annotation from the human-readable text.
+            text = text.slice(0, needsMatch.index).trim();
+        }
+        tasks.push({ index, done, text, needs });
+    }
+    return tasks;
+};
+/**
+ * Tasks that can be worked right now: not yet done, and every `[needs:]`
+ * dependency is a task that exists AND is checked off. A dependency on a
+ * non-existent `#n`, or on a task that isn't done, withholds the task.
+ */
+export const computeRunnableTasks = (markdown) => {
+    const tasks = parseTasksWithDeps(markdown);
+    const doneByIndex = new Map(tasks.map((task) => [task.index, task.done]));
+    return tasks
+        .filter((task) => !task.done)
+        .filter((task) => task.needs.every((dep) => doneByIndex.get(dep) === true))
+        .map((task) => ({ index: task.index, text: task.text }));
+};

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

@@ -1,4 +1,5 @@
 import { type ChokidarOptions } from 'chokidar';
+import { type FeatureFlags } from './feature-flags.js';
 import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 /**
  * Watcher configuration. The atomic-save option matters on Windows: VS
@@ -31,16 +32,14 @@ export interface TasksFileWatcher {
     start: (workspaceId: string, workspacePath: string) => Promise<void>;
     stop: (workspaceId: string) => Promise<void>;
 }
-export declare const createTasksFileWatcher: ({ onTasksUpdated, getWorkflowCliPolicy, getWorkflowsEnabled, getAutostaffEnabled, }: {
+export declare const createTasksFileWatcher: ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }: {
     onTasksUpdated: (workspaceId: string, content: string) => void;
     /** Lets the freshly-written `.hive/PROTOCOL.md` state the workspace's
      *  workflow CLI default + allowlist. Optional: omitted → the doc renders
      *  the unrestricted default. */
     getWorkflowCliPolicy?: () => WorkflowCliPolicy;
-    /** Whether the experimental workflow feature is on. Off → PROTOCOL.md omits
-     *  the workflow DSL + `team workflow` commands entirely. Defaults to off. */
-    getWorkflowsEnabled?: () => boolean;
-    /** Whether the experimental auto-staff feature is on (default on). Off →
-     *  PROTOCOL.md omits the team-sizing rule. */
-    getAutostaffEnabled?: () => boolean;
+    /** Resolves the live experimental flags. PROTOCOL.md omits the workflow DSL
+     *  + `team workflow` commands when `workflowsEnabled` is off, and the
+     *  team-sizing rule when `autostaffEnabled` is off. Omitted → all off. */
+    getFlags?: () => FeatureFlags;
 }) => TasksFileWatcher;

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

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { basename, dirname, normalize } from 'node:path';
 import chokidar from 'chokidar';
+import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { ensureProtocolFile, ensureTasksFile, getTasksFilePath, TASKS_FILE_NAME, } from './tasks-file.js';
 const DEBOUNCE_MS = 100;
 const WATCHER_RETRY_MS = 5000;
@@ -66,7 +67,7 @@ const isTasksFileEvent = (tasksPath, changedPath) => {
     const text = Buffer.isBuffer(changedPath) ? changedPath.toString() : changedPath;
     return normalize(text) === normalize(tasksPath) || basename(text) === TASKS_FILE_NAME;
 };
-export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getWorkflowsEnabled, getAutostaffEnabled, }) => {
+export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, getFlags, }) => {
     const watchers = new Map();
     const timers = new Map();
     const retryTimers = new Map();
@@ -145,7 +146,7 @@ export const createTasksFileWatcher = ({ onTasksUpdated, getWorkflowCliPolicy, g
         closed = false;
         await stop(workspaceId);
         ensureTasksFile(workspacePath);
-        ensureProtocolFile(workspacePath, getWorkflowCliPolicy?.(), getWorkflowsEnabled?.() ?? false, getAutostaffEnabled?.() ?? false);
+        ensureProtocolFile(workspacePath, getWorkflowCliPolicy?.(), getFlags?.() ?? FEATURE_FLAGS_ALL_OFF);
         const tasksPath = getTasksFilePath(workspacePath);
         const watcher = chokidar.watch(dirname(tasksPath), buildTasksWatcherOptions(workspacePath));
         const scheduleEmit = (changedPath) => {

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

@@ -1,3 +1,4 @@
+import { type FeatureFlags } from './feature-flags.js';
 import type { WorkflowCliPolicy } from './workflow-cli-policy.js';
 interface TasksFileService {
     readTasks: (workspacePath: string) => string;
@@ -17,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, cliPolicy?: WorkflowCliPolicy, workflowsEnabled?: boolean, autostaffEnabled?: boolean) => 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';
@@ -50,10 +51,10 @@ 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, cliPolicy, workflowsEnabled = false, autostaffEnabled = false) => {
+export const ensureProtocolFile = (workspacePath, cliPolicy, flags = FEATURE_FLAGS_ALL_OFF) => {
     ensureTasksDir(workspacePath);
     const protocolFilePath = getProtocolFilePath(workspacePath);
-    const desired = buildProtocolDoc(cliPolicy, workflowsEnabled, autostaffEnabled);
+    const desired = buildProtocolDoc(cliPolicy, flags);
     const current = existsSync(protocolFilePath)
         ? runRetryableTasksFileOperation(() => readFileSync(protocolFilePath, 'utf8'))
         : null;

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' | 'spawn' | 'dismiss' | 'workflow';
+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

@@ -2,6 +2,7 @@ import { ForbiddenError, UnauthorizedError } from './http-errors.js';
 const ORCHESTRATOR_COMMANDS = new Set([
     'send',
     'list',
+    'next',
     'cancel',
     'help',
     'spawn',

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

@@ -2,6 +2,8 @@ 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;
@@ -35,6 +37,9 @@ 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
@@ -71,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, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }: 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,4 +1,5 @@
-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
@@ -24,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, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, }) => {
+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;
@@ -171,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
@@ -235,15 +257,6 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             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({
@@ -277,16 +290,65 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     }
                     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) {
-                    try {
-                        agentRuntime.writeReportPrompt(workspaceId, worker.name, workerId, text, artifacts, {
-                            requireActiveRun: input.requireActiveRun,
-                        });
-                        forwarded = 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,
+                            });
+                        }
                     }
-                    catch (error) {
-                        forwardError = reportForwardErrorMessage(error);
-                        console.error('[hive] swallowed:teamReport.forward', error);
+                    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