@myagentroam/node 0.9.2 → 0.9.4

package/dist/runner/codex-runner.js

@@ -1,4 +1,4 @@
-import { CodexAppServerClient } from '../codex-app-server.js';
+import { CodexAppServerClient, isCodexRolloutMissingError } from '../codex-app-server.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
@@ -11,6 +11,7 @@ import { codexSessionControl } from '../codex-app-server.js';
 import { extractId } from '../util/runner-native-session-parsers.js';
 import { nodeLog } from '../operational.js';
 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;
 export class CodexRunner extends AbstractRunner {
@@ -23,6 +24,7 @@ export class CodexRunner extends AbstractRunner {
     environmentFingerprint;
     environmentRuns = new Set();
     profileCache = new Map();
+    profileCacheTimers = new Map();
     profileRefreshes = new Map();
     profileClients = new Set();
     profileKeyByEnvironment = new Map();
@@ -74,7 +76,7 @@ export class CodexRunner extends AbstractRunner {
                 successful: true,
                 retryAt: 0
             };
-            this.profileCache.set(key, cache);
+            this.cacheProfile(key, cache);
             if (this.selectedProfileKey === key)
                 this.latestProfileCache = cache;
             return cache.profile;
@@ -88,7 +90,7 @@ export class CodexRunner extends AbstractRunner {
                 cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
                 return cached.profile;
             }
-            this.profileCache.set(key, {
+            this.cacheProfile(key, {
                 profile: { ...base, models: [] },
                 defaultConfiguration: emptyCodexConfiguration(),
                 fetchedAt: 0,
@@ -106,6 +108,25 @@ export class CodexRunner extends AbstractRunner {
             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;
+            }
+        }, CODEX_PROFILE_ENTRY_TTL_MS);
+        timer.unref();
+        this.profileCacheTimers.set(key, timer);
+    }
     async fetchCodexProfile(base, environment) {
         const client = this.profileClientFactory();
         this.profileClients.add(client);
@@ -430,6 +451,17 @@ export class CodexRunner extends AbstractRunner {
     start() {
         return this.client.start();
     }
+    async recoverMissingRollout(runId, error) {
+        if (!isCodexRolloutMissingError(error))
+            return false;
+        if ([...this.environmentRuns].some((activeRunId) => activeRunId !== runId))
+            return false;
+        if ([...this.execution.runs.keys()].some((activeRunId) => activeRunId !== runId))
+            return false;
+        nodeLog('runner.codex.rollout.recovering', { runId });
+        await this.client.restart();
+        return true;
+    }
     prepareEnvironment(environment, runId) {
         if (Object.keys(environment).length === 0 && this.environmentFingerprint === undefined) {
             this.environmentRuns.add(runId);
@@ -466,6 +498,13 @@ 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;
     }
     request(method, params) {
         return this.client.request(method, params);

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

@@ -128,7 +128,7 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     }, startedAt, completedAt, sequence);
 }
 export function openCodeQuestions(value) {
-    if (!Array.isArray(value) || value.length === 0 || value.length > 4)
+    if (!Array.isArray(value) || value.length === 0)
         return [];
     return value.flatMap((value, index) => {
         const question = record(value);

package/dist/runner/opencode/managed-run-controller.d.ts

@@ -17,10 +17,13 @@ interface OpenCodeManagedRunHost {
         cwd: string;
         externalSessionId?: string;
     }): void;
+    run(runId: string): {
+        readonly id: string;
+    };
+    hasActiveSessionLease(sessionId: string): boolean;
     promote(sessionId: string, nativeSessionId: string): void;
     rememberNative(nativeSessionId: string, sessionId: string): void;
     send(type: string, payload: unknown): void;
-    captureSnapshot(runId: string, cwd: string): Promise<void>;
     createApproval(input: {
         readonly runId: string;
         readonly approvalId: string;
@@ -41,7 +44,7 @@ interface OpenCodeManagedRunHost {
 }
 type OpenCodePublicItem = {
     readonly itemId: string;
-    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'unknown';
+    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'error' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;
@@ -60,6 +63,8 @@ export declare class OpenCodeManagedRunController {
     executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, context: {
         readonly secretEnvironment: Readonly<Record<string, string>>;
     }): Promise<unknown>;
+    private compact;
+    private runCompact;
     start(envelope: NodeEnvelope): void;
     cancel(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
     decideApproval(input: {

package/dist/runner/opencode/managed-run-controller.js

@@ -1,5 +1,5 @@
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
-import { safeErrorCode } from '../../util/safe-error.js';
+import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
 import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 export class OpenCodeManagedRunController {
@@ -19,7 +19,7 @@ export class OpenCodeManagedRunController {
     }
     async executeCommand(session, command, context) {
         if (command.id === 'compact')
-            return this.runner.executeCompact(session, context.secretEnvironment);
+            return this.compact(session, context.secretEnvironment);
         if (command.id !== 'plan')
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const current = this.host.commandState(session.id, 'plan');
@@ -37,6 +37,53 @@ export class OpenCodeManagedRunController {
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
+    compact(session, environment) {
+        if (session.externalSessionId === null ||
+            session.model === null ||
+            session.nativeControl !== 'MAR_MANAGED' ||
+            this.host.hasActiveSessionLease(session.id))
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const runId = crypto.randomUUID();
+        const client = this.runner.managedClient(environment);
+        this.host.adopt({
+            runId,
+            sessionId: session.id,
+            runner: 'opencode',
+            cwd: session.cwd,
+            externalSessionId: session.externalSessionId
+        });
+        this.host.active.add(runId);
+        this.runner.execution.set(runId, {
+            runId,
+            sessionId: session.id,
+            nativeSessionId: session.externalSessionId,
+            cwd: session.cwd,
+            client,
+            abort: new AbortController(),
+            access: session.access ?? 'default',
+            agent: 'build'
+        });
+        this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
+        void this.runCompact(runId, session.model);
+        return {
+            command: 'compact',
+            run: this.host.run(runId),
+            states: this.host.commandStates(session.id)
+        };
+    }
+    async runCompact(runId, model) {
+        const execution = this.runner.execution.get(runId);
+        if (execution === undefined)
+            return;
+        this.host.emit(runId, 'run.running', { command: 'compact' }, 'RUNNING');
+        try {
+            await execution.client.summarize(execution.cwd, execution.nativeSessionId, model);
+            this.finish(runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
+        }
+        catch (error) {
+            this.finish(runId, 'FAILED', 'run.failed', error, 'OPENCODE_COMPACT_FAILED');
+        }
+    }
     start(envelope) {
         const payload = envelope.payload;
         if (payload.runner !== 'opencode' ||
@@ -57,7 +104,14 @@ export class OpenCodeManagedRunController {
             attachments = this.host.parseAttachments(payload.attachments);
         }
         catch (error) {
-            this.host.emit(payload.runId, 'run.rejected', { code: safeErrorCode(error, 'RUNNER_INPUT_INVALID') }, 'FAILED');
+            const projected = runnerErrorProjection(error, 'RUNNER_INPUT_INVALID');
+            this.host.emitItem(payload.runId, {
+                itemId: boundedConversationItemId('runner-error', payload.runId),
+                kind: 'error',
+                status: 'FAILED',
+                payload: { ...projected, recoverable: true, retryAfterMs: null }
+            });
+            this.host.emit(payload.runId, 'run.rejected', projected, 'FAILED');
             return;
         }
         void this.run({
@@ -181,9 +235,7 @@ export class OpenCodeManagedRunController {
                     rejectReady(error);
                     return;
                 }
-                this.finish(input.runId, 'FAILED', 'run.failed', {
-                    code: safeErrorCode(error, 'OPENCODE_EVENT_FAILED')
-                });
+                this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_EVENT_FAILED');
             });
             await subscriptionReady;
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
@@ -206,9 +258,7 @@ export class OpenCodeManagedRunController {
                 this.finish(input.runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
         }
         catch (error) {
-            this.finish(input.runId, 'FAILED', 'run.failed', {
-                code: safeErrorCode(error, 'OPENCODE_RUN_START_FAILED')
-            });
+            this.finish(input.runId, 'FAILED', 'run.failed', error, 'OPENCODE_RUN_START_FAILED');
         }
     }
     event(runId, nativeSessionId, value) {
@@ -231,7 +281,7 @@ export class OpenCodeManagedRunController {
             return;
         }
         if (event?.type === 'session.error') {
-            this.finish(runId, 'FAILED', 'run.failed', { code: 'OPENCODE_SESSION_ERROR' });
+            this.finish(runId, 'FAILED', 'run.failed', properties?.error ?? properties);
             return;
         }
         if (event?.type === 'message.part.updated') {
@@ -309,7 +359,7 @@ export class OpenCodeManagedRunController {
         if (execution === undefined || requestId === undefined)
             return;
         const questions = openCodeQuestions(rawQuestions);
-        if (questions.length === 0 || questions.length > 4 || this.questions.has(requestId))
+        if (questions.length === 0 || this.questions.has(requestId))
             return;
         const timer = setTimeout(() => {
             const pending = this.questions.get(requestId);
@@ -340,7 +390,7 @@ export class OpenCodeManagedRunController {
             payload: { requestId, questions }
         });
     }
-    finish(runId, status, eventType, payload) {
+    finish(runId, status, eventType, payload, fallbackCode = 'OPENCODE_RUN_FAILED') {
         const execution = this.runner.execution.get(runId);
         const cwd = execution?.cwd ?? this.startingCwds.get(runId);
         const client = execution?.client ?? this.startingClients.get(runId);
@@ -363,11 +413,19 @@ export class OpenCodeManagedRunController {
                 clearTimeout(pending.timer);
                 this.questions.delete(id);
             }
+        if (status === 'FAILED') {
+            const projected = runnerErrorProjection(payload, fallbackCode);
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('runner-error', runId),
+                kind: 'error',
+                status: 'FAILED',
+                payload: { ...projected, recoverable: true, retryAfterMs: null }
+            });
+            payload = projected;
+        }
         this.host.emit(runId, eventType, payload, status);
         if (client !== undefined)
             this.runner.releaseManagedClient(client);
-        if (cwd !== undefined)
-            void this.host.captureSnapshot(runId, cwd);
     }
 }
 function openCodeImageInput(input, attachmentPaths) {

package/dist/runner/opencode-runner.d.ts

@@ -19,6 +19,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     readonly discoveryScope: "WORKSPACE_REQUIRED";
     private readonly modelsByWorkspace;
     private readonly contextLimitsByWorkspace;
+    private readonly profileTimersByWorkspace;
     readonly execution: Map<string, OpenCodeManagedExecution>;
     readonly managedTurns: Map<string, string>;
     private readonly environmentClients;
@@ -56,6 +57,8 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         maxTokens: number;
     } | undefined>;
     stop(): Promise<void>;
+    private scheduleProfileExpiry;
+    private clearProfileTimer;
     managedClient(environment: Readonly<Record<string, string>>, isolationKey?: string): OpenCodeServerClient;
     releaseManagedClient(client: OpenCodeServerClient): void;
 }

package/dist/runner/opencode-runner.js

@@ -5,6 +5,7 @@ import { AbstractRunner } from './abstract-runner.js';
 import { isWithinWorkspace } from './codex/conversation-parser.js';
 import { createHash } from 'node:crypto';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
+const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
 export class OpenCodeRunner extends AbstractRunner {
     client;
     clientFactory;
@@ -12,6 +13,7 @@ export class OpenCodeRunner extends AbstractRunner {
     discoveryScope = 'WORKSPACE_REQUIRED';
     modelsByWorkspace = new Map();
     contextLimitsByWorkspace = new Map();
+    profileTimersByWorkspace = new Map();
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -39,11 +41,13 @@ export class OpenCodeRunner extends AbstractRunner {
             const models = openCodeProfileModels(catalog);
             this.modelsByWorkspace.set(workspace.path, models);
             this.contextLimitsByWorkspace.set(workspace.path, openCodeContextLimits(catalog));
+            this.scheduleProfileExpiry(workspace.path);
             return { ...this.profile(capabilities), models };
         }
         catch {
             this.modelsByWorkspace.delete(workspace.path);
             this.contextLimitsByWorkspace.delete(workspace.path);
+            this.clearProfileTimer(workspace.path);
         }
         finally {
             this.releaseManagedClient(client);
@@ -279,6 +283,11 @@ export class OpenCodeRunner extends AbstractRunner {
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
+        for (const timer of this.profileTimersByWorkspace.values())
+            clearTimeout(timer);
+        this.profileTimersByWorkspace.clear();
+        this.modelsByWorkspace.clear();
+        this.contextLimitsByWorkspace.clear();
         const stopping = [
             this.client.stop(),
             ...[...this.environmentClients.values()].map(({ client }) => client.stop()),
@@ -288,6 +297,22 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
+    scheduleProfileExpiry(workspacePath) {
+        this.clearProfileTimer(workspacePath);
+        const timer = setTimeout(() => {
+            this.profileTimersByWorkspace.delete(workspacePath);
+            this.modelsByWorkspace.delete(workspacePath);
+            this.contextLimitsByWorkspace.delete(workspacePath);
+        }, PROFILE_ENTRY_TTL_MS);
+        timer.unref();
+        this.profileTimersByWorkspace.set(workspacePath, timer);
+    }
+    clearProfileTimer(workspacePath) {
+        const timer = this.profileTimersByWorkspace.get(workspacePath);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.profileTimersByWorkspace.delete(workspacePath);
+    }
     managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         if (entries.length === 0 && isolationKey === undefined)

package/dist/runner-profiles.js

@@ -1,3 +1,7 @@
+const COMMON_COMMAND_DESCRIPTIONS = {
+    compact: 'Compact the current session context.',
+    plan: 'Toggle collaborative Plan Mode.'
+};
 const CLAUDE_MODEL_ENVIRONMENT = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
@@ -35,7 +39,7 @@ const definitions = {
             {
                 id: 'compact',
                 label: '/compact',
-                description: 'Compact the current session context.',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 interaction: 'IMMEDIATE_ACTION'
             },
@@ -43,7 +47,7 @@ const definitions = {
                 id: 'plan',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: 'Toggle collaborative Plan Mode.',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 interaction: 'TOGGLE'
             },
@@ -96,7 +100,7 @@ const definitions = {
                 id: 'compact',
                 runner: 'claude-code',
                 label: '/compact',
-                description: 'Compact context through the Claude Agent SDK.',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'IMMEDIATE_ACTION',
@@ -108,7 +112,7 @@ const definitions = {
                 runner: 'claude-code',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: 'Toggle read-only tagged Plan Mode.',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'TOGGLE',
@@ -137,7 +141,7 @@ const definitions = {
                 id: 'compact',
                 runner: 'opencode',
                 label: '/compact',
-                description: 'Compact context through OpenCode.',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 source: 'OPENCODE_SERVER',
                 interaction: 'IMMEDIATE_ACTION',
@@ -149,7 +153,7 @@ const definitions = {
                 runner: 'opencode',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: 'Toggle the native OpenCode Plan Agent.',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 source: 'OPENCODE_SERVER',
                 interaction: 'TOGGLE',

package/dist/runtime-state.d.ts

@@ -1,5 +1,5 @@
 import type { AgentRunStatus, RunnerName } from '@myagentroam/protocol';
-import type { ConversationItemPage, ConversationPage, NativeSessionControl, NodeAgentRun, NodeAgentSession, NodeApproval, NodeConversationTurn, NodeMessageAttachmentInput, NodeRunEvent, NodeWorkspace, WorkspaceActivityPage } from './database.js';
+import type { ConversationItemPage, ConversationPage, NativeSessionControl, NodeAgentRun, NodeAgentSession, NodeApproval, NodeConversationTurn, NodeMessageAttachmentInput, NodeRunEvent, NodeWorkspace } from './database.js';
 /**
  * Deliberately process-local runtime domain.  No method in this class writes
  * into Node SQLite: a Node restart loses active runs, approvals, leases and
@@ -10,22 +10,22 @@ export declare class NodeRuntimeState {
     private readonly nodeId;
     private readonly getWorkspace;
     private readonly now;
+    private static readonly MAX_COMPLETED_TURNS_PER_SESSION;
     private readonly sessions;
     private readonly runs;
     private readonly messageRuns;
     private readonly events;
     private readonly turns;
     private readonly approvals;
-    private readonly workspaceEvents;
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     private readonly leases;
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     private readonly queuedRuns;
     private readonly queueVersions;
     private readonly pausedQueues;
-    private readonly snapshots;
+    /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
+    private readonly terminalRunIds;
     private nextEventId;
-    private nextWorkspaceEventId;
     constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number);
     activeWorkspaceLeaseCount(): number;
     activeSessionRun(sessionId: string): NodeAgentRun | undefined;
@@ -86,9 +86,11 @@ export declare class NodeRuntimeState {
      */
     setRunnerTitleFromNative(id: string, title: string): NodeAgentSession;
     createMessageRun(input: {
+        readonly runId?: string;
         readonly sessionId: string;
         readonly clientMessageId: string;
         readonly content: string;
+        readonly initiatedByUserId?: number;
         readonly attachments?: readonly NodeMessageAttachmentInput[];
     }): {
         readonly run: NodeAgentRun;
@@ -138,11 +140,6 @@ export declare class NodeRuntimeState {
         readonly outputPreview: string;
         readonly failed?: boolean;
     }): NodeConversationTurn;
-    listWorkspaceActivity(input: {
-        readonly workspaceId: string;
-        readonly cursor?: string;
-        readonly limit?: number;
-    }): WorkspaceActivityPage;
     createApproval(input: {
         readonly runId: string;
         readonly approvalId: string;
@@ -156,8 +153,7 @@ export declare class NodeRuntimeState {
     expireDueApprovals(): readonly NodeApproval[];
     listNonterminalRuns(): readonly NodeAgentRun[];
     lastRunSequence(id: string): number;
-    saveSnapshot(id: string, value: unknown): void;
-    getSnapshot(id: string): unknown | undefined;
+    removeTerminalRun(runId: string): void;
     hasActiveWorkspaceLease(workspaceId: string): boolean;
     /** Removes a terminal Session's process-local projection after its native history is deleted. */
     removeAgentSession(sessionId: string): void;
@@ -168,7 +164,6 @@ export declare class NodeRuntimeState {
     private requireSession;
     private requireRun;
     private requireApproval;
-    private recordWorkspaceActivity;
     private updateTurnForRun;
     private projectEvent;
 }