elanous 0.2.20 → 0.2.21

package/src/graph-wizard/saved-steps.ts

@@ -0,0 +1,120 @@
+/**
+ * GRAPH-WIZARD-SAVE-RECIPES — a wizard graph saved from the editor keeps its runnable steps.
+ *
+ * The wizard answers with `steps` (node id → {label, step, arg, retries}) and a `recipes` text. The editor
+ * saves through `POST /v1/graphs` / `PUT …/yaml`, which store YAML only, so the steps used to be lost and
+ * the graph could not really run.
+ *
+ * ⛔ We do NOT store the client's `recipes` text: `<mine>/` is HTTP-writable, and a recipes file there would
+ *    make «run my edited graph» into «run my edited command» (TC 10-07 19:31 — graph-run-api.ts header).
+ *    Instead the save stores the *structured* steps in a sidecar (`<mine>/.steps/<id>.json`), every field
+ *    validated against the step library (WIZARD_STEPS); at run time the server itself turns them into
+ *    commands with `recipesYamlFor` — step names from the whitelist, the argument shell-quoted.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { WIZARD_MAX_RETRIES, WIZARD_STEP_IDS, recipesYamlFor, type WizardNodeStep } from './steps.js';
+
+const NODE_ID = /^[a-z0-9][a-z0-9_-]*$/;
+const GRAPH_ID = /^[a-z0-9-]+$/;
+const MAX_NODES = 200;
+const MAX_LABEL = 80;
+const MAX_ARG = 1000;
+
+export function savedStepsFile(mineDir: string, graphId: string): string {
+  return join(mineDir, '.steps', `${graphId}.json`);
+}
+
+function nodeIdsOf(yaml: string): Set<string> {
+  try {
+    const raw = parseYaml(yaml) as { nodes?: Array<{ node_id?: unknown }> } | null;
+    return new Set((raw?.nodes ?? []).map((node) => node?.node_id).filter((id): id is string => typeof id === 'string'));
+  } catch { return new Set(); }
+}
+
+/** Validate the client's steps against the library and the graph's own node ids. Unknown fields are dropped. */
+export function parseWizardSteps(raw: unknown, yaml: string): { ok: true; steps: Record<string, WizardNodeStep> } | { ok: false; reason: string } {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, reason: 'steps must be an object of node id → {label, step, arg, retries}' };
+  const entries = Object.entries(raw as Record<string, unknown>);
+  if (entries.length > MAX_NODES) return { ok: false, reason: `steps: at most ${MAX_NODES} nodes` };
+  const ids = nodeIdsOf(yaml);
+  const steps: Record<string, WizardNodeStep> = {};
+  for (const [nodeId, value] of entries) {
+    if (!NODE_ID.test(nodeId)) return { ok: false, reason: `steps: invalid node id '${nodeId.slice(0, 40)}'` };
+    if (!ids.has(nodeId)) continue; // a node removed by hand since the wizard turn — nothing to keep
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) return { ok: false, reason: `steps.${nodeId} must be an object` };
+    const { label, step, arg, retries } = value as Record<string, unknown>;
+    const out: WizardNodeStep = {};
+    if (label !== undefined) {
+      if (typeof label !== 'string' || label.length > MAX_LABEL) return { ok: false, reason: `steps.${nodeId}.label must be a string ≤ ${MAX_LABEL}` };
+      if (label.trim()) out.label = label.trim();
+    }
+    if (step !== undefined) {
+      if (typeof step !== 'string' || !WIZARD_STEP_IDS.has(step)) return { ok: false, reason: `steps.${nodeId}.step must be one of ${[...WIZARD_STEP_IDS].join(', ')}` };
+      out.step = step;
+    }
+    if (arg !== undefined) {
+      if (typeof arg !== 'string' || arg.length > MAX_ARG || arg.includes('\0')) return { ok: false, reason: `steps.${nodeId}.arg must be a string ≤ ${MAX_ARG}` };
+      if (arg.trim()) out.arg = arg;
+    }
+    if (retries !== undefined) {
+      if (typeof retries !== 'number' || !Number.isInteger(retries) || retries < 0 || retries > WIZARD_MAX_RETRIES) return { ok: false, reason: `steps.${nodeId}.retries must be 0..${WIZARD_MAX_RETRIES}` };
+      if (retries > 0) out.retries = retries;
+    }
+    steps[nodeId] = out;
+  }
+  return { ok: true, steps };
+}
+
+export function writeWizardSteps(mineDir: string, graphId: string, steps: Record<string, WizardNodeStep>): void {
+  if (!GRAPH_ID.test(graphId)) throw new Error('invalid graph id');
+  const file = savedStepsFile(mineDir, graphId);
+  mkdirSync(join(mineDir, '.steps'), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(steps, null, 2)}\n`);
+  renameSync(temp, file);
+}
+
+/** Save the steps and the graph together: the sidecar is written first; if the graph write then throws, the
+ *  sidecar goes back to what it was (or away), so a failed save changes neither. A sidecar failure stops the
+ *  save before the graph is touched. */
+export function withWizardSteps<T>(mineDir: string, graphId: string, steps: Record<string, WizardNodeStep> | null, writeGraph: () => T): T {
+  if (!steps) return writeGraph();
+  const file = savedStepsFile(mineDir, graphId);
+  const before = existsSync(file) ? readFileSync(file, 'utf8') : null;
+  writeWizardSteps(mineDir, graphId, steps);
+  try {
+    return writeGraph();
+  } catch (error) {
+    try {
+      if (before === null) rmSync(file, { force: true }); else writeFileSync(file, before);
+    } catch { /* best effort — the graph write error is the one to report */ }
+    throw error;
+  }
+}
+
+/** Read the sidecar back — re-validated (the file may have been edited by hand), pruned to the graph's nodes. */
+export function readWizardSteps(mineDir: string, graphId: string, yaml: string): Record<string, WizardNodeStep> | null {
+  if (!GRAPH_ID.test(graphId)) return null;
+  const file = savedStepsFile(mineDir, graphId);
+  if (!existsSync(file)) return null;
+  let raw: unknown;
+  try { raw = JSON.parse(readFileSync(file, 'utf8')); } catch { return null; }
+  const parsed = parseWizardSteps(raw, yaml);
+  return parsed.ok ? parsed.steps : null;
+}
+
+/** Recipes the server generates for the graph's `cmd:` nodes that carry a library step (approvals are not
+ *  generated here — the editor run still refuses approval recipes). */
+export function wizardRecipesFor(yaml: string, steps: Record<string, WizardNodeStep>, bin?: string): Record<string, unknown> {
+  let raw: { nodes?: Array<{ node_id?: unknown; recipe?: unknown }> } | null;
+  try { raw = parseYaml(yaml) as typeof raw; } catch { return {}; }
+  const nodes = (raw?.nodes ?? [])
+    .map((node) => ({ nodeId: String(node?.node_id ?? ''), recipe: typeof node?.recipe === 'string' ? node.recipe : '' }))
+    .filter((node) => node.recipe.startsWith('cmd:') && steps[node.nodeId]?.step);
+  if (!nodes.length) return {};
+  const text = bin === undefined ? recipesYamlFor(nodes, steps) : recipesYamlFor(nodes, steps, bin);
+  const parsed = parseYaml(text) as unknown;
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+}

package/src/graph-wizard/steps.ts

@@ -0,0 +1,193 @@
+/**
+ * GRAPH-WIZARD 단계 서재 — 마법사가 짓는 그래프의 `cmd:` 노드가 «이름만»이 아니라 실제로 도는 부품.
+ *
+ * 노드 하나 = 서재의 단계 하나(⊕ 인자). recipes.yaml 은 `elanous graph step <단계> --arg …` 를 부른다.
+ * 단계는 기존 CLI 만 쓴다(research · ask --bare · notify · self review · gh) — 새 실행 경로를 만들지 않는다.
+ * 계약: 표준출력 마지막 줄 = JSON {outcome, text?} (graph runner 의 lastJsonObject 가 읽는다).
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export interface WizardStepSpec {
+  id: string;
+  /** LLM 에게 보이는 한 줄 — 언제 쓰나 · arg 가 무엇인가. */
+  use: string;
+  /** 이 단계가 낼 수 있는 결과(간선 map 키). */
+  outcomes: string[];
+  timeoutMs: number;
+}
+
+export const WIZARD_STEPS: readonly WizardStepSpec[] = [
+  { id: 'web-search', use: '웹/뉴스를 검색해 결과를 모은다. arg = 검색어(예: "오늘 AI 뉴스")', outcomes: ['ok', 'fail'], timeoutMs: 120_000 },
+  { id: 'summarize', use: '앞 단계 결과를 요약한다. arg = 요약 지시(예: "핵심 5줄, 한국어")', outcomes: ['ok', 'fail'], timeoutMs: 300_000 },
+  { id: 'llm', use: '앞 단계 결과를 LLM 으로 가공한다(표로 정리·분류·초안 작성 등). arg = 지시', outcomes: ['ok', 'fail'], timeoutMs: 300_000 },
+  { id: 'check', use: '앞 단계 결과가 기준을 만족하는지 LLM 이 판정한다. arg = 기준. 결과 ok(통과) · rework(다시)', outcomes: ['ok', 'rework', 'fail'], timeoutMs: 300_000 },
+  { id: 'telegram-send', use: '앞 단계 결과를 텔레그램(대표 채널)으로 보낸다. arg 없음', outcomes: ['ok', 'fail'], timeoutMs: 60_000 },
+  { id: 'notify-me', use: '실패·포기 같은 사건을 나(대표)에게 알린다. arg = 알림 문구', outcomes: ['ok', 'fail'], timeoutMs: 60_000 },
+  { id: 'gh-pr-review', use: 'GitHub PR 을 엘라누스 리뷰어로 리뷰한다. arg = PR 번호(없으면 실행 입력 input.pr). 결과 ok(must-fix 없음) · must-fix', outcomes: ['ok', 'must-fix', 'fail'], timeoutMs: 900_000 },
+  { id: 'gh-pr-merge', use: 'GitHub PR 을 squash 머지한다. arg = PR 번호(없으면 input.pr)', outcomes: ['ok', 'fail'], timeoutMs: 300_000 },
+  { id: 'custom', use: '위 단계로 안 되는 외부 연동(노션·슬랙 업로드 등). 실행하면 «아직 구현되지 않음»으로 실패한다. arg = 무엇을 해야 하는지', outcomes: ['ok', 'fail'], timeoutMs: 60_000 },
+];
+
+/** 재시도 상한 — 넘으면 생성 검증이 문제로 되먹인다(조용히 줄이지 않는다). */
+export const WIZARD_MAX_RETRIES = 10;
+
+export const WIZARD_STEP_IDS: ReadonlySet<string> = new Set(WIZARD_STEPS.map((s) => s.id));
+
+export interface WizardNodeStep { label?: string; step?: string; arg?: string; /** 단계 안 재시도 횟수(실패 시 다시 · 노드·간선을 늘리지 않는다). */ retries?: number }
+
+const ELANOUS_BIN = resolve(import.meta.dir, '../../bin/elanous.mjs');
+
+function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+/** 노드 → recipes.yaml. cmd 노드는 서재 단계를, hitl 노드는 한국어 승인 문구를. */
+/**
+ * 단계 명령의 머리 — 기본은 PATH 의 `elanous`(설치본 갱신을 따라간다 · 판 폴더 절대경로를 박지 않는다).
+ * 작업 트리에서 실물로 돌릴 땐 ELANOUS_WIZARD_BIN='bun <트리>/bin/elanous.mjs' 로 바꾼다.
+ */
+export function wizardStepBin(): string {
+  return process.env.ELANOUS_WIZARD_BIN?.trim() || 'elanous';
+}
+
+export function recipesYamlFor(nodes: ReadonlyArray<{ nodeId: string; recipe: string }>, steps: Record<string, WizardNodeStep>, bin = wizardStepBin()): string {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const node of nodes) {
+    const match = /^(cmd|approval):([a-z0-9][a-z0-9-]*)$/.exec(node.recipe);
+    if (!match || seen.has(match[2]!)) continue;
+    seen.add(match[2]!);
+    const meta = steps[node.nodeId] ?? {};
+    if (match[1] === 'approval') {
+      out.push(`${match[2]}:\n  approval: ${JSON.stringify(`${meta.label ?? node.nodeId} — 승인할까요?`)}`);
+      continue;
+    }
+    const spec = WIZARD_STEPS.find((s) => s.id === meta.step) ?? WIZARD_STEPS.find((s) => s.id === 'custom')!;
+    const arg = meta.arg ?? (spec.id === 'custom' ? (meta.label ?? node.nodeId) : '');
+    const retries = meta.retries && meta.retries > 0 ? meta.retries : 0;
+    const command = `${bin} graph step ${spec.id}${arg ? ` --arg ${shellQuote(arg)}` : ''}${retries ? ` --retries ${retries}` : ''}`;
+    out.push(`${match[2]}:\n  command: ${JSON.stringify(command)}\n  timeout_ms: ${spec.timeoutMs * (retries + 1)}`);
+  }
+  return out.length ? `${out.join('\n')}\n` : '{}\n';
+}
+
+interface GraphContext { graphId?: string; runId?: string; nodeId?: string; input?: unknown; outputs?: Record<string, unknown> }
+
+function readContext(): GraphContext {
+  const path = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!path || !existsSync(path)) return {};
+  try { return JSON.parse(readFileSync(path, 'utf8')) as GraphContext; } catch { return {}; }
+}
+
+/** 앞 단계 결과를 사람이 읽는 글로 — 각 결과의 text 를 우선, 아니면 JSON. */
+export function previousText(ctx: GraphContext, limit = 12_000): string {
+  const parts = Object.entries(ctx.outputs ?? {}).map(([id, value]) => {
+    if (value && typeof value === 'object' && typeof (value as { text?: unknown }).text === 'string') return `[${id}]\n${(value as { text: string }).text}`;
+    if (typeof value === 'string') return `[${id}]\n${value}`;
+    return value == null ? '' : `[${id}]\n${JSON.stringify(value)}`;
+  }).filter(Boolean);
+  const text = parts.join('\n\n');
+  return text.length > limit ? text.slice(-limit) : text;
+}
+
+function runElanous(args: string[], input?: string, timeoutMs = 300_000): { code: number; stdout: string; stderr: string } {
+  const proc = spawnSync('bun', [ELANOUS_BIN, ...args], { input, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024 });
+  return { code: proc.status ?? 1, stdout: proc.stdout ?? '', stderr: proc.stderr ?? '' };
+}
+
+function lastJson(stdout: string): Record<string, unknown> | undefined {
+  for (const line of stdout.split('\n').reverse()) {
+    const t = line.trim();
+    if (!t.startsWith('{')) continue;
+    try { return JSON.parse(t) as Record<string, unknown>; } catch { /* keep looking */ }
+  }
+  return undefined;
+}
+
+function prNumber(arg: string | undefined, ctx: GraphContext): string | undefined {
+  const fromInput = ctx.input && typeof ctx.input === 'object' ? (ctx.input as { pr?: unknown }).pr : undefined;
+  const raw = (arg?.trim() || (fromInput === undefined ? '' : String(fromInput))).replace(/^#/, '');
+  return /^\d+$/.test(raw) ? raw : undefined;
+}
+
+function ask(prompt: string): { ok: boolean; text: string; error?: string } {
+  const r = runElanous(['ask', '--bare', '--json', prompt]);
+  const reply = lastJson(r.stdout)?.reply;
+  return typeof reply === 'string' && r.code === 0 ? { ok: true, text: reply } : { ok: false, text: '', error: r.stderr.slice(-500) || 'ask failed' };
+}
+
+export interface StepResult { outcome: string; text?: string; error?: string }
+
+/** 단계 안 재시도 — 실패면 최대 retries 번 더. 노드·간선을 늘리지 않고 «다시 시도»를 표현한다. */
+export function runWizardStepWithRetries(step: string, arg: string | undefined, retries = 0, run: typeof runWizardStep = runWizardStep): StepResult & { tries: number } {
+  let tries = 0;
+  let result: StepResult = { outcome: 'fail' };
+  for (; tries <= Math.max(0, retries); ) {
+    tries += 1;
+    result = run(step, arg);
+    if (result.outcome !== 'fail') break;
+    debug.log('graph.wizard', 'step-retry', { step, tries, max: retries + 1 });
+  }
+  return { ...result, tries };
+}
+
+/** `elanous graph step <id> --arg …` 의 몸. 부르는 쪽은 그래프 러너(cmd 노드)다. */
+export function runWizardStep(step: string, arg: string | undefined, ctx: GraphContext = readContext()): StepResult {
+  const prev = previousText(ctx);
+  const started = Date.now();
+  let result: StepResult;
+  switch (step) {
+    case 'web-search': {
+      const query = arg?.trim() || (ctx.input && typeof ctx.input === 'object' && typeof (ctx.input as { query?: unknown }).query === 'string' ? (ctx.input as { query: string }).query : '');
+      if (!query) { result = { outcome: 'fail', error: 'web-search: 검색어(arg)가 없다' }; break; }
+      const r = runElanous(['research', '--json', '--limit', '5', query], undefined, 120_000);
+      const out = lastJson(r.stdout);
+      const total = (out?.metadata as { totalHits?: number } | undefined)?.totalHits ?? 0;
+      result = r.code === 0 && typeof out?.output === 'string' && total > 0 ? { outcome: 'ok', text: out.output } : { outcome: 'fail', error: `검색 결과 없음 (${r.stderr.slice(-300)})` };
+      break;
+    }
+    case 'summarize':
+    case 'llm': {
+      const instruction = arg?.trim() || (step === 'summarize' ? '핵심만 한국어로 간결하게 요약하라.' : '앞 결과를 정리하라.');
+      const r = ask(`${instruction}\n\n--- 입력 ---\n${prev || '(입력 없음)'}`);
+      result = r.ok ? { outcome: 'ok', text: r.text } : { outcome: 'fail', error: r.error };
+      break;
+    }
+    case 'check': {
+      const r = ask(`아래 결과가 기준을 만족하는지 판정하라. 기준: ${arg?.trim() || '내용이 충실하고 사실에 맞다'}\n첫 줄에 PASS 또는 REWORK 만, 둘째 줄에 이유 한 줄.\n\n--- 결과 ---\n${prev || '(없음)'}`);
+      result = !r.ok ? { outcome: 'fail', error: r.error } : { outcome: /^\s*PASS/i.test(r.text) ? 'ok' : 'rework', text: r.text };
+      break;
+    }
+    case 'telegram-send':
+    case 'notify-me': {
+      const body = step === 'notify-me' ? `${arg?.trim() || '그래프 알림'}${ctx.graphId ? ` (${ctx.graphId})` : ''}` : (prev || arg || '');
+      if (!body.trim()) { result = { outcome: 'fail', error: '보낼 내용이 없다' }; break; }
+      const r = runElanous(['notify', '--stdin', '--json', ...(step === 'notify-me' ? ['--kind', 'ops-alert'] : [])], body, 60_000);
+      result = lastJson(r.stdout)?.ok === true ? { outcome: 'ok', text: '보냄' } : { outcome: 'fail', error: '발송 실패 — elanous logs --category outbound.send' };
+      break;
+    }
+    case 'gh-pr-review': {
+      const pr = prNumber(arg, ctx);
+      if (!pr) { result = { outcome: 'fail', error: 'PR 번호가 없다(arg 또는 input.pr)' }; break; }
+      const r = runElanous(['self', 'review', pr, '--json'], undefined, 900_000);
+      const out = lastJson(r.stdout) as { mustFix?: unknown[]; verdict?: string } | undefined;
+      result = !out ? { outcome: 'fail', error: r.stderr.slice(-300) || 'review failed' }
+        : { outcome: (out.mustFix?.length ?? 0) > 0 ? 'must-fix' : 'ok', text: JSON.stringify({ verdict: out.verdict, mustFix: out.mustFix }) };
+      break;
+    }
+    case 'gh-pr-merge': {
+      const pr = prNumber(arg, ctx);
+      if (!pr) { result = { outcome: 'fail', error: 'PR 번호가 없다(arg 또는 input.pr)' }; break; }
+      const r = runElanous(['gh', 'pr', 'merge', pr, '--squash'], undefined, 300_000);
+      result = r.code === 0 ? { outcome: 'ok', text: `PR #${pr} 머지` } : { outcome: 'fail', error: r.stderr.slice(-300) };
+      break;
+    }
+    default:
+      result = { outcome: 'fail', error: `아직 구현되지 않은 단계: ${arg ?? step} — recipes.yaml 의 이 줄을 실제 명령으로 바꾸라` };
+  }
+  debug.log('graph.wizard', 'step', { step, graphId: ctx.graphId, nodeId: ctx.nodeId, outcome: result.outcome, ms: Date.now() - started });
+  return result;
+}

package/src/harness/harness-cli-command.ts

@@ -23,7 +23,7 @@ import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
-import { DRAFT_SWEEP_CONCURRENCY, mapBounded, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
+import { collectDraftMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
 import { debug } from '../debug/log.js';
 import { installHarnessSalvageCommand, installHarnessSalvageRetentionCommand } from './harness-salvage-cli.js';
 import { decideNestedElanousLaunch, readNestedElanousDepth } from './nested-elanous-policy.js';
@@ -47,6 +47,8 @@ import { runHarnessPlanRfc } from './harness-plan-rfc.js';
 import { classifyGarbage, isGarbageProcessTarget, type GarbageProcess } from './process-garbage.js';
 import type { MissionSolveOutcome } from './mission-solve-loop.js';
 import { formatAxis, formatAxisObservations, inspectAskMarkers, inspectUnpressedDecisionSignals } from '../../scripts/ask-marker-check.js';
+import { enterJourneyNode, ensureJourneyKey, exitJourneyNode, JOURNEY_KEY_ENV, passJourneyNode, withJourneyNode } from '../self-dev/graph-journey-nodes.js';
+import { intakeTakesQueue, readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 
 let harnessPlanRfcForTesting: typeof runHarnessPlanRfc | undefined;
 let harnessAskMarkerInspectorForTesting: ((ask: string) => readonly string[]) | undefined;
@@ -777,13 +779,17 @@ async function dispatchHarnessAskSay(
   immediateLaunch?: HarnessQueueDeps['launch'],
   immediateExit?: () => Promise<number>,
 ): Promise<void> {
-  await runInjectedHarnessHandler(async () => {
+  // HARNESS-FULL-GRAPH — 여정 조인 키는 이 발사 동안만 환경에 싣는다(자식은 그동안 물려받는다).
+  const journeyPreset = Boolean(process.env[JOURNEY_KEY_ENV]?.trim());
+  try { await runInjectedHarnessHandler(async () => {
     assertHarnessChildLlmModel(opts);
     if (isHarnessDryRun(opts)) {
       resolveLaunchSubstrate(opts);
       printHarnessLaunchDryRun(dryRunPreview);
       return;
     }
+    ensureJourneyKey();
+    const journey = { provenance: dryRunPreview.entrance, ...(opts.goalType ? { goalType: opts.goalType as GoalType } : {}) };
     // Resolve the launch directory once; descendants and the checkpoint retain the same identity.
     const queued = process.env.ELANOUS_HARNESS_QUEUE_LAUNCH && process.env.ELANOUS_HARNESS_SEAT;
     const queueSeat = queued === 'OP' || queued === 'TC' || queued === 'MK' || queued === 'UX' ? queued : undefined;
@@ -801,10 +807,21 @@ async function dispatchHarnessAskSay(
     const podSeat = resolved.substrate === 'pod' && ['OP', 'TC', 'MK', 'UX'].includes(inheritedSeat ?? '')
       ? inheritedSeat as QueueSeat : undefined;
     const stampedSeat = resolved.substrate === 'pod' ? opts.seat ?? queueSeat ?? podSeat ?? assigned : assigned;
+    // HARNESS-FULL-GRAPH 2판 — 대기열을 탈지는 «그래프»가 정한다. 코드는 상태 값(queued|direct)만 내고,
+    // 다음 노드는 YAML(⊕ 조건이 맞는 launch 오버레이)의 intake 간선이 고른다. 기본 YAML 은 오늘과 같은 길이다.
+    // ⛔ 대기열은 자리가 있어야 하고 대기열 자식·--no-queue 는 다시 줄 서지 않는다 — 그 셋은 그래프가 못 넘는다.
+    const intakeLabel = shouldQueue && stampedSeat ? 'queued' : 'direct';
+    // intake 는 판정만 하는 관측 노드 — 진입·출구를 한 자리에서.
+    passJourneyNode('intake', { ...journey, outcome: intakeLabel });
+    const intakeRoute = readJourneyEdge('intake', intakeLabel, { seat: stampedSeat ?? 'none', substrate: resolved.substrate });
+    const queueEligible = opts.queue !== false && !process.env.ELANOUS_HARNESS_QUEUE_LAUNCH && Boolean(stampedSeat);
+    const takeQueue = intakeTakesQueue(intakeLabel, intakeRoute, queueEligible);
+    // 실제로 탄 간선을 전제 검사 «뒤»에 남긴다(그래프 답과 다르면 honored=false · 이유).
+    recordJourneyEdge(intakeRoute, takeQueue ? 'queue' : 'launch-gate', intakeRoute.to === 'queue' && !takeQueue ? (opts.queue === false ? '--no-queue' : process.env.ELANOUS_HARNESS_QUEUE_LAUNCH ? 'queue-child' : 'no-seat') : undefined);
     if (directSay && opts.queue === false) {
       try { debug.log('harness.queue', 'bypass', { seat: stampedSeat ?? null, reason: '--no-queue' }); }
       catch { /* Observation must not prevent an emergency launch. */ }
-    } else if (shouldQueue && stampedSeat) {
+    } else if (takeQueue && stampedSeat) {
       resolveNestedElanousOption(opts);
       const flags: string[] = [];
       const values: Array<[string, string | undefined]> = [
@@ -833,6 +850,7 @@ async function dispatchHarnessAskSay(
         [opts.forceGate, '--force-gate'],
       ] as const) if (enabled) flags.push(flag);
       let row: QueueItem;
+      enterJourneyNode('queue', journey);
       try {
         row = await addHarnessQueue({ seat: stampedSeat, launchCwd: process.cwd(), refuseDuplicate: true,
         ...(dryRunPreview.goalPath ? { ask: dryRunPreview.goalPath } : { say: dryRunPreview.input }),
@@ -842,12 +860,17 @@ async function dispatchHarnessAskSay(
         }, queueDeps);
         await queueDeps?.afterEnqueue?.(row);
       } catch (error) {
-        if (!(error instanceof HarnessQueueDuplicateError)) throw error;
+        if (!(error instanceof HarnessQueueDuplicateError)) {
+          exitJourneyNode('queue', { ...journey, outcome: 'error', data: { error: error instanceof Error ? error.message : String(error) } });
+          throw error;
+        }
         console.error(`발사 거절 — ${error.message.replace(/[\r\n]+/g, ' ')}`);
+        exitJourneyNode('queue', { ...journey, outcome: 'refused' });
         process.exitCode = 1;
         return;
       }
-      const result = await tickHarnessQueue({ ...queueDeps, ...(immediateLaunch ? { launch: immediateLaunch } : {}) }, row.id);
+      const result = await withJourneyNode('queue', journey, () => tickHarnessQueue({ ...queueDeps, ...(immediateLaunch ? { launch: immediateLaunch } : {}) }, row.id));
+      exitJourneyNode('queue', { ...journey, outcome: result.outcome === 'launched' && result.item?.id === row.id ? 'launched' : 'waiting', data: { queueItemId: row.id, queueTick: result.outcome } });
       if (result.outcome === 'launched' && result.item?.id === row.id) {
         if (immediateExit) process.exitCode = await immediateExit();
       } else if (result.outcome === 'waiting') {
@@ -880,6 +903,8 @@ async function dispatchHarnessAskSay(
       const previous = process.env.ELANOUS_HARNESS_SEAT;
       if (stampedSeat) process.env.ELANOUS_HARNESS_SEAT = stampedSeat;
       else delete process.env.ELANOUS_HARNESS_SEAT;
+      // 배치 노드 — 실행 칸(local | pod)이 그 출구 라벨이고, YAML 의 decompose 간선(on: substrate)이 그 값으로 갈린다.
+      passJourneyNode('dispatch', { ...journey, outcome: resolved.substrate });
       try { await dispatch(resolved, stampedOpts); }
       finally {
         if (previous === undefined) delete process.env.ELANOUS_HARNESS_SEAT;
@@ -900,11 +925,16 @@ async function dispatchHarnessAskSay(
     // CLI wiring tests time out on them. Gate tests inject deps or opt in with ELANOUS_LAUNCH_GATE_LIVE=1.
     if (process.env.NODE_ENV === 'test' && Object.keys(gate).length === 0 && process.env.ELANOUS_LAUNCH_GATE_LIVE !== '1') {
       try { debug.log('execution-loop.launch-gate', 'skipped-test-env', { goalId }); } catch { /* observation is fail-soft */ }
+      passJourneyNode('launch-gate', { ...journey, outcome: 'pass', data: { skipped: 'test-env' } });
       await launch();
       return;
     }
-    const budget = await (gate.readBudget ?? (() => readHarnessLaunchBudget(opts)))();
-    const decision = preLaunchGate({ goalId, budget, forceLaunch: opts.forceGate === true }, gate);
+    enterJourneyNode('launch-gate', journey);
+    const decision = await withJourneyNode('launch-gate', journey, async () => {
+      const budget = await (gate.readBudget ?? (() => readHarnessLaunchBudget(opts)))();
+      return preLaunchGate({ goalId, budget, forceLaunch: opts.forceGate === true }, gate);
+    });
+    exitJourneyNode('launch-gate', { ...journey, outcome: decision.action === 'proceed' ? 'pass' : 'refuse', data: { action: decision.action } });
     if (decision.action !== 'proceed') {
       console.error(`❌ launch gate: ${decision.action} — ${decision.reason.split(/\r?\n/, 1)[0]}`);
       process.exitCode = 3;
@@ -916,7 +946,7 @@ async function dispatchHarnessAskSay(
     ];
     if (warnings.length > 0) console.error(`⚠️ launch gate: ${warnings.join(' · ').split(/\r?\n/, 1)[0]}`);
     await launch();
-  });
+  }); } finally { if (!journeyPreset) delete process.env[JOURNEY_KEY_ENV]; }
 }
 
 function normalizeHarnessPlanOptions(opts: HarnessPlanOptions): HarnessPlanOptions {
@@ -2420,15 +2450,16 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     },
     getClaimOwner: async (repository, number) => claimCommentOwner(repository, number, execute),
     getActiveClaimOwner: async (repository, number) => {
+      // DRAFT-METRIC: the batched GraphQL comments (oldest first, proven complete) answer without a per-draft REST call.
+      const batched = (await detailFor(repository, number))?.comments;
+      if (batched) return activeClaimOwnerFromBodies(batched);
       const pages = ghJson<Array<Array<{ body: string; created_at: string }>>>(['api', '--paginate', '--slurp',
         `repos/${repository}/issues/${number}/comments?per_page=100`], execute);
       if (!Array.isArray(pages) || pages.some((page) => !Array.isArray(page)
         || page.some((comment) => typeof comment.body !== 'string' || !Number.isFinite(Date.parse(comment.created_at)))))
         throw new Error('Incomplete claim comments');
-      const last = pages.flat().sort((a, b) => Date.parse(b.created_at) - Date.parse(a.created_at))
-        .map((comment) => comment.body)
-        .find((body) => draftClaimOwner(body) !== undefined || body.startsWith('🔧 처리 끝 —'));
-      return last ? draftClaimOwner(last) : undefined;
+      return activeClaimOwnerFromBodies(pages.flat().sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))
+        .map((comment) => comment.body));
     },
     getReviewGate: async (draft, repository) => reviewGateForDraft(draft, repository),
   };
@@ -2464,6 +2495,12 @@ async function draftSweepRunTtl(repository: string, deps: HarnessDraftSweepDeps,
   }
 }
 
+/** Latest claim or release among comments in chronological order (oldest first); a release means no owner. */
+export function activeClaimOwnerFromBodies(bodies: readonly string[]): string | undefined {
+  const last = [...bodies].reverse().find((body) => draftClaimOwner(body) !== undefined || body.startsWith('🔧 처리 끝 —'));
+  return last ? draftClaimOwner(last) : undefined;
+}
+
 function draftClaimOwner(body: string): string | undefined {
   return /^🔧 처리 중 — owner ([^\n·]+?) · /m.exec(body)?.[1]?.trim();
 }
@@ -2520,6 +2557,25 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         process.exitCode = 1;
       }
     });
+  drafts.command('metrics').description('draft 재고·최장 나이·needs-owner·48h 전환율 (읽기 전용 · PR 근거는 GraphQL 배치)')
+    .option('--json', 'JSON 으로 출력')
+    .option('--repo <owner/name>', '조회할 GitHub 저장소')
+    .action(async (opts: { json?: boolean; repo?: string }) => {
+      try {
+        const execute = deps.execute ?? executeGh;
+        const repository = resolveRepositoryName({ repo: opts.repo ?? deps.repository?.(), executeGh: (args) => execute(args) });
+        if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
+        const started = Date.now();
+        const metrics = await collectDraftMetrics(repository, deps.adapters ?? githubDraftSweepAdapters(deps.execute), deps.now?.() ?? new Date());
+        try { debug.log('self-dev.draft-metrics', 'collected', { repository, ms: Date.now() - started, ...metrics }); } catch { /* fail-soft */ }
+        const write = deps.write ?? console.log;
+        if (opts.json) write(JSON.stringify({ repository, ...metrics }));
+        else write(`draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`);
+      } catch (error) {
+        console.error(humanErrorLine(error));
+        process.exitCode = 1;
+      }
+    });
   return drafts.command('sweep').description('draft PR 을 조사한다 (기본: 변경 없음)')
     .option('--apply', '판정한 라벨 변경과 종료를 적용')
     .option('--json', '판정 결과를 JSON 으로 출력')

package/src/index.ts

@@ -4465,8 +4465,10 @@ selfCmd
     };
     try {
       const { dispatchHeavyCheck } = await import('./self-implement/gate-remote.js');
-      const { execFileSync } = await import('node:child_process');
-      const repo = execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim();
+      const { runGitCommand } = await import('./git-fs/runner.js');
+      const topLevel = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+      if (topLevel.status !== 0) throw new Error(`git rev-parse --show-toplevel failed: ${topLevel.stderr.trim() || `rc=${topLevel.status}`}`);
+      const repo = topLevel.stdout.trim();
       // Only a committed --base range is reproducible on another host: the default mode measures uncommitted files, --pr
       // reads files through gh on this host, and the remote checkout runs from the repository root — those stay local.
       const { realpathSync } = await import('node:fs');
@@ -4891,7 +4893,7 @@ const selfOrchestrateCmd = selfCmd
         // ☸️ 풀이 «원격 노드뿐»이면 이 기계의 이미지는 아무도 안 쓴다 — 로컬 판정·굽기를 건너뛰고 기준 판 = HEAD 로 노드 동기화만 한다.
         //   🩸 2026-09-26 실측: 원격 전용 풀인데 로컬 이미지가 없다고 로컬에서 굽다가 로컬 클러스터(elanous-h1)가 없어 런이 시작도 전에 죽었다.
         const remoteOnlyPool = poolMembers.length > 0 && poolMembers.every((m) => Boolean(m.sshHost));
-        const headCommit = remoteOnlyPool ? ((await import('node:child_process')).spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout?.trim() || null) : null;
+        const headCommit = remoteOnlyPool ? ((await import('./git-fs/runner.js')).runGitCommand(process.cwd(), ['rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout.trim() || null) : null;
         let image = remoteOnlyPool
           ? { imageCommit: headCommit, headCommit, fresh: true, reason: 'remote-only pool — 노드 쪽에서 맞춘다' }
           : podImageFreshness();
@@ -4901,7 +4903,8 @@ const selfOrchestrateCmd = selfCmd
           } else {
             if (!opts.json) ui.info(`[pod] 이미지 다시 굽기 — ${image.reason} (~1분)`);
             const { spawnSync } = await import('node:child_process');
-            const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).stdout.trim() || process.cwd();
+            const { runGitCommand } = await import('./git-fs/runner.js');
+            const top = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).stdout.trim() || process.cwd();
             // bun 1.4 applies the 1 MiB default maxBuffer: a docker build log past it kills the child (ENOBUFS · status null).
             const b = spawnSync('bash', [`${top}/docker/harness/build.sh`], { encoding: 'utf8', timeout: 900_000, maxBuffer: 64 * 1024 * 1024 });
             if (b.status !== 0) { ui.error(`--substrate pod: 이미지 굽기 실패 rc=${b.status}${b.error ? ` (${(b.error as NodeJS.ErrnoException).code ?? b.error.message})` : ''}: ${(b.stdout + b.stderr).slice(-400)}`); process.exit(2); }

package/src/intake-plane/digest.ts

@@ -125,6 +125,19 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
   };
 }
 
+function digestNoteRef(e: DigestEntry): string {
+  return e.noteName ? `[[${e.noteName}]]` : e.note?.trim() || e.url?.trim() || e.id;
+}
+
+/** 참고 줄에 이름을 다는 상한 — 많은 날에도 화면 한 장을 지킨다(M 은 그대로 센다). */
+const DIGEST_REFERENCE_NAMED = 10;
+
+function digestReferenceLine(entries: DigestEntry[]): string {
+  const named = entries.slice(0, DIGEST_REFERENCE_NAMED).map(digestNoteRef).join(', ');
+  const rest = entries.length - DIGEST_REFERENCE_NAMED;
+  return `참고 ${entries.length}편 — 노트: ${named}${rest > 0 ? ` 외 ${rest}편 · 원장 \`elanous intake items\`` : ''}`;
+}
+
 /** 노트 절 — 축별 묶음 · 노트 링크 · 한 줄 요약 · 골 후보. */
 export function renderDigestMarkdown(d: IntakeDigest): string {
   const L: string[] = [`## 📰 오늘의 흡수 요약 (${d.absorbed.length})`, ''];
@@ -165,14 +178,9 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
 
 /** 텔레그램 — 흡수 렌즈가 대조한 항목만 SCQA 짧은 판으로 낸다. */
 export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: string; notePath?: string } = {}): string {
-  if (d.seat && !d.absorbed.length) return '오늘 새 소식 없음';
-  if (d.seat) return [
-    `흡수 ${d.absorbed.length}`,
-    ...d.absorbed.map((item) => `- ${item.oneLiner ?? item.noteName ?? item.id}${item.url ? ` · ${item.url}` : ''}`),
-  ].join('\n');
   // «Touching» is decided by the lens verdict alone; a missing note summary only changes how S reads (ACP must-fix).
   const touching = d.absorbed.filter((e) => e.impact);
-  const L = [`흡수 ${d.absorbed.length} → 우리에게 닿는 것 ${touching.length}`];
+  const L = [`흡수 ${d.absorbed.length}편 → 우리에게 닿는 것 ${touching.length}`];
   // 관심 뉴스는 최대 셋 — 기사마다 S(요약 첫 줄) · A(엘라누스 함의 첫 줄) · 링크를 한 덩어리로(NEWS-INTAKE).
   for (const article of (d.news ?? []).slice(0, 3)) {
     L.push(`📰 ${article.title}`);
@@ -181,9 +189,7 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
     L.push(article.url);
   }
   if (d.shadowSuggestions?.length) L.push(`뉴스 칸 제안 ${d.shadowSuggestions.length}건 (그림자·판 미등록): ${d.shadowSuggestions.slice(0, 3).map((s) => `[${s.verdict}] ${s.fact}${s.url ? ` ${s.url}` : ''}`).join(' · ')}`);
-  if (!touching.length) return L.join('\n');
-  // At most three items are shown, each as its own S·C·A·link block so context and source stay paired;
-  // a later item sharing (verdict, target) says «위와 같은 행동» instead of repeating the A sentence (ACP must-fix).
+  // At most three items are shown, each as its own S·C·A·note block so context and source stay paired.
   // S must be the note's own summary: items without one still count as touching but are not shown (ACP must-fix).
   const shownItems = touching.filter((e) => e.oneLiner?.trim()).slice(0, 3);
   const actionSeen = new Set<string>();
@@ -205,10 +211,11 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
       `S 무엇: ${e.oneLiner?.trim() || '노트 한 줄 요약 없음'}`,
       `C 우리에게 왜: ${impact.why}`,
       `A 그래서 무엇을 하나: ${action}`,
-      `🔗 원문 링크: ${e.url?.trim() || '링크 없음'}`,
+      `🔗 노트: ${digestNoteRef(e)}`,
     );
   }
   if (touching.length > shownItems.length) L.push('', `닿는 것 ${touching.length - shownItems.length}건 더(요약 없는 것 포함) · 원장 \`elanous intake items\``);
-  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 참고`);
+  const reference = d.absorbed.filter((e) => !e.impact);
+  if (reference.length) L.push('', digestReferenceLine(reference));
   return L.join('\n');
 }

package/src/maturity/feature-maturity.ts

@@ -16,10 +16,11 @@ export const FEATURE_MATURITY = {
     '/today': { pwa: 'stable' },
     '/term': { pwa: 'stable' },
     '/live': { pwa: 'stable' },
+    '/live-run': { pwa: 'beta' },        // HARNESS-RUN-LIVE-GRAPH (0.2.21) — 하니스 런 하나가 도는 장면
     '/market': { pwa: 'stable' },
     '/sessions': { pwa: 'stable' },
     '/settings': { pwa: 'beta' },
-    '/editor': { pwa: 'beta' },
+    '/editor': { pwa: 'stable' },        // EDITOR-NAV-PUBLIC (0.2.21) — 데모·0순위 피처: 역할을 안 고른 기기에도 «만들기 › 편집기»
     '/intake': { pwa: 'beta' },
     '/trace': { pwa: 'beta' },
     '/inside': { pwa: 'beta' },