@myagentroam/node 0.9.0 → 0.9.3

package/dist/service/workbench-event-service.d.ts

@@ -1,21 +1,9 @@
-import type { NodeEnvelope, WorkbenchEvent, WorkbenchEventCategory } from '@myagentroam/protocol';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import { type NodeEnvelope, type WorkbenchEventCategory } from '@myagentroam/protocol';
 export declare class WorkbenchEventService {
     private readonly send;
     private readonly accepts;
-    private readonly buffer;
     private sequence;
-    private readonly history;
     constructor(send: (envelope: NodeEnvelope) => void, accepts: (category: WorkbenchEventCategory, payload: unknown) => boolean);
     emit(category: WorkbenchEventCategory, payload: unknown): void;
-    read(after: number): {
-        readonly events: readonly WorkbenchEvent[];
-        readonly latestSequence: number;
-        readonly resyncRequired: boolean;
-    };
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
     snapshotSequence(): number;
-    acknowledge(replyTo: string | undefined): boolean;
-    replay(): void;
-    get pendingCount(): number;
 }

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

@@ -1,10 +1,8 @@
-import { ReliableWorkbenchEventBuffer } from '../event-buffer.js';
+import { createEnvelope } from '@myagentroam/protocol';
 export class WorkbenchEventService {
     send;
     accepts;
-    buffer = new ReliableWorkbenchEventBuffer();
     sequence = 0;
-    history = [];
     constructor(send, accepts) {
         this.send = send;
         this.accepts = accepts;
@@ -13,41 +11,9 @@ export class WorkbenchEventService {
         if (!this.accepts(category, payload))
             return;
         const event = { sequence: ++this.sequence, category, payload };
-        this.history.push(event);
-        if (this.history.length > 1_000)
-            this.history.shift();
-        this.send(this.buffer.queue(event));
-    }
-    read(after) {
-        const first = this.history[0]?.sequence;
-        const reset = after > this.sequence || (first !== undefined && after < first - 1);
-        return {
-            events: reset ? [] : this.history.filter((event) => event.sequence > after),
-            latestSequence: this.sequence,
-            resyncRequired: reset
-        };
-    }
-    operations() {
-        return {
-            'workbench.events.read': (data) => {
-                const afterValue = data?.after;
-                const after = typeof afterValue === 'number' && Number.isInteger(afterValue) && afterValue >= 0
-                    ? afterValue
-                    : 0;
-                return this.read(after);
-            }
-        };
+        this.send(createEnvelope('workbench.event', event));
     }
     snapshotSequence() {
         return this.sequence;
     }
-    acknowledge(replyTo) {
-        return this.buffer.acknowledge(replyTo);
-    }
-    replay() {
-        this.buffer.replay(this.send);
-    }
-    get pendingCount() {
-        return this.buffer.size;
-    }
 }

package/dist/service/workbench-manifest-service.d.ts

@@ -21,7 +21,6 @@ export declare class WorkbenchManifestService {
             reasonCode: null;
             itemVersions: number[];
             supportsSessionCursor: boolean;
-            supportsWorkspaceActivityCursor: boolean;
             supportsHistoryPaging: boolean;
             supportsItemFinalSnapshots: boolean;
             maxPageSize: number;

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

@@ -30,7 +30,6 @@ export class WorkbenchManifestService {
                 reasonCode: null,
                 itemVersions: [1],
                 supportsSessionCursor: true,
-                supportsWorkspaceActivityCursor: true,
                 supportsHistoryPaging: true,
                 supportsItemFinalSnapshots: true,
                 maxPageSize: 500

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

@@ -42,6 +42,7 @@ export interface CompletedComposerAttachment {
     readonly name: string;
     readonly mime: string;
     readonly size: number;
+    readonly timer: NodeJS.Timeout;
 }
 export declare class WorkspaceDomainState {
     readonly uploads: Map<string, ActiveWorkspaceUpload>;

package/dist/service/workspace-git-exclude-service.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureWorkspaceGitExclude(workspace: string): Promise<void>;
+export declare function updateWorkspaceSkillGitExclude(workspace: string, name: string, add: boolean): Promise<void>;
+export declare function rewriteWorkspaceGitExclude(workspace: string, names: ReadonlySet<string>): Promise<void>;
+export declare function hasBrokenWorkspaceSkillGitExclude(workspace: string, names: readonly string[]): Promise<boolean>;

package/dist/service/workspace-git-exclude-service.js

@@ -0,0 +1,119 @@
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const MAR_TEMP_DIRECTORY = '/.mar/';
+const BLOCK_BEGIN = '# BEGIN MyAgentRoam';
+const BLOCK_END = '# END MyAgentRoam';
+const LEGACY_BLOCK_BEGIN = '# BEGIN MyAgentRoam Skills';
+const LEGACY_BLOCK_END = '# END MyAgentRoam Skills';
+export async function ensureWorkspaceGitExclude(workspace) {
+    await mutateGitExclude(workspace, (entries) => entries.add(MAR_TEMP_DIRECTORY));
+}
+export async function updateWorkspaceSkillGitExclude(workspace, name, add) {
+    await mutateGitExclude(workspace, (entries) => {
+        entries.add(MAR_TEMP_DIRECTORY);
+        for (const root of ['.agents', '.claude']) {
+            const line = `/${root}/skills/${name}/`;
+            if (add)
+                entries.add(line);
+            else
+                entries.delete(line);
+        }
+    });
+}
+export async function rewriteWorkspaceGitExclude(workspace, names) {
+    await mutateGitExclude(workspace, (entries) => {
+        entries.clear();
+        entries.add(MAR_TEMP_DIRECTORY);
+        for (const name of names)
+            for (const root of ['.agents', '.claude'])
+                entries.add(`/${root}/skills/${name}/`);
+    });
+}
+export async function hasBrokenWorkspaceSkillGitExclude(workspace, names) {
+    if (!(await exists(path.join(workspace, '.git'))))
+        return false;
+    try {
+        const exclude = await resolveGitExclude(workspace);
+        const content = await readFile(exclude, 'utf8');
+        return names
+            .flatMap((name) => [`/.agents/skills/${name}/`, `/.claude/skills/${name}/`])
+            .some((entry) => !content.includes(entry));
+    }
+    catch {
+        return true;
+    }
+}
+async function mutateGitExclude(workspace, mutate) {
+    if (!(await exists(path.join(workspace, '.git'))))
+        return;
+    const exclude = await resolveGitExclude(workspace);
+    await mkdir(path.dirname(exclude), { recursive: true });
+    let content = '';
+    try {
+        const excludeStat = await lstat(exclude);
+        if (!excludeStat.isFile() || excludeStat.isSymbolicLink())
+            throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
+        content = await readFile(exclude, 'utf8');
+    }
+    catch (error) {
+        if (!isMissing(error))
+            throw error;
+    }
+    const pattern = managedBlockPattern();
+    const existing = [...content.matchAll(pattern)].map((match) => match[0]).join('\n');
+    const entries = new Set(existing.split(/\r?\n/u).filter((line) => line.startsWith('/.')));
+    mutate(entries);
+    const block = `${BLOCK_BEGIN}\n${[...entries].sort().join('\n')}\n${BLOCK_END}\n`;
+    const next = content.replace(pattern, '').replace(/\s*$/u, '\n') + block;
+    const staging = path.join(path.dirname(exclude), `.mar-git-exclude-${randomUUID()}.tmp`);
+    try {
+        await writeFile(staging, next, { encoding: 'utf8', flag: 'wx' });
+        await rename(staging, exclude);
+    }
+    catch (error) {
+        await rm(staging, { force: true });
+        throw error;
+    }
+}
+async function resolveGitExclude(workspace) {
+    try {
+        const result = await promisify(execFile)('git', ['-C', workspace, 'rev-parse', '--git-path', 'info/exclude', '--git-common-dir'], { timeout: 5_000, windowsHide: true });
+        const [excludeOutput, commonOutput] = result.stdout.trim().split(/\r?\n/u);
+        if (!excludeOutput || !commonOutput)
+            throw new Error();
+        const exclude = path.resolve(workspace, excludeOutput);
+        const common = path.resolve(workspace, commonOutput);
+        const relative = path.relative(common, exclude);
+        if (relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error();
+        return exclude;
+    }
+    catch {
+        throw new Error('WORKSPACE_SKILL_GIT_EXCLUDE_FAILED');
+    }
+}
+async function exists(value) {
+    try {
+        await lstat(value);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+}
+function isMissing(error) {
+    return (error instanceof Error && 'code' in error && error.code === 'ENOENT');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+function managedBlockPattern() {
+    const current = `${escapeRegExp(BLOCK_BEGIN)}\\r?\\n[\\s\\S]*?${escapeRegExp(BLOCK_END)}(?:\\r?\\n)?`;
+    const legacy = `${escapeRegExp(LEGACY_BLOCK_BEGIN)}\\r?\\n[\\s\\S]*?${escapeRegExp(LEGACY_BLOCK_END)}(?:\\r?\\n)?`;
+    return new RegExp(`(?:${current}|${legacy})`, 'gu');
+}

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -23,6 +23,7 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly emit: (workspaceId: string, sessionId: string) => void;
     readonly clearImages: (runId: string) => void;
+    readonly cleanupAttachments: (runId: string) => void;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED') => void;
     readonly emitConversation: (turn: unknown) => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;

package/dist/service/workspace-queue-workbench-service.js

@@ -1,6 +1,7 @@
 import { isPlainRecord } from '../runner/codex/conversation-parser.js';
 import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
 import { withNonImageAttachmentPrompt } from '../runner/codex/conversation-parser.js';
+import { safeErrorCode } from '../util/safe-error.js';
 export class WorkspaceQueueWorkbenchService {
     options;
     starts = new Map();
@@ -79,6 +80,7 @@ export class WorkspaceQueueWorkbenchService {
         this.options.runtime.deleteQueuedRun(run.id);
         this.remove(run.id);
         this.options.clearImages(run.id);
+        this.options.cleanupAttachments(run.id);
         this.options.emit(run.workspaceId, run.sessionId);
         return { queue: this.present(run.workspaceId, run.sessionId) };
     }
@@ -183,7 +185,7 @@ export class WorkspaceQueueWorkbenchService {
             });
         }
         catch (error) {
-            this.options.emitRun(run.id, 'run.rejected', { code: error instanceof Error ? error.message : 'QUEUE_START_FAILED' }, 'FAILED');
+            this.options.emitRun(run.id, 'run.rejected', { code: safeErrorCode(error, 'QUEUE_START_FAILED') }, 'FAILED');
         }
     }
     present(workspaceId, sessionId) {
@@ -203,7 +205,7 @@ export class WorkspaceQueueWorkbenchService {
                     {
                         run,
                         sessionId: run.sessionId,
-                        sessionTitle: queuedSession?.customTitle ?? queuedSession?.runnerTitle ?? '未命名会话',
+                        sessionTitle: queuedSession?.customTitle ?? queuedSession?.runnerTitle ?? 'Untitled session',
                         content: this.options.runtime.queuedMessageText(run.id)
                     }
                 ];

package/dist/service/workspace-service.js

@@ -1,5 +1,6 @@
 import { rmdir } from 'node:fs/promises';
 import { createWorkspaceDirectory, inspectWorkspace, listWorkspaceDirectories } from '../workspace.js';
+import { ensureWorkspaceGitExclude } from './workspace-git-exclude-service.js';
 export class WorkspaceService {
     database;
     config;
@@ -31,6 +32,7 @@ export class WorkspaceService {
                 ? (createdPath = await createWorkspaceDirectory(input.path, input.createDirectoryName, this.config().allowedRoots))
                 : input.path;
             const inspected = await inspectWorkspace(path, this.config().allowedRoots);
+            await ensureWorkspaceGitExclude(inspected.path);
             return {
                 workspace: this.database().saveWorkspace({
                     path: inspected.path,

package/dist/service/workspace-upload-service.d.ts

@@ -23,9 +23,11 @@ export declare class WorkspaceUploadService {
     complete(uploadId: unknown): Promise<UploadStatus>;
     cancel(uploadId: unknown): Promise<void>;
     resolve(workspaceId: string, ids: readonly string[]): Promise<readonly ResolvedComposerAttachment[]>;
+    consume(ids: readonly string[]): Promise<void>;
     shutdown(): Promise<void>;
     private require;
     private remove;
+    private removeCompleted;
     private attachmentTarget;
 }
 interface UploadStatus {

package/dist/service/workspace-upload-service.js

@@ -133,16 +133,25 @@ export class WorkspaceUploadService {
         clearTimeout(upload.timer);
         this.state.uploads.delete(upload.id);
         this.onCompleted(upload.workspaceId);
-        if (upload.composerAttachment !== undefined)
-            this.state.composerAttachments.set(upload.composerAttachment.id, {
+        if (upload.composerAttachment !== undefined) {
+            const attachmentId = upload.composerAttachment.id;
+            const timer = setTimeout(() => {
+                const attachment = this.state.composerAttachments.get(attachmentId);
+                if (attachment !== undefined)
+                    void this.removeCompleted(attachment);
+            }, TTL_MS);
+            timer.unref();
+            this.state.composerAttachments.set(attachmentId, {
                 id: upload.composerAttachment.id,
                 workspaceId: upload.workspaceId,
                 path: upload.path,
                 targetPath: upload.targetPath,
                 name: upload.composerAttachment.name,
                 mime: upload.composerAttachment.mime,
-                size: upload.size
+                size: upload.size,
+                timer
             });
+        }
         return {
             uploadId: upload.id,
             path: upload.path,
@@ -159,8 +168,7 @@ export class WorkspaceUploadService {
         const attachment = this.state.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
-        this.state.composerAttachments.delete(uploadId);
-        await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+        await this.removeCompleted(attachment);
     }
     async resolve(workspaceId, ids) {
         return Promise.all(ids.map(async (id) => {
@@ -184,10 +192,17 @@ export class WorkspaceUploadService {
             };
         }));
     }
+    async consume(ids) {
+        await Promise.all(ids.map(async (id) => {
+            const attachment = this.state.composerAttachments.get(id);
+            if (attachment !== undefined)
+                await this.removeCompleted(attachment);
+        }));
+    }
     async shutdown() {
         await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
         for (const attachment of this.state.composerAttachments.values())
-            await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+            await this.removeCompleted(attachment);
         this.state.composerAttachments.clear();
     }
     require(id) {
@@ -206,6 +221,13 @@ export class WorkspaceUploadService {
         if (upload.composerAttachment !== undefined)
             await rm(dirname(upload.targetPath), { recursive: true, force: true }).catch(() => undefined);
     }
+    async removeCompleted(attachment) {
+        if (this.state.composerAttachments.get(attachment.id) !== attachment)
+            return;
+        this.state.composerAttachments.delete(attachment.id);
+        clearTimeout(attachment.timer);
+        await rm(dirname(attachment.targetPath), { recursive: true, force: true }).catch(() => undefined);
+    }
     async attachmentTarget(workspacePath, id, name) {
         const mar = resolve(workspacePath, '.mar');
         await mkdir(mar, { recursive: true, mode: 0o700 });

package/dist/service/workspace-workbench-service.d.ts

@@ -1,13 +1,11 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeWorkspace } from '../database.js';
-import { NodeRuntimeState } from '../runtime-state.js';
 import { WorkspaceChangeService } from './workspace-change-service.js';
 import { WorkspaceFileService } from './workspace-file-service.js';
 import { WorkspaceUploadService } from './workspace-upload-service.js';
 import { WorkspaceWatchService } from './workspace-watch-service.js';
 export interface WorkspaceWorkbenchServiceOptions {
     readonly requireWorkspace: (workspaceId: unknown) => NodeWorkspace;
-    readonly runtime: NodeRuntimeState;
     readonly watch: WorkspaceWatchService;
     readonly files: WorkspaceFileService;
     readonly uploads: WorkspaceUploadService;
@@ -20,7 +18,6 @@ export declare class WorkspaceWorkbenchService {
     private readonly contentSearch;
     constructor(options: WorkspaceWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private activity;
     private watch;
     private unwatch;
     private listFiles;

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

@@ -9,7 +9,6 @@ export class WorkspaceWorkbenchService {
     }
     operations() {
         return {
-            'workspace.activity.read': (data) => this.activity(record(data)),
             'workspace.watch': (data) => this.watch(record(data)),
             'workspace.unwatch': (data) => this.unwatch(record(data)),
             'workspace.files.list': (data) => this.listFiles(record(data)),
@@ -35,20 +34,6 @@ export class WorkspaceWorkbenchService {
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
-    activity(input) {
-        if (typeof input.workspaceId !== 'string' ||
-            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
-            (input.limit !== undefined &&
-                (!Number.isInteger(input.limit) ||
-                    input.limit < 1 ||
-                    input.limit > 500)))
-            throw new Error('EVENT_CURSOR_INVALID');
-        return this.options.runtime.listWorkspaceActivity({
-            workspaceId: input.workspaceId,
-            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
-            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
-        });
-    }
     async watch(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.watchId !== 'string' ||
@@ -143,8 +128,6 @@ export class WorkspaceWorkbenchService {
             (input.state !== 'STAGED' && input.state !== 'UNSTAGED' && input.state !== 'UNTRACKED'))
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
         const workspace = this.gitWorkspace(input.workspaceId);
-        if (this.options.runtime.hasActiveWorkspaceLease(workspace.id))
-            throw new Error('WORKSPACE_BUSY');
         const repository = await resolveGitRepository(workspace.path, input.repositoryPath ?? '');
         await restoreCurrentChange(repository, input.path, input.state);
         this.options.invalidate(workspace.id);

package/dist/supervisor.js

@@ -4,6 +4,7 @@ import { dirname, resolve } from 'node:path';
 import { loadNodeConfig, nodeDatabasePath } from './config.js';
 import { nodeLog, platformCliInvocation } from './operational.js';
 import { nodeUpgradeRequestPath } from './service/node-upgrade-coordinator.js';
+import { safeErrorCode } from './util/safe-error.js';
 const UPGRADE_EXIT_CODE = 75;
 const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
 export async function superviseNode(configPath, bootstrapEntrypoint) {
@@ -73,7 +74,7 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
         catch (error) {
             await writeResult(dataDirectory, {
                 state: 'FAILED',
-                errorCode: error instanceof Error ? error.message : 'NODE_UPGRADE_INSTALL_FAILED',
+                errorCode: safeErrorCode(error, 'NODE_UPGRADE_INSTALL_FAILED'),
                 updatedAt: Date.now()
             });
             await rm(requestPath, { force: true });

package/dist/terminal.js

@@ -384,7 +384,7 @@ function defaultTerminalProfiles(platform) {
     return [
         {
             id: 'default',
-            label: '用户 Shell',
+            label: 'User Shell',
             shell: process.env['SHELL']?.trim() || '/bin/bash',
             args: ['-l', '-i'],
             isDefault: true

package/dist/util/node-operation-parsers.js

@@ -2,7 +2,7 @@ import { nodeCapabilitiesSchema } from '@myagentroam/protocol';
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const USER_AUTHORIZATION_CLOCK_SKEW_MS = 5_000;
-const NON_IMAGE_ATTACHMENT_PROMPT_PREFIX = '\n\n本轮非图片附件已上传到工作区，请按需读取以下文件：\n';
+const NON_IMAGE_ATTACHMENT_PROMPT_PREFIX = '\n\nNon-image attachments for this turn were uploaded to the Workspace. Read these files as needed:\n';
 const COMPOSER_IMAGE_MIME_TYPES = new Set([
     'image/png',
     'image/jpeg',
@@ -100,7 +100,7 @@ export function compactRunnerValue(value, limit) {
             text = JSON.stringify(value);
         }
         catch {
-            return { text: '（无法显示）', truncated: false };
+            return { text: '(Unable to display)', truncated: false };
         }
     }
     return { text: compactRunnerText(text, limit), truncated: text.length > limit };

package/dist/util/runner-error.d.ts

@@ -0,0 +1,6 @@
+export interface RunnerErrorProjection {
+    readonly code: string;
+    readonly message: string;
+    readonly httpStatus: number | null;
+}
+export declare function runnerErrorProjection(error: unknown, fallbackCode: string): RunnerErrorProjection;

package/dist/util/runner-error.js

@@ -0,0 +1,52 @@
+const MAX_RUNNER_ERROR_MESSAGE = 1000;
+export function runnerErrorProjection(error, fallbackCode) {
+    const httpStatus = findHttpStatus(error);
+    const message = findMessage(error) ?? fallbackCode;
+    return {
+        code: httpStatus === null ? fallbackCode : `HTTP_${httpStatus}`,
+        message: message.slice(0, MAX_RUNNER_ERROR_MESSAGE),
+        httpStatus
+    };
+}
+function findHttpStatus(value, depth = 0) {
+    if (depth > 3 || value === null || typeof value !== 'object')
+        return null;
+    const record = value;
+    for (const key of ['status', 'statusCode', 'status_code', 'httpStatus', 'http_status']) {
+        const candidate = record[key];
+        if (((typeof candidate === 'number' && Number.isInteger(candidate)) ||
+            (typeof candidate === 'string' && /^\d{3}$/u.test(candidate))) &&
+            Number(candidate) >= 100 &&
+            Number(candidate) <= 599)
+            return Number(candidate);
+    }
+    const match = findMessage(value)?.match(/(?:^|\b(?:http(?:\s+status)?|status(?:\s+code)?|error)\s*[:=_-]?\s*)([1-5]\d{2})\b/iu);
+    if (match !== null && match !== undefined)
+        return Number(match[1]);
+    for (const key of ['error', 'cause', 'response', 'data']) {
+        const nested = findHttpStatus(record[key], depth + 1);
+        if (nested !== null)
+            return nested;
+    }
+    return null;
+}
+function findMessage(value, depth = 0) {
+    if (typeof value === 'string')
+        return value.trim() || undefined;
+    if (value instanceof Error && value.message.trim())
+        return value.message.trim();
+    if (depth > 3 || value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    for (const key of ['message', 'error_description', 'detail', 'result']) {
+        const candidate = record[key];
+        if (typeof candidate === 'string' && candidate.trim())
+            return candidate.trim();
+    }
+    for (const key of ['error', 'cause', 'response', 'data']) {
+        const nested = findMessage(record[key], depth + 1);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}

package/dist/util/runner-native-session-parsers.d.ts

@@ -25,7 +25,6 @@ export declare function extractCodexThreads(result: unknown): readonly {
     readonly title: string | undefined;
 }[];
 export declare function codexThreadActivity(result: unknown): SessionActivityState;
-export declare function externalResumeFailureDetail(error: unknown): string;
 export declare function codexActiveTurnId(result: unknown): string | undefined;
 export declare function codexThreadCwd(value: unknown): string;
 export declare function isWithinWorkspace(cwd: string, workspacePath: string): boolean;
@@ -46,8 +45,8 @@ export declare function nativeConversationPage(session: NodeAgentSession, histor
     readonly nextCursor: string | null;
 };
 /**
- * Claude JSONL 不保存浏览器请求 ID。Node 进程仍存活时，以正文和生成时刻
- * 对齐当前运行态的用户消息，让 native 历史页替换同一乐观 Turn，而不是重复一条。
+ * Claude JSONL does not retain browser request IDs. While the Node process is alive, match current
+ * runtime user messages by content and creation time so native history replaces the optimistic Turn.
  */
 export declare function nativeUserClientMessageId(entry: Extract<NativeSessionHistory['items'][number], {
     readonly kind: 'message';