elanous 0.2.41 → 0.2.43

package/scripts/demo/demo1104-parallel-scenes.ts

@@ -0,0 +1,301 @@
+import { DEMO1104_STAGE_CONFIG, type DemoActId, type DemoLaneId } from './demo1104-stage.config.js';
+import { createDemoStageConsole, type StageSnapshot } from './demo1104-stage.js';
+import { appendFileSync, chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { handleGraphRunRoute, type GraphRunView } from '../../src/graph-runner/graph-run-api.js';
+import { runGraph, type GraphRunOptions } from '../../src/graph-runner/runner.js';
+import { appendTopicBriefingTelegramDryRun, deliverTopicBriefingWithReceipts } from '../../src/intake-plane/actions.js';
+import type { BriefItem } from '../../src/briefing/brief-items.js';
+import { spawnCodingAgent } from '../../src/terminal/coding-agent.js';
+import type { TerminalSession, TerminalSessionRegistry } from '../../src/terminal/session-registry.js';
+
+export const DEMO1104_SURFACES = [
+  { id: 'claude-code-tui', lane: 'maker', title: 'Claude Code TUI' },
+  { id: 'codex-tui', lane: 'maker', title: 'Codex TUI' },
+  { id: 'web-run-graph', lane: 'secretary', title: '웹 실행 그래프' },
+  { id: 'telegram', lane: 'secretary', title: 'Telegram (dry-run)' },
+] as const;
+
+export type DemoSurfaceId = typeof DEMO1104_SURFACES[number]['id'];
+export type DemoSurfaceAdapter = {
+  start(signal: AbortSignal): Promise<void>;
+  runAct(act: typeof DEMO1104_STAGE_CONFIG.acts[number], signal: AbortSignal): Promise<void>;
+  showVideo(videoId: string, act: typeof DEMO1104_STAGE_CONFIG.acts[number], signal: AbortSignal): Promise<void>;
+};
+
+export type DemoVideoTransition = { videoId: string; source: string; actId: typeof DEMO1104_STAGE_CONFIG.acts[number]['id']; title: string };
+
+function videoTransition(videoId: string, act: typeof DEMO1104_STAGE_CONFIG.acts[number], sources: Readonly<Record<string, string>>): DemoVideoTransition {
+  const source = sources[videoId]?.trim();
+  if (!source) throw new Error(`highlight video source is missing: ${videoId}`);
+  return { videoId, source, actId: act.id, title: act.title };
+}
+
+function writeTelegramVideoDryRun(file: string, linearIssueId: string, transition: DemoVideoTransition): void {
+  appendFileSync(file, `${JSON.stringify({ recordedAt: new Date().toISOString(), linearIssueId, kind: 'video', ...transition })}\n`, { encoding: 'utf8', mode: 0o600 });
+  chmodSync(file, 0o600);
+}
+
+export type DemoTerminalTabAdapters = Pick<Record<DemoSurfaceId, DemoSurfaceAdapter>, 'claude-code-tui' | 'codex-tui'>;
+
+/** Uses the existing dashboard session registry and spawnCodingAgent → TerminalSessionRegistry.spawn path. */
+export function createDemo1104TuiTabAdapters(options: {
+  registry: TerminalSessionRegistry;
+  cwd: string;
+  termSize: () => { cols: number; rows: number };
+  runMission: (session: TerminalSession, act: typeof DEMO1104_STAGE_CONFIG.acts[number], signal: AbortSignal) => Promise<void>;
+  showVideo: (session: TerminalSession, transition: DemoVideoTransition, signal: AbortSignal) => Promise<void> | void;
+  videoSources: Readonly<Record<string, string>>;
+  spawnAgent?: typeof spawnCodingAgent;
+}): DemoTerminalTabAdapters {
+  const sessions = new Map<'claude-code-tui' | 'codex-tui', TerminalSession>();
+  const create = (id: 'claude-code-tui' | 'codex-tui', brand: 'claude-code' | 'codex'): DemoSurfaceAdapter => ({
+    async start(signal) {
+      if (signal.aborted) throw new Error(`${id} startup cancelled`);
+      const size = options.termSize();
+      const session = (options.spawnAgent ?? spawnCodingAgent)(
+        { brand, cwd: options.cwd, title: `11-04 demo · ${brand}` },
+        { registry: options.registry, termCols: size.cols, termRows: size.rows },
+      );
+      sessions.set(id, session);
+    },
+    async runAct(act, signal) {
+      if (act.id !== 'act-2' && act.id !== 'act-5') return;
+      const session = sessions.get(id);
+      if (!session) throw new Error(`${id} session was not started`);
+      if (signal.aborted) throw new Error(`${id} mission cancelled`);
+      await options.runMission(session, act, signal);
+      if (signal.aborted) throw new Error(`${id} mission cancelled`);
+    },
+    async showVideo(videoId, act, signal) {
+      const session = sessions.get(id);
+      if (!session) throw new Error(`${id} session was not started`);
+      if (signal.aborted) throw new Error(`${id} video transition cancelled`);
+      await options.showVideo(session, videoTransition(videoId, act, options.videoSources), signal);
+      if (signal.aborted) throw new Error(`${id} video transition cancelled`);
+    },
+  });
+  return {
+    'claude-code-tui': create('claude-code-tui', 'claude-code'),
+    'codex-tui': create('codex-tui', 'codex'),
+  };
+}
+
+/** Run the same graph API the web editor calls and publish its live run view to a screen renderer. */
+export function createDemoRunGraphSurfaceAdapter(options: {
+  graphId: string;
+  graphYaml: string;
+  videoSources: Readonly<Record<string, string>>;
+  onView: (view: GraphRunView, act: typeof DEMO1104_STAGE_CONFIG.acts[number], signal: AbortSignal) => void;
+  onVideo: (transition: DemoVideoTransition, signal: AbortSignal) => Promise<void> | void;
+  recipesFile?: string;
+}): DemoSurfaceAdapter & { close(): void } {
+  const root = mkdtempSync(join(tmpdir(), 'demo1104-run-graph-'));
+  const mineDir = join(root, 'mine');
+  mkdirSync(mineDir, { recursive: true });
+  const graphId = options.graphId;
+  const graphFile = join(mineDir, `${graphId}.yaml`);
+  writeFileSync(graphFile, options.graphYaml);
+  let executionSettled: Promise<void> | undefined;
+  const deps = {
+    root, mineDir, recipesFile: options.recipesFile ?? resolve(import.meta.dir, '../../graphs/demo/editor-recipes.yaml'),
+    run(path: string, runOptions?: GraphRunOptions) {
+      const execution = runGraph(path, runOptions);
+      executionSettled = execution.then(() => {}, () => {});
+      return execution;
+    },
+  };
+  const abortCheck = (signal: AbortSignal) => { if (signal.aborted) throw new Error('graph screen run aborted'); };
+  const awaitExecutionCleanup = async () => {
+    if (!executionSettled) throw new Error('graph run completion handle is missing');
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const settled = await Promise.race([
+        executionSettled.then(() => true),
+        new Promise<false>(resolve => { timeout = setTimeout(() => resolve(false), DEMO1104_STAGE_CONFIG.failoverDeadlineMs); }),
+      ]);
+      if (!settled) throw new Error(`graph runner cleanup exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`);
+    } finally { if (timeout) clearTimeout(timeout); }
+  };
+  return {
+    async start(signal) { abortCheck(signal); },
+    async runAct(act, signal) {
+      abortCheck(signal);
+      try {
+        const started = handleGraphRunRoute('POST', `/v1/graphs/${graphId}/run`, { ...deps, signal });
+        if (!started || started.status !== 202) throw new Error(`run-graph start failed: ${started?.status ?? 'no route'}`);
+        const { runId } = await started.json() as { runId: string };
+        if (!executionSettled) throw new Error('run-graph route did not start a tracked execution');
+        for (let attempt = 0; attempt < 200; attempt += 1) {
+          abortCheck(signal);
+          const response = handleGraphRunRoute('GET', `/v1/graphs/${graphId}/runs/${runId}`, deps);
+          if (!response?.ok) throw new Error(`run-graph view failed: ${response?.status ?? 'no route'}`);
+          const view = await response.json() as GraphRunView;
+          abortCheck(signal);
+          options.onView(view, act, signal);
+          abortCheck(signal);
+          if (view.status === 'done') { await awaitExecutionCleanup(); return; }
+          if (view.status === 'failed' || view.status === 'budget-exceeded') {
+            await awaitExecutionCleanup();
+            throw new Error(`run-graph ${view.status}: ${view.error ?? runId}`);
+          }
+          await Bun.sleep(25);
+        }
+        throw new Error('run-graph screen did not settle within 5 seconds');
+      } finally {
+        if (signal.aborted && executionSettled) await awaitExecutionCleanup();
+      }
+    },
+    async showVideo(videoId, act, signal) {
+      abortCheck(signal);
+      await options.onVideo(videoTransition(videoId, act, options.videoSources), signal);
+      abortCheck(signal);
+    },
+    close() { rmSync(root, { recursive: true, force: true }); },
+  };
+}
+
+/** Exercise the production delivery/receipt path with its landed Telegram file recorder; never sends externally. */
+export function createDemoTelegramDryRunAdapter(options: {
+  stateDir?: string;
+  file: string;
+  linearIssueId: string;
+  videoSources: Readonly<Record<string, string>>;
+  appendDryRun?: typeof appendTopicBriefingTelegramDryRun;
+}): DemoSurfaceAdapter & { close(): void } {
+  const ownsStateDir = options.stateDir === undefined;
+  const stateDir = options.stateDir ?? mkdtempSync(join(tmpdir(), 'demo1104-telegram-'));
+  const appendDryRun = options.appendDryRun ?? appendTopicBriefingTelegramDryRun;
+  mkdirSync(dirname(options.file), { recursive: true });
+  const brief = (act: typeof DEMO1104_STAGE_CONFIG.acts[number]): BriefItem => ({
+    id: DEMO1104_STAGE_CONFIG.acts.findIndex(row => row.id === act.id) + 1,
+    text: `11-04 데모 · ${act.title}`, domain: '운영', priority: 'P1', deadline: null,
+    evidence: `https://example.invalid/demo/${act.id}`, source: 'demo1104', linearIssueId: options.linearIssueId,
+    created_at: new Date(0).toISOString(), sent_at: null,
+  });
+  return {
+    async start() {},
+    async runAct(act, signal) {
+      const assertActive = () => { if (signal.aborted) throw new Error('Telegram dry-run superseded'); };
+      const item = brief(act);
+      const defaults: Parameters<typeof deliverTopicBriefingWithReceipts>[2] = {
+        sendIssueCard: async ({ text }) => { assertActive(); appendDryRun(options.file, { linearIssueId: options.linearIssueId, text, kind: 'issue' }); },
+        commentIssue: async () => { assertActive(); },
+        issueIsDone: async () => { assertActive(); return false; },
+        isDecisionImpacting: async () => { assertActive(); return false; },
+        reopenIssue: async () => { assertActive(); },
+        sendMemoUpdateCard: async ({ text }) => { assertActive(); appendDryRun(options.file, { linearIssueId: options.linearIssueId, text, kind: 'memo' }); },
+      };
+      const guarded: typeof defaults = {
+        async sendIssueCard(input) { assertActive(); await defaults.sendIssueCard(input); assertActive(); },
+        async commentIssue(id, text) { assertActive(); await defaults.commentIssue(id, text); assertActive(); },
+        async issueIsDone(id) { assertActive(); const done = await defaults.issueIsDone(id); assertActive(); return done; },
+        async isDecisionImpacting(items) { assertActive(); const impact = await defaults.isDecisionImpacting(items); assertActive(); return impact; },
+        async reopenIssue(id) { assertActive(); await defaults.reopenIssue(id); assertActive(); },
+        async sendMemoUpdateCard(input) { assertActive(); await defaults.sendMemoUpdateCard(input); assertActive(); },
+      };
+      await deliverTopicBriefingWithReceipts({ linearIssueId: options.linearIssueId, issueLabel: '11-04 데모', summary: item.text, items: [item] }, stateDir, guarded, 'telegram-dry-run');
+    },
+    async showVideo(videoId, act, signal) {
+      if (signal.aborted) throw new Error('Telegram video transition superseded');
+      writeTelegramVideoDryRun(options.file, options.linearIssueId, videoTransition(videoId, act, options.videoSources));
+      if (signal.aborted) throw new Error('Telegram video transition superseded');
+    },
+    close() { if (ownsStateDir) rmSync(stateDir, { recursive: true, force: true }); },
+  };
+}
+
+export type DemoParallelSnapshot = StageSnapshot & {
+  surfaces: Array<{ id: DemoSurfaceId; lane: DemoLaneId; title: string; status: 'pending' | 'starting' | 'ready' | 'failed'; error: string | null }>;
+};
+
+async function runSurfaces(operations: Array<(signal: AbortSignal) => Promise<void>>, parentSignal: AbortSignal): Promise<void> {
+  const controller = new AbortController();
+  let interrupt!: () => void;
+  const interrupted = new Promise<{ kind: 'interrupted' }>(resolve => { interrupt = () => resolve({ kind: 'interrupted' }); });
+  const abortChildren = () => { controller.abort(); interrupt(); };
+  if (parentSignal.aborted) controller.abort();
+  else parentSignal.addEventListener('abort', abortChildren, { once: true });
+  let firstFailure: unknown;
+  let fail!: (error: unknown) => void;
+  const failed = new Promise<{ kind: 'failed'; error: unknown }>(resolve => { fail = error => resolve({ kind: 'failed', error }); });
+  const pending = operations.map(operation => Promise.resolve().then(() => {
+    if (controller.signal.aborted) throw new Error('demo surface action cancelled');
+    return operation(controller.signal);
+  }).catch(error => {
+    if (firstFailure === undefined) {
+      firstFailure = error;
+      controller.abort();
+      fail(error);
+    }
+    throw error;
+  }));
+  const settled = Promise.allSettled(pending);
+  try {
+    const first = await Promise.race([
+      settled.then(results => ({ kind: 'settled' as const, results })),
+      failed,
+      interrupted,
+    ]);
+    if (first.kind === 'settled') {
+      const failure = first.results.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+      if (failure) throw failure.reason;
+      return;
+    }
+    // Let abort-aware adapters clean up briefly; a wedged host callback cannot hold failover.
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const clean = await Promise.race([
+        settled.then(() => true),
+        new Promise<false>(resolve => { timeout = setTimeout(() => resolve(false), Math.min(250, DEMO1104_STAGE_CONFIG.failoverDeadlineMs)); }),
+      ]);
+      if (!clean) throw new Error(`demo surface cleanup exceeded ${Math.min(250, DEMO1104_STAGE_CONFIG.failoverDeadlineMs)}ms`);
+    } finally { if (timeout) clearTimeout(timeout); }
+    if (first.kind === 'failed') throw first.error;
+    if (firstFailure !== undefined) throw firstFailure;
+    throw new Error('demo surface action cancelled');
+  }
+  finally {
+    parentSignal.removeEventListener('abort', abortChildren);
+    controller.abort();
+  }
+}
+
+/** Connects the existing five-second failover controller to all four real demo surfaces.
+ * Launches stay adapter-owned: the CLI/session manager supplies TUI tabs, the PWA run-graph
+ * client supplies the web surface, and the Telegram adapter must use file-only dry-run output. */
+export function createDemo1104ParallelScenes(adapters: Record<DemoSurfaceId, DemoSurfaceAdapter>) {
+  const surfaceState = new Map<DemoSurfaceId, DemoParallelSnapshot['surfaces'][number]>(
+    DEMO1104_SURFACES.map(surface => [surface.id, { ...surface, status: 'pending' as const, error: null }] as const),
+  );
+  const controller = createDemoStageConsole({
+    adapters: {
+      async startLane(lane) {
+        const surfaces = DEMO1104_SURFACES.filter(surface => surface.lane === lane.id);
+        await Promise.all(surfaces.map(async surface => {
+          const state = surfaceState.get(surface.id)!;
+          state.status = 'starting';
+          try {
+            await adapters[surface.id].start(new AbortController().signal);
+            state.status = 'ready';
+          } catch (error) {
+            state.status = 'failed';
+            state.error = error instanceof Error ? error.message : String(error);
+            throw error;
+          }
+        }));
+      },
+      async runAct(act, signal) { await runSurfaces(DEMO1104_SURFACES.map(surface => childSignal => adapters[surface.id].runAct(act, childSignal)), signal); },
+      async showVideo(videoId, act, signal) { await runSurfaces(DEMO1104_SURFACES.map(surface => childSignal => adapters[surface.id].showVideo(videoId, act, childSignal)), signal); },
+    },
+  });
+  return {
+    start: () => controller.start(),
+    runActNow: (id: DemoActId) => controller.runActNow(id),
+    switchToVideo: (id: DemoActId) => controller.switchToVideo(id),
+    snapshot(): DemoParallelSnapshot {
+      return { ...controller.snapshot(), surfaces: DEMO1104_SURFACES.map(surface => ({ ...surfaceState.get(surface.id)! })) };
+    },
+  };
+}

package/scripts/demo/demo1104-stage.config.ts

@@ -0,0 +1,21 @@
+/** Script timing and pre-recorded failover map for the 11-04 demo. */
+export const DEMO1104_STAGE_CONFIG = {
+  failoverDeadlineMs: 5_000,
+  acts: [
+    { id: 'prologue', title: '프롤로그', targetStartSec: 0, targetEndSec: 40, highlightVideoId: null },
+    { id: 'act-1', title: '아침 브리핑', targetStartSec: 40, targetEndSec: 90, highlightVideoId: 'V1' },
+    { id: 'act-2', title: '깊이 파기', targetStartSec: 90, targetEndSec: 210, highlightVideoId: 'V2' },
+    { id: 'act-3', title: '맡기기', targetStartSec: 210, targetEndSec: 240, highlightVideoId: 'V3' },
+    { id: 'act-4', title: '끝까지 처리', targetStartSec: 240, targetEndSec: 420, highlightVideoId: 'V4' },
+    { id: 'act-5', title: '스스로 만든다', targetStartSec: 420, targetEndSec: 510, highlightVideoId: 'V5' },
+    { id: 'act-6', title: '이어진다', targetStartSec: 510, targetEndSec: 570, highlightVideoId: 'V6' },
+    { id: 'epilogue', title: '에필로그', targetStartSec: 570, targetEndSec: 600, highlightVideoId: null },
+  ],
+  lanes: [
+    { id: 'secretary', title: '업무 비서', startsAtAct: 'prologue' },
+    { id: 'maker', title: '만드는 엘라누스', startsAtAct: 'prologue' },
+  ],
+} as const;
+
+export type DemoActId = typeof DEMO1104_STAGE_CONFIG.acts[number]['id'];
+export type DemoLaneId = typeof DEMO1104_STAGE_CONFIG.lanes[number]['id'];

package/scripts/demo/demo1104-stage.ts

@@ -0,0 +1,316 @@
+import { DEMO1104_STAGE_CONFIG, type DemoActId, type DemoLaneId } from './demo1104-stage.config.js';
+
+type Act = typeof DEMO1104_STAGE_CONFIG.acts[number];
+type Lane = typeof DEMO1104_STAGE_CONFIG.lanes[number];
+type ActStatus = 'pending' | 'running' | 'live' | 'failed' | 'video';
+type TimerHandle = ReturnType<typeof setTimeout>;
+type TimerScheduler = {
+  setTimeout(callback: () => void, delayMs: number): TimerHandle;
+  clearTimeout(handle: TimerHandle): void;
+};
+type LaneStatus = 'pending' | 'running' | 'started' | 'failed';
+type VideoTrigger = 'failure' | 'deadline' | 'manual';
+type VideoTransition = { actId: DemoActId; videoId: string; trigger: VideoTrigger; failedAt: number; requestedAt: number; completedAt: number | null; latencyMs: number | null; status: 'shown' | 'failed' | 'superseded'; error: string | null };
+
+export type StageAdapters = {
+  startLane(lane: Lane): Promise<void>;
+  runAct(act: Act, signal: AbortSignal): Promise<void>;
+  showVideo(videoId: string, act: Act, signal: AbortSignal): Promise<void>;
+};
+
+export type StageSnapshot = {
+  startedAt: number | null;
+  elapsedMs: number;
+  lanes: Array<{ id: DemoLaneId; title: string; startsAtAct: DemoActId; status: LaneStatus; startedAt: number | null }>;
+  acts: Array<{ id: DemoActId; title: string; targetStartSec: number; targetEndSec: number; videoId: string | null; status: ActStatus }>;
+  transitions: VideoTransition[];
+};
+
+export function createDemoStageConsole(options: {
+  adapters: StageAdapters;
+  now?: () => number;
+  timers?: TimerScheduler;
+}): {
+  start(): Promise<void>;
+  runActNow(id: DemoActId): Promise<void>;
+  switchToVideo(id: DemoActId): Promise<void>;
+  snapshot(): StageSnapshot;
+} {
+  const now = options.now ?? Date.now;
+  const timers: TimerScheduler = options.timers ?? {
+    setTimeout: (callback, delayMs) => setTimeout(callback, delayMs) as TimerHandle,
+    clearTimeout: handle => clearTimeout(handle),
+  };
+  const startedAt = { value: null as number | null };
+  const laneStarts = new Map<DemoLaneId, number>();
+  const laneStatuses = new Map<DemoLaneId, LaneStatus>(
+    DEMO1104_STAGE_CONFIG.lanes.map(lane => [lane.id, 'pending']),
+  );
+  const actStatuses = new Map<DemoActId, ActStatus>(DEMO1104_STAGE_CONFIG.acts.map(act => [act.id, 'pending']));
+  const actGenerations = new Map<DemoActId, number>();
+  const actControllers = new Map<DemoActId, { generation: number; controller: AbortController }>();
+  const videoControllers = new Map<DemoActId, { generation: number; controller: AbortController }>();
+  const transitions: VideoTransition[] = [];
+  const abortActWork = (id: DemoActId): void => {
+    actControllers.get(id)?.controller.abort();
+    videoControllers.get(id)?.controller.abort();
+  };
+  const nextActGeneration = (id: DemoActId): number => {
+    abortActWork(id);
+    const next = (actGenerations.get(id) ?? 0) + 1;
+    actGenerations.set(id, next);
+    return next;
+  };
+  const isCurrentActGeneration = (id: DemoActId, generation: number): boolean => actGenerations.get(id) === generation;
+
+  const actFor = (id: DemoActId): Act => {
+    const act = DEMO1104_STAGE_CONFIG.acts.find(candidate => candidate.id === id);
+    if (!act) throw new Error(`Unknown demo act: ${id}`);
+    return act;
+  };
+
+  const switchToVideo = async (id: DemoActId, failedAt: number, trigger: VideoTrigger, generation: number): Promise<void> => {
+    const act = actFor(id);
+    if (!act.highlightVideoId) throw new Error(`${id} has no configured highlight video`);
+    if (!isCurrentActGeneration(id, generation)) return;
+    const requestedAt = now();
+    const transition: VideoTransition = { actId: id, videoId: act.highlightVideoId, trigger, failedAt, requestedAt, completedAt: null, latencyMs: null, status: 'failed', error: null };
+    transitions.push(transition);
+    const controller = new AbortController();
+    videoControllers.set(id, { generation, controller });
+    const remainingMs = DEMO1104_STAGE_CONFIG.failoverDeadlineMs - (requestedAt - failedAt);
+    if (remainingMs <= 0) {
+      transition.error = `video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`;
+      if (isCurrentActGeneration(id, generation)) actStatuses.set(id, 'failed');
+      controller.abort();
+      videoControllers.delete(id);
+      throw new Error(`${id} video transition failed: ${transition.error}`);
+    }
+    let timeout: TimerHandle | undefined;
+    let timedOut = false;
+    let removeAbortListener = () => {};
+    const aborted = new Promise<never>((_resolve, reject) => {
+      const onAbort = () => reject(new Error('video transition superseded'));
+      if (controller.signal.aborted) onAbort();
+      else {
+        controller.signal.addEventListener('abort', onAbort, { once: true });
+        removeAbortListener = () => controller.signal.removeEventListener('abort', onAbort);
+      }
+    });
+    const deadline = new Promise<never>((_resolve, reject) => {
+      timeout = timers.setTimeout(() => {
+        timedOut = true;
+        reject(new Error(`video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`));
+      }, remainingMs);
+    });
+    const display = Promise.resolve()
+      .then(() => options.adapters.showVideo(act.highlightVideoId!, act, controller.signal))
+      .then(() => {
+        transition.completedAt = now();
+        transition.latencyMs = transition.completedAt - failedAt;
+      });
+    try {
+      await Promise.race([display, deadline, aborted]);
+      if (transition.latencyMs! > DEMO1104_STAGE_CONFIG.failoverDeadlineMs) {
+        timedOut = true;
+        throw new Error(`video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`);
+      }
+      if (!isCurrentActGeneration(id, generation)) {
+        transition.status = 'superseded';
+        transition.error = 'video transition superseded';
+        return;
+      }
+      transition.status = 'shown';
+      actStatuses.set(id, 'video');
+    } catch (error) {
+      if (!isCurrentActGeneration(id, generation)) {
+        transition.status = 'superseded';
+        transition.error = 'video transition superseded';
+        return;
+      }
+      transition.error = timedOut ? `video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms` : error instanceof Error ? error.message : String(error);
+      if (isCurrentActGeneration(id, generation)) actStatuses.set(id, 'failed');
+      controller.abort();
+      throw new Error(`${id} video transition failed: ${transition.error}`);
+    } finally {
+      removeAbortListener();
+      if (timeout) timers.clearTimeout(timeout);
+      if (videoControllers.get(id)?.generation === generation) videoControllers.delete(id);
+    }
+  };
+
+  return {
+    async start() {
+      if (startedAt.value !== null) throw new Error('Demo stage already started');
+      startedAt.value = now();
+      // Invoke both lanes before awaiting either one so the two story lines start together.
+      const launches = DEMO1104_STAGE_CONFIG.lanes.map(lane => {
+        laneStatuses.set(lane.id, 'running');
+        const laneStartedAt = now();
+        laneStarts.set(lane.id, laneStartedAt);
+        return options.adapters.startLane(lane).then(
+          () => { laneStatuses.set(lane.id, 'started'); },
+          error => { laneStatuses.set(lane.id, 'failed'); throw error; },
+        );
+      });
+      await Promise.all(launches);
+    },
+
+    async runActNow(id) {
+      if (startedAt.value === null) throw new Error('Start the demo stage before running an act');
+      const act = actFor(id);
+      const generation = nextActGeneration(id);
+      const controller = new AbortController();
+      actControllers.set(id, { generation, controller });
+      actStatuses.set(id, 'running');
+      let timeout: TimerHandle | undefined;
+      let failedAt: number | undefined;
+      let trigger: VideoTrigger = 'failure';
+      let removeAbortListener = () => {};
+      const timeoutMs = DEMO1104_STAGE_CONFIG.failoverDeadlineMs;
+      const aborted = new Promise<never>((_resolve, reject) => {
+        const onAbort = () => reject(new Error('act execution superseded'));
+        if (controller.signal.aborted) onAbort();
+        else {
+          controller.signal.addEventListener('abort', onAbort, { once: true });
+          removeAbortListener = () => controller.signal.removeEventListener('abort', onAbort);
+        }
+      });
+      const deadline = new Promise<never>((_resolve, reject) => {
+        timeout = timers.setTimeout(() => {
+          failedAt = now();
+          trigger = 'deadline';
+          reject(new Error(`Act exceeded ${timeoutMs}ms`));
+        }, timeoutMs);
+      });
+      try {
+        await Promise.race([options.adapters.runAct(act, controller.signal), deadline, aborted]);
+        if (!isCurrentActGeneration(id, generation)) return;
+        actStatuses.set(id, 'live');
+      } catch {
+        if (!isCurrentActGeneration(id, generation)) return;
+        failedAt ??= now();
+        actStatuses.set(id, 'failed');
+        if (!act.highlightVideoId) throw new Error(`${id} failed and has no configured highlight video`);
+        controller.abort();
+        if (actControllers.get(id)?.generation === generation) actControllers.delete(id);
+        await switchToVideo(id, failedAt, trigger, generation);
+      } finally {
+        removeAbortListener();
+        if (timeout) timers.clearTimeout(timeout);
+        if (actControllers.get(id)?.generation === generation) actControllers.delete(id);
+      }
+    },
+
+    switchToVideo(id) {
+      if (startedAt.value === null) throw new Error('Start the demo stage before switching to video');
+      if (!actFor(id).highlightVideoId) throw new Error(`${id} has no configured highlight video`);
+      const generation = nextActGeneration(id);
+      return switchToVideo(id, now(), 'manual', generation);
+    },
+
+    snapshot() {
+      const current = now();
+      return {
+        startedAt: startedAt.value,
+        elapsedMs: startedAt.value === null ? 0 : Math.max(0, current - startedAt.value),
+        lanes: DEMO1104_STAGE_CONFIG.lanes.map(lane => ({
+          id: lane.id,
+          title: lane.title,
+          startsAtAct: lane.startsAtAct,
+          status: laneStatuses.get(lane.id) ?? 'pending',
+          startedAt: laneStarts.get(lane.id) ?? null,
+        })),
+        acts: DEMO1104_STAGE_CONFIG.acts.map(act => ({
+          id: act.id,
+          title: act.title,
+          targetStartSec: act.targetStartSec,
+          targetEndSec: act.targetEndSec,
+          videoId: act.highlightVideoId,
+          status: actStatuses.get(act.id) ?? 'pending',
+        })),
+        transitions: transitions.map(transition => ({ ...transition })),
+      };
+    },
+  };
+}
+
+type CliOptions = { mock: boolean; help?: boolean; runAct?: DemoActId; failAct?: DemoActId; hangAct?: DemoActId; switchToVideo?: DemoActId };
+
+const HELP = 'Usage: bun scripts/demo/demo1104-stage.ts --mock [--run-act <act> [--fail-act <act>|--hang-act <act>]] [--switch-to-video <act>]';
+
+export function parseStageArgs(argv: string[]): CliOptions {
+  if (argv.includes('--help')) return { mock: false, help: true };
+  let mock = false;
+  let runAct: DemoActId | undefined;
+  let failAct: DemoActId | undefined;
+  let hangAct: DemoActId | undefined;
+  let switchToVideo: DemoActId | undefined;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--mock') { mock = true; continue; }
+    if (arg === '--run-act' || arg === '--fail-act' || arg === '--hang-act' || arg === '--switch-to-video') {
+      const value = argv[++index];
+      if (!value) throw new Error(`${arg} needs an act id`);
+      const act = DEMO1104_STAGE_CONFIG.acts.find(candidate => candidate.id === value);
+      if (!act) throw new Error(`Unknown act id: ${value}`);
+      if (arg !== '--run-act' && !act.highlightVideoId) throw new Error(`${value} has no configured highlight video`);
+      if (arg === '--run-act') runAct = act.id;
+      else if (arg === '--fail-act') failAct = act.id;
+      else if (arg === '--hang-act') hangAct = act.id;
+      else switchToVideo = act.id;
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  if (!mock) throw new Error('This first-stage console is mock-only; pass --mock');
+  if (failAct && failAct !== runAct) throw new Error('--fail-act must match --run-act');
+  if (hangAct && hangAct !== runAct) throw new Error('--hang-act must match --run-act');
+  if (hangAct && failAct) throw new Error('--hang-act cannot be combined with --fail-act');
+  if (switchToVideo && (runAct || failAct)) throw new Error('--switch-to-video cannot be combined with act execution');
+  if (switchToVideo && hangAct) throw new Error('--switch-to-video cannot be combined with --hang-act');
+  return { mock, ...(runAct ? { runAct } : {}), ...(failAct ? { failAct } : {}), ...(hangAct ? { hangAct } : {}), ...(switchToVideo ? { switchToVideo } : {}) };
+}
+
+export async function runMockStage(args: CliOptions, stageOptions: { now?: () => number; timers?: TimerScheduler } = {}): Promise<StageSnapshot> {
+  const adapters: StageAdapters = {
+    async startLane(lane) { console.log(`시작: ${lane.title}`); },
+    async runAct(act) {
+      console.log(`지금 실행: ${act.title}`);
+      if (args.failAct === act.id) throw new Error('mock failure injected');
+      if (args.hangAct === act.id) return new Promise<void>(() => {});
+    },
+    async showVideo(videoId, act) { console.log(`영상 전환: ${act.title} → ${videoId}`); },
+  };
+  const stage = createDemoStageConsole({ adapters, ...stageOptions });
+  await stage.start();
+  if (args.runAct) {
+    await stage.runActNow(args.runAct);
+    const transition = stage.snapshot().transitions.at(-1);
+    if (transition?.status === 'shown') {
+      const cause = transition.trigger === 'deadline' ? '정체' : transition.trigger === 'failure' ? '실패' : '수동';
+      console.log(`씬 ${cause} · 영상 전환 완료: ${transition.actId} → ${transition.videoId} · ${transition.latencyMs}ms`);
+    }
+  }
+  if (args.switchToVideo) {
+    await stage.switchToVideo(args.switchToVideo);
+    const transition = stage.snapshot().transitions.at(-1);
+    if (transition?.status === 'shown') console.log(`수동 영상 전환 완료: ${transition.actId} → ${transition.videoId} · ${transition.latencyMs}ms`);
+  }
+  return stage.snapshot();
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseStageArgs(process.argv.slice(2));
+    if (args.help) {
+      console.log(HELP);
+      process.exit(0);
+    }
+    const snapshot = await runMockStage(args);
+    console.log(JSON.stringify(snapshot, null, 2));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 2;
+  }
+}

package/scripts/goal-method-audit.ts

@@ -107,6 +107,22 @@ export function collectSlotLoads(lines: readonly string[]): readonly SlotLoad[]
   return out;
 }
 
+/** §6 머리말이 선언한 「사람 몫」 — 매뉴얼이 canonical 이므로 «수»를 이 파일에 박지 않는다.
+ *  🩸 계기(2026-10-31): `«여섯»` 이 여기 박혀 있었고 매뉴얼 §6 이 `«둘»` 로 바뀐 뒤에도 그 수를 계속 찍었다. */
+const HUMAN_SLOT_DECLARATION = /사람\s*(?:몫|칸)\s*«([^»]+)»/u;
+
+export function declaredHumanSlots(lines: readonly string[]): string | null {
+  const start = lines.findIndex(l => /^##\s*6\./u.test(l));
+  if (start < 0) return null;
+  const rel = lines.slice(start + 1).findIndex(l => /^##\s/u.test(l));
+  const end = rel < 0 ? lines.length : start + 1 + rel;
+  for (const line of lines.slice(start, end)) {
+    const match = HUMAN_SLOT_DECLARATION.exec(line);
+    if (match) return match[1]!;
+  }
+  return null;
+}
+
 export interface NarrativeCount { readonly name: string; readonly lines: number }
 
 /** 머리말이 「여기 없다」고 선언한 것들이 실제로 몇 줄인가. */
@@ -135,7 +151,7 @@ function report(path = MANUAL): number {
   console.log('');
   const slots = collectSlotLoads(lines);
   const mapped = new Set(slots.flatMap(s => s.clauses));
-  console.log(`축② 사람 칸 — §6 선언 «여섯» ↔ 조항 ${clauses.length} · 칸에 «걸린» 조항 ${mapped.size}`);
+  console.log(`축② 사람 칸 — §6 선언 «${declaredHumanSlots(lines) ?? '없음'}» ↔ 조항 ${clauses.length} · 칸에 «걸린» 조항 ${mapped.size}`);
   for (const { slot, clauses: c } of slots) {
     console.log(`   ${slot.padEnd(3)} ${String(c.length).padStart(2)}개  ${c.join(' ')}`);
   }