@tt-a1i/hive 2.1.6 → 2.1.7

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable user-facing changes will be documented in this file.
 
+## 2.1.7 - 2026-06-23
+
+Team delivery recovery and remote-access hardening.
+
+- Makes worker reports durable when the Orchestrator is offline or restarting,
+  so completed work is queued for redelivery instead of being silently lost.
+- Tightens cancel, worker-dismiss, and queued-dispatch recovery paths so stale
+  work gets a clear dropped/cancelled outcome instead of leaving agents waiting.
+- Makes user input delivery truthful: if the Orchestrator terminal is offline,
+  Hive rejects the input instead of recording a message that was never sent.
+- Standardizes remote-access HTTP responses on snake_case fields and keeps the
+  web UI mapping them back into its internal camelCase model.
+- Blocks remote devices from reading or approving desktop-only pairing
+  approvals through the tunnel, while preserving normal equal-authority device
+  management routes.
+
 ## 2.1.6 - 2026-06-21
 
 Team UX polish and release visibility.

package/dist/src/server/agent-runtime-contract.d.ts

@@ -23,26 +23,18 @@ export interface AgentRuntime {
     startAgent: (workspace: WorkspaceSummary, agentId: string, input: StartAgentOptions) => Promise<LiveAgentRun>;
     stopAgentRun: (runId: string) => void;
     validateAgentToken: AgentTokenRegistry['validate'];
-    writeReportPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }) => void;
     writeStatusPrompt: (workspaceId: string, workerName: string, workerId: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }) => void;
     writeSendPrompt: (workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string) => Promise<void>;
     writeCancelPrompt: (workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
         requireActiveRun?: boolean;
-    }) => void;
+    }) => Promise<void>;
     writeUserInputPrompt: (workspaceId: string, text: string) => void;
     writeSystemMessageToAgent: (workspaceId: string, agentId: string, text: string) => void;
     deliverUserInputToOrchestrator: (workspaceId: string, text: string, input?: {
         requireActiveRun?: boolean;
     }) => Promise<void>;
-    /** Awaitable report delivery — rejects if the orchestrator PTY write fails,
-     *  so the caller can persist the report to the redelivery outbox. */
-    deliverReportToOrchestrator: (workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }) => Promise<void>;
     /** Awaitable opaque delivery — used to drain the report outbox so an entry
      *  is marked delivered only after the PTY write resolves. */
     deliverSystemMessageToAgent: (workspaceId: string, agentId: string, text: string, input?: {

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

@@ -139,9 +139,6 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             });
         },
         validateAgentToken: tokenRegistry.validate,
-        writeReportPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
-            stdinDispatcher.writeReportPrompt(workspaceId, workerName, text, artifacts, input);
-        },
         writeStatusPrompt(workspaceId, workerName, _workerId, text, artifacts, input = {}) {
             stdinDispatcher.writeStatusPrompt(workspaceId, workerName, text, artifacts, input);
         },
@@ -149,7 +146,7 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
             return stdinDispatcher.writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text);
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
+            return stdinDispatcher.writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input);
         },
         writeUserInputPrompt(workspaceId, text) {
             stdinDispatcher.writeUserInputPrompt(workspaceId, text);
@@ -160,9 +157,6 @@ export const createAgentRuntime = (agentManager, agentRunStore, sessionStore, ge
         deliverUserInputToOrchestrator(workspaceId, text, input = {}) {
             return stdinDispatcher.deliverUserInputToOrchestrator(workspaceId, text, input);
         },
-        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
-            return stdinDispatcher.deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input);
-        },
         deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {
             return stdinDispatcher.deliverSystemMessageToAgent(workspaceId, agentId, text, input);
         },

package/dist/src/server/agent-stdin-dispatcher.d.ts

@@ -16,22 +16,19 @@ interface AgentStdinDispatcherInput {
      *  Optional; omitted → all flags off. */
     getFlags?: () => FeatureFlags;
 }
-export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
+export declare const buildOrchestratorReportPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags, dispatchId?: string) => string;
 export declare const buildOrchestratorStatusPayload: (workerName: string, text: string, artifacts: string[], flags?: FeatureFlags) => string;
 export declare const buildOrchestratorUserInputPayload: (text: string, flags?: FeatureFlags) => string;
 export declare const buildWorkerDispatchPayload: (fromAgentName: string, workerDescription: string, dispatchId: string, text: string, memoryDigest?: string | null) => string;
 export declare const buildWorkerCancelPayload: (dispatchId: string, reason: string) => string;
 export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }: AgentStdinDispatcherInput) => {
-    writeReportPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }): void;
     writeStatusPrompt(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
         requireActiveRun?: boolean;
     }): void;
     writeSendPrompt(workspaceId: string, workerId: string, dispatchId: string, fromAgentName: string, workerDescription: string, text: string): Promise<void>;
     writeCancelPrompt(workspaceId: string, workerId: string, dispatchId: string, reason: string, input?: {
         requireActiveRun?: boolean;
-    }): void;
+    }): Promise<void>;
     writeUserInputPrompt(workspaceId: string, text: string): void;
     deliverUserInputToOrchestrator(workspaceId: string, text: string, input?: {
         requireActiveRun?: boolean;
@@ -40,12 +37,6 @@ export declare const createAgentStdinDispatcher: ({ agentManager, getLaunchConfi
      *  Used by the workflow runner to notify the triggering orchestrator
      *  when a run finishes (mirrors Claude Code's <task-notification>). */
     writeSystemMessageToAgent(workspaceId: string, agentId: string, text: string): void;
-    /** Awaitable report delivery — same payload as writeReportPrompt but the
-     *  promise is returned so the caller can persist the report to the
-     *  redelivery outbox if the orchestrator PTY write rejects. */
-    deliverReportToOrchestrator(workspaceId: string, workerName: string, text: string, artifacts: string[], input?: {
-        requireActiveRun?: boolean;
-    }): Promise<void>;
     /** Awaitable opaque delivery — used to drain the report outbox so an entry
      *  is marked delivered only after the PTY write actually resolves. */
     deliverSystemMessageToAgent(workspaceId: string, agentId: string, text: string, input?: {

package/dist/src/server/agent-stdin-dispatcher.js

@@ -4,9 +4,20 @@ import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-t
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
 import { buildDispatchMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
-export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
+export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF, dispatchId) => {
+    const dispatchAttribute = dispatchId
+        ? ` dispatch="${escapeHiveEnvelopeAttribute(dispatchId)}"`
+        : '';
     const lines = [
-        `<hive-message kind="report" from="@${escapeHiveEnvelopeAttribute(workerName)}">`,
+        `<hive-message kind="report" from="@${escapeHiveEnvelopeAttribute(workerName)}"${dispatchAttribute}>`,
+        ...(dispatchId
+            ? [
+                '',
+                `dispatch_id: ${escapeHiveEnvelopeText(dispatchId)}`,
+                'If this dispatch_id report was already processed, treat this as a duplicate redelivery and ignore it.',
+                '',
+            ]
+            : []),
         escapeHiveEnvelopeText(text),
     ];
     for (const artifact of artifacts)
@@ -166,9 +177,6 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
         });
     };
     return {
-        writeReportPrompt(workspaceId, workerName, text, artifacts, input = {}) {
-            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input));
-        },
         writeStatusPrompt(workspaceId, workerName, text, artifacts, input = {}) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
         },
@@ -206,7 +214,7 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
             }
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
-            swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));
+            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input);
         },
         writeUserInputPrompt(workspaceId, text) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorUserInputPayload(text, flags())));
@@ -220,12 +228,6 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
         writeSystemMessageToAgent(workspaceId, agentId, text) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, agentId, text));
         },
-        /** Awaitable report delivery — same payload as writeReportPrompt but the
-         *  promise is returned so the caller can persist the report to the
-         *  redelivery outbox if the orchestrator PTY write rejects. */
-        deliverReportToOrchestrator(workspaceId, workerName, text, artifacts, input = {}) {
-            return writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorReportPayload(workerName, text, artifacts, flags()), input);
-        },
         /** Awaitable opaque delivery — used to drain the report outbox so an entry
          *  is marked delivered only after the PTY write actually resolves. */
         deliverSystemMessageToAgent(workspaceId, agentId, text, input = {}) {

package/dist/src/server/post-start-input-writer.js

@@ -8,7 +8,7 @@ const MIN_SUBMIT_AFTER_PASTE_DELAY_MS = 600;
 const MAX_SUBMIT_AFTER_PASTE_DELAY_MS = 1500;
 const PASTE_CHARS_PER_DELAY_MS = 4;
 const PASTE_ACK_CHECK_INTERVAL_MS = 50;
-const PASTE_ACK_SETTLE_DELAY_MS = 100;
+const PASTE_ACK_SETTLE_DELAY_MS = 250;
 const CODEX_PASTE_ACK_SETTLE_DELAY_MS = 250;
 const PASTE_ACK_TIMEOUT_MS = 3000;
 const CLAUDE_HIVE_PASTE_ACK_TIMEOUT_MS = 10000;

package/dist/src/server/report-outbox-store.d.ts

@@ -1,15 +1,16 @@
 import type { Database } from 'better-sqlite3';
 /**
- * Durable redelivery queue for worker reports the orchestrator could not
- * receive. `team report` persists the dispatch as reported and forwards the
- * report into the orchestrator's stdin best-effort; if that write fails (the
- * PTY exited / is mid-restart, or the orchestrator was down at report time)
- * the report would otherwise be lost — the ledger says "reported" yet the
- * orchestrator waits forever, indistinguishable from a hang.
+ * Durable redelivery queue for protocol messages a live agent could not
+ * receive. The primary producer is `team report`: it persists the dispatch as
+ * reported and forwards the report into the orchestrator's stdin; if that write
+ * fails (the PTY exited / is mid-restart, or the orchestrator was down at report
+ * time) the report would otherwise be lost — the ledger says "reported" yet the
+ * orchestrator waits forever, indistinguishable from a hang. Dispatch-drop
+ * notifications use the same queue for their issuer.
  *
  * Entries are keyed by dispatch id (UNIQUE) so a report enqueues at most once,
- * and drain marks them delivered only after the orchestrator PTY write
- * actually resolves, so a failed redelivery stays pending for the next drain.
+ * and drain marks them delivered only after the target PTY write actually
+ * resolves, so a failed redelivery stays pending for the next drain.
  */
 export interface ReportOutboxEntry {
     id: number;
@@ -27,6 +28,7 @@ interface EnqueueInput {
     payload: string;
 }
 export declare const createReportOutboxStore: (db: Database) => {
+    deletePendingForDispatch: (dispatchId: string) => void;
     enqueue: (input: EnqueueInput) => void;
     listPending: (workspaceId: string, targetAgentId: string) => ReportOutboxEntry[];
     markDelivered: (id: number) => void;

package/dist/src/server/report-outbox-store.js

@@ -25,9 +25,18 @@ export const createReportOutboxStore = (db) => {
     const markDelivered = (id) => {
         db.prepare(`UPDATE report_outbox SET delivered_at = ? WHERE id = ? AND delivered_at IS NULL`).run(Date.now(), id);
     };
+    const deletePendingForDispatch = (dispatchId) => {
+        db.prepare('DELETE FROM report_outbox WHERE dispatch_id = ? AND delivered_at IS NULL').run(dispatchId);
+    };
     const pendingCount = (workspaceId, targetAgentId) => db
         .prepare(`SELECT COUNT(*) AS n FROM report_outbox
            WHERE workspace_id = ? AND target_agent_id = ? AND delivered_at IS NULL`)
         .get(workspaceId, targetAgentId).n;
-    return { enqueue, listPending, markDelivered, pendingCount };
+    return {
+        deletePendingForDispatch,
+        enqueue,
+        listPending,
+        markDelivered,
+        pendingCount,
+    };
 };

package/dist/src/server/routes-remote.js

@@ -1,5 +1,6 @@
 import { ForbiddenError } from './http-errors.js';
 import { REMOTE_DAEMON_TOKEN_KEY, REMOTE_ENABLED_KEY, REMOTE_GATEWAY_URL_KEY, } from './remote-config-keys.js';
+import { HIVE_REMOTE_DEVICE_HEADER } from './remote-loopback-auth.js';
 import { getRequiredParam, readJsonBody, route, sendJson } from './route-helpers.js';
 import { requireUiTokenFromRequest } from './ui-auth-helpers.js';
 // Remote-access device-management + pairing routes (M4). Two gate classes:
@@ -23,8 +24,11 @@ const gateUi = ({ request, store }) => {
 // check, so even the short-circuit can't admit a tunnel request that slipped a cookie too.
 const gateLocalDesktopOnly = ({ request, store }) => {
     if (store.authorizeRemoteTunnelRequest(request)) {
+        const rawDeviceId = request.headers[HIVE_REMOTE_DEVICE_HEADER];
         store.getRemoteAuditStore().enqueue({
             action: 'reject',
+            deviceId: typeof rawDeviceId === 'string' ? rawDeviceId : null,
+            endpoint: request.url ?? null,
             result: 'rejected',
             rejectReason: 'pairing_confirm_forbidden',
         });
@@ -38,8 +42,8 @@ const remoteStatus = (store) => {
     const status = store.getRemoteTunnelStatus();
     return {
         enabled: store.settings.getAppState(REMOTE_ENABLED_KEY)?.value === 'true',
-        loggedIn: isLoggedIn(store),
-        gatewayUrl: store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
+        logged_in: isLoggedIn(store),
+        gateway_url: store.settings.getAppState(REMOTE_GATEWAY_URL_KEY)?.value ?? null,
         connected: status === 'online',
         // The FULL tunnel state, not just online/offline — the desktop dot was stuck looking "connected or
         // not" and couldn't show connecting / reconnecting / revoked / logged-out. (connecting+reconnecting
@@ -47,15 +51,41 @@ const remoteStatus = (store) => {
         connection: status,
     };
 };
-// RemoteDeviceRecord is already camelCase + metadata-only (no key material). Identity-mapped so the
-// response shape stays pinned to the store's invariant-7 projection.
+// HTTP responses stay snake_case even though the store uses camelCase records.
+const toPairingTicketView = (ticket) => ({
+    pairing_id: ticket.pairingId,
+    qr: ticket.qr,
+    code: ticket.code,
+    expires_at: ticket.expiresAt,
+});
+const toPendingPairingView = (pending) => ({
+    pairing_id: pending.pairingId,
+    device_name: pending.deviceName,
+    sas: pending.sas,
+    expires_at: pending.expiresAt,
+});
 const toDeviceView = (record) => ({
     id: record.id,
     name: record.name,
-    createdAt: record.createdAt,
-    lastActive: record.lastActive,
-    revokedAt: record.revokedAt,
+    created_at: record.createdAt,
+    last_active: record.lastActive,
+    revoked_at: record.revokedAt,
+});
+const toAuditView = (record) => ({
+    id: record.id,
+    device_id: record.deviceId,
+    ts: record.ts,
+    workspace_id: record.workspaceId,
+    action: record.action,
+    endpoint: record.endpoint,
+    result: record.result,
+    reject_reason: record.rejectReason,
+    byte_count: record.byteCount,
+    preview: record.preview,
 });
+const getSearchParams = (url) => new URL(url ?? '', 'http://x').searchParams;
+const hasCompatFlag = (params, snakeName, camelName) => params.has(snakeName) || params.has(camelName);
+const getCompatParam = (params, snakeName, camelName) => params.get(snakeName) ?? params.get(camelName);
 export const remoteRoutes = [
     route('GET', '/api/remote/status', (ctx) => {
         gateUi(ctx);
@@ -83,7 +113,7 @@ export const remoteRoutes = [
         }
         try {
             const ticket = ctx.store.getRemotePairing().beginPairing();
-            sendJson(ctx.response, 200, ticket);
+            sendJson(ctx.response, 200, toPairingTicketView(ticket));
         }
         catch {
             // beginPairing throws if gateway/daemon id vanished between the status read and here.
@@ -94,7 +124,7 @@ export const remoteRoutes = [
         // HARDEN minor: desktop-only. The confirm dialog backs this; a phone has no use for another
         // device's in-flight SAS, and exposing it would needlessly widen the secret surface (invariant 7).
         gateLocalDesktopOnly(ctx);
-        sendJson(ctx.response, 200, ctx.store.getRemotePairing().listPending());
+        sendJson(ctx.response, 200, ctx.store.getRemotePairing().listPending().map(toPendingPairingView));
     }),
     route('POST', '/api/remote/pairings/:pairingId/confirm', async (ctx) => {
         const { params, request, response, store } = ctx;
@@ -139,7 +169,8 @@ export const remoteRoutes = [
     // ── equal-authority device management ──────────────────────────────────────────────────────────
     route('GET', '/api/remote/devices', (ctx) => {
         gateUi(ctx);
-        const includeRevoked = new URL(ctx.request.url ?? '', 'http://x').searchParams.has('includeRevoked');
+        const params = getSearchParams(ctx.request.url);
+        const includeRevoked = hasCompatFlag(params, 'include_revoked', 'includeRevoked');
         sendJson(ctx.response, 200, ctx.store.getRemoteDeviceStore().list(includeRevoked).map(toDeviceView));
     }),
     route('POST', '/api/remote/devices/:deviceId/revoke', (ctx) => {
@@ -156,11 +187,12 @@ export const remoteRoutes = [
     }),
     route('GET', '/api/remote/audit', (ctx) => {
         gateUi(ctx);
-        const url = new URL(ctx.request.url ?? '', 'http://x');
-        const rawLimit = Number(url.searchParams.get('limit'));
+        const params = getSearchParams(ctx.request.url);
+        const rawLimit = Number(params.get('limit'));
         const limit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, 500) : 100;
-        const deviceId = url.searchParams.get('deviceId');
+        const deviceId = getCompatParam(params, 'device_id', 'deviceId');
         const audit = ctx.store.getRemoteAuditStore();
-        sendJson(ctx.response, 200, deviceId ? audit.listForDevice(deviceId, limit) : audit.list(limit));
+        const records = deviceId ? audit.listForDevice(deviceId, limit) : audit.list(limit);
+        sendJson(ctx.response, 200, records.map(toAuditView));
     }),
 ];

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

@@ -306,7 +306,7 @@ export const teamRoutes = [
             workspaceId: projectId,
         });
         requireCommandForRole(agent, 'cancel');
-        const result = store.cancelTask(projectId, dispatchId, { fromAgentId, reason });
+        const result = await store.cancelTask(projectId, dispatchId, { fromAgentId, reason });
         sendJson(response, 202, {
             dispatch_id: result.dispatch?.id ?? null,
             forward_error: result.forwardError,

package/dist/src/server/routes-workspaces.js

@@ -109,11 +109,9 @@ export const workspaceRoutes = [
             workspaceId,
         });
         requireCommandForRole(agent, 'list');
-        // The orchestrator polling `team list` is its natural post-restart wakeup:
-        // flush any reports a prior outage stranded back into its stdin now that
-        // it is reachable again. Cheap (indexed, usually empty) and a safe no-op
-        // for non-orchestrator callers.
-        store.drainReportOutbox(workspaceId);
+        // Polling `team list` is a natural post-restart wakeup: flush any durable
+        // notices stranded for the caller now that its PTY is reachable again.
+        store.drainReportOutbox(workspaceId, agent.id);
         sendJson(response, 200, serializeTeamListWithOpenDispatches(store, workspaceId));
     }),
     route('POST', '/api/workspaces/:workspaceId/workers', async ({ params, request, response, store }) => {
@@ -198,7 +196,6 @@ export const workspaceRoutes = [
         }
         const orchestratorId = getOrchestratorId(workspaceId);
         if (!store.getActiveRunByAgentId(workspaceId, orchestratorId)) {
-            store.recordUserInput(workspaceId, orchestratorId, body.text);
             throw new PtyInactiveError(`No active run for agent: ${orchestratorId}`);
         }
         await store.deliverUserInput(workspaceId, orchestratorId, body.text);

package/dist/src/server/runtime-store-contract.d.ts

@@ -44,9 +44,9 @@ export interface RuntimeStore {
     reportTask: (workspaceId: string, workerId: string, input?: ReportTaskInput) => ReportTaskResult;
     /** Flush any reports stranded by a prior orchestrator outage. Safe no-op
      *  when the orchestrator is down or the outbox is empty. */
-    drainReportOutbox: (workspaceId: string) => void;
+    drainReportOutbox: (workspaceId: string, targetAgentId?: string) => void;
     statusTask: (workspaceId: string, workerId: string, input?: StatusTaskInput) => ReportTaskResult;
-    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => ReportTaskResult;
+    cancelTask: (workspaceId: string, dispatchId: string, input: CancelTaskInput) => Promise<ReportTaskResult>;
     listDispatches: (workspaceId: string, options?: ListDispatchesOptions) => DispatchRecord[];
     listOpenDispatches: (workspaceId: string) => DispatchRecord[];
     listRecentDispatches: (workspaceId: string, limit?: number) => DispatchRecord[];

package/dist/src/server/runtime-store-helpers.d.ts

@@ -10,6 +10,7 @@ import { type RemoteAuditStore } from './remote-audit-store.js';
 import type { DeviceSessionProvider } from './remote-device-session.js';
 import { type RemoteDeviceStore } from './remote-device-store.js';
 import { type RemotePairing } from './remote-pairing.js';
+import { createReportOutboxStore } from './report-outbox-store.js';
 import { openRuntimeDatabase } from './runtime-database.js';
 import { createSentinelHeartbeatService } from './sentinel-heartbeat.js';
 import { createSettingsStore } from './settings-store.js';
@@ -39,6 +40,8 @@ export interface RuntimeStoreServices {
     agentRuntime: ReturnType<typeof createAgentRuntime>;
     db: ReturnType<typeof openRuntimeDatabase>;
     dispatchLedgerStore: ReturnType<typeof createDispatchLedgerStore>;
+    isRuntimeClosing: () => boolean;
+    markRuntimeClosing: () => void;
     messageLogStore: ReturnType<typeof createMessageLogStore>;
     remoteAuditStore: RemoteAuditStore;
     remoteDeviceSessions: DeviceSessionProvider;
@@ -53,6 +56,7 @@ export interface RuntimeStoreServices {
     teamMemoryDreamScheduler: ReturnType<typeof createTeamMemoryDreamScheduler>;
     sentinelHeartbeat: ReturnType<typeof createSentinelHeartbeatService>;
     protocolEventStats: ReturnType<typeof createProtocolEventStats>;
+    reportOutbox: ReturnType<typeof createReportOutboxStore>;
     teamMemoryDreamStore: ReturnType<typeof createTeamMemoryDreamStore>;
     teamMemoryDiagnostics: ReturnType<typeof createTeamMemoryDiagnostics>;
     teamMemoryStore: ReturnType<typeof createTeamMemoryStore>;

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

@@ -76,6 +76,7 @@ const createWorkspaceUploadStorage = (dataDir) => {
 };
 export const createRuntimeStoreServices = (options = {}) => {
     const db = openRuntimeDatabase(options.dataDir);
+    let closing = false;
     const uploadStorage = createWorkspaceUploadStorage(options.dataDir);
     const messageLogStore = createMessageLogStore(db);
     const dispatchLedgerStore = createDispatchLedgerStore(db);
@@ -239,18 +240,24 @@ export const createRuntimeStoreServices = (options = {}) => {
     // agentRuntime is assigned.
     function removeWorkerCompletely(workspaceId, workerId) {
         const activeRun = agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
-        // Open dispatch rows are about to be hard-deleted — tell their issuers
-        // first, or parked/in-flight work vanishes silently (review finding).
-        try {
-            teamOps.notifyIssuersOfDroppedDispatches(workspaceId, workerId, 'the worker was dismissed');
-        }
-        catch (error) {
-            console.error('[hive] swallowed:removeWorker.notifyDropped', error);
-        }
+        const droppedNoticeTargets = new Set();
         db.transaction(() => {
+            for (const dispatch of dispatchLedgerStore.listWorkspaceDispatches(workspaceId)) {
+                if (dispatch.toAgentId === workerId && dispatch.workflowRunId === null) {
+                    reportOutbox.deletePendingForDispatch(dispatch.id);
+                }
+            }
+            // Open dispatch rows are about to be hard-deleted — queue issuer notices
+            // in the same transaction or the delete must not commit.
+            for (const targetAgentId of teamOps.notifyIssuersOfDroppedDispatches(workspaceId, workerId, 'the worker was dismissed')) {
+                droppedNoticeTargets.add(targetAgentId);
+            }
             dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
             workspaceStore.deleteWorker(workspaceId, workerId);
         })();
+        for (const targetAgentId of droppedNoticeTargets) {
+            teamOps.drainReportOutbox(workspaceId, targetAgentId);
+        }
         agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
         if (activeRun)
             agentRuntime.stopAgentRun(activeRun.runId);
@@ -283,6 +290,8 @@ export const createRuntimeStoreServices = (options = {}) => {
         reparkClaimedDispatch: dispatchLedgerStore.reparkClaimedDispatch,
         reportOutbox,
         notifyWebhook: webhookNotifier.notify,
+        runDataMutation: (mutation) => db.transaction(mutation)(),
+        isRuntimeClosing: () => closing,
         workflowDispatchAwaiter,
         workspaceStore,
         dismissEphemeralWorker: (workspaceId, workerId) => removeWorkerCompletely(workspaceId, workerId),
@@ -296,6 +305,10 @@ export const createRuntimeStoreServices = (options = {}) => {
         agentRuntime,
         db,
         dispatchLedgerStore,
+        isRuntimeClosing: () => closing,
+        markRuntimeClosing: () => {
+            closing = true;
+        },
         messageLogStore,
         remoteAuditStore,
         remoteDeviceSessions,
@@ -310,6 +323,7 @@ export const createRuntimeStoreServices = (options = {}) => {
         teamMemoryDreamScheduler,
         sentinelHeartbeat,
         protocolEventStats,
+        reportOutbox,
         teamMemoryDreamStore,
         teamMemoryDiagnostics,
         teamMemoryExport,
@@ -345,7 +359,15 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                 // for orchestrator/workflow pseudo-agents, which never hold queued
                 // worker dispatches addressed to themselves). Wait for post-start
                 // guidance first so startup instructions never race the first task.
-                const replayQueuedDispatches = () => {
+                const deliverPostStartBacklog = () => {
+                    if (services.isRuntimeClosing())
+                        return;
+                    try {
+                        services.teamOps.drainReportOutbox(workspaceId, agentId);
+                    }
+                    catch (error) {
+                        console.error('[hive] swallowed:startAgent.drainOutbox', error);
+                    }
                     try {
                         services.teamOps.replayQueuedDispatches(workspaceId, agentId, {
                             createdBeforeMs: run.startedAt,
@@ -356,12 +378,12 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
                     }
                 };
                 if (run.postStartInputReady) {
-                    void run.postStartInputReady.then(replayQueuedDispatches).catch((error) => {
+                    void run.postStartInputReady.then(deliverPostStartBacklog).catch((error) => {
                         console.error('[hive] swallowed:startAgent.replayAfterPostStart', error);
                     });
                 }
                 else {
-                    replayQueuedDispatches();
+                    deliverPostStartBacklog();
                 }
             }
             return run;
@@ -406,6 +428,7 @@ export const createRuntimeStoreLifecycle = ({ agentManager, services, }) => {
     };
     return {
         close: async () => {
+            services.markRuntimeClosing();
             try {
                 // Fail in-flight workflow awaiters BEFORE their workers vanish, so the
                 // runner's `await agent(...)` rejects with a clear shutdown error

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

@@ -29,16 +29,22 @@ export const createRuntimeStoreWorkerMutations = ({ addWorker, configureAgentLau
     },
     deleteWorker: (workspaceId, workerId) => {
         const activeRun = services.agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
-        try {
-            services.teamOps.notifyIssuersOfDroppedDispatches(workspaceId, workerId, 'the worker was removed');
-        }
-        catch (error) {
-            console.error('[hive] swallowed:deleteWorker.notifyDropped', error);
-        }
+        const droppedNoticeTargets = new Set();
         runDataMutation(() => {
+            for (const dispatch of services.dispatchLedgerStore.listWorkspaceDispatches(workspaceId)) {
+                if (dispatch.toAgentId === workerId && dispatch.workflowRunId === null) {
+                    services.reportOutbox.deletePendingForDispatch(dispatch.id);
+                }
+            }
+            for (const targetAgentId of services.teamOps.notifyIssuersOfDroppedDispatches(workspaceId, workerId, 'the worker was removed')) {
+                droppedNoticeTargets.add(targetAgentId);
+            }
             services.dispatchLedgerStore.deleteWorkerDispatches(workspaceId, workerId);
             services.workspaceStore.deleteWorker(workspaceId, workerId);
         });
+        for (const targetAgentId of droppedNoticeTargets) {
+            services.teamOps.drainReportOutbox(workspaceId, targetAgentId);
+        }
         services.agentRuntime.deleteAgentLaunchConfig(workspaceId, workerId);
         if (activeRun)
             services.agentRuntime.stopAgentRun(activeRun.runId);

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

@@ -23,7 +23,13 @@ export const createRuntimeStoreWorkflowRuntime = (services, store) => {
                     return false;
                 services.workspaceStore.markTaskCancelled(workspaceId, openDispatch.toAgentId);
                 try {
-                    services.agentRuntime.writeCancelPrompt(workspaceId, cancelled.toAgentId, cancelled.id, reason);
+                    void services.agentRuntime
+                        .writeCancelPrompt(workspaceId, cancelled.toAgentId, cancelled.id, reason, {
+                        requireActiveRun: true,
+                    })
+                        .catch((error) => {
+                        console.error('[hive] swallowed:workflow.cancelDispatch.forward', error);
+                    });
                 }
                 catch (error) {
                     console.error('[hive] swallowed:workflow.cancelDispatch.forward', error);

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

@@ -46,6 +46,10 @@ export interface TeamOperationsInput {
     reportOutbox: ReportOutboxStore;
     /** Fire an outbound completion webhook (best-effort) when a worker reports. */
     notifyWebhook?: (event: WebhookEvent) => void;
+    /** Runs durable protocol writes atomically when backed by SQLite. */
+    runDataMutation?: (mutation: () => void) => void;
+    /** True once runtime shutdown has begun; late async PTY callbacks must not touch SQLite. */
+    isRuntimeClosing?: () => boolean;
     workflowDispatchAwaiter: WorkflowDispatchAwaiter;
     workspaceStore: WorkspaceStore;
     /** Auto-dismiss an ephemeral orchestrator-spawned worker after its
@@ -90,20 +94,23 @@ export interface ReportTaskResult {
     forwarded: boolean;
     pendingWarning?: string;
 }
-export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, listOpenWorkspaceDispatches, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, claimQueuedDispatch, reparkClaimedDispatch, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, recordProtocolEvent, getFlags, }: TeamOperationsInput) => {
-    cancelTask(workspaceId: string, dispatchId: string, input: CancelTaskInput): {
+export declare const createTeamOperations: ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, listOpenWorkspaceDispatches, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, claimQueuedDispatch, reparkClaimedDispatch, reportOutbox, notifyWebhook, runDataMutation, isRuntimeClosing, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, recordProtocolEvent, getFlags, }: TeamOperationsInput) => {
+    cancelTask(workspaceId: string, dispatchId: string, input: CancelTaskInput): Promise<{
         dispatch: DispatchRecord;
         forwardError: string | null;
         forwarded: boolean;
-    };
+    }>;
     dispatchTask: (workspaceId: string, workerId: string, text: string, input?: DispatchTaskInput) => Promise<DispatchRecord>;
-    drainReportOutbox: (workspaceId: string) => void;
+    drainReportOutbox: (workspaceId: string, targetAgentId?: string) => {
+        attempted: number;
+        firstSyncError: string | null;
+    };
     replayQueuedDispatches: (workspaceId: string, workerId: string, options?: {
         beforeSequence?: number;
         createdBeforeMs?: number;
         excludeDispatchId?: string;
     }) => void;
-    notifyIssuersOfDroppedDispatches: (workspaceId: string, workerId: string, reason: string) => void;
+    notifyIssuersOfDroppedDispatches: (workspaceId: string, workerId: string, reason: string) => string[];
     dispatchTaskByWorkerName(workspaceId: string, workerName: string, text: string, input?: DispatchTaskInput): Promise<DispatchRecord & {
         restartedWorker: boolean;
     }>;