elanous 0.2.21 → 0.2.23

package/src/expression/i18n/messages.ja.ts

@@ -39,6 +39,10 @@ export const messagesJa: Messages = {
   rangeError: '値は {min} から {max} の範囲で指定してください。',
   patternError: '"{value}" は想定された形式と一致しません。',
 
+  // Chat fallback
+  chatNoSynthesisLead: '回答を最後まで書けませんでした — ツールを {n} 回使ううちに、まとめる時間が尽きました。質問を絞ってもう一度聞いてください(例: ひとつだけ)。',
+  chatFoldedInternalTail: '● 内部記録を折りたたみ · {n} 行 · f で展開',
+
   // Async + status
   loading: '読み込み中…',
   saving: '保存中…',
@@ -76,6 +80,7 @@ export const messagesJa: Messages = {
   setupBanner: 'elanous — セットアップウィザード',
   setupWritingTo: '保存先: {path}',
   setupComplete: 'セットアップ完了',
+  setupErrorReportNotice: '問題が起きると、elanous はエラーを運営チームに自動で報告します(エラー内容・バージョン・ランダムなインストール ID — 名前やメールは送りません)。オフにするには: elanous config set errorReports.enabled false',
   setupRerunHint: '再実行: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

package/src/expression/i18n/messages.ko.ts

@@ -39,6 +39,10 @@ export const messagesKo: Messages = {
   rangeError: '값은 {min}에서 {max} 사이여야 합니다.',
   patternError: '"{value}"이(가) 예상 형식과 일치하지 않습니다.',
 
+  // Chat fallback
+  chatNoSynthesisLead: '답을 끝까지 쓰지 못했습니다 — 도구를 {n}번 쓰는 동안 정리할 시간이 끝났습니다. 질문을 좁혀 다시 물어 주세요(예: 무엇 하나만).',
+  chatFoldedInternalTail: '● 내부 기록 접힘 · {n}줄 · f 로 펼치기',
+
   // Async + status
   loading: '불러오는 중…',
   saving: '저장 중…',
@@ -76,6 +80,7 @@ export const messagesKo: Messages = {
   setupBanner: 'elanous — 셋업 마법사',
   setupWritingTo: '저장 경로: {path}',
   setupComplete: '셋업 완료',
+  setupErrorReportNotice: '오류가 나면 운영팀에 자동으로 알립니다(오류 내용·버전·무작위 설치 ID — 이름·메일 없이). 끄기: elanous config set errorReports.enabled false',
   setupRerunHint: '다시 실행: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

package/src/expression/i18n/messages.zh.ts

@@ -39,6 +39,10 @@ export const messagesZh: Messages = {
   rangeError: '值必须在 {min} 到 {max} 之间。',
   patternError: '"{value}" 不符合预期格式。',
 
+  // Chat fallback
+  chatNoSynthesisLead: '未能写完回答 — 在使用工具 {n} 次之后，整理的时间已用完。请缩小问题范围后再问一次(例如：只问一件事)。',
+  chatFoldedInternalTail: '● 内部记录已折叠 · {n} 行 · 按 f 展开',
+
   // Async + status
   loading: '加载中…',
   saving: '保存中…',
@@ -76,6 +80,7 @@ export const messagesZh: Messages = {
   setupBanner: 'elanous — 设置向导',
   setupWritingTo: '保存到: {path}',
   setupComplete: '设置完成',
+  setupErrorReportNotice: '出错时，elanous 会自动向运营团队报告错误(错误内容、版本和随机安装 ID — 不包含姓名或邮箱)。关闭方法: elanous config set errorReports.enabled false',
   setupRerunHint: '重新运行: {cmd}',
 
   // Setup wizard — Step 1 (LLM provider)

package/src/expression/i18n/types.ts

@@ -50,6 +50,12 @@ export interface Messages {
   /** Template — supplies `{value}`. */
   patternError: string;
 
+  // ── Chat fallback ────────────────────────────────────────────────
+  /** Template — supplies `{n}`. Optional for older locale bundles. */
+  chatNoSynthesisLead?: string;
+  /** Template — supplies `{n}`. Optional for older locale bundles. */
+  chatFoldedInternalTail?: string;
+
   // ── Async + status ───────────────────────────────────────────────
   loading: string;
   saving: string;
@@ -100,6 +106,8 @@ export interface Messages {
   setupWritingTo: string;
   /** Banner shown after the wizard saves the config. */
   setupComplete: string;
+  /** First-run notice that error reports are on by default — what is sent and how to turn it off. Keep the command untranslated. Optional so older bundles fall back to English. */
+  setupErrorReportNotice?: string;
   /** Template — supplies `{cmd}` (typically `elanous setup`). */
   setupRerunHint: string;
 

package/src/github/pr-labels.ts

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

package/src/graph-kinds/registry.ts

@@ -20,13 +20,13 @@ export interface NodeKindEntry {
   run?: NodeKindRun;
 }
 
-export const HARNESS_CORE_KINDS = ['agent', 'gate', 'git', 'judge', 'observe', 'hitl', 'subgraph'] as const;
+export const HARNESS_CORE_KINDS = ['agent', 'gate', 'git', 'judge', 'observe', 'hitl', 'subgraph', 'prompt'] as const;
 
 // Workflow validation, the palette, and executor variant labels read the same keys.
 export const WORKFLOW_CORE_KINDS = ['prompt', 'bash', 'skill', 'cft', 'approval', 'if', 'switch', 'iteration', 'classify', 'extract', 'set', 'filter', 'template', 'http', 'showroom', 'task', 'scheduleTrigger', 'webhookTrigger', 'discordTrigger', 'telegramTrigger', 'manualTrigger', 'chatTrigger', 'subworkflow', 'knowledge'] as const;
 
 const descriptions: Record<GraphKind, readonly string[]> = {
-  harness: ['Run an agent', 'Check an execution gate', 'Perform git operations', 'Judge an outcome', 'Observe a result', 'Request human input', 'Run a child graph'],
+  harness: ['Run an agent', 'Check an execution gate', 'Perform git operations', 'Judge an outcome', 'Observe a result', 'Request human input', 'Run a child graph', 'Run an LLM prompt'],
   workflow: ['Run an LLM prompt', 'Run a shell command', 'Invoke a skill', 'Invoke a CFT method', 'Request approval', 'Branch on a condition', 'Select a case', 'Iterate items', 'Classify input', 'Extract structured data', 'Assign variables', 'Filter items', 'Render a template', 'Make an HTTP request', 'Run a showroom', 'Create a task', 'Start on a schedule', 'Start on a webhook', 'Start on Discord', 'Start on Telegram', 'Start manually', 'Start on chat', 'Call another workflow', 'Search the vault for context'],
 };
 
@@ -93,21 +93,21 @@ export function getNodeKind(graph: GraphKind, kind: string): NodeKindEntry | und
 
 function isNodeKindRun(run: NodeKindRun): boolean {
   if (!run || typeof run !== 'object' || Array.isArray(run)) return false;
-  if ('bash' in run) return typeof run.bash === 'string' && run.bash.trim().length > 0 && !('http' in run) && !('skill' in run) && !('mcp' in run);
+  if ('bash' in run) return typeof run.bash === 'string' && run.bash.trim().length > 0 && !('prompt' in run) && !('http' in run) && !('skill' in run) && !('mcp' in run);
   if ('http' in run) {
-    return !('skill' in run) && !('mcp' in run)
+    return !('prompt' in run) && !('skill' in run) && !('mcp' in run)
       && typeof run.http === 'object' && run.http !== null
       && typeof run.http.method === 'string' && run.http.method.trim().length > 0
       && typeof run.http.url === 'string' && run.http.url.trim().length > 0
       && (run.http.body === undefined || typeof run.http.body === 'string');
   }
-  if ('skill' in run) return !('mcp' in run)
+  if ('skill' in run) return !('prompt' in run) && !('mcp' in run)
     && typeof run.skill === 'object' && run.skill !== null
     && typeof run.skill.name === 'string' && run.skill.name.trim().length > 0
     && (run.skill.prompt === undefined || typeof run.skill.prompt === 'string');
   if ('mcp' in run) {
     const spec = run.mcp;
-    return typeof spec === 'object' && spec !== null && !Array.isArray(spec)
+    return !('prompt' in run) && typeof spec === 'object' && spec !== null && !Array.isArray(spec)
       && typeof spec.server === 'string' && /^[a-z0-9_-]+$/.test(spec.server)
       && typeof spec.tool === 'string' && /^[a-z0-9_-]+$/.test(spec.tool)
       && (spec.args === undefined || (typeof spec.args === 'object' && spec.args !== null && !Array.isArray(spec.args)));

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

@@ -154,10 +154,12 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
   graph.command('tick <file>')
     .description('Advance one graph run, resuming a pending decision or starting only when requested')
     .option('--start', 'Start a new run when the graph is idle')
+    .option('--schedule', 'Subscribe graph YAML triggers.schedule to the workflow scheduler and tick on each fire')
     .option('--input <json>', 'JSON object passed to a newly started run')
     .option('--json', 'Print the tick result as JSON')
-    .action(async (file: string, opts: { start?: boolean; input?: string; json?: boolean }) => {
+    .action(async (file: string, opts: { start?: boolean; schedule?: boolean; input?: string; json?: boolean }) => {
       try {
+        if (opts.schedule && (opts.start || opts.input !== undefined || opts.json)) throw new Error('--schedule cannot be combined with --start, --input or --json');
         if (opts.input !== undefined && !opts.start) throw new Error('--input requires --start');
         let input: Record<string, unknown> | undefined;
         if (opts.input !== undefined) {
@@ -169,11 +171,41 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         }
         await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
         const { graphTick } = await import('./graph-tick.js');
+        if (opts.schedule) {
+          const { createScheduleSource } = await import('../workflow-runtime/triggers/schedule-source.js');
+          const graphFile = resolve(file);
+          const source = createScheduleSource();
+          // The CLI tick callback is the graph counterpart of the workflow scheduler's onEmit.
+          const onScheduledTick = async () => {
+            try {
+              const { notifyGraphEvents } = await import('./graph-notify.js');
+              const result = await graphTick(graphFile, { startIfIdle: true, deps: { notify: async () => { await notifyGraphEvents(); } } });
+              if (result.status === 'refused') console.error(`graph tick: refused: ${result.reason}`);
+              else if (result.status === 'failed') console.error(`graph tick: ${result.runId}: failed`);
+            } catch (error) {
+              debug.log('graph.runner', 'schedule-tick-failed', { file: graphFile, error: error instanceof Error ? error.message : String(error) });
+              console.error(`graph tick: ${error instanceof Error ? error.message : String(error)}`);
+            }
+          };
+          source.subscribeGraph(graphFile, onScheduledTick);
+          if (!source.subscriptions().length) throw new Error('graph triggers.schedule is missing');
+          await source.start();
+          if (source.handle()?.skipped.length) {
+            const reasons = source.handle()!.skipped.map(item => item.reason).join('; ');
+            await source.stop();
+            throw new Error(`graph schedule skipped: ${reasons}`);
+          }
+          console.log(`graph schedule: ${source.subscriptions().length} active`);
+          const shutdown = () => { void source.stop().then(() => { process.exitCode = 0; }); };
+          process.once('SIGINT', shutdown);
+          process.once('SIGTERM', shutdown);
+          return;
+        }
         const result = await graphTick(file, { startIfIdle: opts.start, ...(input === undefined ? {} : { input }),
           deps: { notify: async () => { const { notifyGraphEvents } = await import('./graph-notify.js'); await notifyGraphEvents(); } } });
         if (opts.json) await writeStdoutJson(JSON.stringify(result) + '\n');
         else console.log(`graph tick: ${result.action}${result.runId ? ` ${result.runId}: ${result.status}` : ''}`);
-        if (result.status === 'failed') process.exitCode = 1;
+        if (result.status === 'failed' || result.status === 'refused') process.exitCode = 1;
       } catch (error) {
         console.error(`graph tick: ${error instanceof Error ? error.message : String(error)}`);
         process.exitCode = 1;

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

@@ -11,6 +11,7 @@ import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { jsonResponse } from '../nexus/api/json-response.js';
+import { peerEditRefusalBody, peerEditRunGate } from '../nexus/api/graph-peer-edit.js';
 import { defaultGraphsDir } from '../self-implement/graph-templates.js';
 import { runGraph, type GraphRunState } from './runner.js';
 import { readWizardSteps, wizardRecipesFor } from '../graph-wizard/saved-steps.js';
@@ -143,6 +144,12 @@ export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}):
   if (!id) return jsonResponse({ error: 'bad_request', reason: 'invalid graph id' }, 400);
   const mine = findMine(mineDirOf(deps), id);
   if (!mine) return jsonResponse({ error: 'not-found', id, reason: '내 그래프에만 실행이 있다 — 핵심 그래프는 복제해서 돌린다' }, 404);
+  // W9c — a peer «edit» save runs nothing on this machine until the owner approves it. Unreadable marker = refused.
+  const peerGate = peerEditRunGate(mineDirOf(deps), id);
+  if (!peerGate.ok) {
+    debug.log('graphs.run', 'refused-peer-edit', { id, error: peerGate.error }, { level: 'warn' });
+    return jsonResponse(peerEditRefusalBody(id, peerGate), 409);
+  }
   const recipesFile = deps.recipesFile ?? join(defaultGraphsDir(), 'demo', 'editor-recipes.yaml');
   let recipeText: string;
   let allowed: Set<string>;

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

@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto';
-import { closeSync, mkdirSync, openSync, readFileSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { closeSync, mkdirSync, openSync, readFileSync, realpathSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { parse as parseYaml } from 'yaml';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { debug } from '../debug/log.js';
+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';
@@ -11,23 +13,74 @@ import { latestGraphRun, runGraph, type GraphRunOptions, type GraphRunState } fr
 export interface GraphTickOptions {
   startIfIdle?: boolean;
   input?: unknown;
+  mineDir?: string;
   deps?: GraphRunOptions['deps'] & { notify?: () => void | Promise<void>; isAlive?: (pid: number) => boolean };
 }
 
 export interface GraphTickResult {
-  action: 'waiting' | 'resumed' | 'started' | 'idle';
+  action: 'waiting' | 'resumed' | 'started' | 'idle' | 'refused';
   runId?: string;
-  status?: GraphRunState['status'];
+  status?: GraphRunState['status'] | 'refused';
+  reason?: 'peer-edit-unapproved' | 'peer-edit-unreadable';
 }
 
 /** One tick owns the graph from the latest-state read through notification and the chosen action. */
 export async function graphTick(path: string, options: GraphTickOptions = {}): Promise<GraphTickResult> {
-  const document: unknown = parseYaml(readFileSync(path, 'utf8'));
-  const graphId = document && typeof document === 'object' && !Array.isArray(document)
-    ? (document as Record<string, unknown>).graph_id : undefined;
-  if (typeof graphId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(graphId) || graphId === '.' || graphId === '..') {
-    throw new Error(`invalid graph id: ${String(graphId)}`);
-  }
+  const mineDir = options.mineDir ?? join(elanousStateRoot(), 'graphs');
+  const inside = (dir: string, file: string): boolean => {
+    const contained = relative(dir, file);
+    return contained !== '' && contained !== '..' && !contained.startsWith(`..${sep}`) && !isAbsolute(contained);
+  };
+  const inspect = (): { source: string; graphId: string; ids: string[] } => {
+    const source = readFileSync(path, 'utf8');
+    const document: unknown = parseYaml(source);
+    const graphId = document && typeof document === 'object' && !Array.isArray(document)
+      ? (document as Record<string, unknown>).graph_id : undefined;
+    if (typeof graphId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(graphId) || graphId === '.' || graphId === '..') {
+      throw new Error(`invalid graph id: ${String(graphId)}`);
+    }
+    const ids: string[] = [];
+    const file = resolve(path);
+    const realFile = realpathSync(path);
+    let realMine: string | undefined;
+    try { realMine = realpathSync(mineDir); }
+    catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+    for (const candidate of [file, realFile]) {
+      if (inside(resolve(mineDir), candidate) || (realMine && inside(realMine, candidate))) {
+        const name = basename(candidate);
+        if (/\.ya?ml$/.test(name)) ids.push(name.replace(/\.ya?ml$/, ''));
+      }
+    }
+    if (ids.length) ids.push(graphId);
+    return { source, graphId, ids: [...new Set(ids)] };
+  };
+  const initial = inspect();
+  const graphId = initial.graphId;
+  const peerRefusal = (ids: string[]): GraphTickResult | null => {
+    for (const id of ids) {
+      const gate = peerEditRunGate(mineDir, id);
+      if (gate.ok) continue;
+      debug.log('graph.runner', 'tick-peer-edit-refused', {
+        id,
+        editedBy: gate.error === 'peer-edit-unapproved' ? gate.record.editedBy : undefined,
+        version: gate.error === 'peer-edit-unapproved' ? gate.record.version : undefined,
+      });
+      return { action: 'refused', status: 'refused', reason: gate.error };
+    }
+    return null;
+  };
+  const refused = peerRefusal(initial.ids);
+  if (refused) return refused;
+  const peerEditRefused = Symbol('tick-peer-edit-refused');
+  let nodeRefusal: GraphTickResult | null = null;
+  const runDeps: GraphRunOptions['deps'] = {
+    ...options.deps,
+    beforeNode: () => {
+      options.deps?.beforeNode?.();
+      nodeRefusal = peerRefusal([...new Set([...initial.ids, ...inspect().ids])]);
+      if (nodeRefusal) throw peerEditRefused;
+    },
+  };
   const root = options.deps?.root ?? effectiveInstanceRoot();
   const lock = join(root, 'graph-runs', graphId, '.tick.lock');
   mkdirSync(join(root, 'graph-runs', graphId), { recursive: true });
@@ -38,6 +91,11 @@ export async function graphTick(path: string, options: GraphTickOptions = {}): P
     acquireTickLock(lock, graphId, options.deps?.isAlive ?? processAlive);
     acquired = true;
     await options.deps?.notify?.();
+    const current = inspect();
+    const refusedAfterNotify = peerRefusal([...new Set([...initial.ids, ...current.ids])]);
+    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 growthCard = latest?.growthPark
       ? (options.deps?.growthDecision?.list ?? ((filters: { status: 'all' }) => new DecisionLedger({ stateDir: root }).list(filters)))({ status: 'all' })
@@ -49,10 +107,10 @@ export async function graphTick(path: string, options: GraphTickOptions = {}): P
     if (latest?.status === 'awaiting-approval' && !latest.pending?.decision && !growthDecided) {
       result = { action: 'waiting', runId: latest.runId, status: latest.status };
     } else if (latest?.status === 'running' || (latest?.status === 'awaiting-approval' && (latest.pending?.decision || growthDecided))) {
-      const state = await runGraph(path, { resumeRunId: latest.runId, deps: { ...options.deps, root } });
+      const state = await runGraph(path, { resumeRunId: latest.runId, graphSource: current.source, deps: { ...runDeps, root } });
       result = { action: 'resumed', runId: state.runId, status: state.status };
     } else if (options.startIfIdle) {
-      const state = await runGraph(path, { input: options.input, deps: { ...options.deps, root } });
+      const state = await runGraph(path, { input: options.input, graphSource: current.source, deps: { ...runDeps, root } });
       result = { action: 'started', runId: state.runId, status: state.status };
     } else {
       result = { action: 'idle' };
@@ -60,6 +118,9 @@ export async function graphTick(path: string, options: GraphTickOptions = {}): P
     (options.deps?.log ?? ((event: string, data: Record<string, unknown>) => debug.log('graph.runner', event, data)))
       ('tick', { graphId, action: result.action, ...(result.runId ? { runId: result.runId } : {}) });
     return result;
+  } catch (error) {
+    if (error === peerEditRefused && nodeRefusal) return nodeRefusal;
+    throw error;
   } finally {
     try {
       if (acquired) {

package/src/graph-runner/runner.ts

@@ -20,7 +20,9 @@ import { parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type Gr
 import { createGraphVariant, type GraphVariantPlan } from '../self-implement/graph-variant.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 import { executeBashNode } from '../workflow-runtime/nodes/bash.js';
+import { interpolate } from '../workflow-runtime/variables.js';
 import type { BashNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
+import { releaseResumeAcceptedRegressions, releaseResumeWaiver, type AcceptedRegression } from '../../scripts/release-loop/resume.js';
 
 type BashRun = WorkflowDeps['runBash'];
 
@@ -37,7 +39,8 @@ export interface GraphRunState {
   path: string[];
   /** startedAt/endedAt (ISO) and seconds are written when the node runs; ledgers before GRAPH-NODE-TIMES (0.2.19) have none. */
   nodes: Array<{ nodeId: string; ok: boolean; exit: number | null; executed: boolean; output?: unknown; error?: string; decidedBy?: string; decidedAt?: string;
-    startedAt?: string; endedAt?: string; seconds?: number }>;
+    startedAt?: string; endedAt?: string; seconds?: number;
+    waiver?: { reason: string; at: string; original: { exit: number | null; output?: unknown; error?: string } } }>;
   /** The node now running and when it started; cleared when its record is written. */
   currentNode?: { nodeId: string; startedAt: string };
   input?: unknown;
@@ -59,12 +62,18 @@ export interface GraphRunState {
 
 export interface GraphRunOptions {
   input?: unknown;
+  /** Bytes already checked by the tick gate, used for a current-graph start or legacy resume. */
+  graphSource?: string;
   dryRun?: boolean;
   variant?: { goal: string; plan: GraphVariantPlan };
   runId?: string;
   resumeRunId?: string;
   resumeGraphId?: string;
   fromNodeId?: string;
+  /** Release-only: accept the recorded failed node without executing it, and expose its regression to known-issues. */
+  releaseWaiver?: { nodeId: string; reason: string; requestedRegressions: AcceptedRegression[]; acceptedRegressions: AcceptedRegression[] };
+  /** Release-only: add accepted issues independently of a waiver at a restart boundary. */
+  releaseAcceptedRegressions?: { requested: AcceptedRegression[]; acceptedRegressions: AcceptedRegression[] };
   useCurrentGraph?: boolean;
   /**
    * RELEASE-LEDGER-UNIVERSE — stamp every cmd: child with this run's ledger root (`ELANOUS_STATE_DIR`).
@@ -72,7 +81,7 @@ export interface GraphRunOptions {
    * its own universe and lands in the tree-derived test universe while the run ledger is prod.
    */
   pinChildUniverse?: boolean;
-  deps?: { root?: string; runBash?: BashRun; log?: (event: string, data: Record<string, unknown>) => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
+  deps?: { root?: string; runBash?: BashRun; callLLM?: (prompt: string) => Promise<string>; log?: (event: string, data: Record<string, unknown>) => void; beforeNode?: () => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
 }
 
 function safeSegment(value: string): string {
@@ -83,24 +92,29 @@ function safeSegment(value: string): string {
 }
 
 type CommandRecipe = { command: string; dry_run_command?: string; timeout_ms?: number };
-type Recipe = CommandRecipe | ({ approval: string } & Partial<CommandRecipe>);
+type PromptRecipe = { prompt: string };
+type Recipe = CommandRecipe | PromptRecipe | ({ approval: string } & Partial<CommandRecipe>);
 
 /** 접두 없는 recipe 가 카탈로그 역할이고, 그래프 옆 recipes.yaml 에 같은 키의 `{ command }` 가 있을 때만 cmd 처럼 실행한다. */
 function roleCommand(recipe: string, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): CommandRecipe | undefined {
   if (!recipe || recipe === 'none' || recipe.includes(':') || !catalogRoles.has(recipe)) return undefined;
   const entry = recipes[recipe];
   // An entry that carries an approval only runs through `approval:` — never as a bare command.
-  return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
+  return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
     ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
     ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } : undefined;
 }
 
-function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; approval?: { approval: string } } {
+function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; prompt?: PromptRecipe; approval?: { approval: string } } {
   if (node.recipe === 'none') return {};
+  if (node.kind === 'prompt' && node.recipe.startsWith('prompt:')) {
+    const entry = recipes[node.recipe.slice('prompt:'.length)];
+    return entry && 'prompt' in entry ? { prompt: entry } : {};
+  }
   if (node.recipe.startsWith('cmd:')) {
     const id = node.recipe.slice(4);
     const entry = recipes[id];
-    return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
+    return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
       ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
       ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } } : {};
   }
@@ -133,7 +147,10 @@ function recipesFor(path: string, recipeSource: string): Record<string, Recipe>
   for (const [id, raw] of Object.entries(parsed)) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(`invalid recipe: ${id}`);
     const item = raw as Record<string, unknown>;
-    if (Object.hasOwn(item, 'approval')) {
+    if (Object.hasOwn(item, 'prompt')) {
+      if (typeof item.prompt !== 'string' || !item.prompt.trim() || Object.keys(item).some(key => key !== 'prompt')) throw new Error(`invalid recipe: ${id}`);
+      recipes[id] = { prompt: item.prompt };
+    } else if (Object.hasOwn(item, 'approval')) {
       if (typeof item.approval !== 'string' || !item.approval.trim() ||
         (item.command !== undefined && (typeof item.command !== 'string' || !item.command.trim())) ||
         (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0)) ||
@@ -377,12 +394,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (options.fromNodeId && !options.resumeRunId) throw new Error('--from requires --resume');
   if (options.useCurrentGraph && !options.resumeRunId) throw new Error('--use-current-graph requires --resume');
   if (options.variant && options.resumeRunId) throw new Error('variant cannot be combined with --resume');
+  if (options.releaseWaiver && (!options.resumeRunId || options.fromNodeId !== options.releaseWaiver.nodeId)) throw new Error('release waiver requires --resume --from <waived node>');
+  if (options.releaseAcceptedRegressions && (!options.resumeRunId || !options.fromNodeId || options.releaseWaiver)) throw new Error('accepted regressions require a release resume boundary');
   const root = options.deps?.root ?? effectiveInstanceRoot();
   const matchingRuns = options.resumeRunId && !options.resumeGraphId
     ? listGraphRuns(root).runs.filter((run) => run.runId === options.resumeRunId && run.graphPath === resolve(path)) : [];
   if (matchingRuns.length > 1) throw new Error(`ambiguous run id: ${options.resumeRunId}`);
   const currentSource = options.resumeRunId && (options.resumeGraphId || matchingRuns.length) && !options.useCurrentGraph
-    ? undefined : readFileSync(path, 'utf8');
+    ? undefined : options.graphSource ?? readFileSync(path, 'utf8');
   const currentHeader: unknown = options.resumeRunId && !options.resumeGraphId && !matchingRuns.length ? parseYaml(currentSource!) : undefined;
   const resumeGraphId = options.resumeGraphId ?? matchingRuns[0]?.graphId ?? (currentHeader && typeof currentHeader === 'object' && !Array.isArray(currentHeader)
     ? (currentHeader as Record<string, unknown>).graph_id : undefined);
@@ -393,7 +412,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   }
   const snapshotDir = saved ? `${saved.statePath}.graph` : undefined;
   const graphMode: 'snapshot' | 'current' = snapshotDir && saved?.graphSnapshot && !options.useCurrentGraph ? 'snapshot' : 'current';
-  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? readFileSync(path, 'utf8');
+  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? options.graphSource ?? readFileSync(path, 'utf8');
   // The shared YAML parser requires a recipe string. A command-less node in
   // this runner is represented internally as `none`, without changing that parser.
   const raw: unknown = parseYaml(source);
@@ -451,7 +470,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   for (const node of graph.nodes) {
     if (node.recipe === 'none') continue;
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
-    if (!resolved.command && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
+    if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
   const graphId = safeSegment(graph.graphId);
   if (saved && graphId !== saved.graphId) {
@@ -488,6 +507,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     throw new Error('graph or recipes changed since grown run');
   }
   if (state.growth?.length) graph = withGrowth(graph, state.growth);
+  let waivedRecord: GraphRunState['nodes'][number] | undefined;
   if (options.fromNodeId) {
     if (state.status !== 'failed' || state.pending || state.dryRun) throw new Error('--from requires a failed, non-dry run without pending approval');
     if (graphMode === 'current' && (!state.sourceHash || state.sourceHash !== approvalSourceHash)) throw new Error('graph or recipes changed since failed run');
@@ -524,6 +544,39 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     if (resolveNodeRecipe(graph.nodes.find((node) => node.nodeId === options.fromNodeId)!, recipes, catalogRoles).approval) {
       throw new Error('--from cannot restart an approval node');
     }
+    if (options.releaseWaiver) {
+      if (graphId !== 'release-loop') throw new Error('release waiver requires the release-loop graph');
+      const checked = releaseResumeWaiver(state, { from: options.fromNodeId, waive: options.releaseWaiver.nodeId, reason: options.releaseWaiver.reason, acceptedRegressions: options.releaseWaiver.requestedRegressions });
+      if (!checked || JSON.stringify(checked.acceptedRegressions) !== JSON.stringify(options.releaseWaiver.acceptedRegressions)) throw new Error('release waiver input changed before restart');
+      const route = new Set<string>();
+      let cursor: string | undefined = nextNode(graph.edges, options.fromNodeId, 'ok', 'ok');
+      while (cursor && !route.has(cursor) && cursor !== 'known-issues') {
+        route.add(cursor);
+        cursor = nextNode(graph.edges, cursor, 'ok', 'ok');
+      }
+      if (cursor !== 'known-issues' || route.has('publish') || route.has('approve-publish')) throw new Error('waived node must reach known-issues before publication');
+    }
+    if (options.releaseAcceptedRegressions) {
+      if (graphId !== 'release-loop') throw new Error('accepted regressions require the release-loop graph');
+      const route = new Set<string>();
+      let cursor: string | undefined = options.fromNodeId;
+      while (cursor && !route.has(cursor) && cursor !== 'known-issues') {
+        route.add(cursor);
+        cursor = nextNode(graph.edges, cursor, 'ok', 'ok');
+      }
+      if (cursor !== 'known-issues' || route.has('publish') || route.has('approve-publish')) throw new Error('accepted regressions must reach known-issues before publication');
+      const checked = releaseResumeAcceptedRegressions(state, options.releaseAcceptedRegressions.requested, options.fromNodeId);
+      if (JSON.stringify(checked) !== JSON.stringify(options.releaseAcceptedRegressions.acceptedRegressions)) throw new Error('accepted regressions changed before restart');
+      state.input = { ...(state.input as Record<string, unknown>), acceptedRegressions: checked };
+    }
+    if (options.releaseWaiver) {
+      waivedRecord = state.nodes[from];
+      state.input = { ...(state.input as Record<string, unknown>), acceptedRegressions: options.releaseWaiver.acceptedRegressions };
+    } else if (graphId === 'release-loop' && state.nodes.slice(from).some((record) => record.waiver)) {
+      // Restarting at or before a waived node drops its waiver record, so its accepted issue goes with it.
+      state.input = { ...(state.input as Record<string, unknown>),
+        acceptedRegressions: releaseResumeAcceptedRegressions(state, [], options.fromNodeId) };
+    }
     state.path = state.path.slice(0, from);
     state.nodes = state.nodes.slice(0, from);
     state.executed = state.nodes.filter((node) => node.executed).length;
@@ -625,6 +678,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     writeFileSync(join(`${statePath}.graph`, 'recipes.yaml'), recipeSource, { flag: 'wx' });
   }
   while (current !== undefined) {
+    options.deps?.beforeNode?.();
     const node = graph.nodes.find((n) => n.nodeId === current);
     if (!node) throw new Error(`undeclared node: ${current}`);
     const resumingPending = state.pending?.nodeId === current;
@@ -643,6 +697,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
     const command = resolved.command;
+    const prompt = resolved.prompt;
     const approval = resolved.approval ? { approval: approvalMessage(resolved.approval.approval, state.input) } : undefined;
     if (resumingPending && (!approval || approval.approval !== state.pending?.message)) {
       throw new Error(`pending approval no longer matches graph: ${current}`);
@@ -679,7 +734,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     let exit: number | null = null;
     let error: string | undefined;
     let output: unknown;
-    if (command && (!approval || state.dryRun || ok) && (!state.dryRun || command.dry_run_command) && !resumingCompleted) {
+    const waiving = options.releaseWaiver?.nodeId === current && waivedRecord !== undefined;
+    if (command && !waiving && (!approval || state.dryRun || ok) && (!state.dryRun || command.dry_run_command) && !resumingCompleted) {
       const outputs: Record<string, unknown> = Object.create(null);
       // 구조 산출(마지막 JSON 줄)이 있으면 그것을, 없으면 원문을 준다 — 다음 노드가 판단을 «값»으로 받는다.
       for (const previous of state.nodes) outputs[previous.nodeId] = lastJsonObject(previous.output) ?? previous.output ?? null;
@@ -739,10 +795,34 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       error = result.error ? redactCredentials(result.error) : undefined;
       state.executed++;
     }
+    if (prompt && !waiving && !state.dryRun && !resumingCompleted) {
+      const outputs: Record<string, { ok: boolean; output: unknown; durationMs: number }> = Object.create(null);
+      for (const previous of state.nodes) outputs[previous.nodeId] = { ok: previous.ok, output: lastJsonObject(previous.output) ?? previous.output ?? null, durationMs: 0 };
+      try {
+        const text = interpolate(prompt.prompt, {
+          arguments: typeof state.input === 'string' ? state.input : state.input === undefined ? '' : JSON.stringify(state.input),
+          artifactsDir: dirname(statePath), outputs,
+        });
+        if (text.missing.length) throw new Error(`missing prompt reference: ${text.missing.join(', ')}`);
+        // The LLM is injected only; production wiring to a provider is a follow-up slice.
+        if (!options.deps?.callLLM) throw new Error('prompt node requires an injected LLM (deps.callLLM)');
+        output = await options.deps.callLLM(text.text);
+        ok = true;
+      } catch (cause) {
+        ok = false;
+        error = cause instanceof Error ? cause.message : String(cause);
+      }
+      state.executed++;
+    }
     const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     // A wall clock stepped back mid-node must not record an end before the start.
     const nodeEndedAt = new Date(Math.max(Date.now(), Date.parse(nodeStartedAt))).toISOString();
     delete state.currentNode;
+    if (waiving) {
+      output = JSON.stringify({ outcome: 'ok', verdict: 'waived', summary: `waived ${current}`, reason: options.releaseWaiver!.reason });
+      ok = true;
+      exit = 0;
+    }
     if (resumingCompleted && completed) {
       ok = completed.ok;
       exit = completed.exit;
@@ -753,7 +833,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       if (approval && !state.dryRun && !command) {
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !!command && (!state.dryRun || !!command.dry_run_command), ...((command || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: !waiving && ((!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun)), ...((waiving || ((command || prompt || approval) && (!state.dryRun || !!command?.dry_run_command))) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+        ...(waiving ? { waiver: { reason: options.releaseWaiver!.reason, at: nodeEndedAt, original: { exit: waivedRecord!.exit, ...(waivedRecord!.output === undefined ? {} : { output: waivedRecord!.output }), ...(waivedRecord!.error === undefined ? {} : { error: waivedRecord!.error }) } } } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
@@ -761,7 +842,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       delete state.pending;
       delete state.approvalSourceHash;
     }
-    const reported = command && (!state.dryRun || command.dry_run_command) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
+    const reported = waiving || (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome = typeof reported === 'string' ? reported : undefined;
     console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit });