@sanqianx/claude-ai-workbench 0.13.2 → 0.13.4

package/packages/server/lib/capture-settings-store.js

@@ -1,35 +1,35 @@
-'use strict';
-
-const path = require('path');
-const { readJson, writeJson } = require('./json-file');
-
-const SCHEMA = 'capture-settings/v1';
-
-// Terminal capture scope. When terminalConversations is true, new Agent
-// Terminal SDK sessions stop flagging themselves as internal-runtime-only and
-// their hooks reach the Bridge journal (Development Conversation / 会话浏览).
-// Default false: the terminal is the system talking to itself, not the
-// developer's CLI conversation record.
-class CaptureSettingsStore {
-  constructor(options = {}) {
-    if (!options.dataDir) throw new Error('CaptureSettingsStore dataDir is required');
-    this.settingsFile = options.settingsFile || path.join(options.dataDir, 'capture-settings.v1.json');
-    this.defaultConversations = options.defaultConversations === true;
-  }
-
-  read() {
-    const cfg = readJson(this.settingsFile, { schema: SCHEMA, terminalConversations: this.defaultConversations });
-    return { schema: SCHEMA, terminalConversations: cfg.terminalConversations === true };
-  }
-
-  save(input = {}) {
-    if (typeof input.terminalConversations !== 'boolean') {
-      throw Object.assign(new Error('terminalConversations must be a boolean'), { status: 400 });
-    }
-    const cfg = { schema: SCHEMA, terminalConversations: input.terminalConversations, updatedAt: new Date().toISOString() };
-    writeJson(this.settingsFile, cfg);
-    return cfg;
-  }
-}
-
-module.exports = { CaptureSettingsStore, SCHEMA };
+'use strict';
+
+const path = require('path');
+const { readJson, writeJson } = require('./json-file');
+
+const SCHEMA = 'capture-settings/v1';
+
+// Terminal capture scope. When terminalConversations is true, new Agent
+// Terminal SDK sessions stop flagging themselves as internal-runtime-only and
+// their hooks reach the Bridge journal (Development Conversation / 会话浏览).
+// Default false: the terminal is the system talking to itself, not the
+// developer's CLI conversation record.
+class CaptureSettingsStore {
+  constructor(options = {}) {
+    if (!options.dataDir) throw new Error('CaptureSettingsStore dataDir is required');
+    this.settingsFile = options.settingsFile || path.join(options.dataDir, 'capture-settings.v1.json');
+    this.defaultConversations = options.defaultConversations === true;
+  }
+
+  read() {
+    const cfg = readJson(this.settingsFile, { schema: SCHEMA, terminalConversations: this.defaultConversations });
+    return { schema: SCHEMA, terminalConversations: cfg.terminalConversations === true };
+  }
+
+  save(input = {}) {
+    if (typeof input.terminalConversations !== 'boolean') {
+      throw Object.assign(new Error('terminalConversations must be a boolean'), { status: 400 });
+    }
+    const cfg = { schema: SCHEMA, terminalConversations: input.terminalConversations, updatedAt: new Date().toISOString() };
+    writeJson(this.settingsFile, cfg);
+    return cfg;
+  }
+}
+
+module.exports = { CaptureSettingsStore, SCHEMA };

package/packages/server/lib/claude-history-recovery.js

@@ -1,87 +1,87 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-
-// Recovery reads the owning CLI's transcript only. It never resumes a model,
-// edits a native transcript, or treats captured tool calls as executable work.
-function recoverClaudeHistory(session, { claudeHome = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude') } = {}) {
-  const id = session.claudeSessionId;
-  if (!/^[a-f0-9-]{36}$/i.test(id || '') || !path.isAbsolute(session.projectPath || '')) return null;
-  const project = session.projectPath.replace(/[^a-zA-Z0-9]/g, '-');
-  const root = path.resolve(claudeHome, 'projects');
-  const directory = path.join(root, project);
-  const file = path.join(directory, `${id}.jsonl`);
-  try {
-    const stat = fs.lstatSync(file);
-    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 128 * 1024 * 1024) return null;
-    const realRoot = fs.realpathSync(root), realFile = fs.realpathSync(file);
-    if (!realFile.startsWith(realRoot + path.sep)) return null;
-    const rows = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line));
-    const owned = rows.filter(row => row.sessionId === id && row.isSidechain !== true);
-    const byId = new Map(owned.filter(row => row.uuid).map(row => [row.uuid, row]));
-    const latest = owned.findLast(row => ['user', 'assistant'].includes(row.type));
-    if (!latest) return null;
-    const lineage = new Set(), chain = [];
-    let current = latest;
-    while (current?.uuid && !lineage.has(current.uuid)) {
-      lineage.add(current.uuid);
-      chain.push(current);
-      const parent = current.parentUuid || (current.subtype === 'compact_boundary' ? current.logicalParentUuid : null);
-      if (parent && !byId.has(parent)) return null;
-      current = byId.get(parent);
-    }
-    if (current?.uuid && lineage.has(current.uuid)) return null;
-    // Preserve bridge/system nodes in the parent chain, but render only the
-    // selected branch's user and assistant messages, not abandoned retries.
-    const messages = chain.reverse().filter(row => ['user', 'assistant'].includes(row.type)
-      && row.isMeta !== true && row.isCompactSummary !== true);
-    const events = [], seen = new Set();
-    let hasTurn = false, finalText = '', finalAt = '', finalModel = '';
-    const finish = () => {
-      if (!hasTurn) return;
-      events.push({ type: 'claude/result', result: finalText, at: finalAt, model: finalModel, recovered: true });
-      hasTurn = false; finalText = '';
-    };
-    for (const row of messages) {
-      if (row.uuid && seen.has(row.uuid)) continue;
-      if (row.uuid) seen.add(row.uuid);
-      const content = typeof row.message?.content === 'string'
-        ? [{ type: 'text', text: row.message.content }] : row.message?.content;
-      if (!Array.isArray(content)) continue;
-      if (row.type === 'user') {
-        const text = content.filter(block => block.type === 'text').map(block => block.text || '').join('\n');
-        const attachments = content.filter(block => block.type === 'image' && block.source?.type === 'base64'
-          && ['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(block.source.media_type))
-          .map(block => ({ mediaType: block.source.media_type, name: '原始图片', url: `data:${block.source.media_type};base64,${block.source.data}` }));
-        if (text || attachments.length) {
-          finish(); hasTurn = true;
-          events.push({ type: 'claude/user-prompt', id: row.uuid, text, attachments, at: row.timestamp, recovered: true });
-        }
-        for (const block of content.filter(block => block.type === 'tool_result')) {
-          const output = typeof block.content === 'string' ? block.content : (block.content || []).filter(item => item.type === 'text').map(item => item.text || '').join('\n');
-          events.push({ type: 'claude/tool-result', id: block.tool_use_id, output, isError: block.is_error === true, at: row.timestamp, recovered: true });
-        }
-        continue;
-      }
-      if (!hasTurn) continue;
-      for (const [index, block] of content.entries()) {
-        const blockId = `${row.uuid || row.message.id}-${index}`;
-        const meta = { id: blockId, at: row.timestamp, recovered: true };
-        if (block.type === 'text') {
-          events.push({ type: 'claude/text-start', ...meta }, { type: 'claude/text-delta', text: block.text || '', ...meta });
-          finalText = block.text || ''; finalAt = row.timestamp; finalModel = row.message.model;
-        } else if (block.type === 'thinking') {
-          events.push({ type: 'claude/thinking-start', ...meta }, { type: 'claude/thinking-delta', text: block.thinking || '', ...meta });
-        } else if (block.type === 'tool_use') {
-          events.push({ type: 'claude/tool-use', id: block.id, name: block.name, input: block.input || {}, at: row.timestamp, recovered: true });
-        }
-      }
-    }
-    finish();
-    return events.some(event => event.type === 'claude/user-prompt') ? events : null;
-  } catch { return null; }
-}
-
-module.exports = { recoverClaudeHistory };
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+// Recovery reads the owning CLI's transcript only. It never resumes a model,
+// edits a native transcript, or treats captured tool calls as executable work.
+function recoverClaudeHistory(session, { claudeHome = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude') } = {}) {
+  const id = session.claudeSessionId;
+  if (!/^[a-f0-9-]{36}$/i.test(id || '') || !path.isAbsolute(session.projectPath || '')) return null;
+  const project = session.projectPath.replace(/[^a-zA-Z0-9]/g, '-');
+  const root = path.resolve(claudeHome, 'projects');
+  const directory = path.join(root, project);
+  const file = path.join(directory, `${id}.jsonl`);
+  try {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 128 * 1024 * 1024) return null;
+    const realRoot = fs.realpathSync(root), realFile = fs.realpathSync(file);
+    if (!realFile.startsWith(realRoot + path.sep)) return null;
+    const rows = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line));
+    const owned = rows.filter(row => row.sessionId === id && row.isSidechain !== true);
+    const byId = new Map(owned.filter(row => row.uuid).map(row => [row.uuid, row]));
+    const latest = owned.findLast(row => ['user', 'assistant'].includes(row.type));
+    if (!latest) return null;
+    const lineage = new Set(), chain = [];
+    let current = latest;
+    while (current?.uuid && !lineage.has(current.uuid)) {
+      lineage.add(current.uuid);
+      chain.push(current);
+      const parent = current.parentUuid || (current.subtype === 'compact_boundary' ? current.logicalParentUuid : null);
+      if (parent && !byId.has(parent)) return null;
+      current = byId.get(parent);
+    }
+    if (current?.uuid && lineage.has(current.uuid)) return null;
+    // Preserve bridge/system nodes in the parent chain, but render only the
+    // selected branch's user and assistant messages, not abandoned retries.
+    const messages = chain.reverse().filter(row => ['user', 'assistant'].includes(row.type)
+      && row.isMeta !== true && row.isCompactSummary !== true);
+    const events = [], seen = new Set();
+    let hasTurn = false, finalText = '', finalAt = '', finalModel = '';
+    const finish = () => {
+      if (!hasTurn) return;
+      events.push({ type: 'claude/result', result: finalText, at: finalAt, model: finalModel, recovered: true });
+      hasTurn = false; finalText = '';
+    };
+    for (const row of messages) {
+      if (row.uuid && seen.has(row.uuid)) continue;
+      if (row.uuid) seen.add(row.uuid);
+      const content = typeof row.message?.content === 'string'
+        ? [{ type: 'text', text: row.message.content }] : row.message?.content;
+      if (!Array.isArray(content)) continue;
+      if (row.type === 'user') {
+        const text = content.filter(block => block.type === 'text').map(block => block.text || '').join('\n');
+        const attachments = content.filter(block => block.type === 'image' && block.source?.type === 'base64'
+          && ['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(block.source.media_type))
+          .map(block => ({ mediaType: block.source.media_type, name: '原始图片', url: `data:${block.source.media_type};base64,${block.source.data}` }));
+        if (text || attachments.length) {
+          finish(); hasTurn = true;
+          events.push({ type: 'claude/user-prompt', id: row.uuid, text, attachments, at: row.timestamp, recovered: true });
+        }
+        for (const block of content.filter(block => block.type === 'tool_result')) {
+          const output = typeof block.content === 'string' ? block.content : (block.content || []).filter(item => item.type === 'text').map(item => item.text || '').join('\n');
+          events.push({ type: 'claude/tool-result', id: block.tool_use_id, output, isError: block.is_error === true, at: row.timestamp, recovered: true });
+        }
+        continue;
+      }
+      if (!hasTurn) continue;
+      for (const [index, block] of content.entries()) {
+        const blockId = `${row.uuid || row.message.id}-${index}`;
+        const meta = { id: blockId, at: row.timestamp, recovered: true };
+        if (block.type === 'text') {
+          events.push({ type: 'claude/text-start', ...meta }, { type: 'claude/text-delta', text: block.text || '', ...meta });
+          finalText = block.text || ''; finalAt = row.timestamp; finalModel = row.message.model;
+        } else if (block.type === 'thinking') {
+          events.push({ type: 'claude/thinking-start', ...meta }, { type: 'claude/thinking-delta', text: block.thinking || '', ...meta });
+        } else if (block.type === 'tool_use') {
+          events.push({ type: 'claude/tool-use', id: block.id, name: block.name, input: block.input || {}, at: row.timestamp, recovered: true });
+        }
+      }
+    }
+    finish();
+    return events.some(event => event.type === 'claude/user-prompt') ? events : null;
+  } catch { return null; }
+}
+
+module.exports = { recoverClaudeHistory };

package/packages/server/lib/cli-session-recovery.js

@@ -1,28 +1,28 @@
-'use strict';
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const SCHEMAS = new Set(['cli-json-runner-session/v1', 'codex-appserver-session/v1', 'opencode-serve-session/v1', 'zcode-appserver-session/v1']);
-
-function recoverOwnedCliSessions({ dataDir, projects, sourceDir = path.join(os.homedir(), '.agent-terminal/cli-sessions') }) {
-  const targetDir = path.join(dataDir, 'cli-sessions');
-  if (path.resolve(sourceDir) === path.resolve(targetDir) || !fs.existsSync(sourceDir)) return;
-  const owners = new Map(projects.list().map(project => [project.id, path.resolve(project.rootPath)]));
-  // Earlier v5 wiring put CLI records in the standalone directory. Preserve
-  // only records whose project ID AND code directory belong to this product.
-  for (const name of fs.readdirSync(sourceDir)) {
-    if (!/^[\w.-]+\.json$/.test(name)) continue;
-    const source = path.join(sourceDir, name); const target = path.join(targetDir, name);
-    let record;
-    try {
-      const stat = fs.lstatSync(source);
-      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 8 * 1024 * 1024 || fs.existsSync(target)) continue;
-      record = JSON.parse(fs.readFileSync(source, 'utf8'));
-    } catch { continue; }
-    if (!SCHEMAS.has(record.schema) || !owners.has(record.projectSlug) || typeof record.projectPath !== 'string' || path.resolve(record.projectPath) !== owners.get(record.projectSlug) || `${record.sessionId}.json` !== name) continue;
-    fs.mkdirSync(targetDir, { recursive: true });
-    try { fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL); }
-    catch (error) { if (error.code !== 'EEXIST') throw error; }
-  }
-}
-module.exports = { recoverOwnedCliSessions };
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const SCHEMAS = new Set(['cli-json-runner-session/v1', 'codex-appserver-session/v1', 'opencode-serve-session/v1', 'zcode-appserver-session/v1']);
+
+function recoverOwnedCliSessions({ dataDir, projects, sourceDir = path.join(os.homedir(), '.agent-terminal/cli-sessions') }) {
+  const targetDir = path.join(dataDir, 'cli-sessions');
+  if (path.resolve(sourceDir) === path.resolve(targetDir) || !fs.existsSync(sourceDir)) return;
+  const owners = new Map(projects.list().map(project => [project.id, path.resolve(project.rootPath)]));
+  // Earlier v5 wiring put CLI records in the standalone directory. Preserve
+  // only records whose project ID AND code directory belong to this product.
+  for (const name of fs.readdirSync(sourceDir)) {
+    if (!/^[\w.-]+\.json$/.test(name)) continue;
+    const source = path.join(sourceDir, name); const target = path.join(targetDir, name);
+    let record;
+    try {
+      const stat = fs.lstatSync(source);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 8 * 1024 * 1024 || fs.existsSync(target)) continue;
+      record = JSON.parse(fs.readFileSync(source, 'utf8'));
+    } catch { continue; }
+    if (!SCHEMAS.has(record.schema) || !owners.has(record.projectSlug) || typeof record.projectPath !== 'string' || path.resolve(record.projectPath) !== owners.get(record.projectSlug) || `${record.sessionId}.json` !== name) continue;
+    fs.mkdirSync(targetDir, { recursive: true });
+    try { fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL); }
+    catch (error) { if (error.code !== 'EEXIST') throw error; }
+  }
+}
+module.exports = { recoverOwnedCliSessions };

package/packages/server/lib/context-resolver.js

@@ -1,55 +1,55 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { normalizeContext } = require('../../contracts');
-
-class ContextResolver {
-  constructor(options = {}) {
-    this.createMissing = options.createMissing === true;
-    this.workspaces = new Map();
-    for (const [ref, target] of Object.entries(options.workspaces || {})) this.register(ref, target);
-  }
-
-  register(ref, target) {
-    if (!ref || !target) throw new Error('workspace ref and target are required');
-    if (path.isAbsolute(String(ref))) throw new Error('workspaceRef must be an opaque server reference');
-    this.workspaces.set(String(ref), path.resolve(String(target)));
-  }
-
-  unregister(ref) { return this.workspaces.delete(String(ref)); }
-
-  resolve(input) {
-    const context = normalizeContext(input);
-    if (!context.workspaceRef) throw Object.assign(new Error('workspaceRef is required'), { status: 400 });
-    if (path.isAbsolute(context.workspaceRef) || /[\\/]/.test(context.workspaceRef)) {
-      throw Object.assign(new Error('absolute or path-like workspaceRef is not trusted'), { status: 403 });
-    }
-    const workspacePath = this.workspaces.get(context.workspaceRef);
-    if (!workspacePath) throw Object.assign(new Error(`workspaceRef is not allowed: ${context.workspaceRef}`), { status: 403 });
-    if (!fs.existsSync(workspacePath)) {
-      if (!this.createMissing) throw Object.assign(new Error('workspace does not exist'), { status: 404 });
-      fs.mkdirSync(workspacePath, { recursive: true });
-    }
-    const real = fs.realpathSync(workspacePath);
-    if (!fs.statSync(real).isDirectory()) throw Object.assign(new Error('workspace is not a directory'), { status: 400 });
-    return { context, workspacePath: real };
-  }
-
-  // Unique-match lookup for legacy sessions recorded before workspaceRef was
-  // persisted: a real path only maps back to a workspace when exactly one
-  // registered ref resolves to it. Zero or multiple matches are the caller's
-  // explicit ambiguity, never a silent pick of the current UI project.
-  findByRealPath(realPath) {
-    const matches = [];
-    if (typeof realPath !== 'string' || !realPath) return matches;
-    for (const [ref, target] of this.workspaces) {
-      try {
-        if (fs.existsSync(target) && fs.realpathSync(target) === realPath) matches.push(ref);
-      } catch { /* unresolvable registration cannot match */ }
-    }
-    return matches;
-  }
-}
-
-module.exports = { ContextResolver };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { normalizeContext } = require('../../contracts');
+
+class ContextResolver {
+  constructor(options = {}) {
+    this.createMissing = options.createMissing === true;
+    this.workspaces = new Map();
+    for (const [ref, target] of Object.entries(options.workspaces || {})) this.register(ref, target);
+  }
+
+  register(ref, target) {
+    if (!ref || !target) throw new Error('workspace ref and target are required');
+    if (path.isAbsolute(String(ref))) throw new Error('workspaceRef must be an opaque server reference');
+    this.workspaces.set(String(ref), path.resolve(String(target)));
+  }
+
+  unregister(ref) { return this.workspaces.delete(String(ref)); }
+
+  resolve(input) {
+    const context = normalizeContext(input);
+    if (!context.workspaceRef) throw Object.assign(new Error('workspaceRef is required'), { status: 400 });
+    if (path.isAbsolute(context.workspaceRef) || /[\\/]/.test(context.workspaceRef)) {
+      throw Object.assign(new Error('absolute or path-like workspaceRef is not trusted'), { status: 403 });
+    }
+    const workspacePath = this.workspaces.get(context.workspaceRef);
+    if (!workspacePath) throw Object.assign(new Error(`workspaceRef is not allowed: ${context.workspaceRef}`), { status: 403 });
+    if (!fs.existsSync(workspacePath)) {
+      if (!this.createMissing) throw Object.assign(new Error('workspace does not exist'), { status: 404 });
+      fs.mkdirSync(workspacePath, { recursive: true });
+    }
+    const real = fs.realpathSync(workspacePath);
+    if (!fs.statSync(real).isDirectory()) throw Object.assign(new Error('workspace is not a directory'), { status: 400 });
+    return { context, workspacePath: real };
+  }
+
+  // Unique-match lookup for legacy sessions recorded before workspaceRef was
+  // persisted: a real path only maps back to a workspace when exactly one
+  // registered ref resolves to it. Zero or multiple matches are the caller's
+  // explicit ambiguity, never a silent pick of the current UI project.
+  findByRealPath(realPath) {
+    const matches = [];
+    if (typeof realPath !== 'string' || !realPath) return matches;
+    for (const [ref, target] of this.workspaces) {
+      try {
+        if (fs.existsSync(target) && fs.realpathSync(target) === realPath) matches.push(ref);
+      } catch { /* unresolvable registration cannot match */ }
+    }
+    return matches;
+  }
+}
+
+module.exports = { ContextResolver };

package/packages/server/lib/conversation-capture.js

@@ -1,51 +1,51 @@
-'use strict';
-const fs = require('node:fs');
-const { writeJson } = require('./json-file');
-const SCHEMA = 'workbench-capture-outbox/v1';
-
-class ConversationCapture {
-  constructor({ file, bridgeUrl, token, fetchImpl = fetch, retryMs = 2000 }) {
-    this.file = file; this.token = token; this.fetch = fetchImpl; this.queue = []; this.pending = null; this.error = null; this.closed = false;
-    const url = new URL('/api/internal/workbench-event', bridgeUrl);
-    if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || url.protocol !== 'http:' || !token) throw new Error('Trusted local bridge configuration required');
-    this.url = url.href;
-    try {
-      const record = JSON.parse(fs.readFileSync(file, 'utf8'));
-      if (record.schema !== SCHEMA || !Array.isArray(record.events)) throw new Error('Capture outbox schema mismatch');
-      this.queue = record.events;
-    } catch (error) { if (error.code !== 'ENOENT') this.error = 'CAPTURE_OUTBOX_DAMAGED'; }
-    this.timer = setInterval(() => this.flush().catch(() => {}), retryMs); this.timer.unref();
-    this.flush().catch(() => {});
-  }
-  status() { return { pending: this.queue.length, error: this.error }; }
-  enqueue(turn, eventType, content, outcome) {
-    if (this.closed || this.error === 'CAPTURE_OUTBOX_DAMAGED') throw new Error(this.error || 'Capture closed');
-    if (content !== undefined && (typeof content !== 'string' || content.length > 200000)) throw new Error('CAPTURE_CONTENT_TOO_LARGE');
-    const origin = ['human', 'agent-delegation'].includes(turn.inputOrigin) ? turn.inputOrigin : 'unknown';
-    const event = { ...turn, eventType, ...(content === undefined ? {} : { content }), ...(outcome ? { outcome } : {}), capturedAt: new Date().toISOString(), eventKey: `workbench:${turn.source}:${turn.sessionId}:${turn.turnId}:${eventType}:origin=${origin}` };
-    const next = [...this.queue, event];
-    if (next.length > 1000 || Buffer.byteLength(JSON.stringify(next)) > 16 * 1024 * 1024) throw new Error('CAPTURE_OUTBOX_FULL');
-    writeJson(this.file, { schema: SCHEMA, events: next }); this.queue = next;
-    this.flush().catch(() => {});
-  }
-  flush() {
-    if (this.pending) return this.pending;
-    if (this.closed || this.error === 'CAPTURE_OUTBOX_DAMAGED') return Promise.resolve();
-    this.pending = (async () => {
-      while (!this.closed && this.queue.length) {
-        this.controller = new AbortController();
-        const timeout = setTimeout(() => this.controller?.abort(), 3000);
-        try {
-          const response = await this.fetch(this.url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.token}` }, body: JSON.stringify(this.queue[0]), signal: this.controller.signal });
-          if (!response.ok || (await response.json()).status !== 'captured') throw new Error('CAPTURE_BRIDGE_UNAVAILABLE');
-          const next = this.queue.slice(1);
-          writeJson(this.file, { schema: SCHEMA, events: next }); this.queue = next; this.error = null;
-        } catch { this.error = 'CAPTURE_BRIDGE_UNAVAILABLE'; break; }
-        finally { clearTimeout(timeout); this.controller = null; }
-      }
-    })().finally(() => { this.pending = null; });
-    return this.pending;
-  }
-  close() { this.closed = true; clearInterval(this.timer); this.controller?.abort(); }
-}
-module.exports = { ConversationCapture };
+'use strict';
+const fs = require('node:fs');
+const { writeJson } = require('./json-file');
+const SCHEMA = 'workbench-capture-outbox/v1';
+
+class ConversationCapture {
+  constructor({ file, bridgeUrl, token, fetchImpl = fetch, retryMs = 2000 }) {
+    this.file = file; this.token = token; this.fetch = fetchImpl; this.queue = []; this.pending = null; this.error = null; this.closed = false;
+    const url = new URL('/api/internal/workbench-event', bridgeUrl);
+    if (!['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || url.protocol !== 'http:' || !token) throw new Error('Trusted local bridge configuration required');
+    this.url = url.href;
+    try {
+      const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (record.schema !== SCHEMA || !Array.isArray(record.events)) throw new Error('Capture outbox schema mismatch');
+      this.queue = record.events;
+    } catch (error) { if (error.code !== 'ENOENT') this.error = 'CAPTURE_OUTBOX_DAMAGED'; }
+    this.timer = setInterval(() => this.flush().catch(() => {}), retryMs); this.timer.unref();
+    this.flush().catch(() => {});
+  }
+  status() { return { pending: this.queue.length, error: this.error }; }
+  enqueue(turn, eventType, content, outcome) {
+    if (this.closed || this.error === 'CAPTURE_OUTBOX_DAMAGED') throw new Error(this.error || 'Capture closed');
+    if (content !== undefined && (typeof content !== 'string' || content.length > 200000)) throw new Error('CAPTURE_CONTENT_TOO_LARGE');
+    const origin = ['human', 'agent-delegation'].includes(turn.inputOrigin) ? turn.inputOrigin : 'unknown';
+    const event = { ...turn, eventType, ...(content === undefined ? {} : { content }), ...(outcome ? { outcome } : {}), capturedAt: new Date().toISOString(), eventKey: `workbench:${turn.source}:${turn.sessionId}:${turn.turnId}:${eventType}:origin=${origin}` };
+    const next = [...this.queue, event];
+    if (next.length > 1000 || Buffer.byteLength(JSON.stringify(next)) > 16 * 1024 * 1024) throw new Error('CAPTURE_OUTBOX_FULL');
+    writeJson(this.file, { schema: SCHEMA, events: next }); this.queue = next;
+    this.flush().catch(() => {});
+  }
+  flush() {
+    if (this.pending) return this.pending;
+    if (this.closed || this.error === 'CAPTURE_OUTBOX_DAMAGED') return Promise.resolve();
+    this.pending = (async () => {
+      while (!this.closed && this.queue.length) {
+        this.controller = new AbortController();
+        const timeout = setTimeout(() => this.controller?.abort(), 3000);
+        try {
+          const response = await this.fetch(this.url, { method: 'POST', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.token}` }, body: JSON.stringify(this.queue[0]), signal: this.controller.signal });
+          if (!response.ok || (await response.json()).status !== 'captured') throw new Error('CAPTURE_BRIDGE_UNAVAILABLE');
+          const next = this.queue.slice(1);
+          writeJson(this.file, { schema: SCHEMA, events: next }); this.queue = next; this.error = null;
+        } catch { this.error = 'CAPTURE_BRIDGE_UNAVAILABLE'; break; }
+        finally { clearTimeout(timeout); this.controller = null; }
+      }
+    })().finally(() => { this.pending = null; });
+    return this.pending;
+  }
+  close() { this.closed = true; clearInterval(this.timer); this.controller?.abort(); }
+}
+module.exports = { ConversationCapture };