@minionry/minion 0.7.36 → 0.7.39

package/dist/server/services/websocket/handler.js

@@ -1,5 +1,6 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -8,6 +9,7 @@ import { machineFile } from '../../../bin/machine-layout.js';
 import { setAgentBrowserHostAttached } from '../../cli/headless/mcp-config.js';
 import { getBrowserDriverState } from '../browser/driver-state.js';
 import { toBrowserPreflightPayload } from '../browser/preflight.js';
+import { getChainEngine } from '../chain/chain-engine.js';
 import { CollabSessionRegistry } from '../collab/registry.js';
 import { COLLAB_EVENT_BUFFER_MAX_AGE_MS, COLLAB_EVENT_BUFFER_MAX_BYTES, COLLAB_EVENT_BUFFER_MAX_EVENTS, } from '../collab/types.js';
 import { respawnInstance } from '../instances.js';
@@ -16,6 +18,7 @@ import { parseDeclaredEnvironment, resolveCliEnvironment } from '../platform-url
 import { getAgentScheduler } from '../schedule/agent-scheduler.js';
 import { getQualityScheduler } from '../schedule/quality-scheduler.js';
 import { getScheduler } from '../schedule/scheduler.js';
+import { holdAppToolCallsFor, resumeAppToolCallsFor } from '../sdk/app-tools.js';
 import { attachSdkBrowserTransport } from '../sdk/browser-transport.js';
 import { teardownSdkForViewer, teardownSdkOnTransportClose } from '../sdk/revoke.js';
 import { captureException } from '../sentry.js';
@@ -28,6 +31,7 @@ import { resolvePendingQuestion } from './ask-user-question-bridge.js';
 import { AutocompleteService } from './autocomplete.js';
 import { activeBrowserAgentTarget } from './browser-agent-runtime.js';
 import { attachBrowserHostBroadcast, broadcastAgentTabState, browserHostPolicy, handleBrowserHostMessage, onViewerDisconnected as onBrowserViewerDisconnected, onWsContextClosed as onBrowserWsContextClosed, } from './browser-handlers.js';
+import { moveViewerToContext } from './browser-viewer-lifecycle.js';
 import { addressToViewer } from './browser-viewer-registry.js';
 import { handleCollabMessage } from './collab-handlers.js';
 import { createCommitSuggestionService, GIT_VIEW_TAB_ID, isAnyExecutionActive } from './commit-suggestion-service.js';
@@ -42,7 +46,7 @@ import { FileUploadHandler } from './file-upload-handler.js';
 import { handleGitMessage } from './git-handlers.js';
 import { GitHeadWatcher } from './git-head-watcher.js';
 import { hasScopeBinding, resolveScopeDir } from './handler-context.js';
-import { MsgIdTracker } from './msg-id-tracker.js';
+import { MsgIdTracker, MUTATION_SCOPE, mutationMsgId, ReplyRecorder } from './msg-id-tracker.js';
 import { maybeStartAutoImplement } from './plan-execution-handlers.js';
 import { handlePlanMessage } from './plan-handlers.js';
 import { executorCache } from './plan-helpers.js';
@@ -64,7 +68,9 @@ import { buildSnippetListResultData, handleSnippetMessage } from './snippet-hand
 import { SeqEventBuffer, SeqEventBufferRegistry, TabEventBufferRegistry } from './tab-event-buffer.js';
 import { handleCreateTab, handleGetActiveTabs, handleMarkTabViewed, handleRemoveTab, handleReorderTabs, handleSetTabEngine, handleSyncTabMeta } from './tab-handlers.js';
 import { cleanupTerminalSubscribers, handleTerminalMessage } from './terminal-handlers.js';
+import { parseStreamInterest, ViewerInterestRegistry } from './viewer-interest.js';
 const log = debugLog('handler');
+export const VIEWER_DETACH_GRACE_MS = 60_000;
 export class WebSocketImproviseHandler {
     sessions = new Map();
     connections = new Map();
@@ -87,12 +93,14 @@ export class WebSocketImproviseHandler {
     snippetExpander = null;
     snippetWatcher = null;
     tabEventBuffers = new TabEventBufferRegistry();
+    viewerInterest = new ViewerInterestRegistry();
     chatTimelines = new ChatTimelineRegistry();
     pmEventBuffers = new SeqEventBufferRegistry();
     pmTimelines = new PmTimelineRegistry();
     collabEventBuffers = new SeqEventBufferRegistry(() => new SeqEventBuffer(COLLAB_EVENT_BUFFER_MAX_EVENTS, COLLAB_EVENT_BUFFER_MAX_AGE_MS, Date.now, COLLAB_EVENT_BUFFER_MAX_BYTES));
     collabSessions = new CollabSessionRegistry(this);
     msgIdTracker = new MsgIdTracker();
+    replyRecorders = new AsyncLocalStorage();
     commitSuggestions = null;
     instanceRegistry;
     shutdownInProgress = false;
@@ -104,6 +112,9 @@ export class WebSocketImproviseHandler {
     browserDriverStateDispose = null;
     currentWorkingDir = null;
     sessionRoles = new SessionRoleDirectory();
+    contextViewers = new Map();
+    detachedContexts = new Map();
+    deferredCloses = new Map();
     constructor(instanceRegistry = null, browserHost = null) {
         this.frecencyPath = machineFile('frecency');
         const frecencyData = this.loadFrecencyData();
@@ -283,6 +294,7 @@ export class WebSocketImproviseHandler {
         }
         if (workingDir) {
             getScheduler(workingDir, this).start();
+            getChainEngine(workingDir, this).start();
             getAgentScheduler(workingDir, this).start();
             getQualityScheduler(workingDir).start();
         }
@@ -316,16 +328,59 @@ export class WebSocketImproviseHandler {
             const viewerId = msg._viewer ?? ws._viewerId;
             delete msg._viewer;
             this.sessionRoles.noteMessage(viewerId, role, ws, { explicitViewerStamp, messageType: msg.type });
-            await this.dispatchMessage(ws, msg, tabId, workingDir, role, viewerId);
+            const msgId = mutationMsgId(msg);
+            if (msgId === undefined) {
+                await this.dispatchMessage(ws, msg, tabId, workingDir, role, viewerId);
+            }
+            else {
+                await this.dispatchMutationOnce(ws, msg, msgId, viewerId, () => this.dispatchMessage(ws, msg, tabId, workingDir, role, viewerId));
+            }
         }
         catch (error) {
-            console.error('[WebSocketImproviseHandler] Error handling message:', error);
-            captureException(error, { context: 'websocket.handleMessage' });
-            this.send(ws, {
-                type: 'error',
-                data: { message: error instanceof Error ? error.message : String(error) }
+            this.replyWithHandlerError(ws, error);
+        }
+    }
+    replyWithHandlerError(ws, error) {
+        console.error('[WebSocketImproviseHandler] Error handling message:', error);
+        captureException(error, { context: 'websocket.handleMessage' });
+        this.send(ws, {
+            type: 'error',
+            data: { message: error instanceof Error ? error.message : String(error) }
+        });
+    }
+    async dispatchMutationOnce(ws, msg, msgId, viewerId, dispatch) {
+        const repeat = this.msgIdTracker.admit(MUTATION_SCOPE, msgId);
+        if (repeat) {
+            this.answerRepeatedMutation(ws, msg, msgId, repeat, viewerId);
+            return;
+        }
+        const recorder = new ReplyRecorder(ws, msg.type);
+        try {
+            await this.replyRecorders.run(recorder, async () => {
+                try {
+                    await dispatch();
+                }
+                catch (error) {
+                    this.replyWithHandlerError(ws, error);
+                }
             });
         }
+        finally {
+            this.msgIdTracker.settle(MUTATION_SCOPE, msgId, recorder.close());
+        }
+    }
+    answerRepeatedMutation(ws, msg, msgId, repeat, viewerId) {
+        console.log(`[WebSocketImproviseHandler] ${msg.type} duplicate msgId=${msgId} — ${repeat.replies ? 'replaying its result' : 'ignored'}`);
+        if (repeat.replies) {
+            for (const frame of repeat.replies)
+                this.deliver(ws, frame);
+            return;
+        }
+        this.send(ws, addressToViewer({
+            type: 'duplicateIgnored',
+            ...(msg.tabId ? { tabId: msg.tabId } : {}),
+            data: { msgId, type: msg.type, ...(repeat.pending ? { pending: true } : {}) },
+        }, ws, viewerId));
     }
     static DISPATCH = {
         execute: 'session', cancel: 'session', getHistory: 'session', new: 'session', approve: 'session', reject: 'session', queueEnqueuePrompt: 'session', queueRemovePrompt: 'session', queueClearPrompts: 'session',
@@ -337,13 +392,13 @@ export class WebSocketImproviseHandler {
         listDirectory: 'fileExplorer', writeFile: 'fileExplorer', createFile: 'fileExplorer', createDirectory: 'fileExplorer', deleteFile: 'fileExplorer', renameFile: 'fileExplorer', notifyFileOpened: 'fileExplorer', searchFileContents: 'fileExplorer', cancelSearch: 'fileExplorer', findDefinition: 'fileExplorer',
         collabJoin: 'collab', collabLeave: 'collab', collabPush: 'collab', collabCursor: 'collab', collabFlush: 'collab',
         gitStatus: 'git', gitStage: 'git', gitUnstage: 'git', gitCommit: 'git', gitCommitWithAI: 'git', gitPush: 'git', gitPull: 'git', gitLog: 'git', gitDiscoverRepos: 'git', gitSetDirectory: 'git', gitGetRemoteInfo: 'git', gitCreatePR: 'git', gitGeneratePRDescription: 'git', gitListBranches: 'git', gitCheckout: 'git', gitCreateBranch: 'git', gitDeleteBranch: 'git', gitDiff: 'git', gitShowCommit: 'git', gitCommitDiff: 'git', gitListTags: 'git', gitCreateTag: 'git', gitPushTag: 'git', gitWorktreeList: 'git', gitWorktreeCreate: 'git', gitWorktreeCreateAndAssign: 'git', gitWorktreeRemove: 'git', tabWorktreeSwitch: 'git', tabRepoWorktreeSwitch: 'git', gitWorktreePush: 'git', gitWorktreeCreatePR: 'git', gitMergePreview: 'git', gitWorktreeMerge: 'git', gitMergeAbort: 'git', gitMergeComplete: 'git', gitMergeStashPop: 'git', gitMergeDiscardBlockers: 'git',
-        planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planUpdateIssue: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planRestoreBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planExportBoard: 'plan', planImportBoard: 'plan', planDownloadBoard: 'plan', planInstantiateTemplate: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan', chatToBoard: 'plan', queueEnqueueComposerPrompt: 'plan', queueRemoveComposerPrompt: 'plan', queueClearComposerPrompts: 'plan',
+        planInit: 'plan', planGetState: 'plan', planListIssues: 'plan', planGetIssue: 'plan', planGetSprint: 'plan', planGetMilestone: 'plan', planUpdateIssue: 'plan', planReviewDecision: 'plan', planDeleteIssue: 'plan', planScaffold: 'plan', planPrompt: 'plan', planExecute: 'plan', planExecuteEpic: 'plan', planPause: 'plan', planStop: 'plan', planResume: 'plan', planCreateBoard: 'plan', planUpdateBoard: 'plan', planArchiveBoard: 'plan', planRestoreBoard: 'plan', planGetBoard: 'plan', planGetBoardState: 'plan', planReorderBoards: 'plan', planSetActiveBoard: 'plan', planGetBoardArtifacts: 'plan', planExportBoard: 'plan', planImportBoard: 'plan', planDownloadBoard: 'plan', planInstantiateTemplate: 'plan', planCreateSprint: 'plan', planActivateSprint: 'plan', planCompleteSprint: 'plan', planGetSprintArtifacts: 'plan', chatToBoard: 'plan', queueEnqueueComposerPrompt: 'plan', queueRemoveComposerPrompt: 'plan', queueClearComposerPrompts: 'plan',
         getPmTimeline: 'plan',
         planScheduleCreate: 'schedule', planScheduleUpdate: 'schedule', planScheduleDelete: 'schedule', planScheduleList: 'schedule', planScheduleValidateSource: 'schedule',
         agentScheduleCreate: 'agentSchedule', agentScheduleUpdate: 'agentSchedule', agentScheduleDelete: 'agentSchedule', agentScheduleList: 'agentSchedule',
         fileUploadStart: 'fileUpload', fileUploadChunk: 'fileUpload', fileUploadComplete: 'fileUpload', fileUploadCancel: 'fileUpload',
         fileDownloadStart: 'fileDownload', fileDownloadCancel: 'fileDownload',
-        sdkConnect: 'sdk', sdkRequest: 'sdk', sdkAgentRun: 'sdk', sdkPmWrite: 'sdk', sdkPmExecute: 'sdk', sdkPmSchedule: 'sdk', sdkFilesWrite: 'sdk', sdkStorageWrite: 'sdk', sdkCancel: 'sdk', sdkRevoke: 'sdk', sdkConsentDecision: 'sdk', sdkAgentSession: 'sdk', sdkAgentInteract: 'sdk', sdkGitWrite: 'sdk', sdkTerminalWrite: 'sdk', sdkToolsServe: 'sdk', sdkQualityWrite: 'sdk', sdkBrowserWrite: 'sdk', sdkInferenceRun: 'sdk', sdkEndpointsWrite: 'sdk',
+        sdkConnect: 'sdk', sdkRequest: 'sdk', sdkAgentRun: 'sdk', sdkPmWrite: 'sdk', sdkPmExecute: 'sdk', sdkPmSchedule: 'sdk', sdkPmChain: 'sdk', sdkFilesWrite: 'sdk', sdkStorageWrite: 'sdk', sdkCancel: 'sdk', sdkRevoke: 'sdk', sdkConsentDecision: 'sdk', sdkAgentSession: 'sdk', sdkAgentInteract: 'sdk', sdkGitWrite: 'sdk', sdkTerminalWrite: 'sdk', sdkToolsServe: 'sdk', sdkQualityWrite: 'sdk', sdkBrowserWrite: 'sdk', sdkInferenceRun: 'sdk', sdkEndpointsWrite: 'sdk',
         appInstallLocal: 'apps', appServeStatus: 'apps', appStop: 'apps', appUpdate: 'apps', appGreenlightDecision: 'apps', appSpaceList: 'apps', appSpaceAdd: 'apps', appSpaceRemove: 'apps', appSpaceConfigure: 'apps',
         browser_preflight: 'browser', browser_snapshot: 'browser', browser_resume_driver: 'browser',
         browser_navigate: 'browser', browser_back: 'browser', browser_forward: 'browser', browser_reload: 'browser', browser_stop: 'browser',
@@ -411,7 +466,7 @@ export class WebSocketImproviseHandler {
                     this.sendPermissionDenied(ws, msg.type);
                     return;
                 }
-                return handleTerminalMessage(this, ws, msg, tabId, workingDir);
+                return handleTerminalMessage(this, ws, msg, tabId, workingDir, viewerId);
             case 'fileExplorer': return handleFileExplorerMessage(this, ws, msg, tabId, effectiveDir, role);
             case 'collab': return handleCollabMessage(this, ws, msg, effectiveDir, role, viewerId);
             case 'git':
@@ -420,7 +475,7 @@ export class WebSocketImproviseHandler {
                     return;
                 }
                 return handleGitMessage(this, ws, msg, tabId, workingDir);
-            case 'plan': return handlePlanMessage(this, ws, msg, tabId, workingDir, role);
+            case 'plan': return handlePlanMessage(this, ws, msg, tabId, workingDir, role, viewerId);
             case 'schedule': return handleScheduleMessage(this, ws, msg, tabId, workingDir, role);
             case 'agentSchedule': return handleAgentScheduleMessage(this, ws, msg, workingDir, role);
             case 'fileUpload': return this.handleFileUploadMessage(ws, msg, tabId, effectiveDir, role);
@@ -549,6 +604,12 @@ export class WebSocketImproviseHandler {
                 if (can(role, 'editSettings'))
                     handleSetTabEngine(this, ws, msg, tabId, workingDir);
                 return true;
+            case 'viewerInterest': {
+                const interest = parseStreamInterest(msg.data?.interest);
+                if (interest)
+                    this.viewerInterest.declare(ws, interest);
+                return true;
+            }
             default:
                 return false;
         }
@@ -772,12 +833,25 @@ export class WebSocketImproviseHandler {
         }
     }
     handleClose(ws) {
+        const deferred = this.deferredCloses.get(ws);
+        if (deferred) {
+            clearTimeout(deferred);
+            this.deferredCloses.delete(ws);
+        }
+        this.contextViewers.delete(ws);
+        const detached = this.detachedContexts.get(ws);
+        if (detached) {
+            clearTimeout(detached.timer);
+            this.detachedContexts.delete(ws);
+            this.killDetachedSearches(detached);
+        }
         const tabMap = this.connections.get(ws);
         if (tabMap) {
             this.cleanupConnectionResources(tabMap);
         }
         this.connections.delete(ws);
         this.allConnections.delete(ws);
+        this.viewerInterest.forget(ws);
         cleanupTerminalSubscribers(this, ws);
         this.sessionRoles.dropWs(ws);
         if (ws._viewerId) {
@@ -802,34 +876,90 @@ export class WebSocketImproviseHandler {
         }
     }
     handleTransportDetach(ws) {
-        const tabMap = this.connections.get(ws);
-        if (tabMap) {
-            for (const tabId of tabMap.keys()) {
-                const searchProcess = this.activeSearches.get(tabId);
-                if (searchProcess) {
-                    try {
-                        searchProcess.kill();
-                    }
-                    catch {   }
-                    this.activeSearches.delete(tabId);
-                }
-            }
+        if (this.detachedContexts.has(ws))
+            return;
+        const searches = new Map();
+        for (const tabId of this.connections.get(ws)?.keys() ?? []) {
+            const search = this.activeSearches.get(tabId);
+            if (search)
+                searches.set(tabId, search);
         }
         this.connections.delete(ws);
         this.allConnections.delete(ws);
+        this.viewerInterest.forget(ws);
         cleanupTerminalSubscribers(this, ws);
         this.sessionRoles.dropWs(ws);
+        this.collabSessions.onTransportDetach();
+        for (const viewerId of this.contextViewers.get(ws) ?? [])
+            holdAppToolCallsFor(viewerId);
+        this.contextViewers.delete(ws);
+        const timer = setTimeout(() => this.expireDetachedContext(ws), VIEWER_DETACH_GRACE_MS);
+        timer.unref?.();
+        this.detachedContexts.set(ws, { searches, resumed: false, timer });
+    }
+    expireDetachedContext(ws) {
+        const detached = this.detachedContexts.get(ws);
+        if (!detached)
+            return;
+        this.detachedContexts.delete(ws);
+        if (!detached.resumed)
+            this.killDetachedSearches(detached);
         if (this.browserHost) {
             try {
                 onBrowserWsContextClosed(this.browserHost, ws);
             }
             catch (err) {
-                captureException(err, { context: 'websocket.handleTransportDetach.browserDetach' });
+                captureException(err, { context: 'websocket.detachGrace.browserRelease' });
             }
         }
-        this.collabSessions.onTransportDetach();
+    }
+    killDetachedSearches(detached) {
+        for (const [tabId, search] of detached.searches) {
+            if (this.activeSearches.get(tabId) !== search)
+                continue;
+            try {
+                search.kill();
+            }
+            catch {   }
+            this.activeSearches.delete(tabId);
+        }
+    }
+    handleViewerConnected(ws, viewerId) {
+        let known = this.contextViewers.get(ws);
+        if (!known) {
+            known = new Set();
+            this.contextViewers.set(ws, known);
+        }
+        known.add(viewerId);
+        this.handleWebConnected();
+        for (const from of this.detachedContexts.keys())
+            moveViewerToContext(viewerId, from, ws);
+        resumeAppToolCallsFor(viewerId);
+    }
+    handleWebConnected() {
+        if (this.deferredCloses.size > 0) {
+            console.log('[handler] A viewer is back — the pending web_disconnected teardown is cancelled');
+        }
+        for (const timer of this.deferredCloses.values())
+            clearTimeout(timer);
+        this.deferredCloses.clear();
+        for (const detached of this.detachedContexts.values())
+            detached.resumed = true;
+    }
+    handleWebDisconnected(ws, onClosed) {
+        if (this.deferredCloses.has(ws))
+            return;
+        const timer = setTimeout(() => {
+            this.deferredCloses.delete(ws);
+            this.handleClose(ws);
+            onClosed?.();
+        }, VIEWER_DETACH_GRACE_MS);
+        timer.unref?.();
+        this.deferredCloses.set(ws, timer);
     }
     handleBrowserViewerDisconnected(viewerId) {
+        for (const known of this.contextViewers.values())
+            known.delete(viewerId);
         teardownSdkForViewer(viewerId);
         this.sessionRoles.dropViewer(viewerId);
         this.collabSessions.dropViewer(viewerId);
@@ -952,23 +1082,45 @@ export class WebSocketImproviseHandler {
         }
     }
     send(ws, response) {
-        try {
-            ws.send(JSON.stringify(response));
-        }
-        catch (error) {
-            console.error('[WebSocketImproviseHandler] Error sending message:', error);
-        }
+        this.write(ws, response, this.replyRecorders.getStore());
     }
     broadcastToOthers(sender, response) {
         for (const ws of this.allConnections) {
             if (ws !== sender) {
-                this.send(ws, response);
+                this.write(ws, response);
             }
         }
     }
     broadcastToAll(response) {
         for (const ws of this.allConnections) {
-            this.send(ws, response);
+            this.write(ws, response);
+        }
+    }
+    broadcastStream(response) {
+        for (const ws of this.allConnections) {
+            if (!this.viewerInterest.wantsStreams(ws))
+                continue;
+            this.write(ws, response);
+        }
+    }
+    write(ws, response, recorder) {
+        let frame;
+        try {
+            frame = JSON.stringify(response);
+        }
+        catch (error) {
+            console.error('[WebSocketImproviseHandler] Error sending message:', error);
+            return;
+        }
+        recorder?.record(ws, response.type, frame, response._target);
+        this.deliver(ws, frame);
+    }
+    deliver(ws, frame) {
+        try {
+            ws.send(frame);
+        }
+        catch (error) {
+            console.error('[WebSocketImproviseHandler] Error sending message:', error);
         }
     }
     cleanupSession(sessionId) {

package/dist/server/services/websocket/msg-id-tracker.js

@@ -2,27 +2,89 @@
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
 const DEFAULT_TTL_MS = 15 * 60 * 1000;
 const DEFAULT_MAX_PER_TAB = 512;
+const DEFAULT_MAX_MUTATIONS = 4096;
+export const IDEMPOTENT_MUTATION_TYPES = new Set([
+    'writeFile', 'createFile', 'createDirectory', 'deleteFile', 'renameFile',
+    'fileUploadStart', 'fileUploadChunk', 'fileUploadComplete', 'fileUploadCancel',
+    'gitStage', 'gitUnstage', 'gitCommit', 'gitCommitWithAI', 'gitPush', 'gitPull', 'gitSetDirectory',
+    'gitCheckout', 'gitCreateBranch', 'gitDeleteBranch', 'gitCreatePR', 'gitCreateTag', 'gitPushTag',
+    'gitWorktreeCreate', 'gitWorktreeCreateAndAssign', 'gitWorktreeRemove', 'gitWorktreePush', 'gitWorktreeCreatePR',
+    'gitWorktreeMerge', 'gitMergeAbort', 'gitMergeComplete', 'gitMergeStashPop', 'gitMergeDiscardBlockers',
+    'tabWorktreeSwitch', 'tabRepoWorktreeSwitch',
+    'cancel', 'approve', 'reject',
+    'removeTab',
+    'askUserQuestionResponse',
+    'planReviewDecision',
+    'sdkPmWrite', 'sdkFilesWrite', 'sdkStorageWrite', 'sdkGitWrite', 'sdkTerminalWrite', 'sdkQualityWrite',
+    'sdkBrowserWrite', 'sdkEndpointsWrite',
+    'sdkPmChain',
+]);
+export const MUTATION_SCOPE = '\u0000mutations';
+const MAX_MSG_ID_LENGTH = 128;
+export function mutationMsgId(msg) {
+    if (!IDEMPOTENT_MUTATION_TYPES.has(msg.type))
+        return undefined;
+    const msgId = msg.data?.msgId;
+    return typeof msgId === 'string' && msgId.length > 0 && msgId.length <= MAX_MSG_ID_LENGTH ? msgId : undefined;
+}
+const MAX_CACHED_REPLIES = 8;
+const MAX_CACHED_REPLY_BYTES = 4 * 1024;
+export class ReplyRecorder {
+    requester;
+    requestType;
+    frames = [];
+    bytes = 0;
+    overflowed = false;
+    open = true;
+    constructor(requester, requestType) {
+        this.requester = requester;
+        this.requestType = requestType;
+    }
+    record(to, replyType, frame, target) {
+        if (!this.open || this.overflowed || to !== this.requester || target !== undefined)
+            return;
+        if (this.requestType.startsWith('sdk') ? replyType !== 'sdkResponse' : replyType.startsWith('sdk'))
+            return;
+        this.bytes += frame.length;
+        if (this.frames.length >= MAX_CACHED_REPLIES || this.bytes > MAX_CACHED_REPLY_BYTES) {
+            this.overflowed = true;
+            return;
+        }
+        this.frames.push(frame);
+    }
+    close() {
+        this.open = false;
+        return this.overflowed || this.frames.length === 0 ? null : this.frames;
+    }
+}
 export class MsgIdTracker {
     ttlMs;
     maxPerTab;
     now;
+    maxMutations;
     tabs = new Map();
-    constructor(ttlMs = DEFAULT_TTL_MS, maxPerTab = DEFAULT_MAX_PER_TAB, now = Date.now) {
+    constructor(ttlMs = DEFAULT_TTL_MS, maxPerTab = DEFAULT_MAX_PER_TAB, now = Date.now, maxMutations = DEFAULT_MAX_MUTATIONS) {
         this.ttlMs = ttlMs;
         this.maxPerTab = maxPerTab;
         this.now = now;
+        this.maxMutations = maxMutations;
     }
     recordIfFirst(tabId, msgId) {
-        const entry = this.tabs.get(tabId) ?? { ids: new Map() };
-        this.evictExpired(entry);
-        if (entry.ids.has(msgId)) {
-            entry.ids.set(msgId, this.now());
-            return false;
-        }
-        entry.ids.set(msgId, this.now());
-        this.enforceSizeCap(entry);
-        this.tabs.set(tabId, entry);
-        return true;
+        return this.seeIfFirst(tabId, msgId, this.maxPerTab) === null;
+    }
+    admit(scope, msgId) {
+        const seen = this.seeIfFirst(scope, msgId, this.maxMutations, true);
+        if (seen === null)
+            return null;
+        return { replies: seen.replies ?? null, pending: seen.pending === true };
+    }
+    settle(scope, msgId, replies) {
+        const seen = this.tabs.get(scope)?.ids.get(msgId);
+        if (!seen)
+            return;
+        seen.pending = false;
+        seen.replies = replies;
+        seen.at = this.now();
     }
     forget(tabId) {
         this.tabs.delete(tabId);
@@ -30,19 +92,32 @@ export class MsgIdTracker {
     size(tabId) {
         return this.tabs.get(tabId)?.ids.size ?? 0;
     }
+    seeIfFirst(tabId, msgId, cap, pending = false) {
+        const entry = this.tabs.get(tabId) ?? { ids: new Map() };
+        this.evictExpired(entry);
+        const seen = entry.ids.get(msgId);
+        if (seen) {
+            seen.at = this.now();
+            return seen;
+        }
+        entry.ids.set(msgId, pending ? { at: this.now(), pending } : { at: this.now() });
+        this.enforceSizeCap(entry, cap);
+        this.tabs.set(tabId, entry);
+        return null;
+    }
     evictExpired(entry) {
         const cutoff = this.now() - this.ttlMs;
-        for (const [id, ts] of entry.ids) {
-            if (ts < cutoff)
+        for (const [id, seen] of entry.ids) {
+            if (seen.at < cutoff && !seen.pending)
                 entry.ids.delete(id);
         }
     }
-    enforceSizeCap(entry) {
-        while (entry.ids.size > this.maxPerTab) {
-            const firstKey = entry.ids.keys().next().value;
-            if (firstKey === undefined)
-                break;
-            entry.ids.delete(firstKey);
+    enforceSizeCap(entry, cap) {
+        for (const [id, seen] of entry.ids) {
+            if (entry.ids.size <= cap)
+                return;
+            if (!seen.pending)
+                entry.ids.delete(id);
         }
     }
 }

package/dist/server/services/websocket/plan-execution-handlers.js

@@ -1,10 +1,13 @@
 // Copyright (c) 2025-present Minionry, Inc.
 // SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { sendAgentPush } from '../agent-push.js';
 import { handlePlanPrompt, parseModelDirective, parseRunModel } from '../plan/composer.js';
+import { resolveReadyToWork } from '../plan/dependency-resolver.js';
 import { parseBoardDirectory, parsePlanDirectory, resolvePmDir } from '../plan/parser.js';
 import { PM_BOARD_ISSUE_ID, PM_COMPOSER_ISSUE_ID, pmTimelineIssueId } from '../plan/pm-timeline.js';
+import { broadcastPlanStateIfChanged } from '../plan/watcher.js';
 import { scopeExecutionDir } from './handler-context.js';
-import { denyIfViewOnly, executorCache, getExecutor } from './plan-helpers.js';
+import { denyIfViewOnly, executorCache, getExecutor, notifyChainExecutorStatus, notifyChainRunEnded, } from './plan-helpers.js';
 import { broadcastPmEvent, pmTimelineKey } from './pm-timeline-broadcast.js';
 import { mergePreUploadedAttachments } from './session-handlers.js';
 export function handlePrompt(ctx, ws, msg, workingDir, permission) {
@@ -42,6 +45,7 @@ export function wireExecutorEvents(executor, ctx, workingDir, boardId, agentTabI
     const timelineKey = (issueId) => pmTimelineKey(boardId ?? null, pmTimelineIssueId(issueId));
     executor.on('statusChanged', (status) => {
         ctx.broadcastToAll({ type: 'planExecutionProgress', data: { status, ...tag } });
+        notifyChainExecutorStatus(workingDir, status);
     });
     executor.on('issueStarted', (issue) => {
         ctx.broadcastToAll({
@@ -80,7 +84,7 @@ export function wireExecutorEvents(executor, ctx, workingDir, boardId, agentTabI
         ctx.broadcastToAll({ type: 'planExecutionMetrics', data: executor.getMetrics() });
         const fullState = parsePlanDirectory(workingDir);
         if (fullState) {
-            ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+            broadcastPlanStateIfChanged(ctx, workingDir, fullState);
         }
     });
     executor.on('issueError', (data) => {
@@ -110,22 +114,34 @@ export function wireExecutorEvents(executor, ctx, workingDir, boardId, agentTabI
     executor.on('stateUpdated', () => {
         const fullState = parsePlanDirectory(workingDir);
         if (fullState) {
-            ctx.broadcastToAll({ type: 'planStateUpdated', data: fullState });
+            broadcastPlanStateIfChanged(ctx, workingDir, fullState);
         }
     });
     executor.on('reviewProgress', (data) => {
         broadcastPmEvent(ctx, timelineKey(data.issueId), 'planReviewProgress', { ...data, ...tag });
+        if (data.status === 'awaiting_approval') {
+            sendAgentPush({
+                event: 'approval_needed',
+                tabId: `${boardId ?? 'pm'}::${data.issueId}`,
+                workingDirectory: workingDir,
+            });
+        }
+    });
+    executor.on('issueAbandoned', (data) => {
+        broadcastPmEvent(ctx, timelineKey(data.issueId), 'planIssueAbandoned', { ...data, ...tag });
     });
     executor.on('complete', (reason) => {
         ctx.broadcastToAll({ type: 'planExecutionComplete', data: { reason, ...tag, metrics: executor.getMetrics() } });
         ctx.commitSuggestions?.notifyExecutionSettled(settleDir);
+        notifyChainRunEnded(workingDir, boardId ?? null, 'complete');
     });
     executor.on('error', (error) => {
         ctx.broadcastToAll({ type: 'planExecutionError', data: { error, ...tag } });
         ctx.commitSuggestions?.notifyExecutionSettled(settleDir);
+        notifyChainRunEnded(workingDir, boardId ?? null, 'error');
     });
 }
-function broadcastBoardRunPrompt(ctx, boardId, prompt) {
+export function broadcastBoardRunPrompt(ctx, boardId, prompt) {
     broadcastPmEvent(ctx, pmTimelineKey(boardId, PM_BOARD_ISSUE_ID), 'planExecutionPrompt', {
         issueId: PM_BOARD_ISSUE_ID,
         prompt,
@@ -139,12 +155,24 @@ export function maybeStartAutoImplement(ctx, workingDir, boardId) {
     const boardState = parseBoardDirectory(pmDir, boardId);
     if (!boardState?.board.autoImplement)
         return;
+    startBoardRunIfIdle(ctx, workingDir, boardId, `Auto-implement board ${boardId}`);
+}
+export function maybeContinueAfterApproval(ctx, workingDir, boardId) {
+    const pmDir = resolvePmDir(workingDir);
+    if (!pmDir)
+        return;
+    const boardState = parseBoardDirectory(pmDir, boardId);
+    if (!boardState || resolveReadyToWork(boardState.issues).length === 0)
+        return;
+    startBoardRunIfIdle(ctx, workingDir, boardId, `Continue board ${boardId} after an approval`);
+}
+function startBoardRunIfIdle(ctx, workingDir, boardId, launchPrompt) {
     const executor = getExecutor(workingDir);
     if (executor.getStatus() === 'executing' || executor.getStatus() === 'starting')
         return;
     const executionDir = scopeExecutionDir(ctx, boardId);
     wireExecutorEvents(executor, ctx, workingDir, boardId, undefined, executionDir);
-    broadcastBoardRunPrompt(ctx, boardId, `Auto-implement board ${boardId}`);
+    broadcastBoardRunPrompt(ctx, boardId, launchPrompt);
     ctx.broadcastToAll({ type: 'planExecutionStarted', data: { status: 'executing', boardId } });
     executor.startBoard(boardId, executionDir).catch(error => {
         ctx.broadcastToAll({

package/dist/server/services/websocket/plan-handlers.js

@@ -4,12 +4,12 @@ import { can } from '@minionry/roles';
 import { dispatchByType } from './dispatch-util.js';
 import { handleArchiveBoard, handleChatToBoard, handleCreateBoard, handleGetBoard, handleGetBoardArtifacts, handleGetBoardState, handleExportBoard as handlePublishExportBoard, handleReorderBoards, handleRestoreBoard, handleSetActiveBoard, handleUpdateBoard } from './plan-board-handlers.js';
 import { handleExecute, handleExecuteEpic, handleGetPmTimeline, handlePause, handlePrompt, handleResume, handleStop } from './plan-execution-handlers.js';
-import { handleDeleteIssue, handleGetIssue, handleGetMilestone, handleGetSprint, handleListIssues, handlePlanInit, handleScaffold, handleUpdateIssue } from './plan-issue-handlers.js';
+import { handleDeleteIssue, handleGetIssue, handleGetMilestone, handleGetSprint, handleListIssues, handlePlanInit, handleReviewDecision, handleScaffold, handleUpdateIssue } from './plan-issue-handlers.js';
 import { handleActivateSprint, handleCompleteSprint, handleCreateSprint, handleGetSprintArtifacts } from './plan-sprint-handlers.js';
 import { handleDownloadBoard, handleImportBoard, handleInstantiateTemplate, handleExportBoard as handleTransferExportBoard } from './plan-transfer-handlers.js';
 import { handleQueueClearComposerPrompts, handleQueueEnqueueComposerPrompt, handleQueueRemoveComposerPrompt } from './prompt-queue-handlers.js';
 export { cleanupPlanResources } from './plan-helpers.js';
-export function buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate) {
+export function buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate, decidedBy = { role: 'owner' }) {
     return {
         planInit: () => handlePlanInit(ctx, ws, workingDir),
         planGetState: () => handlePlanInit(ctx, ws, workingDir),
@@ -17,7 +17,8 @@ export function buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate) {
         planGetIssue: () => handleGetIssue(ctx, ws, msg, workingDir),
         planGetSprint: () => handleGetSprint(ctx, ws, msg, workingDir),
         planGetMilestone: () => handleGetMilestone(ctx, ws, msg, workingDir),
-        planUpdateIssue: () => handleUpdateIssue(ctx, ws, msg, workingDir, editPlanGate),
+        planUpdateIssue: () => handleUpdateIssue(ctx, ws, msg, workingDir, editPlanGate, decidedBy),
+        planReviewDecision: () => handleReviewDecision(ctx, ws, msg, workingDir, editPlanGate, decidedBy),
         planDeleteIssue: () => handleDeleteIssue(ctx, ws, msg, workingDir, editPlanGate),
         planScaffold: () => handleScaffold(ctx, ws, msg, workingDir, editPlanGate),
         planPrompt: () => handlePrompt(ctx, ws, msg, workingDir, editPlanGate),
@@ -52,9 +53,13 @@ export function buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate) {
         queueClearComposerPrompts: () => handleQueueClearComposerPrompts(ctx, ws, msg, workingDir, editPlanGate),
     };
 }
-export function handlePlanMessage(ctx, ws, msg, _tabId, workingDir, role) {
+export function handlePlanMessage(ctx, ws, msg, _tabId, workingDir, role, 
+viewerId) {
     const editPlanGate = can(role, 'editPlan') ? undefined : 'view';
-    const handlers = buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate);
+    const handlers = buildPlanHandlers(ctx, ws, msg, workingDir, editPlanGate, {
+        role,
+        ...(viewerId ? { viewerId } : {}),
+    });
     try {
         dispatchByType(handlers, 'plan', msg.type, (type) => {
             ctx.send(ws, { type: 'planError', data: { error: `Unknown plan message type: ${type}` } });