@myagentroam/node 0.9.118 → 0.9.120

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;
@@ -23,13 +24,12 @@ export class CodexRunner extends AbstractRunner {
     fastEnabled = false;
     environmentFingerprint;
     environmentRuns = new Set();
-    profileCache = new Map();
-    profileCacheTimers = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileCacheVersion;
+    profileCacheTimer;
+    profileRefresh;
     profileClients = new Set();
-    profileKeyByEnvironment = new Map();
-    latestProfileCache;
-    selectedProfileKey;
+    profileGeneration = 0;
     constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
         super();
         this.client = client;
@@ -41,33 +41,42 @@ export class CodexRunner extends AbstractRunner {
             claudeCodeAvailable: capabilities.claudeCode.available,
             openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
-        return { ...base, models: this.latestProfileCache?.profile.models ?? [] };
+        return { ...base, models: this.profileCache?.profile.models ?? [] };
     }
-    async refreshProfile(capabilities, workspace, environment = {}) {
+    cachedProfile(capabilities, environment = {}) {
+        const base = this.profile(capabilities);
+        return this.profileCache === undefined ||
+            this.profileCacheVersion !== capabilities.codex.version
+            ? { ...base, models: [] }
+            : this.profileCache.profile;
+    }
+    async refreshProfile(capabilities, workspace, environment = {}, waitForRefresh = false) {
         void workspace;
         const base = this.profile(capabilities);
         if (!capabilities.codex.available)
             return { ...base, models: [] };
-        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
-        this.profileKeyByEnvironment.set(codexSecretEnvironmentFingerprint(environment), key);
-        this.selectedProfileKey = key;
+        const version = capabilities.codex.version;
         const now = Date.now();
-        const cached = this.profileCache.get(key);
+        const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
         if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
-            return this.selectCachedProfile(key, cached);
+            return cached.profile;
         if (cached?.successful === true) {
-            if (now >= cached.retryAt)
-                void this.refreshCodexProfile(key, base, environment);
-            return this.selectCachedProfile(key, cached);
+            if (now >= cached.retryAt) {
+                const refresh = this.refreshCodexProfile(version, base, environment);
+                if (waitForRefresh)
+                    return refresh;
+            }
+            return cached.profile;
         }
         if (cached !== undefined && now < cached.retryAt)
             return cached.profile;
-        return this.refreshCodexProfile(key, base, environment);
+        return this.refreshCodexProfile(version, base, environment);
     }
-    refreshCodexProfile(key, base, environment) {
-        const existing = this.profileRefreshes.get(key);
+    refreshCodexProfile(version, base, environment) {
+        const existing = this.profileRefresh;
         if (existing !== undefined)
             return existing;
+        const generation = this.profileGeneration;
         const refresh = this.fetchCodexProfile(base, environment)
             .then((value) => {
             const cache = {
@@ -76,21 +85,22 @@ 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(version, cache);
             return cache.profile;
         })
             .catch((error) => {
             nodeLog('runner.codex.models.refresh-failed', {
                 error: error instanceof Error ? error.message : String(error)
             });
-            const cached = this.profileCache.get(key);
+            if (generation !== this.profileGeneration)
+                return { ...base, models: [] };
+            const cached = this.profileCacheVersion === version ? this.profileCache : undefined;
             if (cached !== undefined) {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
                 return cached.profile;
             }
-            this.cacheProfile(key, {
+            this.cacheProfile(version, {
                 profile: { ...base, models: [] },
                 defaultConfiguration: emptyCodexConfiguration(),
                 fetchedAt: 0,
@@ -99,33 +109,24 @@ export class CodexRunner extends AbstractRunner {
             });
             return { ...base, models: [] };
         })
-            .finally(() => this.profileRefreshes.delete(key));
-        this.profileRefreshes.set(key, refresh);
+            .finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
+        });
+        this.profileRefresh = refresh;
         return refresh;
     }
-    selectCachedProfile(key, cached) {
-        if (cached.successful && this.selectedProfileKey === key)
-            this.latestProfileCache = cached;
-        return cached.profile;
-    }
-    cacheProfile(key, cache) {
-        const previousTimer = this.profileCacheTimers.get(key);
-        if (previousTimer !== undefined)
-            clearTimeout(previousTimer);
-        this.profileCache.set(key, cache);
-        const timer = setTimeout(() => {
-            this.profileCacheTimers.delete(key);
-            this.profileCache.delete(key);
-            for (const [environmentKey, profileKey] of this.profileKeyByEnvironment)
-                if (profileKey === key)
-                    this.profileKeyByEnvironment.delete(environmentKey);
-            if (this.selectedProfileKey === key) {
-                this.selectedProfileKey = undefined;
-                this.latestProfileCache = undefined;
-            }
+    cacheProfile(version, cache) {
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCache = cache;
+        this.profileCacheVersion = version;
+        this.profileCacheTimer = setTimeout(() => {
+            this.profileCacheTimer = undefined;
+            this.profileCache = undefined;
+            this.profileCacheVersion = undefined;
         }, CODEX_PROFILE_ENTRY_TTL_MS);
-        timer.unref();
-        this.profileCacheTimers.set(key, timer);
+        this.profileCacheTimer.unref();
     }
     async fetchCodexProfile(base, environment) {
         const client = this.profileClientFactory();
@@ -136,8 +137,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;
@@ -286,11 +291,8 @@ export class CodexRunner extends AbstractRunner {
             profile.models.some((model) => model.id === configuration.model && model.supportedEfforts.includes(configuration.effort)) &&
             profile.accessOptions.some((option) => option.id === configuration.access));
     }
-    profileCacheForEnvironment(environment) {
-        if (environment === undefined)
-            return this.latestProfileCache;
-        const key = this.profileKeyByEnvironment.get(codexSecretEnvironmentFingerprint(environment));
-        return key === undefined ? undefined : this.profileCache.get(key);
+    profileCacheForEnvironment(_environment) {
+        return this.profileCache;
     }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
@@ -454,6 +456,7 @@ export class CodexRunner extends AbstractRunner {
         this.environmentFingerprint = undefined;
     }
     stop() {
+        this.profileGeneration += 1;
         for (const profileClient of this.profileClients)
             profileClient.stop();
         this.profileClients.clear();
@@ -462,13 +465,12 @@ export class CodexRunner extends AbstractRunner {
             this.client.clearEnvironment();
         this.environmentFingerprint = undefined;
         this.environmentRuns.clear();
-        for (const timer of this.profileCacheTimers.values())
-            clearTimeout(timer);
-        this.profileCacheTimers.clear();
-        this.profileCache.clear();
-        this.profileKeyByEnvironment.clear();
-        this.latestProfileCache = undefined;
-        this.selectedProfileKey = undefined;
+        if (this.profileCacheTimer !== undefined)
+            clearTimeout(this.profileCacheTimer);
+        this.profileCacheTimer = undefined;
+        this.profileCache = undefined;
+        this.profileCacheVersion = undefined;
+        this.profileRefresh = undefined;
     }
     request(method, params) {
         return this.client.request(method, params);
@@ -516,19 +518,6 @@ export class CodexRunner extends AbstractRunner {
 function emptyCodexConfiguration() {
     return { runner: 'codex', model: '', effort: '', access: 'on-request' };
 }
-function codexEnvironmentFingerprint(environment, version) {
-    return createHash('sha256')
-        .update(JSON.stringify({
-        environment: Object.entries(environment).sort(([left], [right]) => left.localeCompare(right)),
-        version: version ?? null
-    }))
-        .digest('base64url');
-}
-function codexSecretEnvironmentFingerprint(environment) {
-    return createHash('sha256')
-        .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
-        .digest('base64url');
-}
 function codexModelPage(value) {
     if (!isPlainRecord(value) || !Array.isArray(value.data))
         throw new Error('CODEX_MODELS_INVALID');

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;
@@ -15,8 +18,10 @@ export class OpenCodeRunner extends AbstractRunner {
     discoveryScope = 'WORKSPACE_REQUIRED';
     contextLimits = new Map();
     contextLimitsExpiresAt = 0;
-    profileCache = new Map();
-    profileRefreshes = new Map();
+    profileCache;
+    profileRetryAt = 0;
+    profileRefresh;
+    profileGeneration = 0;
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -34,17 +39,21 @@ 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;
+        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);
-        const cached = this.profileCache.get(cacheKey);
-        if (cached !== undefined) {
+        this.pruneProfileCaches(now);
+        const cached = this.profileCache;
+        if (cached !== undefined && cached.expiresAt > now) {
             nodeLog('runner.opencode.profile.cache-hit', {
                 models: cached.models.length,
                 remainingTtlMs: cached.expiresAt - now
@@ -53,34 +62,42 @@ export class OpenCodeRunner extends AbstractRunner {
             this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
-        const current = this.profileRefreshes.get(cacheKey);
+        if (now < this.profileRetryAt)
+            return cached === undefined
+                ? this.profile(capabilities)
+                : { ...this.profile(capabilities), models: cached.models };
+        const current = this.profileRefresh;
         if (current !== undefined) {
             nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
-        const refresh = this.fetchProfile(capabilities, environment, cacheKey).finally(() => {
-            if (this.profileRefreshes.get(cacheKey) === refresh)
-                this.profileRefreshes.delete(cacheKey);
+        const generation = this.profileGeneration;
+        const refresh = this.fetchProfile(capabilities, environment, generation, cached).finally(() => {
+            if (this.profileRefresh === refresh)
+                this.profileRefresh = undefined;
         });
-        this.profileRefreshes.set(cacheKey, refresh);
+        this.profileRefresh = refresh;
         return refresh;
     }
-    async fetchProfile(capabilities, environment, cacheKey) {
-        const client = this.managedClient(environment);
+    async fetchProfile(capabilities, environment, 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, {
+            this.profileCache = {
                 expiresAt,
-                environmentFingerprint: cacheKey,
+                discardAt: Date.now() + PROFILE_STALE_TTL_MS,
                 models,
                 contextLimits
-            });
+            };
+            this.profileRetryAt = 0;
             nodeLog('runner.opencode.profile.providers.completed', {
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
@@ -88,6 +105,9 @@ export class OpenCodeRunner extends AbstractRunner {
             return { ...this.profile(capabilities), models };
         }
         catch {
+            if (generation !== this.profileGeneration)
+                return this.profile(capabilities);
+            this.profileRetryAt = Date.now() + PROFILE_FAILURE_RETRY_MS;
             nodeLog('runner.opencode.profile.providers.failed', {
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -95,11 +115,9 @@ export class OpenCodeRunner extends AbstractRunner {
         finally {
             this.releaseManagedClient(client);
         }
-        return this.profile(capabilities);
-    }
-    environmentFingerprint(environment) {
-        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
-        return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+        return stale === undefined
+            ? this.profile(capabilities)
+            : { ...this.profile(capabilities), models: stale.models };
     }
     available(capabilities) {
         return capabilities.openCode?.available === true;
@@ -135,11 +153,17 @@ export class OpenCodeRunner extends AbstractRunner {
         };
     }
     cachedModels(environment) {
-        const fingerprint = this.environmentFingerprint(environment);
-        const now = Date.now();
-        return [...this.profileCache.values()]
-            .filter((entry) => entry.expiresAt > now && entry.environmentFingerprint === fingerprint)
-            .flatMap((entry) => entry.models);
+        this.pruneProfileCaches(Date.now());
+        void environment;
+        return this.profileCache?.models ?? [];
+    }
+    pruneProfileCaches(now) {
+        if (this.profileCache !== undefined && this.profileCache.discardAt <= now)
+            this.profileCache = undefined;
+        if (this.profileRetryAt <= now &&
+            this.profileCache === undefined &&
+            this.profileRefresh === undefined)
+            this.profileRetryAt = 0;
     }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
@@ -300,12 +324,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.profileCache = undefined;
+        this.profileRefresh = undefined;
+        this.profileRetryAt = 0;
         this.contextLimits = new Map();
         this.contextLimitsExpiresAt = 0;
         const stopping = [
@@ -351,6 +377,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,25 @@ 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);
+            }
+            catch (error) {
+                nodeLog('runner.profile.refresh.failed', {
+                    runner: runner.name,
+                    workspaceId: workspace?.id,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return runner.cachedProfile(capabilities, environment);
             }
             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.120",
   "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/agent": "0.9.120",
+    "@myagentroam/code-navigation": "0.9.120",
+    "@myagentroam/protocol": "0.9.120"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"