elanous 0.2.38 → 0.2.41

package/src/ux-sim/release-sim-rig.ts

@@ -0,0 +1,262 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { getTestStateRoot } from '../nexus/paths.js';
+import { listGraphRuns, runGraph, type GraphRunState } from '../graph-runner/runner.js';
+import { resolveScenarioFilePath } from './scenario.js';
+
+const REPOSITORY_ROOT = join(import.meta.dir, '../..');
+const RELEASE_GRAPH = join(REPOSITORY_ROOT, 'graphs/release/release-loop.yaml');
+const CUT_TIP = 'a'.repeat(40);
+
+export interface ReleaseSimRigCase {
+  id: string;
+  mode?: 'baseline' | 'cut-tip-moved-after-resume';
+  fault?: { node: string; outcome: 'fail' | 'error' | 'timeout'; evidence?: Record<string, unknown> };
+  expect: { status: 'done' | 'failed' | 'resume-refused'; mustVisit: string[]; mustNotVisit: string[] };
+}
+
+export interface ReleaseSimRigScenario {
+  version: 1;
+  kind: 'release-graph';
+  id: string;
+  isolation: 'test';
+  input: { version: string; previousVersion: string };
+  cases: ReleaseSimRigCase[];
+}
+
+export interface ReleaseSimRigCaseResult {
+  id: string;
+  pass: boolean;
+  status: string;
+  path: string[];
+  dispatchedNodes: string[];
+  unexpectedEdges: Array<{ from: string; to: string; outcome: string; expectedTo?: string }>;
+  checks: { status: boolean; mustVisit: boolean; mustNotVisit: boolean; ledgerEvents: boolean };
+  injectedEvidence: Record<string, unknown>;
+  ledgerEvents: Array<Record<string, unknown>>;
+  statePath: string;
+  refusal?: string;
+}
+
+function unexpectedEdges(path: string[], state: GraphRunState, edges: Map<string, Record<string, unknown>>): ReleaseSimRigCaseResult['unexpectedEdges'] {
+  const nodes = new Map(state.nodes.map((node) => [node.nodeId, node]));
+  const issues: ReleaseSimRigCaseResult['unexpectedEdges'] = [];
+  for (let index = 0; index + 1 < path.length; index++) {
+    const from = path[index]!;
+    const to = path[index + 1]!;
+    const edge = edges.get(from);
+    const output = nodes.get(from)?.output;
+    let parsed: Record<string, unknown> = {};
+    if (typeof output === 'string') {
+      try { parsed = record(JSON.parse(output.trim().split('\n').at(-1) ?? ''), `${from} output`); } catch { /* use runner fallback below */ }
+    } else if (output && typeof output === 'object' && !Array.isArray(output)) parsed = output as Record<string, unknown>;
+    const named = typeof parsed.outcome === 'string' ? parsed.outcome : nodes.get(from)?.ok ? 'ok' : 'fail';
+    const map = edge?.map && typeof edge.map === 'object' ? edge.map as Record<string, unknown> : {};
+    const expectedTo = typeof map[named] === 'string' ? map[named] as string : typeof map[named === 'ok' ? 'ok' : 'fail'] === 'string'
+      ? map[named === 'ok' ? 'ok' : 'fail'] as string : undefined;
+    if (expectedTo !== to) issues.push({ from, to, outcome: named, ...(expectedTo ? { expectedTo } : {}) });
+  }
+  return issues;
+}
+
+function recordObservedEdges(path: string[], events: Array<Record<string, unknown>>): void {
+  for (let index = 0; index + 1 < path.length; index++) {
+    events.push({ event: 'edge-observed', from: path[index], to: path[index + 1], source: 'release-run-path' });
+  }
+}
+
+export interface ReleaseSimRigResult {
+  id: string;
+  pass: boolean;
+  universe: string;
+  cases: ReleaseSimRigCaseResult[];
+  table: Array<{ scenario: string; path: string; status: string; unexpectedEdges: string }>;
+  artifactPath: string;
+}
+
+function record(value: unknown, where: string): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${where} must be an object`);
+  return value as Record<string, unknown>;
+}
+
+function exactKeys(value: Record<string, unknown>, allowed: readonly string[], where: string): void {
+  const extra = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extra.length) throw new Error(`${where} has unsupported key(s): ${extra.join(', ')}`);
+}
+
+function stringList(value: unknown, where: string): string[] {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== 'string' || item.trim() === '')) {
+    throw new Error(`${where} must be an array of non-empty strings`);
+  }
+  return value as string[];
+}
+
+function releaseGraphShape(): { nodeIds: Set<string>; edges: Map<string, Record<string, unknown>> } {
+  const graph = record(parseYaml(readFileSync(RELEASE_GRAPH, 'utf8')), 'release graph');
+  if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) throw new Error('release graph nodes or edges missing');
+  const nodeIds = new Set(graph.nodes.map((value) => record(value, 'release graph node').node_id)
+    .filter((id): id is string => typeof id === 'string'));
+  const edges = new Map<string, Record<string, unknown>>();
+  for (const raw of graph.edges) {
+    const edge = record(raw, 'release edge');
+    if (typeof edge.from !== 'string' || edge.on !== 'outcome' || !edge.map || typeof edge.map !== 'object') {
+      throw new Error('release simulation requires outcome edges with explicit maps');
+    }
+    if (edges.has(edge.from)) throw new Error(`release graph has multiple outcome edges from ${edge.from}`);
+    edges.set(edge.from, edge);
+  }
+  return { nodeIds, edges };
+}
+
+export function parseReleaseSimRigScenario(source: string): ReleaseSimRigScenario {
+  const root = record(parseYaml(source), 'release simulation scenario');
+  exactKeys(root, ['version', 'kind', 'id', 'isolation', 'input', 'cases'], 'release simulation scenario');
+  if (root.version !== 1 || root.kind !== 'release-graph' || root.isolation !== 'test') {
+    throw new Error('release simulation scenario requires version: 1, kind: release-graph, isolation: test');
+  }
+  if (typeof root.id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(root.id)) throw new Error('scenario.id must be lowercase letters, digits, and hyphens');
+  const input = record(root.input, 'scenario.input');
+  exactKeys(input, ['version', 'previousVersion'], 'scenario.input');
+  if (typeof input.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.version)
+    || typeof input.previousVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.previousVersion)) {
+    throw new Error('scenario.input requires release version and previousVersion');
+  }
+  const rawCases = root.cases;
+  if (!Array.isArray(rawCases) || rawCases.length === 0 || rawCases.length > 32) throw new Error('scenario.cases must contain 1–32 cases');
+  const { nodeIds } = releaseGraphShape();
+  const ids = new Set<string>();
+  const cases = rawCases.map((raw, index): ReleaseSimRigCase => {
+    const row = record(raw, `scenario.cases[${index}]`);
+    exactKeys(row, ['id', 'mode', 'fault', 'expect'], `scenario.cases[${index}]`);
+    if (typeof row.id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(row.id) || ids.has(row.id)) throw new Error(`scenario.cases[${index}].id must be unique lowercase text`);
+    ids.add(row.id);
+    let mode: ReleaseSimRigCase['mode'];
+    if (row.mode !== undefined) {
+      if (row.mode !== 'baseline' && row.mode !== 'cut-tip-moved-after-resume') throw new Error(`scenario.cases[${index}].mode is unregistered`);
+      mode = row.mode;
+    }
+    let fault: ReleaseSimRigCase['fault'];
+    if (row.fault !== undefined) {
+      const parsed = record(row.fault, `scenario.cases[${index}].fault`);
+      exactKeys(parsed, ['node', 'outcome', 'evidence'], `scenario.cases[${index}].fault`);
+      if (typeof parsed.node !== 'string' || !nodeIds.has(parsed.node)) throw new Error(`scenario.cases[${index}].fault.node is not in the release graph`);
+      if (parsed.outcome !== 'fail' && parsed.outcome !== 'error' && parsed.outcome !== 'timeout') throw new Error(`scenario.cases[${index}].fault.outcome is unregistered`);
+      fault = { node: parsed.node, outcome: parsed.outcome, ...(parsed.evidence === undefined ? {} : { evidence: record(parsed.evidence, `scenario.cases[${index}].fault.evidence`) }) };
+    }
+    if ((mode === undefined) === (fault === undefined)) throw new Error(`scenario.cases[${index}] requires exactly one of mode or fault`);
+    const expected = record(row.expect, `scenario.cases[${index}].expect`);
+    exactKeys(expected, ['status', 'mustVisit', 'mustNotVisit'], `scenario.cases[${index}].expect`);
+    if (expected.status !== 'done' && expected.status !== 'failed' && expected.status !== 'resume-refused') throw new Error(`scenario.cases[${index}].expect.status is invalid`);
+    const mustVisit = stringList(expected.mustVisit, `scenario.cases[${index}].expect.mustVisit`);
+    const mustNotVisit = stringList(expected.mustNotVisit, `scenario.cases[${index}].expect.mustNotVisit`);
+    for (const id of [...mustVisit, ...mustNotVisit]) if (!nodeIds.has(id)) throw new Error(`scenario.cases[${index}] names unknown release node ${id}`);
+    if (mustVisit.some((id) => mustNotVisit.includes(id))) throw new Error(`scenario.cases[${index}] visits and excludes the same node`);
+    return { id: row.id, ...(mode ? { mode } : {}), ...(fault ? { fault } : {}), expect: { status: expected.status, mustVisit, mustNotVisit } };
+  });
+  return { version: 1, kind: 'release-graph', id: root.id, isolation: 'test',
+    input: { version: input.version, previousVersion: input.previousVersion }, cases };
+}
+
+function parseContext(env: NodeJS.ProcessEnv): { nodeId: string } {
+  const location = env.ELANOUS_GRAPH_CONTEXT;
+  if (!location) throw new Error('ELANOUS_GRAPH_CONTEXT missing in release simulation');
+  const context = record(JSON.parse(readFileSync(location, 'utf8')), 'release graph context');
+  if (typeof context.nodeId !== 'string') throw new Error('release graph context nodeId missing');
+  return { nodeId: context.nodeId };
+}
+
+function resultForNode(nodeId: string, fault: ReleaseSimRigCase['fault'], version: string): { exitCode: number; stdout: string; stderr: string; evidence: Record<string, unknown> } {
+  const triggeredFault = fault?.node === nodeId ? fault : undefined;
+  const outcome = triggeredFault ? triggeredFault.outcome === 'timeout' ? 'error' : triggeredFault.outcome : 'ok';
+  const evidence = triggeredFault?.evidence ?? {};
+  const commit = nodeId === 'version-release' ? { commit: CUT_TIP, tag: `v${version}` } : {};
+  const payload = { outcome, verdict: outcome === 'ok' ? 'pass' : 'fail', summary: triggeredFault ? `simulated ${triggeredFault.outcome}` : `simulated ${nodeId} success`, ...commit,
+    simulation: { injected: triggeredFault !== undefined, node: nodeId, evidence } };
+  return { exitCode: !triggeredFault ? 0 : triggeredFault.outcome === 'fail' ? 1 : triggeredFault.outcome === 'timeout' ? 124 : 2,
+    stdout: `${JSON.stringify(payload)}\n`, stderr: triggeredFault ? `SIMULATED_${triggeredFault.outcome.toUpperCase()}` : '', evidence };
+}
+
+async function runCase(scenario: ReleaseSimRigScenario, item: ReleaseSimRigCase, root: string,
+  edges: Map<string, Record<string, unknown>>): Promise<ReleaseSimRigCaseResult> {
+  const runId = `release-sim-${scenario.id}-${item.id}`;
+  const ledgerEvents: Array<Record<string, unknown>> = [];
+  const dispatchedNodes: string[] = [];
+  const runBash = async (command: string, options: { env?: NodeJS.ProcessEnv }) => {
+    const { nodeId } = parseContext(options.env ?? {});
+    if (!command.trim()) throw new Error(`empty command at simulated node ${nodeId}`);
+    dispatchedNodes.push(nodeId);
+    const result = resultForNode(nodeId, item.fault, scenario.input.version);
+    return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
+  };
+  const capture = (event: string, data: Record<string, unknown>) => ledgerEvents.push({ event, ...data });
+
+  if (item.mode === 'cut-tip-moved-after-resume') {
+    let beforeNode = 0;
+    const simulatedStop = new Error('simulated runner stop after cut');
+    try {
+      await runGraph(RELEASE_GRAPH, { runId, input: scenario.input, pinChildUniverse: true, quiet: true,
+        deps: { root, runBash, log: capture, beforeNode: () => { if (++beforeNode === 2) throw simulatedStop; } } });
+    } catch (error) {
+      if (error !== simulatedStop) throw error;
+    }
+    let refusal = '';
+    try {
+      await runGraph(RELEASE_GRAPH, { resumeRunId: runId, pinChildUniverse: true, quiet: true,
+        releaseCommandSource: { root: REPOSITORY_ROOT, cutTip: 'b'.repeat(40), git: () => { throw new Error('git must not be consulted after the saved tip differs'); } },
+        deps: { root, runBash, log: capture } });
+    } catch (error) { refusal = error instanceof Error ? error.message : String(error); }
+    const interrupted = listGraphRuns(root).runs.find((run) => run.runId === runId);
+    const stateFile = interrupted?.statePath ?? '';
+    const path = interrupted?.path ?? [];
+    recordObservedEdges(path, ledgerEvents);
+    const edgeIssues = interrupted ? unexpectedEdges(path, interrupted, edges) : [];
+    const statusOk = item.expect.status === 'resume-refused' && refusal.includes('release command source differs from the saved cut tip');
+    const visitOk = item.expect.mustVisit.every((id) => path.includes(id));
+    const notVisitOk = item.expect.mustNotVisit.every((id) => !path.includes(id));
+    const ledgerOk = ledgerEvents.some((row) => row.event === 'node-end')
+      && ledgerEvents.filter((row) => row.event === 'edge-observed').length === Math.max(0, path.length - 1);
+    return { id: item.id, pass: statusOk && visitOk && notVisitOk && ledgerOk && edgeIssues.length === 0, status: statusOk ? 'resume-refused' : interrupted?.status ?? 'missing',
+      path, dispatchedNodes, unexpectedEdges: edgeIssues, checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, ledgerEvents: ledgerOk }, injectedEvidence: {}, ledgerEvents,
+      statePath: stateFile, ...(refusal ? { refusal } : {}) };
+  }
+
+  // Initial runs have no releaseCommandSource (the runner only accepts it on resume); all node shell work is intercepted here.
+  const state = await runGraph(RELEASE_GRAPH, { runId, input: scenario.input, pinChildUniverse: true, quiet: true,
+    deps: { root, runBash, log: capture } });
+  const path = state.path;
+  recordObservedEdges(path, ledgerEvents);
+  const edgeIssues = unexpectedEdges(path, state, edges);
+  const statusOk = state.status === item.expect.status;
+  const visitOk = item.expect.mustVisit.every((id) => path.includes(id));
+  const notVisitOk = item.expect.mustNotVisit.every((id) => !path.includes(id));
+  const ledgerOk = ledgerEvents.some((row) => row.event === 'node-start') && ledgerEvents.some((row) => row.event === 'node-end')
+    && ledgerEvents.filter((row) => row.event === 'edge-observed').length === Math.max(0, path.length - 1);
+  const injectedEvidence = item.fault ? item.fault.evidence ?? {} : {};
+  return { id: item.id, pass: statusOk && visitOk && notVisitOk && ledgerOk && edgeIssues.length === 0, status: state.status, path, dispatchedNodes, unexpectedEdges: edgeIssues,
+    checks: { status: statusOk, mustVisit: visitOk, mustNotVisit: notVisitOk, ledgerEvents: ledgerOk }, injectedEvidence,
+    ledgerEvents, statePath: state.statePath };
+}
+
+export async function runReleaseSimRigScenario(source: string): Promise<ReleaseSimRigResult> {
+  const scenario = parseReleaseSimRigScenario(source);
+  const root = getTestStateRoot();
+  if (!root) throw new Error('release simulation rig requires --test isolated mode');
+  const { edges } = releaseGraphShape();
+  const cases = [];
+  for (const item of scenario.cases) cases.push(await runCase(scenario, item, root, edges));
+  const result: ReleaseSimRigResult = { id: scenario.id, pass: cases.every((item) => item.pass), universe: root, cases,
+    table: cases.map((item) => ({ scenario: item.id, path: item.path.join(' → '), status: item.status,
+      unexpectedEdges: item.unexpectedEdges.length ? JSON.stringify(item.unexpectedEdges) : 'none' })),
+    artifactPath: join(root, 'ux-sim', 'evidence', `${scenario.id}.json`) };
+  mkdirSync(join(root, 'ux-sim', 'evidence'), { recursive: true });
+  writeFileSync(result.artifactPath, `${JSON.stringify(result, null, 2)}\n`, { mode: 0o600 });
+  return result;
+}
+
+export async function runReleaseSimRigIfFile(filePath: string): Promise<ReleaseSimRigResult | null> {
+  const source = readFileSync(resolveScenarioFilePath(filePath), 'utf8');
+  if (record(parseYaml(source), 'scenario').kind !== 'release-graph') return null;
+  if (!getTestStateRoot()) throw new Error('release simulation rig requires --test isolated mode');
+  return runReleaseSimRigScenario(source);
+}

package/src/ux-sim/seminar-rehearsal.ts

@@ -0,0 +1,109 @@
+/**
+ * Simulate the 40-minute, seven-scene seminar rehearsal protocol.
+ *
+ * This checks timing, evidence completeness, fallback, and disclosure guards
+ * with injected records. It never claims that a real rehearsal or device run
+ * took place.
+ */
+// Targets mirror RUNBOOK-1027-seminar-smart-wizard-demo-2026-10-24.md; the test
+// parses that table so edits to the runbook cannot silently drift from this rig.
+export const SEMINAR_SCENES = [
+  { id: 1, name: 'hook', targetMinutes: 3 },
+  { id: 2, name: 'problem', targetMinutes: 5 },
+  { id: 3, name: 'AI executive', targetMinutes: 8 },
+  { id: 4, name: 'development demo', targetMinutes: 8 },
+  { id: 5, name: 'two phones', targetMinutes: 8 },
+  { id: 6, name: 'transit demo', targetMinutes: 4 },
+  { id: 7, name: 'close', targetMinutes: 4 },
+] as const;
+
+export type SeminarSceneId = (typeof SEMINAR_SCENES)[number]['id'];
+export type SeminarOutcome = 'pass' | 'fail' | 'unknown';
+
+export interface SeminarSceneRecord {
+  readonly scene: SeminarSceneId;
+  readonly elapsedMinutes: number | null;
+  readonly medium: string | null;
+  readonly evidenceId: string | null;
+  readonly outcome: SeminarOutcome;
+  readonly publicSafe: boolean | null;
+  readonly fallbackUsed: boolean | null;
+  readonly offlineFallbackPlayed: boolean | null;
+}
+
+export interface SeminarRehearsalResult {
+  readonly simulated: true;
+  readonly totalTargetMinutes: number;
+  readonly scenes: ReadonlyArray<{
+    scene: SeminarSceneId;
+    name: string;
+    targetMinutes: number;
+    observedMinutes: number | null;
+    verdict: 'pass' | 'fail' | 'unknown';
+    reason: string;
+  }>;
+  readonly verdict: 'pass' | 'fail' | 'unknown';
+}
+
+export function simSeminarRehearsal(records: readonly SeminarSceneRecord[]): SeminarRehearsalResult {
+  const byScene = new Map<SeminarSceneId, SeminarSceneRecord>();
+  for (const record of records) {
+    if (!SEMINAR_SCENES.some((scene) => scene.id === record.scene)) throw new Error(`unknown scene record: ${String(record.scene)}`);
+    if (byScene.has(record.scene)) throw new Error(`duplicate scene record: ${record.scene}`);
+    byScene.set(record.scene, record);
+  }
+
+  const scenes = SEMINAR_SCENES.map((scene) => {
+    const record = byScene.get(scene.id);
+    if (!record || record.elapsedMinutes === null || !record.medium || !record.evidenceId || record.outcome === 'unknown' || record.publicSafe === null || record.fallbackUsed === null || (record.fallbackUsed && record.offlineFallbackPlayed === null)) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record?.elapsedMinutes ?? null, verdict: 'unknown' as const, reason: '실행 기록의 시간·매체·증거·결과·공개 안전 중 미확인 값이 있음' };
+    }
+    if (record.outcome === 'fail') {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '주입된 장면 결과가 fail' };
+    }
+    if (Math.abs(record.elapsedMinutes - scene.targetMinutes) > 1) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: `목표 ${scene.targetMinutes}분에서 ±1분 초과` };
+    }
+    if (!record.publicSafe) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '공개 안전 확인 실패' };
+    }
+    if (record.fallbackUsed && !record.offlineFallbackPlayed) {
+      return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'fail' as const, reason: '대체 경로를 선택했으나 오프라인 매체 재생을 확인하지 못함' };
+    }
+    return { scene: scene.id, name: scene.name, targetMinutes: scene.targetMinutes, observedMinutes: record.elapsedMinutes, verdict: 'pass' as const, reason: record.fallbackUsed ? '오프라인 대체 매체 재생 확인' : '주입된 시나리오 통과' };
+  });
+
+  const verdict = scenes.some((scene) => scene.verdict === 'unknown')
+    ? 'unknown'
+    : scenes.some((scene) => scene.verdict === 'fail')
+      ? 'fail'
+      : 'pass';
+
+  return {
+    simulated: true,
+    totalTargetMinutes: SEMINAR_SCENES.reduce((sum, scene) => sum + scene.targetMinutes, 0),
+    scenes,
+    verdict,
+  };
+}
+
+export function seminarRehearsalSweep(): SeminarRehearsalResult {
+  const records: SeminarSceneRecord[] = SEMINAR_SCENES.map((scene) => ({
+    scene: scene.id,
+    elapsedMinutes: scene.targetMinutes,
+    medium: scene.id === 5 ? 'simulated iPhone + Fold8' : scene.id === 4 ? 'simulated offline video' : 'simulated stage screen',
+    evidenceId: `sim-scene-${scene.id}`,
+    outcome: 'pass',
+    publicSafe: true,
+    fallbackUsed: scene.id === 5,
+    offlineFallbackPlayed: scene.id === 5 ? true : null,
+  }));
+  return simSeminarRehearsal(records);
+}
+
+export function renderSeminarRehearsal(result: SeminarRehearsalResult): string[] {
+  return [
+    `세미나 리허설 · ${result.totalTargetMinutes}분 · ${result.verdict} · sim only (실제 행사 실행 증거 아님)`,
+    ...result.scenes.map((scene) => `  S${scene.scene} ${scene.name.padEnd(18)} ${scene.observedMinutes === null ? '미확인' : `${scene.observedMinutes}분`.padEnd(5)} / 목표 ${scene.targetMinutes}분 · ${scene.verdict} · ${scene.reason}`),
+  ];
+}

package/src/ux-sim/subagent-tools-device.ts

@@ -1,5 +1,5 @@
 // N03 장치 — SUBAGENT-TOOLS-EMPTY (0.2.36 · 2026-10-22 · 대표 P0).
-// 진짜 classic TUI(bare `elanous`) ⊕ fake LLM 이 Agent 도구를 «틀린 이름» tool_filter 로 부른다
+// 진짜 classic TUI(`--legacy`) ⊕ fake LLM 이 Agent 도구를 «틀린 이름» tool_filter 로 부른다
 // (10-22 운영 실물: allow 5~12개를 줘도 49→0 · «0 tools · Blocked»). 판정은 같은 바이너리의 `logs --json`:
 //   mismatch  — allow 가 모르는 이름뿐 → tool-filter allowIgnored ⊕ dispatch noTools=false(도구 상속)
 //   deny-all  — 모든 도구를 deny → no-tools-refused(발사 거부 · 빈손 실행 0)
@@ -33,7 +33,7 @@ export async function runSubagentToolsDevice(spec: SubagentToolsSpec): Promise<S
     : { allow: ['Read'], deny: ['Read'] };
   const run = await mockSeatPtySequence({
     executable: spec.executable,
-    args: [spec.entry, '--config-dir', '{root}', '--test-state-dir', '{root}'],
+    args: [spec.entry, '--legacy', '--config-dir', '{root}', '--test-state-dir', '{root}'],
     root,
     rows: 30,
     cols: 100,

package/src/ux-sim/task-orchestrator-surfaces-self-implement-pod-device.ts

@@ -31,6 +31,8 @@ export interface PodDeviceEvent {
   jobConditionReason?: string;
   jobConditionMessage?: string;
   activeDeadlineSeconds?: number;
+  jobCreatedAt?: string;
+  jobCompletedAt?: string;
   podPhase?: string;
   podCreatedAt?: string;
   containerReason?: string | null;
@@ -86,6 +88,7 @@ export const POD_DEVICE_EVENTS: readonly PodDeviceEvent[] = [
     jobConditionReason: 'DeadlineExceeded',
     jobConditionMessage: 'Job was active longer than specified deadline',
     activeDeadlineSeconds: 3600,
+    jobCreatedAt: '2026-10-22T12:55:10Z',
     podPhase: 'Failed',
     containerReason: 'Error',
     containerExitCode: 143,
@@ -114,7 +117,7 @@ const ok = (stdout: string) => ({ status: 0, stdout, stderr: '' });
 
 function answerJob(event: PodDeviceEvent, jsonpath: string): { status: number; stdout: string; stderr: string } {
   if (jsonpath === POD_TERMINATION_JOB_JSONPATH) {
-    return ok(`${event.jobConditionReason ?? ''}\t${event.activeDeadlineSeconds ?? ''}\t${event.jobUid ?? ''}`);
+    return ok(`${event.jobConditionReason ?? ''}\t${event.activeDeadlineSeconds ?? ''}\t${event.jobUid ?? ''}\t${event.jobCreatedAt ?? ''}\t${event.jobCompletedAt ?? ''}`);
   }
   if (jsonpath.includes('.spec.activeDeadlineSeconds')) return ok(event.activeDeadlineSeconds != null ? String(event.activeDeadlineSeconds) : '');
   if (jsonpath.includes('conditions[?(@.type=="Failed")].reason')) return ok(event.jobConditionReason ?? '');

package/src/version/packed-revision.json

@@ -1 +1 @@
-{"commit":"a78f3f66a3db5de0bce1342c99d3c4abc0a96f45"}
+{"commit":"479072f6639b631e74d2a88a4e2f982193e00f89"}

package/src/video-pipeline/recipes/explainer.ts

@@ -1,13 +1,16 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync } from 'node:fs';
 import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { parse as parseYaml } from 'yaml';
 import type { RunResult } from './ffmpeg.js';
 import { UNOBSERVED, type Recipe, type RecipeCtx, type RecipeResult } from './types.js';
+import { parseGraphTemplateYaml, type GraphParseIssue, type GraphTemplateSpec } from '../../self-implement/graph-yaml.js';
 
 type CommandRunner = (bin: string, args: readonly string[], timeoutMs: number, cwd?: string) => RunResult;
-interface ExplainerDeps { readonly run?: CommandRunner; readonly engineDir?: string }
+interface ExplainerDeps { readonly run?: CommandRunner; readonly engineDir?: string; readonly declarationPath?: string }
 
 const ENGINE = resolve(import.meta.dir, '../../../skills/explainer-video/engine');
+const LINE_DECLARATION = resolve(import.meta.dir, '../../../graphs/video/explainer-line.yaml');
 const ENGINE_MS = 600_000;
 const QC_MS = 180_000;
 
@@ -199,7 +202,19 @@ export function explainerQc(deps: ExplainerDeps = {}): Recipe {
       const peak = Number(j.input_tp);
       if (j.input_i == null || j.input_tp == null || !Number.isFinite(loudness) || !Number.isFinite(peak)) throw new Error('통합 음량/트루 피크가 비수다');
       const produced = { loudness_lufs: loudness, true_peak_db: peak };
-      const outcome = loudness >= -16 && loudness <= -12 && peak <= -1 ? 'pass' : 'loudness';
+      let outcome = loudness >= -16 && loudness <= -12 && peak <= -1 ? 'pass' : 'loudness';
+      // ⭐ «3분 영상» — qc 생산 경로에서 loadExplainerLine 으로 선언의 target_seconds(180)를 소비한다.
+      // 내레이션이 목표 총 길이를 넘으면 too-long → build(재구성). narration_seconds 를 못 쟀으면 건너뛴다(기존 동작 보존).
+      const narrationSeconds = ctx.state.narration_seconds;
+      if (outcome === 'pass' && typeof narrationSeconds === 'number' && Number.isFinite(narrationSeconds)) {
+        const plan = loadExplainerLine(deps.declarationPath);
+        if (plan.targetSeconds !== null && narrationSeconds > plan.targetSeconds) {
+          return finish(ctx, 'qc', {
+            outcome: 'too-long', produced,
+            note: `${Math.round(narrationSeconds)}초 내레이션이 선언 목표 ${plan.targetSeconds}초를 넘는다 — build 로 재구성한다`,
+          });
+        }
+      }
       return finish(ctx, 'qc', { outcome, produced, note: `${loudness} LUFS · ${peak} dBTP` });
     } catch (e) { return finish(ctx, 'qc', { outcome: UNOBSERVED, note: `loudnorm 결과를 못 읽었다: ${String(e)}` }); }
   };
@@ -211,3 +226,40 @@ export const EXPLAINER: Readonly<Record<string, Recipe>> = {
   'explainer-build': explainerBuild(),
   'explainer-qc': explainerQc(),
 };
+
+/** ⭐ «3분 영상» — explainer-line 선언이 이 라인의 영상 계획에 건 목표 총 길이(초). */
+export interface ExplainerLinePlan {
+  /** 지속 필드 `target_seconds`(초). 선언에 없으면 이 라인은 목표 총 길이를 정하지 않았다(null). */
+  readonly targetSeconds: number | null;
+  /** 생산 컴파일러(parseGraphTemplateYaml)가 낸 정규형 — 나머지 선언(노드·계약·엣지)은 이것으로 관측한다. */
+  readonly template: GraphTemplateSpec | null;
+  readonly errors: readonly GraphParseIssue[];
+}
+
+/** ⭐ 생산 로드 — 라인 저작본(graphs/video/explainer-line.yaml)을 읽어 영상 계획을 낸다.
+ *  컴파일러는 top-level 계획 상수를 정규형에 싣지 않는다 — 지속 필드 `target_seconds` 는 로드에서 직접 읽는다.
+ *  ⛔ 던지지 않는다(graph-yaml 계약) · 뿌리는 인자로 덮는다(ENGINE 과 같은 관습). */
+export function loadExplainerLine(declarationPath = LINE_DECLARATION): ExplainerLinePlan {
+  let source: string;
+  try {
+    source = readFileSync(declarationPath, 'utf8');
+  } catch (error) {
+    return {
+      targetSeconds: null,
+      template: null,
+      errors: [{ path: declarationPath, message: `선언 읽기 실패: ${error instanceof Error ? error.message : String(error)}` }],
+    };
+  }
+  const compiled = parseGraphTemplateYaml(source, 'explainer-line.yaml');
+  let targetSeconds: number | null = null;
+  try {
+    const raw: unknown = parseYaml(source);
+    const declared = raw !== null && typeof raw === 'object' && !Array.isArray(raw)
+      ? (raw as Record<string, unknown>).target_seconds
+      : undefined;
+    if (typeof declared === 'number' && Number.isFinite(declared) && declared > 0) targetSeconds = declared;
+  } catch {
+    // YAML 파싱 실패는 컴파일 결과(errors)가 이미 싣는다 — 로드는 던지지 않는다.
+  }
+  return { targetSeconds, template: compiled.template ?? null, errors: compiled.errors };
+}

package/src/web-search/grok.ts

@@ -18,18 +18,43 @@
 //     custom MCP provider without touching skill bodies.
 
 import { getGrokApiKey } from '../config.js';
-import { grokAgentSearch, GROK_SEARCH_MODEL } from '../grok/agent-search.js';
+import { grokAgentSearch, GROK_SEARCH_MODEL, type GrokAgentSearchOpts } from '../grok/agent-search.js';
+import { peekGrokCredential, resolveFreshGrokCredential } from '../grok/credential.js';
 import { wantsXSearch } from './x-intent.js';
 import type { WebSearchHit, WebSearchProvider, WebSearchResult } from './provider.js';
 
 const DEFAULT_LIMIT = 5;
 const GROK_TIMEOUT_MS = 45_000;
+// The subscription proxy's known working model differs from the metered API default.
+const GROK_SUBSCRIPTION_SEARCH_MODEL = 'grok-4.6';
 
-export function buildGrokWebSearchProvider(): WebSearchProvider {
+/** Explicitly metered API provider. The registry only adds it with webSearch.grokApi.enabled. */
+export function buildGrokWebSearchProvider(opts: { id?: string } = {}): WebSearchProvider {
+  return makeGrokProvider(opts.id ?? 'grok', 'Grok (xAI agent-tools search)',
+    () => !!getGrokApiKey(), () => ({}));
+}
+
+/** Subscription search uses the proven cli-chat-proxy /responses route. No API-key fallback. */
+export function buildGrokSubscriptionWebSearchProvider(): WebSearchProvider {
+  return makeGrokProvider('grok', 'Grok (subscription search)',
+    () => peekGrokCredential({ model: GROK_SUBSCRIPTION_SEARCH_MODEL })?.kind === 'subscription',
+    () => {
+      const credential = resolveFreshGrokCredential({ model: GROK_SUBSCRIPTION_SEARCH_MODEL });
+      if (credential?.kind !== 'subscription') throw new Error('Grok subscription search unavailable');
+      return { apiKey: credential.token, baseUrl: credential.baseUrl, headers: credential.headers, model: GROK_SUBSCRIPTION_SEARCH_MODEL };
+    });
+}
+
+function makeGrokProvider(
+  id: string,
+  displayName: string,
+  available: () => boolean,
+  searchOptions: () => GrokAgentSearchOpts,
+): WebSearchProvider {
   return {
-    id: 'grok',
-    displayName: 'Grok (xAI agent-tools search)',
-    available: () => !!getGrokApiKey(),
+    id,
+    displayName,
+    available,
     search: async (q, signal) => {
       const startedAt = Date.now();
       const limit = Math.max(1, Math.min(20, q.limit ?? DEFAULT_LIMIT));
@@ -45,6 +70,7 @@ export function buildGrokWebSearchProvider(): WebSearchProvider {
 
       const r = await grokAgentSearch(query, {
         model: GROK_SEARCH_MODEL,
+        ...searchOptions(),
         tools: ['web_search', 'x_search'],
         systemPrompt: 'You are a concise web-search assistant. Answer in one or two sentences and let the cited sources carry the detail.',
         timeoutMs: GROK_TIMEOUT_MS,
@@ -67,7 +93,7 @@ export function buildGrokWebSearchProvider(): WebSearchProvider {
       const note = r.text.length > 0 ? r.text.slice(0, 1500) : undefined;
       return {
         hits,
-        providerName: 'grok',
+        providerName: id,
         durationMs: Date.now() - startedAt,
         ...(note ? { note } : {}),
       } satisfies WebSearchResult;

package/src/web-search/index.ts

@@ -5,11 +5,11 @@
 // order) and routes the query. Callers that want a specific
 // provider pass `providerId` to force the choice.
 
-import { buildGrokWebSearchProvider } from './grok.js';
+import { buildGrokSubscriptionWebSearchProvider, buildGrokWebSearchProvider } from './grok.js';
 import { buildFirecrawlWebSearchProvider } from './firecrawl.js';
 import { buildTavilyWebSearchProvider } from './tavily.js';
 import { buildFreeWebSearchProvider } from './free.js';
-import { isTavilySearchEnabled } from '../user-config.js';
+import { isPaidWebSearchEnabled, isTavilySearchEnabled } from '../user-config.js';
 import { debug } from '../debug/log.js';
 import { wantsXSearch } from './x-intent.js';
 import {
@@ -35,8 +35,9 @@ function registerBuiltins(): void {
   //   ⇒ 켜면 종전과 «똑같이» 1순위로 복귀한다: `elanous config set webSearch.tavily.enabled true`.
   //   ⚠️ 등록 시점이라 config 변경은 **다음 기동부터** 먹는다(이미 뜬 프로세스엔 안 먹는다).
   if (isTavilySearchEnabled()) providers.push(buildTavilyWebSearchProvider());
-  providers.push(buildGrokWebSearchProvider());
-  providers.push(buildFirecrawlWebSearchProvider());
+  providers.push(buildGrokSubscriptionWebSearchProvider());
+  if (isPaidWebSearchEnabled('grokApi')) providers.push(buildGrokWebSearchProvider({ id: 'grok-api' }));
+  if (isPaidWebSearchEnabled('firecrawl')) providers.push(buildFirecrawlWebSearchProvider());
   providers.push(buildFreeWebSearchProvider());
 }
 registerBuiltins();
@@ -70,10 +71,10 @@ export async function searchWeb(
 ): Promise<WebSearchResult> {
   const xIntent = !opts.providerId && wantsXSearch(q.query);
   const candidates = opts.providerId
-    ? providers.filter(p => p.id === opts.providerId)
+    ? providers.filter(p => p.id === opts.providerId || (opts.providerId === 'grok' && p.id === 'grok-api'))
     : providers.filter(p => p.available());
   if (xIntent) {
-    const grokIndex = candidates.findIndex(p => p.id === 'grok');
+    const grokIndex = candidates.findIndex(p => p.id === 'grok' || p.id === 'grok-api');
     if (grokIndex > 0) candidates.unshift(...candidates.splice(grokIndex, 1));
   }
   if (candidates.length === 0) {
@@ -91,7 +92,7 @@ export async function searchWeb(
     try {
       const result = await provider.search(q, opts.signal);
       if (!xIntent) return result;
-      if (provider.id === 'grok') {
+      if (provider.id === 'grok' || provider.id === 'grok-api') {
         const isXUrl = (raw: string): boolean => {
           try {
             const url = new URL(raw);