elanous 0.2.13 → 0.2.14

package/src/loops/verdict.ts

@@ -1,20 +1,32 @@
 export type LoopCronVerdict = 'alive' | 'late' | 'failed' | 'off';
 
-/** Shared display inputs for a graph loop or a cron job. The caller supplies
- * the cadence in milliseconds (or null when it is not known). */
+/** Shared display inputs for a graph loop or cron job. Fixed intervals use
+ * milliseconds; calendar cron schedules supply the second actual due instant. */
 export interface LoopCronVerdictInput {
   enabled: boolean;
   lastRunAt: string | null;
   lastStatus: string | null;
   intervalMs: number | null;
+  /** Second scheduled execution after the last run, for calendar-based cron schedules. */
+  secondDueAt?: string | null;
+  /** Cron-aware daemon state (src/domains/schedule-state.ts). Callers pass it for cron schedules only —
+   *  a fixed interval keeps its own «2× interval» rule (review must-fix: stale must not override an interval). */
+  scheduleState?: 'live' | 'firing' | 'stale' | 'off';
 }
 
 /** Pure health classification; a failed last execution takes precedence over age.
- * With no valid timestamp or positive cadence, lateness cannot be established. */
+ * Without a valid last run and a cadence/due instant, lateness needs the daemon stale signal. */
 export function loopCronVerdict(entry: LoopCronVerdictInput, nowMs: number): LoopCronVerdict {
-  if (!entry.enabled) return 'off';
-  if (entry.lastStatus === 'failed' || entry.lastStatus === 'error' || entry.lastStatus === 'failure') return 'failed';
+  if (!entry.enabled || entry.scheduleState === 'off') return 'off';
+  if (entry.lastStatus === 'failed' || entry.lastStatus === 'error' || entry.lastStatus === 'failure' ||
+      entry.lastStatus === 'abandoned' || entry.lastStatus === 'expired') return 'failed';
+  if (entry.scheduleState === 'stale') return 'late';
   const lastRunMs = entry.lastRunAt === null ? NaN : Date.parse(entry.lastRunAt);
+  if (entry.secondDueAt !== undefined) {
+    const secondDueMs = entry.secondDueAt === null ? NaN : Date.parse(entry.secondDueAt);
+    return Number.isFinite(lastRunMs) && Number.isFinite(nowMs) &&
+      Number.isFinite(secondDueMs) && secondDueMs > lastRunMs && nowMs > secondDueMs ? 'late' : 'alive';
+  }
   if (Number.isFinite(nowMs) && Number.isFinite(lastRunMs) &&
       entry.intervalMs !== null && Number.isFinite(entry.intervalMs) && entry.intervalMs > 0 &&
       nowMs - lastRunMs > 2 * entry.intervalMs) return 'late';

package/src/maturity/bot-slash-catalog.ts

@@ -0,0 +1,66 @@
+import type { SlashCommand } from '../chat/index.js';
+import type { Maturity } from './feature-maturity.js';
+import type { BotSurface } from './bot-command-maturity.js';
+
+export interface BotSlashCatalogEntry {
+  name: string;
+  description: string;
+  supported: boolean;
+}
+
+export interface BotSlashCatalog {
+  commands: BotSlashCatalogEntry[];
+  /** Null means this name is already handled, or is not in the catalog. */
+  unsupportedReply(name: string): string | null;
+}
+
+/** The menu is a projection of registered core commands, not a second list of invented names.
+ * A bot's actual handlers take precedence over maturity metadata: a grade describes
+ * visibility, never whether an existing command can be dispatched. */
+export function buildBotSlashCatalog(options: {
+  surface: BotSurface;
+  coreCommands: readonly Pick<SlashCommand, 'name' | 'description'>[];
+  maturity: {
+    tuiSlash: Readonly<Record<string, Maturity>>;
+    telegramCommand: Readonly<Record<string, Maturity>>;
+    discordCommand: Readonly<Record<string, Maturity>>;
+  };
+  handledCommands: readonly { name: string; description: string }[];
+}): BotSlashCatalog {
+  const { surface, coreCommands, maturity, handledCommands } = options;
+  const grades = surface === 'telegram' ? maturity.telegramCommand : maturity.discordCommand;
+  const validName = surface === 'telegram' ? /^[a-z0-9_]{1,32}$/ : /^[a-z0-9_-]{1,32}$/;
+  const commands: BotSlashCatalogEntry[] = [];
+  const seen = new Set<string>();
+  for (const command of handledCommands) {
+    if (seen.has(command.name)) continue;
+    commands.push({ name: command.name, description: command.description, supported: true });
+    seen.add(command.name);
+  }
+  const limit = surface === 'telegram' ? 100 : 25;
+  const candidateNames = new Set<string>();
+  const candidates = coreCommands.filter((command) => {
+    const name = command.name;
+    const grade = Object.hasOwn(grades, name) ? grades[name] : undefined;
+    if (seen.has(name) || candidateNames.has(name) || !validName.test(name) || grade === undefined || grade === 'broken' || grade === 'system') return false;
+    candidateNames.add(name);
+    return true;
+  });
+  if (commands.length + candidates.length > limit) {
+    throw new Error(`${surface} command catalog exceeds ${limit} slots`);
+  }
+  for (const command of candidates) {
+    const name = command.name;
+    const description = command.description.replace(/\s+/g, ' ').trim();
+    const suffix = ` (${surface === 'telegram' ? '텔레그램' : '디스코드'} 미지원)`;
+    commands.push({ name, description: `${description.slice(0, 100 - suffix.length)}${suffix}`, supported: false });
+    seen.add(name);
+  }
+  const unsupported = new Set(commands.filter((command) => !command.supported).map((command) => command.name));
+  return {
+    commands,
+    unsupportedReply(name) {
+      return unsupported.has(name) ? `/${name}은(는) ${surface === 'telegram' ? '텔레그램' : '디스코드'}에서 아직 지원되지 않습니다. TUI에서 /${name}을(를) 사용하세요.` : null;
+    },
+  };
+}

package/src/maturity/feature-maturity.ts

@@ -41,6 +41,7 @@ export const FEATURE_MATURITY = {
     '/design-check': { pwa: 'tool' },
     '/control': { pwa: 'tool' },
     '/scheduler': { pwa: 'ops' },
+    '/loops': { pwa: 'beta' },
     '/ops/release': { pwa: 'ops' },
     '/ops/seats': { pwa: 'ops' },
     '/ops/checklist': { pwa: 'ops' },
@@ -57,7 +58,7 @@ export const FEATURE_MATURITY = {
     pty: 'beta', pr: 'beta', repo: 'beta', role: 'beta', machine: 'beta',
     where: 'stable', shadow: 'beta', llm: 'beta', storage: 'beta', leader: 'beta',
     pod: 'beta', browser: 'beta', questions: 'beta', usage: 'stable', live: 'beta',
-    research: 'beta', release: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
+    research: 'beta', release: 'beta', freeze: 'beta', flow: 'beta', seat: 'beta', hq: 'beta', steward: 'beta', coord: 'beta', context: 'beta', 'model-watch': 'beta', doctor: 'stable',
     control: 'beta', resources: 'beta', hooks: 'beta', setup: 'stable', start: 'stable',
     grounding: 'beta', graph: 'beta', loop: 'stable', card: 'stable', 'launch-head': 'beta',
     a2a: 'beta', plugin: 'stable', make: 'beta', skills: 'beta', connect: 'beta', import: 'beta',
@@ -71,7 +72,7 @@ export const FEATURE_MATURITY = {
     provider: 'stable', 'provider:set': 'beta', 'provider:restore': 'beta',
     'provider:rotate': 'beta', 'provider:use': 'beta', 'status-bar': 'beta',
     schedule: 'beta', intake: 'beta', logs: 'stable', ad: 'beta', docs: 'beta',
-    decisions: 'beta', directives: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
+    decisions: 'beta', directives: 'beta', claims: 'beta', lesson: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
     env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
     config: 'stable', tasks: 'stable', labels: 'beta', msg: 'beta', ask: 'stable',
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
@@ -110,6 +111,8 @@ export const FEATURE_MATURITY = {
     plugin: 'tool',
     widget: 'tool',
     log: 'tool',
+    loops: 'beta',
+    persona: 'beta', // G3 b — 대화별 페르소나(GOAL-BENCH B7 #23836)
     memory: 'beta',
     export: 'stable',
     delta: 'tool',
@@ -153,7 +156,7 @@ export const FEATURE_MATURITY = {
     ping: 'stable', provider: 'stable', sessions: 'stable', fork: 'stable', resume: 'stable',
     decisions: 'stable', work: 'stable', cancel: 'stable',
     skills: 'beta', skill: 'beta', digest: 'beta', intake: 'beta', ad: 'beta',
-    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', project: 'beta', wish: 'beta',
+    taste: 'beta', missions: 'beta', attach: 'beta', detach: 'beta', now: 'beta', loops: 'beta', project: 'beta', wish: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool', local: 'tool',
     harness: 'ops',
     // Existing commands outside the CXO four-grade menu list are owner-only.
@@ -162,7 +165,7 @@ export const FEATURE_MATURITY = {
   },
   discordCommand: {
     status: 'stable', sessions: 'stable', new: 'stable', fork: 'stable',
-    persona: 'beta', poll: 'beta', attach: 'beta',
+    persona: 'beta', poll: 'beta', attach: 'beta', now: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool',
     relay: 'ops', showroom: 'ops', bots: 'ops', bot: 'ops', screen: 'ops', chart: 'ops',
     routines: 'ops', botsay: 'ops', 'voice-join': 'ops', 'voice-leave': 'ops', 'voice-status': 'ops',

package/src/nexus/api/dashboard.ts

@@ -4,6 +4,7 @@
 //   GET /v1/dashboard/timeline  — 신호 타임라인 (?hours=48&floor=6)
 //   GET /v1/dashboard/heatmap   — 자산×국가×섹터 매력도 + US 섹터 + 뉴스 분포
 //   GET /v1/dashboard/digs      — 디깅 리포트 피드 (?limit=20)
+//   GET /v1/dashboard/loop-activity — 루프 활동 그래프 (?since=24h)
 //
 // 전부 read-only · 캐시/로컬 SQLite 만 (dashboard-data.ts) — 라이브 fetch 없음.
 // PWA 폴링(60s) 대상. reflection.ts 패턴(CORS·checkAuth seam) 상속.
@@ -16,12 +17,15 @@ import {
 } from '../../domains/dashboard-data.js';
 import { readLiveSnapshot } from '../../domains/market-live.js';
 import { marketSessions } from '../../domains/finance.js';
+import { loopActivity } from '../../loops/activity.js';
 
 export interface DashboardRouteOpts {
   /** Auth check seam. */
   checkAuth?: (req: Request) => boolean;
   /** Test seam — 실제 detached 수집 spawn 대체. */
   spawnCollector?: () => void;
+  /** Read-only activity provider for isolated route tests. */
+  loopActivity?: typeof loopActivity;
 }
 
 const CORS_HEADERS: Record<string, string> = {
@@ -43,7 +47,7 @@ export function parseDashboardPath(pathname: string): string | null {
   const m = /^\/v1\/dashboard\/([^/]+)$/.exec(pathname);
   if (!m) return null;
   const seg = decodeURIComponent(m[1]!);
-  return ['summary', 'timeline', 'heatmap', 'digs', 'schedules', 'ontology', 'backtest', 'loops', 'ops'].includes(seg) ? seg : null;
+  return ['summary', 'timeline', 'heatmap', 'digs', 'schedules', 'ontology', 'backtest', 'loops', 'loop-activity', 'ops'].includes(seg) ? seg : null;
 }
 
 /** POST /v1/dashboard/refresh-live — 온디맨드 라이브 재수집 트리거 (refresh 버튼 설계 ·
@@ -99,6 +103,7 @@ export function handleDashboard(req: Request, section: string, opts: DashboardRo
       case 'ontology': return jsonResponse({ ok: true, ontology: dashboardOntology() }, 200);
       case 'backtest': return jsonResponse({ ok: true, backtest: dashboardBacktest() }, 200);
       case 'loops': return jsonResponse({ ok: true, loops: dashboardLoops() }, 200);
+      case 'loop-activity': return jsonResponse({ ok: true, activity: (opts.loopActivity ?? loopActivity)({ since: q.get('since') ?? '24h' }) }, 200);
       case 'ops': {
         const mid = q.get('mission');
         if (mid) return jsonResponse({ ok: true, missionDetail: dashboardOpsMission(mid) }, 200);

package/src/nexus/api/http-server.ts

@@ -184,7 +184,9 @@ import { handleChannelBotsGet, handleChannelBotSet } from './setup-channel-bot.j
 import { handleLlmRoutePredict } from './llm-route-predict.js';
 import type { MissionRouter } from '../../llm/mission-router.js';
 import { handleContextFetchUrl } from './context-url.js';
-import { contextNow } from '../../context-bus/context-now.js';
+import { contextNow, type ContextNowDeps } from '../../context-bus/context-now.js';
+import type { ContextNowAudience } from '../../context-bus/context-now-surfaces.js';
+import { renderVoiceNow } from '../../context-bus/context-now-surfaces.js';
 import type { IntentPredictionService } from '../../intent-prediction/index.js';
 import type { NotificationActionLoopback } from '../../web-push/notification-action-loopback.js';
 import { handlePlatforms } from './platforms.js';
@@ -486,6 +488,8 @@ export interface NexusHttpServerOpts {
   eventBus: NexusEventBus;
   /** Test seam for the read-only usage collector; production uses the cached handler. */
   usageHandler?: () => Promise<Response>;
+  /** Test seam for the context-now ledgers; production reads the live ledgers. */
+  contextNowDeps?: ContextNowDeps;
   /** Supervisor handle — required for the write API (PR ι). When omitted
    *  (skipSupervisor mode), mutation routes return 503. */
   supervisor?: Supervisor;
@@ -2879,7 +2883,19 @@ export async function routeRequest(
   }
   if (pathname === '/v1/context/now') {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
-    return jsonResponse(contextNow({ ...(url.searchParams.has('topic') ? { topic: url.searchParams.get('topic') ?? '' } : {}) }));
+    const audiences = url.searchParams.getAll('audience');
+    if (audiences.length > 1) return jsonResponse({ error: 'invalid_audience' }, 400);
+    const requested = audiences[0];
+    if (requested !== undefined && requested !== 'operator' && requested !== 'user' && requested !== 'public-demo') {
+      return jsonResponse({ error: 'invalid_audience' }, 400);
+    }
+    const forced = getUserConfig().nexus?.demoMode === true;
+    const audience: ContextNowAudience = forced ? 'public-demo' : requested ?? 'operator';
+    const answer = contextNow({ audience, ...(url.searchParams.has('topic') ? { topic: url.searchParams.get('topic') ?? '' } : {}) }, opts.contextNowDeps);
+    debug.log('context.now', 'served', { audience, hidden: answer.hiddenCount ?? 0, forced });
+    return jsonResponse(url.searchParams.get('format') === 'voice'
+      ? { text: renderVoiceNow(answer, audience), audience, hiddenCount: answer.hiddenCount ?? 0 }
+      : { ...answer, audience, hiddenCount: answer.hiddenCount ?? 0 });
   }
   // §6.3 (2026-05-09) — context URL fetch (showroom).
   // POST /v1/context/fetch-url

package/src/nexus/api/merge-approvals-gate.ts

@@ -53,7 +53,7 @@ export function startApprovalGate(input: ApprovalGateInput, deps: ApprovalGateDe
     void Promise.resolve().then(() => (deps.runHostRegate ?? runHostRegate)({
       prNumber: input.prNumber, headCommit: input.headSha, repoRoot: input.repoRoot, verifyOnly: true,
     })).then(async (result) => {
-      let status = result.status ?? (result.passed ? 'passed' : 'failed');
+      let status: ApprovalGateStatus = result.status === 'frozen' ? 'unmeasured' : result.status ?? (result.passed ? 'passed' : 'failed');
       let failures = result.failures.map(({ step, detail }) => `${step} — ${detail.replace(/\s+/g, ' ')}`.slice(0, 800));
       if (status === 'passed') {
         const current = await (deps.readPr ?? readPr)(input);

package/src/nexus/api/schedules-read.ts

@@ -193,9 +193,13 @@ function inventory(deps: SchedulesReadDeps): { cards: ScheduleCard[]; names: Map
   return { cards, names };
 }
 
+export function readSchedulesInventory(deps: SchedulesReadDeps = {}): ScheduleCard[] {
+  return inventory(deps).cards;
+}
+
 export function handleSchedulesList(req: Request, opts: MetaApiOpts, deps: SchedulesReadDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
-  const { cards } = inventory(deps);
+  const cards = readSchedulesInventory(deps);
   const schedules = new URL(req.url).searchParams.get('includeOff') === '1' ? cards : cards.filter(c => c.state !== 'off');
   return jsonResponse({ schedules, count: schedules.length }, 200);
 }

package/src/nexus/api/task-cards-api.ts

@@ -1,4 +1,8 @@
-import { CardStore } from '../../task-cards/card-store.js';
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { CardStore, type TaskCard } from '../../task-cards/card-store.js';
+import { releaseLedgerRoot } from '../../instance/resolve.js';
 import { createWishCard } from '../../intake-plane/wish-card.js';
 import { jsonResponse } from './json-response.js';
 
@@ -7,19 +11,53 @@ export async function handleTaskCardsWishPost(req: Request, root?: string): Prom
   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 { text, ref } = body as Record<string, unknown>;
-  if (typeof text !== 'string' || !text.trim() || typeof ref !== 'string' || !ref.trim()) {
+  const { text, ref, sessionId } = body as Record<string, unknown>;
+  if (typeof text !== 'string' || !text.trim() || typeof ref !== 'string' || !ref.trim()
+    || typeof sessionId !== 'string' || !sessionId.trim()) {
     return jsonResponse({ error: 'bad_request' }, 400);
   }
   const store = new CardStore(root);
   try {
-    const card = createWishCard({ text, source: 'pwa', ref }, store);
+    const card = createWishCard({ text, source: 'pwa', ref, replyTo: { surface: 'pwa', sessionId } }, store);
     return jsonResponse(card, card.created ? 201 : 200);
   } finally {
     store.close();
   }
 }
 
+export interface WishPlacement { cellId: string; cellTitle: string; version: string; status: 'green' | 'yellow' | 'red' | 'done' }
+
+export function isSplitCell(cell: unknown): cell is { id: string } {
+  return cell !== null && typeof cell === 'object' && 'id' in cell
+    && typeof cell.id === 'string' && cell.id.trim().length > 0;
+}
+
+/** Join the live checklist to the wish card by the split cell ID, never by title or card status. */
+export function wishPlacements(card: TaskCard, root?: string): WishPlacement[] {
+  if (!card.goalId.startsWith('wish:')) return [];
+  const split = [...card.sections].reverse().find(section => section.key === 'orch:split');
+  if (!split) return [];
+  let cells: unknown;
+  try { cells = JSON.parse(split.content); } catch { return []; }
+  if (!Array.isArray(cells)) return [];
+  const ids = [...new Set(cells.filter(isSplitCell).map(cell => cell.id.trim()))];
+  if (!ids.length) return [];
+  const ledgerRoot = root ?? releaseLedgerRoot();
+  const path = join(ledgerRoot, 'release', 'features.sqlite');
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try {
+    const placements: WishPlacement[] = [];
+    for (const cellId of ids) {
+      const rows = db.query('SELECT a.version, a.status, COALESCE(a.title_override, f.title) AS title FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.feature_id = ? ORDER BY a.version').all(cellId) as Array<{ version: string; status: string; title: string }>;
+      for (const row of rows) if (['green', 'yellow', 'red', 'done'].includes(row.status)) {
+        placements.push({ cellId, cellTitle: row.title, version: row.version, status: row.status as WishPlacement['status'] });
+      }
+    }
+    return placements;
+  } finally { db.close(); }
+}
+
 /** Read-only card API; route registration and authorization belong to the HTTP server. */
 export function handleTaskCardsGet(pathname: string, root?: string): Response {
   if (pathname !== '/v1/task-cards' && !/^\/v1\/task-cards\/[^/]+$/.test(pathname)) {
@@ -46,7 +84,8 @@ export function handleTaskCardsGet(pathname: string, root?: string): Response {
   const store = new CardStore(root);
   try {
     const card = store.getCard(id);
-    return card ? jsonResponse({ card }) : jsonResponse({ error: 'not_found' }, 404);
+    return card ? jsonResponse({ card, ...(card.goalId.startsWith('wish:') ? { placements: wishPlacements(card, root) } : {}) })
+      : jsonResponse({ error: 'not_found' }, 404);
   } finally {
     store.close();
   }

package/src/nexus/api/workflows.ts

@@ -302,6 +302,7 @@ export async function handleWorkflowPut(
   }
   const r = saveWorkflow(name, yamlText, { scope });
   if (!r.ok) {
+    if (r.readonly) return jsonResponse({ error: 'readonly_workflow', reason: r.error }, 409);
     return jsonResponse(
       {
         error: 'invalid_workflow',
@@ -323,7 +324,7 @@ export function handleWorkflowDelete(
   const url = new URL(req.url);
   const scope = url.searchParams.get('scope') === 'global' ? 'global' : 'project';
   const r = deleteWorkflow(name, { scope });
-  if (!r.ok) return jsonResponse({ error: 'delete_failed', reason: r.error }, 404);
+  if (!r.ok) return jsonResponse({ error: r.readonly ? 'readonly_workflow' : 'delete_failed', reason: r.error }, r.readonly ? 409 : 404);
   return jsonResponse({ ok: true, path: r.path, scope }, 200);
 }
 

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

@@ -0,0 +1,48 @@
+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';
+
+/** Cuts become eligible at cutAt and remain eligible through the end of the window. */
+export function selectScheduledCut(schedules: readonly ReleaseSchedule[], now: Date, windowMinutes: number): ReleaseSchedule | null {
+  if (!Number.isFinite(windowMinutes) || windowMinutes <= 0) throw new Error('windowMinutes must be positive and finite');
+  const current = now.getTime();
+  if (!Number.isFinite(current)) throw new Error('now must be a valid date');
+  return schedules
+    .filter((schedule) => {
+      const cut = Date.parse(schedule.cutAt);
+      return Number.isFinite(cut) && cut <= current && current - cut <= windowMinutes * 60_000;
+    })
+    .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt) || a.version.localeCompare(b.version))[0] ?? null;
+}
+
+export type AutoStartResult =
+  | { status: 'no-cut' }
+  | { status: 'planned'; version: string; cutAt: string }
+  | { status: 'skipped'; version: string; reason: Exclude<ReleaseReadiness, { ready: true }>['reason'] }
+  | { status: 'started'; version: string; cutAt: string };
+
+export interface AutoStartOptions {
+  windowMinutes: number;
+  apply?: boolean;
+  now?: Date;
+  ledgerRoot?: string;
+  schedules?: (root: string) => ReleaseSchedule[];
+  readiness?: (version: string, ledgerRoot: string, now: Date) => ReleaseReadiness;
+  launch?: (version: string) => void | Promise<void>;
+}
+
+/** Select from the release schedule; the existing `release run --if-ready` owns the launch-time lock and guards. */
+export async function autoStartScheduledRelease(options: AutoStartOptions): Promise<AutoStartResult> {
+  const root = options.ledgerRoot ?? releaseLedgerRoot();
+  const now = options.now ?? new Date();
+  // 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;
+  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');
+  await options.launch(version);
+  return { status: 'started', version, cutAt };
+}

package/src/release-loop/checklist.ts

@@ -13,6 +13,9 @@ export interface ChecklistItem {
   title: string;
   status: ChecklistStatus;
   owner?: string;
+  priority?: 'P0' | 'P1' | 'P2';
+  predecessors?: string[];
+  deadlineVersion?: string;
   evidence?: string;
   disposition?: ChecklistDisposition;
   kind?: ChecklistKind;
@@ -93,11 +96,14 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
   debug.log('release-loop.checklist', 'change', { version: data.version, id, field, from: from ?? null, to: to ?? null, by });
 }
 
-export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind }, options: { allowDuplicateId?: boolean } = {}): Checklist {
+export function addItem(v: string, input: { id: string; title: string; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
   if (input.kind !== undefined && input.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen');
   if (input.owner !== undefined) parseOwner(input.owner);
+  if (input.priority !== undefined && !['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
+  if (input.predecessors !== undefined && (!Array.isArray(input.predecessors) || input.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === input.id))) throw new CliUserError('잘못된 선행 칸');
+  if (input.deadlineVersion !== undefined) store.validateVersion(input.deadlineVersion);
   return mutate(v, (data, otherItems) => {
     if (data.items.some((item) => item.id === input.id)) throw new CliUserError(`이미 있는 칸: ${input.id}`, 'set <id> 로 고친다');
     const collisions = otherItems(input.id);
@@ -108,27 +114,30 @@ export function addItem(v: string, input: { id: string; title: string; owner?: s
     }
     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 } : {}), updatedAt: at, updatedBy: by };
+    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 } : {}), updatedAt: at, updatedBy: by };
     data.items.push(item);
     change(data, item.id, 'add', null, item, by, at);
     return true;
   });
 }
 
-export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind }, by: string): Checklist {
+export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string }, by: string): Checklist {
   return mutate(v, (data) => {
     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}`);
     if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new CliUserError(`잘못된 처분: ${patch.disposition}`);
     if (patch.kind !== undefined && patch.kind !== 'screen') throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen');
+    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('잘못된 선행 칸');
+    if (patch.deadlineVersion !== undefined) store.validateVersion(patch.deadlineVersion);
     if (patch.owner !== undefined) {
       parseOwner(patch.owner);
       if (item.owner && patch.owner !== item.owner) {
         throw new CliUserError(`지금 주인: ${item.owner} — --force 로만 바꾼다`, 'release checklist claim <id> --by <자리> --force');
       }
     }
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field]));
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {

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

@@ -58,14 +58,20 @@ function open(root = releaseLedgerRoot()): Database {
     if (!columns.some((column) => column.name === 'imported_at')) db.exec('ALTER TABLE imported_versions ADD COLUMN imported_at TEXT');
     if (!(db.query('PRAGMA table_info(events)').all() as Array<{ name: string }>).some((column) => column.name === 'reason')) db.exec('ALTER TABLE events ADD COLUMN reason TEXT');
     db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
+    const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
+    for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT']] as const) {
+      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`);
     return db;
   } catch (error) { db.close(); throw error; }
 }
 
-export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; updatedAt: string; updatedBy: string }
-type StoredSchedule = { version: string; cut_at: string; land_by: string | null; updated_at: string; updated_by: string };
+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 };
 function scheduleRow(row: StoredSchedule): ScheduleRow {
-  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, 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 } : {}), updatedAt: row.updated_at, updatedBy: row.updated_by };
 }
 
 export function readSchedule(version: string, root?: string): ScheduleRow | null {
@@ -84,7 +90,7 @@ export function readSchedules(root?: string): ScheduleRow[] {
   finally { db.close(); }
 }
 
-export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ScheduleRow {
+export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string }, by: string, root?: string): ScheduleRow {
   validateVersion(version);
   const db = open(root);
   try {
@@ -93,13 +99,17 @@ export function writeSchedule(version: string, patch: { cutAt?: string; landBy?:
       const cutAt = patch.cutAt ?? previous?.cut_at;
       if (!cutAt) throw new CliUserError('새 판에는 --cut-at 이 필요하다');
       const landBy = patch.landBy ?? previous?.land_by ?? null;
-      if (previous && previous.cut_at === cutAt && previous.land_by === landBy) return scheduleRow(previous);
+      const freezeFrom = patch.freezeFrom ?? previous?.freeze_from ?? null;
+      const freezeUntil = patch.freezeUntil ?? previous?.freeze_until ?? null;
+      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);
       const at = new Date().toISOString();
-      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, updated_at, updated_by) VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-        .run(version, cutAt, landBy, at, by);
+      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);
       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],
       ] as const) {
         if (from !== to) record(db, version, { at, by, id: '@version', field, from, to, released: releasedVersion(root), dev: devVersion() });
       }
@@ -134,12 +144,14 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
     FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | null>>;
   return rows.map((r) => {
     const evidence = [r.evidence, ...evidenceRefs(db, version, r.id!)].filter((value) => value !== null).join('\n');
     return { id: r.id!, title: r.title!, status: r.status as ChecklistItem['status'],
       ...(r.owner !== null ? { owner: r.owner! } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
+      ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors!) as string[] } : {}),
+      ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version! } : {}),
       ...(r.evidence !== null || evidence ? { evidence } : {}), ...(r.disposition !== null ? { disposition: r.disposition as ChecklistItem['disposition'] } : {}),
       updatedAt: r.updated_at!, updatedBy: r.updated_by! };
   });
@@ -153,9 +165,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -196,8 +208,8 @@ function importOnDb(db: Database, version: string): boolean {
       // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
       if (!existing) putItem(db, version, item);
       else {
-        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.updatedAt, item.updatedBy);
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.updatedAt, item.updatedBy);
       }
     }
     for (const entry of data.history) record(db, version, entry);
@@ -224,12 +236,12 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind'] as const;
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'
       ? (!preserveRefs && current.evidence !== item.evidence)
-      : current[field] !== item[field]);
+      : JSON.stringify(current[field]) !== JSON.stringify(item[field]));
     if (!differs) continue;
     if (!(Date.parse(item.updatedAt) > Date.parse(current.updatedAt))) {
       ledgerWonIds.push(item.id);