elanous 0.2.23 → 0.2.25

package/src/ops/overview-cache.ts

@@ -0,0 +1,175 @@
+import { debug } from '../debug/log.js';
+import { parentPort, Worker } from 'node:worker_threads';
+import { collectOverview, type CollectOptions } from './overview-collect.js';
+import { computeVerdict, unmeasured, okCell, type OverviewSnapshot, type PodMemberRow } from './overview.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getElanousConfigDirOverride, setElanousConfigDir } from '../elanous-config-dir.js';
+
+const SNAPSHOT_MS = 10_000;
+const POD_MS = 60_000;
+const POD_STALE_MS = 2 * POD_MS;
+/** Bounds for distinct (version, owner, since) keys: memo entries kept and collections in flight. */
+const MAX_MEMO = 32;
+const MAX_PENDING = 2;
+
+type PodReading = { context: string; occupied: number | null; reason: string | null; observedAt: number };
+type OverviewData = OverviewSnapshot & ReturnType<typeof computeVerdict> & { cacheAgeMs: number; durationMs: number; sources: string[]; refreshFailed: string | null };
+type WorkerMessage = ({ kind: 'pods' } | { kind: 'snapshot'; options: CollectOptions }) & { configDir?: string };
+
+/** The kubectl-capable grid reader lives in a worker, never on the HTTP event loop. */
+const port = parentPort;
+if (port) {
+  port.on('message', async (message: WorkerMessage) => {
+    try {
+      // A worker does not share the main thread's module state: carry the daemon's universe in.
+      if (message.configDir) setElanousConfigDir(message.configDir);
+      if (message.kind === 'pods') {
+        const { buildGridData } = await import('../nexus/api/grid.js');
+        const rows = buildGridData().members.map((m) => ({ context: m.context, occupied: m.occupied, reason: m.reason, observedAt: Date.now() }));
+        port.postMessage({ rows });
+      } else port.postMessage({ snapshot: await collectOverview(message.options) });
+    } catch (error) {
+      port.postMessage({ error: error instanceof Error ? error.message : String(error) });
+    }
+  });
+}
+
+function workerRead<T>(message: WorkerMessage, timeoutMs: number, field: 'rows' | 'snapshot'): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(new URL('./overview-cache.ts', import.meta.url));
+    let settled = false;
+    const finish = (error?: Error, result?: T) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      void worker.terminate();
+      if (error) reject(error);
+      else resolve(result!);
+    };
+    const timeout = setTimeout(() => finish(new Error(`${field} 측정 시간 초과`)), timeoutMs);
+    worker.on('message', (result: { rows?: PodReading[]; snapshot?: OverviewSnapshot; error?: string }) => {
+      if (result.error) finish(new Error(result.error));
+      else finish(undefined, result[field] as T);
+    });
+    worker.on('error', (error) => finish(error instanceof Error ? error : new Error(String(error))));
+    const configDir = getElanousConfigDirOverride();
+    worker.postMessage({ ...message, ...(configDir ? { configDir } : {}) });
+  });
+}
+
+const measurePodsInWorker = () => workerRead<PodReading[]>({ kind: 'pods' }, 55_000, 'rows');
+const collectInWorker = (options: CollectOptions) => workerRead<OverviewSnapshot>({ kind: 'snapshot', options: { ...options, root: options.root ?? effectiveInstanceRoot() } }, 30_000, 'snapshot');
+
+function pendingSnapshot(at: number, since: string, reason: string): OverviewSnapshot {
+  const missing = <T>(name: string) => unmeasured<T>(name, reason);
+  return {
+    // Same resolution the collector uses; never the daemon's cwd.
+    generatedAt: new Date(at).toISOString(), instanceRoot: effectiveInstanceRoot(), since,
+    release: { version: missing('release.version'), run: missing('release.run'), schedule: missing('release.schedule'), checklist: missing('release.checklist') },
+    tasks: { byOwner: missing('tasks.byOwner'), done: missing('tasks.done'), launchable: missing('tasks.launchable'), capacity: missing('tasks.capacity') },
+    machines: { hosts: [], pods: [], parents: missing('machines.parents') },
+    landings: missing('landings'), loops: [],
+  };
+}
+
+export function createOverviewCache(deps: {
+  collect?: (opts: CollectOptions) => Promise<OverviewSnapshot>;
+  measurePods?: () => Promise<PodReading[]>;
+  now?: () => number;
+  schedule?: (tick: () => void, ms: number) => NodeJS.Timeout;
+} = {}) {
+  const now = deps.now ?? Date.now;
+  const collect = deps.collect ?? collectInWorker;
+  const backgroundSnapshot = !deps.collect;
+  const measurePods = deps.measurePods ?? measurePodsInWorker;
+  const schedule = deps.schedule ?? ((tick: () => void, ms: number): NodeJS.Timeout => setInterval(tick, ms));
+  // The memo holds the collected snapshot only; Pod occupancy and the verdict are
+  // overlaid at response time so a failed or stale (120 s) measurement shows at once.
+  type Entry = { at: number; snapshot: OverviewSnapshot; durationMs: number; failure?: string; retryAt?: number };
+  const memo = new Map<string, Entry>();
+  const pending = new Map<string, Promise<void>>();
+  let podRows: PodReading[] = [];
+  let podFailure: string | null = null;
+  let podTimer: ReturnType<typeof setInterval> | null = null;
+  let podPending = false;
+
+  const refreshPods = async () => {
+    if (podPending) return;
+    podPending = true;
+    try { podRows = await measurePods(); podFailure = null; }
+    catch (error) { podRows = []; podFailure = error instanceof Error ? error.message : String(error); }
+    finally { podPending = false; }
+  };
+  const start = () => {
+    if (podTimer) return;
+    // The timer starts on the first authorized read; measurement never runs on the request stack.
+    podTimer = schedule(() => { void refreshPods(); }, POD_MS);
+    podTimer.unref();
+  };
+  const present = (entry: Entry): OverviewData => {
+    const at = now();
+    const byContext = new Map(podRows.map((row) => [row.context, row]));
+    const pods: PodMemberRow[] = entry.snapshot.machines.pods.map((pod) => {
+      const row = byContext.get(pod.context);
+      const stale = row && at - row.observedAt >= POD_STALE_MS;
+      const occupied = !podFailure && row && !stale && row.occupied !== null
+        ? okCell(row.occupied, 'pod pool background measure', new Date(row.observedAt).toISOString())
+        : unmeasured<number>('pod pool background measure', podFailure ?? (stale ? '낡음(120초)' : row?.reason ?? '측정 대기'), row ? new Date(row.observedAt).toISOString() : null);
+      return { ...pod, occupied };
+    });
+    const full = { ...entry.snapshot, machines: { ...entry.snapshot.machines, pods } };
+    return { ...full, ...computeVerdict(full), durationMs: entry.durationMs,
+      sources: [full.release.run.source, full.tasks.launchable.source, full.tasks.capacity.source],
+      cacheAgeMs: Math.max(0, at - entry.at), refreshFailed: entry.failure ?? null };
+  };
+  const get = async (options: Pick<CollectOptions, 'version' | 'owner'> & { sinceMs?: number; sinceLabel?: string } = {}): Promise<OverviewData> => {
+    start();
+    const key = JSON.stringify([options.version ?? null, options.owner ?? null, options.sinceMs ?? 3_600_000]);
+    const at = now();
+    // Drop expired entries of other keys, then cap the memo (oldest first).
+    for (const [other, entry] of memo) if (other !== key && !pending.has(other) && at - entry.at >= SNAPSHOT_MS && (entry.retryAt ?? 0) <= at) memo.delete(other);
+    const cached = memo.get(key);
+    // A failed refresh keeps the original collection time (true age) and only delays the retry.
+    if (cached && (at - cached.at < SNAPSHOT_MS || backgroundSnapshot && pending.has(key) || (cached.retryAt ?? 0) > at)) return present(cached);
+    let current = pending.get(key);
+    if (!current && pending.size >= MAX_PENDING) {
+      // Collections in flight are capped; answer from what we have instead of starting another worker.
+      const entry = cached ?? { at, snapshot: pendingSnapshot(at, options.sinceLabel ?? '최근 1h', '동시 수집 상한'), durationMs: 0 };
+      return present({ ...entry, failure: entry.failure ?? `동시 수집 상한(${MAX_PENDING})` });
+    }
+    if (!current) {
+      // Evict only when a new key is about to be stored, never on a hit for an existing key.
+      if (!memo.has(key)) while (memo.size >= MAX_MEMO) { const oldest = [...memo.keys()].find((other) => !pending.has(other)); if (!oldest) break; memo.delete(oldest); }
+      if (backgroundSnapshot && !cached) {
+        // Placeholder until the worker answers; it is not a collection.
+        memo.set(key, { at, snapshot: pendingSnapshot(at, options.sinceLabel ?? '최근 1h', '백그라운드 스냅숏 수집 대기'), durationMs: 0 });
+      }
+      current = (async () => {
+        const startAt = now();
+        const snapshot = await collect({ sinceMs: options.sinceMs ?? 3_600_000, sinceLabel: options.sinceLabel ?? '최근 1h',
+          ...(options.version ? { version: options.version } : {}), ...(options.owner ? { owner: options.owner } : {}), now: startAt });
+        // Age counts from when collection started (= snapshot.generatedAt), not when it finished.
+        const entry = { at: startAt, snapshot, durationMs: now() - startAt };
+        memo.set(key, entry);
+        const verdict = present(entry);
+        debug.log('ops.overview', 'verdict', { verdict: verdict.verdict, reasons: verdict.reasons, cacheAgeMs: verdict.cacheAgeMs, durationMs: entry.durationMs });
+      })();
+      pending.set(key, current);
+      void current.then(
+        () => { pending.delete(key); },
+        (error) => {
+          pending.delete(key);
+          debug.log('ops.overview', 'refresh-failed', { reason: error instanceof Error ? error.message : String(error) });
+          const prior = memo.get(key);
+          if (prior) memo.set(key, { ...prior, failure: error instanceof Error ? error.message : String(error), retryAt: now() + SNAPSHOT_MS });
+        },
+      );
+    }
+    if (!backgroundSnapshot) {
+      try { await current; }
+      catch (error) { if (!memo.has(key)) throw error; }
+    }
+    return present(memo.get(key)!);
+  };
+  return { get, memoSize: () => memo.size, stop: () => { if (podTimer) clearInterval(podTimer); podTimer = null; memo.clear(); } };
+}

package/src/ops/overview.ts

@@ -6,6 +6,8 @@
  * ⛔ «못 잼»은 `value:null` ⊕ `reason` 이다 — 절대 0 으로 읽지 않는다(판정도 그렇다).
  */
 
+import { formatLandingThroughput, type LandingThroughput } from '../task-agent/cover.js';
+
 export type CellStatus = 'ok' | 'unmeasured' | 'partial';
 export interface Cell<T> {
   value: T | null;
@@ -84,6 +86,8 @@ export interface OverviewSnapshot {
     parents: Cell<ParentsInfo>;
   };
   landings: Cell<{ count: number; recent: string[] }>;
+  /** Optional until launch/PR/age sources are wired; existing snapshots keep their exact output. */
+  throughput?: Cell<LandingThroughput>;
   loops: LoopRow[];
 }
 
@@ -176,6 +180,7 @@ export function unmeasuredCells(s: OverviewSnapshot): string[] {
   for (const h of s.machines.hosts) visit(`machines.${h.name}`, h.load);
   for (const p of s.machines.pods) visit(`pods.${p.context}`, p.occupied);
   visit('machines.parents', s.machines.parents); visit('landings', s.landings);
+  if (s.throughput) visit('throughput', s.throughput);
   for (const l of s.loops) visit(`loops.${l.name}`, l.beat);
   return out;
 }
@@ -215,6 +220,9 @@ export function renderOverview(s: OverviewSnapshot, v: VerdictResult, meta: { el
   lines.push(`       Pod ${s.machines.pods.map((p) => `${p.context} ${show(p.occupied, String)}/${p.capacity}`).join(' · ') || '못 잼(풀 설정 없음)'}`);
   lines.push(`       하니스 부모(이 기계) ${show(s.machines.parents, (p) => `${p.count} · 6h 넘음 ${p.staleOver6h}${p.oldestHours !== null ? ` · 최고 ${p.oldestHours}h` : ''}`)}`);
   lines.push(`착지   ${s.since} ${show(s.landings, (l) => `${l.count}`)} [${s.landings.source}]`);
+  if (s.throughput) {
+    lines.push(`${show(s.throughput, formatLandingThroughput)} [${s.throughput.source}]`);
+  }
   for (const l of s.loops) {
     lines.push(`루프   ${l.name}${l.era === 'seat-era' ? ' [자리 시대 원천]' : ''} ${show(l.beat, (b) => `${kst(b.lastAt)} (${Math.round(b.ageSeconds / 60)}분 전)${b.alive === null ? '' : b.alive ? ' 살아 있음' : ' 프로세스 없음'}${l.staleAfterSeconds === null ? ' · 주기 미상(판정 제외)' : ''}`)}`);
   }

package/src/preview/terminal.ts

@@ -19,7 +19,6 @@
 // just its mental model (active vs alternate buffer, viewport,
 // cursor, cell attrs).
 
-import type { IPty } from 'node-pty';
 import * as fs from 'node:fs';
 import { StringDecoder } from 'node:string_decoder';
 import { Terminal } from '@xterm/headless';
@@ -104,6 +103,17 @@ export interface PreviewTerminalOpts {
   onRawOutput?: (chunk: string) => void;
 }
 
+// ⛔ `import type { IPty } from 'node-pty'` 도 두지 않는다 — PWA `next build` 가 이 파일까지 타입 검사하는데,
+//   node-pty 는 optionalDependency 라 리눅스(WSL)·게이트 Pod 설치에서 빠지면 «Cannot find module 'node-pty'»
+//   로 빌드가 죽고 self-update 가 매번 실패한다(LINUX-SELF-UPDATE-NODEPTY · 10-11). 이 파일이 실제로 쓰는 면만 둔다.
+/** node-pty `IPty` 중 이 파일이 부르는 면(pid · resize · kill · onExit). master fd 는 resolveMasterFd 가 비공개 칸에서 읽는다. */
+export interface NodePtyHandle {
+  readonly pid: number;
+  resize(cols: number, rows: number): void;
+  kill(signal?: string): void;
+  onExit(listener: (e: { exitCode: number | null; signal?: number }) => void): unknown;
+}
+
 /** Shared so tests can override (fake pty) — the default is node-pty. */
 export type SpawnFn = (shell: string, args: string[], opts: {
   name: string;
@@ -111,7 +121,7 @@ export type SpawnFn = (shell: string, args: string[], opts: {
   rows: number;
   cwd: string;
   env: Record<string, string>;
-}) => IPty;
+}) => NodePtyHandle;
 
 // ⛔⭐ `node-pty` 를 «최상위»에서 싣지 않는다 — 이 모듈은 dashboard·shell-runner 등 다섯 곳이
 //   정적으로 끌어오므로, 최상위 import 면 ***PTY 를 안 쓰는 명령(`--version`)까지*** 네이티브 바인딩을
@@ -124,7 +134,7 @@ export type SpawnFn = (shell: string, args: string[], opts: {
 const defaultSpawn: SpawnFn = (shell, args, o) => {
   // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-explicit-any
   const pty: any = require('node-pty');
-  return pty.spawn(shell, args, o as any) as IPty;
+  return pty.spawn(shell, args, o as any) as NodePtyHandle;
 };
 
 /** node-pty 네이티브 `resize(fd, cols, rows)` 를 임의의 master fd(우리 dup)에 부른다. 'ok' 또는 실패 사유. */
@@ -163,7 +173,7 @@ export interface PreviewRegistryDeps {
 }
 
 export class PreviewTerminal {
-  private pty: IPty | null = null;
+  private pty: NodePtyHandle | null = null;
   private dupFd: number = -1;
   /** ★ P0b-2 — useRegistry 모드일 때 공유 버스 핸들(dup-fd 대신). null=dup-fd 경로(기본). */
   private registryHandle: PtyHandle | null = null;
@@ -470,7 +480,7 @@ export class PreviewTerminal {
   /** node-pty doesn't publish its master fd as a stable field; dig
    *  through the plausible private slots in order of most-to-least
    *  likely so a minor library revision doesn't bite us. */
-  private resolveMasterFd(p: IPty): number | null {
+  private resolveMasterFd(p: NodePtyHandle): number | null {
     const any = p as any;
     const fd = any._fd
       ?? any._socket?._handle?.fd

package/src/project/project-store.ts

@@ -10,9 +10,11 @@ export interface Project {
   name: string;
   primaryFolder?: string;
   createdAt: string;
+  relations?: Array<{ type: 'dependsOn' | 'derivedFrom' | 'partOf' | 'deploysTo'; target: string }>;
 }
 
 const PROJECT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const RELATION_TYPES = new Set(['dependsOn', 'derivedFrom', 'partOf', 'deploysTo']);
 
 function validId(id: unknown): id is string {
   return typeof id === 'string' && PROJECT_ID.test(id);
@@ -26,9 +28,27 @@ function validateProject(value: unknown): Project {
     || (item.primaryFolder !== undefined && (typeof item.primaryFolder !== 'string' || !isAbsolute(item.primaryFolder)))) {
     throw new Error('invalid project record');
   }
+  if (item.relations !== undefined) {
+    if (!Array.isArray(item.relations)) throw new Error('invalid project record');
+    const seen = new Set<string>();
+    for (const rel of item.relations) {
+      if (!rel || typeof rel !== 'object' || Array.isArray(rel)) throw new Error('invalid project record');
+      const edge = rel as Record<string, unknown>;
+      if (!RELATION_TYPES.has(edge.type as string) || !validId(edge.target) || edge.target === item.id) {
+        throw new Error('invalid project record');
+      }
+      const key = `${edge.type}\0${edge.target}`;
+      if (seen.has(key)) throw new Error('invalid project record');
+      seen.add(key);
+    }
+  }
   return value as Project;
 }
 
+export function relationsOf(project: Project): Array<{ type: 'dependsOn' | 'derivedFrom' | 'partOf' | 'deploysTo'; target: string }> {
+  return project.relations ?? [];
+}
+
 export class ProjectStore {
   readonly dir: string;
 

package/src/prompt-cache/openai.ts

@@ -23,6 +23,7 @@
 // event with cacheReadInputTokens absent (treated as 0 downstream).
 
 import type { LLMUsage } from './types.js';
+import { readOpenRouterByokUsage } from '../llm/openrouter-byok-cost.js';
 
 /** Extract LLMUsage from an OpenAI streaming chunk. Returns null when
  *  the chunk has no usage object (every chunk except the final one
@@ -71,6 +72,8 @@ export function parseOpenAIUsage(event: unknown): LLMUsage | null {
     out.reasoningOutputTokens = r.completion_tokens_details.reasoning_tokens;
   }
   if (typeof r.cost === 'number' && Number.isFinite(r.cost) && r.cost >= 0) out.reportedCostUsd = r.cost;
+  // OR-BYOK-COST — BYOK 호출이면 `byok` ⊕ `upstreamCostUsd`(비-BYOK 이면 아무 칸도 안 더한다 · 종전 바이트).
+  Object.assign(out, readOpenRouterByokUsage(event));
   const keys = Object.keys(out).filter(k => k !== 'provider');
   return keys.length === 0 ? null : out;
 }

package/src/prompt-cache/types.ts

@@ -32,6 +32,11 @@ export interface LLMUsage {
   /** provider 가 «응답에 실어 보낸» 실제 청구액(USD) — OpenRouter `usage.cost`(요청에 `usage:{include:true}`).
    *  ⭐ 추정(카탈로그 단가)이 아니라 청구 사실이다 — 비용 판정이 이것을 먼저 쓴다(BACKLOG C7). */
   reportedCostUsd?: number;
+  /** OR-BYOK-COST — OpenRouter `usage.is_byok === true`(상류 키로 청구된 호출 · OR `cost` 는 0). */
+  byok?: true;
+  /** OR-BYOK-COST — OpenRouter `usage.cost_details.upstream_inference_cost`(상류 키로 실제 청구된 USD).
+   *  ⛔ 칸이 없거나 숫자가 아니면 «없다»(=미상) — 0 으로 꾸미지 않는다. */
+  upstreamCostUsd?: number;
 }
 
 /** Back-compat alias for callers that imported `AnthropicUsage` from

package/src/prompt-enhance/enhance.ts

@@ -158,6 +158,29 @@ export function selectEnhanceLlm(
   return { model, effort: opts.reasoningEffort ?? validEnvEffort ?? planning?.effort ?? 'high', modelSource, effortSource };
 }
 
+/**
+ * ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 골 쪼개기·적대 비평의 `streamLLM` 두 호출이 따를 노브.
+ *   `selectEnhanceLlm` 과 «같은 규칙»으로 planning 역할을 푼다: ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT →
+ *   `roleLlm.planning`(`resolveRoleLlm('planning', …)`). 규칙의 «유일한» 차이는 model 폴백이다 —
+ *   인핸서는 자기 기본(`tierModel('better')`)으로 떨어지지만, 이 길은 아무것도 설정되지 않으면
+ *   `undefined` 를 돌려 호출자가 `model` 을 아예 전달하지 않게 한다(프로바이더 기본 모델 = 종전 동작).
+ *   effort 는 `selectEnhanceLlm` 과 같은 `high` 폴백이며, 두 노브는 따로 풀린다 —
+ *   effort 만 세팅돼도 모델은 종전 기본 그대로다.
+ */
+export function selectPlanningLlm(
+  env: NodeJS.ProcessEnv = process.env,
+  config: UserConfig = getUserConfig(),
+): { model: string | undefined; effort: 'low' | 'medium' | 'high' } {
+  const planning = config.roleLlm?.planning;
+  const model = env.ELANOUS_PROMPT_ENHANCE_MODEL
+    || (planning && (planning.model || planning.tier || planning.provider)
+      ? resolveRoleLlm('planning', { config, overrides: {} }).model
+      : undefined);
+  const envEffort = env.ELANOUS_PROMPT_ENHANCE_EFFORT;
+  const validEnvEffort = envEffort === 'low' || envEffort === 'medium' || envEffort === 'high' ? envEffort : undefined;
+  return { model, effort: validEnvEffort ?? planning?.effort ?? 'high' };
+}
+
 /** 스캐폴드 생성 LLM 시스템 프롬프트 — 가산·원문불가침 규율. */
 const enhanceSystem = (deliverableHint?: string, wantsScqa = false, checklistUse: ChecklistUse = 'coverage-gate'): string =>
   [

package/src/release-loop/auto-start.ts

@@ -1,3 +1,4 @@
+import { debug } from '../debug/log.js';
 import { releaseLedgerRoot } from '../instance/resolve.js';
 import { releaseReadiness, type ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -21,7 +22,7 @@ export type AutoStartResult =
   | { status: 'no-cut' }
   | { status: 'planned'; version: string; cutAt: string }
   | { status: 'skipped'; version: string; reason: AutoStartDeferral['reason'] }
-  | { status: 'started'; version: string; cutAt: string };
+  | { status: 'started'; version: string; cutAt: string; publishAt?: string };
 
 export interface AutoStartOptions {
   windowMinutes: number;
@@ -30,7 +31,7 @@ export interface AutoStartOptions {
   ledgerRoot?: string;
   schedules?: (root: string) => ReleaseSchedule[];
   readiness?: (version: string, ledgerRoot: string, now: Date) => ReleaseReadiness;
-  launch?: (version: string) => void | AutoStartDeferral | Promise<void | AutoStartDeferral>;
+  launch?: (version: string, launchOptions?: { publishAt?: string }) => void | AutoStartDeferral | Promise<void | AutoStartDeferral>;
 }
 
 /** Select from the release schedule; the existing `release run --if-ready` owns the launch-time lock and guards. */
@@ -40,12 +41,13 @@ export async function autoStartScheduledRelease(options: AutoStartOptions): Prom
   // Validate the window even when the ledger has no rows.
   const schedule = selectScheduledCut((options.schedules ?? listSchedules)(root), now, options.windowMinutes);
   if (!schedule) return { status: 'no-cut' };
-  const { version, cutAt } = schedule;
+  const { version, cutAt, publishAt } = schedule;
   if (!options.apply) return { status: 'planned', version, cutAt };
   const readiness = (options.readiness ?? ((v, ledgerRoot, at) => releaseReadiness(v, { ledgerRoot, now: () => at })))(version, root, now);
   if (!readiness.ready) return { status: 'skipped', version, reason: readiness.reason };
   if (!options.launch) throw new Error('auto-start apply requires a launch callback');
-  const launched = await options.launch(version);
+  const launched = await options.launch(version, publishAt != null ? { publishAt: publishAt } : {});
   if (launched?.deferred) return { status: 'skipped', version, reason: launched.reason };
-  return { status: 'started', version, cutAt };
+  debug.log('release.schedule', 'auto-start', { version, cutAt, publishAt: publishAt ?? null });
+  return { status: 'started', version, cutAt, ...(publishAt != null ? { publishAt: publishAt } : {}) };
 }

package/src/release-loop/checklist.ts

@@ -102,6 +102,14 @@ export function statusChangesSince(history: readonly ChecklistHistory[], sinceIs
   return history.filter((entry) => entry.field === 'status' && Date.parse(entry.at) >= since);
 }
 
+/** CELL-DEPENDS-ID: a predecessor must name a cell that exists in SOME version — this one (data.items) or any other (otherItems). */
+function assertPredecessorsExist(predecessors: readonly string[] | undefined, data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]): void {
+  for (const id of predecessors ?? []) {
+    if (data.items.some((item) => item.id === id) || otherItems(id).length) continue;
+    throw new CliUserError(`없는 선행 칸: ${JSON.stringify(id).slice(1, -1)}`, '어느 판에도 없는 id 다 — release checklist status --json 으로 칸 id 를 확인한다');
+  }
+}
+
 function mutate(v: string, apply: (data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]) => boolean): Checklist {
   // addItem/setItem/claimItem/removeItem/seedFromRoadmap reach the generation-fenced ledger write here.
   return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
@@ -244,6 +252,7 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
       console.error(`⚠ 중복 id: ${displayedId} — ${collisions.map((item) => `${item.version} · 담당 ${JSON.stringify(item.owner ?? '-').slice(1, -1)} · ${item.title.replace(/\s+/g, ' ').slice(0, 40)}`).join(' / ')}`);
       if (!options.allowDuplicateId) throw new CliUserError(`다른 판에 이미 있는 칸: ${displayedId}`, '--allow-duplicate-id 로 허용');
     }
+    assertPredecessorsExist(input.predecessors, data, otherItems);
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
     const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), ...(refs ? { refs } : {}), updatedAt: at, updatedBy: by };
@@ -254,7 +263,7 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
 }
 
 export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; refs?: string[]; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
-  return mutate(v, (data) => {
+  return mutate(v, (data, otherItems) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
     if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new CliUserError(`잘못된 상태: ${patch.status}`);
@@ -262,6 +271,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
     if (patch.kind !== undefined && !CHECKLIST_KINDS.includes(patch.kind)) throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen|postpub');
     if (patch.priority !== undefined && !['P0', 'P1', 'P2'].includes(patch.priority)) throw new CliUserError(`잘못된 우선순위: ${patch.priority}`);
     if (patch.predecessors !== undefined && (!Array.isArray(patch.predecessors) || patch.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === id))) throw new CliUserError('잘못된 선행 칸');
+    assertPredecessorsExist(patch.predecessors, data, otherItems);
     if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
     if (patch.accelerator !== undefined && patch.accelerator !== true && patch.accelerator !== null) throw new CliUserError('가속 등급은 true(부여) 또는 null(해제)이다');
     validateCeoLoad(patch);

package/src/release-loop/gate-shards.ts

@@ -21,6 +21,8 @@ export interface GateShard {
   waitReason?: string;
   /** 계획 분 — 남은 시간 추정의 재료. */
   plannedMin?: number;
+  /** GATE-MULTI-HOST — 이 조각(가장 최근 시도)이 놓인 풀 멤버(kubectl 컨텍스트). 놓이기 전엔 없다. */
+  host?: string;
 }
 
 /** 게이트 노드의 판정 결과 — 끝난 조각의 rc≠0 을 «새로 생긴 실패»와 «기존 실패»로 가른 수. */
@@ -58,11 +60,13 @@ function shardOf(value: unknown): GateShard | null {
   const rc = num(raw.rc);
   const waitReason = str(raw.waitReason);
   const plannedMin = num(raw.plannedMin);
+  const host = str(raw.host, 120);
   return {
     id, state,
     ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
     ...(installSec !== undefined ? { installSec } : {}), ...(rc !== undefined ? { rc } : {}),
     ...(waitReason ? { waitReason } : {}), ...(plannedMin !== undefined ? { plannedMin } : {}),
+    ...(host ? { host } : {}),
   };
 }