elanous 0.2.41 → 0.2.43

package/scripts/video-pipeline.ts

@@ -1092,7 +1092,15 @@ async function plan() {
         ovSelections = sel.selections.map((x) => ({ overlayId: x.overlayId, verdict: x.verdict, detail: x.detail }));
         if (sel.applied.length > 0) {
           const applied = applyGraphOverlays(decl.template, sel.applied);
-          if (applied.ok) ovPatches = applied.patches.map((x) => ({ overlayId: x.overlayId, node: x.node, field: x.field, before: (x as { before: unknown }).before, after: (x as { after: unknown }).after }));
+          if (applied.ok) ovPatches = applied.patches.map((x) => {
+            if (x.field === 'edge-rerouted') return {
+              overlayId: x.overlayId, node: x.from, field: x.field, before: x.was, after: x.to,
+            };
+            if (x.field === 'node-added') return {
+              overlayId: x.overlayId, node: x.node, field: x.field, before: null, after: x.kind,
+            };
+            return { overlayId: x.overlayId, node: x.node, field: x.field, before: x.before, after: x.after };
+          });
           else ovError = `얹다가 거절됐다 — ${applied.rejections.map((r) => r.kind).join(', ')}`;
         }
       }

package/scripts/warm-pool-provider-config.ts

@@ -0,0 +1,286 @@
+import { spawn } from 'node:child_process';
+import { chmodSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { userConfigPath } from '../src/user-config.js';
+import type { WarmWorkerCandidate } from '../src/task-orchestrator/surfaces/pod-warm-worker-provider.js';
+
+const TOKEN = /^[a-f0-9]{64}$/;
+const SHA = /^[a-f0-9]{40}$/;
+const DIGEST = /^sha256:[a-f0-9]{64}$/;
+const LOCK_HASH = /^[a-f0-9]{64}$/;
+const TIERS = new Set(['lite', 'standard']);
+
+type JsonObject = Record<string, unknown>;
+
+export interface WarmPoolProviderConfig {
+  candidates: WarmWorkerCandidate[];
+  poolTemplates: Array<{
+    host: string;
+    tier: 'lite' | 'standard';
+    spec: {
+      name: string;
+      namespace: string;
+      kubectlContext: string;
+      workerId: string;
+      image: string;
+      sourceUrl?: string;
+      sourceMirrorHostPath?: string;
+      nodeName: string;
+      cutSha: string;
+      key: { context: string; imageDigest: string; lockHash: string; architecture: string };
+      memoryLimit: '2Gi' | '16Gi';
+      hostProbeUrl: string;
+      prodProbeUrl: string;
+    };
+  }>;
+  profileConfig: { pod: { warmPoolProfile: string } };
+  controlUrl: string;
+  memberToken: string;
+  machineTokens: Record<string, string>;
+}
+
+export interface AssembleWarmPoolProviderConfigInput {
+  config: unknown;
+  controlUrl: string;
+  memberToken: string;
+  machineTokens: Record<string, string>;
+}
+
+/** Keep a deployment canary to one explicit worker instead of expanding its profile quota. */
+export function selectSingleWarmPoolCandidate(config: WarmPoolProviderConfig, selection: string): WarmPoolProviderConfig {
+  const match = /^([a-zA-Z0-9][a-zA-Z0-9._-]*)\/(lite|standard)$/.exec(selection);
+  if (!match) throw new Error('--single-candidate must be HOST/lite or HOST/standard');
+  const [, host, tier] = match;
+  const template = config.poolTemplates.find(candidate => candidate.host === host && candidate.tier === tier);
+  if (!template) throw new Error(`warm pool template not found: ${host}/${tier}`);
+  const index = 1;
+  return {
+    ...config,
+    candidates: [{ host, tier: tier as 'lite' | 'standard', spec: {
+      ...template.spec,
+      name: `warm-${host}-${tier}-${index}`,
+      workerId: `${template.spec.workerId}-${tier}-${index}`,
+    } }],
+    poolTemplates: [],
+  };
+}
+
+function object(value: unknown, label: string): JsonObject {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${label} is required`);
+  return value as JsonObject;
+}
+
+function text(value: unknown, label: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${label} is required`);
+  return value.trim();
+}
+
+function token(value: unknown, label: string): string {
+  const parsed = text(value, label);
+  if (!TOKEN.test(parsed)) throw new Error(`${label} must be a 64-character hexadecimal token`);
+  return parsed;
+}
+
+function httpUrl(value: unknown, label: string, hostname?: string): string {
+  const parsed = text(value, label);
+  try {
+    const url = new URL(parsed);
+    if (url.protocol !== 'http:' || !url.port || url.username || url.password || url.search || url.hash
+      || (hostname !== undefined && url.hostname !== hostname)) throw new Error();
+    return url.href;
+  } catch { throw new Error(`${label} must be an http URL${hostname ? ` for ${hostname}` : ''}`); }
+}
+
+function controlUrl(value: unknown): string {
+  const parsed = text(value, 'controlUrl');
+  try {
+    const url = new URL(parsed);
+    const authority = /^(?:http|https):\/\/([^/?#]*)/i.exec(parsed)?.[1] ?? '';
+    const explicitPort = !authority.includes('\\') && /^(?:\[[^\]]+\]|[^:]+):\d+$/.test(authority);
+    if (!['http:', 'https:'].includes(url.protocol) || !explicitPort || authority.includes('@') || url.username || url.password
+      || parsed.includes('?') || parsed.includes('#') || url.search || url.hash)
+      throw new Error();
+    return url.href;
+  } catch { throw new Error('controlUrl must be an http or https URL with an explicit port'); }
+}
+
+function privateSource(pool: JsonObject): Pick<WarmPoolProviderConfig['poolTemplates'][number]['spec'], 'sourceUrl' | 'sourceMirrorHostPath'> {
+  const mirror = pool.sourceMirrorHostPath;
+  const source = pool.sourceUrl;
+  if (typeof mirror === 'string' && mirror.trim()) {
+    if (!isAbsolute(mirror) || mirror.trim() !== mirror) throw new Error('pod.warmPool.sourceMirrorHostPath must be an absolute normalized path');
+    return { sourceMirrorHostPath: mirror };
+  }
+  if (typeof source === 'string' && source.trim()) {
+    try {
+      const url = new URL(source);
+      if (url.protocol !== 'https:' || !url.hostname || url.username || url.password || url.search || url.hash) throw new Error();
+      return { sourceUrl: url.href };
+    } catch { throw new Error('pod.warmPool.sourceUrl must be a public https URL'); }
+  }
+  throw new Error('pod.warmPool.sourceMirrorHostPath or pod.warmPool.sourceUrl is required');
+}
+
+/** Convert canonical user config plus operator-supplied private credentials into the two provider loaders' shared format. */
+export function assembleWarmPoolProviderConfig(input: AssembleWarmPoolProviderConfigInput): WarmPoolProviderConfig {
+  const root = object(input.config, 'config');
+  const pod = object(root.pod, 'pod');
+  const harness = object(root.harness, 'harness');
+  const profile = text(pod.warmPoolProfile, 'pod.warmPoolProfile');
+  const pool = object(pod.warmPool, 'pod.warmPool');
+  const cutSha = text(harness.imageCommit, 'harness.imageCommit');
+  if (!SHA.test(cutSha)) throw new Error('harness.imageCommit must be a 40-character commit SHA');
+  const kubectlContext = text(harness.podPool, 'harness.podPool');
+  const namespace = text(pool.namespace, 'pod.warmPool.namespace');
+  const imageRepository = text(pool.imageRepository, 'pod.warmPool.imageRepository').replace(/\/$/, '');
+  const imageDigest = text(pool.imageDigest, 'pod.warmPool.imageDigest');
+  if (!DIGEST.test(imageDigest)) throw new Error('pod.warmPool.imageDigest must be a sha256 digest');
+  const lockHash = text(pool.lockHash, 'pod.warmPool.lockHash');
+  if (!LOCK_HASH.test(lockHash)) throw new Error('pod.warmPool.lockHash must be a 64-character SHA-256');
+  const architecture = text(pool.architecture, 'pod.warmPool.architecture');
+  const hostProbeUrl = httpUrl(pool.hostProbeUrl, 'pod.warmPool.hostProbeUrl', 'host.orb.internal');
+  const prodProbeUrl = httpUrl(pool.prodProbeUrl, 'pod.warmPool.prodProbeUrl', 'core.elanous-prod');
+  const source = privateSource(pool);
+  const templates = pool.templates;
+  if (!Array.isArray(templates) || templates.length === 0) throw new Error('pod.warmPool.templates is required');
+  const seen = new Set<string>();
+  const machineTokens: Record<string, string> = {};
+  const poolTemplates = templates.map((raw, index) => {
+    const row = object(raw, `pod.warmPool.templates[${index}]`);
+    const host = text(row.host, `pod.warmPool.templates[${index}].host`);
+    const tier = text(row.tier, `pod.warmPool.templates[${index}].tier`);
+    if (!TIERS.has(tier)) throw new Error(`pod.warmPool.templates[${index}].tier must be lite or standard`);
+    const nodeName = text(row.nodeName, `pod.warmPool.templates[${index}].nodeName`);
+    const identity = `${host}/${tier}`;
+    if (seen.has(identity)) throw new Error(`duplicate pod.warmPool template ${identity}`);
+    seen.add(identity);
+    machineTokens[host] = token(input.machineTokens[host], `machine token for ${host}`);
+    return {
+      host,
+      tier: tier as 'lite' | 'standard',
+      spec: {
+        name: `warm-${host}-${tier}-template`, namespace, kubectlContext,
+        workerId: `warm-${host}-${cutSha.slice(0, 12)}`, image: `${imageRepository}@${imageDigest}`,
+        ...source, nodeName, cutSha,
+        key: { context: kubectlContext, imageDigest, lockHash, architecture },
+        memoryLimit: tier === 'lite' ? '2Gi' as const : '16Gi' as const,
+        hostProbeUrl, prodProbeUrl,
+      },
+    };
+  });
+  return { candidates: [], poolTemplates, profileConfig: { pod: { warmPoolProfile: profile } },
+    controlUrl: controlUrl(input.controlUrl), memberToken: token(input.memberToken, 'member token'), machineTokens };
+}
+
+/** Atomically replace the private provider config and repair permissions on an existing file. */
+export function writeWarmPoolProviderConfig(path: string, config: WarmPoolProviderConfig): void {
+  if (!isAbsolute(path)) throw new Error('output path must be absolute');
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    renameSync(temporary, path);
+    chmodSync(path, 0o600);
+  } catch (error) {
+    try { unlinkSync(temporary); } catch { /* no temporary output */ }
+    throw error;
+  }
+}
+
+function redact(config: WarmPoolProviderConfig): unknown {
+  return { ...config, memberToken: '[redacted]', machineTokens: Object.fromEntries(Object.keys(config.machineTokens).map(host => [host, '[redacted]'])) };
+}
+
+function shellQuote(value: string): string { return `'${value.replaceAll("'", "'\\''")}'`; }
+
+interface CliOptions {
+  configPath: string;
+  controlUrl: string;
+  memberTokenFile: string;
+  machineTokenFiles: Record<string, string>;
+  output: string;
+  dryRun: boolean;
+  serve: boolean;
+  singleCandidate?: string;
+}
+
+function parseArgs(argv: readonly string[]): CliOptions {
+  let configPath = userConfigPath(), controlUrl = '', memberTokenFile = '', output = '';
+  let dryRun = false, serve = false, singleCandidate: string | undefined;
+  const machineTokenFiles: Record<string, string> = {};
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    const next = () => {
+      const value = argv[++index];
+      if (!value) throw new Error(`missing value for ${arg}`);
+      return value;
+    };
+    if (arg === '--config') configPath = next();
+    else if (arg === '--control-url') controlUrl = next();
+    else if (arg === '--member-token-file') memberTokenFile = next();
+    else if (arg === '--machine-token') {
+      const [host, file, extra] = next().split('=');
+      if (!host || !file || extra !== undefined) throw new Error('--machine-token must be HOST=FILE');
+      machineTokenFiles[host] = file;
+    } else if (arg === '--output') output = next();
+    else if (arg === '--dry-run') dryRun = true;
+    else if (arg === '--serve') serve = true;
+    else if (arg === '--single-candidate') singleCandidate = next();
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  if (!isAbsolute(configPath) || !controlUrl || !isAbsolute(memberTokenFile))
+    throw new Error('usage: --config ABSOLUTE --control-url URL --member-token-file ABSOLUTE --machine-token HOST=ABSOLUTE [--output ABSOLUTE] [--single-candidate HOST/TIER] [--dry-run|--serve]');
+  if (Object.values(machineTokenFiles).some(file => !isAbsolute(file))) throw new Error('machine token files must be absolute');
+  if (dryRun && serve) throw new Error('--dry-run and --serve cannot be combined');
+  return { configPath, controlUrl, memberTokenFile, machineTokenFiles,
+    output: output || join(dirname(configPath), 'warm-pod-provider.json'), dryRun, serve, singleCandidate };
+}
+
+function readPrivateToken(path: string, label: string): string {
+  if (!isAbsolute(path)) throw new Error(`${label} path must be absolute`);
+  return token(readFileSync(path, 'utf8').trim(), label);
+}
+
+export async function runWarmPoolProviderConfig(argv: readonly string[]): Promise<void> {
+  const options = parseArgs(argv);
+  const config = JSON.parse(readFileSync(options.configPath, 'utf8')) as unknown;
+  const machineTokens = Object.fromEntries(Object.entries(options.machineTokenFiles)
+    .map(([host, path]) => [host, readPrivateToken(path, `machine token for ${host}`)]));
+  const assembled = assembleWarmPoolProviderConfig({ config, controlUrl: options.controlUrl,
+    memberToken: readPrivateToken(options.memberTokenFile, 'member token'), machineTokens });
+  const selected = options.singleCandidate ? selectSingleWarmPoolCandidate(assembled, options.singleCandidate) : assembled;
+  if (!options.dryRun) writeWarmPoolProviderConfig(options.output, selected);
+  process.stdout.write(`${JSON.stringify({ output: options.output, config: redact(selected),
+    ...(options.serve ? { serve: { command: `ELANOUS_WARM_POD_PROVIDER_CONFIG=${shellQuote(options.output)} bun src/task-orchestrator/surfaces/pod-warm-worker-provider.ts --serve` } } : {}) })}\n`);
+  if (!options.serve) return;
+  const provider = fileURLToPath(new URL('../src/task-orchestrator/surfaces/pod-warm-worker-provider.ts', import.meta.url));
+  const child = spawn(process.execPath, [provider, '--serve'], { stdio: 'inherit',
+    env: { ...process.env, ELANOUS_WARM_POD_PROVIDER_CONFIG: options.output } });
+  const forwardSignal = (signal: NodeJS.Signals) => { if (child.exitCode === null && child.signalCode === null) child.kill(signal); };
+  const forwardInterrupt = () => forwardSignal('SIGINT');
+  const forwardTerminate = () => forwardSignal('SIGTERM');
+  process.on('SIGINT', forwardInterrupt);
+  process.on('SIGTERM', forwardTerminate);
+  try {
+    await new Promise<void>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', (code, signal) => {
+        process.exitCode = code ?? (signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : 2);
+        resolve();
+      });
+    });
+  } finally {
+    process.off('SIGINT', forwardInterrupt);
+    process.off('SIGTERM', forwardTerminate);
+  }
+}
+
+if (import.meta.main) {
+  try { await runWarmPoolProviderConfig(process.argv.slice(2)); }
+  catch (error) {
+    process.stderr.write(`warm-pool-provider-config: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 2;
+  }
+}

package/skills/omni-crawl/SKILL.md

@@ -81,13 +81,16 @@ requires: []
 자체 합성 파이프라인 (Tavily Research 엔드포인트 미사용 — 콜당 15~250cr 폭탄 회피):
 
 ```
-1) 다각도 tavily advanced ×3 (core/outlook/risk) 병렬   ~6cr  ⚙️ OMNI_CRAWL_TAVILY=0 이면 ddg 무료 ×3 (0cr)
-2) URL dedup → 상위 5개 firecrawl 풀스크랩 (캐시 2h)     ~5cr
+1) 다각도 검색 ×3 (Tavily 사용 가능 시 Tavily, 키 없음/비활성 시 Firecrawl) 병렬
+   런타임 0건/실패면 다음 유료 엔진, 두 검색축이 모두 비었을 때만 DDG 무료 최후 폴백
+2) URL dedup → 상위 5개 Firecrawl 풀스크랩 (캐시 2h)
 3) grok-community 1콜 (X+레딧 여론 각도)                 ~$0.05
 4) 기술 주제면 fc-dev 1콜 자동 가세 (looksTechnical 게이트)  ~2cr
 → 통합 마크다운 (풀본문이 스니펫보다 dedup 우선 생존)
 ```
 
+각 각도 검색과 URL 스크랩은 엔진·단계별 경과 시간을 로그에 남긴다. Tavily 키가 없는 정상 경로는 Firecrawl 검색으로 세 각도를 채우며, DDG는 Tavily와 Firecrawl이 모두 없거나 0건일 때만 최후 폴백으로 호출한다.
+
 ## 실행
 
 이 스킬 폴더에서 실행합니다.

package/skills/omni-crawl/scripts/main.ts

@@ -153,7 +153,7 @@ async function main(query: string) {
 
 // ── Deep research 파이프라인 (자체 합성 — Tavily Research 엔드포인트 미사용·비용 예측성) ──
 //
-// 1) 다각도 tavily advanced ×3 (사실/전망/리스크 각도) 병렬
+// 1) 다각도 웹 검색 ×3 (Tavily 사용 가능 시 Tavily, 아니면 Firecrawl) 병렬
 // 2) URL dedup → 상위 K=5 를 firecrawl 풀스크랩 (maxAge 2h 캐시)
 // 3) grok-community 1콜 (X+레딧 여론 각도)
 // 카버당 비용: tavily ~6cr + firecrawl ~5cr + grok ~$0.03 — 예측 가능.
@@ -173,15 +173,11 @@ async function runDeep(query: string): Promise<CrawlResult[]> {
   const results: CrawlResult[] = [];
 
   // 1) 다각도 검색 + grok-community 동시 발사
-  // ⛔⭐ 2026-08-06 (공식 결정) — tavily 각도 검색은 **기본 OFF**(deep 1회당 advanced ×3 ≈ 6cr 고정비).
-  //    켜기: `.env` 또는 셸에 `OMNI_CRAWL_TAVILY=1`. 끄면 아래 `!gotTavily` 분기가 **이미 있는**
-  //    ddg 무료 각도 검색을 대신 돌린다(별도 배선 불필요).
+  // 키 부재·비활성뿐 아니라 Tavily/Firecrawl 런타임 공백도 다음 엔진으로 넘긴다.
+  // Tavily 부재 시 Firecrawl이 우선이며 DDG는 두 유료 검색축이 모두 비었을 때만 최후 폴백.
+  const angleEngines = deepAngleSearchOrder(tavilyEnabled() && tavilyAvailable(), firecrawlAvailable());
   const searchTasks: Array<Promise<CrawlResult | null>> = [
-    ...(tavilyEnabled() ? angles.map(a =>
-      searchTavily(a.q, { depth: 'advanced', maxResults: 5, chunksPerSource: 3, timeRange: flags['time-range'] })
-        .then(r => ({ ...r, engine: `tavily:${a.label}` }))
-        .catch(e => { console.log(`  [deep] tavily(${a.label}) 실패: ${e.message?.slice(0, 80)}`); return null; }),
-    ) : []),
+    ...angles.map(a => searchDeepAngle(a, angleEngines)),
     searchGrok({ query, mode: 'community' })
       .catch(e => { console.log(`  [deep] grok-community 실패: ${e.message?.slice(0, 80)}`); return null; }),
     // 기술 주제면 개발자 인덱스 1콜 추가(실측 ~2cr) — 패시지가 곧 인용이라 풀스크랩 콜을 아낀다.
@@ -193,20 +189,11 @@ async function runDeep(query: string): Promise<CrawlResult[]> {
   const settled = await Promise.all(searchTasks);
   for (const r of settled) if (r) results.push(r as CrawlResult);
 
-  // 1-b) tavily 축이 비면(기본 OFF · 키 없음 · 장애) ddg 무료가 각도 검색을 담당한다.
-  const gotTavily = results.some(r => r.engine.startsWith('tavily') && r.totalItems > 0);
-  if (!gotTavily) {
-    console.log('  [deep] ddg 무료 티어로 각도 검색');
-    const ddgResults = await Promise.all(angles.map(a =>
-      searchDdg(a.q, { maxResults: 5 }).then(r => ({ ...r, engine: `ddg:${a.label}` })).catch(() => null)));
-    for (const r of ddgResults) if (r && r.totalItems > 0) results.push(r as CrawlResult);
-  }
-
   // 2) 검색 히트에서 상위 URL 추출 → firecrawl 풀스크랩 (병렬·캐시 2h)
   const seen = new Set<string>();
   const topUrls: string[] = [];
   for (const r of results) {
-    if (!r.engine.startsWith('tavily') && !r.engine.startsWith('ddg')) continue;
+    if (!r.engine.startsWith('tavily') && !r.engine.startsWith('firecrawl') && !r.engine.startsWith('ddg')) continue;
     for (const it of r.items) {
       if (!it.url || seen.has(it.url)) continue;
       seen.add(it.url);
@@ -217,9 +204,21 @@ async function runDeep(query: string): Promise<CrawlResult[]> {
   }
   if (topUrls.length) {
     console.log(`  [deep] 상위 ${topUrls.length}개 URL 풀스크랩 (firecrawl·캐시 2h)`);
-    const scraped = await Promise.all(topUrls.map(u =>
-      scrapeFirecrawl(u, { maxAge: 2 * 3600_000 }).catch(() => null),
-    ));
+    const scraped = await Promise.all(topUrls.map(async u => {
+      const startedAt = Date.now();
+      try {
+        const result = await scrapeFirecrawl(u, { maxAge: 2 * 3600_000 });
+        if (!result) {
+          console.log(`  [deep:firecrawl:scrape] ${u} · 실패 · ${Date.now() - startedAt}ms · 본문 없음`);
+          return null;
+        }
+        console.log(`  [deep:firecrawl:scrape] ${u} · ${Date.now() - startedAt}ms · ${result.content.length}자`);
+        return result;
+      } catch (e: any) {
+        console.log(`  [deep:firecrawl:scrape] ${u} · 실패 · ${Date.now() - startedAt}ms · ${e.message?.slice(0, 80)}`);
+        return null;
+      }
+    }));
     const items: CrawlItem[] = [];
     for (let i = 0; i < scraped.length; i++) {
       const s = scraped[i];
@@ -248,12 +247,54 @@ async function runDeep(query: string): Promise<CrawlResult[]> {
         if (s) items.push({ engine: 'fc-deep', query, url: missed[i], text: s.content.slice(0, 6000), metadata: { via: s.method, title: s.title } });
       }
     }
-    if (items.length) results.push({ engine: 'deep-fullscrape', query, items, totalItems: items.length, costNote: `firecrawl ~${scraped.filter(Boolean).length}cr + 무료` });
+    if (items.length) {
+      console.log(`  [deep:firecrawl:fullscrape] ${items.length}/${topUrls.length}건 본문 확보`);
+      results.push({ engine: 'deep-fullscrape', query, items, totalItems: items.length, costNote: `firecrawl ~${scraped.filter(Boolean).length}cr + 무료` });
+    } else {
+      console.log(`  [deep:firecrawl:fullscrape] 0/${topUrls.length}건 본문 확보`);
+    }
   }
 
   return results;
 }
 
+type DeepAngleEngine = 'tavily' | 'firecrawl' | 'ddg';
+
+function deepAngleSearchOrder(tavilyReady: boolean, firecrawlReady: boolean): DeepAngleEngine[] {
+  return [
+    ...(tavilyReady ? ['tavily' as const] : []),
+    ...(firecrawlReady ? ['firecrawl' as const] : []),
+    'ddg',
+  ];
+}
+
+function firecrawlTbsFromTimeRange(timeRange?: string): string | undefined {
+  if (!timeRange) return undefined;
+  return ({ day: 'qdr:d', week: 'qdr:w', month: 'qdr:m', year: 'qdr:y' } as Record<string, string>)[timeRange];
+}
+
+async function searchDeepAngle(
+  angle: { q: string; label: string },
+  engines: DeepAngleEngine[],
+): Promise<CrawlResult | null> {
+  for (const engine of engines) {
+    const startedAt = Date.now();
+    try {
+      const result = engine === 'tavily'
+        ? await searchTavily(angle.q, { depth: 'advanced', maxResults: 5, chunksPerSource: 3, timeRange: flags['time-range'] })
+        : engine === 'firecrawl'
+          ? await searchFirecrawl(angle.q, { limit: 5, tbs: firecrawlTbsFromTimeRange(flags['time-range']) })
+          : await searchDdg(angle.q, { maxResults: 5 });
+      const elapsedMs = Date.now() - startedAt;
+      console.log(`  [deep:${engine}:${angle.label}] ${result.totalItems}건 · ${elapsedMs}ms`);
+      if (result.totalItems > 0) return { ...result, engine: `${engine}:${angle.label}` };
+    } catch (e: any) {
+      console.log(`  [deep:${engine}:${angle.label}] 실패 · ${Date.now() - startedAt}ms · ${e.message?.slice(0, 80)}`);
+    }
+  }
+  return null;
+}
+
 // ── 폴백 체인: tavily ↔ firecrawl → (최후) ddg 무료 (웹 검색 축 공백 방지) ──
 //
 // 원칙: 유료(tavily/firecrawl)가 1순위·기본. 유료가 공백/미가용일 때만 무료(ddg)로 강등.
@@ -494,6 +535,26 @@ function runSelfTest() {
     else { console.log(`  FAIL: looksTechnical("${q}") expect ${expect}, got ${got}`); failed++; }
   }
 
+  const angleEngineCases: Array<[string, boolean, boolean, string]> = [
+    ['Tavily and Firecrawl ready', true, true, 'tavily,firecrawl,ddg'],
+    ['Tavily unavailable', false, true, 'firecrawl,ddg'],
+    ['Tavily disabled', false, true, 'firecrawl,ddg'],
+    ['both paid search engines unavailable', false, false, 'ddg'],
+  ];
+  for (const [label, tavilyReady, firecrawlReady, expected] of angleEngineCases) {
+    const got = deepAngleSearchOrder(tavilyReady, firecrawlReady).join(',');
+    if (got === expected) { console.log(`  PASS: deep angle fallback ${label} → ${got}`); passed++; }
+    else { console.log(`  FAIL: deep angle fallback ${label} expect ${expected}, got ${got}`); failed++; }
+  }
+  const tbsCases: Array<[string, string | undefined]> = [
+    ['day', 'qdr:d'], ['week', 'qdr:w'], ['month', 'qdr:m'], ['year', 'qdr:y'], ['unset', undefined],
+  ];
+  for (const [timeRange, expected] of tbsCases) {
+    const got = firecrawlTbsFromTimeRange(timeRange === 'unset' ? undefined : timeRange);
+    if (got === expected) { console.log(`  PASS: Firecrawl time range ${timeRange} → ${got ?? 'unset'}`); passed++; }
+    else { console.log(`  FAIL: Firecrawl time range ${timeRange} expect ${expected}, got ${got}`); failed++; }
+  }
+
   console.log(`\n결과: ${passed} passed, ${failed} failed`);
   if (failed > 0) process.exit(1);
 }

package/src/acp/agent-manager.ts

@@ -76,6 +76,7 @@ export class AcpAgentManager {
       agent = new CodexAppServerAgent({
         backendId,
         ...opts,
+        remoteSocketPath: process.env.ELANOUS_CODEX_REMOTE_SIDETAB_SOCKET || undefined,
         elicitationHandler: createAskUserElicitationHandler(),
       }) as unknown as AcpAgent;
     } else {

package/src/acp/codex-app-server-agent.ts

@@ -31,6 +31,7 @@
 import {
   CodexAppServerClient,
   spawnCodexAppServer,
+  spawnCodexRemoteTui,
   type SpawnCodexAppServerOpts,
   type SpawnedCodexAppServer,
 } from './codex-app-server-client.js';
@@ -713,6 +714,8 @@ export interface CodexAppServerAgentOpts {
   readonly codexBinary?: string;
   /** Session-scoped argv forwarded to `spawnCodexAppServer`. */
   readonly codexArgs?: readonly string[];
+  /** Explicit opt-in Codex remote side-tab Unix socket path. */
+  readonly remoteSocketPath?: string;
   readonly env?: Record<string, string>;
   readonly log?: (msg: string) => void;
   /** Called after a successful initialize with this backend's advertised capabilities.
@@ -770,6 +773,7 @@ export interface CodexAppServerAgentOpts {
   readonly _spawnFactory?: (
     opts: SpawnCodexAppServerOpts,
   ) => SpawnedCodexAppServer;
+  readonly _remoteTuiSpawnForTesting?: typeof spawnCodexRemoteTui;
 }
 
 export class CodexAppServerAgent {
@@ -777,12 +781,14 @@ export class CodexAppServerAgent {
   private readonly cwd?: string;
   private readonly codexBinary?: string;
   private readonly codexArgs?: readonly string[];
+  private readonly remoteSocketPath?: string;
   private readonly env?: Record<string, string>;
   private readonly log: (msg: string) => void;
   private readonly onCapabilities: ((capabilities: ElanousCapabilities) => void) | undefined;
 
   private client: CodexAppServerClient | null;
   private child: SpawnedCodexAppServer['child'] | null = null;
+  private remoteTuiChild: ReturnType<typeof spawnCodexRemoteTui> | null = null;
   private initialized = false;
 
   private readonly approvalAdapter: CodexApprovalAdapter;
@@ -877,12 +883,14 @@ export class CodexAppServerAgent {
   private readonly _spawnFactory:
     | ((opts: SpawnCodexAppServerOpts) => SpawnedCodexAppServer)
     | undefined;
+  private readonly _remoteTuiSpawnForTesting: typeof spawnCodexRemoteTui | undefined;
 
   constructor(opts: CodexAppServerAgentOpts) {
     this.backendId = opts.backendId;
     this.cwd = opts.cwd;
     this.codexBinary = opts.codexBinary;
     this.codexArgs = opts.codexArgs ? [...opts.codexArgs] : undefined;
+    this.remoteSocketPath = opts.remoteSocketPath;
     this.env = opts.env;
     this.log = opts.log ?? ((msg) => debug.log('acp.cxn.appserver.agent', msg));
     this.onCapabilities = opts.onCapabilities;
@@ -894,6 +902,7 @@ export class CodexAppServerAgent {
     this.imageTempDir = opts.imageTempDir ?? defaultImageTempDir();
     this._clientForTesting = opts._clientForTesting;
     this._spawnFactory = opts._spawnFactory;
+    this._remoteTuiSpawnForTesting = opts._remoteTuiSpawnForTesting;
     this.threadIndex = opts._threadIndexForTesting ?? globalCasThreadIndex();
     // M6 · idle hibernate config. Env override only applies when opts
     // didn't set it explicitly so tests can pin a value regardless of
@@ -979,6 +988,7 @@ export class CodexAppServerAgent {
         env: { ...rotatedCodexChildEnv(childEnv), ...(this.env ?? {}) },
         codexBinary,
         codexArgs: this.codexArgs,
+        remoteSocketPath: this.remoteSocketPath,
       };
       const spawned = spawnFn(spawnOpts);
       this.client = spawned.client;
@@ -1069,6 +1079,13 @@ export class CodexAppServerAgent {
         /* swallow */
       }
     }
+    if (this.remoteTuiChild) {
+      try {
+        this.remoteTuiChild.kill('SIGTERM');
+      } catch {
+        /* swallow */
+      }
+    }
     if (this.child) {
       try {
         this.child.kill('SIGTERM');
@@ -1078,6 +1095,7 @@ export class CodexAppServerAgent {
     }
     this.client = null;
     this.child = null;
+    this.remoteTuiChild = null;
     this.initialized = false;
     this.sessionToThread.clear();
     this.threadToSession.clear();
@@ -1110,6 +1128,7 @@ export class CodexAppServerAgent {
    *  disabled. unref() so a CLI can still exit cleanly when the daemon
    *  is the only thing keeping the loop alive. */
   private armIdleTimer(): void {
+    if (this.remoteSocketPath) return;
     if (this.idleTimerHandle !== null) return;
     if (this.idleTimeoutMs <= 0) return;
     this.idleTimerHandle = setInterval(() => {
@@ -1328,6 +1347,20 @@ export class CodexAppServerAgent {
     // M6 · brand-new sessions are alive in the current daemon by
     // definition · no thread/resume needed before the first turn.
     this.currentDaemonSessions.add(sessionId);
+    if (this.remoteSocketPath && !this.remoteTuiChild) {
+      const explicitEnv = this.env ?? {};
+      const tuiEnv = {
+        ...rotatedCodexChildEnv({ ...process.env, ...explicitEnv }),
+        ...explicitEnv,
+      };
+      const spawnRemoteTui = this._remoteTuiSpawnForTesting ?? spawnCodexRemoteTui;
+      this.remoteTuiChild = spawnRemoteTui({
+        codexBinary: this.codexBinary ?? resolvePreferredCodexBinary(),
+        socketPath: this.remoteSocketPath,
+        cwd: this.cwd,
+        env: tuiEnv,
+      });
+    }
     debug.log('acp.client', 'session-new', { backendId: this.backendId, sessionId });
     return sessionId;
   }