@tt-a1i/hive 2.1.6 → 2.1.8

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

@@ -17,7 +17,7 @@ export const formatUnknownWorkerError = (workerName, roster) => {
     if (roster.length === 0) {
         return [
             `Unknown worker "${workerName}": this workspace currently has no workers.`,
-            '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.',
+            'Report the empty roster to the user and recommend the worker role to add. If the user or workspace policy has explicitly authorized autonomous staffing, run `team spawn <role> [--name <name>] [--ephemeral]`, then `team list` and retry with the spawned worker name.',
         ].join('\n');
     }
     const lines = roster.map((entry) => `  - ${entry.name} (${entry.role}, ${entry.status}, ${entry.pendingTaskCount} pending)`);
@@ -50,27 +50,55 @@ const buildPendingWarning = (workerName, pendingTaskCount, action) => pendingTas
     ? `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, listOpenWorkspaceDispatches, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, claimQueuedDispatch, reparkClaimedDispatch, reportOutbox, notifyWebhook, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, recordProtocolEvent, getFlags, }) => {
+export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispatch, deleteMessage, findOpenDispatch, findOpenDispatchById, listOpenWorkspaceDispatches, insertMessage, markDispatchCancelled, markDispatchReportedByWorker, claimQueuedDispatch, reparkClaimedDispatch, reportOutbox, notifyWebhook, runDataMutation, isRuntimeClosing, workflowDispatchAwaiter, workspaceStore, dismissEphemeralWorker, recordProtocolEvent, getFlags, }) => {
     const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
+    const runMutation = runDataMutation ?? ((mutation) => mutation());
+    const runtimeClosing = () => isRuntimeClosing?.() === true;
+    const drainingReportOutboxIds = new Set();
     // 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 drainReportOutbox = (workspaceId, targetAgentId = `${workspaceId}:orchestrator`) => {
+        if (runtimeClosing())
+            return { attempted: 0, firstSyncError: null };
+        if (!agentRuntime.getActiveRunByAgentId(workspaceId, targetAgentId)) {
+            return { attempted: 0, firstSyncError: null };
+        }
+        let attempted = 0;
+        let firstSyncError = null;
+        for (const entry of reportOutbox.listPending(workspaceId, targetAgentId)) {
+            if (drainingReportOutboxIds.has(entry.id))
+                continue;
+            drainingReportOutboxIds.add(entry.id);
+            attempted += 1;
+            try {
+                void agentRuntime
+                    .deliverSystemMessageToAgent(workspaceId, targetAgentId, entry.payload, {
+                    requireActiveRun: true,
+                })
+                    .then(() => {
+                    if (!runtimeClosing())
+                        reportOutbox.markDelivered(entry.id);
+                })
+                    .catch((error) => {
+                    if (runtimeClosing())
+                        return;
+                    console.error('[hive] swallowed:teamReport.outboxDrain', error);
+                })
+                    .finally(() => {
+                    drainingReportOutboxIds.delete(entry.id);
+                });
+            }
+            catch (error) {
+                drainingReportOutboxIds.delete(entry.id);
+                firstSyncError ??= reportForwardErrorMessage(error);
+                if (!runtimeClosing())
+                    console.error('[hive] swallowed:teamReport.outboxDrain', error);
+            }
         }
+        return { attempted, firstSyncError };
     };
     const ensureWorkerRun = async (workspaceId, workerId, hivePort) => {
         const activeRun = agentRuntime.getActiveRunByAgentId(workspaceId, workerId);
@@ -125,6 +153,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             return workerId;
         }
     };
+    const buildIssuerSystemReminderPayload = (text) => `<hive-system-reminder>\n${escapeHiveEnvelopeText(text)}\n</hive-system-reminder>\n`;
     /** 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
@@ -132,7 +161,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
      *  (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 payload = buildIssuerSystemReminderPayload(text);
         const park = () => {
             try {
                 reportOutbox.enqueue({
@@ -157,28 +186,30 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             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. */
+    /** Called inside the worker-delete transaction after stale pending outbox rows
+     *  for the doomed dispatches are removed, but before dispatch rows are
+     *  deleted. Open non-workflow dispatches get a durable issuer notice, avoiding
+     *  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 open = listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId &&
+            item.workflowRunId === null &&
+            item.fromAgentId !== null &&
+            item.fromAgentId !== getWorkflowAgentId(workspaceId));
         const workerName = workerNameOrId(workspaceId, workerId);
+        const targetAgentIds = new Set();
         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.');
+            targetAgentIds.add(item.fromAgentId);
+            reportOutbox.enqueue({
+                workspaceId,
+                targetAgentId: item.fromAgentId,
+                dispatchId: item.id,
+                payload: buildIssuerSystemReminderPayload(`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.'),
+            });
         }
+        return [...targetAgentIds];
     };
     /** #33: deliver dispatches parked while their worker was stopped. Called on
      *  worker run start (lifecycle) and after dispatchTask auto-starts a worker.
@@ -213,6 +244,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
            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 = (item, error) => {
+            if (runtimeClosing())
+                return;
             if (isPromptReadinessTimeoutError(error)) {
                 try {
                     cancelUndeliveredDispatch(workspaceId, workerId, item.id, reportForwardErrorMessage(error), item.workflowRunId ?? undefined, item.fromAgentId ?? undefined);
@@ -303,6 +336,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     try {
                         const writePrompt = agentRuntime.writeSendPrompt(workspaceId, workerId, dispatchId, sender.name, currentWorker.description, text);
                         void writePrompt.catch((error) => {
+                            if (runtimeClosing())
+                                return;
                             // `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.
@@ -344,6 +379,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     workspaceStore.markTaskDispatched(workspaceId, workerId);
                     pendingMarked = true;
                     const cancelDeferredDispatch = (error) => {
+                        if (runtimeClosing())
+                            return;
                         try {
                             cancelUndeliveredDispatch(workspaceId, workerId, dispatchId, reportForwardErrorMessage(error), input.workflowRunId, isWorkflowDispatch ? undefined : fromAgentId);
                         }
@@ -356,6 +393,8 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
                     };
                     void deferUntilPostStartReady
                         .then(() => {
+                        if (runtimeClosing())
+                            return;
                         const current = listOpenWorkspaceDispatches(workspaceId).find((item) => item.id === dispatchId);
                         if (!current || current.status !== 'queued')
                             return;
@@ -408,7 +447,7 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         }
     };
     return {
-        cancelTask(workspaceId, dispatchId, input) {
+        async cancelTask(workspaceId, dispatchId, input) {
             workspaceStore.getAgent(workspaceId, input.fromAgentId);
             const openDispatch = findOpenDispatchById(workspaceId, dispatchId);
             if (!openDispatch) {
@@ -433,7 +472,9 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             let forwardError = null;
             let forwarded = false;
             try {
-                agentRuntime.writeCancelPrompt(workspaceId, dispatch.toAgentId, dispatch.id, input.reason);
+                await agentRuntime.writeCancelPrompt(workspaceId, dispatch.toAgentId, dispatch.id, input.reason, {
+                    requireActiveRun: true,
+                });
                 forwarded = true;
             }
             catch (error) {
@@ -474,10 +515,21 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
         },
         async deliverUserInput(workspaceId, orchestratorId, text) {
             workspaceStore.getAgent(workspaceId, orchestratorId);
-            await agentRuntime.deliverUserInputToOrchestrator(workspaceId, text, {
-                requireActiveRun: true,
-            });
-            insertMessage(createUserInputMessage(workspaceId, orchestratorId, text));
+            const messageHandle = insertMessage(createUserInputMessage(workspaceId, orchestratorId, text));
+            try {
+                await agentRuntime.deliverUserInputToOrchestrator(workspaceId, text, {
+                    requireActiveRun: true,
+                });
+            }
+            catch (error) {
+                try {
+                    deleteMessage(messageHandle);
+                }
+                catch (deleteError) {
+                    console.error('[hive] swallowed:userInput.rollback', deleteError);
+                }
+                throw error;
+            }
         },
         statusTask(workspaceId, workerId, input = {}) {
             const text = input.text ?? '';
@@ -522,146 +574,153 @@ export const createTeamOperations = ({ agentRuntime, createDispatch, deleteDispa
             if (!openDispatch) {
                 throw new ConflictError(formatNoOpenDispatchError(worker.name, input.dispatchId, listOpenWorkspaceDispatches(workspaceId).filter((item) => item.toAgentId === workerId)));
             }
-            const messageHandle = insertMessage(createReportMessage(workspaceId, workerId, text, status, artifacts));
+            let messageHandle;
+            let dispatch;
+            let reportQueuedBeforeCommit = false;
+            const orchestratorId = `${workspaceId}:orchestrator`;
+            const payload = buildOrchestratorReportPayload(worker.name, text, artifacts, flags(), openDispatch.id);
+            const workflowDispatch = openDispatch.fromAgentId === getWorkflowAgentId(workspaceId);
+            const shouldQueueForOrchestrator = input.requireActiveRun === true && !workflowDispatch;
+            if (shouldQueueForOrchestrator &&
+                agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
+                drainReportOutbox(workspaceId);
+            }
             try {
-                const dispatch = markDispatchReportedByWorker({
-                    artifacts,
-                    ...(input.dispatchId ? { dispatchId: input.dispatchId } : {}),
-                    reportText: text,
-                    toAgentId: workerId,
-                    workspaceId,
-                });
-                if (!dispatch) {
-                    // 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;
-                const pendingWarning = buildPendingWarning(worker.name, remainingPendingTaskCount, 'report');
-                // Workflow-sourced dispatches: the source is the in-process runner, not a
-                // PTY. Resolve its awaiting Promise instead of injecting into orchestrator
-                // stdin (which would do nothing — `__workflow__` has no PTY).
-                if (dispatch.fromAgentId === getWorkflowAgentId(workspaceId)) {
-                    try {
-                        workflowDispatchAwaiter.notifyReport(dispatch.id, {
-                            artifacts,
-                            text,
-                            ...(status ? { status } : {}),
-                        });
-                        forwarded = true;
-                    }
-                    catch (error) {
-                        forwardError = reportForwardErrorMessage(error);
-                        console.error('[hive] swallowed:teamReport.workflowForward', error);
-                    }
-                    return {
-                        dispatch,
-                        forwardError,
-                        forwarded,
-                        ...(pendingWarning ? { pendingWarning } : {}),
-                    };
-                }
-                // Real worker reported (not a workflow-internal step) — fire the
-                // outbound completion webhook. Best-effort; never blocks the report.
-                notifyWebhook?.({
-                    type: 'report_received',
-                    workspaceId,
-                    agentId: workerId,
-                    agentName: worker.name,
-                    summary: text.slice(0, 280),
-                    at: Date.now(),
-                });
-                if (input.requireActiveRun === true) {
-                    const orchestratorId = `${workspaceId}:orchestrator`;
-                    // A fresh report proves the orchestrator is reachable — flush any
-                    // backlog a prior outage stranded first, in arrival order, before
-                    // this one (both ride the dispatcher's per-agent serial queue).
-                    drainReportOutbox(workspaceId);
-                    const payload = buildOrchestratorReportPayload(worker.name, text, artifacts, flags());
-                    if (agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
-                        try {
-                            const delivery = agentRuntime.deliverReportToOrchestrator(workspaceId, worker.name, text, artifacts, { requireActiveRun: true });
-                            forwarded = true;
-                            // The dispatch is already marked reported. If the PTY dies
-                            // mid-write the ledger would say "reported" while the
-                            // orchestrator never received it — persist for redelivery so it
-                            // isn't silently lost.
-                            void delivery.catch((error) => {
-                                console.error('[hive] swallowed:teamReport.forward', error);
-                                reportOutbox.enqueue({
-                                    workspaceId,
-                                    targetAgentId: orchestratorId,
-                                    dispatchId: dispatch.id,
-                                    payload,
-                                });
-                            });
-                        }
-                        catch (error) {
-                            // TOCTOU: orchestrator vanished between the active-run check and
-                            // the write. Same fix — queue it.
-                            console.error('[hive] swallowed:teamReport.forward', error);
-                            forwardError = reportForwardErrorMessage(error);
-                            reportOutbox.enqueue({
-                                workspaceId,
-                                targetAgentId: orchestratorId,
-                                dispatchId: dispatch.id,
-                                payload,
-                            });
-                        }
-                    }
-                    else {
-                        // Orchestrator is down. Queue the report instead of dropping it;
-                        // the CLI surfaces forwarded:false and the backlog drains on the
-                        // orchestrator's next `team list` after it restarts.
-                        forwardError = 'Orchestrator is not running; report queued for delivery.';
+                runMutation(() => {
+                    messageHandle = insertMessage(createReportMessage(workspaceId, workerId, text, status, artifacts));
+                    if (shouldQueueForOrchestrator) {
                         reportOutbox.enqueue({
                             workspaceId,
                             targetAgentId: orchestratorId,
-                            dispatchId: dispatch.id,
+                            dispatchId: openDispatch.id,
                             payload,
                         });
+                        reportQueuedBeforeCommit = true;
                     }
-                }
-                // 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(() => {
+                    const nextDispatch = markDispatchReportedByWorker({
+                        artifacts,
+                        ...(input.dispatchId ? { dispatchId: input.dispatchId } : {}),
+                        reportText: text,
+                        toAgentId: workerId,
+                        workspaceId,
+                    });
+                    if (!nextDispatch) {
+                        // 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)));
+                    }
+                    dispatch = nextDispatch;
+                    recordProtocolEvent?.('report');
+                });
+            }
+            catch (error) {
+                if (!runDataMutation) {
+                    if (reportQueuedBeforeCommit) {
                         try {
-                            dismissEphemeralWorker(workspaceId, workerId);
+                            reportOutbox.deletePendingForDispatch(openDispatch.id);
                         }
-                        catch (error) {
-                            console.error('[hive] swallowed:teamReport.ephemeralDismiss', error);
+                        catch (deleteOutboxError) {
+                            console.error('[hive] swallowed:teamReport.outboxRollback', deleteOutboxError);
                         }
+                    }
+                    if (messageHandle)
+                        deleteMessage(messageHandle);
+                }
+                throw error;
+            }
+            if (!dispatch)
+                throw new Error('Report dispatch was not committed');
+            const committedDispatch = dispatch;
+            workspaceStore.markTaskReported(workspaceId, workerId);
+            const remainingPendingTaskCount = workspaceStore.getWorker(workspaceId, workerId).pendingTaskCount;
+            let forwardError = null;
+            let forwarded = false;
+            const pendingWarning = buildPendingWarning(worker.name, remainingPendingTaskCount, 'report');
+            // Workflow-sourced dispatches: the source is the in-process runner, not a
+            // PTY. Resolve its awaiting Promise instead of injecting into orchestrator
+            // stdin (which would do nothing — `__workflow__` has no PTY).
+            if (committedDispatch.fromAgentId === getWorkflowAgentId(workspaceId)) {
+                try {
+                    workflowDispatchAwaiter.notifyReport(committedDispatch.id, {
+                        artifacts,
+                        text,
+                        ...(status ? { status } : {}),
                     });
+                    forwarded = true;
+                }
+                catch (error) {
+                    forwardError = reportForwardErrorMessage(error);
+                    console.error('[hive] swallowed:teamReport.workflowForward', error);
                 }
                 return {
-                    dispatch,
+                    dispatch: committedDispatch,
                     forwardError,
                     forwarded,
                     ...(pendingWarning ? { pendingWarning } : {}),
                 };
             }
-            catch (error) {
-                deleteMessage(messageHandle);
-                throw error;
+            // 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) {
+                if (agentRuntime.getActiveRunByAgentId(workspaceId, orchestratorId)) {
+                    const drainResult = drainReportOutbox(workspaceId, orchestratorId);
+                    forwarded = false;
+                    forwardError =
+                        drainResult.firstSyncError ??
+                            (reportQueuedBeforeCommit
+                                ? 'Report queued for durable delivery; redelivery is in progress.'
+                                : null);
+                }
+                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 = reportQueuedBeforeCommit
+                        ? 'Orchestrator is not running; report queued for delivery.'
+                        : 'Orchestrator is not running; report could not be queued for delivery.';
+                }
+            }
+            // 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(() => {
+                    if (runtimeClosing())
+                        return;
+                    try {
+                        dismissEphemeralWorker(workspaceId, workerId);
+                    }
+                    catch (error) {
+                        console.error('[hive] swallowed:teamReport.ephemeralDismiss', error);
+                    }
+                });
             }
+            return {
+                dispatch: committedDispatch,
+                forwardError,
+                forwarded,
+                ...(pendingWarning ? { pendingWarning } : {}),
+            };
         },
     };
 };

package/dist/src/shared/remote-bridge-routing.js

@@ -29,7 +29,7 @@ const ALLOWED_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'
 // routes-ui refusing tunnel-tagged requests is layer (3).
 const DENIED_HTTP_PATHS = new Set(['/api/ui/session']);
 // HARDEN (trust-root defense-in-depth): the device-pairing TRUST-ROOT actions — begin a pairing,
-// confirm/approve a device, reject a pending one — are desktop-only at the route layer
+// list pending approvals, confirm/approve a device, reject a pending one — are desktop-only at the route layer
 // (routes-remote.gateLocalDesktopOnly). The Authority Model says a phone can NEVER self-approve a
 // new device, so we mirror /api/ui/session's layered defense: layer 1 hard-denies these here on the
 // bridge (a forwarded frame is Reset(StreamRefused) + audited path_denied), layer 3 is the route gate.
@@ -39,6 +39,8 @@ const DENIED_HTTP_PATHS = new Set(['/api/ui/session']);
 const isDeniedPairingPath = (pathname) => {
     if (pathname === '/api/remote/pairings')
         return true; // begin a pairing (POST)
+    if (pathname === '/api/remote/pairings/pending')
+        return true; // read pending SAS approvals (GET)
     // confirm/reject under /api/remote/pairings/:id — match the action suffix on a pairings path.
     return (pathname.startsWith('/api/remote/pairings/') &&
         (pathname.endsWith('/confirm') || pathname.endsWith('/reject')));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tt-a1i/hive",
-  "version": "2.1.6",
+  "version": "2.1.8",
   "description": "Run Claude Code, Codex, Gemini, OpenCode, Qwen, and other CLI agents as a visible local team in your browser.",
   "type": "module",
   "packageManager": "pnpm@10.30.3",