@myagentroam/node 0.9.159 → 0.9.160

package/dist/connector.js

@@ -756,6 +756,7 @@ export class NodeConnector {
             mcps: (workspaceId) => this.database?.effectiveMcpInstallations(workspaceId) ?? [],
             retainEnvironment: (environment) => this.gitExecution().retain(environment),
             goalCurrent: (input) => input.goal === undefined || this.goalGenerationCurrent(input.sessionId, input.goal),
+            goalActive: (sessionId) => this.goalRuntime.get(sessionId)?.status === 'active',
             afterExecutionStarted: async (input) => {
                 if (input.goal === undefined)
                     return;

package/dist/runtime-state.js

@@ -22,6 +22,8 @@ export class NodeRuntimeState {
     retainedExecutionTurns = new Map();
     runSequences = new Map();
     turns = new Map();
+    /** New Sessions retain their full history until the bounded Runtime window drops a Turn. */
+    completeHistorySessions = new Set();
     approvals = new Map();
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     leases = new Map();
@@ -84,6 +86,8 @@ export class NodeRuntimeState {
             createdAt: input.createdAt ?? now
         };
         this.sessions.set(value.id, value);
+        if (input.externalSessionId === undefined)
+            this.completeHistorySessions.add(value.id);
         return value;
     }
     /** Internal envelope compatibility for a Run already accepted in this process. */
@@ -114,6 +118,8 @@ export class NodeRuntimeState {
                 createdAt: now
             };
             this.sessions.set(session.id, session);
+            if (input.externalSessionId === undefined)
+                this.completeHistorySessions.add(session.id);
         }
         const existing = this.getRun(input.runId);
         if (existing !== undefined)
@@ -200,6 +206,8 @@ export class NodeRuntimeState {
         const paused = this.pausedQueues.has(id);
         this.sessions.delete(id);
         this.sessions.set(nativeSessionId, next);
+        if (this.completeHistorySessions.delete(id))
+            this.completeHistorySessions.add(nativeSessionId);
         this.promotedSessionAliases.set(id, nativeSessionId);
         for (const [alias, target] of this.promotedSessionAliases)
             if (target === id)
@@ -749,6 +757,7 @@ export class NodeRuntimeState {
         const slice = all.slice(start, end);
         return {
             turns: slice,
+            historyComplete: this.completeHistorySessions.has(input.sessionId),
             nextCursor: start > 0 ? encodeCursor(input.sessionId, start) : null
         };
     }
@@ -908,6 +917,8 @@ export class NodeRuntimeState {
         const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
         const retainedTurns = turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id));
         const retainedTurnIds = new Set(retainedTurns.map((turn) => turn.id));
+        if (retainedTurns.length < (this.turns.get(run.sessionId)?.length ?? 0))
+            this.completeHistorySessions.delete(run.sessionId);
         this.turns.set(run.sessionId, retainedTurns);
         for (const [executionId, execution] of this.executions) {
             if (execution.runId !== runId)
@@ -947,6 +958,7 @@ export class NodeRuntimeState {
             .filter((execution) => runIds.has(execution.runId))
             .map((execution) => execution.id));
         this.sessions.delete(sessionId);
+        this.completeHistorySessions.delete(sessionId);
         this.removePromotedSessionAliases(sessionId);
         this.turns.delete(sessionId);
         this.pruneRetainedExecutionTurns(sessionId, new Set());
@@ -998,6 +1010,7 @@ export class NodeRuntimeState {
         if (this.sessionQueue(sessionId).itemIds.length > 0)
             throw new Error('SESSION_QUEUE_NOT_EMPTY');
         this.turns.delete(sessionId);
+        this.completeHistorySessions.delete(sessionId);
         this.pruneRetainedExecutionTurns(sessionId, new Set());
         for (const key of this.failedMessageSubmissions.keys())
             if (key.startsWith(`${sessionId}\u0000`))
@@ -1017,6 +1030,7 @@ export class NodeRuntimeState {
         const queueItemIds = new Set([...sessionIds].flatMap((sessionId) => this.queuedItems.get(sessionId) ?? []));
         for (const sessionId of sessionIds) {
             this.sessions.delete(sessionId);
+            this.completeHistorySessions.delete(sessionId);
             this.removePromotedSessionAliases(sessionId);
             this.turns.delete(sessionId);
             this.pruneRetainedExecutionTurns(sessionId, new Set());

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

@@ -7,6 +7,7 @@ export class ContinuousRunCoordinator {
     dispatchedExecutions = new Set();
     startedExecutions = new Set();
     scheduledSessions = new Map();
+    immediateQueueItems = new Set();
     constructor(options) {
         this.options = options;
     }
@@ -106,10 +107,13 @@ export class ContinuousRunCoordinator {
         if (startsAcceptedRun || !input.queueBefore.paused || input.intent !== 'QUEUE')
             this.options.runtime.resumeSessionQueue(sessionId);
         if (input.activeRunId !== undefined && active?.id === input.activeRunId) {
+            if (item !== undefined)
+                this.immediateQueueItems.add(item.id);
             if (executionEnded) {
                 if (item !== undefined)
                     this.options.runtime.prioritizeQueueItem(item.id);
-                this.schedule(sessionId);
+                this.publish(sessionId);
+                this.scheduleImmediate(sessionId);
                 return 'RESTARTING';
             }
             if (this.options.runtime.currentExecutionId(active.id) === undefined &&
@@ -126,6 +130,13 @@ export class ContinuousRunCoordinator {
             this.schedule(sessionId);
             return 'STARTED';
         }
+        if (item !== undefined &&
+            prepared?.goal === undefined &&
+            this.options.goalActive?.(sessionId)) {
+            if (this.options.runtime.sessionQueue(sessionId).version !== queueVersionBeforeSettle)
+                this.publish(sessionId);
+            return 'QUEUED';
+        }
         if (active === undefined && item !== undefined) {
             if (input.queueBefore.paused && input.intent === 'SEND')
                 this.options.runtime.prioritizeQueueItem(item.id);
@@ -133,10 +144,12 @@ export class ContinuousRunCoordinator {
             return 'STARTED';
         }
         if (executionEnded && item !== undefined) {
-            if (input.intent === 'SEND')
+            if (input.queueBefore.paused && input.intent === 'SEND') {
                 this.options.runtime.prioritizeQueueItem(item.id);
+                this.publish(sessionId);
+            }
             this.schedule(sessionId);
-            return 'STARTED';
+            return this.nextQueueItem(sessionId) === item.id ? 'STARTED' : 'QUEUED';
         }
         if (this.options.runtime.sessionQueue(sessionId).version !== queueVersionBeforeSettle)
             this.publish(sessionId);
@@ -144,11 +157,18 @@ export class ContinuousRunCoordinator {
     }
     executeQueueItem(itemId) {
         const item = this.requirePreparedItem(itemId);
+        this.immediateQueueItems.add(item.id);
         this.options.runtime.resumeSessionQueue(item.sessionId);
         this.options.runtime.prioritizeQueueItem(item.id);
         const active = this.options.runtime.activeSessionRun(item.sessionId);
         if (active !== undefined) {
-            this.replace(item.id, active.id, false);
+            if (this.options.runtime.currentExecutionId(active.id) !== undefined)
+                this.replace(item.id, active.id, false);
+            else {
+                this.publish(item.sessionId);
+                if (this.isMessageRun(active))
+                    this.scheduleImmediate(item.sessionId);
+            }
             return { run: active, delivery: 'RESTARTING' };
         }
         this.startIdleQueue(item.sessionId);
@@ -222,6 +242,13 @@ export class ContinuousRunCoordinator {
         this.scheduledSessions.set(sessionId, timer);
         timer.unref();
     }
+    scheduleImmediate(sessionId) {
+        const timer = this.scheduledSessions.get(sessionId);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.scheduledSessions.delete(sessionId);
+        this.schedule(sessionId);
+    }
     async dispatch(sessionId) {
         const active = this.options.runtime.activeSessionRun(sessionId);
         if (active === undefined)
@@ -233,7 +260,7 @@ export class ContinuousRunCoordinator {
             ? this.preparedInputs.get(active.id)
             : this.preparedInputs.get(executionId);
         if (executionId === undefined && pending === undefined) {
-            const itemId = this.options.runtime.sessionQueue(sessionId).itemIds[0];
+            const itemId = this.nextQueueItem(sessionId);
             if (itemId === undefined)
                 return;
             pending = this.preparedInputs.get(itemId);
@@ -247,10 +274,12 @@ export class ContinuousRunCoordinator {
                 this.schedule(sessionId);
                 return;
             }
+            this.prioritizeNextQueueItem(sessionId, itemId);
             if (this.options.runtime.claimNextQueueItem(sessionId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths)) === undefined)
                 return;
             const execution = this.options.runtime.createExecution(active.id);
             executionId = execution.id;
+            this.immediateQueueItems.delete(itemId);
             this.preparedInputs.delete(itemId);
             this.moveEnvironmentLease(itemId, execution.id);
             this.preparedInputs.set(execution.id, { ...pending, runId: execution.id });
@@ -369,6 +398,7 @@ export class ContinuousRunCoordinator {
         }
     }
     remove(id) {
+        this.immediateQueueItems.delete(id);
         this.environmentLeases.get(id)?.();
         this.environmentLeases.delete(id);
         this.preparedInputs.delete(id);
@@ -408,6 +438,7 @@ export class ContinuousRunCoordinator {
         this.preparedInputs.clear();
         this.dispatchedExecutions.clear();
         this.startedExecutions.clear();
+        this.immediateQueueItems.clear();
         for (const timer of this.scheduledSessions.values())
             clearTimeout(timer);
         this.scheduledSessions.clear();
@@ -417,8 +448,7 @@ export class ContinuousRunCoordinator {
             this.schedule(sessionId);
             return;
         }
-        const queue = this.options.runtime.sessionQueue(sessionId);
-        const itemId = queue.paused ? undefined : queue.itemIds[0];
+        const itemId = this.nextQueueItem(sessionId);
         if (itemId === undefined)
             return;
         const pending = this.preparedInputs.get(itemId);
@@ -432,13 +462,30 @@ export class ContinuousRunCoordinator {
             this.startIdleQueue(sessionId);
             return;
         }
+        this.prioritizeNextQueueItem(sessionId, itemId);
         const { run, turn } = this.options.runtime.startRunFromQueueItem(itemId, withNonImageAttachmentPrompt(item.content, pending.attachmentPaths));
+        this.immediateQueueItems.delete(itemId);
         this.preparedInputs.delete(itemId);
         this.preparedInputs.set(run.id, { ...pending, runId: run.id });
         this.options.emitQueue(run.workspaceId, sessionId);
         this.options.emitConversation(turn);
         this.schedule(sessionId);
     }
+    nextQueueItem(sessionId) {
+        const queue = this.options.runtime.sessionQueue(sessionId);
+        if (queue.paused)
+            return undefined;
+        const immediate = queue.itemIds.find((id) => this.immediateQueueItems.has(id));
+        if (immediate !== undefined)
+            return immediate;
+        if (this.options.goalActive?.(sessionId))
+            return queue.itemIds.find((id) => this.preparedInputs.get(id)?.goal !== undefined);
+        return queue.itemIds[0];
+    }
+    prioritizeNextQueueItem(sessionId, itemId) {
+        if (this.options.runtime.sessionQueue(sessionId).itemIds[0] !== itemId)
+            this.options.runtime.prioritizeQueueItem(itemId);
+    }
     requirePreparedItem(itemId) {
         const item = this.options.runtime.getQueueItem(itemId);
         if (item === undefined)

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

@@ -373,7 +373,7 @@ export class ConversationHistoryService {
                 beforeAt,
                 cursor: runtimePage.nextCursor
             })
-            : session.externalSessionId === null
+            : session.externalSessionId === null || runtimePage.historyComplete === true
                 ? null
                 : encodeActiveHistoryCursor({
                     sessionId: session.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.159",
+  "version": "0.9.160",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -36,10 +36,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.159",
+    "@myagentroam/agent": "0.9.160",
     "@myagentroam/code-navigation": "0.9.129",
     "@myagentroam/marctl": "0.9.120",
-    "@myagentroam/protocol": "0.9.159"
+    "@myagentroam/protocol": "0.9.160"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"