elanous 0.2.19 → 0.2.20

package/src/nexus/api/loop-edges.ts

@@ -31,6 +31,8 @@ export interface LoopEdge {
   tick?: string;
   /** live claimed 뒤 handed·released 없이 N분 지남 = 발사 실패(끊긴 넘김). ref = 오케스트레이터 카드 id. */
   broken?: true;
+  /** launch 간선만 — 그 카드에 묶인 런 원장 runId(ID 정규식). 못 묶으면 생략(PWA 가 10분 뒤 «유령»으로 본다). */
+  run?: string;
 }
 
 /** 노드 접두 — 조율 루프는 레지스트리 행 `loop:orchestrator` 그대로 쓴다. `queue:` 는 대기열 대체 간선 자리(조각 A 밖). */
@@ -369,10 +371,10 @@ function taskAgentEdges(deps: LoopEdgesDeps, facts: readonly RunFact[], seats: R
     if (typeof card.mission === 'string' && ID.test(card.mission)) journey.links.push({ from: card.id, to: card.mission, both: false });
     if (Array.isArray(card.pieces)) journey.pieces.set(card.id, card.pieces.filter(piece => typeof piece === 'string' && ID.test(piece)));
     const launches = launchesOf(card);
+    const runId = linkedRun(card, launches[0]?.at, launchedTexts, facts, childIds);
     for (const launch of launches) {
-      if (seat(card.seat, seats) && inWindow(launch.at, since, now)) edges.push({ at: launch.at, kind: 'launch', from: TASK_AGENT_NODE, to: card.seat, ref: card.id });
+      if (seat(card.seat, seats) && inWindow(launch.at, since, now)) edges.push({ at: launch.at, kind: 'launch', from: TASK_AGENT_NODE, to: card.seat, ref: card.id, ...(runId ? { run: runId } : {}) });
     }
-    const runId = linkedRun(card, launches[0]?.at, launchedTexts, facts, childIds);
     if (runId) journey.links.push({ from: card.id, to: runId, both: true });
     const green = object(card.greenProposal);
     if (green && typeof green.at === 'string' && typeof green.checklistId === 'string' && ID.test(green.checklistId) && inWindow(green.at, since, now)) {

package/src/nexus/api/ops-api.ts

@@ -1,7 +1,8 @@
 import { lstatSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug, redactSecretText } from '../../debug/log.js';
-import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../instance/resolve.js';
+import { gateShardsPath, readGateShards, summarizeShards, type GateShardsFile, type GateShardsSummary } from '../../release-loop/gate-shards.js';
 import { listChecklist } from '../../release-loop/checklist.js';
 import { getSchedule } from '../../release-loop/release-schedule.js';
 import { jsonResponse } from './json-response.js';
@@ -123,13 +124,25 @@ export function releaseNodeFacts(output: unknown): ReleaseNodeFacts {
 }
 export interface ReleaseRunView {
   runId: string; status: string; startedAt: string; version: string | null; path: string[]; nodes: ReleaseRunNodeView[];
+  /** GATE-LIVE-OBS — 지금 gate 노드에 있는 런에만 싣는다(발행 원장 `gate-logs/cut/shards.json`). 파일이 없으면 생략. */
+  gateShards?: GateShardsFile & { summary: GateShardsSummary };
+}
+
+/** 도는 gate 노드의 조각 표 — 다른 판의 파일을 붙이지 않게 version 이 같을 때만. */
+function gateShardsFor(version: string | null, status: string, nodes: ReleaseRunNodeView[], ledgerRoot: string, now: number):
+  ReleaseRunView['gateShards'] | undefined {
+  if (!version || status !== 'running' || !nodes.some((node) => node.nodeId === 'gate' && node.ok === null)) return undefined;
+  const file = readGateShards(gateShardsPath(version, ledgerRoot));
+  if (!file || file.version !== version) return undefined;
+  return { ...file, shards: file.shards.map((shard) => shard.waitReason ? { ...shard, waitReason: redactSecretText(shard.waitReason) } : shard),
+    summary: summarizeShards(file, now) };
 }
 
 /** The release run ledger as `/v1/ops/release/runs` serves it (newest 20) — shared with Telegram /release and away mode
  *  so every surface reads the same verdicts. `'unavailable'` = the directory exists but cannot be read. */
 export function readReleaseRuns(version: string | null = null,
   dir: string = join(effectiveInstanceRoot(), 'graph-runs', 'release-loop'),
-  opts: { facts?: boolean } = {}): ReleaseRunView[] | 'unavailable' {
+  opts: { facts?: boolean; ledgerRoot?: string; now?: number } = {}): ReleaseRunView[] | 'unavailable' {
   let filenames: string[];
   try {
     filenames = readdirSync(dir, { withFileTypes: true })
@@ -146,15 +159,17 @@ export function readReleaseRuns(version: string | null = null,
     if (!run) return [];
     const v = runVersion(run.input);
     if (version !== null && v !== version) return [];
+    const nodes: ReleaseRunNodeView[] = [...run.nodes.filter((node) => node && typeof node.nodeId === 'string').map((node) => ({
+      nodeId: redactSecretText(node.nodeId), ok: typeof node.ok === 'boolean' ? node.ok : null,
+      summary: nodeSummary(node.output), ...nodeTimes(node),
+      ...(opts.facts ? { facts: releaseNodeFacts(node.output) } : {}),
+    })), ...runningNode(run, run.nodes.length)];
+    const gateShards = gateShardsFor(v, run.status, nodes, opts.ledgerRoot ?? releaseLedgerRoot(), opts.now ?? Date.now());
     return [{
       runId: redactSecretText(filename.slice(0, -5)), status: redactSecretText(run.status),
       startedAt: redactSecretText(run.startedAt), version: v,
       path: run.path.filter((step): step is string => typeof step === 'string').map(redactSecretText),
-      nodes: [...run.nodes.filter((node) => node && typeof node.nodeId === 'string').map((node) => ({
-        nodeId: redactSecretText(node.nodeId), ok: typeof node.ok === 'boolean' ? node.ok : null,
-        summary: nodeSummary(node.output), ...nodeTimes(node),
-        ...(opts.facts ? { facts: releaseNodeFacts(node.output) } : {}),
-      })), ...runningNode(run, run.nodes.length)],
+      nodes, ...(gateShards ? { gateShards } : {}),
     }];
   }).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, 20);
 }

package/src/nexus/api/ops-board-route.ts

@@ -0,0 +1,48 @@
+import { canonicalSeatId, openMsgStore, type Message, type MsgStore } from '../../msg/msg-store.js';
+import { jsonResponse } from './json-response.js';
+
+function ownerNotices(store: Pick<MsgStore, 'list'>): Message[] {
+  const notices: Message[] = [];
+  let after = 0;
+  let batch: Message[];
+  do {
+    batch = store.list('CEO', after, 1000);
+    notices.push(...batch.filter(message => message.from !== 'CEO'));
+    if (batch.length) after = batch[batch.length - 1]!.id;
+  } while (batch.length === 1000);
+  return notices;
+}
+
+export const OPS_BOARD_PATH = '/v1/ops-board/notices';
+
+export interface OpsBoardDeps {
+  authorize: (request: Request) => boolean;
+  openStore?: () => Pick<MsgStore, 'list' | 'post' | 'close'>;
+}
+
+/** Owner reads the CEO inbox without acknowledging it; replies are addressed to the original sender. */
+export async function handleOpsBoard(req: Request, deps: OpsBoardDeps): Promise<Response> {
+  if (!deps.authorize(req)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (req.method !== 'GET' && req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  const store = (deps.openStore ?? openMsgStore)();
+  try {
+    if (req.method === 'GET') {
+      const notices = ownerNotices(store);
+      return jsonResponse({ notices });
+    }
+    let body: unknown;
+    try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
+    if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+    const input = body as Record<string, unknown>;
+    if (!Number.isSafeInteger(input.noticeId) || (input.noticeId as number) < 1
+      || typeof input.body !== 'string' || !input.body.trim() || input.body.length > 3000
+      || Object.keys(input).some(key => key !== 'noticeId' && key !== 'body')) return jsonResponse({ error: 'bad_request' }, 400);
+    const notice: Message | undefined = ownerNotices(store).find(message => message.id === input.noticeId);
+    if (!notice) return jsonResponse({ error: 'not-found' }, 404);
+    const recipient = canonicalSeatId(notice.from);
+    const reply = store.post({ from: 'CEO', to: recipient, body: input.body.trim(), kind: 'reply' });
+    return jsonResponse({ reply }, 201);
+  } finally {
+    store.close();
+  }
+}

package/src/onboarding/entry-hints.ts

@@ -5,4 +5,9 @@ export function unattendedSetupHint(): string {
   return `unattended: \`${UNATTENDED_SETUP_COMMAND}\``;
 }
 
+/** One-line next step printed after a non-TTY onboarding refusal (FIRST-CHAT-NONTTY). */
+export function unattendedNextStepLine(): string {
+  return `next: ${unattendedSetupHint()}`;
+}
+
 export const SKILLS_LIST_DESCRIPTION = 'List elanous skills from configured skill directories (skills.activeSet / skills.dirs and packaged skills): subdirectories and the first non-heading line of each SKILL.md. Read-only.';

package/src/onboarding.ts

@@ -59,7 +59,7 @@ import type {
 import { showStepOr, chooseFrom } from './onboarding/io-extended.js';
 import { askWithHelp } from './onboarding/wire-helpers.js';
 import { stepTransition } from './onboarding/transition.js';
-import { unattendedSetupHint } from './onboarding/entry-hints.js';
+import { unattendedNextStepLine, unattendedSetupHint } from './onboarding/entry-hints.js';
 import { continueHereLines } from './onboarding/continue-here.js';
 import type { NexusShowResult } from './cli/nexus-show.js';
 import type { TailscaleProbe } from './nexus/onboarding/tailscale-probe.js';
@@ -1370,15 +1370,33 @@ export class OnboardingRefusedError extends Error {
   }
 }
 
-/** Handle only typed refusals; the agent setup hint applies to its non-TTY path alone. */
-export function handleOnboardingRefusal(error: unknown, entrance: 'agent' | 'other'): boolean {
+export interface OnboardingRefusalIO {
+  printError: (line: string) => void;
+  setExitCode: (code: number) => void;
+}
+
+const defaultRefusalIO: OnboardingRefusalIO = {
+  printError: (line) => console.error(line),
+  setExitCode: (code) => { process.exitCode = code; },
+};
+
+/** Handle only typed refusals; the agent setup hint applies to its non-TTY path alone.
+ *  FIRST-CHAT-NONTTY: on the non-TTY path of any other entrance the refusal ends with a
+ *  one-line next step (`unattendedNextStepLine()`), so a script or app that called first knows
+ *  what to run. The exit code stays 2. */
+export function handleOnboardingRefusal(
+  error: unknown,
+  entrance: 'agent' | 'other',
+  io: OnboardingRefusalIO = defaultRefusalIO,
+): boolean {
   if (!(error instanceof OnboardingRefusedError) || error.code !== 'onboarding-refused') return false;
   if (entrance === 'agent' && error.reason === 'non-tty') {
-    console.error(`elanous agent needs a configured LLM. Run \`elanous onboarding\` in a terminal, or ${unattendedSetupHint()} for unattended setup.`);
+    io.printError(`elanous agent needs a configured LLM. Run \`elanous onboarding\` in a terminal, or ${unattendedSetupHint()} for unattended setup.`);
   } else {
-    console.error(error.message);
+    io.printError(error.message);
+    if (error.reason === 'non-tty') io.printError(unattendedNextStepLine());
   }
-  process.exitCode = 2;
+  io.setExitCode(2);
   return true;
 }
 

package/src/release-loop/feature-store.ts

@@ -36,7 +36,7 @@ const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
   imported_versions: ['json_hash', 'imported_at'],
   events: ['reason', 'generation'],
   assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs'],
-  release_schedules: ['freeze_from', 'freeze_until'],
+  release_schedules: ['freeze_from', 'freeze_until', 'publish_at'],
 };
 function schemaCurrent(db: Database): boolean {
   return Object.entries(SCHEMA_COLUMNS).every(([table, names]) => {
@@ -83,16 +83,16 @@ function open(root = releaseLedgerRoot()): Database {
         if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
       }
       const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
-      for (const name of ['freeze_from', 'freeze_until']) if (!scheduleColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE release_schedules ADD COLUMN ${name} TEXT`);
+      for (const name of ['freeze_from', 'freeze_until', 'publish_at']) if (!scheduleColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE release_schedules ADD COLUMN ${name} TEXT`);
     }).immediate();
     return db;
   } catch (error) { db.close(); throw error; }
 }
 
-export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; freezeFrom?: string | null; freezeUntil?: string | null; updatedAt: string; updatedBy: string }
-type StoredSchedule = { version: string; cut_at: string; land_by: string | null; freeze_from: string | null; freeze_until: string | null; updated_at: string; updated_by: string };
+export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; freezeFrom?: string | null; freezeUntil?: string | null; publishAt?: string | null; updatedAt: string; updatedBy: string }
+type StoredSchedule = { version: string; cut_at: string; land_by: string | null; freeze_from: string | null; freeze_until: string | null; publish_at?: string | null; updated_at: string; updated_by: string };
 function scheduleRow(row: StoredSchedule): ScheduleRow {
-  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, ...(row.freeze_from ? { freezeFrom: row.freeze_from } : {}), ...(row.freeze_until ? { freezeUntil: row.freeze_until } : {}), updatedAt: row.updated_at, updatedBy: row.updated_by };
+  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, ...(row.freeze_from ? { freezeFrom: row.freeze_from } : {}), ...(row.freeze_until ? { freezeUntil: row.freeze_until } : {}), ...(row.publish_at ? { publishAt: row.publish_at } : {}), updatedAt: row.updated_at, updatedBy: row.updated_by };
 }
 
 export function readSchedule(version: string, root?: string): ScheduleRow | null {
@@ -119,7 +119,7 @@ export function assignedVersions(root = releaseLedgerRoot()): string[] {
   finally { db.close(); }
 }
 
-export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string }, by: string, root?: string): ScheduleRow {
+export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string; publishAt?: string }, by: string, root?: string): ScheduleRow {
   validateVersion(version);
   const db = open(root);
   try {
@@ -130,19 +130,22 @@ export function writeSchedule(version: string, patch: { cutAt?: string; landBy?:
       const landBy = patch.landBy ?? previous?.land_by ?? null;
       const freezeFrom = patch.freezeFrom ?? previous?.freeze_from ?? null;
       const freezeUntil = patch.freezeUntil ?? previous?.freeze_until ?? null;
+      const publishAt = patch.publishAt ?? previous?.publish_at ?? null;
+      if (publishAt && Date.parse(publishAt) <= Date.parse(cutAt)) throw new CliUserError('발행 시각은 컷보다 뒤여야 한다');
       if (Boolean(freezeFrom) !== Boolean(freezeUntil) || (freezeFrom && freezeUntil && Date.parse(freezeFrom) >= Date.parse(freezeUntil))) throw new CliUserError('동결 시작·끝은 함께 주고 시작이 끝보다 앞서야 한다');
-      if (previous && previous.cut_at === cutAt && previous.land_by === landBy && previous.freeze_from === freezeFrom && previous.freeze_until === freezeUntil) return scheduleRow(previous);
+      if (previous && previous.cut_at === cutAt && previous.land_by === landBy && previous.freeze_from === freezeFrom && previous.freeze_until === freezeUntil && (previous.publish_at ?? null) === publishAt) return scheduleRow(previous);
       const at = new Date().toISOString();
-      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, freeze_from, freeze_until, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?)
-        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, freeze_from=excluded.freeze_from, freeze_until=excluded.freeze_until, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-        .run(version, cutAt, landBy, freezeFrom, freezeUntil, at, by);
+      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, freeze_from, freeze_until, publish_at, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, freeze_from=excluded.freeze_from, freeze_until=excluded.freeze_until, publish_at=excluded.publish_at, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+        .run(version, cutAt, landBy, freezeFrom, freezeUntil, publishAt, at, by);
       for (const [field, from, to] of [
         ['cut_at', previous?.cut_at ?? null, cutAt], ['land_by', previous?.land_by ?? null, landBy],
         ['freeze_from', previous?.freeze_from ?? null, freezeFrom], ['freeze_until', previous?.freeze_until ?? null, freezeUntil],
+        ['publish_at', previous?.publish_at ?? null, publishAt],
       ] as const) {
         if (from !== to) record(db, version, { at, by, id: '@version', field, from, to, released: releasedVersion(root), dev: devVersion() });
       }
-      return { version, cutAt, landBy, updatedAt: at, updatedBy: by };
+      return { version, cutAt, landBy, ...(publishAt ? { publishAt } : {}), updatedAt: at, updatedBy: by };
     });
   } finally { db.close(); }
 }

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

@@ -0,0 +1,158 @@
+// GATE-LIVE-OBS — 게이트 «조각 상태» 한 장(`<ledger>/release/<v>/gate-logs/cut/shards.json`)의 계약.
+// 쓰는 쪽 = gate-node(TC · GATE-TIMEOUT-HEAL) · 읽는 쪽 = /v1/ops/release/runs ⊕ 외출 알림(UX).
+// 로그가 아니라 발행 원장 파일인 이유: 게이트 사건은 실행 트리의 test 우주로 가지만 원장은 운영 한 곳이다(TC·OP 10-07 19:12).
+// ⛔ 못 읽으면 `null` — 「조각 0」으로 읽지 않는다.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+
+export const SHARD_STATES = ['pending', 'running', 'done', 'retry', 'timeout', 'failed'] as const;
+export type ShardState = typeof SHARD_STATES[number];
+
+export interface GateShard {
+  id: string;
+  state: ShardState;
+  startedAt?: string;
+  endedAt?: string;
+  /** 설치(install) 단계에 쓴 초. */
+  installSec?: number;
+  rc?: number;
+  /** 대기 이유(예: «CPU 부족 31.2/32»). pending 일 때 화면이 그대로 보인다. */
+  waitReason?: string;
+  /** 계획 분 — 남은 시간 추정의 재료. */
+  plannedMin?: number;
+}
+
+export interface GateShardsFile {
+  v: 1;
+  version: string;
+  updatedAt: string;
+  shards: GateShard[];
+}
+
+export function gateShardsPath(version: string, root: string = releaseLedgerRoot()): string {
+  return join(root, 'release', version, 'gate-logs', 'cut', 'shards.json');
+}
+
+const str = (value: unknown, max = 160): string | undefined =>
+  typeof value === 'string' && value.trim() ? value.trim().slice(0, max) : undefined;
+const num = (value: unknown): number | undefined => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+
+function shardOf(value: unknown): GateShard | null {
+  if (!value || typeof value !== 'object') return null;
+  const raw = value as Record<string, unknown>;
+  const id = str(raw.id, 80);
+  const state = SHARD_STATES.find((s) => s === raw.state);
+  if (!id || !state) return null;
+  const startedAt = str(raw.startedAt, 40);
+  const endedAt = str(raw.endedAt, 40);
+  const installSec = num(raw.installSec);
+  const rc = num(raw.rc);
+  const waitReason = str(raw.waitReason);
+  const plannedMin = num(raw.plannedMin);
+  return {
+    id, state,
+    ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
+    ...(installSec !== undefined ? { installSec } : {}), ...(rc !== undefined ? { rc } : {}),
+    ...(waitReason ? { waitReason } : {}), ...(plannedMin !== undefined ? { plannedMin } : {}),
+  };
+}
+
+/** 파일이 없거나 깨졌으면 null. 알 수 없는 상태값의 조각은 버리되 파일 전체는 살린다. */
+export function readGateShards(path: string): GateShardsFile | null {
+  let parsed: unknown;
+  try { parsed = JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const raw = parsed as Record<string, unknown>;
+  if (raw.v !== 1 || !Array.isArray(raw.shards)) return null;
+  const version = str(raw.version, 40);
+  const updatedAt = str(raw.updatedAt, 40);
+  if (!version || !updatedAt) return null;
+  return { v: 1, version, updatedAt, shards: raw.shards.map(shardOf).filter((s): s is GateShard => s !== null) };
+}
+
+/** tmp → rename — 읽는 쪽이 반쯤 쓴 파일을 보지 않게. */
+export function writeGateShards(path: string, file: GateShardsFile): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(file)}\n`);
+  renameSync(tmp, path);
+}
+
+export interface GateShardsSummary {
+  total: number;
+  counts: Record<ShardState, number>;
+  /** 대기 이유별 조각 수(많은 순). */
+  waitReasons: Array<{ reason: string; count: number }>;
+  /** 남은 분 추정 — 계획 분이 모자라면 null(«추정 불가»). */
+  etaMin: number | null;
+  /** 도는 조각 중 계획 분을 가장 많이 넘긴 분(없으면 0). 넘겼으면 etaMin 은 «하한»일 뿐이라 화면이 그렇게 말한다
+   *  — canary 10-07 실측: 계획 0.1분 · 실제 22분 → 넘김을 안 보이면 내내 «남은 약 0분». */
+  overrunMin: number;
+  /** 파일이 마지막으로 바뀐 뒤 지난 분. 크면 쓰는 쪽이 멎었다는 뜻이다. */
+  staleMin: number | null;
+}
+
+const minutesBetween = (fromIso: string | undefined, now: number): number | null => {
+  const at = fromIso ? Date.parse(fromIso) : Number.NaN;
+  return Number.isFinite(at) ? Math.max(0, (now - at) / 60_000) : null;
+};
+
+/**
+ * 남은 시간 추정: 도는 조각은 «계획 − 경과», 기다리는 조각(pending·retry)은 계획 분을 지금 도는 자리 수로 나눠 뒤에 잇는다.
+ * 도는 조각이 없으면 자리 1로 본다. 계획 분이 없는 조각이 하나라도 남아 있으면 null.
+ */
+function estimate(shards: GateShard[], now: number): number | null {
+  const running = shards.filter((s) => s.state === 'running');
+  const waiting = shards.filter((s) => s.state === 'pending' || s.state === 'retry');
+  if (!running.length && !waiting.length) return 0;
+  if ([...running, ...waiting].some((s) => s.plannedMin === undefined)) return null;
+  const runningLeft = running.map((s) => Math.max(0, s.plannedMin! - (minutesBetween(s.startedAt, now) ?? 0)));
+  const slots = Math.max(1, running.length);
+  const waitingSum = waiting.reduce((sum, s) => sum + s.plannedMin!, 0);
+  return Math.ceil(Math.max(0, ...runningLeft) + waitingSum / slots);
+}
+
+export function summarizeShards(file: GateShardsFile, now: number = Date.now()): GateShardsSummary {
+  const counts = Object.fromEntries(SHARD_STATES.map((s) => [s, 0])) as Record<ShardState, number>;
+  const reasons = new Map<string, number>();
+  for (const shard of file.shards) {
+    counts[shard.state] += 1;
+    if (shard.waitReason && (shard.state === 'pending' || shard.state === 'retry')) {
+      reasons.set(shard.waitReason, (reasons.get(shard.waitReason) ?? 0) + 1);
+    }
+  }
+  const stale = minutesBetween(file.updatedAt, now);
+  const overrun = Math.max(0, ...file.shards
+    .filter((s) => s.state === 'running' && s.plannedMin !== undefined)
+    .map((s) => (minutesBetween(s.startedAt, now) ?? 0) - s.plannedMin!));
+  return {
+    total: file.shards.length,
+    counts,
+    waitReasons: [...reasons].map(([reason, count]) => ({ reason, count })).sort((a, b) => b.count - a.count),
+    etaMin: estimate(file.shards, now),
+    overrunMin: Math.floor(overrun),
+    staleMin: stale === null ? null : Math.floor(stale),
+  };
+}
+
+export const SHARD_WORD: Record<ShardState, string> = {
+  pending: '대기', running: '돌기', done: '통과', retry: '재시도', timeout: '잘림', failed: '실패',
+};
+
+/** 외출 알림·/release 한 줄 — «조각 24 · 돌기 5 · 대기 8(CPU 부족 8) · 잘림 2 · 통과 9 · 남은 약 40분». */
+export function shardsLine(summary: GateShardsSummary): string {
+  const order: ShardState[] = ['running', 'pending', 'retry', 'timeout', 'failed', 'done'];
+  const parts = [`조각 ${summary.total}`];
+  for (const state of order) {
+    const n = summary.counts[state];
+    if (!n) continue;
+    const why = state === 'pending' && summary.waitReasons.length
+      ? `(${summary.waitReasons.slice(0, 2).map((w) => `${w.reason} ${w.count}`).join(' · ')})` : '';
+    parts.push(`${SHARD_WORD[state]} ${n}${why}`);
+  }
+  if (summary.overrunMin >= 1) parts.push(`계획보다 ${summary.overrunMin}분 넘게 도는 중 — 남은 시간 추정 불가`);
+  else parts.push(summary.etaMin === null ? '남은 시간 추정 불가(계획 분 없음)' : `남은 약 ${summary.etaMin}분`);
+  if (summary.staleMin !== null && summary.staleMin >= 15) parts.push(`⚠️ ${summary.staleMin}분째 갱신 없음`);
+  return parts.join(' · ');
+}

package/src/release-loop/release-schedule.ts

@@ -35,12 +35,13 @@ export function listSchedules(root?: string): ReleaseSchedule[] {
   return schedules;
 }
 
-export function setSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string }, by: string, root?: string): ReleaseSchedule {
+export function setSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string; publishAt?: string }, by: string, root?: string): ReleaseSchedule {
   const schedule = writeSchedule(version, {
     ...(patch.cutAt !== undefined ? { cutAt: utcIso(patch.cutAt) } : {}),
     ...(patch.landBy !== undefined ? { landBy: utcIso(patch.landBy) } : {}),
     ...(patch.freezeFrom !== undefined ? { freezeFrom: utcIso(patch.freezeFrom) } : {}),
     ...(patch.freezeUntil !== undefined ? { freezeUntil: utcIso(patch.freezeUntil) } : {}),
+    ...(patch.publishAt !== undefined ? { publishAt: utcIso(patch.publishAt) } : {}),
   }, by, root);
   debug.log('release.schedule', 'set', { version, cutAt: schedule.cutAt, landBy: schedule.landBy });
   return schedule;
@@ -51,5 +52,8 @@ export function formatSchedule(schedule: ReleaseSchedule): string {
   const deadline = schedule.landBy ? formatKst(schedule.landBy) : null;
   const sameDay = schedule.landBy && new Date(Date.parse(schedule.landBy) + 9 * 60 * 60_000).toISOString().slice(0, 10)
     === new Date(Date.parse(schedule.cutAt) + 9 * 60 * 60_000).toISOString().slice(0, 10);
-  return `${schedule.version} 컷 ${cut}${deadline ? ` · 착지 마감 ${sameDay ? deadline.split(' ')[1] : deadline}` : ''}`;
+  const publish = schedule.publishAt ? formatKst(schedule.publishAt) : null;
+  const publishSameDay = schedule.publishAt && new Date(Date.parse(schedule.publishAt) + 9 * 60 * 60_000).toISOString().slice(0, 10)
+    === new Date(Date.parse(schedule.cutAt) + 9 * 60 * 60_000).toISOString().slice(0, 10);
+  return `${schedule.version} 컷 ${cut}${deadline ? ` · 착지 마감 ${sameDay ? deadline.split(' ')[1] : deadline}` : ''}${publish ? ` · 발행 ${publishSameDay ? publish.split(' ')[1] : publish}` : ''}`;
 }