@myagentroam/node 0.11.35 → 0.11.37

package/dist/runtime-state.js

@@ -1,12 +1,9 @@
 import { randomUUID } from 'node:crypto';
-import { projectConversationWorkProcesses } from './service/conversation-work-process.js';
+import { RuntimeApprovals } from './session/runtime/approvals.js';
+import { projectConversationEvent, conversationItemFromEvent, activeConversationItem, completedStatusForRun } from './session/runtime/conversation-projection.js';
 import { nodeLog } from './operational.js';
 import { safeErrorCode } from './util/safe-error.js';
-import { permissionStopSchema } from '@myagentroam/protocol';
 /** User inputs arrive with a durable Session identity, unlike execution-local output IDs. */
-export function runConversationItemId(runId, itemId, kind) {
-    return kind === 'user_message' ? itemId : `${runId}:${itemId}`;
-}
 /**
  * Deliberately process-local runtime domain.  No method in this class writes
  * into Node SQLite: a Node restart loses active runs, approvals, leases and
@@ -18,6 +15,26 @@ export class NodeRuntimeState {
     getWorkspace;
     now;
     onRunChanged;
+    activeExecutions = new Set();
+    interruptedExecutions = new Set();
+    executionAccepted(executionId) {
+        this.activeExecutions.add(executionId);
+    }
+    executionReleased(executionId) {
+        this.activeExecutions.delete(executionId);
+    }
+    isExecutionActive(executionId) {
+        return this.activeExecutions.has(executionId);
+    }
+    activeExecutionCount() {
+        return this.activeExecutions.size;
+    }
+    requestExecutionInterrupt(executionId) {
+        this.interruptedExecutions.add(executionId);
+    }
+    isExecutionInterruptRequested(executionId) {
+        return this.interruptedExecutions.has(executionId);
+    }
     static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
@@ -33,7 +50,7 @@ export class NodeRuntimeState {
     turns = new Map();
     /** New Sessions retain their full history until the bounded Runtime window drops a Turn. */
     completeHistorySessions = new Set();
-    approvals = new Map();
+    approvalState = new RuntimeApprovals((runId) => this.getRun(runId), (runId) => this.currentExecutionId(runId), (runId) => this.canonicalRunId(runId), () => this.now());
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     leases = new Map();
     /** Blocks new Runs or queued messages while native history is being destructively replaced. */
@@ -795,6 +812,21 @@ export class NodeRuntimeState {
         }));
         return value;
     }
+    acceptExecutionTerminal(input) {
+        const run = this.getRun(input.runId);
+        if (run === undefined)
+            return { recorded: undefined, current: false, interrupted: false };
+        const currentId = this.currentExecutionId(run.id);
+        const current = currentId === input.runId || (currentId === undefined && input.runId === run.id);
+        const recorded = this.appendRunEvent(input);
+        if (recorded === undefined)
+            return { recorded, current, interrupted: false };
+        if (current && input.pauseQueue)
+            this.pauseSessionQueue(run.sessionId);
+        this.activeExecutions.delete(input.runId);
+        const interrupted = this.interruptedExecutions.delete(input.runId);
+        return { recorded, current, interrupted: current && interrupted };
+    }
     appendRunEvent(input) {
         const execution = this.executions.get(input.runId);
         const runId = execution?.runId ?? input.runId;
@@ -985,65 +1017,22 @@ export class NodeRuntimeState {
         return completedTurn;
     }
     createApproval(input) {
-        const run = this.getRun(input.runId);
-        if (run === undefined)
-            throw new Error('RUN_NOT_FOUND');
-        if (input.runId !== run.id && this.currentExecutionId(run.id) !== input.runId)
-            throw new Error('RUN_EXECUTION_NOT_CURRENT');
-        if (this.approvals.has(input.approvalId))
-            throw new Error('APPROVAL_ALREADY_EXISTS');
-        if (input.expiresAt <= this.now())
-            throw new Error('APPROVAL_EXPIRED');
-        const value = {
-            id: input.approvalId,
-            runId: input.runId,
-            status: 'PENDING',
-            payload: input.payload,
-            expiresAt: input.expiresAt,
-            createdAt: this.now(),
-            decidedAt: null
-        };
-        this.approvals.set(value.id, value);
-        return value;
+        return this.approvalState.createApproval(input);
     }
     getApproval(id) {
-        const value = this.approvals.get(id);
-        if (value?.status === 'PENDING' && value.expiresAt <= this.now())
-            return this.expireApproval(id);
-        return value;
+        return this.approvalState.getApproval(id);
     }
     listApprovals(runId) {
-        const canonicalRunId = this.canonicalRunId(runId);
-        return [...this.approvals.values()]
-            .filter((value) => this.canonicalRunId(value.runId) === canonicalRunId)
-            .map((value) => this.getApproval(value.id));
+        return this.approvalState.listApprovals(runId);
     }
     expireApproval(id) {
-        const value = this.requireApproval(id);
-        if (value.status !== 'PENDING')
-            return value;
-        if (value.expiresAt > this.now())
-            throw new Error('APPROVAL_NOT_EXPIRED');
-        const next = { ...value, status: 'EXPIRED', decidedAt: this.now() };
-        this.approvals.set(id, next);
-        return next;
+        return this.approvalState.expireApproval(id);
     }
     decideApproval(id, decision) {
-        const value = this.getApproval(id);
-        if (value === undefined)
-            throw new Error('APPROVAL_NOT_FOUND');
-        if (value.status === 'EXPIRED')
-            throw new Error('APPROVAL_EXPIRED');
-        if (value.status !== 'PENDING')
-            throw new Error('APPROVAL_ALREADY_DECIDED');
-        const next = { ...value, status: decision, decidedAt: this.now() };
-        this.approvals.set(id, next);
-        return next;
+        return this.approvalState.decideApproval(id, decision);
     }
     expireDueApprovals() {
-        return [...this.approvals.values()]
-            .filter((value) => value.status === 'PENDING' && value.expiresAt <= this.now())
-            .map((value) => this.expireApproval(value.id));
+        return this.approvalState.expireDueApprovals();
     }
     listNonterminalRuns() {
         return [...this.runs.values()].filter((run) => !terminal(run.status));
@@ -1100,9 +1089,7 @@ export class NodeRuntimeState {
                 this.messageSubmissions.delete(key);
                 this.rememberTerminalMessageSubmission(key, runId);
             }
-        for (const [approvalId, approval] of this.approvals)
-            if (approval.runId === runId || executionIds.has(approval.runId))
-                this.approvals.delete(approvalId);
+        this.approvalState.removeRun(runId, executionIds);
     }
     clearTerminalMessageSubmissions(sessionId) {
         for (const key of this.terminalMessageSubmissions.keys())
@@ -1153,9 +1140,7 @@ export class NodeRuntimeState {
         for (const key of this.failedMessageSubmissions.keys())
             if (key.startsWith(`${sessionId}\u0000`))
                 this.failedMessageSubmissions.delete(key);
-        for (const [approvalId, approval] of this.approvals)
-            if (runIds.has(approval.runId) || executionIds.has(approval.runId))
-                this.approvals.delete(approvalId);
+        this.approvalState.removeRuns(runIds, executionIds);
     }
     beginSessionHistoryMutation(sessionId, options) {
         if (this.sessionHistoryMutations.has(sessionId))
@@ -1226,9 +1211,7 @@ export class NodeRuntimeState {
             if (separator >= 0 && sessionIds.has(key.slice(0, separator)))
                 this.failedMessageSubmissions.delete(key);
         }
-        for (const [approvalId, approval] of this.approvals)
-            if (runIds.has(approval.runId) || executionIds.has(approval.runId))
-                this.approvals.delete(approvalId);
+        this.approvalState.removeRuns(runIds, executionIds);
         for (const sessionId of sessionIds) {
             const queued = this.queuedItems.get(sessionId) ?? [];
             this.queuedItems.delete(sessionId);
@@ -1310,12 +1293,6 @@ export class NodeRuntimeState {
             throw new Error('QUEUE_ITEM_INVALID');
         return value;
     }
-    requireApproval(id) {
-        const value = this.approvals.get(id);
-        if (value === undefined)
-            throw new Error('APPROVAL_NOT_FOUND');
-        return value;
-    }
     updateTurnForRun(runId, update) {
         const run = this.requireRun(runId);
         const current = this.turns.get(run.sessionId) ?? [];
@@ -1438,146 +1415,7 @@ export class NodeRuntimeState {
             this.currentTurnForRun(event.runId) === undefined &&
             conversationItemFromEvent(event) !== undefined)
             this.createItemOnlyTurn(run, event.createdAt);
-        let needsProcessProjection = false;
-        const update = (turn) => {
-            if (event.eventType === 'text.delta' &&
-                isRecord(event.payload) &&
-                typeof event.payload.text === 'string') {
-                const nativeItemId = typeof event.payload.itemId === 'string' && event.payload.itemId.length <= 88
-                    ? event.payload.itemId
-                    : undefined;
-                const stableItemId = nativeItemId === undefined ? undefined : `${event.runId}:${nativeItemId}`;
-                const lastItem = turn.items.at(-1);
-                const existing = stableItemId === undefined
-                    ? lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
-                        ? lastItem
-                        : undefined
-                    : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
-                const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
-                const sourceItemId = conversationSourceItemId(event.payload) ?? existing?.sourceItemId;
-                needsProcessProjection =
-                    existing === undefined ||
-                        existing.sourceItemId !== sourceItemId ||
-                        (!readableText(existing.payload).trim() && !!text.trim());
-                const item = {
-                    id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
-                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
-                    sessionId: run.sessionId,
-                    turnId: turn.id,
-                    runId: event.runId,
-                    parentItemId: null,
-                    sourceSequence: existing?.sourceSequence ?? event.sequence,
-                    revision: event.sequence,
-                    kind: 'assistant_message',
-                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
-                    updatedAt: event.createdAt,
-                    status: 'IN_PROGRESS',
-                    payload: { text, format: 'markdown', model: null },
-                    startedAt: existing?.startedAt ?? event.createdAt,
-                    completedAt: null
-                };
-                return {
-                    ...turn,
-                    status: 'RUNNING',
-                    startedAt: turn.startedAt ?? event.createdAt,
-                    items: existing === undefined
-                        ? [...turn.items, item]
-                        : turn.items.map((value) => (value.id === item.id ? item : value))
-                };
-            }
-            const projected = conversationItemFromEvent(event);
-            if (projected !== undefined) {
-                const itemId = runConversationItemId(event.runId, projected.itemId, projected.kind);
-                const trailingItem = turn.items.at(-1);
-                const orderedItems = projected.kind !== 'user_message' &&
-                    trailingItem?.kind === 'assistant_message' &&
-                    activeConversationItem(trailingItem.status)
-                    ? turn.items.map((item) => item.id === trailingItem.id
-                        ? {
-                            ...item,
-                            status: 'COMPLETED',
-                            completedAt: event.createdAt,
-                            updatedAt: event.createdAt
-                        }
-                        : item)
-                    : turn.items;
-                const existing = orderedItems.find((item) => item.id === itemId) ??
-                    (projected.kind === 'assistant_message' &&
-                        projected.itemId.startsWith('codex:') &&
-                        trailingItem?.kind === 'assistant_message' &&
-                        trailingItem.id.startsWith(`${event.runId}:assistant:`) &&
-                        activeConversationItem(trailingItem.status)
-                        ? trailingItem
-                        : undefined);
-                const status = projected.status;
-                const sourceItemId = projected.sourceItemId ?? existing?.sourceItemId;
-                const parentItemId = projected.parentItemId === undefined
-                    ? (existing?.parentItemId ?? null)
-                    : runConversationItemId(event.runId, projected.parentItemId);
-                needsProcessProjection =
-                    existing === undefined ||
-                        existing.kind !== projected.kind ||
-                        projected.kind === 'context_compaction' ||
-                        existing.parentItemId !== parentItemId ||
-                        existing.sourceItemId !== sourceItemId ||
-                        (projected.kind === 'assistant_message' &&
-                            !!readableText(existing.payload).trim() !== !!readableText(projected.payload).trim()) ||
-                        (projected.kind === 'reasoning' && existing.processGroup === undefined);
-                const item = {
-                    id: itemId,
-                    sessionId: run.sessionId,
-                    turnId: turn.id,
-                    runId: event.runId,
-                    parentItemId,
-                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
-                    sourceSequence: existing?.sourceSequence ?? event.sequence,
-                    revision: (existing?.revision ?? -1) + 1,
-                    kind: projected.kind,
-                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
-                    updatedAt: event.createdAt,
-                    status,
-                    payload: mergeConversationItemPayload(existing?.payload, projected),
-                    ...(projected.permissionStop === undefined
-                        ? {}
-                        : { permissionStop: projected.permissionStop }),
-                    startedAt: existing?.startedAt ?? event.createdAt,
-                    completedAt: completedConversationItem(status) ? event.createdAt : null
-                };
-                return {
-                    ...turn,
-                    status: terminal(run.status) ? run.status : 'RUNNING',
-                    startedAt: turn.startedAt ?? event.createdAt,
-                    items: existing === undefined
-                        ? [...orderedItems, item]
-                        : orderedItems.map((value) => (value.id === existing.id ? item : value))
-                };
-            }
-            if (event.eventType === 'run.started' || event.eventType === 'run.running')
-                return { ...turn, status: 'RUNNING', startedAt: turn.startedAt ?? event.createdAt };
-            if (event.eventType === 'run.completed' ||
-                event.eventType === 'run.failed' ||
-                event.eventType === 'run.rejected') {
-                const status = event.status ?? this.requireRun(event.runId).status;
-                return {
-                    ...turn,
-                    status,
-                    completedAt: event.createdAt,
-                    items: turn.items.map((item) => activeConversationItem(item.status)
-                        ? {
-                            ...item,
-                            status: completedStatusForRun(status),
-                            completedAt: event.createdAt
-                        }
-                        : item)
-                };
-            }
-            return turn;
-        };
-        const project = (turn) => {
-            const next = update(turn);
-            // Ordinary token/output updates retain membership; only structural input needs a scan.
-            return needsProcessProjection ? projectConversationWorkProcesses(next) : next;
-        };
+        const project = (turn) => projectConversationEvent(turn, run, event, terminal(run.status));
         if (turnId === undefined)
             this.updateCurrentTurnForRun(event.runId, project);
         else {
@@ -1601,168 +1439,6 @@ function transitionAllowed(from, to) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
-function readableText(value) {
-    return isRecord(value) && typeof value.text === 'string' ? value.text : '';
-}
-function conversationItemFromEvent(event) {
-    if (isRecord(event.payload)) {
-        const approvalId = event.payload.approvalId;
-        if (typeof approvalId === 'string' && approvalId.length > 0) {
-            if (event.eventType === 'approval.request')
-                return {
-                    itemId: `approval:${approvalId}`,
-                    kind: 'approval_request',
-                    status: 'PENDING',
-                    payload: {
-                        approvalId,
-                        approvalStatus: 'PENDING',
-                        approval: event.payload.payload,
-                        expiresAt: event.payload.expiresAt
-                    },
-                    merge: false
-                };
-            if (event.eventType === 'approval.decided') {
-                const decision = event.payload.decision;
-                if (decision === 'APPROVED' || decision === 'REJECTED')
-                    return {
-                        itemId: `approval:${approvalId}`,
-                        kind: 'approval_request',
-                        status: decision === 'APPROVED' ? 'COMPLETED' : 'DECLINED',
-                        payload: { approvalId, approvalStatus: decision },
-                        merge: true
-                    };
-            }
-            if (event.eventType === 'approval.expired')
-                return {
-                    itemId: `approval:${approvalId}`,
-                    kind: 'approval_request',
-                    status: 'CANCELLED',
-                    payload: { approvalId, approvalStatus: 'EXPIRED' },
-                    merge: true
-                };
-        }
-    }
-    if (event.eventType !== 'conversation.item' || !isRecord(event.payload))
-        return undefined;
-    const itemId = event.payload.itemId;
-    const kind = event.payload.kind;
-    const status = event.payload.status;
-    const payload = event.payload.payload;
-    if (typeof itemId !== 'string' ||
-        itemId.length === 0 ||
-        itemId.length > 88 ||
-        typeof kind !== 'string' ||
-        !projectableConversationKind(kind) ||
-        typeof status !== 'string' ||
-        !projectableConversationStatus(status) ||
-        !isRecord(payload))
-        return undefined;
-    const append = event.payload.append;
-    const sourceItemId = conversationSourceItemId(event.payload);
-    const permissionStop = permissionStopSchema.safeParse(event.payload.permissionStop);
-    return {
-        itemId,
-        kind,
-        status,
-        payload,
-        ...(sourceItemId === undefined ? {} : { sourceItemId }),
-        ...(typeof event.payload.parentItemId === 'string' &&
-            event.payload.parentItemId.length > 0 &&
-            event.payload.parentItemId.length <= 88
-            ? { parentItemId: event.payload.parentItemId }
-            : {}),
-        ...(permissionStop.success ? { permissionStop: permissionStop.data } : {}),
-        merge: event.payload.merge === true,
-        ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
-            ? { append }
-            : {})
-    };
-}
-function conversationSourceItemId(payload) {
-    return typeof payload.sourceItemId === 'string' &&
-        payload.sourceItemId.length > 0 &&
-        payload.sourceItemId.length <= 1024
-        ? payload.sourceItemId
-        : undefined;
-}
-function projectableConversationKind(value) {
-    return (value === 'user_message' ||
-        value === 'assistant_message' ||
-        value === 'reasoning' ||
-        value === 'tool_call' ||
-        value === 'command_execution' ||
-        value === 'approval_request' ||
-        value === 'user_input_request' ||
-        value === 'plan' ||
-        value === 'todo_list' ||
-        value === 'file_change' ||
-        value === 'context_compaction' ||
-        value === 'unknown' ||
-        value === 'warning' ||
-        value === 'error');
-}
-function projectableConversationStatus(value) {
-    return [
-        'PENDING',
-        'IN_PROGRESS',
-        'COMPLETED',
-        'FAILED',
-        'DECLINED',
-        'CANCELLED',
-        'INTERRUPTED'
-    ].includes(value);
-}
-function mergeConversationItemPayload(existing, next) {
-    const base = next.merge && isRecord(existing) ? existing : {};
-    const value = { ...base, ...next.payload };
-    if (next.append === 'sections') {
-        const prior = Array.isArray(base.sections) ? base.sections : [];
-        const incoming = Array.isArray(next.payload.sections) ? next.payload.sections : [];
-        const sections = new Map();
-        for (const section of [...prior, ...incoming]) {
-            if (!isRecord(section) ||
-                typeof section.index !== 'number' ||
-                !Number.isInteger(section.index) ||
-                section.index < 0 ||
-                typeof section.text !== 'string')
-                continue;
-            sections.set(section.index, appendProjectionText(sections.get(section.index) ?? '', section.text));
-        }
-        value.sections = [...sections]
-            .sort(([left], [right]) => left - right)
-            .map(([index, text]) => ({ index, text }));
-    }
-    if (next.append === 'outputPreview') {
-        const prior = typeof base.outputPreview === 'string' ? base.outputPreview : '';
-        const incoming = typeof next.payload.outputPreview === 'string' ? next.payload.outputPreview : '';
-        value.outputPreview = appendProjectionText(prior, incoming);
-    }
-    if (next.append === 'outputSummary') {
-        const prior = typeof base.outputSummary === 'string' ? base.outputSummary : '';
-        const incoming = typeof next.payload.outputSummary === 'string' ? next.payload.outputSummary : '';
-        value.outputSummary = appendProjectionText(prior, incoming);
-    }
-    return value;
-}
-function appendProjectionText(previous, next) {
-    const text = `${previous}${next}`;
-    return text.length <= 10_000 ? text : `${text.slice(0, 9_999)}…`;
-}
-function activeConversationItem(status) {
-    return status === 'PENDING' || status === 'IN_PROGRESS';
-}
-function completedConversationItem(status) {
-    return !activeConversationItem(status);
-}
-function completedStatusForRun(status) {
-    if (status === 'INTERRUPTED')
-        return 'INTERRUPTED';
-    if (status === 'CANCELLED')
-        return 'CANCELLED';
-    if (status === 'FAILED')
-        return 'FAILED';
-    return 'COMPLETED';
-}
 function executionStatusForRun(status) {
     if (status === 'FAILED')
         return 'FAILED';

package/dist/service/computer-use-enablement-service.js

@@ -1,6 +1,6 @@
 import { computerUseDisableInputSchema, computerUseEnableInputSchema, computerUseEnableResultSchema } from '@myagentroam/protocol';
 import { computerUseRuntimeExecutable, saveNodeConfig } from '../config.js';
-import { nodeOperationData } from '../util/node-operation-data.js';
+import { nodeOperationData } from '../connection/node-operation-data.js';
 /** Persists Computer Use authorization and owns its asynchronous capability probe. */
 export class ComputerUseEnablementService {
     options;

package/dist/service/continuous-run-coordinator.js

@@ -1,6 +1,6 @@
-import { withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
+import { withNonImageAttachmentPrompt } from '../session/attachments.js';
 import { safeErrorCode } from '../util/safe-error.js';
-import { withSessionPrompt } from '../util/personal-instructions.js';
+import { withSessionPrompt } from '../runner/personal-instructions.js';
 import { prepareComposerResourceInput } from './composer-message-input.js';
 import { nodeLog } from '../operational.js';
 export class ContinuousRunCoordinator {
@@ -18,6 +18,46 @@ export class ContinuousRunCoordinator {
     constructor(options) {
         this.options = options;
     }
+    acceptExecutionTerminal(input) {
+        const run = this.options.runtime.getRun(input.executionId);
+        if (run === undefined)
+            return { recorded: undefined, manuallyInterrupted: false };
+        let accepted;
+        try {
+            accepted = this.options.runtime.acceptExecutionTerminal({
+                runId: input.executionId,
+                sequence: input.sequence,
+                eventType: input.eventType,
+                payload: input.payload,
+                status: input.status,
+                pauseQueue: input.permissionStop !== undefined
+            });
+        }
+        catch {
+            return { recorded: undefined, manuallyInterrupted: false };
+        }
+        const { recorded, interrupted: manuallyInterrupted } = accepted;
+        if (recorded === undefined || !accepted.current)
+            return { recorded, manuallyInterrupted };
+        const goalResult = this.options.executionTerminating(input.executionId, input.status, input.permissionStop);
+        const queue = this.options.runtime.sessionQueue(run.sessionId);
+        const continues = run.status !== 'CANCELLING' &&
+            input.permissionStop === undefined &&
+            ((!queue.paused && queue.itemIds.length > 0) || this.options.keepRunActive(run.sessionId));
+        let finalStatus;
+        if (!continues) {
+            finalStatus =
+                input.status === 'CANCELLED' || manuallyInterrupted ? 'INTERRUPTED' : input.status;
+            if (finalStatus === 'SUCCEEDED' || finalStatus === 'FAILED' || finalStatus === 'INTERRUPTED')
+                this.options.runtime.finishRun(run.id, finalStatus);
+        }
+        return {
+            recorded,
+            manuallyInterrupted,
+            ...(finalStatus === undefined ? {} : { finalStatus }),
+            ...goalResult
+        };
+    }
     suspend() {
         this.suspended = true;
         for (const timer of this.scheduledSessions.values())
@@ -430,7 +470,7 @@ export class ContinuousRunCoordinator {
                 : `${pending.precedingInput}\n\n${resources}`, pending.attachmentPaths, pending.attachmentFiles)
         });
     }
-    deleteQueueItem(itemId) {
+    deleteQueueItem(itemId, publish = true) {
         const item = this.options.runtime.getQueueItem(itemId);
         if (item === undefined)
             throw new Error('QUEUE_ITEM_INVALID');
@@ -438,7 +478,8 @@ export class ContinuousRunCoordinator {
         this.remove(item.id);
         this.options.clearImages(item.id);
         this.options.cleanupAttachments(item.id);
-        this.options.emitQueue(item.workspaceId, item.sessionId);
+        if (publish)
+            this.options.emitQueue(item.workspaceId, item.sessionId);
     }
     publishCurrentTurn(runId) {
         const turn = this.options.runtime.conversationTurnForRun(runId);
@@ -725,7 +766,8 @@ export class ContinuousRunCoordinator {
         if (lease !== undefined)
             this.environmentLeases.set(nextId, lease);
     }
-    removeGoalQueue(sessionId, preservedGoal, preservedSubmissionId) {
+    removeGoalQueue(sessionId, preservedGoal, preservedSubmissionId, publish = true) {
+        let changed = false;
         for (const [id, pending] of this.preparedInputs) {
             if (id === preservedSubmissionId)
                 continue;
@@ -737,9 +779,12 @@ export class ContinuousRunCoordinator {
             if (pending.goal.id === preservedGoal?.id && pending.goal.revision === preservedGoal.revision)
                 continue;
             const item = this.options.runtime.getQueueItem(id);
-            if (item !== undefined)
-                this.deleteQueueItem(id);
+            if (item !== undefined) {
+                this.deleteQueueItem(id, publish);
+                changed = true;
+            }
         }
+        return changed;
     }
     removePendingQueue(sessionId, preservedItemId) {
         for (const itemId of [...this.options.runtime.sessionQueue(sessionId).itemIds]) {

package/dist/service/conversation-history-service.js

@@ -1,8 +1,8 @@
-import { projectConversationWorkProcesses } from './conversation-work-process.js';
+import { projectConversationWorkProcesses } from '../session/runtime/work-process.js';
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
-import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
-import { conversationClientMessageId } from '../util/conversation-identity.js';
+import { nativeConversationPage } from '../session/runner-native-session-parsers.js';
+import { isPlainRecord } from '../util/records.js';
+import { conversationClientMessageId } from '../session/conversation-identity.js';
 import { nodeLog } from '../operational.js';
 export function hasManagedActiveRun(runtime, session) {
     const current = runtime.getAgentSession(session.id) ?? session;

package/dist/service/conversation-hosting-capability-service.js

@@ -3,7 +3,7 @@ import { mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { safeErrorCode } from '../util/safe-error.js';
-import { hostedConversationSandboxProfile } from './hosted-conversation-sandbox-profile.js';
+import { hostedConversationSandboxProfile } from '../hosting/hosted-conversation-sandbox-profile.js';
 const CONVERSATION_HOSTING_API_VERSION = 1;
 /** Runs the same bounded Bubblewrap policy used by hosted local processes. */
 export async function probeBubblewrap() {

package/dist/service/conversation-hosting-enablement-service.js

@@ -1,6 +1,6 @@
 import { conversationHostingDisableInputSchema, conversationHostingEnableInputSchema, conversationHostingEnableResultSchema } from '@myagentroam/protocol';
 import { saveNodeConfig } from '../config.js';
-import { nodeOperationData } from '../util/node-operation-data.js';
+import { nodeOperationData } from '../connection/node-operation-data.js';
 /** Owns management operations that persist and hot-apply hosting configuration. */
 export class ConversationHostingEnablementService {
     options;

package/dist/service/conversation-hosting-lifecycle-service.js

@@ -1,11 +1,11 @@
 import { hostedConversationStorePath, nodeDataDirectory } from '../config.js';
-import { HostedConversationStore } from './hosted-conversation-store.js';
+import { HostedConversationStore } from '../hosting/hosted-conversation-store.js';
 import { ConversationTemplateNodeService } from './conversation-template-node-service.js';
-import { HostedConversationNodeService } from './hosted-conversation-node-service.js';
+import { HostedConversationNodeService } from '../hosting/hosted-conversation-node-service.js';
 import { ConversationHostingMaintenanceService } from './conversation-hosting-maintenance-service.js';
 import { MarAgentHostedConversationRuntime } from '../runner/mar-agent/hosted-conversation-runtime.js';
 import { BubblewrapSandboxExecutor } from '@myagentroam/agent/sandbox/linux';
-import { hostedConversationSandboxProfile } from './hosted-conversation-sandbox-profile.js';
+import { hostedConversationSandboxProfile } from '../hosting/hosted-conversation-sandbox-profile.js';
 import { conversationHostingCapability } from './conversation-hosting-capability-service.js';
 import { nodeLog } from '../operational.js';
 import { safeErrorCode } from '../util/safe-error.js';

package/dist/service/conversation-hosting-maintenance-service.js

@@ -1,6 +1,6 @@
 import { statfs } from 'node:fs/promises';
 import { conversationHostingCleanupExecuteInputSchema, conversationHostingCleanupPreviewInputSchema, conversationHostingCleanupPreviewSchema, conversationHostingCleanupResultSchema, conversationHostingStorageCapacitySchema } from '@myagentroam/protocol';
-import { nodeOperationData } from '../util/node-operation-data.js';
+import { nodeOperationData } from '../connection/node-operation-data.js';
 const DAY_MS = 24 * 60 * 60 * 1_000;
 const AUTOMATIC_CLEANUP_INTERVAL_MS = DAY_MS;
 /** Owns aggregate storage watermarks and permanent hosted-conversation cleanup. */