elanous 0.2.42 → 0.2.44

package/scripts/ci-typecheck-main-delta.sh

@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# Pinned landing TSC guard: compare the integrated commit against its exact main baseline.
+set -euo pipefail
+
+BASE_SHA=${1:-}
+if [[ ! "$BASE_SHA" =~ ^[0-9a-fA-F]{40}$ ]]; then
+  echo "error: expected a pinned 40-character main baseline SHA" >&2
+  exit 2
+fi
+
+ROOT=$(git rev-parse --show-toplevel 2>/dev/null) || { echo "error: repository root unavailable" >&2; exit 2; }
+git -C "$ROOT" cat-file -e "${BASE_SHA}^{commit}" 2>/dev/null || { echo "error: main baseline commit unavailable: $BASE_SHA" >&2; exit 2; }
+# Share dependencies for speed only when resolution inputs match. If they differ,
+# install the pinned main baseline from its own lockfile in the detached worktree.
+dependency_changes=$(git -C "$ROOT" diff --name-only "$BASE_SHA" HEAD) || { echo "error: dependency diff unavailable" >&2; exit 2; }
+dependency_changes=$(printf '%s\n' "$dependency_changes" | awk '/(^|\/)(package\.json|bun\.lock(\.b)?|package-lock\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bunfig\.toml)$/')
+INSTALL_BASELINE=0
+if [[ -n "$dependency_changes" ]]; then
+  printf '[tsc-main-delta] dependency inputs changed; installing pinned-main dependencies independently:\n%s\n' "$dependency_changes"
+  INSTALL_BASELINE=1
+fi
+TMP=$(mktemp -d "${TMPDIR:-/var/tmp}/elanous-tsc-delta.XXXXXXXX") || { echo "error: temporary directory unavailable" >&2; exit 2; }
+BASE_TREE="$TMP/base"
+
+cleanup() {
+  git -C "$ROOT" worktree remove --force "$BASE_TREE" >/dev/null 2>&1 || true
+  rm -rf "$TMP"
+}
+trap cleanup EXIT
+trap 'exit 130' INT TERM
+
+git -C "$ROOT" worktree add --quiet --detach "$BASE_TREE" "$BASE_SHA" || { echo "error: main baseline worktree unavailable" >&2; exit 2; }
+if [[ "$INSTALL_BASELINE" == 1 ]]; then
+  (cd "$BASE_TREE" && bun install --frozen-lockfile) || { echo "error: pinned-main dependency install failed" >&2; exit 2; }
+else
+  ln -s "$ROOT/node_modules" "$BASE_TREE/node_modules" || { echo "error: baseline dependency link unavailable" >&2; exit 2; }
+fi
+
+run_tsc() {
+  local tree="$1" label="$2" rc
+  local log="$TMP/$label.log" diagnostics="$TMP/$label.diagnostics"
+  if (cd "$tree" && NODE_OPTIONS='--max-old-space-size=12288' bunx tsc --noEmit --pretty false) >"$log" 2>&1; then rc=0; else rc=$?; fi
+  if [[ "$rc" != 0 && "$rc" != 1 && "$rc" != 2 ]]; then
+    cat "$log" >&2
+    echo "error: $label tsc did not complete (rc=$rc)" >&2
+    return 2
+  fi
+  awk '
+    function flush() {
+      if (active) {
+        # Keep path/code/full text as the key; only ignore line/column drift. A moved
+        # diagnostic is intentionally treated as new so cross-file errors stay visible.
+        sub(/\([0-9]+,[0-9]+\): error TS/, ": error TS", block)
+        print block
+      }
+      active = 0; block = ""
+    }
+    /^[^[:space:]].*: error TS[0-9]+:/ { flush(); block = $0; active = 1; next }
+    active && /^[[:space:]]+/ { sub(/^[[:space:]]+/, ""); block = block " | " $0; next }
+    { flush() }
+    END { flush() }
+  ' "$log" >"$TMP/$label.raw-diagnostics"
+  LC_ALL=C sort "$TMP/$label.raw-diagnostics" >"$diagnostics"
+  if [[ "$rc" != 0 && ! -s "$diagnostics" ]]; then
+    cat "$log" >&2
+    echo "error: $label tsc failed without parseable TypeScript diagnostics (rc=$rc)" >&2
+    return 2
+  fi
+  if [[ "$rc" == 0 && -s "$diagnostics" ]]; then
+    cat "$log" >&2
+    echo "error: $label tsc returned success with diagnostics" >&2
+    return 2
+  fi
+  printf '%s\n' "$rc"
+}
+
+BASE_RC=$(run_tsc "$BASE_TREE" baseline) || exit $?
+HEAD_RC=$(run_tsc "$ROOT" integration) || exit $?
+LC_ALL=C comm -13 "$TMP/baseline.diagnostics" "$TMP/integration.diagnostics" >"$TMP/new.diagnostics"
+new_count=$(wc -l <"$TMP/new.diagnostics" | tr -d ' ')
+printf '[tsc-main-delta] base=%s base_rc=%s head=%s head_rc=%s baseline_errors=%s head_errors=%s new_errors=%s\n' \
+  "$BASE_SHA" "$BASE_RC" "$(git -C "$ROOT" rev-parse HEAD)" "$HEAD_RC" \
+  "$(wc -l <"$TMP/baseline.diagnostics" | tr -d ' ')" "$(wc -l <"$TMP/integration.diagnostics" | tr -d ' ')" "$new_count"
+if [[ "$new_count" != 0 ]]; then
+  echo "error: main-baseline tsc introduced $new_count TypeScript diagnostic(s)" >&2
+  cat "$TMP/new.diagnostics" >&2
+  exit 1
+fi

package/scripts/codex-fallback-live-probe.ts

@@ -55,7 +55,7 @@ export type LiveProbeInputs = {
 
 export type LiveProbeLine = LiveProbeInputs & (
   | { readonly action: 'stay'; readonly why: StayReason; readonly backend?: never; readonly to?: never }
-  | { readonly action: 'switch-backend'; readonly backend: 'grok' | 'claude' | 'openrouter'; readonly model?: string; readonly why?: never; readonly to?: never }
+  | { readonly action: 'switch-backend'; readonly backend: 'grok' | 'claude' | 'openrouter' | 'zai'; readonly model?: string; readonly why?: never; readonly to?: never }
   | { readonly action: 'codex-rotate'; readonly to: string; readonly why?: never; readonly backend?: never }
   | { readonly action: 'codex-credits'; readonly to?: string; readonly why?: never; readonly backend?: never }
 ) & { readonly inputKind: 'live' };

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

@@ -0,0 +1,56 @@
+import type { TerminalSessionRegistry } from '../../src/terminal/session-registry.js';
+import {
+  createDemo1104ParallelScenes,
+  createDemo1104TuiTabAdapters,
+  type DemoParallelSnapshot,
+  type DemoSurfaceAdapter,
+} from './demo1104-parallel-scenes.js';
+import type { DemoActId } from './demo1104-stage.config.js';
+import { spawnCodingAgent } from '../../src/terminal/coding-agent.js';
+
+export type Demo1104ParallelHostOptions = {
+  registry: TerminalSessionRegistry;
+  cwd: string;
+  termSize: () => { cols: number; rows: number };
+  runMission: Parameters<typeof createDemo1104TuiTabAdapters>[0]['runMission'];
+  showVideo: Parameters<typeof createDemo1104TuiTabAdapters>[0]['showVideo'];
+  videoSources: Readonly<Record<string, string>>;
+  webRunGraph: DemoSurfaceAdapter;
+  telegram: DemoSurfaceAdapter;
+  spawnAgent?: typeof spawnCodingAgent;
+};
+
+export type Demo1104ParallelStage = {
+  start(): Promise<void>;
+  runActNow(id: DemoActId): Promise<void>;
+  switchToVideo(id: DemoActId): Promise<void>;
+  snapshot(): DemoParallelSnapshot;
+};
+
+/** The single host composition point for the two visible agent tabs and the two secretary surfaces. */
+export function createDemo1104ParallelHost(options: Demo1104ParallelHostOptions): Demo1104ParallelStage {
+  const tuiTabs = createDemo1104TuiTabAdapters({
+    registry: options.registry,
+    cwd: options.cwd,
+    termSize: options.termSize,
+    runMission: options.runMission,
+    showVideo: options.showVideo,
+    videoSources: options.videoSources,
+    ...(options.spawnAgent ? { spawnAgent: options.spawnAgent } : {}),
+  });
+  return createDemo1104ParallelScenes({
+    ...tuiTabs,
+    'web-run-graph': options.webRunGraph,
+    telegram: options.telegram,
+  });
+}
+
+/** Start all four demo surfaces together and return the live controls to the demo runner. */
+export async function startDemo1104ParallelHost(options: Demo1104ParallelHostOptions): Promise<{
+  stage: Demo1104ParallelStage;
+  snapshot: DemoParallelSnapshot;
+}> {
+  const stage = createDemo1104ParallelHost(options);
+  await stage.start();
+  return { stage, snapshot: stage.snapshot() };
+}

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-parallel.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env bun
+import { readFileSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { resolve } from 'node:path';
+import { DisplayCoordinator } from '../../src/display/coordinator.js';
+import { TerminalSessionRegistry } from '../../src/terminal/session-registry.js';
+import { createDemoRunGraphSurfaceAdapter, createDemoTelegramDryRunAdapter } from './demo1104-parallel-scenes.js';
+import { DEMO1104_STAGE_CONFIG } from './demo1104-stage.config.js';
+import { startDemo1104ParallelHost } from './demo1104-parallel-host.js';
+
+const repoRoot = resolve(import.meta.dir, '../..');
+const outputDir = resolve(process.env.DEMO1104_OUTPUT_DIR ?? `${process.env.HOME}/Movies/elanous/demo-1104/live`);
+const videoSources = Object.fromEntries(['V1', 'V2', 'V3', 'V4', 'V5', 'V6'].map(id => [id, resolve(outputDir, `${id}.mp4`)]));
+const coordinator = new DisplayCoordinator({ termSize: () => ({ cols: process.stdout.columns ?? 120, rows: process.stdout.rows ?? 40 }) });
+const registry = new TerminalSessionRegistry({ coordinator });
+const webRunGraph = createDemoRunGraphSurfaceAdapter({
+  graphId: 'inside-seed',
+  graphYaml: readFileSync(resolve(repoRoot, 'graphs/demo/inside-seed.yaml'), 'utf8'),
+  videoSources,
+  onView(view, act) { stdout.write(`[web-run-graph] ${act.id} ${view.status}\n`); },
+  onVideo(transition) { stdout.write(`[web-run-graph] video ${transition.videoId}: ${transition.source}\n`); },
+});
+const telegramFile = resolve(outputDir, 'telegram-dry-run.jsonl');
+const telegram = createDemoTelegramDryRunAdapter({ file: telegramFile, linearIssueId: 'DEMO1104', videoSources });
+let stage: Awaited<ReturnType<typeof startDemo1104ParallelHost>>['stage'] | undefined;
+
+try {
+  const started = await startDemo1104ParallelHost({
+    registry,
+    cwd: repoRoot,
+    termSize: () => ({ cols: process.stdout.columns ?? 120, rows: process.stdout.rows ?? 40 }),
+    videoSources,
+    webRunGraph,
+    telegram,
+    async runMission(session, act) {
+      const prompt = `\n[11-04 ${act.id}] ${act.title}\n`;
+      session.preview.write(`${prompt}\n`);
+      stdout.write(`[${session.agentBrand}] mission sent to ${session.id}\n`);
+    },
+    showVideo(session, transition) {
+      session.preview.write(`\n[11-04 video ${transition.videoId}] ${transition.source}\n`);
+    },
+  });
+  stage = started.stage;
+  stdout.write(`11-04 parallel stage started\n${JSON.stringify(started.snapshot, null, 2)}\n`);
+  stdout.write(`Controls: act <act-id> | video <act-id> | snapshot | quit\nActs: ${DEMO1104_STAGE_CONFIG.acts.map(act => act.id).join(', ')}\n`);
+  const input = createInterface({ input: stdin, output: stdout, terminal: Boolean(stdin.isTTY) });
+  try {
+    for await (const line of input) {
+      const [command, id] = line.trim().split(/\s+/, 2);
+      if (command === 'quit' || command === 'exit') break;
+      if (command === 'snapshot') {
+        stdout.write(`${JSON.stringify(stage.snapshot(), null, 2)}\n`);
+      } else if (command === 'act' && id) {
+        await stage.runActNow(id as typeof DEMO1104_STAGE_CONFIG.acts[number]['id']);
+        stdout.write(`act complete: ${id}\n`);
+      } else if (command === 'video' && id) {
+        await stage.switchToVideo(id as typeof DEMO1104_STAGE_CONFIG.acts[number]['id']);
+        stdout.write(`video transition complete: ${id}\n`);
+      } else {
+        stdout.write('Use: act <act-id> | video <act-id> | snapshot | quit\n');
+      }
+    }
+  } finally {
+    input.close();
+  }
+} finally {
+  for (const session of registry.list()) registry.kill(session.id);
+  webRunGraph.close();
+  telegram.close();
+}

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'];