elanous 0.2.23 → 0.2.24

package/src/dashboard/index.ts

@@ -11,280 +11,26 @@ import { spawn, spawnSync } from 'node:child_process';
 import { $ } from 'bun';
 import { LOCAL_SKILLS_DIR, SERVICE_NAMES, DATA_DIR, OBSIDIAN_VAULT } from '../config.js';
 import { dispatchDashboardSessionRuntimeTool } from './session-runtime-dispatch.js';
-import { buildAdRunSetup } from '../ad-pipeline/ad-run-setup.js';
 import { nextChatScrollOffset } from '../chat/log-scroll-key.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 { suggestProjectForFolder } from '../project/project-store.js';
 import { createProjectSuggester } from '../project/project-suggestion.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;
-    },
-  });
-}
+import {
+  createDashboardAdRunSetupBindings,
+  createDashboardAdRunSetupFactory,
+  createDashboardAdSlashRuntime,
+  dashboardAdAssetPresetPath,
+  dashboardAdCommandRunner,
+} from './ad-run-setup-bindings.js';
+export {
+  dashboardOptionalProductionInputs,
+  type DashboardAdAssetPreset,
+  dashboardAdAssetPresetPath,
+  loadDashboardAdAssetPreset,
+  dashboardAdCommandRunner,
+  createDashboardAdRunSetupFactory,
+  createDashboardAdRunSetupBindings,
+  createDashboardAdSlashRuntime,
+} from './ad-run-setup-bindings.js';
 
 export interface DashboardGlobalKeyRegistration {
   id: string;
@@ -1005,11 +751,7 @@ import { createDashboardControlSignalSlashRuntime } from './control-signal-slash
 import { createDashboardBrowserCdpSlashRuntime } from './browser-cdp-slash-runtime.js';
 import { collectGroundingFactsViaCdp } from '../product-grounding/cdp-collect.js';
 import { createDashboardSimSlashRuntime } from './sim-slash-runtime.js';
-import {
-  createDashboardAdSlashRuntime as createAdSlashRuntime,
-  type DashboardAdSlashRuntime,
-  type DashboardAdSlashRuntimeDeps,
-} from './ad-slash-runtime.js';
+import type { DashboardAdSlashRuntime } from './ad-slash-runtime.js';
 import { openDashboardLocalSimulationWebCockpit } from './sim-web-cockpit-runtime.js';
 import { createDashboardCompanionFeedbackRuntime } from './companion-feedback-runtime.js';
 import { resolveDashboardMediaSlash } from './media-slash-runtime.js';

package/src/dashboard/stale-install-check.ts

@@ -12,6 +12,17 @@ export type StaleInstallResult = {
 
 export const STALE_INSTALL_CHECK_INTERVAL_MS = 60_000;
 
+/**
+ * Builds the command that relaunches the TUI on the same daemon session: `elanous --resume <id>` boots the dashboard,
+ * loads that session (ACP session/load) and replays its turns (src/index.ts resumeSessionId · dashboard acp-boot).
+ * The user-facing hint and its key binding land with the dashboard wiring slice (`r` is the render toggle today).
+ * Intentional wiring boundary: the dashboard owns the key binding and executes this command;
+ * this scoped helper only constructs it and does not spawn a child process.
+ */
+export function buildStaleInstallRelaunchCommand(sessionId: string): string {
+  return `elanous --resume ${JSON.stringify(sessionId)}`;
+}
+
 export function formatStaleInstallNotice(result: StaleInstallResult, notifiedCount: number): string {
   const message = `새 판이 깔렸습니다 (부팅 판 ${result.bootCommit!.slice(0, 7)} → 지금 ${result.installedCommit!.slice(0, 7)}) · TUI 를 다시 띄우면 새 판으로 돕니다`;
   return notifiedCount >= 2 ? `${message} · 이 TUI 가 뜬 뒤 ${notifiedCount}번째 새 판` : message;

package/src/debug/log-diet.ts

@@ -2,6 +2,13 @@ import type { DebugEvent } from './log.js';
 
 export const LOG_DIET_WINDOW_MS = 60_000;
 
+/** LOG-DIET-2 — minimum spacing between two `log.diet/suppressed` summary releases.
+ *  One diet window: a folded stream costs at most one summary row per window instead of one per flush. */
+export const LOG_DIET_SUMMARY_MIN_INTERVAL_MS = LOG_DIET_WINDOW_MS;
+
+/** LOG-DIET-2 — pending-stream pressure that releases summaries before the interval elapses. */
+export const LOG_DIET_SUMMARY_MAX_PENDING = 256;
+
 export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> = {
   'watchdog/activity': 'consecutive',
   'user-config.llm/provider-resolved': 'repeat',
@@ -9,6 +16,11 @@ export const LOG_DIET_KEYS: Readonly<Record<string, 'repeat' | 'consecutive'>> =
   'input.cursor.claim/chat-main': 'repeat',
   'tox.loop/waiting-capacity': 'repeat',
   'tox.loop/tick': 'repeat',
+  'llm.credential/provider-key-missing': 'repeat',
+  'llm.credential/provider-key-resolved': 'repeat',
+  'pty.manifest/output-bytes-flushed': 'repeat',
+  // `pod-lease/admit-by-usage` is NOT folded: dispatch backpressure and the TA parent-host admission
+  // read it back from logs and count rows (`admissionCounts`) — it is a judgment-path event.
 };
 
 export interface LogDietSummary {
@@ -57,14 +69,20 @@ export class LogDietGuard {
   private readonly now: () => number;
   private readonly keys: Readonly<Record<string, Policy>>;
   private readonly maxStreams: number;
+  private readonly summaryMinIntervalMs: number;
+  private readonly summaryMaxPending: number;
   private readonly disabled: boolean;
   private readonly streams = new Map<string, Stream>();
+  private lastSummaryReleaseAt = Number.NEGATIVE_INFINITY;
+  private pendingStreams = 0;
 
-  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number } = {}) {
+  constructor(opts: { windowMs?: number; now?: () => number; keys?: Readonly<Record<string, Policy>>; maxStreams?: number; summaryMinIntervalMs?: number; summaryMaxPending?: number } = {}) {
     this.windowMs = opts.windowMs ?? LOG_DIET_WINDOW_MS;
     this.now = opts.now ?? Date.now;
     this.keys = opts.keys ?? LOG_DIET_KEYS;
     this.maxStreams = Math.max(1, opts.maxStreams ?? 2000);
+    this.summaryMinIntervalMs = Math.max(0, opts.summaryMinIntervalMs ?? LOG_DIET_SUMMARY_MIN_INTERVAL_MS);
+    this.summaryMaxPending = Math.max(1, opts.summaryMaxPending ?? LOG_DIET_SUMMARY_MAX_PENDING);
     this.disabled = process.env.ELANOUS_LOG_DIET === 'off';
   }
 
@@ -84,8 +102,9 @@ export class LogDietGuard {
 
   admit(rec: DietRecord): { pass: boolean; summaries: LogDietSummary[] } {
     const policy = this.keys[`${rec.category}/${rec.event}`];
+    // LOG-DIET-2 — a registered key folds at warn too; unregistered warn/error/critical alarms never fold.
     if (this.disabled || !policy || rec.category === 'log.diet'
-      || rec.level === 'warn' || rec.level === 'error' || rec.level === 'critical') {
+      || rec.level === 'error' || rec.level === 'critical') {
       return { pass: true, summaries: [] };
     }
 
@@ -108,6 +127,7 @@ export class LogDietGuard {
       this.streams.delete(key); // Evict the least recently observed flow.
       this.streams.set(key, stream);
       if ((policy === 'repeat' || stream.value === value) && time - stream.lastEmittedAt < this.windowMs) {
+        if (stream.count === 0) this.pendingStreams++;
         stream.count++;
         const at = new Date(time).toISOString();
         stream.firstSuppressedAt ??= at;
@@ -115,7 +135,7 @@ export class LogDietGuard {
         return { pass: false, summaries };
       }
       const pending = this.summary(stream);
-      if (pending) summaries.push(pending);
+      if (pending) { summaries.push(pending); this.pendingStreams--; }
       stream.count = 0;
       stream.firstSuppressedAt = undefined;
       stream.lastSuppressedAt = undefined;
@@ -128,7 +148,7 @@ export class LogDietGuard {
       const oldestKey = this.streams.keys().next().value!;
       const oldest = this.streams.get(oldestKey)!;
       const pending = this.summary(oldest);
-      if (pending) summaries.push(pending);
+      if (pending) { summaries.push(pending); this.pendingStreams--; }
       this.streams.delete(oldestKey);
     }
     this.streams.set(key, { category: rec.category, event: rec.event,
@@ -138,8 +158,12 @@ export class LogDietGuard {
     return { pass: true, summaries };
   }
 
-  /** Emit pending counts without reopening the current sample windows. */
-  flushPending(): LogDietSummary[] {
+  /** Emit pending counts without reopening the current sample windows.
+   *  LOG-DIET-2 — releases are spaced by `summaryMinIntervalMs` unless forced (drain)
+   *  or the pending-stream pressure cap is hit. Deferred counts stay accumulated on
+   *  their streams, so a held-back release never drops a suppressed event. */
+  flushPending(force = false): LogDietSummary[] {
+    if (!force && !this.summaryReleaseDue()) return [];
     const summaries: LogDietSummary[] = [];
     for (const stream of this.streams.values()) {
       const pending = this.summary(stream);
@@ -148,11 +172,18 @@ export class LogDietGuard {
       stream.firstSuppressedAt = undefined;
       stream.lastSuppressedAt = undefined;
     }
+    this.pendingStreams = 0;
+    this.lastSummaryReleaseAt = this.now();
     return summaries;
   }
 
+  private summaryReleaseDue(): boolean {
+    if (this.pendingStreams >= this.summaryMaxPending) return true;
+    return this.now() - this.lastSummaryReleaseAt >= this.summaryMinIntervalMs;
+  }
+
   drain(): LogDietSummary[] {
-    const summaries = this.flushPending();
+    const summaries = this.flushPending(true);
     this.streams.clear();
     return summaries;
   }

package/src/debug/log.ts

@@ -561,6 +561,24 @@ class DebugLog {
     for (const summary of summaries) this.log('log.diet', 'suppressed', summary);
   }
 
+  /** LOG-DIET-2 — summaries are now spaced by the diet window, so a short-lived process could exit
+   *  holding folded counts. On the first suppression we arm one exit drain that force-releases them
+   *  (and flushes the sinks synchronously) so a held-back release never drops a count at shutdown. */
+  private _logDietExitArmed = false;
+  private armLogDietExitDrain(): void {
+    if (this._logDietExitArmed) return;
+    this._logDietExitArmed = true;
+    const drain = (): void => { try { this.drainLogDietPending(); } catch { /* exit path must not throw */ } };
+    process.once('beforeExit', drain);
+    process.once('exit', drain);
+  }
+
+  /** Force-release every pending diet summary (ignores the summary interval) and flush sinks. */
+  drainLogDietPending(): void {
+    if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending(true));
+    this.flush();
+  }
+
   /** Force any buffered events to disk immediately. */
   flush(): void {
     if (this._logDietGuard) this.emitLogDietSummaries(this._logDietGuard.flushPending());
@@ -615,7 +633,7 @@ class DebugLog {
     if (this._logDietGuard) {
       const decision = this._logDietGuard.admit(rec);
       this.emitLogDietSummaries(decision.summaries);
-      if (!decision.pass) return;
+      if (!decision.pass) { this.armLogDietExitDrain(); return; }
     }
 
     // Ring buffer — always populated when at least one sink is live so

package/src/domains/release-tool.ts

@@ -9,6 +9,7 @@ import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hi
 import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist, type ChecklistItem } from '../release-loop/checklist.js';
 import { add, move, validateVersion } from '../release-loop/feature-store.js';
 import { formatKst, formatSchedule, getSchedule, listSchedules, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+import { mergedPrsLast24h as countMergedPrsLast24h } from '../release-loop/placement.js';
 import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
 import { formatElanousCard, type ElanousCard } from './elanous-card.js';
 
@@ -24,6 +25,7 @@ export const RELEASE_STATUS_SPEC: LLMToolSpec = {
   parameters: { type: 'object', properties: {
     version: { type: 'string', description: '조회할 판. 생략하면 개발 판과 다음 판.' },
     topic: { type: 'string', enum: ['status', 'features', 'cell', 'schedule', 'ops'], description: '읽을 대상(기본 status).' },
+    action: { type: 'string', enum: ['schedule', 'blocked', 'landed'], description: '짧은 읽기 요약: 다음 컷 일정·막힌 칸·최근 24시간 병합 PR.' },
     id: { type: 'string', description: 'topic=cell 때 찾을 칸 id(필수).' },
   }, required: [] },
 };
@@ -57,6 +59,7 @@ export interface ReleaseToolDeps {
   add?: typeof add;
   move?: typeof move;
   setSchedule?: typeof setSchedule;
+  mergedPrsLast24h?: (now?: Date) => number;
 }
 
 function nextVersion(version: string): string {
@@ -129,6 +132,42 @@ export function dispatchReleaseStatus(args: Record<string, unknown>, deps: Relea
     return { text: facts.length ? facts.map(fact => JSON.stringify(fact)).join('\n') : '운영 개관: 관측된 사실 없음', structured: { facts } };
   }
   const dev = checklistDevVersion(deps.devVersion?.() ?? devVersion());
+  if (args.action !== undefined) {
+    const action = args.action;
+    if (typeof action !== 'string' || !['schedule', 'blocked', 'landed'].includes(action)) {
+      throw new Error('action 은 schedule, blocked, landed 중 하나여야 합니다');
+    }
+    if (action === 'schedule') {
+      const released = checklist(dev).released;
+      const schedules = (deps.schedules ?? listSchedules)()
+        .filter(row => requested ? row.version === requested : !released || versionOrder(row.version, released) > 0)
+        .sort((a, b) => versionOrder(a.version, b.version));
+      const text = schedules.length ? `다음 컷 시각:\n${schedules.map(formatSchedule).join('\n')}` : '다음 컷 시각: 일정 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? dev });
+      return { text, structured: { schedules: schedules.map(row => ({ version: row.version, cutAt: row.cutAt, landBy: row.landBy,
+        publishAt: row.publishAt ?? null, freezeFrom: row.freezeFrom ?? null, freezeUntil: row.freezeUntil ?? null })) } };
+    }
+    if (action === 'blocked') {
+      const versions = requested ? [requested as string] : [dev, nextVersion(dev)];
+      const blocked = versions.flatMap(version => {
+        validateVersion(version);
+        return checklist(version).items
+          .filter(item => item.status === 'red' || (item.status === 'yellow' && item.disposition === 'block'))
+          .map(item => ({ version, id: item.id, title: firstLine(item.title), status: item.status, disposition: item.disposition ?? null, owner: item.owner ?? null }));
+      });
+      const text = blocked.length ? `막힌 칸 ${blocked.length}개:\n${blocked.map(item => `${item.version} · ${item.id} ${item.title} · ${item.status === 'red' ? '빨강' : '보류'}${item.owner ? ` · 담당 ${item.owner}` : ''}`).join('\n')}` : '막힌 칸 없음';
+      debug.log('release.tool', 'status', { action, version: requested ?? versions.join(',') });
+      return { text, structured: { blocked } };
+    }
+    const now = deps.now ?? new Date();
+    const merged = (deps.mergedPrsLast24h ?? countMergedPrsLast24h)(now);
+    debug.log('release.tool', 'status', { action, since: new Date(now.getTime() - 86_400_000).toISOString(), until: now.toISOString(), merged });
+    return { text: `어제 착지: 최근 24시간 병합 PR ${merged}건`, structured: {
+      mergedPrsLast24h: merged,
+      since: new Date(now.getTime() - 86_400_000).toISOString(),
+      until: now.toISOString(),
+    } };
+  }
   if (topic === 'features' || topic === 'cell' || topic === 'schedule') {
     let result: { text: string; structured: Record<string, unknown> };
     if (topic === 'features') {

package/src/error-report/report.ts

@@ -31,7 +31,7 @@ export interface ErrorReport {
   at: string; consent: true;
 }
 
-export interface ErrorReportSettings { enabled: boolean; identity: boolean; email?: string; telegramUser?: string }
+export interface ErrorReportSettings { enabled: boolean; identity: boolean; consented?: boolean; email?: string; telegramUser?: string }
 
 export interface ErrorReportDeps {
   configDir?: () => string;
@@ -100,10 +100,18 @@ export function buildErrorReport(input: ErrorReportInput, ctx: { installId: stri
   return report;
 }
 
+/** First-run notice: says what is actually sent — identity fields go along only when errorReports.identity is on. */
+export function errorReportNoticeLine(config: { identity?: boolean; email?: string; telegramUser?: string } | undefined): string {
+  const fields = [config?.email ? '이메일' : '', config?.telegramUser ? '텔레그램 사용자' : ''].filter(Boolean).join('·');
+  // Mirrors buildErrorReport: a field goes along only when identity is on AND the field is set.
+  const who = config?.identity === true && fields ? `진단과 함께 설정된 신원(${fields})을` : '익명 진단을';
+  return `오류 보고 안내: 오류 발생 시 ${who} 운영팀에 전송합니다. 끄려면 \`elanous config set errorReports.enabled false\`.`;
+}
+
 function defaultSettings(): ErrorReportSettings {
   try {
     const er = getUserConfig().errorReports;
-    return { enabled: er?.enabled !== false, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
+    return { enabled: er?.enabled !== false, consented: er?.noticeShown === true, identity: er?.identity === true, ...(er?.email ? { email: er.email } : {}), ...(er?.telegramUser ? { telegramUser: er.telegramUser } : {}) };
   } catch { return { enabled: false, identity: false }; }
 }
 
@@ -137,10 +145,17 @@ export async function reportError(input: ErrorReportInput, deps: ErrorReportDeps
     if (!settings.enabled) return { sent: false, reason: 'disabled' };
     const now = (deps.now ?? Date.now)();
     const key = `${input.code}\u0000${input.message.slice(0, 200)}`;
+    const configDir = (deps.configDir ?? getElanousConfigDir)();
+    if (settings.consented !== true) {
+      const report = buildErrorReport(input, {
+        installId: installId(configDir), settings, nexus: { alive: false }, at: new Date(now).toISOString(),
+      });
+      keepPending(report, configDir, deps);
+      return { sent: false, reason: 'awaiting-notice' };
+    }
     const previous = lastSent.get(key);
     if (previous !== undefined && now - previous < SAME_ERROR_GAP_MS) return { sent: false, reason: 'recently-sent' };
     lastSent.set(key, now);
-    const configDir = (deps.configDir ?? getElanousConfigDir)();
     const report = buildErrorReport(input, {
       installId: installId(configDir), settings, nexus: await (deps.nexusMeta ?? defaultNexusMeta)(), at: new Date(now).toISOString(),
     });
@@ -186,7 +201,9 @@ function keepPending(report: ErrorReport, configDir: string, deps: ErrorReportDe
 export async function retryPendingErrorReport(deps: ErrorReportDeps = {}): Promise<ReportOutcome> {
   try {
     if (!(deps.enabledByEnvironment ?? defaultEnabledByEnvironment)()) return { sent: false, reason: 'environment' };
-    if (!(deps.settings ?? defaultSettings)().enabled) return { sent: false, reason: 'disabled' };
+    const settings = (deps.settings ?? defaultSettings)();
+    if (!settings.enabled) return { sent: false, reason: 'disabled' };
+    if (settings.consented !== true) return { sent: false, reason: 'awaiting-notice' };
     const configDir = (deps.configDir ?? getElanousConfigDir)();
     const file = pendingFile(configDir);
     if (!existsSync(file)) return { sent: false, reason: 'none' };

package/src/github/pr-labels.ts

@@ -32,6 +32,7 @@ export const PR_LABELS = [
   { name: 'elanous:release-hold', axis: 'addon', color: 'D4C5F9', description: 'Exclude from release notes until verified in production', appliedBy: ['launcher', 'session', 'human'], sweep: { action: 'none' } },
   { name: 'elanous:idea-stale', axis: 'addon', color: 'FBCA04', description: 'Approval pending beyond the notification threshold', appliedBy: ['sweeper'], sweep: { action: 'notify', afterDays: IDEA_STALE_DAYS } },
   { name: 'elanous:needs-rebase', axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper'], sweep: { action: 'block-approval' } },
+  { name: 'elanous:bench', axis: 'addon', color: 'C5DEF5', description: 'Bench arm output: never landed or swept; the owner harvests the winner onto main', appliedBy: ['harness'], sweep: { action: 'none' } },
   { name: 'elanous:harvestable', axis: 'addon', color: 'FBCA04', description: 'Pod terminal marked this PR for harvest', appliedBy: ['harness'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:from-harness', axis: 'origin', color: 'C5DEF5', description: 'Launched from a harness goal', appliedBy: ['harness'], sweep: { action: 'none' } },
   { name: 'elanous:from-intake', axis: 'origin', color: 'C5DEF5', description: 'Launched from an absorbed idea', appliedBy: ['launcher'], sweep: { action: 'none' } },