@myagentroam/agent 0.10.60 → 0.10.61

package/dist/agent-core/session/store/types.d.ts

@@ -56,6 +56,7 @@ export interface SessionMeta {
     storageTransactionId?: string;
     resume?: {
         version: 1;
+        userTurns?: number;
         compactSequence?: number;
         gcSequence?: number;
         gcGeneration?: number;

package/dist/agent-core/subagent/scheduler.js

@@ -12,7 +12,7 @@ export class SubagentScheduler {
     #disposed = false;
     #createdInExecution = 0;
     #runner;
-    constructor(runner, limits = { maxTasks: 8, maxConcurrent: 4 }) {
+    constructor(runner, limits = { maxTasks: 16, maxConcurrent: 16 }) {
         this.limits = limits;
         this.#runner = runner;
     }

package/dist/agent-core/subagent/session-controller.d.ts

@@ -78,7 +78,7 @@ export interface SubagentSessionControllerBackend {
     }>;
     deleteSession(sessionId: string): Promise<void>;
     /** Returns children in durable creation order. */
-    listChildren(parentSessionId: string): Promise<readonly PersistedSubagentSession[]>;
+    listChildren(parentSessionId: string): Promise<readonly Omit<PersistedSubagentSession, 'records'>[]>;
     loadChild(parentSessionId: string, sessionId: string): Promise<PersistedSubagentSession | undefined>;
 }
 export declare class SubagentSessionController implements SubagentController {
@@ -109,6 +109,9 @@ export declare class SubagentSessionController implements SubagentController {
     withOperation<T>(operation: SubagentParentOperation, run: () => T): T;
     inspect(agentId: string): Promise<SubagentTaskSnapshot>;
     inspectAll(): readonly SubagentTaskSnapshot[];
+    /** Full listing is explicit; ordinary opens and executions never require it. */
+    prepareAll(signal?: AbortSignal): Promise<void>;
+    prepareSessionResources(signal?: AbortSignal): Promise<void>;
     collectModelUpdates(): readonly {
         snapshot: SubagentTaskSnapshot;
         truncated: boolean;

package/dist/agent-core/subagent/session-controller.js

@@ -4,12 +4,16 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../error.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
 import { parseAgentWaitTargets, waitForAgentCondition } from './wait.js';
+const RECENT_TERMINAL_RESOURCE_LIMIT = 16;
 export class SubagentSessionController {
     parentSessionId;
     rootSessionId;
     backend;
     limits;
     #agents = new Map();
+    // Discovery order is independent of the order in which history is requested.
+    #discovered = new Map();
+    #loading = new Map();
     #queue = [];
     #completionWaiters = new Set();
     #activityWaiters = new Set();
@@ -35,7 +39,7 @@ export class SubagentSessionController {
     #retainedExecution = new AsyncLocalStorage();
     #execution;
     #pendingDeliveries = new Set();
-    constructor(parentSessionId, rootSessionId, backend, limits = { maxTasks: 8, maxConcurrent: 4 }) {
+    constructor(parentSessionId, rootSessionId, backend, limits = { maxTasks: 16, maxConcurrent: 16 }) {
         this.parentSessionId = parentSessionId;
         this.rootSessionId = rootSessionId;
         this.backend = backend;
@@ -43,11 +47,12 @@ export class SubagentSessionController {
     }
     static async open(input) {
         const controller = new SubagentSessionController(input.parentSessionId, input.rootSessionId, input.backend, input.limits);
-        const sessions = [...(await input.backend.listChildren(input.parentSessionId))].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt));
-        for (const session of sessions) {
-            const state = restoreAgentState(session);
-            state.resourceRevision = ++controller.#resourceRevision;
-            controller.#agents.set(session.id, state);
+        const sessions = await input.backend.listChildren(input.parentSessionId);
+        // Map insertion order is creation order; values independently rank activity.
+        for (const session of sessions)
+            controller.#discovered.set(session.id, 0);
+        for (const session of [...sessions].sort((a, b) => a.lastActivityAt.localeCompare(b.lastActivityAt))) {
+            controller.#discovered.set(session.id, ++controller.#resourceRevision);
         }
         return controller;
     }
@@ -98,7 +103,49 @@ export class SubagentSessionController {
     inspectAll() {
         if (this.#disposed)
             throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
-        return [...this.#agents.values()].map((state) => this.#snapshot(state, { full: true }));
+        return this.#orderedStates().map((state) => this.#snapshot(state, { full: true }));
+    }
+    /** Full listing is explicit; ordinary opens and executions never require it. */
+    async prepareAll(signal) {
+        for (const id of this.#discovered.keys()) {
+            signal?.throwIfAborted();
+            await this.#restoreDiscovered(id);
+        }
+        signal?.throwIfAborted();
+    }
+    async prepareSessionResources(signal) {
+        const candidates = [...this.#discovered]
+            .filter(([id]) => {
+            const state = this.#agents.get(id);
+            return !state || isTerminalState(state);
+        })
+            .sort(([a, ar], [b, br]) => (this.#agents.get(b)?.resourceRevision ?? br) -
+            (this.#agents.get(a)?.resourceRevision ?? ar));
+        let prepared = 0;
+        for (const [id] of candidates) {
+            signal?.throwIfAborted();
+            const state = await this.#restoreDiscovered(id);
+            if (state && isTerminalState(state) && ++prepared === RECENT_TERMINAL_RESOURCE_LIMIT)
+                break;
+        }
+        signal?.throwIfAborted();
+    }
+    async #restoreDiscovered(agentId) {
+        try {
+            return await this.#find(agentId);
+        }
+        catch (error) {
+            if (!(error instanceof MarAgentError) || error.code !== 'MAR_AGENT_SUBAGENT_NOT_FOUND')
+                throw error;
+            this.#discovered.delete(agentId);
+            return undefined;
+        }
+    }
+    #orderedStates() {
+        return [...this.#discovered.keys()].flatMap((id) => {
+            const state = this.#agents.get(id);
+            return state ? [state] : [];
+        });
     }
     collectModelUpdates() {
         return [...this.#agents.values()]
@@ -223,6 +270,7 @@ export class SubagentSessionController {
         if (!native)
             (this.#retainedExecution.getStore()?.budget ?? this.#creationBudget).count++;
         this.#agents.set(state.agentId, state);
+        this.#discovered.set(state.agentId, state.resourceRevision);
         const knownModel = execution.models.get(input.modelId ?? execution.modelId);
         if (knownModel) {
             state.modelId = knownModel.id;
@@ -335,7 +383,16 @@ export class SubagentSessionController {
         if (options.untilSettled)
             throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'An unbounded wait requires an agent id.');
         validateOutputOptions(options, this.#retainedExecution.getStore()?.native === true);
-        const states = [...this.#agents.values()];
+        const hasLive = [...this.#agents.values()].some((state) => !isTerminalState(state));
+        if (!hasLive) {
+            for (const id of [...this.#discovered.keys()].reverse()) {
+                options.signal?.throwIfAborted();
+                if (await this.#restoreDiscovered(id))
+                    break;
+            }
+        }
+        options.signal?.throwIfAborted();
+        const states = this.#orderedStates();
         if (states.length === 0)
             throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
         const live = states.filter((state) => state.status === 'queued' || state.status === 'running');
@@ -625,7 +682,7 @@ export class SubagentSessionController {
         const terminal = states
             .filter((state) => state.status !== 'queued' && state.status !== 'running')
             .sort((left, right) => right.resourceRevision - left.resourceRevision)
-            .slice(0, 8);
+            .slice(0, RECENT_TERMINAL_RESOURCE_LIMIT);
         return [...active, ...terminal].map((state) => ({
             agentId: state.agentId,
             status: state.status,
@@ -946,6 +1003,7 @@ export class SubagentSessionController {
     }
     async #deleteUnstartedSession(agentId, error) {
         this.#agents.delete(agentId);
+        this.#discovered.delete(agentId);
         try {
             await this.backend.deleteSession(agentId);
         }
@@ -957,15 +1015,41 @@ export class SubagentSessionController {
         throw error;
     }
     async #find(agentId) {
+        if (this.#disposed)
+            throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
         const known = this.#agents.get(agentId);
         if (known)
             return known;
-        const persisted = await this.backend.loadChild(this.parentSessionId, agentId);
-        if (!persisted)
-            throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
-        const restored = restoreAgentState(persisted);
-        this.#agents.set(agentId, restored);
-        return restored;
+        const pending = this.#loading.get(agentId);
+        if (pending)
+            return pending;
+        const load = (async () => {
+            const persisted = await this.backend.loadChild(this.parentSessionId, agentId);
+            if (this.#disposed)
+                throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
+            if (!persisted)
+                throw new MarAgentError('MAR_AGENT_SUBAGENT_NOT_FOUND', 'Subagent was not found.');
+            const existing = this.#agents.get(agentId);
+            if (existing)
+                return existing;
+            const restored = restoreAgentState(persisted);
+            let revision = this.#discovered.get(agentId);
+            if (revision === undefined) {
+                revision = ++this.#resourceRevision;
+                this.#discovered.set(agentId, revision);
+            }
+            restored.resourceRevision = revision;
+            this.#agents.set(agentId, restored);
+            return restored;
+        })();
+        this.#loading.set(agentId, load);
+        try {
+            return await load;
+        }
+        finally {
+            if (this.#loading.get(agentId) === load)
+                this.#loading.delete(agentId);
+        }
     }
     #requireExecution() {
         if (this.#disposed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.10.60",
+  "version": "0.10.61",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",