@sanqianx/claude-ai-workbench 0.13.2 → 0.13.4

package/packages/server/lib/agent-discovery.js

@@ -1,133 +1,133 @@
-'use strict';
-
-const { spawn, spawnSync } = require('child_process');
-const { AGENTS, AGENT_IDS } = require('../../contracts');
-const { discoverZCodeCli } = require('./drivers/zcode-driver');
-
-const PROBE_TIMEOUT_MS = 5000;
-const CACHE_TTL_MS = 30000;
-
-// Probes locally installed agent CLIs. Results are cached briefly so
-// GET /agents stays cheap; a failed probe is a valid (negative) result.
-  function parseVersionToken(text) {
-    const trimmed = String(text || '').trim();
-    const match = trimmed.match(/(\d+\.\d+[\w.-]*)/);
-    return match ? match[1] : null;
-  }
-  // Spawns `<executable> --version` directly (no shell) and returns the first
-  // version-looking token, or null when the probe fails. This is the only
-  // version source: nothing here invents or hardcodes one.
-  function probeExecutable(cmd) {
-    try {
-      const script = /\.(?:[cm]?js)$/i.test(cmd);
-      const result = spawnSync(script ? process.execPath : cmd, script ? [cmd, '--version'] : ['--version'], {
-        timeout: PROBE_TIMEOUT_MS,
-        windowsHide: true,
-        encoding: 'utf8',
-      });
-      if (result.error || result.status !== 0) return { available: false, version: null, code: result.error?.code || 'CLI_PROBE_FAILED', reason: String(result.error?.message || result.stderr || result.stdout || `exit ${result.status}`).slice(0, 2000), exitCode: result.status };
-      const version = parseVersionToken(String(result.stdout || result.stderr || ''));
-      return { available: Boolean(version), version, reason: version ? '' : 'Claude Code 未返回版本号。' };
-    } catch {
-      return { available: false, version: null, code: 'CLI_PROBE_FAILED', reason: 'Claude Code 版本探测失败。' };
-    }
-  }
-function probeExecutableVersion(cmd) { return probeExecutable(cmd).version; }
-function runProbe(command, args, { signal, timeoutMs = PROBE_TIMEOUT_MS, shell = false } = {}) {
-  return new Promise(resolve => {
-    if (signal?.aborted) return resolve({ available: false, code: 'PROBE_TIMEOUT', reason: '探测超时，保留上次结果。' });
-    let child, output = '', errors = '', done = false;
-    const finish = result => { if (done) return; done = true; clearTimeout(timer); signal?.removeEventListener('abort', cancel); resolve(result); };
-    const cancel = () => {
-      if (child?.pid && child.exitCode === null && process.platform === 'win32' && shell) {
-        const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' }); killer.once('error', () => child.kill());
-      } else child?.kill();
-      finish({ available: false, code: 'PROBE_TIMEOUT', reason: '探测超时，保留上次结果。' });
-    };
-    const timer = setTimeout(cancel, timeoutMs);
-    signal?.addEventListener('abort', cancel, { once: true });
-    try {
-      child = spawn(command, args, { windowsHide: true, shell, stdio: ['ignore', 'pipe', 'pipe'] });
-      child.stdout.on('data', b => { output = (output + b).slice(-8192); });
-      child.stderr.on('data', b => { errors = (errors + b).slice(-8192); });
-      child.once('error', error => finish({ available: false, version: null, code: error.code || 'CLI_PROBE_FAILED', reason: String(error.message).slice(0, 2000) }));
-      child.once('close', code => {
-        const version = code === 0 ? parseVersionToken(output || errors) : null;
-        finish({ available: !!version, version, exitCode: code, code: code === 0 ? undefined : 'CLI_PROBE_FAILED', reason: version ? '' : (errors || output || `exit ${code}`).slice(0, 2000), stdout: output });
-      });
-    } catch (error) { finish({ available: false, code: error.code || 'CLI_PROBE_FAILED', reason: String(error.message).slice(0, 2000) }); }
-  });
-}
-async function probeExecutableAsync(command, options = {}) {
-  const script = /\.(?:[cm]?js)$/i.test(command);
-  return runProbe(script ? process.execPath : command, script ? [command, '--version'] : ['--version'], { ...options, shell: !script && process.platform === 'win32' && !require('path').isAbsolute(command) });
-}
-async function resolveClaudeAsync(driver, options = {}) {
-  if (typeof driver.findClaudeExecutableForSdkAsync === 'function') return driver.findClaudeExecutableForSdkAsync(options);
-  let found = driver.findClaudeExecutableForSdk({ pathHits: [] });
-  if (found?.cmd || typeof found === 'string' || process.platform !== 'win32') return found;
-  const where = require('path').join(process.env.WINDIR || 'C:/Windows', 'System32', 'where.exe');
-  const result = await runProbe(where, ['claude'], options);
-  return driver.findClaudeExecutableForSdk({ pathHits: (result.stdout || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean) });
-}
-async function resolveZCodeAsync({ signal, discover = discoverZCodeCli, probe = runProbe, platform = process.platform } = {}) {
-  const direct = discover({ regQuery: () => null });
-  if (direct || platform !== 'win32') return direct;
-  const entries = new Map();
-  for (const hive of ['HKCU', 'HKLM']) {
-    const key = `${hive}\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\ZCode.exe`;
-    entries.set(key, (await probe('reg', ['query', key], { signal })).stdout || '');
-  }
-  return discover({ regQuery: key => entries.get(key) });
-}
-function createAgentDiscovery(options = {}) {
-  const clock = options.now || Date.now;
-  const claudeProbe = options.claudeProbe || (() => ({ available: false, reason: 'Claude Code executable was not found' }));
-  let cache = Object.fromEntries(AGENT_IDS.map(id => [id, { ...AGENTS[id], available: false, version: null, scanState: 'unknown', reason: '尚未检查' }]));
-  let cacheAt = 0, pending = null, generation = 0, closed = false;
-  let scan = { state: 'idle', generation, updatedAt: null };
-  const active = new Set();
-
-  async function inspect(id, signal) {
-    if (options.probes?.[id]) return options.probes[id]({ signal });
-    if (id === 'claude-code') return claudeProbe({ signal });
-    if (id !== 'zcode') return probeExecutableAsync(id, { signal });
-    const cli = await resolveZCodeAsync({ signal });
-    if (!cli) return { available: false, reason: 'ZCode was not found on this machine' };
-    return probeExecutableAsync(cli.path, { signal });
-  }
-  function discover() {
-    if (!closed && clock() - cacheAt >= (options.cacheTtlMs ?? CACHE_TTL_MS)) void discover.refresh().catch(() => {});
-    return cache;
-  }
-  discover.snapshot = () => ({ ...scan });
-  discover.refresh = () => {
-    if (pending) return pending;
-    if (closed) return Promise.resolve(cache);
-    scan = { ...scan, state: 'scanning', generation: ++generation };
-    let cursor = 0;
-    const deadline = Date.now() + (options.scanBudgetMs ?? 12000);
-    const worker = async () => {
-      while (cursor < AGENT_IDS.length && !closed) {
-        const id = AGENT_IDS[cursor++], controller = new AbortController(); active.add(controller);
-        const budget = Math.max(0, Math.min(options.probeTimeoutMs ?? 5000, deadline - Date.now()));
-        let timer;
-        const timeout = new Promise(resolve => { const expire = () => resolve({ code: 'PROBE_TIMEOUT', reason: '检查超时，保留上次结果。' }); controller.signal.addEventListener('abort', expire, { once: true }); timer = setTimeout(() => controller.abort(), budget); });
-        let result;
-        try { result = await Promise.race([Promise.resolve().then(() => inspect(id, controller.signal)), timeout]); }
-        catch { result = { code: 'PROBE_FAILED', reason: '检查失败，保留上次结果。' }; }
-        finally { clearTimeout(timer); active.delete(controller); }
-        if (closed) return;
-        const uncertain = ['PROBE_TIMEOUT', 'ETIMEDOUT', 'PROBE_FAILED'].includes(result.code);
-        cache = { ...cache, [id]: { ...cache[id], ...(uncertain ? {} : { available: !!result.available, version: result.version || null }), reason: result.reason || '', scanState: uncertain ? 'error' : 'ready', checkedAt: new Date().toISOString(), errorCode: result.code || null } };
-      }
-    };
-    pending = Promise.all([worker(), worker()]).then(() => { cacheAt = clock(); scan = { state: 'ready', generation, updatedAt: new Date(cacheAt).toISOString() }; return cache; }).finally(() => { pending = null; });
-    return pending;
-  };
-  discover.invalidate = () => { cacheAt = 0; };
-  discover.close = () => { closed = true; for (const controller of active) controller.abort(); };
-  return discover;
-}
-
-module.exports = { createAgentDiscovery, probeExecutableVersion, probeExecutable, probeExecutableAsync, resolveClaudeAsync, resolveZCodeAsync, runProbe };
+'use strict';
+
+const { spawn, spawnSync } = require('child_process');
+const { AGENTS, AGENT_IDS } = require('../../contracts');
+const { discoverZCodeCli } = require('./drivers/zcode-driver');
+
+const PROBE_TIMEOUT_MS = 5000;
+const CACHE_TTL_MS = 30000;
+
+// Probes locally installed agent CLIs. Results are cached briefly so
+// GET /agents stays cheap; a failed probe is a valid (negative) result.
+  function parseVersionToken(text) {
+    const trimmed = String(text || '').trim();
+    const match = trimmed.match(/(\d+\.\d+[\w.-]*)/);
+    return match ? match[1] : null;
+  }
+  // Spawns `<executable> --version` directly (no shell) and returns the first
+  // version-looking token, or null when the probe fails. This is the only
+  // version source: nothing here invents or hardcodes one.
+  function probeExecutable(cmd) {
+    try {
+      const script = /\.(?:[cm]?js)$/i.test(cmd);
+      const result = spawnSync(script ? process.execPath : cmd, script ? [cmd, '--version'] : ['--version'], {
+        timeout: PROBE_TIMEOUT_MS,
+        windowsHide: true,
+        encoding: 'utf8',
+      });
+      if (result.error || result.status !== 0) return { available: false, version: null, code: result.error?.code || 'CLI_PROBE_FAILED', reason: String(result.error?.message || result.stderr || result.stdout || `exit ${result.status}`).slice(0, 2000), exitCode: result.status };
+      const version = parseVersionToken(String(result.stdout || result.stderr || ''));
+      return { available: Boolean(version), version, reason: version ? '' : 'Claude Code 未返回版本号。' };
+    } catch {
+      return { available: false, version: null, code: 'CLI_PROBE_FAILED', reason: 'Claude Code 版本探测失败。' };
+    }
+  }
+function probeExecutableVersion(cmd) { return probeExecutable(cmd).version; }
+function runProbe(command, args, { signal, timeoutMs = PROBE_TIMEOUT_MS, shell = false } = {}) {
+  return new Promise(resolve => {
+    if (signal?.aborted) return resolve({ available: false, code: 'PROBE_TIMEOUT', reason: '探测超时，保留上次结果。' });
+    let child, output = '', errors = '', done = false;
+    const finish = result => { if (done) return; done = true; clearTimeout(timer); signal?.removeEventListener('abort', cancel); resolve(result); };
+    const cancel = () => {
+      if (child?.pid && child.exitCode === null && process.platform === 'win32' && shell) {
+        const killer = spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' }); killer.once('error', () => child.kill());
+      } else child?.kill();
+      finish({ available: false, code: 'PROBE_TIMEOUT', reason: '探测超时，保留上次结果。' });
+    };
+    const timer = setTimeout(cancel, timeoutMs);
+    signal?.addEventListener('abort', cancel, { once: true });
+    try {
+      child = spawn(command, args, { windowsHide: true, shell, stdio: ['ignore', 'pipe', 'pipe'] });
+      child.stdout.on('data', b => { output = (output + b).slice(-8192); });
+      child.stderr.on('data', b => { errors = (errors + b).slice(-8192); });
+      child.once('error', error => finish({ available: false, version: null, code: error.code || 'CLI_PROBE_FAILED', reason: String(error.message).slice(0, 2000) }));
+      child.once('close', code => {
+        const version = code === 0 ? parseVersionToken(output || errors) : null;
+        finish({ available: !!version, version, exitCode: code, code: code === 0 ? undefined : 'CLI_PROBE_FAILED', reason: version ? '' : (errors || output || `exit ${code}`).slice(0, 2000), stdout: output });
+      });
+    } catch (error) { finish({ available: false, code: error.code || 'CLI_PROBE_FAILED', reason: String(error.message).slice(0, 2000) }); }
+  });
+}
+async function probeExecutableAsync(command, options = {}) {
+  const script = /\.(?:[cm]?js)$/i.test(command);
+  return runProbe(script ? process.execPath : command, script ? [command, '--version'] : ['--version'], { ...options, shell: !script && process.platform === 'win32' && !require('path').isAbsolute(command) });
+}
+async function resolveClaudeAsync(driver, options = {}) {
+  if (typeof driver.findClaudeExecutableForSdkAsync === 'function') return driver.findClaudeExecutableForSdkAsync(options);
+  let found = driver.findClaudeExecutableForSdk({ pathHits: [] });
+  if (found?.cmd || typeof found === 'string' || process.platform !== 'win32') return found;
+  const where = require('path').join(process.env.WINDIR || 'C:/Windows', 'System32', 'where.exe');
+  const result = await runProbe(where, ['claude'], options);
+  return driver.findClaudeExecutableForSdk({ pathHits: (result.stdout || '').split(/\r?\n/).map(s => s.trim()).filter(Boolean) });
+}
+async function resolveZCodeAsync({ signal, discover = discoverZCodeCli, probe = runProbe, platform = process.platform } = {}) {
+  const direct = discover({ regQuery: () => null });
+  if (direct || platform !== 'win32') return direct;
+  const entries = new Map();
+  for (const hive of ['HKCU', 'HKLM']) {
+    const key = `${hive}\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\ZCode.exe`;
+    entries.set(key, (await probe('reg', ['query', key], { signal })).stdout || '');
+  }
+  return discover({ regQuery: key => entries.get(key) });
+}
+function createAgentDiscovery(options = {}) {
+  const clock = options.now || Date.now;
+  const claudeProbe = options.claudeProbe || (() => ({ available: false, reason: 'Claude Code executable was not found' }));
+  let cache = Object.fromEntries(AGENT_IDS.map(id => [id, { ...AGENTS[id], available: false, version: null, scanState: 'unknown', reason: '尚未检查' }]));
+  let cacheAt = 0, pending = null, generation = 0, closed = false;
+  let scan = { state: 'idle', generation, updatedAt: null };
+  const active = new Set();
+
+  async function inspect(id, signal) {
+    if (options.probes?.[id]) return options.probes[id]({ signal });
+    if (id === 'claude-code') return claudeProbe({ signal });
+    if (id !== 'zcode') return probeExecutableAsync(id, { signal });
+    const cli = await resolveZCodeAsync({ signal });
+    if (!cli) return { available: false, reason: 'ZCode was not found on this machine' };
+    return probeExecutableAsync(cli.path, { signal });
+  }
+  function discover() {
+    if (!closed && clock() - cacheAt >= (options.cacheTtlMs ?? CACHE_TTL_MS)) void discover.refresh().catch(() => {});
+    return cache;
+  }
+  discover.snapshot = () => ({ ...scan });
+  discover.refresh = () => {
+    if (pending) return pending;
+    if (closed) return Promise.resolve(cache);
+    scan = { ...scan, state: 'scanning', generation: ++generation };
+    let cursor = 0;
+    const deadline = Date.now() + (options.scanBudgetMs ?? 12000);
+    const worker = async () => {
+      while (cursor < AGENT_IDS.length && !closed) {
+        const id = AGENT_IDS[cursor++], controller = new AbortController(); active.add(controller);
+        const budget = Math.max(0, Math.min(options.probeTimeoutMs ?? 5000, deadline - Date.now()));
+        let timer;
+        const timeout = new Promise(resolve => { const expire = () => resolve({ code: 'PROBE_TIMEOUT', reason: '检查超时，保留上次结果。' }); controller.signal.addEventListener('abort', expire, { once: true }); timer = setTimeout(() => controller.abort(), budget); });
+        let result;
+        try { result = await Promise.race([Promise.resolve().then(() => inspect(id, controller.signal)), timeout]); }
+        catch { result = { code: 'PROBE_FAILED', reason: '检查失败，保留上次结果。' }; }
+        finally { clearTimeout(timer); active.delete(controller); }
+        if (closed) return;
+        const uncertain = ['PROBE_TIMEOUT', 'ETIMEDOUT', 'PROBE_FAILED'].includes(result.code);
+        cache = { ...cache, [id]: { ...cache[id], ...(uncertain ? {} : { available: !!result.available, version: result.version || null }), reason: result.reason || '', scanState: uncertain ? 'error' : 'ready', checkedAt: new Date().toISOString(), errorCode: result.code || null } };
+      }
+    };
+    pending = Promise.all([worker(), worker()]).then(() => { cacheAt = clock(); scan = { state: 'ready', generation, updatedAt: new Date(cacheAt).toISOString() }; return cache; }).finally(() => { pending = null; });
+    return pending;
+  };
+  discover.invalidate = () => { cacheAt = 0; };
+  discover.close = () => { closed = true; for (const controller of active) controller.abort(); };
+  return discover;
+}
+
+module.exports = { createAgentDiscovery, probeExecutableVersion, probeExecutable, probeExecutableAsync, resolveClaudeAsync, resolveZCodeAsync, runProbe };

package/packages/server/lib/agent-registry.js

@@ -1,143 +1,143 @@
-'use strict';
-
-const { AGENT_IDS, normalizeAgentId } = require('../../contracts');
-
-// Routes every WorkbenchRunner call to the driver that owns the session.
-// The claude-code driver is whatever runner the host injected (legacy
-// claude-cli-runner in production, fake runners in tests); CLI drivers plug
-// in beside it with the same interface.
-class AgentRegistry {
-  constructor(options = {}) {
-    this.drivers = new Map();
-    this.sessionAgents = new Map();
-    for (const [agentId, driver] of Object.entries(options.drivers || {})) {
-      this.register(agentId, driver);
-    }
-  }
-
-  register(agentId, driver) {
-    const id = normalizeAgentId(agentId);
-    if (!driver) throw new Error(`driver for ${id} is required`);
-    this.drivers.set(id, driver);
-    return driver;
-  }
-
-  driverFor(agentId) {
-    const id = normalizeAgentId(agentId);
-    const driver = this.drivers.get(id);
-    if (!driver) {
-      throw Object.assign(new Error(`agent "${id}" has no registered driver`), { status: 501 });
-    }
-    return driver;
-  }
-
-  agentOf(sessionId) {
-    return this.sessionAgents.get(sessionId) || 'claude-code';
-  }
-
-  _route(sessionId) {
-    try {
-      return this.driverFor(this.agentOf(sessionId));
-    } catch {
-      throw Object.assign(new Error('session not found'), { status: 404 });
-    }
-  }
-
-  asRunner() {
-    const registry = this;
-    return {
-      async destroy() {
-        await Promise.all([...registry.drivers.values()].map(driver => typeof driver.destroy === 'function' ? driver.destroy() : undefined));
-      },
-      startChatSession(args = {}) {
-        // Reserved delegated identity reaches sessions only through the
-        // trusted startDelegatedSession route below — never through ordinary
-        // user-driven session creation, whatever the caller forwarded.
-        if (args.reservedSessionId !== undefined || args.delegation !== undefined) {
-          throw Object.assign(new Error('reserved delegated identity is not accepted on the ordinary session path'), {
-            status: 400, code: 'DELEGATION_IDENTITY_FORBIDDEN',
-          });
-        }
-        const agentId = normalizeAgentId(args.agentId);
-        const driver = registry.driverFor(agentId);
-        const started = driver.startChatSession({ ...args, agentId });
-        registry.sessionAgents.set(started.sessionId, agentId);
-        return started;
-      },
-      // Trusted reserved-identity factory route. A driver that cannot honor a
-      // server-reserved childSessionId fails explicitly here — it must never
-      // fall back to minting its own random child.
-      startDelegatedSession(args = {}) {
-        const agentId = normalizeAgentId(args.agentId);
-        const driver = registry.driverFor(agentId);
-        if (typeof driver.startDelegatedSession !== 'function') {
-          throw Object.assign(new Error(`agent "${agentId}" cannot run delegated sessions with a server-reserved identity`), {
-            status: 501, code: 'DELEGATION_AGENT_UNSUPPORTED',
-          });
-        }
-        const started = driver.startDelegatedSession({ ...args, agentId });
-        registry.sessionAgents.set(started.sessionId, agentId);
-        return started;
-      },
-      // Capability probe that creates nothing: validates the command BEFORE
-      // the ledger reserves an identity for an agent that could never run it.
-      supportsDelegatedSessions(agentId) {
-        const id = normalizeAgentId(agentId);
-        const driver = registry.drivers.get(id);
-        return Boolean(driver && typeof driver.startDelegatedSession === 'function');
-      },
-      listSessions(filter = {}) {
-        const all = [];
-        for (const id of AGENT_IDS) {
-          const driver = registry.drivers.get(id);
-          if (!driver) continue;
-          for (const session of driver.listSessions(filter)) {
-            registry.sessionAgents.set(session.sessionId, id);
-            all.push({ ...session, agentId: registry.agentOf(session.sessionId) });
-          }
-        }
-        return all;
-      },
-      getState(id) { return registry._route(id).getState(id); },
-      getSession(id) { return registry._route(id).getSession(id); },
-      getSessionTokenUsage(id) { return registry._route(id).getSessionTokenUsage(id); },
-      subscribe(id, listener) { return registry._route(id).subscribe(id, listener); },
-      sendInput(id, text, profile, options) { return registry._route(id).sendInput(id, text, profile, options); },
-      updateSelection(id, profile, selectedModel) {
-        const driver = registry._route(id);
-        if (typeof driver.updateSelection === 'function') return driver.updateSelection(id, profile, selectedModel);
-        // Bare runners without the method still get rebound so the service
-        // fallback and the proxy stay interchangeable.
-        const session = driver.getSession && driver.getSession(id);
-        if (!session) throw Object.assign(new Error('session not found'), { status: 404 });
-        session.aiProfileId = profile && profile.id || null;
-        session.selectedModel = selectedModel || null;
-        return session;
-      },
-      resolvePermission(id, requestId, decision) { return registry._route(id).resolvePermission(id, requestId, decision); },
-      abort(id, reason) { return registry._route(id).abort(id, reason); },
-      deleteSession(id) { return registry._route(id).deleteSession(id); },
-      attachNativeTaskRuntime(id, identity) {
-        // Native-task scope binding is claude-code-only today; CLI drivers
-        // answer with an explicit unavailable result instead of throwing.
-        const driver = registry._route(id);
-        if (typeof driver.attachNativeTaskRuntime !== 'function') return { attached: false, reason: 'runner-without-native-tasks' };
-        return driver.attachNativeTaskRuntime(id, identity);
-      },
-      detachNativeTaskRuntime(id, identity) {
-        const driver = registry._route(id);
-        if (typeof driver.detachNativeTaskRuntime !== 'function') return { detached: false, reason: 'runner-without-native-tasks' };
-        return driver.detachNativeTaskRuntime(id, identity);
-      },
-      listSupportedCommands(id, profile) { return registry._route(id).listSupportedCommands(id, profile); },
-      findClaudeExecutableForSdk() {
-        const driver = registry.drivers.get('claude-code');
-        return driver && typeof driver.findClaudeExecutableForSdk === 'function'
-          ? driver.findClaudeExecutableForSdk()
-          : null;
-      },
-    };
-  }
-}
-
-module.exports = { AgentRegistry };
+'use strict';
+
+const { AGENT_IDS, normalizeAgentId } = require('../../contracts');
+
+// Routes every WorkbenchRunner call to the driver that owns the session.
+// The claude-code driver is whatever runner the host injected (legacy
+// claude-cli-runner in production, fake runners in tests); CLI drivers plug
+// in beside it with the same interface.
+class AgentRegistry {
+  constructor(options = {}) {
+    this.drivers = new Map();
+    this.sessionAgents = new Map();
+    for (const [agentId, driver] of Object.entries(options.drivers || {})) {
+      this.register(agentId, driver);
+    }
+  }
+
+  register(agentId, driver) {
+    const id = normalizeAgentId(agentId);
+    if (!driver) throw new Error(`driver for ${id} is required`);
+    this.drivers.set(id, driver);
+    return driver;
+  }
+
+  driverFor(agentId) {
+    const id = normalizeAgentId(agentId);
+    const driver = this.drivers.get(id);
+    if (!driver) {
+      throw Object.assign(new Error(`agent "${id}" has no registered driver`), { status: 501 });
+    }
+    return driver;
+  }
+
+  agentOf(sessionId) {
+    return this.sessionAgents.get(sessionId) || 'claude-code';
+  }
+
+  _route(sessionId) {
+    try {
+      return this.driverFor(this.agentOf(sessionId));
+    } catch {
+      throw Object.assign(new Error('session not found'), { status: 404 });
+    }
+  }
+
+  asRunner() {
+    const registry = this;
+    return {
+      async destroy() {
+        await Promise.all([...registry.drivers.values()].map(driver => typeof driver.destroy === 'function' ? driver.destroy() : undefined));
+      },
+      startChatSession(args = {}) {
+        // Reserved delegated identity reaches sessions only through the
+        // trusted startDelegatedSession route below — never through ordinary
+        // user-driven session creation, whatever the caller forwarded.
+        if (args.reservedSessionId !== undefined || args.delegation !== undefined) {
+          throw Object.assign(new Error('reserved delegated identity is not accepted on the ordinary session path'), {
+            status: 400, code: 'DELEGATION_IDENTITY_FORBIDDEN',
+          });
+        }
+        const agentId = normalizeAgentId(args.agentId);
+        const driver = registry.driverFor(agentId);
+        const started = driver.startChatSession({ ...args, agentId });
+        registry.sessionAgents.set(started.sessionId, agentId);
+        return started;
+      },
+      // Trusted reserved-identity factory route. A driver that cannot honor a
+      // server-reserved childSessionId fails explicitly here — it must never
+      // fall back to minting its own random child.
+      startDelegatedSession(args = {}) {
+        const agentId = normalizeAgentId(args.agentId);
+        const driver = registry.driverFor(agentId);
+        if (typeof driver.startDelegatedSession !== 'function') {
+          throw Object.assign(new Error(`agent "${agentId}" cannot run delegated sessions with a server-reserved identity`), {
+            status: 501, code: 'DELEGATION_AGENT_UNSUPPORTED',
+          });
+        }
+        const started = driver.startDelegatedSession({ ...args, agentId });
+        registry.sessionAgents.set(started.sessionId, agentId);
+        return started;
+      },
+      // Capability probe that creates nothing: validates the command BEFORE
+      // the ledger reserves an identity for an agent that could never run it.
+      supportsDelegatedSessions(agentId) {
+        const id = normalizeAgentId(agentId);
+        const driver = registry.drivers.get(id);
+        return Boolean(driver && typeof driver.startDelegatedSession === 'function');
+      },
+      listSessions(filter = {}) {
+        const all = [];
+        for (const id of AGENT_IDS) {
+          const driver = registry.drivers.get(id);
+          if (!driver) continue;
+          for (const session of driver.listSessions(filter)) {
+            registry.sessionAgents.set(session.sessionId, id);
+            all.push({ ...session, agentId: registry.agentOf(session.sessionId) });
+          }
+        }
+        return all;
+      },
+      getState(id) { return registry._route(id).getState(id); },
+      getSession(id) { return registry._route(id).getSession(id); },
+      getSessionTokenUsage(id) { return registry._route(id).getSessionTokenUsage(id); },
+      subscribe(id, listener) { return registry._route(id).subscribe(id, listener); },
+      sendInput(id, text, profile, options) { return registry._route(id).sendInput(id, text, profile, options); },
+      updateSelection(id, profile, selectedModel) {
+        const driver = registry._route(id);
+        if (typeof driver.updateSelection === 'function') return driver.updateSelection(id, profile, selectedModel);
+        // Bare runners without the method still get rebound so the service
+        // fallback and the proxy stay interchangeable.
+        const session = driver.getSession && driver.getSession(id);
+        if (!session) throw Object.assign(new Error('session not found'), { status: 404 });
+        session.aiProfileId = profile && profile.id || null;
+        session.selectedModel = selectedModel || null;
+        return session;
+      },
+      resolvePermission(id, requestId, decision) { return registry._route(id).resolvePermission(id, requestId, decision); },
+      abort(id, reason) { return registry._route(id).abort(id, reason); },
+      deleteSession(id) { return registry._route(id).deleteSession(id); },
+      attachNativeTaskRuntime(id, identity) {
+        // Native-task scope binding is claude-code-only today; CLI drivers
+        // answer with an explicit unavailable result instead of throwing.
+        const driver = registry._route(id);
+        if (typeof driver.attachNativeTaskRuntime !== 'function') return { attached: false, reason: 'runner-without-native-tasks' };
+        return driver.attachNativeTaskRuntime(id, identity);
+      },
+      detachNativeTaskRuntime(id, identity) {
+        const driver = registry._route(id);
+        if (typeof driver.detachNativeTaskRuntime !== 'function') return { detached: false, reason: 'runner-without-native-tasks' };
+        return driver.detachNativeTaskRuntime(id, identity);
+      },
+      listSupportedCommands(id, profile) { return registry._route(id).listSupportedCommands(id, profile); },
+      findClaudeExecutableForSdk() {
+        const driver = registry.drivers.get('claude-code');
+        return driver && typeof driver.findClaudeExecutableForSdk === 'function'
+          ? driver.findClaudeExecutableForSdk()
+          : null;
+      },
+    };
+  }
+}
+
+module.exports = { AgentRegistry };

package/packages/server/lib/agent-spawn-env.js

@@ -1,17 +1,17 @@
-'use strict';
-
-// KB_KNOWLEDGE_DATA_DIR names the product knowledge root the host product
-// launches the workbench with (explicit and non-secret by contract). The
-// workbench itself repoints KB_DATA_DIR at its own session storage; an agent
-// inheriting that value resolves project-knowledge-kb against the workbench
-// store and fails with PROJECT_NOT_FOUND. Map the product root onto KB_DATA_DIR
-// only in spawned agent environments: the workbench's own storage resolution
-// stays untouched, and a standalone workbench without the variable keeps the
-// inherited behavior.
-function knowledgeRootEnv(source) {
-  const env = source || process.env;
-  const root = typeof env.KB_KNOWLEDGE_DATA_DIR === 'string' ? env.KB_KNOWLEDGE_DATA_DIR.trim() : '';
-  return root ? { KB_DATA_DIR: root } : {};
-}
-
-module.exports = { knowledgeRootEnv };
+'use strict';
+
+// KB_KNOWLEDGE_DATA_DIR names the product knowledge root the host product
+// launches the workbench with (explicit and non-secret by contract). The
+// workbench itself repoints KB_DATA_DIR at its own session storage; an agent
+// inheriting that value resolves project-knowledge-kb against the workbench
+// store and fails with PROJECT_NOT_FOUND. Map the product root onto KB_DATA_DIR
+// only in spawned agent environments: the workbench's own storage resolution
+// stays untouched, and a standalone workbench without the variable keeps the
+// inherited behavior.
+function knowledgeRootEnv(source) {
+  const env = source || process.env;
+  const root = typeof env.KB_KNOWLEDGE_DATA_DIR === 'string' ? env.KB_KNOWLEDGE_DATA_DIR.trim() : '';
+  return root ? { KB_DATA_DIR: root } : {};
+}
+
+module.exports = { knowledgeRootEnv };