@myagentroam/node 0.9.118 → 0.9.119

package/dist/connector.js

@@ -669,7 +669,10 @@ export class NodeConnector {
                 (await this.runAttachmentService.readNative(runId, imageIndex)),
             respondUserInput: (runId, requestId, answers) => this.runnerInteractionService.respondUserInput(runId, requestId, answers),
             pauseQueue: (sessionId) => this.workspaceQueueWorkbenchService.pauseSessionQueue(sessionId),
-            runInterrupted: (sessionId) => this.clearGoalState(sessionId),
+            runInterrupted: (sessionId) => {
+                const goalExit = this.clearGoalState(sessionId, 'stopped');
+                return goalExit === undefined ? undefined : { goalExit };
+            },
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
             control: (operation, payload) => this.controlMessages.handle(JSON.stringify(createEnvelope(operation, payload))),
             markInterrupted: (runId) => this.runState.interruptRequested.add(runId)
@@ -930,9 +933,13 @@ export class NodeConnector {
                 };
             },
             clearGoal: (session) => {
-                this.clearGoalState(session.id);
+                const goalExit = this.clearGoalState(session.id, 'removed');
                 this.finishIdleGoalRun(session.id, 'SUCCEEDED');
-                return { session: this.sessionPresentationService.present(session), cleared: true };
+                return {
+                    session: this.sessionPresentationService.present(session),
+                    cleared: true,
+                    ...(goalExit === undefined ? {} : { goalExit })
+                };
             }
         });
         this.sessionMessageService = new SessionMessageService({
@@ -1680,7 +1687,8 @@ export class NodeConnector {
             return;
         this.runEventBridge.emitRun(run.id, status === 'SUCCEEDED' ? 'run.completed' : 'run.failed', status === 'SUCCEEDED' ? {} : { code: 'GOAL_CONTINUATION_FAILED' }, status);
     }
-    clearGoalState(sessionId) {
+    clearGoalState(sessionId, status) {
+        const goalExit = this.goalRuntime.exitSummary(sessionId, status);
         this.retireGoalContinuation(sessionId);
         const removed = this.goalRuntime.clear(sessionId);
         this.continuousRunCoordinator.removeGoalQueue(sessionId);
@@ -1688,12 +1696,13 @@ export class NodeConnector {
         if (commandState !== undefined)
             this.commandStates.clear(sessionId, 'goal');
         if (!removed && commandState === undefined)
-            return;
+            return goalExit;
         const session = this.runtime.getAgentSession(sessionId);
         if (session !== undefined)
             this.emitWorkbenchEvent('session', {
                 session: this.sessionPresentationService.present(session)
             });
+        return goalExit;
     }
     prepareGoalSession(session) {
         const access = goalUnrestrictedAccess(session.runner);

package/dist/runner/abstract-runner.js

@@ -12,8 +12,12 @@ export class AbstractRunner {
     /** Test-only runners are registered explicitly but never advertised. */
     advertised = true;
     interceptsRuns = false;
-    async refreshProfile(capabilities, workspace, environment = {}) {
-        void [workspace, environment];
+    cachedProfile(capabilities, environment = {}) {
+        void environment;
+        return this.profile(capabilities);
+    }
+    async refreshProfile(capabilities, workspace, environment = {}, waitForRefresh = false) {
+        void [workspace, environment, waitForRefresh];
         return this.profile(capabilities);
     }
     supportsConfiguration(configuration, workspace, environment) {

package/dist/runner/codex-runner.js

@@ -14,6 +14,7 @@ const CODEX_MODEL_CACHE_MS = 10 * 60 * 1_000;
 const CODEX_PROFILE_ENTRY_TTL_MS = 30 * 60 * 1_000;
 const CODEX_MODEL_FAILURE_RETRY_MS = 30 * 1_000;
 const CODEX_MODEL_PAGE_SIZE = 100;
+const CODEX_MODEL_MAX_PAGES = 6;
 export class CodexRunner extends AbstractRunner {
     client;
     profileClientFactory;
@@ -30,6 +31,7 @@ export class CodexRunner extends AbstractRunner {
     profileKeyByEnvironment = new Map();
     latestProfileCache;
     selectedProfileKey;
+    profileGeneration = 0;
     constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
         super();
         this.client = client;
@@ -43,7 +45,13 @@ export class CodexRunner extends AbstractRunner {
         }).find((profile) => profile.runner === this.name);
         return { ...base, models: this.latestProfileCache?.profile.models ?? [] };
     }
-    async refreshProfile(capabilities, workspace, environment = {}) {
+    cachedProfile(capabilities, environment = {}) {
+        const base = this.profile(capabilities);
+        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
+        const cached = this.profileCache.get(key);
+        return cached === undefined ? { ...base, models: [] } : cached.profile;
+    }
+    async refreshProfile(capabilities, workspace, environment = {}, waitForRefresh = false) {
         void workspace;
         const base = this.profile(capabilities);
         if (!capabilities.codex.available)
@@ -56,8 +64,11 @@ export class CodexRunner extends AbstractRunner {
         if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
             return this.selectCachedProfile(key, cached);
         if (cached?.successful === true) {
-            if (now >= cached.retryAt)
-                void this.refreshCodexProfile(key, base, environment);
+            if (now >= cached.retryAt) {
+                const refresh = this.refreshCodexProfile(key, base, environment);
+                if (waitForRefresh)
+                    return refresh;
+            }
             return this.selectCachedProfile(key, cached);
         }
         if (cached !== undefined && now < cached.retryAt)
@@ -68,6 +79,7 @@ export class CodexRunner extends AbstractRunner {
         const existing = this.profileRefreshes.get(key);
         if (existing !== undefined)
             return existing;
+        const generation = this.profileGeneration;
         const refresh = this.fetchCodexProfile(base, environment)
             .then((value) => {
             const cache = {
@@ -76,15 +88,19 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            this.cacheProfile(key, cache);
-            if (this.selectedProfileKey === key)
-                this.latestProfileCache = cache;
+            if (generation === this.profileGeneration) {
+                this.cacheProfile(key, cache);
+                if (this.selectedProfileKey === key)
+                    this.latestProfileCache = cache;
+            }
             return cache.profile;
         })
             .catch((error) => {
             nodeLog('runner.codex.models.refresh-failed', {
                 error: error instanceof Error ? error.message : String(error)
             });
+            if (generation !== this.profileGeneration)
+                return { ...base, models: [] };
             const cached = this.profileCache.get(key);
             if (cached !== undefined) {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
@@ -136,8 +152,12 @@ export class CodexRunner extends AbstractRunner {
             await client.start();
             const models = [];
             let cursor = null;
+            let pages = 0;
             const cursors = new Set();
             do {
+                if (pages >= CODEX_MODEL_MAX_PAGES)
+                    throw new Error('CODEX_MODELS_PAGE_LIMIT');
+                pages += 1;
                 const page = codexModelPage(await client.listModels({ cursor, limit: CODEX_MODEL_PAGE_SIZE, includeHidden: false }));
                 models.push(...page.models);
                 cursor = page.nextCursor;
@@ -454,6 +474,7 @@ export class CodexRunner extends AbstractRunner {
         this.environmentFingerprint = undefined;
     }
     stop() {
+        this.profileGeneration += 1;
         for (const profileClient of this.profileClients)
             profileClient.stop();
         this.profileClients.clear();

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

@@ -67,7 +67,12 @@ export class MarAgentConversationNormalizer {
             return this.#toolCompleted(event);
         if (event.type === 'tool.failed')
             return this.#toolFailed(event);
-        if (event.type === 'hosted_tool.updated')
+        if (event.type === 'hosted_tool.updated') {
+            const sourceSummary = event.summary.sources
+                ?.slice(0, 20)
+                .map((source) => (source.title ? `${source.title} — ${source.url}` : source.url))
+                .join('\n');
+            const output = sourceSummary || event.summary.title || '';
             return [
                 {
                     itemId: itemId('hosted', event.itemId),
@@ -84,16 +89,17 @@ export class MarAgentConversationNormalizer {
                         inputSummary: event.summary.query === undefined && event.summary.url === undefined
                             ? null
                             : compactRunnerText(event.summary.query ?? event.summary.url ?? '', 10_000),
-                        outputSummary: event.summary.title === undefined
-                            ? null
-                            : compactRunnerText(event.summary.title, 10_000),
+                        outputSummary: output ? compactRunnerText(output, 10_000) : null,
                         progressLabel: event.status === 'RUNNING' ? 'Running' : null,
                         errorCode: event.status === 'FAILED' ? 'HOSTED_TOOL_FAILED' : null,
-                        truncated: false
+                        truncated: event.summary.sourcesTruncated === true ||
+                            (event.summary.sources?.length ?? 0) > 20 ||
+                            output.length > 10_000
                     },
                     merge: true
                 }
             ];
+        }
         if (event.type === 'todo.updated')
             return [
                 {

package/dist/runner/opencode-runner.js

@@ -8,6 +8,9 @@ import { homedir } from 'node:os';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
 import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
+const PROFILE_STALE_TTL_MS = 60 * 60_000;
+const PROFILE_FAILURE_RETRY_MS = 30_000;
+const PROFILE_REFRESH_TIMEOUT_MS = 90_000;
 export class OpenCodeRunner extends AbstractRunner {
     client;
     clientFactory;
@@ -16,7 +19,9 @@ export class OpenCodeRunner extends AbstractRunner {
     contextLimits = new Map();
     contextLimitsExpiresAt = 0;
     profileCache = new Map();
+    profileRetryAt = new Map();
     profileRefreshes = new Map();
+    profileGeneration = 0;
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -34,17 +39,22 @@ export class OpenCodeRunner extends AbstractRunner {
         }).find((profile) => profile.runner === this.name);
         return { ...base, models: [] };
     }
-    async refreshProfile(capabilities, _workspace, environment = {}) {
+    cachedProfile(capabilities, environment = {}) {
+        this.pruneProfileCaches(Date.now());
+        const cached = this.profileCache.get(this.environmentFingerprint(environment));
+        return cached === undefined
+            ? this.profile(capabilities)
+            : { ...this.profile(capabilities), models: cached.models };
+    }
+    async refreshProfile(capabilities, _workspace, environment = {}, _waitForRefresh = false) {
         if (capabilities.openCode?.available !== true) {
             return this.profile(capabilities);
         }
         const cacheKey = this.environmentFingerprint(environment);
         const now = Date.now();
-        for (const [key, entry] of this.profileCache)
-            if (entry.expiresAt <= now)
-                this.profileCache.delete(key);
+        this.pruneProfileCaches(now);
         const cached = this.profileCache.get(cacheKey);
-        if (cached !== undefined) {
+        if (cached !== undefined && cached.expiresAt > now) {
             nodeLog('runner.opencode.profile.cache-hit', {
                 models: cached.models.length,
                 remainingTtlMs: cached.expiresAt - now
@@ -53,34 +63,43 @@ export class OpenCodeRunner extends AbstractRunner {
             this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
+        if (now < (this.profileRetryAt.get(cacheKey) ?? 0))
+            return cached === undefined
+                ? this.profile(capabilities)
+                : { ...this.profile(capabilities), models: cached.models };
         const current = this.profileRefreshes.get(cacheKey);
         if (current !== undefined) {
             nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
-        const refresh = this.fetchProfile(capabilities, environment, cacheKey).finally(() => {
+        const generation = this.profileGeneration;
+        const refresh = this.fetchProfile(capabilities, environment, cacheKey, generation, cached).finally(() => {
             if (this.profileRefreshes.get(cacheKey) === refresh)
                 this.profileRefreshes.delete(cacheKey);
         });
         this.profileRefreshes.set(cacheKey, refresh);
         return refresh;
     }
-    async fetchProfile(capabilities, environment, cacheKey) {
-        const client = this.managedClient(environment);
+    async fetchProfile(capabilities, environment, cacheKey, generation, stale) {
+        const client = this.managedClient(environment, 'runner-profile');
         const startedAt = performance.now();
         try {
-            const catalog = await client.providers(homedir());
+            const catalog = await withProfileTimeout(client.providers(homedir()));
             const models = openCodeProfileModels(catalog);
             const contextLimits = openCodeContextLimits(catalog);
             const expiresAt = Date.now() + PROFILE_ENTRY_TTL_MS;
+            if (generation !== this.profileGeneration)
+                return this.profile(capabilities);
             this.contextLimits = contextLimits;
             this.contextLimitsExpiresAt = expiresAt;
             this.profileCache.set(cacheKey, {
                 expiresAt,
+                discardAt: Date.now() + PROFILE_STALE_TTL_MS,
                 environmentFingerprint: cacheKey,
                 models,
                 contextLimits
             });
+            this.profileRetryAt.delete(cacheKey);
             nodeLog('runner.opencode.profile.providers.completed', {
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
@@ -88,6 +107,9 @@ export class OpenCodeRunner extends AbstractRunner {
             return { ...this.profile(capabilities), models };
         }
         catch {
+            if (generation !== this.profileGeneration)
+                return this.profile(capabilities);
+            this.profileRetryAt.set(cacheKey, Date.now() + PROFILE_FAILURE_RETRY_MS);
             nodeLog('runner.opencode.profile.providers.failed', {
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -95,7 +117,9 @@ export class OpenCodeRunner extends AbstractRunner {
         finally {
             this.releaseManagedClient(client);
         }
-        return this.profile(capabilities);
+        return stale === undefined
+            ? this.profile(capabilities)
+            : { ...this.profile(capabilities), models: stale.models };
     }
     environmentFingerprint(environment) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
@@ -135,12 +159,23 @@ export class OpenCodeRunner extends AbstractRunner {
         };
     }
     cachedModels(environment) {
+        this.pruneProfileCaches(Date.now());
         const fingerprint = this.environmentFingerprint(environment);
-        const now = Date.now();
         return [...this.profileCache.values()]
-            .filter((entry) => entry.expiresAt > now && entry.environmentFingerprint === fingerprint)
+            .filter((entry) => entry.environmentFingerprint === fingerprint)
             .flatMap((entry) => entry.models);
     }
+    pruneProfileCaches(now) {
+        for (const [key, entry] of this.profileCache) {
+            if (entry.discardAt > now)
+                continue;
+            this.profileCache.delete(key);
+            this.profileRetryAt.delete(key);
+        }
+        for (const [key, retryAt] of this.profileRetryAt)
+            if (retryAt <= now && !this.profileCache.has(key) && !this.profileRefreshes.has(key))
+                this.profileRetryAt.delete(key);
+    }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
         return Object.fromEntries(servers.map((server) => [
@@ -300,12 +335,14 @@ export class OpenCodeRunner extends AbstractRunner {
         return maxTokens === undefined ? undefined : { model: modelId, usedTokens, maxTokens };
     }
     async stop() {
+        this.profileGeneration += 1;
         for (const execution of this.execution.values())
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
         this.profileCache.clear();
         this.profileRefreshes.clear();
+        this.profileRetryAt.clear();
         this.contextLimits = new Map();
         this.contextLimitsExpiresAt = 0;
         const stopping = [
@@ -351,6 +388,22 @@ export class OpenCodeRunner extends AbstractRunner {
         }
     }
 }
+async function withProfileTimeout(operation) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('OPENCODE_PROFILE_REFRESH_TIMEOUT')), PROFILE_REFRESH_TIMEOUT_MS);
+                timer.unref();
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
 function object(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
         ? value

package/dist/runner/runner-registry.js

@@ -29,17 +29,17 @@ export class RunnerRegistry {
         const runner = this.runners.get(name);
         return runner?.advertised === true ? runner : undefined;
     }
-    profiles(capabilities) {
+    profiles(capabilities, environment = {}) {
         return this.advertised().flatMap((runner) => {
-            const profile = runner.profile(capabilities);
+            const profile = runner.cachedProfile(capabilities, environment);
             return profile === undefined ? [] : [profile];
         });
     }
-    async refreshProfiles(capabilities, workspace, environment = {}) {
+    async refreshProfiles(capabilities, workspace, environment = {}, waitForRefresh = false) {
         const profiles = await Promise.all(this.advertised().map(async (runner) => {
             const startedAt = performance.now();
             try {
-                return await runner.refreshProfile(capabilities, workspace, environment);
+                return await runner.refreshProfile(capabilities, workspace, environment, waitForRefresh);
             }
             finally {
                 const durationMs = Math.round(performance.now() - startedAt);

package/dist/service/goal-mcp-server.js

@@ -98,7 +98,11 @@ export class GoalMcpServer {
                 throw new Error('GOAL_STATUS_INVALID');
             const goal = this.goals.update(capability.sessionId, capability.goalId, capability.revision, status);
             this.changed(capability.sessionId);
-            socket.end(`${JSON.stringify({ result: goal })}\n`);
+            socket.end(`${JSON.stringify({
+                result: goal.status === 'active'
+                    ? goal
+                    : { ...goal, elapsedWallMs: this.goals.elapsedWallMs(goal) }
+            })}\n`);
         }
         catch (error) {
             socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : 'GOAL_IPC_FAILED' })}\n`);

package/dist/service/goal-runtime.js

@@ -72,10 +72,12 @@ export function publicGoalHistoryText(text) {
 }
 export class GoalRuntime {
     changed;
+    now;
     goals = new Map();
     executionFailures = new Map();
-    constructor(changed) {
+    constructor(changed, now = Date.now) {
         this.changed = changed;
+        this.now = now;
     }
     get(sessionId) {
         return this.goals.get(sessionId);
@@ -104,6 +106,7 @@ export class GoalRuntime {
             id: continuing ? current.id : randomUUID(),
             sessionId,
             objective: normalized,
+            startedAt: continuing ? current.startedAt : this.now(),
             revision: continuing ? current.revision + 1 : 1,
             status: 'active',
             turns: 0,
@@ -117,6 +120,15 @@ export class GoalRuntime {
         this.changed(goal);
         return goal;
     }
+    elapsedWallMs(goal) {
+        return Math.max(0, this.now() - goal.startedAt);
+    }
+    exitSummary(sessionId, status) {
+        const goal = this.get(sessionId);
+        if (goal === undefined || goal.status !== 'active')
+            return undefined;
+        return { status, elapsedWallMs: this.elapsedWallMs(goal), turns: goal.turns };
+    }
     recordTurn(sessionId) {
         const current = this.goals.get(sessionId);
         if (current?.status !== 'active')
@@ -235,7 +247,7 @@ export class GoalRuntime {
         const heading = kind === 'start' ? 'A Goal has started or changed.' : 'Continue the active Goal.';
         const open = kind === 'start' ? START_OPEN : CONTINUE_OPEN;
         const close = kind === 'start' ? START_CLOSE : CONTINUE_CLOSE;
-        return `${open}\n${heading}\n\nOriginal objective:\n${goal.objective}\n\nContinue executing this Goal across turns:\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_goal with status=completed.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_goal only when you need to reread the authoritative objective or status.\n${close}`;
+        return `${open}\n${heading}\n\nOriginal objective:\n${goal.objective}\n\nContinue executing this Goal across turns:\n- Work on the objective now. If it is incomplete, use tools to finish a coherent unit or obtain decisive evidence; do not stop at an acknowledgement, status, plan, or promise.\n- Preserve the original scope. Before completion, review the full objective and verify it with real evidence, then call mar_update_goal with status=completed.\n- Adapt and retry after individual failures. Request blocked only after the same blocker persists for three turns and the required additional retry.\n- Use mar_get_goal only when you need to reread the authoritative objective or status.\n- After mar_update_goal confirms completed or finally blocked, summarize the completed work, verification evidence, remaining issues, and the tool-reported elapsedWallMs converted from milliseconds into a concise readable duration in your final user-facing response. Name whether the Goal completed or is finally blocked. That elapsed time is wall-clock time through the status update, including waiting and retries, not tool execution time or time through this final response. If blocked returns active for the required retry, continue work instead of claiming a final summary.\n${close}`;
     }
     requireCurrent(sessionId, goalId, revision) {
         const current = this.goals.get(sessionId);

package/dist/service/run-workbench-service.js

@@ -67,6 +67,7 @@ export class RunWorkbenchService {
         const executionId = this.options.runtime.currentExecutionId(run.id);
         const turn = this.options.runtime.conversationTurnForRun(run.id);
         const controlRunId = executionId ?? (turn === undefined || turn.userItemId === null ? run.id : undefined);
+        let interruptionResult;
         try {
             this.options.pauseQueue(run.sessionId);
             if (controlRunId === undefined) {
@@ -79,9 +80,9 @@ export class RunWorkbenchService {
             }
         }
         finally {
-            this.options.runInterrupted(run.sessionId);
+            interruptionResult = this.options.runInterrupted(run.sessionId);
         }
-        return { run: next };
+        return { run: next, ...interruptionResult };
     }
     decideApproval(input) {
         if (typeof input.runId !== 'string' ||

package/dist/service/runner-service.js

@@ -19,11 +19,11 @@ export class RunnerService {
             'runner.defaults.save': (data) => this.saveDefaults(data)
         };
     }
-    profiles() {
-        return this.runners.profiles(this.capabilities());
+    profiles(environment = {}) {
+        return this.runners.profiles(this.capabilities(), environment);
     }
-    refreshProfiles(environment = {}) {
-        return this.runners.refreshProfiles(this.capabilities(), undefined, environment);
+    refreshProfiles(environment = {}, waitForRefresh = false) {
+        return this.runners.refreshProfiles(this.capabilities(), undefined, environment, waitForRefresh);
     }
     async usageStatuses() {
         return {
@@ -61,8 +61,18 @@ export class RunnerService {
             this.database().saveRunnerDefaults(normalized);
             return normalized;
         });
+        const cacheOnly = input.waitForRefresh === false;
+        const waitForRefresh = !cacheOnly;
+        const refresh = this.refreshProfiles(environment, waitForRefresh);
+        if (cacheOnly) {
+            void refresh.catch(() => undefined);
+            return {
+                profiles: this.profiles(environment),
+                defaults
+            };
+        }
         return {
-            profiles: await this.refreshProfiles(environment),
+            profiles: await refresh,
             defaults
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.118",
+  "version": "0.9.119",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.118",
-    "@myagentroam/code-navigation": "0.9.118",
-    "@myagentroam/protocol": "0.9.118"
+    "@myagentroam/protocol": "0.9.119",
+    "@myagentroam/agent": "0.9.119",
+    "@myagentroam/code-navigation": "0.9.119"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"