elanous 0.2.34 → 0.2.36

package/graphs/journey/units/author-dialogue/author-dialogue.yaml

@@ -0,0 +1,42 @@
+# 저작 ↔ 구현 «대화 고리» (내부 문서 `RFC-progressive-goal-elaboration-2026-10-21` §7).
+# author(고정 층 소유 · 구체화 층 편집자) ⇄ implement(질문자/제안자) · judge(gate·review) 지적도 같은 대화로.
+# 간선 ① author→implement «구체화 층 vN» · ② implement→author «발견/질문» · ③ author→implement «답 = vN+1»
+#      ④ implement→judge→(findings)→author. 왕복 상한 = max_visits 5. 방향·KPI 를 바꿔야 하면 author 가 needs-human.
+# 실행: 첫 왕복(① = E1 착수 구체화 · 사건 goal-elaborated · GOAL-ELABORATE-ON-ARRIVAL) ⊕
+#       ④→③ refine 되돌이(첫 라운드 judge findings → author 가 E3 goal-refined 를 읽어 v2 deliver · GOAL-REFINE-FROM-FIRST-IMPL ·
+#       orchestrator 는 런당 한 번 — goal-refine.ts GOAL_REFINE_MAX_VISITS). judge 는 라운드별 값(data.rounds)을 읽는다.
+#       값 공급자가 없는 implement·judge 는 «통과»(done · reason declared-only:pass-through)라 E1 성공 → dispatch-pod 로 간다.
+graph_id: author-dialogue
+version: 1
+unit:
+  inputs: [ask, context, prior]
+  outputs: [result, evidence]
+  exits: [done, needs-human, failed]
+entry_node: author
+terminal_nodes: [done, needs-human, failed]
+nodes:
+  - node_id: author
+    kind: agent
+    recipe: 'cmd:dialogue-author'
+    max_visits: 5
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - node_id: implement
+    kind: agent
+    recipe: 'cmd:dialogue-implement'
+    max_visits: 5
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - node_id: judge
+    kind: gate
+    recipe: 'cmd:dialogue-judge'
+    max_visits: 5
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }
+  - { node_id: needs-human, kind: hitl, recipe: none, max_visits: 1 }
+  - { node_id: failed, kind: observe, recipe: none, max_visits: 1 }
+edges:
+  # ① vN 전달(첫 회 = E1) · ③ 답 = vN+1 은 같은 간선 «deliver» — 판은 spec ledger(goal-elaborated · goal-refined)가 가른다.
+  - { from: author, on: outcome, map: { deliver: implement, needs-human: needs-human, failed: failed } }
+  # ② 발견/질문 «ask» → author · 구현을 마치면 judge 로.
+  - { from: implement, on: outcome, map: { done: judge, ask: author, needs-human: needs-human, failed: failed } }
+  # ④ judge 지적 «findings» 은 같은 대화의 발견으로 author 에.
+  - { from: judge, on: outcome, map: { done: done, findings: author, needs-human: needs-human, failed: failed } }

package/graphs/journey/units/author-dialogue/observe.ts

@@ -0,0 +1,96 @@
+import { readFileSync } from 'node:fs';
+
+/**
+ * author-dialogue 단위의 읽기 전용 관측(RFC-progressive-goal-elaboration §7).
+ * 기존 실행 경로(self-implement orchestrator)가 공급한 사건만 출구로 옮긴다 — 성공을 추정하지 않는다.
+ * 사건이 없으면 needs-human(다른 여정 단위와 같은 규칙: 빠진 관측은 미해결 증거다).
+ */
+export type DialogueNode = 'author' | 'implement' | 'judge';
+type Observation = { outcome?: unknown; data?: Record<string, unknown> };
+type DialogueContext = { observations?: Record<string, Observation> };
+/** 이 단위 안에서 앞서 돈 노드의 마지막 출력(graph-runner `outputs`) — 되돌이 판별·라운드 수에 쓴다. */
+type PriorOutputs = Record<string, unknown>;
+
+/**
+ * author 는 E1 의 세 사건 중 «있는 것»을 읽는다 — `runArrivalElaboration`(src/self-implement/goal-elaborate.ts)이
+ * 셋 중 하나만 낸다. skipped(공급자 없음·실패)는 카드 없이 오늘처럼 구현하므로 대화를 지나간다(deliver).
+ */
+const AUTHOR_EVENTS: ReadonlyArray<readonly [event: string, exit: string]> = [
+  ['goal-elaboration-needs-human', 'needs-human'],
+  ['goal-elaborated', 'deliver'],
+  ['goal-elaboration-skipped', 'deliver'],
+];
+/**
+ * author 되돌이(③ 답 = vN+1) — judge findings·implement ask 뒤 다시 들어오면 E3 `goal-refined`(GOAL-REFINE-FROM-FIRST-IMPL ·
+ * src/self-implement/goal-refine.ts `runFirstRoundRefine`)를 읽는다. refined(v2)·kept(v1 유지 ⊕ 사유) 둘 다 deliver —
+ * 방향·KPI 를 바꿔야 하는 경우는 goal-refine 이 v1 을 유지하고 사유(kept: fixed-layer-edit)를 남긴다.
+ */
+const REFINE_EVENT = 'goal-refined';
+/** implement · judge 값 공급자 — 사건 값 → 출구 표 · 사건이 없으면 통과(done). judge 는 라운드별 값(`data.rounds`)도 읽는다. */
+const VALUE_SOURCES: Record<Exclude<DialogueNode, 'author'>, { event: string; exits: Record<string, string> }> = {
+  implement: { event: 'implement', exits: { done: 'done', ask: 'ask', 'needs-human': 'needs-human', failed: 'failed' } },
+  judge: { event: 'judge', exits: { pass: 'done', findings: 'findings', 'needs-human': 'needs-human', failed: 'failed' } },
+};
+const NODES = new Set<DialogueNode>(['author', 'implement', 'judge']);
+
+function observedValue(observation: Observation | undefined): string {
+  const value = observation?.outcome ?? observation?.data?.outcome;
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function priorResult(outputs: PriorOutputs | undefined, node: string): Record<string, unknown> | undefined {
+  const output = outputs?.[node] as { result?: unknown } | undefined;
+  return output && typeof output.result === 'object' && output.result !== null ? output.result as Record<string, unknown> : undefined;
+}
+
+export function observeDialogueNode(node: DialogueNode, context: DialogueContext, outputs?: PriorOutputs): {
+  outcome: string;
+  result: { node: DialogueNode; event: string; observed: boolean; value?: string; reason?: string; round?: number };
+  evidence: { source: 'existing-harness-observation'; events: string[] };
+} {
+  const observations = context.observations ?? {};
+  if (node === 'author' && (outputs?.judge !== undefined || outputs?.implement !== undefined)) {
+    // ③ 되돌이 — 첫 왕복 뒤 다시 들어왔다. E3 goal-refined 가 없으면 미해결 증거(성공을 추정하지 않는다).
+    const observation = observations[REFINE_EVENT];
+    const evidence = { source: 'existing-harness-observation' as const, events: observation === undefined ? [] : [REFINE_EVENT] };
+    if (observation === undefined) return { outcome: 'needs-human', result: { node, event: REFINE_EVENT, observed: false, reason: `missing-observation:${REFINE_EVENT}` }, evidence };
+    const value = observedValue(observation);
+    return { outcome: 'deliver', result: { node, event: REFINE_EVENT, observed: true, ...(value ? { value } : {}) }, evidence };
+  }
+  if (node === 'author') {
+    const hit = AUTHOR_EVENTS.find(([event]) => observations[event] !== undefined);
+    const events = AUTHOR_EVENTS.map(([event]) => event).filter((event) => observations[event] !== undefined);
+    const evidence = { source: 'existing-harness-observation' as const, events };
+    if (!hit) return { outcome: 'needs-human', result: { node, event: 'goal-elaborated', observed: false, reason: 'missing-observation:goal-elaborated' }, evidence };
+    return { outcome: hit[1], result: { node, event: hit[0], observed: true, ...(observedValue(observations[hit[0]]) ? { value: observedValue(observations[hit[0]]) } : {}) }, evidence };
+  }
+  const { event, exits } = VALUE_SOURCES[node];
+  // judge 는 라운드마다 다른 값을 낸다 — `data.rounds[n-1]`(n = 이 단위에서 judge 를 몇 번째로 도는가).
+  const round = node === 'judge' ? Number(priorResult(outputs, 'judge')?.round ?? 0) + 1 : undefined;
+  const rounds = observations[event]?.data?.rounds;
+  const value = round !== undefined && Array.isArray(rounds)
+    ? (typeof rounds[round - 1] === 'string' ? (rounds[round - 1] as string).trim() : '')
+    : observedValue(observations[event]);
+  const evidence = { source: 'existing-harness-observation' as const, events: value ? [event] : [] };
+  // ⭐ 선언만인 간선(②③④)은 아직 관측 공급자가 없다(GOAL-REFINE-FROM-FIRST-IMPL) — 사건이 없으면 «통과»한다.
+  //   성공을 추정하는 것이 아니라 «이 왕복은 아직 실행되지 않는다»를 이유와 함께 적는다(observed:false).
+  //   그렇지 않으면 E1 이 성공해도 실제 여정이 여기서 needs-human 으로 멈춘다.
+  const at = round !== undefined ? { round } : {};
+  if (!value) return { outcome: 'done', result: { node, event, observed: false, reason: 'declared-only:pass-through', ...at }, evidence };
+  const outcome = exits[value];
+  if (!outcome) return { outcome: 'needs-human', result: { node, event, observed: true, value, reason: 'unknown-observation-value', ...at }, evidence };
+  return { outcome, result: { node, event, observed: true, value, ...at }, evidence };
+}
+
+if (import.meta.main) {
+  const node = process.argv[2] as DialogueNode;
+  try {
+    if (!NODES.has(node)) throw new Error(`unknown dialogue node: ${node}`);
+    const path = process.env.ELANOUS_GRAPH_CONTEXT;
+    if (!path) throw new Error('ELANOUS_GRAPH_CONTEXT is required');
+    const graphContext = JSON.parse(readFileSync(path, 'utf8')) as { input?: { context?: DialogueContext }; outputs?: PriorOutputs };
+    process.stdout.write(`${JSON.stringify(observeDialogueNode(node, graphContext.input?.context ?? {}, graphContext.outputs))}\n`);
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ outcome: 'failed', result: { node, observed: false, reason: error instanceof Error ? error.message : String(error) }, evidence: { source: 'existing-harness-observation', events: [] } })}\n`);
+  }
+}

package/graphs/journey/units/author-dialogue/recipes.yaml

@@ -0,0 +1,10 @@
+# 읽기 전용 관측 — 기존 실행 경로가 공급한 사건만 기록한다(성공을 추정하지 않는다).
+dialogue-author:
+  command: 'bun "$ELANOUS_GRAPH_DIR/observe.ts" author'
+  timeout_ms: 30000
+dialogue-implement:
+  command: 'bun "$ELANOUS_GRAPH_DIR/observe.ts" implement'
+  timeout_ms: 30000
+dialogue-judge:
+  command: 'bun "$ELANOUS_GRAPH_DIR/observe.ts" judge'
+  timeout_ms: 30000

package/graphs/operate-loop.yaml

@@ -12,7 +12,8 @@
 #      (0건이면 여전히 이름뿐이다 — 그것을 「결함」이 아니라 「아직」으로 읽어라)
 graph_id: operate-loop
 version: 1
-entry_node: operate-plan
+journey_stages: [entry, author, dispatch, run, land, recover, end]
+entry_node: intake
 terminal_nodes: [landed, operate-blocked, needs-human]
 runner_inputs: [goal, worktree, branch, review-intent, head-sha, base-branch, ask, context, prior]
 docs_only_gate_skip: false
@@ -140,7 +141,45 @@ nodes:
   - { node_id: landed, kind: gate, recipe: none, max_visits: 1 }
   - { node_id: needs-human, kind: gate, recipe: none, max_visits: 1 }
 
+  - { node_id: intake, kind: observe, recipe: harness-entrance, journey_stage: entry, max_visits: 1 }
+  - { node_id: queue, kind: gate, recipe: harness-queue, journey_stage: entry, max_visits: 1 }
+  - { node_id: launch-gate, kind: gate, recipe: pre-launch-gate, journey_stage: entry, max_visits: 1 }
+  - node_id: entry-unit
+    kind: subgraph
+    recipe: none
+    journey_stage: entry
+    max_visits: 1
+    call: entry@1
+    budget: { inner_steps: 4 }
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - { node_id: dispatch, kind: judge, recipe: harness-substrate-select, journey_stage: dispatch, max_visits: 2 }
+  - { node_id: pool-admit, kind: gate, recipe: pod-pool-admission, journey_stage: dispatch, max_visits: 4 }
+  - node_id: dispatch-pod-unit
+    kind: subgraph
+    recipe: none
+    journey_stage: dispatch
+    max_visits: 4
+    call: dispatch-pod@1
+    budget: { inner_steps: 4 }
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - { node_id: freeze-check, kind: gate, recipe: landing-freeze-admission, journey_stage: land, max_visits: 4 }
+  - { node_id: hold, kind: hitl, recipe: frozen-merge-queue, journey_stage: land, max_visits: 4 }
+  - { node_id: cleanup, kind: git, recipe: post-merge-cleanup, journey_stage: land, max_visits: 1 }
+  - { node_id: result-parse, kind: observe, recipe: pod-failure-reason, journey_stage: recover, max_visits: 4 }
+  - { node_id: salvage, kind: git, recipe: salvage-branch, journey_stage: recover, max_visits: 4 }
+  - { node_id: heal, kind: judge, recipe: heal-intake, journey_stage: recover, max_visits: 4 }
+  - { node_id: next-move, kind: judge, recipe: task-agent-judge, journey_stage: recover, max_visits: 4 }
+  - { node_id: ready, kind: gate, recipe: none, journey_stage: land, max_visits: 1 }
+  - { node_id: pr-head-checkout, kind: gate, recipe: none, journey_stage: land, max_visits: 1 }
+
 edges:
+  - { from: intake, on: outcome, map: { queued: queue, direct: launch-gate, ok: launch-gate, fail: needs-human } }
+  - { from: queue, on: outcome, map: { launched: launch-gate, waiting: needs-human, refused: needs-human, ok: launch-gate, fail: needs-human } }
+  - { from: launch-gate, on: outcome, map: { pass: entry-unit, refuse: needs-human, ok: entry-unit, fail: needs-human } }
+  - { from: entry-unit, on: outcome, map: { done: dispatch, rework: operate-plan, needs-human: needs-human, failed: needs-human } }
+  - { from: dispatch, on: outcome, map: { local: operate-plan, pod: pool-admit, fresh: operate-plan, pr-source: pool-admit, ok: operate-plan, fail: needs-human } }
+  - { from: pool-admit, on: outcome, map: { admitted: dispatch-pod-unit, refused: needs-human, ok: dispatch-pod-unit, fail: needs-human } }
+  - { from: dispatch-pod-unit, on: outcome, map: { done: operate-plan, rework: operate-plan, needs-human: needs-human, failed: result-parse } }
   - from: operate-plan
     to: operate-verify
 
@@ -181,11 +220,20 @@ edges:
       fail: operate-rework
 
   - from: open-pr
-    to: merge
+    to: freeze-check
+  - { from: freeze-check, on: outcome, map: { open: merge, frozen: hold, taken: needs-human, ok: merge, fail: needs-human } }
+  - { from: hold, to: freeze-check }
 
   - from: merge
     on: outcome
-    map: { merged: landed, land-refused: recover, ok: needs-human, fail: needs-human }
+    map: { merged: cleanup, land-refused: recover, draft: ready, head-branch: pr-head-checkout, not-ancestor: main-sync, review-missing: operate-review, other: next-move, ok: needs-human, fail: needs-human }
+  - { from: cleanup, to: landed }
+  - { from: result-parse, to: salvage }
+  - { from: salvage, to: heal }
+  - { from: heal, to: next-move }
+  - { from: ready, to: next-move }
+  - { from: pr-head-checkout, to: next-move }
+  - { from: next-move, on: outcome, map: { narrow-relaunch: dispatch, salvage-relaunch: dispatch, alternative: dispatch, wait-retry: dispatch, decision-card: needs-human, wait: needs-human, ok: needs-human, fail: needs-human } }
 
   - from: recover
     on: outcome

package/graphs/release/recipes.yaml

@@ -11,6 +11,9 @@ gate:
   command: 'bun scripts/release-loop/gate-node.ts --json'
   # 4h — the Pod gate took 2h02m on 09-30 (G1f ②) and the 0.2.5 loop was cut at exactly 2h with no verdict; K9 (≤15 min) is the real fix.
   timeout_ms: 14400000
+traffic-gate-passed:
+  command: 'bun scripts/release-loop/traffic-node.ts traffic-gate-passed'
+  timeout_ms: 30000
 gate-triage:
   command: 'bun scripts/release-loop/gate-triage-node.ts'
   timeout_ms: 60000
@@ -59,6 +62,9 @@ docs-land:
 verify:
   command: 'bun scripts/release-loop/verify-node.ts'
   timeout_ms: 1800000
+traffic-verify-complete:
+  command: 'bun scripts/release-loop/traffic-node.ts traffic-verify-complete'
+  timeout_ms: 30000
 vault-note:
   command: 'bun scripts/release-loop/vault-note-node.ts'
   timeout_ms: 60000

package/graphs/release/release-loop.yaml

@@ -19,6 +19,8 @@ nodes:
   - { node_id: export-check, kind: gate, recipe: 'cmd:export-check', max_visits: 1 }
   - { node_id: prefetch, kind: agent, recipe: 'cmd:docs', max_visits: 1 }
   - { node_id: gate, kind: gate, recipe: 'cmd:gate', max_visits: 1, notify: { on: [fail] } }
+  # Deterministic, best-effort traffic transition; it never changes the release verdict.
+  - { node_id: traffic-gate-passed, kind: gate, recipe: 'cmd:traffic-gate-passed', max_visits: 1 }
   # S1 shadow: classify and record only; all exits still terminate through the existing failed node.
   - { node_id: gate-triage, kind: judge, recipe: 'cmd:gate-triage', max_visits: 1 }
   - { node_id: mac-smoke, kind: gate, recipe: 'cmd:mac-smoke', max_visits: 1 }
@@ -29,12 +31,17 @@ nodes:
   - { node_id: docs, kind: agent, recipe: 'cmd:docs', max_visits: 1 }
   - { node_id: known-issues, kind: agent, recipe: 'cmd:known-issues', max_visits: 1 }
   - { node_id: notes-check, kind: gate, recipe: 'cmd:notes-check', max_visits: 1 }
+  # RELEASE-GRAPH-SELFHEAL: a failed notes check re-enters through the docs repair node before one recheck.
+  # Repair is observation-only: it introduces no approval, budget, or loop-cap policy of its own.
+  - { node_id: notes-repair, kind: agent, recipe: 'cmd:docs', max_visits: 1 }
+  - { node_id: notes-recheck, kind: gate, recipe: 'cmd:notes-check', max_visits: 1 }
   - { node_id: auto-approve, kind: gate, recipe: 'cmd:auto-approve', max_visits: 1 }
   - { node_id: approve-publish, kind: hitl, recipe: 'approval:publish', max_visits: 1 }
   - { node_id: publish, kind: git, recipe: 'cmd:publish-command', max_visits: 1, notify: { on: [ok, fail] } }
   - { node_id: npm-publish, kind: git, recipe: 'cmd:npm-publish', max_visits: 1 }
   - { node_id: docs-land, kind: git, recipe: 'cmd:docs-land', max_visits: 1 }
   - { node_id: verify, kind: gate, recipe: 'cmd:verify', max_visits: 1, notify: { on: [ok, fail] } }
+  - { node_id: traffic-verify-complete, kind: gate, recipe: 'cmd:traffic-verify-complete', max_visits: 1 }
   - { node_id: vault-note, kind: gate, recipe: 'cmd:vault-note', max_visits: 1 }
   - { node_id: release-story, kind: gate, recipe: 'cmd:release-story', max_visits: 1 }
   - { node_id: ops-upgrade, kind: agent, recipe: 'cmd:ops-upgrade', max_visits: 1 }
@@ -49,7 +56,9 @@ edges:
   - { from: export-check, on: outcome, map: { ok: prefetch, fail: failed, error: failed } }
   # Prefetch never gates: even a crashed prefetch node is a cache miss — the late nodes take their original paths.
   - { from: prefetch, on: outcome, map: { ok: gate, fail: gate, error: gate } }
-  - { from: gate, on: outcome, map: { ok: mac-smoke, fail: gate-triage, error: gate-triage } }
+  - { from: gate, on: outcome, map: { ok: traffic-gate-passed, fail: gate-triage, error: gate-triage } }
+  # Warning-only: the transition result stays truthful; every outcome continues to the next release node.
+  - { from: traffic-gate-passed, on: outcome, map: { ok: mac-smoke, fail: mac-smoke, error: mac-smoke } }
   - { from: gate-triage, on: outcome, map: { ok: failed, fail: failed, error: failed } }
   # Warning-only: a macOS failure or unmeasured run never blocks publishing — auto-approve shows it as a warning row.
   - { from: mac-smoke, on: outcome, map: { ok: pwa, fail: pwa, error: pwa } }
@@ -59,15 +68,19 @@ edges:
   - { from: tui, on: outcome, map: { ok: docs, fail: failed, error: failed } }
   - { from: docs, on: outcome, map: { ok: known-issues, fail: failed, error: failed } }
   - { from: known-issues, on: outcome, map: { ok: notes-check, fail: failed, error: failed } }
-  - { from: notes-check, on: outcome, map: { ok: auto-approve, fail: failed, error: failed } }
+  # RELEASE-GRAPH-SELFHEAL: fail/error re-enter notes-check through one repair; publish still requires a passing recheck.
+  - { from: notes-check, on: outcome, map: { ok: auto-approve, fail: notes-repair, error: notes-repair } }
+  - { from: notes-repair, on: outcome, map: { ok: notes-recheck, fail: failed, error: failed } }
+  - { from: notes-recheck, on: outcome, map: { ok: auto-approve, fail: failed, error: failed } }
   - { from: auto-approve, on: outcome, map: { ok: publish, fail: approve-publish, error: approve-publish } }
   - { from: approve-publish, on: outcome, map: { ok: publish, fail: failed } }
   - { from: publish, on: outcome, map: { ok: npm-publish, fail: failed, error: failed } }
-  - { from: npm-publish, on: outcome, map: { ok: docs-land, fail: docs-land, error: docs-land } }
+  - { from: npm-publish, on: outcome, map: { ok: docs-land, fail: failed, error: failed } }
   # RELEASE-DEVBUMP-ALWAYS: after a successful publish every fail/error routes through version-dev-bump —
   # a published release always hands main to its own next -dev, then still finishes failed.
   - { from: docs-land, on: outcome, map: { ok: verify, fail: version-dev-bump-after-failure, error: version-dev-bump-after-failure } }
-  - { from: verify, on: outcome, map: { ok: vault-note, fail: version-dev-bump-after-failure, error: version-dev-bump-after-failure } }
+  - { from: verify, on: outcome, map: { ok: traffic-verify-complete, fail: version-dev-bump-after-failure, error: version-dev-bump-after-failure } }
+  - { from: traffic-verify-complete, on: outcome, map: { ok: vault-note, fail: vault-note, error: vault-note } }
   # Warning-only: vault note and release story failures after publication never block operational upgrades.
   - { from: vault-note, on: outcome, map: { ok: release-story, fail: release-story, error: release-story } }
   - { from: release-story, on: outcome, map: { ok: ops-upgrade, fail: ops-upgrade, error: ops-upgrade } }

package/graphs/research-loop.yaml

@@ -9,7 +9,8 @@
 
 graph_id: research-loop
 version: 5
-entry_node: investigate
+journey_stages: [entry, author, dispatch, run, land, recover, end]
+entry_node: intake
 terminal_nodes: [landed, needs-human]
 runner_inputs: [goal, worktree, branch, review-intent, head-sha, base-branch, ask, context, prior]
 # ⛔ 키 이름은 파서(`src/self-implement/graph-yaml.ts:201`)가 아는 것뿐이다 — 다른 이름은 «조용히» 무시된다.
@@ -121,7 +122,122 @@ nodes:
   - { node_id: landed, kind: gate, recipe: none, max_visits: 1 }
   - { node_id: needs-human, kind: gate, recipe: none, max_visits: 1 }
 
+  # Entry and Pod dispatch reuse the existing ARG-UNIT-LIB units.
+  - node_id: intake
+    kind: observe
+    recipe: harness-entrance
+    journey_stage: entry
+    max_visits: 1
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [route, reason] }
+  - node_id: queue
+    kind: gate
+    recipe: harness-queue
+    journey_stage: entry
+    max_visits: 1
+    contract: { inputs: [goal], tools: read-only, outputs: [queue_status, card_id] }
+  - node_id: launch-gate
+    kind: gate
+    recipe: pre-launch-gate
+    journey_stage: entry
+    max_visits: 1
+    contract: { inputs: [goal], tools: read-only, outputs: [decision, reason] }
+  - node_id: entry-unit
+    kind: subgraph
+    recipe: none
+    journey_stage: entry
+    max_visits: 1
+    call: entry@1
+    budget: { inner_steps: 4 }
+    contract: { inputs: [ask, context, prior], tools: read-only, outputs: [result, evidence] }
+  - node_id: dispatch
+    kind: judge
+    recipe: harness-substrate-select
+    journey_stage: dispatch
+    max_visits: 2
+    contract: { inputs: [launch_decision], tools: read-only, outputs: [substrate] }
+  - node_id: pool-admit
+    kind: gate
+    recipe: pod-pool-admission
+    journey_stage: dispatch
+    max_visits: 4
+    contract: { inputs: [goal, substrate], tools: read-only, outputs: [admission, reason] }
+  - node_id: dispatch-pod-unit
+    kind: subgraph
+    recipe: none
+    journey_stage: dispatch
+    max_visits: 4
+    call: dispatch-pod@1
+    budget: { inner_steps: 4 }
+    contract: { inputs: [ask, context, prior], tools: worktree-write, outputs: [result, evidence] }
+  - node_id: freeze-check
+    kind: gate
+    recipe: landing-freeze-admission
+    journey_stage: land
+    max_visits: 4
+    contract: { inputs: [worktree, changed-files], tools: read-and-run-tests, outputs: [decision, reason] }
+  - node_id: hold
+    kind: hitl
+    recipe: frozen-merge-queue
+    journey_stage: land
+    max_visits: 4
+    contract: { inputs: [pr-number, freeze-state], tools: human-selection, outputs: [decision] }
+  - node_id: cleanup
+    kind: git
+    recipe: post-merge-cleanup
+    journey_stage: land
+    max_visits: 1
+    contract: { inputs: [pr-number, merge-sha, worktree], tools: git-write, outputs: [cleaned, worktree] }
+  - node_id: result-parse
+    kind: observe
+    recipe: pod-failure-reason
+    journey_stage: recover
+    max_visits: 4
+    contract: { inputs: [failure-log], tools: read-only, outputs: [failure-class, evidence] }
+  - node_id: salvage
+    kind: git
+    recipe: salvage-branch
+    journey_stage: recover
+    max_visits: 4
+    contract: { inputs: [worktree, branch], tools: git-write, outputs: [salvage-branch, ref] }
+  - node_id: heal
+    kind: judge
+    recipe: heal-intake
+    journey_stage: recover
+    max_visits: 4
+    contract: { inputs: [failure-class, evidence], tools: read-only, outputs: [repair-plan, reason] }
+  - node_id: next-move
+    kind: judge
+    recipe: task-agent-judge
+    journey_stage: recover
+    max_visits: 4
+    contract: { inputs: [repair-results, card-state], tools: read-only, outputs: [next-action, reason] }
+  - node_id: ready
+    kind: gate
+    recipe: none
+    journey_stage: land
+    max_visits: 1
+    contract: { inputs: [pr-number, head-sha], tools: read-only, outputs: [ready, reason] }
+  - node_id: pr-head-checkout
+    kind: gate
+    recipe: none
+    journey_stage: land
+    max_visits: 1
+    contract: { inputs: [pr-number, worktree], tools: git-write, outputs: [checked-out-head, worktree] }
+
 edges:
+  - { from: intake, on: outcome, map: { queued: queue, direct: launch-gate, ok: launch-gate, fail: needs-human } }
+  - { from: queue, on: outcome, map: { launched: launch-gate, waiting: needs-human, refused: needs-human, ok: launch-gate, fail: needs-human } }
+  - { from: launch-gate, on: outcome, map: { pass: entry-unit, refuse: needs-human, ok: entry-unit, fail: needs-human } }
+  - from: entry-unit
+    on: outcome
+    map: { done: dispatch, rework: investigate, needs-human: needs-human, failed: needs-human }
+  - from: dispatch
+    on: outcome
+    map: { local: investigate, pod: pool-admit, fresh: investigate, pr-source: pool-admit, ok: investigate, fail: needs-human }
+  - { from: pool-admit, on: outcome, map: { admitted: dispatch-pod-unit, refused: needs-human, ok: dispatch-pod-unit, fail: needs-human } }
+  - from: dispatch-pod-unit
+    on: outcome
+    map: { done: investigate, rework: investigate, needs-human: needs-human, failed: result-parse }
   # ⛔⭐ 유일하게 implement-loop 과 «다른» 자리 — gate 를 «건너뛸 수 있다».
   #   조건은 코드가 낸다: 변경 파일에 «코드»가 있나(routeGate). 못 세면 «돈다»(fail-safe).
   - from: investigate
@@ -161,11 +277,29 @@ edges:
     to: open-pr
 
   - from: open-pr
-    to: merge
+    to: freeze-check
+  - from: freeze-check
+    on: outcome
+    map: { open: merge, frozen: hold, taken: needs-human, ok: merge, fail: needs-human }
+  - from: hold
+    to: freeze-check
 
   - from: merge
     on: outcome
-    map: { merged: landed, land-refused: recover, ok: needs-human, fail: needs-human }
+    map: { merged: cleanup, land-refused: recover, draft: ready, head-branch: pr-head-checkout, not-ancestor: main-sync, review-missing: judge, other: next-move, ok: needs-human, fail: needs-human }
+  - from: cleanup
+    to: landed
+  - from: result-parse
+    to: salvage
+  - from: salvage
+    to: heal
+  - from: heal
+    to: next-move
+  - { from: ready, to: next-move }
+  - { from: pr-head-checkout, to: next-move }
+  - from: next-move
+    on: outcome
+    map: { narrow-relaunch: dispatch, salvage-relaunch: dispatch, alternative: dispatch, wait-retry: dispatch, decision-card: needs-human, wait: needs-human, ok: needs-human, fail: needs-human }
 
   # The train/TA owns retry effects; the unit only classifies the refusal.
   - from: recover

package/graphs/test-diet/test-diet.yaml

@@ -1,5 +1,8 @@
 # TD2 — daily test review (shadow): pick a cost-weighted slice from the cursor ledger, measure each file alone on a
 # remote host, judge mechanically, append one ledger line «#a~#b» and draft a card. It never deletes or moves a test.
+# pick weighs the gate's own failure history (preexisting · knownEnv · flaky · repeated introduced) on top of cost, so
+# the files most likely to fail come first; record turns each verdict into exactly one T1~T7 prescription card draft and
+# writes the slice's preexisting ⊕ knownEnv totals (with their delta) into the same ledger line. Deletion stays human.
 # Inputs: budgetSecs (default 1800) · remote (default node-b) · mirror (default ~/mirror/elanous-agent.git)
 graph_id: test-diet
 loop:

package/graphs/wizard/recipes.yaml

@@ -0,0 +1,44 @@
+# graphs/wizard/recipes.yaml — wizard-loop 그래프의 노드별 명령 카탈로그
+#
+# 로더(src/self-implement/graph-yaml.ts)는 recipes.yaml 을 «템플릿»이 아니라
+# 명령 카탈로그로 본다 — 그래프 러너(src/graph-runner/runner.ts)가 노드 id 로 찾아 실행한다.
+# 형식은 src/graph-wizard/steps.ts 의 recipesYamlFor 가 내는 것과 같다:
+#   cmd:<id>       → command: "<bin> graph step <step> --arg '<arg>'" · timeout_ms
+#   approval:<id>  → approval: "<사람에게 물을 한 줄>"
+# 커맨드 문자열은 따옴표로 감싼다 — 산문 안의 ':' 가 중첩 매핑으로 읽히지 않게.
+
+intake:
+  command: "eln graph step llm --arg '지시를 한 줄로: 무엇을 만들려는가 — 막연해도 된다'"
+  timeout_ms: 240000
+classify:
+  command: "eln graph step llm --arg '분류: 종류(harness|workflow) · 결과물 · 필요한 도구 · 위험도를 적어라'"
+  timeout_ms: 240000
+ground:
+  command: "eln graph step check --arg '저장소 근거: 이미 있는 부품·경로·시험을 실제로 읽어 적어라. 없으면 없다고 적어라'"
+  timeout_ms: 240000
+gap:
+  command: "eln graph step llm --arg '차이: refs 와 observed 를 견주어 지금 없는 것을 gap 으로 뽑아라. 비었으면 비었다고 적어라'"
+  timeout_ms: 240000
+approve:
+  approval: "분류·근거·gap 을 읽었나요? 이 계획으로 진행할까요 — 승인 또는 거부"
+acquire:
+  command: "eln graph step knowledge-rag --arg 'gap 을 메울 자료: 저장소·문서·설치된 팩에서 인용을 모아라'"
+  timeout_ms: 240000
+generate:
+  command: "eln graph step llm --arg 'gap 을 메우는 그래프 YAML 초안을 써라 — 노드·간선·종료 노드는 스키마 그대로'"
+  timeout_ms: 240000
+compose:
+  command: "eln graph step llm --arg '초안을 하나의 그래프로 합쳐라 — 노드 id 와 recipes 키를 맞추고 간선을 잇는다'"
+  timeout_ms: 240000
+verify:
+  command: "eln graph step check --arg '검증: 로더 불변식(노드 종류·간선 참조·to/map 배타·종료 done|failed)과 드라이런을 확인하라'"
+  timeout_ms: 240000
+store:
+  command: "eln graph step llm --arg '확정된 그래프를 저장 경로 graphs/<id>.yaml 에 적고 recipes 도 같은 디렉터리에 남겨라'"
+  timeout_ms: 240000
+run:
+  command: "eln graph step notify-me --arg '저장된 그래프를 실행하고 결과 상태와 지난 경로를 알려라'"
+  timeout_ms: 240000
+improve:
+  command: "eln graph step summarize --arg '개선: 이번 루프에서 무엇이 아쉬웠고 다음에 무엇을 바꿀지 한 줄씩'"
+  timeout_ms: 240000

package/graphs/wizard/wizard-loop.yaml

@@ -0,0 +1,44 @@
+graph_id: wizard-loop
+version: 1
+entry_node: intake
+terminal_nodes: [done, failed]
+metadata:
+  title: 마법사 루프 — 지시 하나를 근거 있는 산출물로 닫는다
+  description: >-
+    intake→classify→ground→gap→approve→acquire/generate→compose→verify→store→run→improve 순서를 도는
+    마법사 루프 선언. 불변식 W1~W4 는 docs/RFC-smart-wizard-to-loop-collective-2026-10-08.md §A2 를 따른다.
+    recipes.yaml 은 이 그래프의 명령 카탈로그다(로더는 recipes.yaml 을 템플릿으로 읽지 않는다).
+limits:
+  max_steps: 200
+  max_wall_ms: 5400000
+nodes:
+  # W1 승인 포인트: approve 는 kind=hitl · recipe=approval:* 만 쓴다(사람 승인 없이는 진행하지 않는다).
+  - { node_id: intake, kind: agent, recipe: 'cmd:intake', max_visits: 1 } # 지시 접수 | llm | 사용자 지시와 첨부 자료를 하나의 인테이크로 정리
+  - { node_id: classify, kind: agent, recipe: 'cmd:classify', max_visits: 1 } # 지시 분류 | llm | 지시 유형·필요 산출물·위험도를 분류
+  - { node_id: ground, kind: agent, recipe: 'cmd:ground', max_visits: 1 } # 근거 수집 | web-search | 지시가 전제하는 사실을 찾아 근거를 모은다
+  - { node_id: gap, kind: judge, recipe: 'cmd:gap', max_visits: 2 } # 공백 판정 | check | 근거가 지시를 받치는지 판정한다 (결과: ok/gap/fail)
+  - { node_id: approve, kind: hitl, recipe: 'approval:approve', max_visits: 1 } # 계획 승인 | approval | 사람이 계획과 근거를 보고 진행을 승인
+  - { node_id: acquire, kind: agent, recipe: 'cmd:acquire', max_visits: 2 } # 자료 보강 | web-search | gap 이 지목한 공백을 메울 자료를 더 가져온다
+  - { node_id: generate, kind: agent, recipe: 'cmd:generate', max_visits: 1 } # 초안 생성 | llm | 승인된 계획으로 초안을 만든다
+  - { node_id: compose, kind: agent, recipe: 'cmd:compose', max_visits: 3 } # 구성 조립 | llm | 초안과 근거를 하나의 산출물로 조립 (verify rework 의 back-edge 대상)
+  - { node_id: verify, kind: judge, recipe: 'cmd:verify', max_visits: 2 } # 검증 | check | 산출물이 지시·근거에 맞는지 검증 (결과: ok/rework/fail)
+  - { node_id: store, kind: agent, recipe: 'cmd:store', max_visits: 1 } # 저장 | knowledge-rag | 검증된 산출물을 지식에 적재
+  - { node_id: run, kind: agent, recipe: 'cmd:run', max_visits: 1 } # 실행 | llm | 산출물로 지시를 실제로 수행
+  - { node_id: improve, kind: agent, recipe: 'cmd:improve', max_visits: 1 } # 개선 | llm | 실행 결과를 다음 루프의 개선점으로 남긴다
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 } # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 } # 실패
+edges:
+  - { from: intake, on: outcome, map: { ok: classify, fail: failed } }
+  - { from: classify, on: outcome, map: { ok: ground, fail: failed } }
+  - { from: ground, on: outcome, map: { ok: gap, fail: failed } }
+  # W2 공백 분기: gap 은 outcome 키로 approve(충분) / acquire(보강) 로 갈라진다.
+  - { from: gap, on: outcome, map: { ok: approve, gap: acquire, fail: failed } }
+  - { from: acquire, on: outcome, map: { ok: approve, fail: failed } }
+  - { from: approve, on: outcome, map: { ok: generate, fail: failed } }
+  - { from: generate, on: outcome, map: { ok: compose, fail: failed } }
+  - { from: compose, on: outcome, map: { ok: verify, fail: failed } }
+  # W3 되돌림: verify 실패(rework)는 compose 로 돌아가고 compose.max_visits=3 ≥ 2.
+  - { from: verify, on: outcome, map: { ok: store, rework: compose, fail: failed } }
+  - { from: store, on: outcome, map: { ok: run, fail: failed } }
+  - { from: run, on: outcome, map: { ok: improve, fail: failed } }
+  - { from: improve, on: outcome, map: { ok: done, fail: failed } }

package/graphs/work/research-report.yaml

@@ -1,5 +1,7 @@
 graph_id: work-research-report-rehearsal
 version: 1
+# TASK-HAND-GRAPH-RUN — `tasks hand --completion research-report` 가 이 조합을 실제 graph run(runGraph)으로 발사한다.
+launcher: graph-run
 entry_node: make-doc
 terminal_nodes: [done, failed]
 nodes:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elanous",
   "mcpName": "io.github.ElanvitalAI/elanous",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "author": "Elanvital AI",