@jsonstudio/rcc 0.89.168 → 0.89.524

package/scripts/auth-iflow-manual.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { createProviderOAuthStrategy } from '../dist/providers/core/config/provider-oauth-configs.js';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-manual] Manual auth for: ${tokenPath}`);
+  
+  // ensure token file exists
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try { await fs.access(tokenPath); } catch { await fs.writeFile(tokenPath, '{}', 'utf-8'); }
+  
+  // Use device code flow but let user open the URL manually
+  const strategy = createProviderOAuthStrategy('iflow', {
+    flowType: 'device_code',
+    endpoints: {
+      deviceCodeUrl: 'https://iflow.cn/oauth/device/code',
+      tokenUrl: 'https://iflow.cn/oauth/token',
+      userInfoUrl: 'https://iflow.cn/api/oauth/getUserInfo'
+    },
+    client: { clientId: '10009311001', scopes: ['openid','profile','email','api'] }
+  }, tokenPath);
+  
+  // Manually trigger device code flow
+  const deviceCodeData = await strategy.initiateDeviceCodeFlow();
+  console.log('Please open this URL in your browser:');
+  console.log(deviceCodeData.verification_uri);
+  console.log('User code:', deviceCodeData.user_code);
+  console.log('Press Enter when you have authorized...');
+  
+  await new Promise(resolve => process.stdin.once('data', resolve));
+  
+  const token = await strategy.pollForToken(deviceCodeData);
+  await strategy.saveToken(token);
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-manual] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[iflow-manual] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => { console.error('[iflow-manual] Error:', err); process.exit(1); });

package/scripts/auth-iflow-token-direct.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+// iFlow token auth using direct device flow - no browser redirect
+// Usage: ILOW_TOKEN_FILE="~/.routecodex/auth/iflow-oauth-1-xxx.json" node scripts/auth-iflow-token-direct.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-auth-direct] Starting device flow for: ${tokenPath}`);
+  
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+  
+  const { createProviderOAuthStrategy } = await import('../dist/providers/core/config/provider-oauth-configs.js');
+  
+  // Use device code flow instead of auth code flow
+  const strategy = createProviderOAuthStrategy('iflow', {
+    flowType: 'device_code',
+    endpoints: {
+      deviceCodeUrl: 'https://iflow.cn/oauth/device/code',
+      tokenUrl: 'https://iflow.cn/oauth/token',
+      userInfoUrl: 'https://iflow.cn/api/oauth/getUserInfo'
+    },
+    client: {
+      clientId: process.env.IFLOW_CLIENT_ID || 'iflow-desktop-client',
+      scopes: ['openid','profile','email','api']
+    }
+  }, tokenPath);
+  
+  console.log('[iflow-auth-direct] Opening browser for device code flow...');
+  const token = await strategy.authenticate({ openBrowser: true });
+  await strategy.saveToken(token);
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-auth-direct] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+  
+  console.log(`[iflow-auth-direct] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => {
+  console.error('[iflow-auth-direct] Error:', err);
+  process.exit(1);
+});

package/scripts/auth-iflow-token.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+// iFlow token authentication script for specific token file
+// Usage: ILOW_TOKEN_FILE="~/.routecodex/auth/iflow-oauth-1-xxx.json" node scripts/auth-iflow-token.mjs
+
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+
+async function resolveIflowTokenPath() {
+  const envFile = process.env.IFLOW_TOKEN_FILE;
+  if (envFile && envFile.trim()) {
+    const normalized = envFile.startsWith('~') ? envFile.replace(/^~\//, `${os.homedir()}/`) : envFile;
+    return { tokenPath: normalized, duplicates: [] };
+  }
+
+  const authDir = path.join(os.homedir(), '.routecodex', 'auth');
+  const seq = 1;
+  const prefix = `iflow-oauth-${seq}`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(authDir);
+  } catch {
+    // directory may not exist yet
+  }
+  const matches = entries
+    .filter((entry) => entry.endsWith('.json'))
+    .filter((entry) => entry === `${prefix}.json` || entry.startsWith(`${prefix}-`));
+  matches.sort();
+  if (matches.length > 0) {
+    const canonical = path.join(authDir, matches[0]);
+    const duplicates = matches.slice(1).map((name) => path.join(authDir, name));
+    return { tokenPath: canonical, duplicates };
+  }
+  const canonical = path.join(authDir, `${prefix}-primary.json`);
+  return { tokenPath: canonical, duplicates: [] };
+}
+
+async function run() {
+  const { tokenPath, duplicates } = await resolveIflowTokenPath();
+  console.log(`[iflow-auth] Authenticating token: ${tokenPath}`);
+
+  // ensure token file exists so re-auth can recreate after delete
+  await fs.mkdir(path.dirname(tokenPath), { recursive: true });
+  try {
+    await fs.access(tokenPath);
+  } catch {
+    await fs.writeFile(tokenPath, '{}', 'utf-8');
+  }
+
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+  
+  await ensureValidOAuthToken('iflow', {
+    type: 'iflow-oauth',
+    tokenFile: tokenPath
+  }, {
+    forceReauthorize: true,
+    openBrowser: true
+  });
+
+  // clean up duplicate token files for the same sequence
+  for (const dup of duplicates) {
+    if (dup === tokenPath) continue;
+    try {
+      await fs.unlink(dup);
+      console.log(`[iflow-auth] Removed duplicate token file: ${dup}`);
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(`[iflow-auth] Token saved to: ${tokenPath}`);
+}
+
+run().catch(err => {
+  console.error('[iflow-auth] Error:', err);
+  process.exit(1);
+});

package/scripts/copy-compat-assets.mjs

@@ -15,23 +15,11 @@ async function ensureDir(p) {
 }
 
 async function main() {
-  const SRC = path.resolve(process.cwd(), 'src/providers/compat');
-  const DIST = path.resolve(process.cwd(), 'dist/providers/compat');
   const PROMPT_SRC = path.resolve(process.cwd(), 'src/config/system-prompts');
   const PROMPT_DIST = path.resolve(process.cwd(), 'dist/config/system-prompts');
-  const copied = [];
   const promptCopied = [];
   try {
-    for await (const file of walk(SRC)) {
-      if (file.endsWith('.json') && file.includes(`${path.sep}config${path.sep}`)) {
-        const rel = path.relative(SRC, file);
-        const dest = path.join(DIST, rel);
-        await ensureDir(path.dirname(dest));
-        await fs.copyFile(file, dest);
-        copied.push(rel);
-      }
-    }
-    // copy system prompt artifacts
+    // copy system prompt artifacts only; provider compat assets are owned by llmswitch-core
     try {
       for await (const file of walk(PROMPT_SRC)) {
         const stats = await fs.stat(file);
@@ -46,8 +34,8 @@ async function main() {
     } catch (promptErr) {
       if (promptErr && promptErr.code !== 'ENOENT') throw promptErr;
     }
-    // 不再复制 pipeline-config.generated.json 到 dist；统一从 ~/.routecodex/config/generated 读取
-    console.log(`[copy-compat-assets] copied ${copied.length} JSON assets; prompts: ${promptCopied.length}`);
+    // 不再复制 provider compat 资产；兼容层由 sharedmodule/llmswitch-core 提供
+    console.log(`[copy-compat-assets] prompts copied: ${promptCopied.length}`);
   } catch (err) {
     console.error('[copy-compat-assets] failed:', err?.message || String(err));
     process.exit(1);

package/scripts/install-verify.mjs

@@ -1027,6 +1027,7 @@ async function main() {
       messages: [...chatMessages, assistantMsg, toolMsg],
       tools: chatTools,
       stream: false,
+      tool_choice: 'auto'
     };
 
     console.log('📨 提交工具输出...');

package/scripts/pack-mode.mjs

@@ -59,11 +59,12 @@ try {
   if (args.name === 'routecodex' || args.name === 'rcc') {
     mutated.bundledDependencies = [];
     mutated.bundleDependencies = [];
+    const llmsVersion = original.dependencies?.['@jsonstudio/llms'] || '^0.6.230';
     mutated.dependencies = {
       ...(original.dependencies || {}),
       "ajv": original.dependencies?.ajv || "^8.17.1",
       "zod": original.dependencies?.zod || "^3.23.8",
-      "@jsonstudio/llms": original.dependencies?.["@jsonstudio/llms"] || "^0.4.3"
+      "@jsonstudio/llms": llmsVersion
     };
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));

package/scripts/publish-rcc.mjs

@@ -7,10 +7,7 @@ import { fileURLToPath } from 'node:url';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 const PACK_SCRIPT = path.join(PROJECT_ROOT, 'scripts', 'pack-mode.mjs');
-const packageJson = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf-8'));
-const version = packageJson.version;
-const tarballName = `jsonstudio-rcc-${version}.tgz`;
-const tarballPath = path.join(PROJECT_ROOT, tarballName);
+const pkgPath = path.join(PROJECT_ROOT, 'package.json');
 
 function run(command, args, options = {}) {
   const res = spawnSync(command, args, { stdio: 'inherit', ...options });
@@ -20,11 +17,30 @@ function run(command, args, options = {}) {
 }
 
 try {
+  // 1) 使用 release 模式构建 dist（依赖 npm 上的 @jsonstudio/llms）
+  run('npm', ['run', 'build:min'], {
+    cwd: PROJECT_ROOT,
+    env: { ...process.env, BUILD_MODE: 'release' }
+  });
+
+  // 2) 通过 pack-mode 生成 rcc tarball（内部会临时切换 package.json.name/bin 并确保 llms 为 release 包）
   run(process.execPath, [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'], { cwd: PROJECT_ROOT });
+
+  // 构建过程中版本号可能被 bump（gen-build-info 会 auto-bump），因此需要在 pack 之后重新读取版本号
+  const updatedPkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  const version = updatedPkg.version;
+  const tarballName = `jsonstudio-rcc-${version}.tgz`;
+  const tarballPath = path.join(PROJECT_ROOT, tarballName);
+
   if (!fs.existsSync(tarballPath)) {
     throw new Error(`tarball not found: ${tarballPath}`);
   }
+
+  // 3) 发布 npm 包
   run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
+
+  // 4) pack-mode 会在内部检测 dev 链接并调用 ensure-llmswitch-mode 恢复 dev 模式，
+  //    因此此处不再额外修改 BUILD_MODE 或重新 link。后续本地如需 dev build，可单独运行 `npm run build:dev`。
 } catch (err) {
   console.error('[publish-rcc] failed:', err.message);
   process.exit(1);

package/scripts/replay-codex-sample.mjs

@@ -39,21 +39,26 @@ function readJson(file) {
 }
 
 function extractEndpoint(doc) {
-  return doc?.data?.url || doc?.endpoint || '/v1/responses';
+  return doc?.data?.url || doc?.url || doc?.endpoint || '/v1/responses';
 }
 
 function extractBody(doc) {
-  const body = doc?.data?.body;
-  if (!body) return undefined;
-  if (typeof body.body === 'object') return body.body;
-  if (typeof body === 'object') return body;
-  if (typeof doc.data.data === 'object') return doc.data.data;
+  const bodyNode = doc?.data?.body || doc?.body;
+  if (!bodyNode) {
+    if (typeof doc?.data?.data === 'object') return doc.data.data;
+    if (typeof doc?.body?.data === 'object') return doc.body.data;
+    return undefined;
+  }
+  if (typeof bodyNode.body === 'object') return bodyNode.body;
+  if (typeof bodyNode === 'object') return bodyNode;
+  if (typeof doc?.data?.data === 'object') return doc.data.data;
+  if (typeof doc?.body?.data === 'object') return doc.body.data;
   return undefined;
 }
 
 function detectStream(doc, requestBody) {
-  if (doc?.data?.meta?.stream === true) return true;
-  if (doc?.data?.body?.metadata?.stream === true) return true;
+  if (doc?.data?.meta?.stream === true || doc?.meta?.stream === true) return true;
+  if (doc?.data?.body?.metadata?.stream === true || doc?.body?.metadata?.stream === true) return true;
   if (requestBody?.stream === true) return true;
   return false;
 }

package/scripts/tests/chat-pipeline-blackbox.mjs

@@ -191,7 +191,7 @@ function resolveGoldenExpectations(sample) {
   if (sample.meta?.endpoint && sample.meta?.requestId) {
     const reqId = sample.meta.requestId;
     const endpoint = sample.meta.endpoint;
-    const baseDir = path.join(os.homedir(), '.routecodex', 'golden_samples');
+    const baseDir = path.join(os.homedir(), '.routecodex', 'codex-samples');
     const folder = endpoint.includes('/messages')
       ? 'anthropic-messages'
       : endpoint.includes('/responses')

package/scripts/tests/virtual-router-health.mjs

@@ -13,7 +13,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(__dirname, '../..');
-const CORE_DIST = path.join(ROOT, 'sharedmodule', 'llmswitch-core', 'dist', 'v2', 'router', 'virtual-router');
+const CORE_DIST = path.join(ROOT, 'sharedmodule', 'llmswitch-core', 'dist', 'router', 'virtual-router');
 
 async function loadCoreModule(rel) {
   const file = path.join(CORE_DIST, rel);
@@ -21,16 +21,19 @@ async function loadCoreModule(rel) {
 }
 
 const { VirtualRouterEngine } = await loadCoreModule('engine.js');
+const { bootstrapVirtualRouterConfig } = await loadCoreModule('bootstrap.js');
 const { providerErrorCenter } = await loadCoreModule('error-center.js');
 const { VirtualRouterError } = await loadCoreModule('types.js');
 
 function parseArgs(argv) {
-  const args = { out: null };
+  const args = { out: null, config: null };
   const list = [...argv];
   while (list.length) {
     const cur = list.shift();
     if (cur === '--out' || cur === '--output') {
       args.out = list.shift() || null;
+    } else if (cur === '--config') {
+      args.config = list.shift() || null;
     } else if (cur === '--help' || cur === '-h') {
       args.help = true;
     }
@@ -57,9 +60,18 @@ function createRouterConfig() {
     'charlie.sim-model': buildProviderProfile('charlie.sim-model', 'https://charlie.local/v1')
   };
   const routing = {
-    default: Object.keys(providers),
-    coding: ['bravo.sim-model', 'charlie.sim-model'],
-    thinking: ['charlie.sim-model', 'alpha.sim-model']
+    default: [
+      { id: 'default-primary', priority: 200, targets: ['alpha.sim-model', 'bravo.sim-model'] },
+      { id: 'default-backup', backup: true, priority: 100, targets: ['charlie.sim-model'] }
+    ],
+    coding: [
+      { id: 'coding-primary', priority: 200, targets: ['bravo.sim-model', 'charlie.sim-model'] },
+      { id: 'coding-backup', backup: true, priority: 100, targets: ['alpha.sim-model'] }
+    ],
+    thinking: [
+      { id: 'thinking-primary', priority: 200, targets: ['charlie.sim-model'] },
+      { id: 'thinking-backup', backup: true, priority: 100, targets: ['bravo.sim-model'] }
+    ]
   };
   return {
     routing,
@@ -227,16 +239,128 @@ async function scenarioScheduler(sim) {
   sim.runRoute('thinking');
 }
 
+async function scenarioPriorityPools(sim) {
+  const first = sim.runRoute('thinking');
+  if (first !== 'charlie.sim-model') {
+    throw new Error(`expected primary thinking pool hit charlie.sim-model, got ${first}`);
+  }
+  sim.engine.handleProviderFailure({
+    providerKey: 'charlie.sim-model',
+    reason: 'priority-test',
+    fatal: true,
+    affectsHealth: true,
+    cooldownOverrideMs: 60_000
+  });
+  const second = sim.runRoute('thinking');
+  if (second !== 'bravo.sim-model') {
+    throw new Error(`expected thinking backup pool hit bravo.sim-model, got ${second}`);
+  }
+}
+
 async function scenarioRoutingDirectives(sim) {
   sim.runRoute('baseline', '普通请求');
   sim.runRoute('forced-thinking', '请仔细分析这个问题 <**thinking**>');
   sim.runRoute('forced-provider', '请强制使用这个provider <**charlie.sim-model**> 来回答');
 }
 
+async function scenarioRealConfig(configPath) {
+  const resolvedPath = path.resolve(configPath);
+  console.log(`\n=== Scenario: real-config (${resolvedPath}) ===`);
+  const source = JSON.parse(await fs.readFile(resolvedPath, 'utf-8'));
+  const section = source.virtualrouter && typeof source.virtualrouter === 'object' ? source.virtualrouter : source;
+  const { config } = bootstrapVirtualRouterConfig(section);
+  const engine = new VirtualRouterEngine();
+  engine.initialize(config);
+  const thinkingPools = config.routing.thinking ?? [];
+  const primaryPools = thinkingPools.filter((tier) => !tier.backup);
+  const backupPools = thinkingPools.filter((tier) => tier.backup);
+
+  const runThinking = (label) => {
+    const reqId = `real-config-${label}-${Date.now()}`;
+    const request = {
+      model: 'gpt-5.2-codex',
+      messages: [
+        { role: 'system', content: 'diagnostic' },
+        { role: 'user', content: `深入思考：${label}` }
+      ]
+    };
+    const metadata = {
+      requestId: reqId,
+      entryEndpoint: '/v1/responses',
+      processMode: 'chat',
+      stream: false,
+      direction: 'request',
+      providerProtocol: 'openai-responses'
+    };
+    const result = engine.route(request, metadata);
+    console.log(
+      JSON.stringify(
+        {
+          stage: 'real-config-route',
+          label,
+          providerKey: result.decision.providerKey,
+          route: result.decision.routeName,
+          poolId: result.decision.poolId
+        },
+        null,
+        2
+      )
+    );
+    return result.decision.providerKey;
+  };
+
+  const markUnavailable = (targets, reason) => {
+    for (const key of targets || []) {
+      engine.handleProviderFailure({
+        providerKey: key,
+        fatal: true,
+        affectsHealth: true,
+        reason,
+        cooldownOverrideMs: 60_000
+      });
+    }
+  };
+
+  // Primary hit
+  const firstProvider = runThinking('primary-hit');
+  const primaryTargets = primaryPools.flatMap((pool) => pool.targets ?? []);
+  const backupTargets = backupPools.flatMap((pool) => pool.targets ?? []);
+  if (primaryTargets.length === 0) {
+    console.warn('[real-config] No explicit primary thinking pool configured.');
+  } else if (!primaryTargets.includes(firstProvider)) {
+    console.warn('[real-config] First provider is not part of primary tier:', firstProvider);
+  }
+
+  // Drain primary
+  markUnavailable(primaryTargets, 'primary-exhausted');
+  const secondProvider = runThinking('backup-hit');
+  if (backupTargets.length && !backupTargets.includes(secondProvider)) {
+    throw new Error(
+      `[real-config] Expected backup pool provider after draining primary, got ${secondProvider}`
+    );
+  }
+
+  // Drain backup -> should fall to default
+  markUnavailable(backupTargets, 'backup-exhausted');
+  const thirdProvider = runThinking('default-fallback');
+  const usedRoute = engine.getStatus().routes;
+  console.log(
+    JSON.stringify(
+      {
+        stage: 'real-config-summary',
+        thirdProvider,
+        routes: usedRoute
+      },
+      null,
+      2
+    )
+  );
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) {
-    console.log('Usage: node scripts/tests/virtual-router-health.mjs [--out summary.json]');
+    console.log('Usage: node scripts/tests/virtual-router-health.mjs [--out summary.json] [--config ~/.routecodex/config.json]');
     return;
   }
 
@@ -247,6 +371,7 @@ async function main() {
     ['upstream', scenarioUpstream],
     ['timeout', scenarioTimeout],
     ['scheduler', scenarioScheduler],
+    ['priority-pools', scenarioPriorityPools],
     ['routing-directives', scenarioRoutingDirectives]
   ];
 
@@ -260,6 +385,16 @@ async function main() {
     });
   }
 
+  if (args.config) {
+    try {
+      await scenarioRealConfig(args.config);
+      summary.push({ name: 'real-config', status: 'ok', lastHealth: null });
+    } catch (error) {
+      console.error('[real-config] failed:', error);
+      summary.push({ name: 'real-config', status: 'failed', error: error?.message || String(error), lastHealth: null });
+    }
+  }
+
   if (args.out) {
     const outFile = path.resolve(process.cwd(), args.out);
     await fs.mkdir(path.dirname(outFile), { recursive: true });

package/scripts/tools/capture-provider-goldens.mjs

@@ -13,18 +13,19 @@ const ROOT = path.resolve(__dirname, '../..');
 
 const HOME = os.homedir();
 const PROVIDER_ROOT = path.join(HOME, '.routecodex', 'provider');
-const SNAPSHOT_ROOT = path.join(HOME, '.routecodex', 'golden_samples');
-const PROVIDER_GOLDEN_ROOT = path.join(SNAPSHOT_ROOT, 'provider_golden_samples');
+const RUNTIME_SNAPSHOT_ROOT = path.join(HOME, '.routecodex', 'codex-samples');
+const GOLDEN_ROOT = path.join(HOME, '.routecodex', 'golden_samples');
+const PROVIDER_GOLDEN_ROOT = path.join(GOLDEN_ROOT, 'provider_golden_samples');
 const CI_GOLDENS_ROOT = path.join(ROOT, 'samples', 'ci-goldens');
 const CUSTOM_SAMPLE_ROOTS = [
-  path.join(SNAPSHOT_ROOT, 'new'),
+  path.join(GOLDEN_ROOT, 'new'),
   CI_GOLDENS_ROOT
 ];
 const TEMP_ROOT = path.join(process.cwd(), 'tmp', 'provider-captures');
 const STAGE_DIRS = {
-  'openai-chat': path.join(SNAPSHOT_ROOT, 'openai-chat'),
-  'openai-responses': path.join(SNAPSHOT_ROOT, 'openai-responses'),
-  'anthropic-messages': path.join(SNAPSHOT_ROOT, 'anthropic-messages')
+  'openai-chat': path.join(RUNTIME_SNAPSHOT_ROOT, 'openai-chat'),
+  'openai-responses': path.join(RUNTIME_SNAPSHOT_ROOT, 'openai-responses'),
+  'anthropic-messages': path.join(RUNTIME_SNAPSHOT_ROOT, 'anthropic-messages')
 };
 const ENTRY_STAGE_MATRIX = {
   'openai-chat': {
@@ -437,7 +438,7 @@ function spawnServer(configPath, port) {
 }
 
 async function captureProvider(providerEntry, entryType, port, options, sanitizedProviderId) {
-  const stageDir = path.join(SNAPSHOT_ROOT, ENTRY_DEFS[entryType].stageDir);
+  const stageDir = path.join(RUNTIME_SNAPSHOT_ROOT, ENTRY_DEFS[entryType].stageDir);
   const suffix = '_req_outbound_stage2_format_build.json';
   const before = snapshotStageFiles(stageDir, suffix);
   const baseUrl = `http://127.0.0.1:${port}`;