@myagentroam/node 0.11.73 → 0.12.0

package/dist/runner/mar-agent/hosted-conversation-runtime.js

@@ -9,7 +9,8 @@ import { MarAgentRuntimeModelFactory, sdkModelConfigurations, closeImageCredenti
 import { createImageGenerationExtensions } from './image-generation-extensions.js';
 import { createWebToolsExtensions } from './web-tools-extensions.js';
 import { combineExecutionExtensions } from './execution-extensions.js';
-import { compactRuntimeConfigurations, marAgentCompactExtensionSource, updateMarAgentCompactState } from './compact-extensions.js';
+import { compactRuntimeConfigurations, updateMarAgentCompactState } from './compact-extensions.js';
+import { marAgentRuntimeExtensionSource } from './runtime-extensions.js';
 import { webSessionScope } from '../../service/web-fetch-contracts.js';
 /**
  * Opens one short-lived MAR Agent Host per hosted Run so template mounts cannot leak across Run
@@ -391,7 +392,7 @@ export class MarAgentHostedConversationRuntime {
                 mode: 'node',
                 host,
                 models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
-                extensions: marAgentCompactExtensionSource(compactState),
+                extensions: marAgentRuntimeExtensionSource(compactState),
                 defaultModelId: 'defaultModelId' in input ? input.defaultModelId : input.modelId,
                 workspaceMapping: {
                     logicalPath: '/workspace',

package/dist/runner/mar-agent/runtime-extensions.js

@@ -0,0 +1,33 @@
+import { marAgentCompactExtensionSource } from './compact-extensions.js';
+export function marAgentRuntimeExtensionSource(state) {
+    const compactSource = marAgentCompactExtensionSource(state);
+    return {
+        async resolve(request) {
+            const snapshot = await compactSource.resolve(request);
+            return {
+                ...snapshot,
+                extensions: [
+                    ...snapshot.extensions,
+                    {
+                        id: 'mar.node.file-links',
+                        apiVersion: '1.0',
+                        attachSession(context) {
+                            context.hooks.intercept('prompt.sections', (input, _call, next) => next({
+                                ...input,
+                                sections: [
+                                    ...input.sections,
+                                    {
+                                        id: 'mar.node.file-links',
+                                        text: input.facts?.mode === 'compact'
+                                            ? null
+                                            : 'When mentioning key files changed in this task, prefer Markdown links to their absolute paths for easy preview.'
+                                    }
+                                ]
+                            }));
+                        }
+                    }
+                ]
+            };
+        }
+    };
+}

package/dist/runner/mar-agent/session-runtime.js

@@ -9,7 +9,8 @@ import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { nodeLog } from '../../operational.js';
 import { BUNDLED_RIPGREP_VERSION, bundledRipgrepPath, prependBundledRipgrepToPath } from '../../ripgrep-binary.js';
 import { canonicalJson } from '../../util/canonical-json.js';
-import { compactRuntimeConfigurations, marAgentCompactExtensionSource, updateMarAgentCompactState } from './compact-extensions.js';
+import { compactRuntimeConfigurations, updateMarAgentCompactState } from './compact-extensions.js';
+import { marAgentRuntimeExtensionSource } from './runtime-extensions.js';
 import { MarAgentConversationNormalizer } from './conversation-normalizer.js';
 import { sdkModelConfigurations } from './runtime-model-factory.js';
 export const HOST_CONFIGURATION_CATEGORIES = [
@@ -72,7 +73,7 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
         });
         const compactState = { revision: 0 };
         updateMarAgentCompactState(compactState, input.compact, models, input.models.map((model) => model.id));
-        const compactSource = marAgentCompactExtensionSource(compactState);
+        const runtimeSource = marAgentRuntimeExtensionSource(compactState);
         const networkProvider = networkContext;
         agent = await dependencies.createAgent({
             mode: 'node',
@@ -80,10 +81,10 @@ export async function createSessionRuntime(input, sessionKey, fingerprint, hostC
             models: sdkModelConfigurations(models.filter((model) => input.models.some((candidate) => candidate.id === model.id))),
             defaultModelId: input.model.id,
             extensions: networkProvider === undefined
-                ? compactSource
+                ? runtimeSource
                 : {
                     async resolve(request) {
-                        const snapshot = await compactSource.resolve(request);
+                        const snapshot = await runtimeSource.resolve(request);
                         return {
                             ...snapshot,
                             extensions: [

package/dist/runner/mar-agent-runner.js

@@ -310,45 +310,32 @@ export class MarAgentRunner extends AbstractRunner {
         try {
             catalog = await openAgentSessionCatalog({ homeDirectory: this.homeDirectory });
             const activeCatalog = catalog;
-            const listed = await activeCatalog.list({ limit: 200 });
-            if (context.cleanup) {
-                const sessions = [...listed.sessions];
-                let cursor = listed.nextCursor;
-                while (cursor !== undefined) {
-                    const next = await activeCatalog.list({ limit: 200, cursor });
-                    sessions.push(...next.sessions);
-                    cursor = next.nextCursor;
-                }
-                const workspaces = workspace ? [workspace] : context.workspaces;
-                return sessions.flatMap((session) => {
-                    const target = workspaces.find((candidate) => resolve(candidate.path) === resolve(session.workspace));
-                    return target
-                        ? [
-                            context.createProjection({
-                                workspace: target,
-                                runner: this.name,
-                                externalSessionId: session.id,
-                                cwd: session.workspace,
-                                ...(session.source?.parentSessionId === undefined
-                                    ? {}
-                                    : { parentSessionId: session.source.parentSessionId }),
-                                lastActivityAt: Date.parse(session.lastActivityAt)
-                            })
-                        ]
-                        : [];
-                });
-            }
             const workspaces = workspace ? [workspace] : context.workspaces;
-            return (await Promise.all(listed.sessions.map(async (session) => {
+            const sessions = (await activeCatalog.listSnapshot()).flatMap((session) => {
                 const target = workspaces.find((candidate) => resolve(candidate.path) === resolve(session.workspace));
-                if (!target)
-                    return [];
-                const executionConfiguration = session.modelId === undefined
-                    ? await activeCatalog.executionConfiguration(session.id)
-                    : session;
-                const title = await marAgentSessionTitle(session, activeCatalog);
-                return [
-                    {
+                return target ? [{ session, target }] : [];
+            });
+            if (context.cleanup) {
+                return sessions.map(({ session, target }) => context.createProjection({
+                    workspace: target,
+                    runner: this.name,
+                    externalSessionId: session.id,
+                    cwd: session.workspace,
+                    ...(session.source?.parentSessionId === undefined
+                        ? {}
+                        : { parentSessionId: session.source.parentSessionId }),
+                    lastActivityAt: Date.parse(session.lastActivityAt)
+                }));
+            }
+            const discovered = [];
+            const batchSize = 8;
+            for (let offset = 0; offset < sessions.length; offset += batchSize) {
+                const batch = await Promise.allSettled(sessions.slice(offset, offset + batchSize).map(async ({ session, target }) => {
+                    const executionConfiguration = session.modelId === undefined
+                        ? await activeCatalog.executionConfiguration(session.id)
+                        : session;
+                    const title = await marAgentSessionTitle(session, activeCatalog);
+                    return {
                         ...context.createProjection({
                             workspace: target,
                             runner: this.name,
@@ -366,14 +353,15 @@ export class MarAgentRunner extends AbstractRunner {
                         ...(executionConfiguration?.reasoningEffort === undefined
                             ? {}
                             : { effort: executionConfiguration.reasoningEffort })
-                    }
-                ];
-            }))).flat();
-        }
-        catch (error) {
-            if (context.cleanup)
-                throw error;
-            return [];
+                    };
+                }));
+                for (const entry of batch) {
+                    if (entry.status === 'rejected')
+                        throw entry.reason;
+                    discovered.push(entry.value);
+                }
+            }
+            return discovered;
         }
         finally {
             await catalog?.close().catch(() => undefined);

package/dist/session/native-session-projection-service.js

@@ -361,8 +361,7 @@ export class NativeSessionProjectionService {
     projectionForNative(native) {
         return this.resolveNativeProjection(native, this.options.runtime, false);
     }
-    projectionsForNative(native) {
-        const lookup = this.options.runtime.createSessionLookup();
+    projectionsForNative(native, lookup = this.options.runtime.createSessionLookup()) {
         return new Map(native.map((session) => [session, this.resolveNativeProjection(session, lookup, false)]));
     }
     managedForNative(native) {

package/dist/session/session-catalog-service.js

@@ -76,7 +76,7 @@ export class SessionCatalogService {
             ancestors.add(parent.id);
             root = parent;
         }
-        const project = this.navigationProjector(input.workspaceId);
+        const { project } = this.navigationProjector(input.workspaceId, (id) => sessionActivityStatus(this.options.runtime, id));
         const queue = [root];
         const visited = new Set([root.id]);
         const nodes = [];
@@ -97,10 +97,26 @@ export class SessionCatalogService {
     }
     navigation(query) {
         const database = this.options.database();
-        const project = this.navigationProjector(query.workspaceId);
+        const statuses = new Map();
+        const status = (id) => {
+            const cached = statuses.get(id);
+            if (cached !== undefined)
+                return cached;
+            const value = sessionActivityStatus(this.options.runtime, id);
+            statuses.set(id, value);
+            return value;
+        };
+        let projection;
+        const projector = () => (projection ??= this.navigationProjector(query.workspaceId, status));
+        const project = (record) => projector().project(record);
+        const registered = new Map();
         const get = (id) => {
+            if (registered.has(id))
+                return registered.get(id);
             const record = database.getSessionRecord(id);
-            return record?.workspaceId === query.workspaceId ? record : undefined;
+            const scoped = record?.workspaceId === query.workspaceId ? record : undefined;
+            registered.set(id, scoped);
+            return scoped;
         };
         const requestedIds = new Set([
             ...query.sessionIds,
@@ -113,19 +129,13 @@ export class SessionCatalogService {
             return record === undefined ? [] : [project(record)];
         });
         const descendantsByAnchor = new Map();
-        const statuses = new Map();
-        const status = (id) => {
-            const cached = statuses.get(id);
-            if (cached !== undefined)
-                return cached;
-            const value = sessionActivityStatus(this.options.runtime, id);
-            statuses.set(id, value);
-            return value;
-        };
         const descendants = (anchor) => {
             let records = descendantsByAnchor.get(anchor);
             if (records === undefined) {
-                records = database.sessionTreeRecords(query.workspaceId, anchor).slice(1);
+                const tree = database.sessionTreeRecords(query.workspaceId, anchor);
+                for (const record of tree)
+                    registered.set(record.id, record);
+                records = tree.slice(1);
                 descendantsByAnchor.set(anchor, records);
             }
             return records;
@@ -166,12 +176,32 @@ export class SessionCatalogService {
                     activePaths.add(record.metadata.parentSessionId);
             }
         }
-        // Select active paths before idle filler, not after truncating arbitrary records.
-        // Stable breadth-first order keeps selected children connected to their ancestors.
-        const prioritized = [
-            ...records.filter((record) => activePaths.has(record.id)),
-            ...records.filter((record) => !activePaths.has(record.id))
-        ];
+        const activity = new Map(records.map((record) => [record.id, projector().lastActivityAt(record)]));
+        const compare = (left, right) => Number(activePaths.has(right.id)) - Number(activePaths.has(left.id)) ||
+            activity.get(right.id) - activity.get(left.id) ||
+            (left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+        const prioritized = [...records].sort(compare);
+        const byId = new Map(records.map((record) => [record.id, record]));
+        const selected = new Map();
+        const fill = (candidates) => {
+            for (const record of candidates) {
+                if (selected.size >= query.limit)
+                    break;
+                const path = [];
+                let current = record;
+                while (current !== undefined && !selected.has(current.id)) {
+                    path.push(current);
+                    current = byId.get(current.metadata.parentSessionId ?? '');
+                }
+                if (path.length > query.limit - selected.size)
+                    continue;
+                for (const ancestor of path.reverse())
+                    selected.set(ancestor.id, ancestor);
+            }
+        };
+        // An unfit path must not consume slots before another active session that can fit.
+        fill(prioritized.filter((record) => status(record.id) !== 'IDLE'));
+        fill(prioritized);
         const parent = anchor?.metadata.parentSessionId
             ? get(anchor.metadata.parentSessionId)
             : undefined;
@@ -180,23 +210,28 @@ export class SessionCatalogService {
             : {
                 anchorSessionId: anchor.id,
                 parent: parent === undefined ? null : project(parent),
-                nodes: prioritized.slice(0, query.limit).map(project),
+                nodes: [...selected.values()].sort(compare).map(project),
                 truncated: records.length > query.limit
             };
         return { sessions, summaries, tree, missingSessionIds };
     }
-    navigationProjector(workspaceId) {
+    navigationProjector(workspaceId, status) {
+        const lookup = this.options.runtime.createSessionLookup();
         const native = this.options
             .cachedNative()
             .filter((session) => session.workspaceId === workspaceId);
-        const projections = this.options.projection.projectionsForNative(native);
+        const projections = this.options.projection.projectionsForNative(native, lookup);
         const activityById = new Map();
         for (const source of native) {
             const id = projections.get(source)?.id ?? source.id;
             activityById.set(id, latestSessionActivityAt(activityById.get(id) ?? 0, source.lastActivityAt));
         }
-        return (session) => {
-            const active = this.options.runtime.getAgentSession(session.id);
+        const current = (session) => lookup.getAgentSessionById(session.id) ??
+            lookup.findAgentSessionByExternalSession(session.runner, session.id, workspaceId);
+        const lastActivityAt = (session) => latestSessionActivityAt(current(session)?.lastActivityAt ?? 0, activityById.get(session.id) ?? 0);
+        const projected = new Map();
+        const project = (session) => {
+            const active = current(session);
             const live = active === undefined ? undefined : this.options.present(active);
             return {
                 id: session.id,
@@ -208,10 +243,21 @@ export class SessionCatalogService {
                     'Untitled session',
                 runner: session.runner,
                 activity: live && 'activity' in live ? live.activity : 'IDLE',
-                status: sessionActivityStatus(this.options.runtime, session.id),
+                status: status(session.id),
                 lastActivityAt: latestSessionActivityAt(live?.lastActivityAt ?? 0, activityById.get(session.id) ?? 0)
             };
         };
+        return {
+            lastActivityAt,
+            project: (session) => {
+                let value = projected.get(session.id);
+                if (value === undefined) {
+                    value = project(session);
+                    projected.set(session.id, value);
+                }
+                return value;
+            }
+        };
     }
     async collect(input) {
         const workspaceId = typeof input.workspaceId === 'string' ? input.workspaceId : undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.73",
+  "version": "0.12.0",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -40,10 +40,10 @@
     "turndown-plugin-gfm": "^1.0.2",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.73",
+    "@myagentroam/agent": "0.12.0",
+    "@myagentroam/marctl": "0.12.0",
     "@myagentroam/code-navigation": "0.11.1",
-    "@myagentroam/protocol": "0.11.73",
-    "@myagentroam/marctl": "0.11.12"
+    "@myagentroam/protocol": "0.12.0"
   },
   "devDependencies": {
     "@types/turndown": "^5.0.6",