elanous 0.2.41 → 0.2.43

package/src/decisions/linear-progress-summary.ts

@@ -0,0 +1,78 @@
+import type { DecisionEntry } from './decision-ledger.js';
+import type { Checklist, ChecklistHistory, ChecklistItem } from '../release-loop/checklist.js';
+
+const LINEAR_ISSUE = /\bELA-[A-Z0-9]+\b/gi;
+const PULL_URL = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+/g;
+
+export interface LinearProgressSummary {
+  issue: string;
+  day: string;
+  body: string;
+}
+
+function issueRefs(text: string): string[] {
+  return [...new Set(text.match(LINEAR_ISSUE) ?? [])].map(value => value.toUpperCase());
+}
+
+function eventIssues(item: ChecklistItem): string[] {
+  return issueRefs(`${item.title}\n${item.evidence ?? ''}\n${item.refs?.join('\n') ?? ''}`);
+}
+
+function short(value: unknown): string {
+  return typeof value === 'string' ? value.replace(/[\r\n]+/g, ' ').trim().slice(0, 80) : '미상';
+}
+
+/** Build non-sensitive daily summaries from local ledgers; this function performs no network or file writes. */
+export function buildLinearProgressSummaries(input: {
+  checklist: Checklist;
+  history: readonly ChecklistHistory[];
+  decisions: readonly DecisionEntry[];
+  since: string;
+  now?: Date;
+}): LinearProgressSummary[] {
+  const since = Date.parse(input.since);
+  if (!Number.isFinite(since)) throw new Error('since must be a valid timestamp');
+  const now = input.now ?? new Date();
+  const day = now.toISOString().slice(0, 10);
+  const cells = new Map(input.checklist.items.map(item => [item.id, item]));
+  const grouped = new Map<string, string[]>();
+  const add = (issue: string, line: string) => {
+    const lines = grouped.get(issue) ?? [];
+    if (!lines.includes(line)) lines.push(line);
+    grouped.set(issue, lines);
+  };
+
+  for (const event of input.history) {
+    if (Date.parse(event.at) < since) continue;
+    const item = cells.get(event.id);
+    if (!item || event.field !== 'status') continue;
+    for (const issue of eventIssues(item)) add(issue, `칸 ${item.id}: ${short(event.from)} → ${short(event.to)}`);
+  }
+
+  for (const decision of input.decisions) {
+    const changed = decision.history.filter(event => event.at && Date.parse(event.at) >= since);
+    if (!changed.length) continue;
+    for (const ref of decision.refs ?? []) for (const issue of issueRefs(ref)) {
+      const latest = changed.at(-1)!;
+      add(issue, `결정 ${decision.id}: ${latest.type === 'decided' ? `확정 ${short(latest.choice)}` : latest.type}`);
+    }
+  }
+
+  for (const item of input.checklist.items) {
+    if (item.status === 'green' || item.status === 'done') continue;
+    for (const issue of eventIssues(item)) add(issue, `다음: ${item.id}`);
+  }
+
+  for (const event of input.history) {
+    if (Date.parse(event.at) < since || !['evidence', 'evidence.add'].includes(event.field)) continue;
+    const item = cells.get(event.id);
+    if (!item) continue;
+    const pulls = String(event.to ?? '').match(PULL_URL) ?? [];
+    for (const issue of eventIssues(item)) for (const url of pulls) add(issue, `PR: ${url}`);
+  }
+
+  return [...grouped].sort(([a], [b]) => a.localeCompare(b)).map(([issue, lines]) => {
+    const body = [`진행 요약 · ${day}`, ...lines].join('\n');
+    return { issue, day, body };
+  });
+}

package/src/decisions/linear-progress-sync.ts

@@ -0,0 +1,152 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeFileSync, writeSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { commentLinearIssue } from '../connectors/linear.js';
+import { debug } from '../debug/log.js';
+import { getSecretAsync } from '../nexus/config/secrets/index.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { DecisionLedger } from './decision-ledger.js';
+import { buildLinearProgressSummaries, type LinearProgressSummary } from './linear-progress-summary.js';
+import { checklistHistory, listChecklist } from '../release-loop/checklist.js';
+
+type SentState = Record<string, true>;
+type IssueLookup = { issue?: { id?: string; team?: { key?: string }; comments?: { nodes?: Array<{ body?: string }> } } };
+
+export interface LinearProgressSyncResult {
+  day: string;
+  planned: number;
+  posted: number;
+  skipped: number;
+  failed: number;
+  plan: Array<{ issue: string; body: string; action: 'post' | 'already-posted' | 'team-mismatch' }>;
+}
+
+function readState(path: string): SentState {
+  if (!existsSync(path)) return {};
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  const invalid = !value || typeof value !== 'object' || Array.isArray(value)
+    || Object.entries(value).some(([key, row]) => !/^\d{4}-\d{2}-\d{2}:ELA-[A-Z0-9]+$/.test(key)
+      || (row !== true && (!row || typeof row !== 'object' || Array.isArray(row))));
+  if (invalid) {
+    throw new Error('invalid Linear progress sync state');
+  }
+  // Older entries stored write-only fingerprint/postedAt metadata. Normalize them to the marker that skip logic reads.
+  return Object.fromEntries(Object.keys(value).map(key => [key, true]));
+}
+
+function saveState(path: string, state: SentState): void {
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(state), { mode: 0o600 });
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) unlinkSync(temp); }
+}
+
+async function lookupIssue(apiKey: string, identifier: string, fetchFn: typeof fetch): Promise<IssueLookup['issue']> {
+  const response = await fetchFn('https://api.linear.app/graphql', {
+    method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query: 'query ProgressIssue($id: String!) { issue(id: $id) { id team { key } comments(first: 100) { nodes { body } } } }', variables: { id: identifier } }),
+  });
+  if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+  const body = await response.json() as { data?: IssueLookup; errors?: unknown[] };
+  if (body.errors?.length || !body.data) throw new Error('Linear GraphQL issue lookup failed');
+  return body.data.issue;
+}
+
+function marker(summary: LinearProgressSummary): string { return `progress-sync:${summary.day}:${summary.issue}`; }
+
+function summaries(version: string, now: Date): LinearProgressSummary[] {
+  const checklist = listChecklist(version);
+  const history = [...new Set(checklist.items.map(item => item.id))].flatMap(id => checklistHistory(id));
+  const since = `${now.toISOString().slice(0, 10)}T00:00:00.000Z`;
+  return buildLinearProgressSummaries({ checklist, history, decisions: new DecisionLedger().list({ status: 'all' }), since, now });
+}
+
+/** Plan is read-only by default. `live` sends at most one marked comment per issue per UTC day. */
+export async function syncLinearProgress(options: {
+  version: string;
+  live?: boolean;
+  now?: Date;
+  fetch?: typeof fetch;
+  getSecret?: (name: string) => Promise<string | undefined>;
+  ledgerRoot?: string;
+  /** Injection seam for deterministic sync tests; normal callers use the local ledgers. */
+  buildSummaries?: (version: string, now: Date) => LinearProgressSummary[];
+}): Promise<LinearProgressSyncResult> {
+  const now = options.now ?? new Date();
+  const plans = (options.buildSummaries ?? summaries)(options.version, now);
+  const result: LinearProgressSyncResult = { day: now.toISOString().slice(0, 10), planned: plans.length, posted: 0, skipped: 0, failed: 0,
+    plan: plans.map(summary => ({ issue: summary.issue, body: summary.body, action: 'post' })) };
+  if (!options.live) {
+    for (const item of result.plan) debug.log('linear.progress-sync', 'planned', { issue: item.issue, day: result.day });
+    return result;
+  }
+
+  const apiKey = await (options.getSecret ?? getSecretAsync)('connector.linear.apiKey');
+  if (!apiKey) throw new Error('Linear credential missing');
+  const ledgerRoot = options.ledgerRoot ?? releaseLedgerRoot();
+  const directory = join(ledgerRoot, 'release');
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, 'linear-progress-sync.json');
+  const lockPath = `${path}.lock`;
+  let lock: number | undefined;
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    try { lock = openSync(lockPath, 'wx', 0o600); writeSync(lock, `${process.pid}`); break; }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        const pid = Number(readFileSync(lockPath, 'utf8'));
+        if (Number.isSafeInteger(pid) && pid > 0 && Date.now() - statSync(lockPath).mtimeMs > 30_000) {
+          try { process.kill(pid, 0); }
+          catch (probe) { if ((probe as NodeJS.ErrnoException).code === 'ESRCH') { unlinkSync(lockPath); continue; } }
+        }
+      } catch (probe) { if ((probe as NodeJS.ErrnoException).code === 'ENOENT') continue; }
+      if (Date.now() >= deadline) throw new Error('Linear progress sync lock timeout');
+      await Bun.sleep(25);
+    }
+  }
+  try {
+    const state = readState(path);
+    const fetchFn = options.fetch ?? fetch;
+    for (const summary of plans) {
+      const key = `${summary.day}:${summary.issue}`;
+      if (state[key]) {
+        result.skipped++;
+        result.plan.find(item => item.issue === summary.issue)!.action = 'already-posted';
+        debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'already-posted' });
+        continue;
+      }
+      try {
+        const issue = await lookupIssue(apiKey, summary.issue, fetchFn);
+        if (!issue?.id) throw new Error('Linear issue not found');
+        if (issue.team?.key !== 'DEMO') {
+          result.skipped++;
+          result.plan.find(item => item.issue === summary.issue)!.action = 'team-mismatch';
+          debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'team-not-allowed' });
+          continue;
+        }
+        if ((issue.comments?.nodes ?? []).some(comment => comment.body?.includes(marker(summary)))) {
+          state[key] = true;
+          saveState(path, state);
+          result.skipped++;
+          result.plan.find(item => item.issue === summary.issue)!.action = 'already-posted';
+          debug.log('linear.progress-sync', 'skipped', { issue: summary.issue, day: summary.day, reason: 'remote-marker-found' });
+          continue;
+        }
+        const body = `${summary.body}\n\n_${marker(summary)}_`;
+        await commentLinearIssue({ apiKey, issueId: issue.id, body, fetch: fetchFn });
+        state[key] = true;
+        saveState(path, state);
+        result.posted++;
+        debug.log('linear.progress-sync', 'posted', { issue: summary.issue, day: summary.day });
+      } catch (error) {
+        result.failed++;
+        const reason = error instanceof Error ? (/^Linear GraphQL HTTP \d{3}$/.test(error.message) ? error.message : error.name) : 'unknown';
+        debug.log('linear.progress-sync', 'failed', { issue: summary.issue, day: summary.day, reason });
+      }
+    }
+    return result;
+  } finally {
+    if (lock !== undefined) { closeSync(lock); unlinkSync(lockPath); }
+  }
+}

package/src/domains/outbound-alert.ts

@@ -119,10 +119,42 @@ export function kstMinutes(now: Date = new Date()): number {
   return ((h ?? 0) % 24) * 60 + (m ?? 0);
 }
 
-/** 야간 무음 창(00:00 ≤ t < 06:30 KST). 아침리포트(06:25)는 별도 경로라 비대상. */
+export const OUTBOUND_QUIET_HOURS_ENV = 'ELANOUS_OUTBOUND_QUIET_HOURS';
+const DEFAULT_QUIET_HOURS = '00:00-06:30';
+type QuietHours = 'off' | { start: number; end: number; label: string };
+
+/** `off` 또는 HH:MM-HH:MM 을 분 범위로 해석한다. 잘못된 설정은 기본값에 맡긴다. */
+function parseQuietHours(value: unknown): QuietHours | null {
+  if (value === 'off') return 'off';
+  if (typeof value !== 'string') return null;
+  const match = /^(\d{2}):(\d{2})-(\d{2}):(\d{2})$/.exec(value.trim());
+  if (!match) return null;
+  const [, sh, sm, eh, em] = match;
+  const startHour = Number(sh), startMinute = Number(sm), endHour = Number(eh), endMinute = Number(em);
+  if (startHour > 23 || endHour > 23 || startMinute > 59 || endMinute > 59) return null;
+  const start = startHour * 60 + startMinute, end = endHour * 60 + endMinute;
+  if (start === end) return null;
+  return { start, end, label: `${sh}:${sm}-${eh}:${em}` };
+}
+
+/** config.outbound.quietHours > ELANOUS_OUTBOUND_QUIET_HOURS > 기존 기본 창. */
+function configuredQuietHours(): QuietHours {
+  try {
+    const configValue = parseQuietHours(getUserConfig().outbound?.quietHours);
+    if (configValue) return configValue;
+  } catch { /* use env/default */ }
+  const envValue = parseQuietHours(process.env[OUTBOUND_QUIET_HOURS_ENV]?.trim());
+  return envValue ?? parseQuietHours(DEFAULT_QUIET_HOURS)!;
+}
+
+/** 야간 무음 창. 기본은 기존 00:00 ≤ t < 06:30 KST. */
 export function inQuietHours(now: Date = new Date()): boolean {
-  const m = kstMinutes(now);
-  return m >= 0 && m < 390;
+  const quiet = configuredQuietHours();
+  if (quiet === 'off') return false;
+  const minute = kstMinutes(now);
+  return quiet.start < quiet.end
+    ? minute >= quiet.start && minute < quiet.end
+    : minute >= quiet.start || minute < quiet.end;
 }
 
 /** 최근 사용자 활동 우회 창(분) — 이 시간 내 genuine 사용자 인텐트가 있으면 무음이어도 즉시 발송. */
@@ -465,11 +497,14 @@ export function flushDeferred(path = DEFERRED_PATH, deps: FlushDeferredDeps = {}
 
 /** TEST-PROD-LEAK — a test process may not reach a real bot or the ops daemon. `external` = a third-party bot API
  *  (refused unless curl is a test double replacing the real one); the local daemon is refused only when ops-routed. */
-function assertTestSendFaked(what: string, external = true): void {
+function assertTestSendFaked(what: string, external = true, injectedTransport?: unknown): void {
   let roots: string[] = [];
   try { roots = [getElanousConfigDir(), dirname(ACP_TOKEN_PATH), effectiveInstanceRoot(), conatusDataDir(), dirname(DEFERRED_PATH)]; }
   catch { roots = [dirname(ACP_TOKEN_PATH), dirname(DEFERRED_PATH)]; }
-  assertNoRealSendFromTest(what, { transportFaked: isTestDouble(childProcess.execFileSync, REAL_EXEC_FILE_SYNC), routingRoots: roots, external });
+  const transportFaked = injectedTransport === undefined
+    ? isTestDouble(childProcess.execFileSync, REAL_EXEC_FILE_SYNC)
+    : isTestDouble(injectedTransport);
+  assertNoRealSendFromTest(what, { transportFaked, routingRoots: roots, external });
 }
 
 /** 동기 curl(POST). body 는 stdin. 파싱 실패/에러 → null. `what` names the send for the test guard (never the URL — it carries the token). */
@@ -509,25 +544,28 @@ export function sendOutbound(text: string, kind = 'alert', origin?: (MissionOrig
     : 'unknown');
   ensureOutboundLogSink();
   let bot = origin?.channel === 'discord' ? 'discord:configured' : 'unknown';
+  const quietConfig = configuredQuietHours();
+  const quietMode = quietConfig === 'off' ? 'off' : `window:${quietConfig.label}`;
   const logOutcome = (event: 'sent' | 'deferred' | 'failed', path?: string): void => {
-    try { debug.log('outbound.send', event, { kind: safeObservationLabel(kind), source: safeObservationLabel(source), chars: text.length, bot, ...(path ? { path } : {}) }); } catch { /* fail-open */ }
+    try { debug.log('outbound.send', event, { kind: safeObservationLabel(kind), source: safeObservationLabel(source), chars: text.length, bot, quietMode, ...(path ? { path } : {}) }); } catch { /* fail-open */ }
   };
   // ★ 무음 우회(대표 2026-07-14) — 사용자가 최근(기본 30분) genuine 인텐트(타이핑/버튼탭)를 냈으면
   //   깨어있으므로 야간 무음이어도 즉시 발송(사용자 발원 흐름의 결과물이 아침까지 묶이지 않게).
   //   우회 시 flushDeferred 로 그간 보류분도 함께 전달(사용자가 지금 볼 수 있음).
-  if (inQuietHours() && !userRecentlyActive()) {
+  const quietNow = inQuietHours();
+  if (quietNow && !userRecentlyActive()) {
     const queued = deferOutbound(text, kind, origin);
     if (queued) recordOutbound(text, kind); // 성공한 보류만 회상 대상
     logOutcome(queued ? 'deferred' : 'failed', queued ? 'deferred' : 'queue-failed');
     return queued; // 적재가 성공했을 때만 보류 수락
   }
-  const bypass = inQuietHours();
+  const bypass = quietNow;
   if (bypass) console.error('[outbound] 야간 무음 우회 — 최근 사용자 활동(깨어있음) → 즉시 발송 + 보류분 flush');
   try { flushDeferred(); } catch { /* fail-soft */ }
   // ★ 발송 관측(대표 지시) — 발송 시각·mode·밀림(burst) 판정을 logs.db 에. burst=최근 2분 5건+
   //   (몰려 나가는 중 = 밀림 의심). `elanous logs --category outbound.send` 로 실시간/밀림 구분.
   const { recentCount, burst } = recentSendBurst();
-  logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, ...(burst ? { backlog: true } : {}) });
+  logSend(bypass ? 'quiet-bypass' : 'realtime', kind, { burst, recentCount, quietMode, ...(burst ? { backlog: true } : {}) });
   // ★ origin 되돌림(무음 밖) — 발신 채널로 직접 발송. 성공 시 종료, 실패면 report 폴백.
   if (origin && deliverToOrigin(origin, text, (label) => { bot = label; })) {
     recordOutbound(text, kind);
@@ -706,8 +744,8 @@ export function sendTelegramDirect(
   onBot?: (bot: string) => void,
 ): boolean {
   const sendRaw = (token: string, chatId: string | number, body: string): boolean => {
-    // The transport is checked only after a route is eligible; a test double cannot target the ops universe.
-    assertTestSendFaked('send a real Telegram message', !deps.sendRaw);
+    // The transport is checked only after a route is eligible; injected transports must themselves be test doubles.
+    assertTestSendFaked('send a real Telegram message', true, deps.sendRaw);
     return (deps.sendRaw ?? sendTelegramRaw)(token, chatId, body);
   };
   let cfg: UserConfig | undefined;

package/src/domains/telegram-kind-route.ts

@@ -36,16 +36,23 @@ function operationsBotToken(cfg: UserConfig): string | undefined {
   const tradingTokens = new Set(channels.filter(c => c.roles.includes('report')).map(c => c.botToken));
   // The report (trading) bot is never the operations bot — with or without a channels table (review must-fix · OUT1).
   if (cfg.telegram.reportChannel?.botToken) tradingTokens.add(cfg.telegram.reportChannel.botToken);
+  // An explicit operational channel is authoritative even when env/tokenRef/legacy botToken
+  // resolves first; those older sources can point at a different (or trading) bot.
+  const operationalChannels = channels.filter(c => (c.name === 'ops' && c.roles.includes('system'))
+    || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')));
+  if (operationalChannels.length > 0) {
+    const tokens = new Set(operationalChannels.filter(c => !tradingTokens.has(c.botToken)).map(c => c.botToken));
+    if (tokens.size !== 1) return undefined;
+    const explicitToken = tokens.values().next().value;
+    // The explicitly named operational channel outranks the generic tab's tokenRef;
+    // legacy/env conflicts without a trading identity remain ambiguous and fail closed.
+    if (main.source !== 'channels.main' && main.source !== 'tokenRef'
+      && main.token && main.token !== explicitToken && !tradingTokens.has(main.token)) return undefined;
+    return explicitToken;
+  }
+
   if (main.source !== 'channels.main') return main.token && !tradingTokens.has(main.token) ? main.token : undefined;
-  // channels.main may mean "first channel", which can be the trading bot.
-  // Only a named operations channel (or the named main channel) with an
-  // operational role establishes identity; array order and role alone do not.
-  const tokens = new Set(channels
-    .filter(c => (c.name === 'ops' && c.roles.includes('system'))
-      || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')))
-    .filter(c => !tradingTokens.has(c.botToken))
-    .map(c => c.botToken));
-  return tokens.size === 1 ? tokens.values().next().value : undefined;
+  return undefined;
 }
 
 function isAllowedBot(cfg: UserConfig, kind: string | undefined, token: string): boolean {

package/src/graph-runner/arg-allowance.ts

@@ -0,0 +1,13 @@
+export type AllowanceDecision =
+  | { readonly kind: 'run'; readonly requested: number; readonly granted: number; readonly clamped: boolean }
+  | { readonly kind: 'needs-human'; readonly requested: number; readonly remaining: 0 };
+
+/** Resolve a child allowance against the parent's remaining steps before spawning the child. */
+export function resolveChildAllowance(requested: number, parentRemaining: number): AllowanceDecision {
+  if (!Number.isSafeInteger(requested) || requested < 1) throw new Error('requested allowance must be a positive safe integer');
+  if (!(parentRemaining === Infinity || (Number.isSafeInteger(parentRemaining) && parentRemaining >= 0)))
+    throw new Error('parent remaining allowance must be a non-negative safe integer or Infinity');
+  if (parentRemaining === 0) return { kind: 'needs-human', requested, remaining: 0 };
+  const granted = Math.min(requested, parentRemaining);
+  return { kind: 'run', requested, granted, clamped: granted < requested };
+}

package/src/graph-runner/graph-cli.ts

@@ -5,10 +5,10 @@ import { parse as parseYaml } from 'yaml';
 import { writeStdoutJson } from '../cli/stdout-json.js';
 import type { GraphVariantPlan } from '../self-implement/graph-variant.js';
 import { debug } from '../debug/log.js';
-import { decideGraphApproval, graphRunAlive, lastJsonObject, latestGraphRun, listGraphRuns, manageGraphRun, runGraph, type GraphRunState } from './runner.js';
+import { decideGraphApproval, graphRunAlive, lastJsonObject, latestGraphRun, listGraphRuns, manageGraphRun, runGraph, type GraphRunOptions, type GraphRunState } from './runner.js';
 
-function findGraphFile(graphId: string): string | undefined {
-  const roots = [resolve('graphs'), resolve(import.meta.dir, '../../graphs')];
+function findGraphFile(graphId: string, extraRoots: string[] = []): string | undefined {
+  const roots = [...extraRoots.map((root) => resolve(root)), resolve('graphs'), resolve(import.meta.dir, '../../graphs')];
   for (const root of roots) {
     for (const dir of [root, ...['release', 'ops'].map((part) => join(root, part))]) {
       if (!existsSync(dir)) continue;
@@ -26,7 +26,10 @@ function findGraphFile(graphId: string): string | undefined {
   return undefined;
 }
 
-export function registerGraphCommands(program: Command, runsDeps: { root?: string; processStartMs?: (pid: number) => number | null } = {}): void {
+export function registerGraphCommands(program: Command, runsDeps: {
+  root?: string; processStartMs?: (pid: number) => number | null; graphRoots?: string[];
+  runBash?: NonNullable<GraphRunOptions['deps']>['runBash'];
+} = {}): void {
   const graph = program.command('graph').description('Run a declared command graph or inspect its latest run');
   graph.command('adapt-report')
     .description('Measure recorded graph path diversity, unit calls, adaptations and landings for one goal')
@@ -333,10 +336,23 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
   graph.command('approve <graph_id> <run_id>')
     .option('--reject', 'Reject instead of approving')
     .option('--by <name>', 'Record the approver name')
-    .action((graphId: string, runId: string, opts: { reject?: boolean; by?: string }) => {
+    .action(async (graphId: string, runId: string, opts: { reject?: boolean; by?: string }) => {
       try {
-        const state = decideGraphApproval(graphId, runId, opts.reject ? 'rejected' : 'approved', opts.by);
-        console.log(`${state.graphId} ${state.runId}: ${state.pending?.decision}`);
+        // A release approval is the decision point for a live publish run. Resume its
+        // saved graph immediately so approval does not depend on a later manual tick.
+        // Resolve the release graph before recording the irreversible decision; if it
+        // is unavailable, leave the approval undecided so an operator can retry.
+        const releaseGraph = graphId === 'release-loop' ? findGraphFile(graphId, runsDeps.graphRoots) : undefined;
+        if (graphId === 'release-loop' && !releaseGraph) throw new Error('release-loop graph file not found; approval was not recorded');
+        const state = decideGraphApproval(graphId, runId, opts.reject ? 'rejected' : 'approved', opts.by, runsDeps.root);
+        if (releaseGraph) {
+          await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
+          const { graphTick } = await import('./graph-tick.js');
+          const result = await graphTick(releaseGraph, { resumeRunId: runId, deps: { root: runsDeps.root, runBash: runsDeps.runBash } });
+          console.log(`${state.graphId} ${state.runId}: ${state.pending?.decision} · ${result.action} ${result.status ?? ''}`.trim());
+        } else {
+          console.log(`${state.graphId} ${state.runId}: ${state.pending?.decision}`);
+        }
       } catch (error) {
         console.error(`graph approve: ${error instanceof Error ? error.message : String(error)}`);
         process.exitCode = 1;

package/src/graph-runner/graph-run-api.ts

@@ -29,6 +29,8 @@ export interface GraphRunApiDeps {
   root?: string;
   run?: typeof runGraph;
   now?: () => number;
+  /** Allows a host-owned preview/demo request to stop an in-flight editor graph run. */
+  signal?: AbortSignal;
 }
 
 /** 시작 전에 죽은 런(레시피 없음 등)은 원장 파일이 안 생긴다 — 그 이유를 여기 잠깐 들고 있다가 상태 조회에 돌려준다. */
@@ -187,7 +189,7 @@ export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}):
     return jsonResponse({ error: 'run-workspace-failed', reason: error instanceof Error ? error.message.slice(0, 200) : 'unknown' }, 500);
   }
   debug.log('graphs.run', 'started', { id, runId });
-  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, deps: { root } })
+  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, ...(deps.signal ? { signal: deps.signal } : {}), deps: { root } })
     .then((state) => debug.log('graphs.run', 'finished', { id, runId, status: state.status, executed: state.executed }))
     .catch((error: unknown) => {
       const message = error instanceof Error ? error.message : String(error);

package/src/graph-runner/graph-tick.ts

@@ -8,10 +8,12 @@ import { peerEditRunGate } from '../nexus/api/graph-peer-edit.js';
 import { observeModelInputTokens } from '../harness/model-input-observation.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { DecisionLedger } from '../decisions/decision-ledger.js';
-import { latestGraphRun, runGraph, type GraphRunOptions, type GraphRunState } from './runner.js';
+import { latestGraphRun, listGraphRuns, runGraph, type GraphRunOptions, type GraphRunState } from './runner.js';
 
 export interface GraphTickOptions {
   startIfIdle?: boolean;
+  /** Resume this exact persisted run instead of whichever run happens to be latest. */
+  resumeRunId?: string;
   input?: unknown;
   mineDir?: string;
   deps?: GraphRunOptions['deps'] & { notify?: () => void | Promise<void>; isAlive?: (pid: number) => boolean };
@@ -96,7 +98,13 @@ export async function graphTick(path: string, options: GraphTickOptions = {}): P
     if (refusedAfterNotify) return refusedAfterNotify;
     // The run identity and executed bytes must agree with the ledger and the gate.
     if (current.graphId !== graphId) throw new Error(`graph id changed during tick: ${graphId} -> ${current.graphId}`);
-    const latest = latestGraphRun(graphId, root);
+    const latest = options.resumeRunId
+      ? listGraphRuns(root).runs.find(run => run.graphId === graphId && run.runId === options.resumeRunId) ?? null
+      : latestGraphRun(graphId, root);
+    if (options.resumeRunId && !latest) throw new Error(`graph run not found: ${graphId}/${options.resumeRunId}`);
+    if (options.resumeRunId && (latest?.status !== 'awaiting-approval' || !latest.pending?.decision)) {
+      throw new Error(`graph run is not awaiting a recorded decision: ${graphId}/${options.resumeRunId}`);
+    }
     const growthCard = latest?.growthPark
       ? (options.deps?.growthDecision?.list ?? ((filters: { status: 'all' }) => new DecisionLedger({ stateDir: root }).list(filters)))({ status: 'all' })
         .find(entry => entry.id === latest.growthPark?.decisionId && entry.refs?.includes(latest.growthPark.decisionRef))