wtt-connect 0.2.17 → 0.2.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wtt-connect",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "private": false,
   "description": "WTT-native connector daemon for Codex, Claude Code, Cursor, Gemini, ACP, and other coding agent surfaces.",
   "type": "module",

package/src/adapters/codex.js

@@ -1,7 +1,11 @@
 import { spawn } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import readline from 'node:readline';
+import { promisify } from 'node:util';
 import { log } from '../logger.js';
 
+const execFileAsync = promisify(execFile);
+
 export class CodexAdapter {
   constructor(config, deps = {}) {
     this.config = config;
@@ -35,6 +39,45 @@ export class CodexAdapter {
     return result.text.trim();
   }
 
+  async handleSlashCommand(commandText, context = {}) {
+    const parsed = parseSlashCommand(commandText);
+    if (!parsed) return null;
+    const sessionKey = context.sessionKey || 'default';
+
+    switch (parsed.command) {
+      case '/help':
+        return [
+          'Codex slash commands supported by WTT:',
+          '- `/status`: show Codex runtime/session status.',
+          '- `/model`: show the model selected by WTT for this run. Use the WTT model picker to switch models.',
+          '- `/approvals`: show the current approval/sandbox mode.',
+          '- `/diff`: show current git diff summary and patch excerpt.',
+          '- `/review`: run Codex native code review for the current workspace.',
+          '- `/init`: ask Codex to inspect the workspace and create/update AGENTS.md guidance.',
+          '- `/clear`: clear the stored Codex resume thread for this WTT topic.',
+          '- `/compact`: non-interactive Codex cannot compact an existing TUI context; WTT clears the stored resume thread instead.',
+        ].join('\n');
+      case '/status':
+        return this.codexStatus(sessionKey, context);
+      case '/model':
+        return this.codexModel(context, parsed.args);
+      case '/approvals':
+        return this.codexApprovals();
+      case '/diff':
+        return this.gitDiff();
+      case '/clear':
+        return this.clearSession(sessionKey, 'clear');
+      case '/compact':
+        return this.clearSession(sessionKey, 'compact');
+      case '/review':
+        return this.runNativeReview(context, sessionKey);
+      case '/init':
+        return this.runInit(context, sessionKey);
+      default:
+        return `Unsupported Codex slash command: ${parsed.command}\n\nTry \`/help\` for supported WTT/Codex commands.`;
+    }
+  }
+
   async runWithArgs(args, prompt, context, sessionKey) {
     return runJsonCli(this.config.codexBin, args, prompt, this.config.workDir, (event) => {
       const eventThreadId = event.thread_id || event.session_id || event.conversation_id;
@@ -47,6 +90,12 @@ export class CodexAdapter {
   }
 
   buildArgs(threadId, context = {}) {
+    const options = this.buildOptions(context);
+    if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
+    return ['exec', ...options, '--cd', this.config.workDir, '-'];
+  }
+
+  buildOptions(context = {}) {
     const options = ['--skip-git-repo-check', '--json'];
     options.push(...(this.permissions?.codexArgs() || []));
     const model = modelForCodex(this.config, context);
@@ -54,9 +103,102 @@ export class CodexAdapter {
     for (const img of context.images || []) options.push('--image', img);
     const reasoningEffort = reasoningEffortForRun(this.config, context);
     if (reasoningEffort && reasoningEffort !== 'off') options.push('-c', `model_reasoning_effort=${JSON.stringify(reasoningEffort)}`);
-    if (threadId) return ['exec', 'resume', ...options, threadId, '-'];
-    return ['exec', ...options, '--cd', this.config.workDir, '-'];
+    return options;
+  }
+
+  async codexStatus(sessionKey, context = {}) {
+    const stored = this.store?.getSession(sessionKey) || {};
+    const threadId = this.threadBySession.get(sessionKey) || stored.codexThreadId || '';
+    const version = await commandOutput(this.config.codexBin, ['--version'], this.config.workDir);
+    const model = modelForCodex(this.config, context) || '(config/default)';
+    return [
+      'Codex status',
+      `- binary: ${this.config.codexBin}`,
+      `- version: ${version || 'unknown'}`,
+      `- workdir: ${this.config.workDir}`,
+      `- mode: ${this.config.mode}`,
+      `- model: ${model}`,
+      `- resume thread: ${threadId || '(none)'}`,
+    ].join('\n');
+  }
+
+  codexModel(context = {}, args = '') {
+    const model = modelForCodex(this.config, context) || '(config/default)';
+    if (args.trim()) {
+      return [
+        `Current Codex model: ${model}`,
+        '',
+        'WTT runs Codex in non-interactive `codex exec` mode. Use the WTT Web model picker for per-message model switching; `/model <name>` is not applied to local Codex config.',
+      ].join('\n');
+    }
+    return `Current Codex model: ${model}\nUse the WTT Web model picker to switch the model for the next message.`;
   }
+
+  codexApprovals() {
+    const approvalArgs = (this.permissions?.codexArgs() || []).join(' ') || '(default Codex permissions)';
+    return [
+      'Codex approvals / sandbox',
+      `- WTT mode: ${this.config.mode}`,
+      `- Codex args: ${approvalArgs}`,
+    ].join('\n');
+  }
+
+  async gitDiff() {
+    const stat = await commandOutput('git', ['diff', '--stat'], this.config.workDir);
+    const patch = await commandOutput('git', ['diff', '--', '.'], this.config.workDir, 120000, 20000);
+    if (!stat && !patch) return 'No git diff in the current workspace.';
+    return [
+      'Current git diff',
+      stat ? `\n${stat}` : '',
+      patch ? `\nPatch excerpt:\n\`\`\`diff\n${truncate(patch, 12000)}\n\`\`\`` : '',
+    ].filter(Boolean).join('\n');
+  }
+
+  clearSession(sessionKey, reason) {
+    this.threadBySession.delete(sessionKey);
+    this.store?.clearSession(sessionKey, { adapter: this.name, codexThreadId: '', clearedBy: `/${reason}` });
+    return reason === 'compact'
+      ? 'Codex compact: non-interactive `codex exec` has no TUI context compaction. Cleared the stored WTT resume thread instead; the next turn starts a fresh Codex thread.'
+      : 'Codex session cleared for this WTT topic. The next turn starts a fresh Codex thread.';
+  }
+
+  async runNativeReview(context = {}, sessionKey = 'default') {
+    const args = ['exec', ...this.buildOptions(context), '--cd', this.config.workDir, 'review'];
+    const result = await this.runWithArgs(args, '', context, sessionKey);
+    return result.text.trim() || 'Codex review completed with no output.';
+  }
+
+  async runInit(context = {}, sessionKey = 'default') {
+    const prompt = [
+      'Inspect this workspace and create or update AGENTS.md with concise repository guidance for future coding agents.',
+      'Keep it specific to this repo. Include build/test commands and deployment notes only if discoverable from the workspace.',
+    ].join('\n');
+    const result = await this.runWithArgs(this.buildArgs('', context), prompt, context, sessionKey);
+    return result.text.trim() || 'Codex init completed with no output.';
+  }
+}
+
+function parseSlashCommand(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  return { command: command.toLowerCase(), args: rest.join(' ') };
+}
+
+async function commandOutput(bin, args, cwd, timeoutMs = 30000, maxChars = 8000) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { cwd, timeout: timeoutMs, maxBuffer: Math.max(maxChars * 4, 1024 * 1024) });
+    return truncate((stdout || stderr || '').trim(), maxChars);
+  } catch (err) {
+    const detail = `${err.stdout || ''}\n${err.stderr || ''}`.trim() || err.message;
+    return truncate(detail, maxChars);
+  }
+}
+
+function truncate(text, maxChars) {
+  const value = String(text || '');
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
 }
 
 function modelForCodex(config, context = {}) {

package/src/runner.js

@@ -72,7 +72,7 @@ export class Runner {
   }
 
   runtimeInfo() {
-    return buildRuntimeInfo(this.config);
+    return buildRuntimeInfo(this.config, this.store.getRuntime());
   }
 
   async onEvent(msg) {
@@ -167,16 +167,35 @@ export class Runner {
     const staged = await this.attachments.stageMessage(m);
     if (!content && !staged.files.length) return;
     await this.wtt.typing(topicId, 'start', { statusText: 'Agent 已接收消息，正在准备执行', statusKind: 'queued', ttlMs: 30000 });
+    let runtimeSelection = null;
     try {
       const transcripts = await this.transcribeAttachments(staged.files);
       const modelConfig = modelConfigFromMessage(m);
       const adapter = this.registry.select({ ...m, content, model_config: modelConfig });
+      runtimeSelection = { adapter: adapter.name, modelConfig };
+      this.recordRuntimeSelection(adapter.name, modelConfig, 'running');
       await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行${modelConfig.model ? ` · ${modelConfig.model}` : ''}`, statusKind: 'running', adapter: adapter.name, model: modelConfig.model || undefined, ttlMs: 30000 });
       const agentProfile = await this.getAgentProfile();
       const agentSoul = renderAgentSoulContext(m.metadata, agentProfile?.role_template);
       const discussionRouting = renderDiscussionRoutingInstruction(m, this.config);
       const currentDisplayName = effectiveAgentDisplayName(this.config, agentProfile);
       const isSlashPassthrough = isAgentSlashCommand(m, content);
+      if (isSlashPassthrough) {
+        const localSlash = await this.handleLocalSlashCommand(content, adapter, {
+          sessionKey: `wtt:topic:${topicId}:${adapter.name}:${sessionModelKey(modelConfig)}`,
+          topicId,
+          modelConfig,
+          files: staged.files,
+          images: staged.images,
+          onProgress: (event) => this.maybePublishProgress(topicId, event, adapter.name),
+        });
+        if (localSlash !== null) {
+          const reply = stripHiddenContextLeak(localSlash || '(empty response)') || '(empty response)';
+          await this.wtt.publish(topicId, reply, 'CHAT_REPLY');
+          log('info', 'slash command replied', { topicId, adapter: adapter.name, chars: reply.length });
+          return;
+        }
+      }
       const prompt = isSlashPassthrough ? content : [
         'You are replying to a WTT Web conversation. Do not mention implementation internals unless asked.',
         `WTT topic_id: ${topicId}`,
@@ -217,6 +236,7 @@ export class Runner {
       await this.wtt.publish(topicId, `执行失败：${err.message}`, 'CHAT_REPLY');
       log('error', 'chat failed', { topicId, error: err.message });
     } finally {
+      if (runtimeSelection) this.recordRuntimeSelection(runtimeSelection.adapter, runtimeSelection.modelConfig, 'idle');
       await this.wtt.typing(topicId, 'stop');
     }
   }
@@ -231,6 +251,7 @@ export class Runner {
     const transcripts = await this.transcribeAttachments(staged.files);
     const modelConfig = modelConfigFromMessage(task);
     const adapter = this.registry.select({ ...task, model_config: modelConfig });
+    this.recordRuntimeSelection(adapter.name, modelConfig, 'running');
     const agentProfile = await this.getAgentProfile();
     if (topicId) await this.wtt.typing(topicId, 'start', { statusText: `${adapterDisplayName(adapter.name)} 正在执行任务${modelConfig.model ? ` · ${modelConfig.model}` : ''}`, statusKind: 'running', adapter: adapter.name, model: modelConfig.model || undefined, ttlMs: 30000 });
     const prompt = buildTaskPrompt(task, this.config, staged, transcripts, agentProfile);
@@ -263,6 +284,7 @@ export class Runner {
       if (topicId) await this.wtt.publish(topicId, `任务失败：${err.message}`, 'TASK_BLOCKED');
       log('error', 'task failed', { taskId, error: err.message });
     } finally {
+      this.recordRuntimeSelection(adapter.name, modelConfig, 'idle');
       if (topicId) await this.wtt.typing(topicId, 'stop');
     }
   }
@@ -300,6 +322,73 @@ export class Runner {
     }
   }
 
+  async handleLocalSlashCommand(content, adapter, context = {}) {
+    const parsed = parseSlashCommand(content);
+    if (!parsed) return null;
+    if (parsed.command === '/wtt') {
+      const nested = parseSlashCommand(`/${parsed.args}`);
+      if (!nested) return wttSlashHelp();
+      parsed.command = nested.command;
+      parsed.args = nested.args;
+    }
+    if (parsed.command === '/upgrade') {
+      return this.handleUpgradeCommand(parsed.args);
+    }
+    if (adapter.name === 'codex' && typeof adapter.handleSlashCommand === 'function') {
+      return adapter.handleSlashCommand(content, context);
+    }
+    if (parsed.command === '/status') {
+      return this.runtimeStatusText(adapter, context);
+    }
+    if (parsed.command === '/clear') {
+      this.store.clearSession(context.sessionKey || 'default', { adapter: adapter.name, clearedBy: '/clear' });
+      if (adapter.threadBySession?.delete) adapter.threadBySession.delete(context.sessionKey || 'default');
+      if (adapter.sessionByKey?.delete) adapter.sessionByKey.delete(context.sessionKey || 'default');
+      return `${adapterDisplayName(adapter.name)} session cleared for this WTT topic.`;
+    }
+    return null;
+  }
+
+  runtimeStatusText(adapter, context = {}) {
+    const runtime = this.runtimeInfo();
+    const modelConfig = context.modelConfig || {};
+    const model = modelConfig.model || runtime.current_model || runtime.model || this.config.model || '(config/default)';
+    return [
+      'WTT agent runtime status',
+      `- agent_id: ${this.config.agentId || '(unbound)'}`,
+      `- adapter: ${adapter.name}`,
+      `- model: ${model}`,
+      `- workdir: ${this.config.workDir}`,
+      `- mode: ${this.permissions.describe()}`,
+      `- node: ${process.version}`,
+      `- wtt-connect: ${runtime.wtt_connect || runtime.wttConnect || '(unknown)'}`,
+      `- claude: ${runtime.claude_code || runtime.claude || '(unknown)'}`,
+      `- codex: ${runtime.codex || '(unknown)'}`,
+    ].join('\n');
+  }
+
+  async handleUpgradeCommand(argsText = '') {
+    const parsed = parseUpgradeArgs(argsText);
+    if (parsed.help) return upgradeHelp();
+    const result = await upgradeToolchain(this.config, parsed.targets);
+    this.store.patchRuntime({
+      toolchain_updated_at: new Date().toISOString(),
+      toolchain_update: result.summary,
+    });
+    return result.message;
+  }
+
+  recordRuntimeSelection(adapter, modelConfig = {}, status = 'idle') {
+    const model = String(modelConfig.model || modelConfig.model_id || modelConfig.modelId || '').trim();
+    const reasoning = String(modelConfig.reasoning_effort || modelConfig.reasoningEffort || '').trim().toLowerCase();
+    this.store.patchRuntime({
+      adapter,
+      ...(model ? { current_model: model, model, model_source: 'message_metadata' } : { model_source: 'config' }),
+      ...(reasoning ? { reasoning_effort: reasoning } : {}),
+      status,
+    });
+  }
+
   async transcribeAttachments(files) {
     try {
       return await this.stt.transcribeAll(files);
@@ -427,6 +516,192 @@ function adapterDisplayName(name) {
   return name || 'Agent';
 }
 
+function parseSlashCommand(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed.startsWith('/')) return null;
+  const [command, ...rest] = trimmed.split(/\s+/);
+  return { command: command.toLowerCase(), args: rest.join(' ') };
+}
+
+function wttSlashHelp() {
+  return [
+    'WTT slash commands:',
+    '- `/upgrade codex`: install the latest Codex CLI into the persistent toolchain.',
+    '- `/upgrade claude-code`: install the latest Claude Code CLI into the persistent toolchain.',
+    '- `/upgrade wtt-connect`: install the latest wtt-connect package into the persistent toolchain. Restart is required to use the new connector process.',
+    '- `/upgrade all`: install all three tools.',
+    '- `/status`: show WTT agent runtime status.',
+    '- `/clear`: clear this WTT topic session state.',
+  ].join('\n');
+}
+
+function upgradeHelp() {
+  return [
+    'Usage:',
+    '- `/upgrade codex`',
+    '- `/upgrade claude-code`',
+    '- `/upgrade wtt-connect`',
+    '- `/upgrade all`',
+    '',
+    'Aliases: `claude`, `claude_code`, `connect`, `connector`, `tools`.',
+    'Installs use the current persistent npm prefix when available, for example `/workspace/toolchain/node-global` in Cloudflare Sandbox.',
+  ].join('\n');
+}
+
+function parseUpgradeArgs(argsText = '') {
+  const tokens = String(argsText || '').trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (!tokens.length || tokens.includes('--help') || tokens.includes('-h') || tokens.includes('help')) {
+    return { help: true, targets: [] };
+  }
+  const targets = new Set();
+  for (const token of tokens) {
+    if (['all', 'tools', 'toolchain'].includes(token)) {
+      targets.add('wtt-connect');
+      targets.add('codex');
+      targets.add('claude-code');
+    } else if (['wtt-connect', 'connect', 'connector'].includes(token)) {
+      targets.add('wtt-connect');
+    } else if (['codex', 'openai-codex', 'openai'].includes(token)) {
+      targets.add('codex');
+    } else if (['claude-code', 'claude_code', 'claude', 'anthropic'].includes(token)) {
+      targets.add('claude-code');
+    }
+  }
+  if (!targets.size) return { help: true, targets: [] };
+  return { help: false, targets: Array.from(targets) };
+}
+
+async function upgradeToolchain(config, targets) {
+  const specs = [];
+  if (targets.includes('wtt-connect')) specs.push('wtt-connect@latest');
+  if (targets.includes('codex')) specs.push('@openai/codex@latest');
+  if (targets.includes('claude-code')) specs.push('@anthropic-ai/claude-code@latest');
+  if (!specs.length) return { message: upgradeHelp(), summary: {} };
+
+  const prefix = await resolveNpmPrefix(config);
+  const cache = process.env.NPM_CONFIG_CACHE
+    || process.env.npm_config_cache
+    || (prefix.endsWith('/node-global') ? path.join(path.dirname(prefix), 'npm-cache') : path.join(prefix, '.npm-cache'));
+  const registry = process.env.NPM_CONFIG_REGISTRY || process.env.npm_config_registry || 'https://registry.npmjs.org';
+  await fsp.mkdir(prefix, { recursive: true });
+  await fsp.mkdir(cache, { recursive: true });
+
+  const before = await toolVersions(config);
+  const env = {
+    ...process.env,
+    NPM_CONFIG_PREFIX: prefix,
+    npm_config_prefix: prefix,
+    NPM_CONFIG_CACHE: cache,
+    npm_config_cache: cache,
+    npm_config_nodedir: process.env.npm_config_nodedir || '/usr/local',
+  };
+  const install = await execFileAsync('npm', [
+    'install',
+    '-g',
+    '--prefix',
+    prefix,
+    '--cache',
+    cache,
+    `--registry=${registry}`,
+    ...specs,
+  ], {
+    cwd: config.workDir,
+    env,
+    timeout: 10 * 60_000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  const after = await toolVersions(config, prefix);
+  const lines = [
+    'Toolchain upgrade completed.',
+    `- npm prefix: ${prefix}`,
+    `- npm cache: ${cache}`,
+    `- packages: ${specs.join(', ')}`,
+    '',
+    'Versions:',
+    `- wtt-connect: ${before.wtt_connect || 'unknown'} -> ${after.wtt_connect || 'unknown'}`,
+    `- codex: ${before.codex || 'unknown'} -> ${after.codex || 'unknown'}`,
+    `- claude-code: ${before.claude_code || 'unknown'} -> ${after.claude_code || 'unknown'}`,
+  ];
+  if (targets.includes('wtt-connect')) {
+    lines.push('', 'Note: `wtt-connect` was upgraded on disk. Restart this agent process to run the new connector version; Claude Code and Codex upgrades are used on the next run because they are spawned per request.');
+  }
+  const stdout = String(install.stdout || '').trim();
+  if (stdout) lines.push('', 'npm output:', truncate(stdout, 4000));
+  return {
+    message: lines.join('\n'),
+    summary: {
+      prefix,
+      cache,
+      packages: specs,
+      before,
+      after,
+      installed_at: new Date().toISOString(),
+    },
+  };
+}
+
+async function resolveNpmPrefix(config) {
+  const envPrefix = process.env.NPM_CONFIG_PREFIX || process.env.npm_config_prefix || '';
+  if (envPrefix) return path.resolve(envPrefix);
+  const bin = await commandPath('wtt-connect').catch(() => '');
+  if (bin && path.basename(path.dirname(bin)) === 'bin') {
+    return path.dirname(path.dirname(bin));
+  }
+  const stateDir = config.stateDir || path.join(config.workDir || process.cwd(), '.wtt-connect');
+  return path.join(stateDir, 'toolchain', 'node-global');
+}
+
+async function commandPath(bin) {
+  const { stdout } = await execFileAsync('which', [bin], { timeout: 10000 });
+  return String(stdout || '').trim().split('\n')[0] || '';
+}
+
+async function toolVersions(config, prefix = '') {
+  const binDir = prefix ? path.join(prefix, 'bin') : '';
+  const wttConnectBin = binDir ? path.join(binDir, 'wtt-connect') : 'wtt-connect';
+  const codexBin = binDir ? path.join(binDir, 'codex') : config.codexBin;
+  const claudeBin = binDir ? path.join(binDir, 'claude') : config.claudeBin;
+  const [wttConnect, codex, claude] = await Promise.all([
+    npmPackageVersion('wtt-connect', prefix),
+    commandVersion(codexBin, ['--version'], config.workDir),
+    commandVersion(claudeBin, ['--version'], config.workDir),
+  ]);
+  return {
+    wtt_connect: wttConnect || await commandVersion(wttConnectBin, ['help'], config.workDir, /^wtt-connect\b/im),
+    codex,
+    claude_code: claude,
+  };
+}
+
+async function npmPackageVersion(packageName, prefix = '') {
+  try {
+    const args = ['list', '-g', packageName, '--depth=0', '--json'];
+    if (prefix) args.splice(2, 0, '--prefix', prefix);
+    const { stdout } = await execFileAsync('npm', args, { timeout: 30000, maxBuffer: 1024 * 1024 });
+    const parsed = JSON.parse(stdout || '{}');
+    return parsed.dependencies?.[packageName]?.version || '';
+  } catch {
+    return '';
+  }
+}
+
+async function commandVersion(bin, args, cwd, pattern = null) {
+  try {
+    const { stdout, stderr } = await execFileAsync(bin, args, { cwd, timeout: 30000, maxBuffer: 256 * 1024 });
+    const text = String(stdout || stderr || '').trim();
+    if (pattern && !pattern.test(text)) return '';
+    return text.split('\n')[0] || '';
+  } catch {
+    return '';
+  }
+}
+
+function truncate(text, maxChars) {
+  const value = String(text || '');
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}\n...[truncated ${value.length - maxChars} chars]`;
+}
+
 function renderGeneratedFileArtifactInstruction(config, topicId = '') {
   const workDir = config.workDir || process.cwd();
   const uploadCommand = `wtt-connect upload-file --topic-id ${topicId || '<topic_id>'} --title "optional display name" <file-or-files>`;

package/src/runtime-info.js

@@ -3,17 +3,20 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { execFileSync } from 'node:child_process';
 
-export function buildRuntimeInfo(config) {
+export function buildRuntimeInfo(config, runtimeState = {}) {
   const workdir = resolveWorkDir(config.workDir);
   const git = gitInfo(workdir);
-  const model = runtimeModel(config);
+  const adapter = String(runtimeState.adapter || config.adapter || '').trim();
+  const model = runtimeModel(config, adapter, runtimeState);
   return {
     kind: 'wtt-connect',
     agent_id: config.agentId,
-    adapter: config.adapter,
+    adapter: adapter || config.adapter,
     adapters: config.adapters,
     ...(model ? { model, current_model: model } : {}),
-    ...(config.reasoningEffort ? { reasoning_effort: String(config.reasoningEffort) } : {}),
+    ...(runtimeState.model_source ? { model_source: String(runtimeState.model_source) } : {}),
+    ...(runtimeState.status ? { runtime_status: String(runtimeState.status) } : {}),
+    ...(runtimeState.reasoning_effort || config.reasoningEffort ? { reasoning_effort: String(runtimeState.reasoning_effort || config.reasoningEffort) } : {}),
     workdir,
     workdir_name: path.basename(workdir || ''),
     cwd: safeRealpath(process.cwd()),
@@ -28,20 +31,85 @@ export function buildRuntimeInfo(config) {
   };
 }
 
-function runtimeModel(config) {
+function runtimeModel(config, adapter, runtimeState = {}) {
+  const fromRun = String(runtimeState.current_model || runtimeState.model || '').trim();
+  if (fromRun) return fromRun;
+
   const explicit = String(config.model || '').trim();
   if (explicit) return explicit;
 
-  const adapter = String(config.adapter || '').trim().toLowerCase();
-  if (adapter === 'codex') {
-    return String(process.env.OPENAI_MODEL || process.env.CODEX_MODEL || '').trim();
+  const normalizedAdapter = String(adapter || config.adapter || '').trim().toLowerCase();
+  if (normalizedAdapter === 'codex') {
+    return String(process.env.OPENAI_MODEL || process.env.CODEX_MODEL || readCodexConfigModel() || '').trim();
   }
-  if (adapter === 'claude-code' || adapter === 'claude' || adapter === 'claude_code') {
-    return String(process.env.ANTHROPIC_MODEL || '').trim();
+  if (normalizedAdapter === 'claude-code' || normalizedAdapter === 'claude' || normalizedAdapter === 'claude_code') {
+    return String(process.env.ANTHROPIC_MODEL || readClaudeConfigModel() || '').trim();
   }
   return String(process.env.WTT_CONNECT_MODEL || '').trim();
 }
 
+function readCodexConfigModel() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.codex', 'config.toml'),
+    path.join(home, '.config', 'codex', 'config.toml'),
+  ];
+  for (const file of candidates) {
+    const model = readTomlStringKey(file, 'model');
+    if (model) return model;
+  }
+  return '';
+}
+
+function readClaudeConfigModel() {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, '.claude.json'),
+    path.join(home, '.claude', 'settings.json'),
+    path.join(home, '.config', 'claude', 'settings.json'),
+  ];
+  for (const file of candidates) {
+    const model = readJsonModelKey(file);
+    if (model) return model;
+  }
+  return '';
+}
+
+function readJsonModelKey(file) {
+  try {
+    if (!fs.existsSync(file)) return '';
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return findModelValue(parsed);
+  } catch {
+    return '';
+  }
+}
+
+function findModelValue(value, depth = 0) {
+  if (!value || typeof value !== 'object' || depth > 4) return '';
+  for (const key of ['model', 'model_id', 'modelId', 'defaultModel', 'default_model']) {
+    const raw = value[key];
+    if (typeof raw === 'string' && raw.trim()) return raw.trim();
+  }
+  for (const child of Object.values(value)) {
+    const found = findModelValue(child, depth + 1);
+    if (found) return found;
+  }
+  return '';
+}
+
+function readTomlStringKey(file, key) {
+  try {
+    if (!fs.existsSync(file)) return '';
+    const text = fs.readFileSync(file, 'utf8');
+    const re = new RegExp(`^\\s*${key}\\s*=\\s*["']([^"']+)["']\\s*$`, 'm');
+    const match = text.match(re);
+    return match ? String(match[1] || '').trim() : '';
+  } catch {
+    return '';
+  }
+}
+
 function resolveWorkDir(workDir) {
   const raw = String(workDir || process.cwd()).trim() || process.cwd();
   return safeRealpath(path.resolve(raw));

package/src/store.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 export class DurableStore {
   constructor(file) {
     this.file = file;
-    this.data = { version: 1, sessions: {}, seen: {}, artifacts: [] };
+    this.data = { version: 1, sessions: {}, seen: {}, artifacts: [], runtime: {} };
     this.loaded = false;
   }
 
@@ -37,6 +37,23 @@ export class DurableStore {
     this.save();
   }
 
+  clearSession(sessionKey, patch = {}) {
+    this.load();
+    this.data.sessions[sessionKey] = { ...patch, updatedAt: new Date().toISOString() };
+    this.save();
+  }
+
+  getRuntime() {
+    this.load();
+    return this.data.runtime || {};
+  }
+
+  patchRuntime(patch) {
+    this.load();
+    this.data.runtime = { ...(this.data.runtime || {}), ...patch, updatedAt: new Date().toISOString() };
+    this.save();
+  }
+
   hasSeen(id, ttlMs = 24 * 3600_000) {
     this.load();
     const now = Date.now();