elanous 0.2.22 → 0.2.24

package/src/context-bus/context-first.ts

@@ -1,17 +1,59 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { debug } from '../debug/log.js';
 import type { ContextNowAnswer, ContextNowDeps } from './context-now.js';
 
 const CONTEXT_FIRST_GAP_MS = 6 * 60 * 60 * 1000;
 const CONTEXT_UNREADABLE = '맥락 못 읽음';
 
+/** Where the last-utterance times survive a daemon restart, so a restart does not read as a first utterance. */
+export interface ContextFirstStore {
+  load(): Record<string, number>;
+  save(lastUtteranceAt: Record<string, number>): void;
+}
+
+/** JSON-file store; unreadable or malformed content loads as empty, write failures never block the turn.
+ *  Both are logged (`context-first.store`) so a gate that keeps re-arming after restarts can be traced. */
+export function createContextFirstFileStore(path: string): ContextFirstStore {
+  return {
+    load() {
+      try {
+        const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+        if (!parsed || typeof parsed !== 'object') return {};
+        return Object.fromEntries(Object.entries(parsed).filter((entry): entry is [string, number] => Number.isFinite(entry[1])));
+      } catch (err) {
+        if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+          debug.log('context-first.store', 'load-failed', { path, error: err instanceof Error ? err.message : String(err) });
+        }
+        return {};
+      }
+    },
+    save(lastUtteranceAt) {
+      try {
+        mkdirSync(dirname(path), { recursive: true });
+        // Write-then-rename so a daemon killed mid-write never leaves a torn file (which would re-arm every opening).
+        const tmp = `${path}.${process.pid}.tmp`;
+        writeFileSync(tmp, JSON.stringify(lastUtteranceAt));
+        renameSync(tmp, path);
+      } catch (err) {
+        // Persistence must not block the conversation, but a failure is observed.
+        debug.log('context-first.store', 'save-failed', { path, error: err instanceof Error ? err.message : String(err) });
+      }
+    },
+  };
+}
+
 /** Track every allowed utterance, consuming a pending summary only on a normal turn. */
-export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: { now: () => number; gapMs?: number }) {
-  const lastUtteranceAt = new Map<string, number>();
+export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS, store }: { now: () => number; gapMs?: number; store?: ContextFirstStore }) {
+  const lastUtteranceAt = new Map<string, number>(Object.entries(store?.load() ?? {}));
   const pending = new Set<string>();
   return {
     note(key: string): void {
       const at = now();
       const previous = lastUtteranceAt.get(key);
       lastUtteranceAt.set(key, at);
+      // An entry older than the gap behaves like no entry, so it is dropped from the persisted state.
+      store?.save(Object.fromEntries([...lastUtteranceAt].filter(([, time]) => at - time < gapMs)));
       if (previous === undefined || at - previous >= gapMs) pending.add(key);
     },
     take(key: string): boolean {
@@ -20,6 +62,13 @@ export function createContextFirstGate({ now, gapMs = CONTEXT_FIRST_GAP_MS }: {
   };
 }
 
+const OPERATIONAL_QUERY = /발행|릴리[스즈]|배포|버전|상태|현황|스케줄|체크리스트|도는\s*런|돌고\s*있|\brelease\b|\bversion\b|\bstatus\b|\/now\b/i;
+
+/** A question about the operation or the release itself already asks for the ledger, so the opening would only push the answer down. */
+export function isOperationalQuery(text: string | undefined): boolean {
+  return !!text && OPERATIONAL_QUERY.test(text);
+}
+
 export function renderContextFirst(
   read: (options: {}, deps?: ContextNowDeps) => ContextNowAnswer,
   deps: ContextNowDeps | undefined,

package/src/context-bus/context-now-surfaces.ts

@@ -57,6 +57,18 @@ export function renderTelegramNow(input: ContextNowAnswer, audience: ContextNowA
  *  release run, late schedules) ahead of the same `/now` body. `/now` itself stays unchanged. */
 export function renderContextFirstNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
   const answer = forAudience(input, audience);
+  const { lines, total } = operationalLines(answer);
+  if (total > lines.length) lines.push(`… 운영 항목 ${total - lines.length}개 더 (/now)`);
+  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+}
+
+/** Telegram opening: at most three operational rows and nothing else — no `/now` body, no «최근:» row.
+ *  Empty when nothing operational is running, so the caller sends no opening at all. */
+export function renderContextFirstOpening(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string {
+  return operationalLines(forAudience(input, audience)).lines.join('\n');
+}
+
+function operationalLines(answer: ContextNowAnswer): { lines: string[]; total: number } {
   const labels = { run: '도는 런', release: '발행 런', 'schedule-late': '지연 스케줄' } as const;
   const operational = answer.facts.filter(fact => fact.kind === 'run' ||
     (fact.kind === 'release' && (fact.unreadable || fact.status !== 'done')) ||
@@ -67,8 +79,7 @@ export function renderContextFirstNow(input: ContextNowAnswer, audience: Context
     const text = fact.kind === 'run' && !fact.unreadable ? `${short(fact.goal.replace(/\s+/g, ' ').trim())} · ${fact.phase} · ${fact.elapsed}` : factText(fact);
     return `${labels[fact.kind as keyof typeof labels]}: ${text} — ${fact.source}`.replace(/\s+/g, ' ').trim();
   });
-  if (operational.length > lines.length) lines.push(`… 운영 항목 ${operational.length - lines.length}개 더 (/now)`);
-  return [...lines, renderTelegramNow(answer, 'operator')].join('\n');
+  return { lines, total: operational.length };
 }
 
 export function renderTuiNow(input: ContextNowAnswer, audience: ContextNowAudience = 'operator'): string[] {

package/src/context-bus/long-term-memory.ts

@@ -252,7 +252,9 @@ export async function condenseContextWindowWithReport(
     if (!/^(?:https?:\/\/|elanous:\/\/)[^\s]+$/.test(link)) { skip('bad-link', source); continue; }
     const claim = summary.claim && { key: safeLine(summary.claim.key), value: safeLine(summary.claim.value) };
     if (claim && (!claim.key || !claim.value)) { skip('bad-claim', source); continue; }
-    if (source.kind === 'event' && !claim) { skip('no-claim', source); continue; }
+    // Sleep review can promote a sourced durable event without asserting a comparable fact.
+    // The ordinary condense command still requires a claim for event candidates.
+    if (source.kind === 'event' && !claim && policy.promotion !== 'sleep-review') { skip('no-claim', source); continue; }
     kept++;
     bump(funnel.summarized.accepted, source.seat);
     const key = keyFor({ project, seat, topic });

package/src/context-bus/nightly-condense.ts

@@ -151,7 +151,7 @@ export function summaryInstruction(recipe: 'standard' | 'sleep-review' = 'standa
   const system = 'Summarize this one-line context event as a compact project/seat memory item. Return ONLY JSON: {"project":"...","topic":"...","summary":"...","claim":{"key":"...","value":"..."}}. Omit claim when the event makes no comparable factual assertion. Never invent a project, topic or claim.';
   if (recipe === 'standard') return system;
   // SLEEP1 builds on this librarian recipe; the guardian owns storage hygiene, not promotion judgments.
-  return `${system.replace('"project":"..."', '"promote":false,"project":"..."')} You are the nightly task agent (librarian). Sleep review (librarian contract): apply the coordinator promotion policy. Return a boolean "promote" for every source. Set promote=true only for sourced, durable project/seat facts or decisions; set promote=false for chatter or speculative claims. A correction with a later timestamp wins; return a comparable claim only for an explicit factual assertion so opposing claims can become OP conflict candidates. Do not perform guardian hygiene (retention, compression, size, backup, integrity or rollback).`;
+  return `${system.replace('"project":"..."', '"promote":false,"project":"..."')} You are the nightly task agent (librarian). Sleep review (librarian contract): apply the coordinator promotion policy. Return a boolean "promote" for every source. Set promote=true only for sourced, durable project/seat facts or decisions, including durable updates without a comparable claim; set promote=false for chatter or speculative claims. A correction with a later timestamp wins; return a comparable claim only for an explicit factual assertion so opposing claims can become OP conflict candidates. Do not perform guardian hygiene (retention, compression, size, backup, integrity or rollback).`;
 }
 
 export async function summarize(source: MemorySource, injected?: Record<string, MemorySummary>, recipe: 'standard' | 'sleep-review' = 'standard'): Promise<MemorySummary> {
@@ -213,6 +213,7 @@ export async function runNightlyStage(stage: Stage, context: Context, root: stri
   if (!collected?.day || !collected.events || !collected.decisions) throw new Error('collect output missing');
   if (stage === 'condense') {
     const assignments: Array<{ owner: 'coordinator'; assignee: 'nightly-task-agent'; contract: 'librarian'; recipe: 'sleep-review'; workerPid: number }> = [];
+    const policy = { promotion: 'sleep-review', retention: 'guardian' } as const;
     const items = await condenseContextDay(collected.day, dryRun ? [] : storedItems(root).filter(item => Date.parse(item.updatedAt) < Date.parse(`${collected.day}T00:00:00Z`)), {
       events: () => collected.events!, decisions: () => collected.decisions!,
       summarize: async source => {
@@ -223,7 +224,7 @@ export async function runNightlyStage(stage: Stage, context: Context, root: stri
         assignments.push({ owner: 'coordinator', assignee: 'nightly-task-agent', contract: 'librarian', recipe: 'sleep-review', workerPid });
         return result;
       },
-    }, now, { promotion: 'sleep-review', retention: 'guardian' });
+    }, now, policy);
     return { outcome: 'ok', items, assignments };
   }
   const items = context.outputs.condense?.items;

package/src/core-turn/run-goal-loop.ts

@@ -33,7 +33,7 @@ import { debug } from '../debug/log.js';
 import { publishGoalLifecycle } from '../goals/loop.js';
 import { boundReadableText } from '../self-implement/orchestrator.js';
 import { changedFiles } from '../self-implement/seams.js';
-import { getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
+import { getHarnessRole, getHarnessRunId, getHarnessSpace } from '../harness/harness-space.js';
 import { CONTROL_INBOX_DIR_ENV, drainControlInbox, drainSoftStopControlInbox, enqueueControlMemo, type ControlInboxDrain, type ControlMemoPayload } from '../harness/control-inbox.js';
 import { enqueuePendingUserInput } from '../session/pending-input.js';
 import { getCurrentPtyId } from '../agent/pty-identity.js';
@@ -200,6 +200,23 @@ export const GOAL_READBACK_PROMPT = [
   '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
 ].join('\n');
 
+/** GOAL-LOOP-INTENT-STALL (0.2.24 · OP or-audit-1010) — 구현 자식이 «도구를 한 번도 안 부르고 말만 한 턴»에
+ *  넣는 재촉. hermes-agent stall guard(`agent/turn_final_response.py` 172-205)를 본떴다.
+ *  ⛔ 기존 프롬프트 상수는 건드리지 않는다 — 재촉 문면은 이 상수 하나뿐이다. */
+export const GOAL_INTENT_STALL_PROMPT = [
+  '[act now]',
+  '말로 계획만 적고 도구를 하나도 호출하지 않았다. 지금 바로 실제로 도구를 호출해 첫 스텝을 실행하라(예: 대상 파일 읽기).',
+  '설명 문장만으로 이 턴을 끝내지 마라.',
+].join('\n');
+
+/** 재촉 상한 — 이 횟수를 쓰고도 텍스트만이면 종전 ④(텍스트 수용)로 그대로 떨어진다. */
+export const GOAL_INTENT_STALL_MAX_REPROMPTS = 2;
+
+/** 재촉 가드가 켜지는 provider — 구현 자식을 내는 provider 전부(10-11 · 첫 조각 #25876 은 OpenRouter 한정이었다 ·
+ *  실측 GLM Flash 첫 턴 40토큰 말만 하고 abandoned). 재촉은 «도구 0회·텍스트만» 턴에만 걸리므로 도구를 부르는 자식에는 영향이 없다.
+ *  목록 밖 provider(local 등)는 종전 그대로 바로 수용한다. */
+export const GOAL_INTENT_STALL_PROVIDERS: ReadonlySet<string> = new Set(['openrouter', 'openai-codex', 'anthropic', 'grok', 'bedrock']);
+
 /** evidence 누락 complete 재주입 — update_goal(complete) 를 호출했으나 evidence 가 비었을 때. */
 export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
   '[evidence required]',
@@ -264,6 +281,10 @@ export interface GoalLoopOptions {
   controlSpaceId?: string | null;
   /** Test seam — file-backed child liveness heartbeat. Default starts the workspace-file writer. */
   startLivenessHeartbeat?: typeof startChildLivenessHeartbeat;
+  /** GOAL-LOOP-INTENT-STALL — 구현 자식의 LLM provider. GOAL_INTENT_STALL_PROVIDERS 에 있을 때만 «도구 0회·텍스트만» 턴을
+   *  최대 2번 재촉한다. 생략하면 harness role 이 executor 인 프로세스에서만 활성 provider 로 푼다.
+   *  null = 가드 꺼짐. 시험은 이 인자를 명시해 env 에 기대지 않는다. */
+  intentStallProvider?: string | null;
 }
 
 export type GoalLoopStopReason =
@@ -449,10 +470,17 @@ export async function runGoalLoop(
   //   ※ 객체 홀더: onToolResult 클로저에서 변이하므로 let narrowing 대신 property 타입으로 읽는다.
   const runTests: { last: { ok: boolean; fail: number; unmatchedFilters: string[]; pass: number } | null } = { last: null };
   let lastResult: CoreTurnResult = { stopReason: 'end_turn', finalText: '' };
+  // GOAL-LOOP-INTENT-STALL — provider 는 루프 진입 시 «한 번» 정한다. 런 전체 도구 활동은 누적한다.
+  const intentStallProvider = await resolveIntentStallProvider(opts.intentStallProvider);
+  const intentStallGuard = intentStallProvider !== null && GOAL_INTENT_STALL_PROVIDERS.has(intentStallProvider);
+  let anyToolActivity = false;
+  let intentStallReprompts = 0;
+  // GOAL-LOOP-MIDRUN-STALL — 도구를 쓴 «뒤»의 말뿐인 턴 재촉은 런당 1회뿐이다.
+  let intentStallMidrunUsed = false;
 
   debug.log('goal.loop', 'start', {
     sessionId: ctx.sessionId, ...runAttribution, objective, maxIterations, noProgressLimit,
-    contextTokenLimit, contextPressureRatio,
+    contextTokenLimit, contextPressureRatio, intentStallGuard, intentStallProvider,
   }, { level: 'info' });
   const bus = getChannelBus();
   ensureProcessLifecycleBridge(bus, opts.attachLifecycleBridge ?? attachLifecycleBridge);
@@ -702,6 +730,7 @@ export async function runGoalLoop(
     const goalUpdate = findGoalUpdate(turnNewMessages);
     const rejectedTools = findRejectedToolCalls(turnNewMessages);
     const toolActivity = hadToolActivity(turnNewMessages);
+    if (toolActivity) anyToolActivity = true;
     const markerComplete = hasCompletionMarker(lastResult.finalText);
     const markerBlocked = hasBlockedMarker(lastResult.finalText);
 
@@ -868,6 +897,43 @@ export async function runGoalLoop(
     }
     readbackStreak = 0;
 
+    // ④-0 GOAL-LOOP-INTENT-STALL — OpenRouter 구현 자식이 런 내내 도구를 한 번도 안 부르고 말만 했다
+    //    (예: 「먼저 파일을 읽겠습니다」 후 멈춤). 일상 답변으로 수락하기 전에 «실제로 도구를 호출하라»를
+    //    최대 GOAL_INTENT_STALL_MAX_REPROMPTS 번 넣는다. 재촉 턴도 maxIterations 에 센다(하드캡이 이긴다).
+    //    상한을 쓰고도 텍스트만이면 포기 이벤트만 남기고 아래 ④ 로 «그대로» 떨어진다(포기 경로 불변).
+    //    ⛔ 가드가 꺼졌거나(다른 provider·비-executor) 한 번이라도 도구를 불렀으면 이 블록은 아무것도 안 한다.
+    //    ⭐ 빈 답(finalChars 0)도 «도구 0회»면 같은 정체로 본다 — 빈 답도 종전엔 text-only-accept 로 abandoned 됐다.
+    if (!toolActivity && intentStallGuard && !anyToolActivity) {
+      if (intentStallReprompts < GOAL_INTENT_STALL_MAX_REPROMPTS) {
+        intentStallReprompts += 1;
+        debug.log('goal.loop', 'intent-stall-reprompt', {
+          sessionId: ctx.sessionId, ...runAttribution, iterations, attempt: intentStallReprompts,
+          finalChars: lastResult.finalText.length, provider: intentStallProvider,
+        }, { level: 'info' });
+        messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+        continue;
+      }
+      debug.log('goal.loop', 'intent-stall-exhausted', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, attempts: intentStallReprompts,
+        provider: intentStallProvider,
+      }, { level: 'warn' });
+    }
+
+    // ④-0b GOAL-LOOP-MIDRUN-STALL — 앞서 도구를 썼는데 이번 턴은 도구 없이 말로 끝났다
+    //    (예: 파일을 읽은 뒤 「이제 수정하겠습니다」 후 멈춤 → 변경 0 abort · 10-10). 같은 가드에서
+    //    같은 GOAL_INTENT_STALL_PROMPT 를 «런당 1회»만 넣는다. 재촉 턴도 maxIterations 에 센다.
+    //    두 번째 중간 정체는 아래 ④ 로 «그대로» 떨어진다(text-only-accept 불변).
+    //    ⛔ 가드가 꺼졌으면(다른 provider·비-executor) 이 블록은 아무것도 안 한다 · ④-0 과는 anyToolActivity 로 배타.
+    if (!toolActivity && intentStallGuard && anyToolActivity && !intentStallMidrunUsed) {
+      intentStallMidrunUsed = true;
+      debug.log('goal.loop', 'intent-stall-midrun', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations,
+        finalChars: lastResult.finalText.length, provider: intentStallProvider,
+      }, { level: 'info' });
+      messages.push({ role: 'user', content: GOAL_INTENT_STALL_PROMPT });
+      continue;
+    }
+
     // ④ 순수 텍스트(도구 없음)로 끝났고 종결 신호도 없음 = 일상 답변(목표성 작업 아님).
     //    재주입하지 않고 그대로 수용해 trivial chat 을 이중 루프하지 않는다.
     if (!toolActivity) {
@@ -908,3 +974,22 @@ export async function runGoalLoop(
     stopLivenessHeartbeat();
   }
 }
+
+/** 가드 provider 를 정한다. 명시 인자가 이긴다(시험·호출부). 생략하면 «구현 자식»(harness role executor)
+ *  프로세스에서만 활성 provider(`resolveActiveProvider` — `ELANOUS_LLM_PROVIDER` 릴레이 포함)를 읽는다.
+ *  ⛔ executor 가 아닌 프로세스(ACP 대시보드·`chat --goal-loop`)는 읽지도 않는다 ⇒ null = 가드 꺼짐.
+ *  읽기 실패도 null(fail-open = 종전 동작). */
+async function resolveIntentStallProvider(explicit: string | null | undefined): Promise<string | null> {
+  if (explicit !== undefined) return explicit?.trim().toLowerCase() || null;
+  if (getHarnessRole() !== 'executor') return null;
+  try {
+    const { getUserConfig, resolveActiveProvider } = await import('../user-config.js');
+    return resolveActiveProvider(getUserConfig());
+  } catch (error) {
+    // fail-open(가드 꺼짐 = 종전 동작)이지만 «왜 꺼졌나»는 남긴다 — 조용한 꺼짐은 관측 안 한 것이다.
+    debug.log('goal.loop', 'intent-stall-provider-unresolved', {
+      error: error instanceof Error ? error.message : String(error),
+    }, { level: 'warn' });
+    return null;
+  }
+}

package/src/dashboard/ad-run-setup-bindings.ts

@@ -0,0 +1,279 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildAdRunSetup } from '../ad-pipeline/ad-run-setup.js';
+import type { CommandRunner } from '../ad-pipeline/higgsfield-backend.js';
+import type { ShootRunOptions } from '../ad-pipeline/shoot-run.js';
+import type { QcThresholds } from '../ad-pipeline/qc.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import {
+  createDashboardAdSlashRuntime as createAdSlashRuntime,
+  type DashboardAdSlashRuntime,
+  type DashboardAdSlashRuntimeDeps,
+} from './ad-slash-runtime.js';
+
+const dashboardDefaultShootRunOptions: Required<Pick<ShootRunOptions, 'pollIntervalMs' | 'maxPollsPerJob' | 'submitStaggerMs'>> = {
+  pollIntervalMs: 3_000,
+  // 2026-09-12 seedance_2_0 measured 330–400s; 174 polls = 522s, leaving 402s after six 20s staggers.
+  maxPollsPerJob: 174,
+  submitStaggerMs: 20_000,
+};
+
+/**
+ * ⛔ `src/ad-pipeline/ad-run-setup.ts` 의 `optionalProductionInputs` «사본»이다 — 그 목록은 export 가 아니다.
+ * 여기서 다시 세는 이유: 이 파일이 `buildAdRunSetup` «뒤»에 `assemblyMaterials` 를 덧붙이므로,
+ * 그 함수가 «입력» 기준으로 낸 목록은 최종 `production` 과 어긋난다(`#17880`).
+ * ⚠️ 사본이라 «늙는다» — `src/dashboard/index.test.ts` 가 권위 목록과 같은지 단언한다.
+ */
+export const dashboardOptionalProductionInputs = [
+  'assembly',
+  'assemblyMaterials',
+  'captionFontPath',
+  'musicBedPath',
+  'qcThresholds',
+  'voiceover',
+  'soundtrack',
+  'referenceAssets',
+  'shootRunOptions',
+  'ground',
+  'invariants',
+] as const;
+
+export interface DashboardAdAssetPreset {
+  readonly captionFontPath?: string;
+  readonly musicBedPath?: string;
+  readonly referenceAssets?: Readonly<Record<string, string[]>>;
+  readonly shootRunOptions?: ShootRunOptions;
+  readonly qcThresholds?: QcThresholds;
+}
+
+/** Operator-owned, instance-scoped optional asset preset; never a repository asset path. */
+export function dashboardAdAssetPresetPath(stateRoot = elanousStateRoot()): string {
+  return join(stateRoot, 'ad-assets.json');
+}
+
+/** Reads optional operator-owned asset paths without inventing local defaults. */
+export function loadDashboardAdAssetPreset(path: string): DashboardAdAssetPreset {
+  let raw: string;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return {};
+    throw new Error(`dashboard ad asset preset unreadable at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: expected an object`);
+  }
+
+  const preset = parsed as Record<string, unknown>;
+  for (const key of ['captionFontPath', 'musicBedPath'] as const) {
+    if (preset[key] !== undefined && typeof preset[key] !== 'string') {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: ${key} must be a string`);
+    }
+  }
+  if (preset.referenceAssets !== undefined && (
+    preset.referenceAssets === null
+    || typeof preset.referenceAssets !== 'object'
+    || Array.isArray(preset.referenceAssets)
+    || Object.values(preset.referenceAssets).some((value) => !Array.isArray(value) || value.some((entry) => typeof entry !== 'string'))
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: referenceAssets must be a record of string arrays`);
+  }
+  if (preset.shootRunOptions !== undefined && (
+    preset.shootRunOptions === null
+    || typeof preset.shootRunOptions !== 'object'
+    || Array.isArray(preset.shootRunOptions)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions must be an object`);
+  }
+  const shootRunOptions = preset.shootRunOptions as Record<string, unknown> | undefined;
+  for (const key of ['pollIntervalMs', 'maxPollsPerJob', 'maxPollElapsedMs', 'submitStaggerMs', 'submitRetries'] as const) {
+    if (shootRunOptions?.[key] !== undefined && (typeof shootRunOptions[key] !== 'number' || !Number.isFinite(shootRunOptions[key]))) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: shootRunOptions.${key} must be a finite number`);
+    }
+  }
+  if (preset.qcThresholds !== undefined && (
+    preset.qcThresholds === null
+    || typeof preset.qcThresholds !== 'object'
+    || Array.isArray(preset.qcThresholds)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds must be an object`);
+  }
+  const qcThresholds = preset.qcThresholds as Record<string, unknown> | undefined;
+  for (const key of ['dialogueLufsTolerance', 'colorDistance', 'frameDiffVariance'] as const) {
+    if (qcThresholds?.[key] !== undefined && (typeof qcThresholds[key] !== 'number' || !Number.isFinite(qcThresholds[key]))) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.${key} must be a finite number`);
+    }
+  }
+  if (qcThresholds?.durationRanges !== undefined && (
+    qcThresholds.durationRanges === null
+    || typeof qcThresholds.durationRanges !== 'object'
+    || Array.isArray(qcThresholds.durationRanges)
+  )) {
+    throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges must be an object`);
+  }
+  const durationRanges = qcThresholds?.durationRanges as Record<string, unknown> | undefined;
+  for (const scope of ['cut', 'master'] as const) {
+    if (durationRanges?.[scope] !== undefined && (
+      durationRanges[scope] === null
+      || typeof durationRanges[scope] !== 'object'
+      || Array.isArray(durationRanges[scope])
+    )) {
+      throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope} must be an object`);
+    }
+    const range = durationRanges?.[scope] as Record<string, unknown> | undefined;
+    if (range !== undefined) {
+      const minimumSeconds = range.minimumSeconds;
+      const maximumSeconds = range.maximumSeconds;
+      if (typeof minimumSeconds !== 'number' || !Number.isFinite(minimumSeconds)) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be a finite number`);
+      }
+      if (typeof maximumSeconds !== 'number' || !Number.isFinite(maximumSeconds)) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.maximumSeconds must be a finite number`);
+      }
+      if (minimumSeconds > maximumSeconds) {
+        throw new Error(`dashboard ad asset preset malformed at ${path}: qcThresholds.durationRanges.${scope}.minimumSeconds must be less than or equal to maximumSeconds`);
+      }
+    }
+  }
+  return {
+    ...(typeof preset.captionFontPath === 'string' ? { captionFontPath: preset.captionFontPath } : {}),
+    ...(typeof preset.musicBedPath === 'string' ? { musicBedPath: preset.musicBedPath } : {}),
+    ...(preset.referenceAssets === undefined ? {} : { referenceAssets: preset.referenceAssets as Record<string, string[]> }),
+    ...(shootRunOptions === undefined ? {} : { shootRunOptions: shootRunOptions as ShootRunOptions }),
+    ...(qcThresholds === undefined ? {} : { qcThresholds: qcThresholds as QcThresholds }),
+  };
+}
+
+export const dashboardAdCommandRunner: CommandRunner = {
+  async run(argv, options) {
+    const process = Bun.spawn([...argv], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+      ...(options?.timeoutMs ? { timeout: options.timeoutMs } : {}),
+    });
+    const [raw, stderr, exitCode] = await Promise.all([
+      new Response(process.stdout).bytes(),
+      new Response(process.stderr).text(),
+      process.exited,
+    ]);
+    return { stdout: new TextDecoder().decode(raw), stderr, exitCode, raw };
+  },
+};
+
+export function createDashboardAdRunSetupFactory(input: {
+  readonly home: string;
+  readonly date: string;
+  readonly contractsJson: string;
+  readonly runner: CommandRunner;
+  readonly assetPresetPath?: string;
+}): (allowSpend: boolean) => ReturnType<typeof buildAdRunSetup> {
+  let runSequence = 0;
+  let activeRunSlug: string | undefined;
+
+  return (allowSpend) => {
+    if (!allowSpend) {
+      const runStart = new Date();
+      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
+        .map((part) => String(part).padStart(2, '0'))
+        .join('');
+      activeRunSlug = `dashboard-ad-${time}-${++runSequence}`;
+    }
+    const slug = activeRunSlug ?? (() => {
+      const runStart = new Date();
+      const time = [runStart.getHours(), runStart.getMinutes(), runStart.getSeconds()]
+        .map((part) => String(part).padStart(2, '0'))
+        .join('');
+      return `dashboard-ad-${time}-${++runSequence}`;
+    })();
+    const assetPreset = input.assetPresetPath === undefined ? {} : loadDashboardAdAssetPreset(input.assetPresetPath);
+    let setup = buildAdRunSetup({
+      home: input.home,
+      slug,
+      date: input.date,
+      version: 1,
+      aspect: '9x16',
+      contractsJson: input.contractsJson,
+      runner: input.runner,
+      ...assetPreset,
+      referenceAssets: assetPreset.referenceAssets ?? {},
+      shootRunOptions: { ...dashboardDefaultShootRunOptions, ...assetPreset.shootRunOptions },
+      soundtrack: input.runner,
+      voiceover: { runner: input.runner, lines: [] },
+      allowSpend,
+    });
+    if (!('error' in setup) && setup.production) {
+      const production = {
+        ...setup.production,
+        assemblyMaterials: { options: { workDir: setup.workDir, outputName: setup.outputName } },
+      };
+      setup = {
+        ...setup,
+        production,
+        missingProductionInputs: dashboardOptionalProductionInputs.filter((key) => production[key] === undefined),
+      };
+    }
+    return setup;
+  };
+}
+
+/** Builds the /ad runtime bindings used by showDashboard for each invocation's spend intent. */
+export function createDashboardAdRunSetupBindings(
+  buildDashboardAdRunSetup: ReturnType<typeof createDashboardAdRunSetupFactory>,
+) {
+  let adRunSetup: ReturnType<typeof buildAdRunSetup> | undefined;
+  let outputSetupError: string | undefined;
+  try {
+    adRunSetup = buildDashboardAdRunSetup(false);
+    outputSetupError = 'error' in adRunSetup ? adRunSetup.error : undefined;
+  } catch (error) {
+    outputSetupError = error instanceof Error ? error.message : String(error);
+  }
+
+  return {
+    production: adRunSetup && !('error' in adRunSetup) ? adRunSetup.production : undefined,
+    productionForSpend: (allowSpend: boolean) => {
+      try {
+        const setup = buildDashboardAdRunSetup(allowSpend);
+        if ('error' in setup) {
+          outputSetupError = setup.error;
+          return undefined;
+        }
+        return setup.production;
+      } catch (error) {
+        outputSetupError = error instanceof Error ? error.message : String(error);
+        return undefined;
+      }
+    },
+    missingProductionInputs: adRunSetup && !('error' in adRunSetup) ? adRunSetup.missingProductionInputs : undefined,
+    get outputSetupError() {
+      return outputSetupError;
+    },
+  };
+}
+
+/** Connects the dashboard's setup state to the actual /ad runtime. */
+export function createDashboardAdSlashRuntime(
+  input: Omit<DashboardAdSlashRuntimeDeps, 'production' | 'productionForSpend' | 'missingProductionInputs' | 'outputSetupError'> & {
+    readonly adRunSetupBindings?: ReturnType<typeof createDashboardAdRunSetupBindings>;
+    readonly adRunSetupError?: string;
+  },
+): DashboardAdSlashRuntime {
+  const { adRunSetupBindings, adRunSetupError, ...deps } = input;
+  return createAdSlashRuntime({
+    ...deps,
+    production: adRunSetupBindings?.production,
+    productionForSpend: adRunSetupBindings?.productionForSpend,
+    missingProductionInputs: adRunSetupBindings?.missingProductionInputs,
+    get outputSetupError() {
+      return adRunSetupBindings?.outputSetupError ?? adRunSetupError;
+    },
+  });
+}
+

package/src/dashboard/chat-fold.ts

@@ -0,0 +1,20 @@
+import { format, getMessages } from '../expression/i18n/index.js';
+
+type Locale = NonNullable<Parameters<typeof getMessages>[0]>;
+
+export function splitNoSynthesisTail(text: string): { head: string; tail: string } | null {
+  const index = text.indexOf('[NO FINAL SYNTHESIS]');
+  if (index === -1) return null;
+  return {
+    head: text.slice(0, index).trimEnd(),
+    tail: text.slice(index),
+  };
+}
+
+/** English fallback for locale bundles that do not carry the optional key. */
+const FOLDED_TAIL_FALLBACK = '● Internal notes folded · {n} lines · press f to expand';
+
+export function buildFoldedTailLine(lineCount: number, locale?: Locale): string {
+  const template = getMessages(locale).chatFoldedInternalTail ?? FOLDED_TAIL_FALLBACK;
+  return format(template, { n: lineCount });
+}