@myagentroam/node 0.9.105 → 0.9.107

package/dist/connector.js

@@ -856,6 +856,7 @@ export class NodeConnector {
             runtime: this.runtime,
             runners: this.runners,
             projection: this.nativeSessionProjectionService,
+            resolveForCommand: (sessionId) => this.externalSessionResumeService.resolveForMessage(sessionId),
             profiles: () => this.runnerService.profiles(),
             present: (session) => this.sessionPresentationService.present(session),
             resumeQueueAfterCommandRun: (sessionId) => this.workspaceQueueWorkbenchService.resumeAfterCommandRun(sessionId),

package/dist/runner/codex/conversation-parser.js

@@ -43,21 +43,17 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
     if (items.length === 0)
         return undefined;
     if (managedTurn !== undefined) {
+        const officialComplete = value.status === 'completed' ||
+            value.status === 'failed' ||
+            value.status === 'interrupted' ||
+            (value.status === undefined && codexTimestamp(value.completedAt) !== null);
         const localUser = managedTurn.items.find((item) => item.kind === 'user_message');
         const officialNativeItemIds = codexNativeItemIds(value.items);
         const officialAssistantCount = items.filter((item) => item.kind === 'assistant_message').length;
         const officialAssistantMessage = officialAssistantCount > 0;
         const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message' && conversationItemNativeId(item.id) === undefined);
         const managedAssistantCandidates = officialAssistantCount === 0 ? [] : managedAssistants.slice(-officialAssistantCount);
-        const assistantLength = (values) => values.reduce((length, item) => {
-            if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
-                return length;
-            return length + (typeof item.payload.text === 'string' ? item.payload.text.length : 0);
-        }, 0);
-        const preferLocalAssistant = officialAssistantMessage &&
-            (assistantLength(managedAssistantCandidates) > assistantLength(items) ||
-                ((managedTurn.completedAt ?? 0) > (completedAt ?? 0) &&
-                    assistantLength(managedAssistantCandidates) > 0));
+        const preferLocalAssistant = officialAssistantMessage && !officialComplete;
         const replacedManagedAssistantIds = new Set(preferLocalAssistant
             ? []
             : officialAssistantCount === 0
@@ -66,6 +62,8 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         const localLiveItems = managedTurn.items.filter((item) => {
             if (item.kind === 'user_message')
                 return false;
+            if (preferLocalAssistant && item.kind === 'assistant_message')
+                return true;
             // `item/agentMessage/delta` uses a synthetic runtime ID. Once
             // `thread/read` returns the final Agent message, it is the same reply
             // without a shared native item ID and must replace that transient item.
@@ -112,15 +110,6 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
                     replacement = officialAssistants.find((item) => !consumedOfficialIds.has(item.id));
             }
             if (replacement !== undefined) {
-                if (managedItem.kind === 'assistant_message' &&
-                    replacement.kind === 'assistant_message' &&
-                    (assistantLength([managedItem]) > assistantLength([replacement]) ||
-                        ((managedTurn.completedAt ?? 0) > (completedAt ?? 0) &&
-                            assistantLength([managedItem]) > 0))) {
-                    reconciledItems.push(managedItem);
-                    consumedOfficialIds.add(replacement.id);
-                    continue;
-                }
                 if (!consumedOfficialIds.has(replacement.id)) {
                     reconciledItems.push(replacement);
                     consumedOfficialIds.add(replacement.id);
@@ -134,13 +123,13 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
                 reconciledItems.push(item);
         return {
             ...managedTurn,
-            status: 'SUCCEEDED',
+            status: officialComplete ? 'SUCCEEDED' : managedTurn.status,
             // Reconcile against the managed runtime order. Official items replace
             // matching live projections in place; newly visible terminal items such
             // as a plan are appended after the commentary and tools that preceded it.
             items: reconciledItems,
             startedAt,
-            completedAt
+            completedAt: officialComplete ? completedAt : null
         };
     }
     return {

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

@@ -20,7 +20,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             rewind: { before: previous?.id ?? null, after: turnId },
             items: [],
             startedAt: at,
-            completedAt: at
+            completedAt: null
         };
         turns.set(turnId, created);
         return created;
@@ -32,13 +32,17 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             items.push(item);
         else
             items[index] = { ...items[index], ...item, startedAt: items[index].startedAt };
-        turns.set(turn.id, { ...turn, items, completedAt: item.completedAt ?? turn.completedAt });
+        turns.set(turn.id, { ...turn, items });
     };
     for (const entry of entries) {
         if (entry.kind === 'user') {
             const at = Date.parse(entry.timestamp);
             const turn = ensure(entry.turnId, at);
-            const id = `${entry.turnId}:user`;
+            // SDK mailbox messages are persisted as additional turn.user records in the same Turn.
+            // The first input keeps its existing identity; later inputs use their storage sequence.
+            const id = turn.userItemId === null
+                ? `${entry.turnId}:user`
+                : `${entry.turnId}:user:${entry.sequence}`;
             const images = entry.images;
             const registeredImages = images === undefined ? [] : (options.registerInputImages?.(entry) ?? []);
             replace(turn, historyItem(session, turn, id, 'user_message', 'COMPLETED', {
@@ -56,7 +60,8 @@ export function projectMarAgentHistory(session, entries, options = {}) {
                     }
                     : {})
             }, at));
-            turns.set(entry.turnId, { ...turns.get(entry.turnId), userItemId: id });
+            if (turn.userItemId === null)
+                turns.set(entry.turnId, { ...turns.get(entry.turnId), userItemId: id });
             continue;
         }
         const event = entry.event;

package/dist/runner/opencode/conversation-parser.js

@@ -1,5 +1,4 @@
 import { boundedConversationItemId, compactRunnerText } from '../codex/conversation-parser.js';
-import { runtimeAssistantProjectionMoreComplete } from '../../util/runner-native-session-parsers.js';
 import { stripMissionStartPrompt } from '../../service/mission-runtime.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
@@ -73,9 +72,14 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
     const completedAt = Math.max(startedAt ?? 0, ...assistants.map(({ info }) => number(record(info.time)?.completed) ?? 0)) || startedAt;
     const id = managed?.id ?? `${session.id}:official:${nativeTurnId}`;
     const runId = managed?.runId ?? null;
-    const projectedItems = runtimeAssistantProjectionMoreComplete(managed, items)
-        ? managed.items
-        : items;
+    const officialAssistantIds = new Set(assistants.flatMap(({ parts }) => parts.flatMap((part) => {
+        const value = record(part);
+        return value?.type === 'text' && typeof value.id === 'string'
+            ? [`${managed?.runId}:${boundedConversationItemId('opencode', value.id)}`]
+            : [];
+    })));
+    const pendingOfficialReply = managed?.items.some((item) => item.kind === 'assistant_message' && !officialAssistantIds.has(item.id));
+    const projectedItems = pendingOfficialReply ? managed.items : items;
     return {
         id,
         sessionId: session.id,

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

@@ -13,6 +13,35 @@ export function convergeConversationWatchPage(previous, previousObserved, next,
     const authority = isConversationHistorySource(previousAuthority)
         ? previousAuthority
         : previous?.source;
+    if (next.deferredOlderHistory === true && previous !== undefined)
+        return {
+            page: composeConversationRuntimePage(previous, next),
+            authority: authority ?? next.source
+        };
+    // A Runner history read can lag a Run that the Watch has already delivered. Keep the
+    // unconfirmed Runtime tail until the history includes that Turn; source priority alone
+    // does not establish that the returned window contains the latest conversation.
+    if (previous?.source === 'runtime' &&
+        previous.turns.length > 0 &&
+        next.source !== 'runtime' &&
+        (authority === undefined || sourceRank(next.source) >= sourceRank(authority))) {
+        const boundary = previous.turns.findLastIndex((turn) => next.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+        if (boundary < 0)
+            return { page: previous, authority: next.source };
+        const tail = previous.turns
+            .slice(boundary + 1)
+            .filter((turn) => !next.turns.some((candidate) => sameConversationTurn(candidate, turn)));
+        if (tail.length > 0)
+            return {
+                page: {
+                    ...next,
+                    source: 'runtime',
+                    snapshotSequence: previous.snapshotSequence,
+                    turns: [...next.turns, ...tail]
+                },
+                authority: next.source
+            };
+    }
     if (previous === undefined ||
         authority === undefined ||
         sourceRank(next.source) >= sourceRank(authority))
@@ -91,13 +120,37 @@ export class ConversationHistoryService {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
         const activeCursor = decodeActiveHistoryCursor(input.cursor, session.id);
-        if (activeCursor !== undefined || this.options.hasManagedActiveRun(session))
+        if (activeCursor !== undefined ||
+            this.options.hasManagedActiveRun(session) ||
+            this.hasManagedRuntimeHistory(session))
             return this.readManagedActive(session, input, activeCursor, snapshotSequence, readAt);
         return this.readHistory(session, input, snapshotSequence, readAt);
     }
     async readHistoryPage(session, input) {
+        if (this.hasManagedRuntimeHistory(session)) {
+            const runtimeTurns = this.options.runtime.listConversationTurns({
+                sessionId: session.id,
+                limit: 500
+            }).turns;
+            const olderCursor = this.options.hasManagedActiveRun(session)
+                ? {
+                    sessionId: session.id,
+                    stage: 'OFFICIAL',
+                    beforeAt: oldestTurnActivityAt(runtimeTurns),
+                    cursor: null
+                }
+                : undefined;
+            return this.readManagedActive(session, input, olderCursor, this.options.snapshotSequence(), Date.now());
+        }
         return this.readHistory(session, input, this.options.snapshotSequence(), Date.now());
     }
+    hasManagedRuntimeHistory(session) {
+        return (session.runner === 'mar-agent' &&
+            session.nativeControl === 'MAR_MANAGED' &&
+            this.options.runtime.getAgentSession(session.id) !== undefined &&
+            this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 1 }).turns.length >
+                0);
+    }
     async readHistory(session, input, snapshotSequence, readAt) {
         const selected = await this.readRunnerHistory(session, input);
         if (selected.page?.source === 'native')
@@ -113,9 +166,9 @@ export class ConversationHistoryService {
                 ? []
                 : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 }).turns;
             const initialOfficialTurns = official.turns;
-            const lastRepresentedRuntimeIndex = runtimeTurns.findLastIndex((turn) => initialOfficialTurns.some((officialTurn) => sameHistoryConversationTurn(officialTurn, turn)));
+            const lastRepresentedRuntimeIndex = runtimeTurns.findLastIndex((turn) => initialOfficialTurns.some((officialTurn) => sameConversationTurn(officialTurn, turn)));
             const officialHasTurns = initialOfficialTurns.length > 0;
-            const absentLocalTurns = runtimeTurns.filter((turn, index) => !initialOfficialTurns.some((officialTurn) => sameHistoryConversationTurn(officialTurn, turn)) &&
+            const absentLocalTurns = runtimeTurns.filter((turn, index) => !initialOfficialTurns.some((officialTurn) => sameConversationTurn(officialTurn, turn)) &&
                 (!officialHasTurns || index > lastRepresentedRuntimeIndex));
             const missingLocalTurns = absentLocalTurns.slice(-limit);
             if (input.cursor === undefined &&
@@ -130,7 +183,7 @@ export class ConversationHistoryService {
             const runtimeTurnsByOfficialId = new Map();
             const runtimeSupplementalItemsByOfficialId = new Map();
             for (const officialTurn of officialTurns) {
-                const runtimeTurn = runtimeTurns.find((candidate) => sameHistoryConversationTurn(officialTurn, candidate));
+                const runtimeTurn = runtimeTurns.find((candidate) => sameConversationTurn(officialTurn, candidate));
                 if (runtimeTurn === undefined)
                     continue;
                 runtimeTurnsByOfficialId.set(officialTurn.id, runtimeTurn);
@@ -459,7 +512,7 @@ function latestTurnActivityAt(turn) {
     return Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0);
 }
 function oldestTurnActivityAt(turns) {
-    return turns.length === 0 ? 0 : Math.min(...turns.map(latestTurnActivityAt));
+    return turns.length === 0 ? 0 : Math.min(...turns.map(earliestTurnActivityAt));
 }
 function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments) {
     const officialUser = officialTurn.items.find((item) => item.kind === 'user_message');
@@ -524,9 +577,6 @@ function mergeRuntimeUserImageReferences(officialTurn, runtimeTurn, attachments)
             : item)
     };
 }
-function sameHistoryConversationTurn(left, right) {
-    return sameConversationTurn(left, right) || (left.runId !== null && left.runId === right.runId);
-}
 function sameConversationTurn(left, right) {
     if (left.id === right.id)
         return true;

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

@@ -6,7 +6,7 @@ function conversationSegmentPrefix(turn) {
         : undefined;
     const clientMessageId = payload?.clientMessageId;
     return typeof clientMessageId === 'string' && clientMessageId.length > 0
-        ? `${turn.sessionId}:message:${clientMessageId}`
+        ? `message:${clientMessageId}`
         : turn.id;
 }
 export function conversationSegments(turn) {

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

@@ -115,6 +115,7 @@ export class NativeSessionWatchService {
             mode: this.options.managedActive(session) ? 'RUNNING' : 'HISTORY',
             expiresAt: Date.now() + TTL_MS,
             refresh: undefined,
+            refreshMode: undefined,
             sessionSignature: undefined,
             signature: undefined,
             page: undefined,
@@ -202,7 +203,7 @@ export class NativeSessionWatchService {
     get size() {
         return this.watches.size;
     }
-    async refresh(sessionId, limit = 10, emit = true) {
+    async refresh(sessionId, limit = 10, mode = 'observation') {
         const watch = this.watches.get(sessionId);
         if (watch === undefined)
             return undefined;
@@ -212,20 +213,19 @@ export class NativeSessionWatchService {
             this.stop(sessionId);
             return undefined;
         }
-        const refresh = this.performRefresh(sessionId, watch, limit, emit);
-        watch.refresh = refresh;
-        try {
-            return await refresh;
-        }
-        finally {
+        const refresh = this.performRefresh(sessionId, watch, limit, mode).finally(() => {
             if (this.watches.get(sessionId) === watch) {
                 watch.refresh = undefined;
+                watch.refreshMode = undefined;
                 clearTimeout(watch.timer);
                 watch.timer = this.refreshTimer(sessionId);
             }
-        }
+        });
+        watch.refresh = refresh;
+        watch.refreshMode = mode;
+        return refresh;
     }
-    async performRefresh(sessionId, watch, limit, emit) {
+    async performRefresh(sessionId, watch, limit, mode) {
         let stage = 'resolve';
         let session;
         const readHistoricalPage = watch.mode === 'HISTORY' && this.options.readHistoryPage !== undefined;
@@ -238,7 +238,7 @@ export class NativeSessionWatchService {
                 return undefined;
             }
             watch.session = session;
-            if (emit && this.options.managedActive(session))
+            if (mode === 'observation' && this.options.managedActive(session))
                 return watch.page;
             stage = 'refresh_activity';
             await this.options.refreshActivity(session);
@@ -249,14 +249,26 @@ export class NativeSessionWatchService {
             const page = await (readHistoricalPage
                 ? this.options.readHistoryPage(session, limit)
                 : this.options.readPage(session, limit));
-            if (emit && revisionBeforeRead !== watch.eventRevision)
-                return watch.page;
+            if (revisionBeforeRead !== watch.eventRevision) {
+                // Initial still needs a full page for its new lease, whose pending events will
+                // replay above that page's sequence. Never publish this invalidated read to
+                // existing leases or replace their shared observation state.
+                if (mode !== 'initial')
+                    return watch.page;
+                const initial = this.options.convergePage(watch.page, watch.observedPage, page, watch.authority).page;
+                if (watch.page === undefined && watch.signature === undefined)
+                    watch.signature = JSON.stringify({
+                        source: initial.source,
+                        turns: initial.turns.slice(-(EMITTED_TURN_LIMIT + 1))
+                    });
+                return initial;
+            }
             stage = 'present_session';
             const presented = this.options.present(session);
             const sessionSignature = JSON.stringify(presented);
             if (sessionSignature !== watch.sessionSignature) {
                 watch.sessionSignature = sessionSignature;
-                if (emit)
+                if (mode === 'observation')
                     this.options.emitSession(presented);
             }
             watch.failures = 0;
@@ -265,7 +277,7 @@ export class NativeSessionWatchService {
                 : page.turns.slice(-EMITTED_TURN_LIMIT);
             const observed = { ...page, turns };
             stage = 'converge_page';
-            const convergence = this.options.convergePage(watch.page, watch.observedPage, observed, watch.authority);
+            const convergence = this.options.convergePage(watch.page, watch.observedPage, page, watch.authority);
             const converged = convergence.page;
             const accepted = converged.turns.length <= EMITTED_TURN_LIMIT + 1
                 ? converged
@@ -285,14 +297,18 @@ export class NativeSessionWatchService {
             const changed = signature !== watch.signature;
             if (changed) {
                 watch.signature = signature;
-                watch.page = accepted;
             }
+            if (changed || watch.page === undefined)
+                watch.page = accepted;
             stage = 'emit_page';
-            if (emit && completingConvergence)
+            if (completingConvergence && accepted.source === 'runtime')
+                this.releasePendingEvents(session.id);
+            else if (completingConvergence)
                 this.emitSnapshotToLeases(session, accepted, true);
-            else if (emit && changed)
+            else if (changed)
                 this.emitObservedPage(session, accepted);
-            return emit ? accepted : page;
+            // Initial uses the full result of the same authority decision as observation.
+            return mode === 'initial' ? converged : accepted;
         }
         catch (error) {
             watch.failures += 1;
@@ -345,15 +361,19 @@ export class NativeSessionWatchService {
             const activeAtStart = this.options.managedActive(session);
             if (watch !== undefined)
                 watch.mode = activeAtStart ? 'RUNNING' : watch.mode;
-            const cached = !activeAtStart && watch?.page !== undefined ? watch.page : undefined;
-            let page = activeAtStart
-                ? watch === undefined
-                    ? undefined
-                    : this.composeRuntimePage(watch.page, await this.readRuntimePage(watch, session))
-                : (cached ??
-                    (watch === undefined
-                        ? undefined
-                        : await this.refresh(session.id, INITIAL_TURN_LIMIT, false)));
+            let page;
+            if (watch !== undefined) {
+                if (activeAtStart)
+                    page = this.composeRuntimePage(watch.page, await this.readRuntimePage(watch, session));
+                else {
+                    // An initial subscription must read after any older observation, not join its
+                    // potentially smaller or already-stale page.
+                    if (watch.refresh !== undefined &&
+                        (watch.page !== undefined || watch.refreshMode === 'observation'))
+                        await watch.refresh;
+                    page = await this.refresh(session.id, INITIAL_TURN_LIMIT, 'initial');
+                }
+            }
             if (page === undefined)
                 throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
             if (lease.snapshotSent)
@@ -506,7 +526,7 @@ export class NativeSessionWatchService {
             watch.mode !== 'CONVERGING' ||
             watch.transitionGeneration !== generation)
             return;
-        await this.refresh(session.id, INITIAL_TURN_LIMIT, true);
+        await this.refresh(session.id, INITIAL_TURN_LIMIT);
     }
     emitLeaseEvent(lease, event) {
         this.options.emitWatchEvent?.({

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

@@ -146,7 +146,12 @@ export class RunEventService {
         }
         if (!terminalExecution)
             return;
-        if (targetsCurrentTurn && createdTurn === undefined) {
+        // A completed reply has already been delivered through its own stream event. Only a
+        // continuing Run, an exceptional termination, or a pending item needs a final Turn update.
+        if (targetsCurrentTurn &&
+            createdTurn === undefined &&
+            (finalStatus !== 'SUCCEEDED' ||
+                targetTurn?.items.some((item) => item.status === 'PENDING' || item.status === 'IN_PROGRESS'))) {
             const turn = this.options.runtime.conversationTurnForRun(runId);
             if (turn !== undefined)
                 this.options.emitWorkbench('conversation', { turn });

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

@@ -39,15 +39,19 @@ export class SessionCommandService {
             (await this.options.projection.resolveCurrent(input.sessionId));
         if (resolved === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        if (resolved.nativeControl === 'EXTERNAL')
-            throw new Error('SESSION_ACTIVATION_REQUIRED');
-        const session = resolved;
         const command = this.options
             .profiles()
-            .find((profile) => profile.runner === session.runner)
+            .find((profile) => profile.runner === resolved.runner)
             ?.commands.find((candidate) => isPlainRecord(candidate) && candidate.id === input.commandId);
+        if (resolved.nativeControl === 'EXTERNAL' && command?.source !== 'MAR_RUNTIME')
+            throw new Error('SESSION_ACTIVATION_REQUIRED');
         if (command?.available !== true)
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const session = resolved.nativeControl === 'EXTERNAL' && command.source === 'MAR_RUNTIME'
+            ? await this.options.resolveForCommand(input.sessionId)
+            : resolved;
+        if (session.nativeControl === 'EXTERNAL')
+            throw new Error('SESSION_ACTIVATION_REQUIRED');
         if ((command.interaction === 'IMMEDIATE_ACTION' ||
             command.interaction === 'DESTRUCTIVE_ACTION') &&
             this.options.runtime.hasActiveSessionLease(session.id))

package/dist/util/runner-native-session-parsers.js

@@ -159,7 +159,9 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const runtimeErrors = (runtimeTurn?.items ?? [])
             .filter((item) => item.kind === 'error')
             .map((item) => ({ ...item, turnId, runId: runtimeTurn?.runId ?? null }));
-        const items = runtimeAssistantProjectionMoreComplete(runtimeTurn, nativeItems)
+        // Native transcripts do not expose a terminal event for an individual response.
+        // Once linked to a managed Run, the Runtime owns that Turn until it leaves memory.
+        const items = runtimeTurn !== undefined
             ? runtimeTurn.items.map((item) => ({
                 ...item,
                 turnId,
@@ -225,22 +227,6 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             : precedingWindow
     };
 }
-export function runtimeAssistantProjectionMoreComplete(runtimeTurn, projectedItems) {
-    if (runtimeTurn === undefined)
-        return false;
-    const assistantStats = (items) => items.reduce((stats, item) => {
-        if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
-            return stats;
-        return {
-            count: stats.count + 1,
-            characters: stats.characters +
-                (typeof item.payload.text === 'string' ? item.payload.text.length : 0)
-        };
-    }, { count: 0, characters: 0 });
-    const runtime = assistantStats(runtimeTurn.items);
-    const projected = assistantStats(projectedItems);
-    return runtime.count > projected.count || runtime.characters > projected.characters;
-}
 function runtimeTurnClientMessageId(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');
     return isPlainRecord(user?.payload) && typeof user.payload.clientMessageId === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.105",
+  "version": "0.9.107",
   "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.105",
-    "@myagentroam/code-navigation": "0.9.105",
-    "@myagentroam/protocol": "0.9.105"
+    "@myagentroam/agent": "0.9.107",
+    "@myagentroam/code-navigation": "0.9.107",
+    "@myagentroam/protocol": "0.9.107"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"