@myagentroam/node 0.1.3 → 0.1.6

package/dist/runtime-state.js

@@ -484,22 +484,23 @@ export class NodeRuntimeState {
         // Queued turns have not received `run.started` yet. Their user item still
         // has the acceptance timestamp, so use it rather than sorting every
         // queued turn as time zero. The insertion index makes same-millisecond
-        // sends deterministic; callers receive newest first and render reverse.
+        // sends deterministic; callers receive every page from oldest to newest.
         const all = [...(this.turns.get(input.sessionId) ?? [])]
             .map((turn, index) => ({ turn, index }))
             .sort((a, b) => {
             const timestamp = (value) => value.startedAt ??
                 value.items.find((item) => item.id === value.userItemId)?.startedAt ??
                 0;
-            return timestamp(b.turn) - timestamp(a.turn) || b.index - a.index;
+            return timestamp(a.turn) - timestamp(b.turn) || a.index - b.index;
         })
             .map(({ turn }) => turn);
-        const start = decodeCursor(input.cursor, input.sessionId);
+        const end = input.cursor === undefined ? all.length : decodeCursor(input.cursor, input.sessionId);
         const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
-        const slice = all.slice(start, start + limit);
+        const start = Math.max(0, end - limit);
+        const slice = all.slice(start, end);
         return {
             turns: slice,
-            nextCursor: start + limit < all.length ? encodeCursor(input.sessionId, start + limit) : null
+            nextCursor: start > 0 ? encodeCursor(input.sessionId, start) : null
         };
     }
     conversationTurnForRun(runId) {
@@ -753,15 +754,18 @@ export class NodeRuntimeState {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
                 typeof event.payload.text === 'string') {
-                const existing = turn.items.find((item) => item.id === `${event.runId}:assistant`);
+                const lastItem = turn.items.at(-1);
+                const existing = lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
+                    ? lastItem
+                    : undefined;
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
                 const item = {
-                    id: `${event.runId}:assistant`,
+                    id: existing?.id ?? `${event.runId}:assistant:${event.sequence}`,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
                     parentItemId: null,
-                    sourceSequence: event.sequence,
+                    sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: event.sequence,
                     kind: 'assistant_message',
                     status: 'IN_PROGRESS',
@@ -773,12 +777,20 @@ export class NodeRuntimeState {
                     ...turn,
                     status: 'RUNNING',
                     startedAt: turn.startedAt ?? event.createdAt,
-                    items: [...turn.items.filter((value) => value.id !== item.id), item]
+                    items: existing === undefined
+                        ? [...turn.items, item]
+                        : turn.items.map((value) => (value.id === item.id ? item : value))
                 };
             }
             const projected = conversationItemFromEvent(event);
             if (projected !== undefined) {
-                const existing = turn.items.find((item) => item.id === `${event.runId}:${projected.itemId}`);
+                const trailingItem = turn.items.at(-1);
+                const orderedItems = trailingItem?.kind === 'assistant_message' && activeConversationItem(trailingItem.status)
+                    ? turn.items.map((item) => item.id === trailingItem.id
+                        ? { ...item, status: 'COMPLETED', completedAt: event.createdAt }
+                        : item)
+                    : turn.items;
+                const existing = orderedItems.find((item) => item.id === `${event.runId}:${projected.itemId}`);
                 const status = projected.status;
                 const item = {
                     id: `${event.runId}:${projected.itemId}`,
@@ -786,7 +798,7 @@ export class NodeRuntimeState {
                     turnId: turn.id,
                     runId: event.runId,
                     parentItemId: null,
-                    sourceSequence: event.sequence,
+                    sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: (existing?.revision ?? -1) + 1,
                     kind: projected.kind,
                     status,
@@ -799,8 +811,8 @@ export class NodeRuntimeState {
                     status: terminal(run.status) ? run.status : 'RUNNING',
                     startedAt: turn.startedAt ?? event.createdAt,
                     items: existing === undefined
-                        ? [...turn.items, item]
-                        : turn.items.map((value) => (value.id === item.id ? item : value))
+                        ? [...orderedItems, item]
+                        : orderedItems.map((value) => (value.id === item.id ? item : value))
                 };
             }
             if (event.eventType === 'run.started' || event.eventType === 'run.running')
@@ -873,6 +885,7 @@ function projectableConversationKind(value) {
         value === 'plan' ||
         value === 'file_change' ||
         value === 'context_compaction' ||
+        value === 'unknown' ||
         value === 'warning' ||
         value === 'error');
 }
@@ -954,4 +967,3 @@ function decodeCursor(cursor, scope) {
         return 0;
     }
 }
-//# sourceMappingURL=runtime-state.js.map

package/dist/service/attachment-domain-state.d.ts

@@ -0,0 +1,5 @@
+export declare class AttachmentDomainState<TCachedRunImages, TNativeImageSource> {
+    readonly runDirectories: Map<string, string>;
+    readonly runImages: Map<string, TCachedRunImages>;
+    readonly nativeHistoryImages: Map<string, TNativeImageSource[]>;
+}

package/dist/service/attachment-domain-state.js

@@ -0,0 +1,5 @@
+export class AttachmentDomainState {
+    runDirectories = new Map();
+    runImages = new Map();
+    nativeHistoryImages = new Map();
+}

package/dist/service/conversation-history-service.d.ts

@@ -0,0 +1,34 @@
+import type { NodeCapabilities, SessionActivityState } from '@myagentroam/protocol';
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import { type ConversationHistoryPage } from '../util/runner-native-session-parsers.js';
+import type { RunAttachmentService } from './run-attachment-service.js';
+export declare function hasManagedActiveRun(runtime: NodeRuntimeState, session: NodeAgentSession): boolean;
+interface ConversationHistoryServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly capabilities: () => NodeCapabilities;
+    readonly attachments: RunAttachmentService;
+    readonly snapshotSequence: () => number;
+    readonly hasManagedActiveRun: (session: NodeAgentSession) => boolean;
+    readonly setExternalActivity: (sessionId: string, activity: SessionActivityState) => void;
+}
+export declare class ConversationHistoryService {
+    private readonly options;
+    constructor(options: ConversationHistoryServiceOptions);
+    read(session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }): Promise<ConversationHistoryPage>;
+    refreshExternalActivity(session: NodeAgentSession): Promise<void>;
+    readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
+    private attachNativeImages;
+    readOfficial(session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }): Promise<import("../runner/abstract-runner.js").RunnerOfficialConversationPage | undefined>;
+    private managedRunnerTurn;
+    private page;
+}
+export {};

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

@@ -0,0 +1,158 @@
+import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
+import { coalesceImageGenerationItems } from '../runner/codex/conversation-parser.js';
+import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
+import { isPlainRecord } from '../util/node-operation-parsers.js';
+export function hasManagedActiveRun(runtime, session) {
+    return (session.nativeControl === 'MAR_MANAGED' &&
+        runtime
+            .listRunsForSession(session.id)
+            .some((run) => run.status === 'STARTING' || run.status === 'RUNNING' || run.status === 'CANCELLING'));
+}
+export class ConversationHistoryService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async read(session, input) {
+        const snapshotSequence = this.options.snapshotSequence();
+        const readAt = Date.now();
+        const official = await this.readOfficial(session, input);
+        if (official !== undefined) {
+            const officialTurns = await this.attachNativeImages(session, official.turns);
+            const officialRunIds = new Set(officialTurns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
+            const localTurns = this.options.runtime.getAgentSession(session.id) === undefined
+                ? []
+                : this.options.runtime
+                    .listConversationTurns({ sessionId: session.id, limit: 500 })
+                    .turns.flatMap((turn) => {
+                    if (turn.runId === null || !officialRunIds.has(turn.runId))
+                        return [turn];
+                    const pendingItems = turn.items.filter((item) => item.kind === 'user_input_request' && item.status === 'PENDING');
+                    return pendingItems.length === 0 ? [] : [{ ...turn, items: pendingItems }];
+                });
+            const localRequestIds = new Set(localTurns.flatMap((turn) => turn.items.flatMap((item) => {
+                const requestId = item.kind === 'user_input_request' && isPlainRecord(item.payload)
+                    ? item.payload.requestId
+                    : undefined;
+                return typeof requestId === 'string' ? [requestId] : [];
+            })));
+            const turns = [
+                ...officialTurns
+                    .map((turn) => ({
+                    ...turn,
+                    items: turn.items.filter((item) => item.kind !== 'user_input_request' ||
+                        !isPlainRecord(item.payload) ||
+                        typeof item.payload.requestId !== 'string' ||
+                        !localRequestIds.has(item.payload.requestId))
+                }))
+                    .filter((turn) => turn.items.length > 0),
+                ...localTurns
+            ].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            return this.page(official.nextCursor, turns, {
+                snapshotSequence,
+                source: 'official',
+                readAt
+            });
+        }
+        if (session.externalSessionId !== null && !this.options.hasManagedActiveRun(session)) {
+            const history = await this.readNative(session);
+            if (history !== undefined) {
+                if (history.truncated !== true ||
+                    this.options.runners.require(session.runner).acceptsTruncatedNativeHistory()) {
+                    const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
+                        ? []
+                        : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 })
+                            .turns;
+                    const page = nativeConversationPage(session, history, input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
+                    return this.page(page.nextCursor, page.turns, {
+                        snapshotSequence,
+                        source: 'native',
+                        readAt
+                    });
+                }
+                const runtimePage = this.options.runtime.listConversationTurns({
+                    sessionId: session.id,
+                    ...input
+                });
+                if (runtimePage.turns.length === 0)
+                    throw new Error('NATIVE_TRANSCRIPT_INCOMPLETE');
+                return this.page(runtimePage.nextCursor, runtimePage.turns, {
+                    snapshotSequence,
+                    source: 'runtime',
+                    readAt
+                });
+            }
+            if (session.nativeControl === 'EXTERNAL')
+                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        }
+        const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
+        return this.page(page.nextCursor, page.turns, { snapshotSequence, source: 'runtime', readAt });
+    }
+    async refreshExternalActivity(session) {
+        const runner = this.options.runners.require(session.runner);
+        if (!runner.available(this.options.capabilities())) {
+            this.options.setExternalActivity(session.id, 'UNAVAILABLE');
+            return;
+        }
+        const activity = await runner.readExternalActivity(session);
+        if (activity !== undefined)
+            this.options.setExternalActivity(session.id, activity);
+    }
+    async readNative(session) {
+        if (session.externalSessionId === null)
+            return undefined;
+        const current = await readNativeSession(session.runner, session.cwd, session.externalSessionId);
+        if (current !== undefined)
+            return current;
+        await discoverNativeSessions(session.runner, session.cwd);
+        return readNativeSession(session.runner, session.cwd, session.externalSessionId);
+    }
+    async attachNativeImages(session, turns) {
+        const history = await this.readNative(session);
+        if (history === undefined)
+            return turns;
+        const attachments = new Map();
+        for (const item of history.items) {
+            if (item.kind !== 'tool_call' || item.imageAttachments === undefined)
+                continue;
+            const registered = this.options.attachments.registerNative(session, item.imageAttachments);
+            if (registered.length > 0)
+                attachments.set(item.toolUseId, registered);
+        }
+        if (attachments.size === 0)
+            return turns;
+        return turns.map((turn) => ({
+            ...turn,
+            items: coalesceImageGenerationItems(turn.items.map((item) => {
+                const registered = attachments.get(item.id.slice(item.id.lastIndexOf(':') + 1));
+                if (registered === undefined || !isPlainRecord(item.payload))
+                    return item;
+                return { ...item, payload: { ...item.payload, attachments: registered } };
+            }))
+        }));
+    }
+    async readOfficial(session, input) {
+        const runner = this.options.runners.require(session.runner);
+        if (session.externalSessionId === null || !runner.available(this.options.capabilities()))
+            return undefined;
+        return runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+    }
+    managedRunnerTurn(session, nativeTurnId) {
+        const runId = this.options.runners
+            .require(session.runner)
+            .managedRunForNativeTurn(nativeTurnId);
+        if (runId === undefined)
+            return undefined;
+        return this.options.runtime
+            .listConversationTurns({ sessionId: session.id, limit: 500 })
+            .turns.find((turn) => turn.runId === runId);
+    }
+    page(nextCursor, turns, metadata) {
+        return {
+            ...metadata,
+            turns,
+            nextCursor,
+            latestVisibleAt: Math.max(0, ...turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)))
+        };
+    }
+}

package/dist/service/external-session-resume-service.d.ts

@@ -0,0 +1,32 @@
+import type { RunnerDefaultConfiguration } from '@myagentroam/protocol';
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { SessionDomainState } from './session-domain-state.js';
+interface ExternalSessionResumeServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly state: SessionDomainState<NodeAgentSession, unknown>;
+    readonly available: (runner: NodeAgentSession['runner']) => boolean;
+    readonly projectionFor: (session: NodeAgentSession) => NodeAgentSession | undefined;
+    readonly managedAliasFor: (session: NodeAgentSession) => NodeAgentSession | undefined;
+    readonly ensureConfiguration: (session: NodeAgentSession) => NodeAgentSession;
+    readonly configuration: (session: NodeAgentSession) => RunnerDefaultConfiguration;
+    readonly workspacePath: (workspaceId: string) => string | undefined;
+    readonly rememberNative: (nativeSessionId: string, sessionId: string) => void;
+    readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
+}
+export declare class ExternalSessionResumeService {
+    private readonly options;
+    constructor(options: ExternalSessionResumeServiceOptions);
+    resume(external: NodeAgentSession, force?: boolean): Promise<NodeAgentSession | undefined>;
+    failure(sessionId: string): {
+        readonly code: string;
+        readonly detail?: string;
+    };
+    resolveForMessage(sessionId: string): Promise<NodeAgentSession>;
+    delivery(session: NodeAgentSession): 'RESUMABLE' | 'REJECTED';
+    private clearFailure;
+    private setFailure;
+}
+export {};

package/dist/service/external-session-resume-service.js

@@ -0,0 +1,98 @@
+export class ExternalSessionResumeService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async resume(external, force = false) {
+        this.clearFailure(external.id);
+        const priorId = this.options.state.resumedByDirectId.get(external.id);
+        const prior = priorId === undefined ? undefined : this.options.runtime.getAgentSession(priorId);
+        if (prior !== undefined)
+            return this.options.ensureConfiguration(prior);
+        const runner = this.options.runners.product(external.runner);
+        if (runner === undefined) {
+            this.setFailure(external.id, 'RUNNER_UNAVAILABLE');
+            return undefined;
+        }
+        const result = await runner.resumeExternal(external, {
+            available: this.options.available(external.runner),
+            projectionFor: this.options.projectionFor,
+            managedAliasFor: this.options.managedAliasFor,
+            currentResumed: (sessionId) => {
+                const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+                return resumedId === undefined
+                    ? undefined
+                    : this.options.runtime.getAgentSession(resumedId);
+            },
+            promote: (sessionId) => {
+                this.options.runtime.setNativeControl(sessionId, 'MAR_MANAGED');
+                return this.options.runtime.getAgentSession(sessionId);
+            },
+            ensureConfiguration: this.options.ensureConfiguration,
+            create: (session) => {
+                const configuration = this.options.configuration(session);
+                return this.options.runtime.createAgentSession({
+                    workspaceId: session.workspaceId,
+                    runner: session.runner,
+                    ...(session.externalSessionId === null
+                        ? {}
+                        : { externalSessionId: session.externalSessionId }),
+                    nativeControl: 'MAR_MANAGED',
+                    cwd: session.cwd,
+                    model: configuration.model,
+                    effort: configuration.effort,
+                    access: configuration.access,
+                    ...(session.runnerTitle === null ? {} : { title: session.runnerTitle })
+                });
+            },
+            workspacePath: this.options.workspacePath,
+            rememberManagedNative: this.options.rememberNative
+        }, force);
+        if (result.activity !== undefined)
+            this.options.state.externalActivity.set(external.id, result.activity);
+        if (result.session !== undefined) {
+            this.options.state.resumedByDirectId.set(external.id, result.session.id);
+            return result.session;
+        }
+        this.setFailure(external.id, result.failureCode ?? 'SESSION_RESUME_REJECTED', result.failureDetail);
+        this.options.state.messageResumeFailures.set(external.id, result.messageFailureCode ?? result.failureCode ?? 'SESSION_RESUME_REJECTED');
+        return undefined;
+    }
+    failure(sessionId) {
+        const code = this.options.state.resumeFailures.get(sessionId) ?? 'SESSION_RESUME_REJECTED';
+        const detail = this.options.state.resumeFailureDetails.get(sessionId);
+        return detail === undefined ? { code } : { code, detail };
+    }
+    async resolveForMessage(sessionId) {
+        const resumedId = this.options.state.resumedByDirectId.get(sessionId);
+        const current = this.options.runtime.getAgentSession(resumedId ?? sessionId) ??
+            (await this.options.resolve(sessionId));
+        if (current === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (current.nativeControl !== 'EXTERNAL')
+            return current;
+        const resumed = await this.resume(current);
+        if (resumed !== undefined)
+            return resumed;
+        if (this.options.state.externalActivity.get(current.id) === 'EXTERNAL_ACTIVE')
+            throw new Error('EXTERNAL_SESSION_ACTIVE');
+        throw new Error(this.options.state.messageResumeFailures.get(current.id) ?? this.failure(current.id).code);
+    }
+    delivery(session) {
+        return session.nativeControl === 'EXTERNAL' && session.externalSessionId !== null
+            ? 'RESUMABLE'
+            : 'REJECTED';
+    }
+    clearFailure(sessionId) {
+        this.options.state.resumeFailures.delete(sessionId);
+        this.options.state.resumeFailureDetails.delete(sessionId);
+        this.options.state.messageResumeFailures.delete(sessionId);
+    }
+    setFailure(sessionId, code, detail) {
+        this.options.state.resumeFailures.set(sessionId, code);
+        if (detail === undefined)
+            this.options.state.resumeFailureDetails.delete(sessionId);
+        else
+            this.options.state.resumeFailureDetails.set(sessionId, detail);
+    }
+}

package/dist/service/fake-managed-run-service.d.ts

@@ -0,0 +1,29 @@
+import type { NodeEnvelope } from '@myagentroam/protocol';
+import type { FakeRunnerStatus, FakeRunnerStep } from '../fake-runner.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { FakeTestRunner } from '../runner/fake-test-runner.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { RunDomainState } from './run-domain-state.js';
+interface FakeManagedRunServiceOptions {
+    readonly runner: FakeTestRunner;
+    readonly script: (input: unknown, runId: string) => readonly FakeRunnerStep[];
+    readonly runners: RunnerRegistry;
+    readonly runtime: NodeRuntimeState;
+    readonly state: RunDomainState;
+    readonly emitRun: (runId: string, type: string, payload: unknown, status?: FakeRunnerStatus) => void;
+    readonly publishApproval: (input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly payload: unknown;
+        readonly expiresAt: number;
+    }) => void;
+    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
+    readonly disconnect: () => void;
+}
+/** Test-only managed Run adapter; production Runner paths never depend on it. */
+export declare class FakeManagedRunService {
+    private readonly options;
+    constructor(options: FakeManagedRunServiceOptions);
+    start(envelope: NodeEnvelope): void;
+}
+export {};

package/dist/service/fake-managed-run-service.js

@@ -0,0 +1,62 @@
+import { isTerminalRunStatus } from '../runner/codex/conversation-parser.js';
+/** Test-only managed Run adapter; production Runner paths never depend on it. */
+export class FakeManagedRunService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    start(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.runId !== 'string' || this.options.state.active.has(payload.runId))
+            return;
+        const runId = payload.runId;
+        const cwd = typeof payload.cwd === 'string' ? payload.cwd : undefined;
+        if (typeof payload.sessionId === 'string' &&
+            typeof payload.runner === 'string' &&
+            cwd !== undefined) {
+            const runner = this.options.runners.product(payload.runner);
+            if (runner === undefined)
+                return;
+            this.options.runtime.adoptRun({
+                runId,
+                sessionId: payload.sessionId,
+                ...(typeof payload.workspaceId === 'string' ? { workspaceId: payload.workspaceId } : {}),
+                runner: runner.name,
+                cwd
+            });
+        }
+        this.options.state.active.add(runId);
+        void this.options.runner
+            .start(runId, this.options.script(payload.input, runId), {
+            event: (eventType, eventPayload, status) => {
+                this.options.emitRun(runId, eventType, eventPayload, status);
+                if (status !== undefined && isTerminalRunStatus(status)) {
+                    this.options.state.active.delete(runId);
+                    if (cwd !== undefined)
+                        void this.options.captureSnapshot(runId, cwd);
+                }
+            },
+            approval: (approvalId, approvalPayload, expiresAt) => {
+                try {
+                    this.options.runtime.createApproval({
+                        runId,
+                        approvalId,
+                        payload: approvalPayload,
+                        expiresAt
+                    });
+                }
+                catch {
+                    return;
+                }
+                this.options.publishApproval({
+                    runId,
+                    approvalId,
+                    payload: approvalPayload,
+                    expiresAt
+                });
+            },
+            disconnect: this.options.disconnect
+        })
+            .finally(() => this.options.state.active.delete(runId));
+    }
+}

package/dist/service/managed-runner-session-service.d.ts

@@ -0,0 +1,12 @@
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { NodeAgentSession } from '../database.js';
+/** Owns managed native-session identity and best-effort native title refresh. */
+export declare class ManagedRunnerSessionService {
+    private readonly runtime;
+    private readonly runners;
+    private readonly emitSession;
+    constructor(runtime: NodeRuntimeState, runners: RunnerRegistry, emitSession: (session: NodeAgentSession) => void);
+    remember(nativeSessionId: string, sessionId: string): void;
+    refreshTitle(sessionId: string, externalSessionId: string, cwd: string): Promise<void>;
+}

package/dist/service/managed-runner-session-service.js

@@ -0,0 +1,35 @@
+/** Owns managed native-session identity and best-effort native title refresh. */
+export class ManagedRunnerSessionService {
+    runtime;
+    runners;
+    emitSession;
+    constructor(runtime, runners, emitSession) {
+        this.runtime = runtime;
+        this.runners = runners;
+        this.emitSession = emitSession;
+    }
+    remember(nativeSessionId, sessionId) {
+        const session = this.runtime.getAgentSession(sessionId);
+        if (session === undefined || session.nativeControl !== 'MAR_MANAGED')
+            return;
+        this.runners.require(session.runner).rememberManagedNative(session, nativeSessionId);
+    }
+    async refreshTitle(sessionId, externalSessionId, cwd) {
+        const session = this.runtime.getAgentSession(sessionId);
+        if (session === undefined || session.nativeControl !== 'MAR_MANAGED')
+            return;
+        try {
+            const title = await this.runners
+                .require(session.runner)
+                .readManagedRunnerTitle({ ...session, cwd }, externalSessionId);
+            if (title === undefined)
+                return;
+            const updated = this.runtime.setRunnerTitleFromNative(session.id, title);
+            if (updated.runnerTitle !== session.runnerTitle)
+                this.emitSession(updated);
+        }
+        catch {
+            // Native history is a best-effort source and cannot alter the completed Run result.
+        }
+    }
+}

package/dist/service/native-session-projection-service.d.ts

@@ -0,0 +1,51 @@
+import type { NodeCapabilities, RunnerDefaultConfiguration } from '@myagentroam/protocol';
+import type { CodexSessionControl } from '../codex-app-server.js';
+import type { NodeAgentSession, NodeDatabase } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { RunnerDiscoveryContext } from '../runner/abstract-runner.js';
+import type { CommandStateStore } from '../runner-command-engine.js';
+import type { SessionDomainState } from './session-domain-state.js';
+interface NativeSessionProjectionServiceOptions {
+    readonly database: () => NodeDatabase | undefined;
+    readonly nodeId: () => string;
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly capabilities: () => NodeCapabilities;
+    readonly state: SessionDomainState<NodeAgentSession, unknown>;
+    readonly commands: CommandStateStore;
+    readonly present: (session: NodeAgentSession) => NodeAgentSession & {
+        readonly control: CodexSessionControl;
+    };
+}
+export declare class NativeSessionProjectionService {
+    private readonly options;
+    constructor(options: NativeSessionProjectionServiceOptions);
+    discover(runnerName: NodeAgentSession['runner'], workspaceId?: string): Promise<readonly NodeAgentSession[]>;
+    discoverCodex(workspaceId?: string): Promise<{
+        readonly sessions: readonly (NodeAgentSession & {
+            readonly control: CodexSessionControl;
+        })[];
+    }>;
+    list(): Promise<readonly (NodeAgentSession & {
+        readonly control: CodexSessionControl;
+    })[]>;
+    discoverWorkspace(workspaceId: string): Promise<readonly NodeAgentSession[]>;
+    resolve(sessionId: string): Promise<NodeAgentSession | undefined>;
+    createMetadataProjection(sessionId: string): Promise<NodeAgentSession | undefined>;
+    resumedConfiguration(session: NodeAgentSession): RunnerDefaultConfiguration;
+    ensureResumedConfiguration(session: NodeAgentSession): NodeAgentSession;
+    rename(session: NodeAgentSession, input: {
+        readonly title?: string | null;
+        readonly pinned?: boolean;
+    }): Promise<void>;
+    project(input: Parameters<RunnerDiscoveryContext['createProjection']>[0]): NodeAgentSession;
+    remember(sessions: readonly NodeAgentSession[]): void;
+    projectionForNative(native: NodeAgentSession): NodeAgentSession | undefined;
+    managedForNative(native: NodeAgentSession): NodeAgentSession | undefined;
+    nativeIds(session: NodeAgentSession): ReadonlySet<string>;
+    forget(session: NodeAgentSession, knownNativeIds: ReadonlySet<string>): void;
+    private isManagedProjection;
+    private requireDatabase;
+}
+export {};