@tt-a1i/hive 2.1.6 → 2.1.8

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;
     }>;