elanous 0.2.34 → 0.2.35

package/docs/goal-context/04-mock-scenarios.md

@@ -0,0 +1,100 @@
+# 재사용 검증 무대 카탈로그
+
+S: 골 저작기와 Pod 자식은 HQ의 private `seat-state` 파일을 읽지 못한다. C: 검증 메뉴가 개념만 제시하면 실제 수용선을 쓸 때 사건 무대와 실행 경계가 다시 발명된다. Q: 어떤 재사용 무대를 고르고 무엇을 채워야 하나? A: 아래 공통 템플릿과 MS-01~05를 저장소 정본으로 둔다. 각 무대는 특정 입력·환경에서 증명하는 범위만 보장하며, 빠진 명령이나 정리는 해당 골에서 채운다.
+
+이 카탈로그는 `docs/goal-context/03-verification-menu.md`의 검증 방법을 구체적인 무대와 연결한다. 초기 원본은 `~/elanous-hq/seat-state/OP/MOCK-SCENARIO-CATALOG.md`이며, 이 저장소 파일이 착지하면 저장소 쪽이 정본이다.
+
+## 표준 템플릿
+
+한 시나리오마다 다음 필드를 채운다. 자리표시자는 실행 전에 실제 값으로 바꾼다.
+
+```text
+### MS-<번호> <짧은 이름>
+- 증명하는 동작: <무엇이 일어나야 하나 — 한 문장>
+- 언제 쓰나: <운영에서 드물거나 기다려야 하는 사건 · 어떤 칸 꼴에>
+- 우주: test(--test) | Docker 격리(node-b 이미지 pin) | ux-sim | 임시 git 저장소 | 격리 HOME
+- 무대 세우기(명령 · 연산자 없는 줄 여러 개): ...
+- 실행(생산 진입점을 지나는 명령): ...
+- 판정(무엇을 보면 통과): rc · 출력 문구 · 원장 행 · 파일 해시 불변 …
+- 치우기: ...
+- 함정: <운영 우주 오염 · 비밀값 · push 금지 …>
+- 출처: <green-e4 파일 · 칸 · 자리 · 날짜>
+```
+
+원본 카탈로그에서 제공하지 않은 값은 `원본에 미기재`로 표시했다. 실행 계획은 이 빈칸을 해당 골의 다섯 줄 검증 계획으로 구체화한다.
+아래 명령은 재사용 계획의 템플릿이다. 골에서 실제 값을 채워 실행 결과를 남기기 전에는 동작 검증 증거로 인용하지 않는다.
+
+## 검증 무대
+
+### <a id="ms-01"></a> MS-01 시험 판 무대(체크리스트 fixture)
+
+- **증명하는 동작:** 칸·카드를 읽는 생산 CLI가 실제 체크리스트 행으로 동작한다.
+- **언제 쓰나:** test 우주 체크리스트가 비어 있어 운영 칸이 있어야 보이는 기능을 시험할 때.
+- **우주:** test (`--test`).
+- **무대 세우기:** `bun bin/elanous.mjs --test release checklist add <시험칸> "<제목>" --version 9.9.9 --owner <자리>`
+- **실행:** 대상 기능의 생산 CLI를 `--test`로 실행한다(예: `tasks work-order build`).
+- **판정:** 종료 코드 0과 목표가 요구한 정규화 필드를 확인한다. `unknownFields`를 다루는 목표일 때만 그 보존도 판정한다.
+- **치우기:** 원본 미기재. 시험 인스턴스를 재사용하지 않는지 계획에 적는다.
+- **함정:** 운영 원장을 복사하지 않는다. `config sync-test`를 쓸 때 비밀값 제거를 확인한다.
+- **출처:** `~/elanous-hq/seat-state/MK/green-e4/ENTRANCE-WORK-ORDER-BUILD.md`.
+
+### <a id="ms-02"></a> MS-02 실패 런 무대(release resume)
+
+- **증명하는 동작:** 실패한 발행/예행 런에서 resume이 실행 가능한 계획을 내고 저장된 런 원장은 불변이다.
+- **언제 쓰나:** 실제 발행 실패를 기다려야 하는 복구 경로를 시험할 때.
+- **우주:** test 및 push하지 않는 로컬 시험 가지.
+- **무대 세우기:** 저장소의 격리 임시 clone에서 시험 판 `9.9.9`를 만든다; `release/9.9.9` 로컬 가지는 `origin/main`에서 만든다; 저장 런 JSON은 gate 실패·attempt 0·저장 commit이 가지 조상인 상태로 둔다. 현재 작업 저장소에는 이 가지를 만들지 않는다.
+- **실행:** `bun bin/elanous.mjs --test release resume --dry-run <실패 런 경로>`
+- **판정:** 종료 코드 0, 계획 출력, 런 JSON 해시가 전후 동일, attempt 파일 없음.
+- **치우기:** 임시 시험 판·로컬 가지·런 JSON만 제거한다. 실제 발행 기록은 건드리지 않는다.
+- **함정:** 원본은 `--dry-run` 경계와 push 금지를 요구한다. 실패 상태를 운영에 만들지 않는다.
+- **출처:** `~/elanous-hq/seat-state/MK/green-e4/RELEASE-RECOVER-ONE-STEP.md`.
+
+### <a id="ms-03"></a> MS-03 격리 self-implement 한 바퀴
+
+- **증명하는 동작:** `runSelfImplement` 생산 진입점이 실제 기능을 부르고 원장에 남긴다.
+- **언제 쓰나:** 함수 단위 시험을 넘어 격리된 self-implement 한 실행에서 호출과 기록을 확인할 때.
+- **우주:** 격리 HOME 및 test.
+- **무대 세우기:** 원본에 미기재. 골에 격리 HOME·test 설정과 Pod가 열 수 있는 저장소 내 시험 경로를 명시한다. 이를 제시할 수 없으면 이 장면을 재사용하지 말고 새 무대를 제안한다.
+- **실행:** 원본에 미기재. `runSelfImplement`를 부르는 실제 생산 진입점과 한 바퀴 명령, 저장소 내 계약 시험 경로를 골에서 특정한다. HQ 증거 파일만으로 완료를 판정하지 않는다.
+- **판정:** 원본 표본은 round 0 호출 1/0 및 `K-TC-777` 산출 크기 0보다 큼을 기록했다. 새 골은 필요한 원장 행과 출력 조건을 구체화한다.
+- **치우기:** 원본에 미기재. 격리 HOME만 제거하고 운영 HOME은 사용하지 않는다.
+- **함정:** 함수 직접 호출이나 합성 결과만으로 생산 경로 연결을 주장하지 않는다.
+- **출처:** `~/elanous-hq/seat-state/TC/green-e4/TA-KNOWHOW-PACK.md`.
+
+### <a id="ms-04"></a> MS-04 실제 git ⊕ 생산 PrManager
+
+- **증명하는 동작:** 실제 git 상태에 의존하는 PR 재사용·회수 동작을 확인한다.
+- **언제 쓰나:** 가지·원격·커밋 상태가 결과를 가르는 생산 PR 관리 경로를 시험할 때.
+- **우주:** 임시 git 저장소에서 실제 git을 실행하고, GitHub API 경계는 CmdRunner stub으로 둔다.
+- **무대 세우기:** 임시 bare 저장소·seed·clone을 사용한다. 구체 명령은 원본에 미기재. 골에 Pod가 열 수 있는 저장소 내 시험 경로를 명시하고, 그런 경로가 없으면 새 무대를 제안한다.
+- **실행:** 생산 `PrManager` 경로를 부르는 시험 명령은 원본에 미기재. 골에서 명령과 계약 시험 파일을 특정한다.
+- **판정:** 원본 카탈로그는 실제 git 시험 8개 통과를 보고하지만, 원본 시험 경로가 저장소에서 확인되기 전에는 재사용 증거로 세지 않는다. 새 실행 결과에는 GitHub 경계가 stub임을 명시한다.
+- **치우기:** 임시 저장소를 제거한다.
+- **함정:** 운영 GitHub를 호출하지 않는다.
+- **출처:** `~/elanous-hq/seat-state/OPC/green-e4/PR-SAME-CELL-REUSE.md`.
+
+### <a id="ms-05"></a> MS-05 생산 호출부 확인(배선)
+
+- **증명하는 동작:** 착지한 함수가 시험 코드 밖의 생산 경로에서 호출된다.
+- **언제 쓰나:** helper·패키지·생산 호출부 연결을 수용선으로 삼을 때.
+- **우주:** 검증 대상 PR 커밋(`HEAD`)의 생산 소스 검사. 런타임 동작 자체는 별도의 해당 우주에서 검증한다.
+- **무대 세우기:** 대상 함수 이름과 production source 범위를 정한다.
+- **실행:** PR 검증 대상 커밋을 checkout한 저장소 루트에서 골에 정한 생산 소스 범위로 실행한다. 예: `git grep -n -F '<함수이름>(' HEAD -- <생산-소스-경로>`
+- **판정:** 검색은 후보를 찾는 단계다. 생산 소스의 파일·행을 열어 함수 선언·주석이 아닌 실제 호출 문장임을 확인하고 근거로 남긴다. 이 grep의 0건만으로 미배선을 판정하지 않는다. 별칭·재수출·줄바꿈 호출을 포함해 심볼 참조나 AST/수동 검색으로 범위를 확인한 뒤에도 호출부가 없을 때 미배선으로 기록한다.
+- **치우기:** 파일 변경 없음.
+- **함정:** `HEAD`가 검증할 PR 커밋인지, 검색 경로가 그 기능의 전체 생산 소스 범위인지 먼저 확인한다. 테스트만 제외하는 등 경로 필터는 골에 적는다. 별칭·재수출·줄바꿈 호출은 단순 grep이 놓칠 수 있으므로 결과 0건을 완전성으로 보지 않는다. 소스 확인은 호출부 존재만 증명하고 런타임 실행·결과를 증명하지 않으므로 해당 시험도 추가로 고른다.
+- **출처:** `~/elanous-hq/seat-state/MK/green-e4/ALREADY-BUILT-HINT.md`; `~/elanous-hq/seat-state/TC/green-e4/REVIEW-FINDING-PATH-HEAD-CHECK.md`; `~/elanous-hq/seat-state/TC/green-e4/CLAUDE-FAILOVER.md`. E4 과업에서 미측정·미완료면 별도 E4 절차에 따라 FU 제목 파일을 만든다. 이는 MS-05의 pass 판정이 아니다.
+
+## <a id="catalog-gaps"></a> 현재 카탈로그 빈칸
+
+기존 MS가 방법의 증거 경계와 맞지 않으면 억지로 연결하지 않고 새 무대 제안으로 잇는다. 이 절은 실행 증거가 아니라 빈칸 표시다.
+
+| 방법 | 아직 없는 표준 무대 |
+|---|---|
+| ux-sim 시뮬레이션 | 실제 함수·렌더 경계를 재사용 입력으로 실행하는 구체 시나리오 |
+| <a id="cli-sim-run-gap"></a>CLI `sim run` mock 시나리오 | 명시한 mock 입력을 허용된 실제 경로에 통과시켜 기대 결과를 판정하는 별도 CLI 무대 |
+| Docker 격리 | Pod 실패 봉투를 고정된 node-b 이미지와 checkout에서 재현 |
+| 열차 사이드 gate | 같은 PR head의 통합·원격 gate 결과를 확인하는 대기열/receipt 장면 |
+| 운영 실물 | 운영 데이터·실제 사건을 입력으로 하는 대상별 기록; 공통 fixture는 만들지 않음 |
+| 로그 관측 | 지정 인스턴스에서 이벤트를 조회하고 실제 로그 필드·시간 창·상관 키를 확인하는 장면 |

package/docs/goal-context/README.md

@@ -74,8 +74,12 @@ RESULT: 51 pass, 0 fail, 390 expect() calls; Ran 51 tests across 2 files.
 | 파일 | 무엇 | 원본(전문) |
 |---|---|---|
 | [`01-goal-authoring-checks.md`](01-goal-authoring-checks.md) | 골을 쓰기 «전»에 답하는 여섯 | [`CONCEPT-self-implement-closed-loop-map`](../CONCEPT-self-implement-closed-loop-map-2026-08-08.md) §8 |
+| [`03-verification-menu.md`](03-verification-menu.md) | 수용선의 주장에 맞춰 검증 방법을 고르는 안내 메뉴 | 해당 방법의 정본 매뉴얼 링크는 메뉴 안에 둔다 |
+| [`04-mock-scenarios.md`](04-mock-scenarios.md) | 표준 검증 무대 템플릿과 MS-01~05 재사용 예시 | initial source: `~/elanous-hq/seat-state/OP/MOCK-SCENARIO-CATALOG.md` |
 | [`refactoring.md`](../refactoring.md) | 리팩터링·seam·큰 파일 쪼개기 골은 냄새 → seam → 패턴 순서를 따르고, 이론상 깔끔함만으로 패턴을 도입하지 않는다 | [`refactoring.md`](../refactoring.md) |
 
+골의 수용선을 쓸 때는 [`03-verification-menu.md`](03-verification-menu.md)에서 주장에 맞는 검증 방법을 고른다. 이는 안내이며 골 발사를 막는 관문이 아니다.
+
 ## Cross-ref
 [[CONCEPT-self-implement-closed-loop-map-2026-08-08]](폐루프 전도 · §7a 가 이 두 계층의 근거) ·
 [[MANUAL-goal-authoring-method-2026-08-03]](저작 «절차» canonical) · **PR #5730**

package/graphs/catalog/catalog.yaml

@@ -21,7 +21,7 @@ catalog_id: elanous-node-catalog
 version: 1
 
 kinds:
-  existing: [agent, gate, git, judge, observe, hitl, prompt, subgraph]
+  existing: [agent, gate, git, judge, observe, hitl, prompt, subgraph, classify]
   proposed: {}
 
 roles:

package/graphs/default-loop.yaml

@@ -12,7 +12,8 @@
 # ═══════════════════════════════════════════════════════════════════════════════
 graph_id: default-loop
 version: 3
-entry_node: author
+journey_stages: [entry, author, dispatch, run, land, recover, end]
+entry_node: intake
 terminal_nodes: [landed, stopped]
 runner_inputs: [ask_text, worktree, branch, ask, context, prior]
 
@@ -198,7 +199,45 @@ nodes:
       tools: gh-pr-create               # 중단 산출물을 draft PR 로 «보존»한다
       outputs: [draft_pr, reason]
 
+  # Common journey units sit beside the default loop's existing author/build/recovery nodes.
+  - { 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: 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: stopped } }
+  - { from: queue, on: outcome, map: { launched: launch-gate, waiting: stopped, refused: stopped, ok: launch-gate, fail: stopped } }
+  - { from: launch-gate, on: outcome, map: { pass: entry-unit, refuse: stopped, ok: entry-unit, fail: stopped } }
+  - { from: entry-unit, on: outcome, map: { done: dispatch, rework: author, needs-human: stopped, failed: stopped } }
+  - { from: dispatch, on: outcome, map: { local: author, pod: pool-admit, fresh: author, pr-source: pool-admit, ok: author, fail: stopped } }
+  - { from: pool-admit, on: outcome, map: { admitted: dispatch-pod-unit, refused: stopped, ok: dispatch-pod-unit, fail: stopped } }
+  - { from: dispatch-pod-unit, on: outcome, map: { done: author, rework: author, needs-human: stopped, failed: result-parse } }
   - from: author
     on: outcome
     map:
@@ -304,14 +343,19 @@ edges:
   - from: open-pr
     on: outcome
     map:
-      opened: merge
+      opened: freeze-check
       declined: stopped
 
   - from: merge
     on: outcome
     map:
-      merged: landed
+      merged: cleanup
       land-refused: recover
+      draft: ready
+      head-branch: pr-head-checkout
+      not-ancestor: main-sync
+      review-missing: review
+      other: next-move
       ok: stopped
       blocked: stopped
       fail: stopped
@@ -319,3 +363,13 @@ edges:
   - from: recover
     on: outcome
     map: { done: stopped, rework: stopped, needs-human: stopped, failed: stopped }
+
+  - { from: freeze-check, on: outcome, map: { open: merge, frozen: hold, taken: stopped, ok: merge, fail: stopped } }
+  - { from: hold, to: freeze-check }
+  - { from: cleanup, to: landed }
+  - { from: result-parse, to: salvage }
+  - { from: salvage, to: heal }
+  - { from: heal, on: pod_result, map: { failed: 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: stopped, wait: stopped, ok: stopped, fail: stopped } }

package/graphs/document-loop.yaml

@@ -1,6 +1,7 @@
 graph_id: document-loop
 version: 1
-entry_node: document-draft
+journey_stages: [entry, author, dispatch, run, land, recover, end]
+entry_node: intake
 terminal_nodes: [landed, document-blocked, needs-human]
 runner_inputs: [goal, worktree, branch, review-intent, head-sha, base-branch, ask, context, prior]
 docs_only_gate_skip: true
@@ -117,7 +118,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: document-draft, needs-human: needs-human, failed: needs-human } }
+  - { from: dispatch, on: outcome, map: { local: document-draft, pod: pool-admit, fresh: document-draft, pr-source: pool-admit, ok: document-draft, 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: document-draft, rework: document-draft, needs-human: needs-human, failed: result-parse } }
   - from: document-draft
     on: changed-files
     map:
@@ -156,11 +195,20 @@ edges:
       fail: document-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: document-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/implement-loop.yaml

@@ -46,7 +46,7 @@ version: 1
 #   ⛔ 여정 노드(intake … stopped)의 id 는 원장·라이브 그래프 화면의 조인 키다 — 바꾸지 마라.
 #   🔀 분기는 «데이터»다(`on:` 상태 키 ⊕ `map:` 값→노드) — 기본 = 풀세트, 환경(substrate·freeze·queue)이 일부를 건너뛴다.
 entry_node: intake
-terminal_nodes: [cleanup, stopped]
+terminal_nodes: [cleanup, stopped, needs-human, decision-card]
 
 # Runner-provided inputs are declared here so contract-flow can distinguish them from undeclared gaps.
 runner_inputs: [ask_text, goal, worktree, branch, review-intent, head-sha, base-branch]
@@ -419,6 +419,46 @@ nodes:
       tools: none
       outputs: []
 
+  # GRAPH-AUTHOR-FAIL-EDGE (0.2.35 첫 조각 · 선언 ⊕ 관측 · 동작 무변경):
+  #   author 의 결과가 «길»이 된다 — 코드에 이미 있던 자동 재저작 한 번(ask-launch-flow.ts retryableNoTargetPaths)과
+  #   NOT-GROUNDED 범위 카드 거절(launch-preflight.ts)을 그래프가 이름으로 안다. 관측 = graph-front-nodes.ts observeFrontNodeExit.
+  - node_id: re-ground
+    group: author
+    journey_stage: author
+    kind: judge
+    recipe: ask-auto-reauthor          # ask-launch-flow.ts — 대상 경로 후보 검색 → 한 번 더 저작
+    max_visits: 1                      # ⛔ 두 번째 not-grounded 는 여기로 «안» 온다 — needs-human
+    terminal_stages: []
+    contract:
+      inputs: [ask_text, blockers]
+      tools: read-only
+      outputs: [target_path_candidates]
+
+  - node_id: needs-human
+    group: end
+    journey_stage: end
+    kind: hitl
+    recipe: launch-preflight-blocked   # ask-launch-flow.ts resolveBlockedInteractively — 근거 카드(막힘 이름·사유) 동반
+    max_visits: 1
+    terminal_stages: []
+    contract:
+      inputs: [blockers]
+      tools: none
+      outputs: [evidence_card]
+
+  # next-move 의 wait 가 «조용히» stopped 로 가지 않게 — task-agent 의 결정 카드 경로(judge.ts 'decision-card')로 모은다.
+  - node_id: decision-card
+    group: recover
+    journey_stage: recover
+    kind: hitl
+    recipe: task-agent-decision-card   # src/task-agent/judge.ts move 'decision-card' → 결정 카드 발신
+    max_visits: 1
+    terminal_stages: []
+    contract:
+      inputs: [next_action]
+      tools: none
+      outputs: [decision_card]
+
   # LAND-REFUSAL-EDGES: destinations only; recovery execution is a later slice.
   - node_id: ready
     group: land
@@ -478,8 +518,17 @@ edges:
       fresh: author
       pr-source: pool-admit          # 같은 PR 수리: author·plan·decompose를 건너뛰고 Pod rework
 
+  # GRAPH-AUTHOR-FAIL-EDGE — 결과 값은 observeFrontNodeExit 가 그 자리(ask-launch-flow.ts)에서 낸다.
   - from: author
-    to: plan
+    on: outcome
+    map:
+      ok: plan
+      re-authored: plan                # 자동 재저작 뒤 발사 가능
+      not-grounded: re-ground          # 대상 경로 0 · NOT-GROUNDED 범위 카드 — 두 번째면 re-ground 예산(1) 소진 → needs-human
+      fail: needs-human                # 저작기가 던졌다
+
+  - from: re-ground
+    to: author
 
   - from: plan
     to: decompose
@@ -536,8 +585,8 @@ edges:
       salvage-relaunch: dispatch
       alternative: dispatch
       wait-retry: dispatch
-      decision-card: stopped
-      wait: stopped
+      decision-card: decision-card
+      wait: decision-card              # GRAPH-AUTHOR-FAIL-EDGE ③ — 조용한 stopped 0
 
   - from: implement
     to: gate

package/graphs/journey/ta-journey.yaml

@@ -18,6 +18,15 @@ nodes:
     max_visits: 1
     budget: { inner_steps: 10 }
     contract: { inputs: [ask, context, prior], tools: harness-say, outputs: [result, evidence] }
+  # 저작 ↔ 구현 대화 고리(RFC-progressive-goal-elaboration §7) — 첫 왕복 = E1 착수 구체화(goal-elaborated) ·
+  # refine 되돌이 = E3 첫 라운드 → author(goal-refined · 골 v2 · 런당 1회) — 한 번 되돌아도 author·implement·judge ×2 + done = 7 걸음 ≤ inner_steps.
+  - node_id: author-dialogue
+    kind: subgraph
+    recipe: none
+    call: author-dialogue@1
+    max_visits: 1
+    budget: { inner_steps: 20 }
+    contract: { inputs: [ask, context, prior], tools: harness-say, outputs: [result, evidence] }
   - node_id: dispatch-pod
     kind: subgraph
     recipe: none
@@ -73,7 +82,8 @@ nodes:
   - { node_id: rework, kind: gate, recipe: none, max_visits: 1 }
 edges:
   - { from: entry, on: outcome, map: { done: author, rework: rework, needs-human: needs-human, failed: failed } }
-  - { from: author, on: outcome, map: { done: dispatch-pod, rework: rework, needs-human: needs-human, failed: failed } }
+  - { from: author, on: outcome, map: { done: author-dialogue, rework: rework, needs-human: needs-human, failed: failed } }
+  - { from: author-dialogue, on: outcome, map: { done: dispatch-pod, needs-human: needs-human, failed: failed } }
   - { from: dispatch-pod, on: outcome, map: { done: pr, rework: rework, needs-human: needs-human, failed: failed } }
   - { from: pr, on: outcome, map: { done: harvest, rework: rework, needs-human: needs-human, failed: failed } }
   - { from: harvest, on: outcome, map: { done: land, rework: rework, needs-human: needs-human, failed: failed } }

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