elanous 0.2.34 → 0.2.36

package/src/self-dev/graph-front-nodes.ts

@@ -1,6 +1,10 @@
 import { debug } from '../debug/log.js';
+import type { GoalType } from '../self-implement/goal-author.js';
 import { frontObservationTemplate, visitBudgetOfVisits, type VisitBudgetReading } from '../self-implement/graph-authority.js';
 import { GRAPH_TEMPLATES_SOURCE, graphIdentityOf, pipelineNodeEntryPayload, type GraphTemplate } from '../self-implement/graph-templates.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
+import { journeyJoinFields } from './graph-journey-nodes.js';
+import { journeySpec, readJourneyEdge, recordJourneyEdge, type JourneyRoute } from './graph-journey-route.js';
 
 /** ⭐ RFC §5 «5단계» — 전반부(저작·플랜·분해) 노드를 그래프 관측에 «잇는다».
  *
@@ -51,6 +55,25 @@ export function resetFrontVisitCountsForTesting(now?: () => number): void {
   lastFrontVisitPruneMs = Number.NEGATIVE_INFINITY;
 }
 
+/** Record the actual front-half execution boundary, without controlling the stage. */
+export async function observeFrontNodeUnit<T>(node: FrontNodeId, runId: string | undefined, goalType: GoalType | undefined, execute: () => Promise<T>): Promise<T> {
+  const emit = (phase: 'enter' | 'exit'): void => {
+    if (!runId) return;
+    try {
+      const template = frontObservationTemplate(goalType);
+      const contractId = template.nodes.find((item) => item.nodeId === node)?.recipe ?? null;
+      const data = { graphId: template.graphId, nodeId: node, unit: node, contractId, phase };
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId, event: 'graph.unit', data }, runLedgerDir()); }
+      catch { /* ledger failure cannot change execution */ }
+      try { debug.log('graph.unit', phase, { ...data, runId }); }
+      catch { /* debug failure cannot change execution */ }
+    } catch { /* template failure cannot change execution */ }
+  };
+  emit('enter');
+  try { return await execute(); }
+  finally { emit('exit'); }
+}
+
 function pruneIdleFrontVisitRuns(nowMs: number): void {
   if (nowMs - lastFrontVisitPruneMs < FRONT_VISIT_PRUNE_INTERVAL_MS) return;
   lastFrontVisitPruneMs = nowMs;
@@ -120,3 +143,92 @@ export function observeFrontNodeEntry(node: FrontNodeId, data: {
     });
   } catch { /* 판독 실패는 fail-soft — 예산은 관측이고 저작을 막지 않는다 */ }
 }
+
+/** GRAPH-AUTHOR-FAIL-EDGE — author 결과가 고르는 «앞단 결과 노드». ⛔ 런타임 값 — YAML 이 더한 노드를 시험이 센다. */
+export const AUTHOR_OUTCOME_NODE_IDS = ['re-ground', 'needs-human'] as const;
+
+/** author 노드의 결과 라벨 — implement-loop.yaml `from: author · on: outcome` 의 map 키와 «같은» 닫힌 집합. */
+export const AUTHOR_EXIT_OUTCOMES = ['ok', 're-authored', 'not-grounded', 'fail'] as const;
+export type AuthorExitOutcome = typeof AUTHOR_EXIT_OUTCOMES[number];
+
+export type FrontNodeExit =
+  | { readonly node: 'author'; readonly outcome: AuthorExitOutcome }
+  | { readonly node: 're-ground'; readonly outcome: 'retry' };
+
+export interface FrontNodeExitData {
+  /** 1 = 첫 저작 · 2 = 자동 재저작(re-ground 를 한 번 지난 뒤). */
+  readonly attempt: number;
+  /** 코드가 «실제로» 간 다음 노드 — 그래프 답과 다르면 graph-edge-taken 이 honored:false 로 남긴다. 없으면 그래프 답. */
+  readonly taken?: string;
+  readonly reason?: string;
+  readonly runId?: string;
+  readonly goalId?: string;
+  readonly goalType?: string;
+  readonly goalFile?: string;
+  /** 근거 카드 — needs-human 으로 갈 때 사람이 «무엇 때문에»를 다시 캐지 않게 막힘을 그대로 싣는다. */
+  readonly blockers?: readonly { readonly kind: string; readonly name: string; readonly detail?: string }[];
+}
+
+const EVIDENCE_DETAIL_CHARS = 400;
+
+/** 그래프가 고른 다음 노드에 «방문 예산»을 겹친다 — re-ground(max_visits 1)를 이미 지났으면 같은 결과의
+ *  두 번째는 re-ground 가 아니라 author 의 `fail` 출구(needs-human)로 간다. ⛔ 노드 이름·예산은 선언에서 읽는다. */
+function withVisitBudget(route: JourneyRoute, exit: FrontNodeExit, attempt: number): { readonly to: string | null; readonly budgetReason?: string } {
+  // ⛔ 예산을 겹치는 대상은 re-ground 뿐이다 — attempt-1 은 «re-ground 를 지난 횟수»이지 다른 노드의 방문 수가 아니다.
+  if (exit.node !== 'author' || route.to !== 're-ground') return { to: route.to };
+  const target = journeySpec({}).spec?.nodes.find((node) => node.nodeId === route.to);
+  const priorVisits = Math.max(0, attempt - 1);
+  if (target === undefined || priorVisits < target.maxVisits) return { to: route.to };
+  const exhausted = readJourneyEdge('author', 'fail');
+  return { to: exhausted.to, budgetReason: `${route.to}-visit-budget-exhausted (max_visits ${target.maxVisits})` };
+}
+
+/** ⭐ GRAPH-AUTHOR-FAIL-EDGE ① — 앞 노드의 «나감»을 결과와 함께 남긴다(진입만 있던 자리).
+ *  호출부(실행 경로): src/self-dev/ask-launch-flow.ts — 저작 끝(author ok · not-grounded · re-authored) ·
+ *    저작기 throw(author fail) · 자동 재저작 시작(re-ground retry).
+ *  🔎 관측: `self-implement` / `front-node-exit` ⊕ 같은 자리의 `graph-edge-taken`(from author|re-ground).
+ *  ⛔ 관측이지 제어가 아니다 — 다음 걸음은 여전히 코드가 정하고, 그래프 답과 다르면 honored:false 로 남는다.
+ *  ⛔ fail-soft — 관측 실패가 저작을 죽이지 않는다. */
+export function observeFrontNodeExit(exit: FrontNodeExit, data: FrontNodeExitData): JourneyRoute | null {
+  let recorded: JourneyRoute | null = null;
+  try {
+    const route = readJourneyEdge(exit.node, exit.outcome);
+    const budget = withVisitBudget(route, exit, data.attempt);
+    const graphRoute: JourneyRoute = { ...route, to: budget.to };
+    const taken = data.taken ?? budget.to ?? exit.outcome;
+    const reason = [budget.budgetReason, data.reason].filter((part): part is string => part !== undefined).join(' · ');
+    recordJourneyEdge(graphRoute, taken, reason.length > 0 ? reason : undefined);
+    recorded = graphRoute;
+    const payload = {
+      graphId: 'self-implement',
+      node: exit.node,
+      outcome: exit.outcome,
+      attempt: data.attempt,
+      to: budget.to,
+      taken,
+      honored: budget.to === null || budget.to === taken,
+      ...(reason.length > 0 ? { reason } : {}),
+      ...(data.runId === undefined ? {} : { runId: data.runId }),
+      ...(data.goalId === undefined ? {} : { goalId: data.goalId }),
+      ...(data.goalType === undefined ? {} : { goalType: data.goalType }),
+      ...(data.goalFile === undefined ? {} : { goalFile: data.goalFile }),
+      ...(data.blockers === undefined || data.blockers.length === 0 ? {} : {
+        evidenceCard: data.blockers.map((blocker) => ({
+          kind: blocker.kind, name: blocker.name,
+          ...(blocker.detail === undefined ? {} : { detail: blocker.detail.slice(0, EVIDENCE_DETAIL_CHARS) }),
+        })),
+      }),
+      phase: 'front',
+      graphTemplatesSource: GRAPH_TEMPLATES_SOURCE,
+      ...journeyJoinFields(),
+    };
+    try { debug.log('self-implement', 'front-node-exit', payload); }
+    catch { /* debug failure cannot change authoring */ }
+    // Pod 의 logs.db 는 Job 과 사라진다 — 원장에도 남겨 호스트가 NOT-GROUNDED 의 길을 사후에 읽게 한다.
+    if (data.runId !== undefined) {
+      try { appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: data.runId, event: 'front-node-exit', data: payload }, runLedgerDir()); }
+      catch { /* ledger failure cannot change authoring */ }
+    }
+  } catch { /* 관측은 fail-soft — 저작을 죽이지 않는다 */ }
+  return recorded;
+}

package/src/self-dev/graph-journey-nodes.ts

@@ -39,8 +39,10 @@ export const JOURNEY_NODE_IDS = [
   'salvage',
   'heal',
   'next-move',
+  'decision-card',
   'ready',
   'pr-head-checkout',
+  'recover',          // LAND-REFUSAL-EDGES — 착지 거부 결속 간선의 목적지(recover@1 subgraph)
   'stopped',
 ] as const;
 export type JourneyNodeId = typeof JOURNEY_NODE_IDS[number];

package/src/self-dev/graph-journey-route.ts

@@ -117,8 +117,16 @@ export function readJourneyEdge(
   return route;
 }
 
+/** 간선 행에 덧붙이는 조인·근거 칸.
+ *  `moveId` 는 next-move 결정 순간 한 번 만든 값(HARNESS-FULL-GRAPH-NEXTMOVE · 여기서 만들지 않는다).
+ *  그 밖의 칸은 그 간선에 결속할 근거(예: 착지 거부 원문·cardId · LAND-REFUSAL-EDGES) — 간선 칸(from·to·taken…)을 덮지 못한다. */
+export interface JourneyEdgeFields {
+  readonly moveId?: string;
+  readonly [key: string]: unknown;
+}
+
 /** 실제로 탄 간선을 남긴다 — `taken` 은 실제 다음 노드(그래프 답과 다르면 `honored: false` · 그 이유를 `reason` 에). */
-export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string): void {
+export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: string, data: JourneyEdgeFields = {}): void {
   try {
     if (route.ambiguousConditions?.length) debug.log('self-implement', 'edge-ambiguous', {
       graphId: 'self-implement', from: route.from, conditions: route.ambiguousConditions,
@@ -132,8 +140,10 @@ export function recordJourneyEdge(route: JourneyRoute, taken: string, reason?: s
       graphId: 'self-implement', node: skipped.node, reason: 'condition', condition: skipped.condition,
       ...journeyJoinFields(),
     });
+    // Evidence never overrides an edge field: the later spread wins, and `reason`/join keys are reserved.
+    const { reason: _reservedReason, journeyKey: _reservedJourney, queueLaunchId: _reservedLaunch, ...evidence } = data ?? {};
     debug.log('self-implement', 'graph-edge-taken', {
-      graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
+      ...evidence, graphId: 'self-implement', ...route, taken, honored: route.to === null || route.to === taken,
       ...(reason === undefined ? {} : { reason }), ...journeyJoinFields(),
     });
   } catch { /* 관측은 fail-soft */ }

package/src/self-dev/harness-run-cli.ts

@@ -1,28 +1,16 @@
 import { buildHarnessRunDevSpec, runDevPipeline, type DevHarnessDispatchArgs, type DevPipelineDeps } from './dev-pipeline.js';
 import type { SurfaceUxSource } from '../agent/surface-ux/build.js';
 import { debug } from '../debug/log.js';
-import { CLI_HARNESS_RUN_ENTRANCE, describeEntranceCommand, retiredEntranceNotice } from './entrance-registry.js';
+import { CLI_HARNESS_RUN_ENTRANCE, retiredEntranceNotice } from './entrance-registry.js';
+import { HARNESS_RUN_REPLACEMENT } from './cli-help-text.js';
+export { HARNESS_RUN_REPLACEMENT, HARNESS_RUN_DEPRECATION_HELP } from './cli-help-text.js';
 
 /** `elanous logs --category`로 레거시 입구의 제거 안전시점을 조회하는 브레드크럼. */
 export const HARNESS_RUN_DEPRECATION_LOG_CATEGORY = 'harness-cli.deprecated';
-export const HARNESS_RUN_REPLACEMENT = 'elanous harness say <objective>';
 /** 실행 «중»에 사람에게 내는 한 줄. ⛔ `--help` 용은 아래 HARNESS_RUN_DEPRECATION_HELP 다 —
  *  그쪽은 레지스트리가 은퇴 표시와 «갈 곳»을 이미 붙이므로 여기서 그것을 되풀이하지 않는다. */
 export const HARNESS_RUN_DEPRECATION_NOTICE = `ℹ️  \`elanous harness run\`은 deprecated 입구입니다 — \`${HARNESS_RUN_REPLACEMENT}\`로 이행하세요.`;
 
-/** `--help` 머리에 붙는 은퇴 표시.
- *
- *  ⛔⭐ **문면을 «손으로 짓지 않는다»** — 레지스트리가 낸다(RFC-one-door-many-entrances P2).
- *  📏 2026-08-20 실측: 은퇴로 «선언»된 입구 셋 중 `--help` 가 그 사실을 말한 것은 하나뿐이었고,
- *  ***그 하나(여기)조차 문면을 레지스트리와 «따로» 들고 있었다.***
- *  ⇒ 🔑 선언과 표면이 «두 곳»에 살면 한쪽만 고쳐지고 다른 쪽이 조용히 늙는다.
- *  ⚠️ 상수 «이름»은 유지한다 — 시험과 index.ts 가 이 이름으로 읽는다(뜻이 좁아지지 않는다). */
-export const HARNESS_RUN_DEPRECATION_HELP = describeEntranceCommand(
-  CLI_HARNESS_RUN_ENTRANCE,
-  HARNESS_RUN_REPLACEMENT,
-  '이 입구는 더 이상 실행되지 않습니다.',
-).trimEnd();
-
 /** ⭐ 진행 릴레이를 «단 곳» — 하니스 시퀀서가 스테이지마다 내는 progress 를 CLI 부모 stdout 까지 잇는다.
  *
  *  ⛔ **왜 `ctx` 가 아니라 `deps.uxSource` 인가**: `dispatchRunDevHarness` 의 detached 가드가

package/src/self-dev/orchestrate-cli-text.ts

@@ -0,0 +1,10 @@
+/** Shared, dependency-free text rules for both orchestrate CLI entrances. */
+export function splitOrchestrateGoalTexts(parts: readonly string[]): string[] {
+  const joined = parts.join(' ');
+  return (joined.includes(';;') ? joined.split(';;') : parts).map((goal) => goal.trim()).filter(Boolean);
+}
+
+export function normalizeOrchestrateRequest(input: readonly string[] | string): string {
+  const joined = typeof input === 'string' ? input : input.join(' ');
+  return joined.replace(/;;/g, ' ').trim();
+}

package/src/self-dev/orchestrate-cli.ts

@@ -342,9 +342,15 @@ export async function runSelfOrchestrateCliCommand(
   try {
     // ⭐ goals·spec 이 «라운드마다 바뀔 수 있다» — 분해 제안이 조각을 쪼개면 연합으로 승격된다.
     let currentGoals = input.goals;
+    // A supervised split starts from an ordinary single goal, so the CLI did not
+    // receive --decompose/parentRequest. Preserve that goal as the boundary source
+    // when its children replace it in a later round.
+    let supervisedParentRequest = input.parentRequest;
     let spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
     /** 이미 쪼갠 goal — ⛔ 같은 것을 두 번 쪼개면 조각이 무한히 불어난다. */
     const decomposedFeatures = new Set<string>();
+    /** 거부된 제안의 feature — ⛔ 다음 라운드가 같은 제안을 다시 쓰고 다시 조용히 거부하는 것을 막는다. */
+    const rejectedFeatures = new Set<string>();
     const repairFingerprints = new Map<string, number>();
     const repairAppend: RepairAppendObservation[] = [];
     let repairFragmentsAdded = 0;
@@ -383,7 +389,7 @@ export async function runSelfOrchestrateCliCommand(
     };
     const runtimeWithParentRequest = (): OrchestrateRuntime => {
       const runtime = runtimeForObservationCycle();
-      return input.parentRequest === undefined ? runtime : { ...runtime, parentRequest: input.parentRequest };
+      return supervisedParentRequest === undefined ? runtime : { ...runtime, parentRequest: supervisedParentRequest };
     };
     const exec = deps.executeReroute ?? executeOrchestrateReroute;
     const pipelineDeps = deps.pipelineDeps ? { pipelineDeps: deps.pipelineDeps } : undefined;
@@ -391,11 +397,35 @@ export async function runSelfOrchestrateCliCommand(
     let baseRuntime = runtimeWithParentRequest();
     let { results, exitCode } = await exec(spec, baseRuntime, pipelineDeps);
 
+    // ⭐⭐⭐ SUPERVISOR-SOFTSTOP-HONOR — 사람이 child 를 멈췄다는 신호(stage 'soft-stopped')는
+    //   «라운드 경계»에서 존중된다(재현 원장 run-8cf691c5: ccaf Pod 가 soft-stopped 로 끝났는데
+    //   5초 뒤 fa fa Pod 가 발사됐다). 근거는 «이번 invocation 에서 막 끝난 결과»뿐이다 —
+    //   과거 checkpoint 의 soft-stopped 항목을 읽지 않으므로 새 호출의 무관한 작업을 막지 않는다.
+    const childSoftStop = (rs: readonly SelfDevJobResult[]): SelfDevJobResult | undefined =>
+      rs.find((r) => r.stage === 'soft-stopped');
+    // ⭐ 원샷 래치 — 이번 invocation 이 «같은 정지된 조각»을 두 번 계상하지 않는다: rerun 재진입
+    //   방어가 pair 를 이미 냈으면 종착 관측(stoppedAfter)이 같은 taskId 로 재발행하지 않는다.
+    //   #30606 리뷰: 방어가 여러 번 재진입돼도(결과 불변 감독 루프) pair 는 정확히 1회.
+    const honoredStops = new Set<string>();
+    const observeSoftStopHonored = (stopped: SelfDevJobResult, round: number): void => {
+      if (honoredStops.has(stopped.taskId)) return;
+      honoredStops.add(stopped.taskId);
+      try {
+        debug.log('self-dev.supervisor', 'human-stopped', { stage: 'soft-stopped', taskId: stopped.taskId, round });
+        debug.log('self-dev.supervisor', 'soft-stop-honored', { stage: 'soft-stopped', taskId: stopped.taskId, round });
+      } catch { /* observation must not interrupt execution */ }
+    };
+
     // ⭐⭐⭐ 런 슈퍼바이저 — 스위치가 켜졌으면 «여기»서 끝까지 돈다.
     //   ⛔ 프로세스를 다시 띄우지 않는다: resumeFrom 심으로 같은 프로세스 안에서 라운드를 돌아야
     //     runId·체크포인트·관측이 한 줄로 이어진다.
     //   ⛔ 판정은 순수 모듈(run-supervisor)이 하고, 이 심은 그 답을 «집행»만 한다.
     if (input.supervise) {
+      const stoppedFirst = childSoftStop(results);
+      // 첫 라운드가 사람 정지로 끝났으면 재발사를 «시작하지 않는다» — 총 exec 1 · 다음 Pod 0.
+      // 라운드 표기는 strategy.launch 와 같은 1-기반(첫 exec = round 1)을 쓴다.
+      if (stoppedFirst) observeSoftStopHonored(stoppedFirst, 1);
+      if (!stoppedFirst) {
       const limits = {
         ...(input.supervise.rounds === undefined ? {} : { maxRounds: input.supervise.rounds }),
         ...(input.supervise.stallRounds === undefined ? {} : { stallRounds: input.supervise.stallRounds }),
@@ -435,6 +465,14 @@ export async function runSelfOrchestrateCliCommand(
         // ⭐ 방금 끝난 결과를 넘긴다 — orchestrateSelfDev 가 classifyResumeDisposition 으로
         //   skip/rerun 을 갈라준다(재발명 0 · 착지한 조각은 다시 안 돈다).
         rerun: async (previous, invocation) => {
+          // ⭐⭐⭐ SUPERVISOR-SOFTSTOP-HONOR — 직전 라운드가 사람 정지(stage 'soft-stopped')로
+          //   끝났으면 다음 exec(spec, resumeFrom…) 직전에 멈춘다. 근거는 «이번 invocation 에서
+          //   막 끝난 previous» 하나뿐 — 과거 checkpoint 를 읽지 않으므로 새 호출을 막지 않는다.
+          const stoppedPrevious = childSoftStop(previous);
+          if (stoppedPrevious) {
+            observeSoftStopHonored(stoppedPrevious, supervisedRound + 1);
+            return previous;
+          }
           let addedRepairIds: string[] = [];
           // A requested repair that cannot be bound to exactly one goal is held (not relaunched with the old strategy).
           const unrepairedHold: string[] = [];
@@ -485,15 +523,37 @@ export async function runSelfOrchestrateCliCommand(
           //   ⛔ 의존성은 조각이 «들고 온 그대로» 물려준다 ⇒ dependsOn 이 없는 조각은
           //     orchestrateSelfDev 의 위상 병렬로 «자동으로 동시에» 돈다(대표 2026-08-19 기본 동작).
           const goalsBeforeDecompose = new Set(currentGoals);
-          const applied = applyDecomposeProposals(currentGoals, previous, { alreadyDecomposed: decomposedFeatures });
+          const applied = applyDecomposeProposals(currentGoals, previous, {
+            // ⛔⭐ 거부된 feature 도 «다시 제안되지 않게» 한다 — 이미 쪼갠 것과 같은 상태로 센다.
+            //   이렇게 하지 않으면 다음 라운드가 같은 제안을 다시 읽고 다시 조용히 거부한다.
+            alreadyDecomposed: new Set([...decomposedFeatures, ...rejectedFeatures]),
+          });
+          // ⛔⭐ 거부된 제안을 «상태로» 남긴다 — applyDecomposeProposals 안의 관측과 함께
+          //   「쪼개지 않았다」는 사실과 그 사유가 로그와 라운드 간 상태에 다 남는다.
+          if (applied.rejected.length > 0) {
+            for (const rejection of applied.rejected) rejectedFeatures.add(rejection.feature);
+            try {
+              debug.log('self-dev.supervisor', 'decompose-rejected.applied', {
+                rejected: applied.rejected.map((rejection) => ({
+                  feature: rejection.feature.slice(0, 120),
+                  reason: rejection.reason,
+                  danglingIds: [...rejection.detail],
+                })),
+              });
+            } catch { /* fail-open */ }
+          }
           if (applied.decomposed.length > 0) {
+            if (supervisedParentRequest === undefined && applied.decomposed.length === 1
+              && currentGoals.length === 1 && currentGoals[0]?.feature === applied.decomposed[0]) {
+              supervisedParentRequest = applied.decomposed[0];
+            }
             for (const f of applied.decomposed) decomposedFeatures.add(f);
             currentGoals = applied.goals;
             spec = buildSelfOrchestrateDevSpec(currentGoals, input.concurrency);
             try {
               // ⛔⭐ 「원본 ↔ 조각」을 «이름»으로 남긴다 — 수만 남기면 그 연결이 «영영» 안 남는다.
               //   📏 2026-08-19 자수: 초판이 decomposed.length 만 실었다. 그러면 나중에
-              //     「이 런이 어느 원본에서 쪼개졌나」를 «아무 데서도» 못 가린다.
+              //     「이 런이 어느 원본에서 쪼개졌나»를 «아무 데서도» 못 가린다.
               //   ⚠️ 그리고 이 값은 «로그»라 보존이 짧다(~2.5시간 실측 · 원장은 15일) —
               //     원장에 싣는 것이 다음 칸이다(🅣 축 · E0).
               debug.log('self-dev.supervisor', 'decompose-and-retry.applied', {
@@ -569,6 +629,11 @@ export async function runSelfOrchestrateCliCommand(
           return next.results;
         },
       });
+      // 감독 루프가 사람 정지 라운드 뒤 rerun 없이 스스로 멈출 수도 있다 — 그 종결도
+      // 이번 invocation 의 «막 끝난» 결과만 근거로 이름 있는 관측으로 남긴다.
+      const stoppedAfter = childSoftStop(results);
+      if (stoppedAfter) observeSoftStopHonored(stoppedAfter, supervisedRound + 1);
+      } // (!stoppedFirst — 사람 정지면 superviseRun 자체를 시작하지 않는다)
     }
 
     return { ok: true, results, exitCode, ...(repairAppend.length ? { repairAppend } : {}) };

package/src/self-dev/orchestrate.ts

@@ -204,7 +204,7 @@ interface SelfDevTerminalOutcome {
   stage: string | null;
   merged: boolean | null;
   prUrl: string | null;
-  blockReason?: 'parent-unlanded' | 'dependency-needs-human';
+  blockReason?: 'parent-unlanded' | 'dependency-needs-human' | 'dependency-deferred';
   parentPrNumber?: number | null;
   parentNoPr?: true;
 }
@@ -270,7 +270,8 @@ export function hasDelivered(result: SelfDevJobResult): boolean {
 
 /** 열린 PR 을 사람에게 보여줄 때 분류 칸에 싣는 문면. 없는 mergeReason 은 「사유 모름」— 값을 짓지 않는다. */
 export function openPrAwaitingHumanMessage(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl' | 'mergeReason'>): string {
-  const pointer = result.prNumber !== undefined ? `#${result.prNumber}` : (result.prUrl ?? '');
+  const pointer = typeof result.prNumber === 'number' && Number.isSafeInteger(result.prNumber) && result.prNumber > 0
+    ? `#${result.prNumber}` : (result.prUrl ?? '');
   const reason = result.mergeReason && result.mergeReason.length > 0 ? result.mergeReason : '사유 모름';
   return `열린 PR ${pointer} · ${reason}`;
 }
@@ -488,17 +489,42 @@ export function queryPreflightWarning(
   }
 }
 
+function hasConcretePrEvidence(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl'>): boolean {
+  const number = result.prNumber;
+  if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) return true;
+  if (typeof result.prUrl !== 'string') return false;
+  // Match the raw URL. WHATWG URL normalizes dot segments before exposing
+  // pathname, which would turn a noncanonical pointer into apparent evidence.
+  const match = /^https:\/\/github\.com\/[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*\/pull\/([1-9]\d*)$/.exec(result.prUrl);
+  return match !== null && Number.isSafeInteger(Number(match[1]));
+}
+
+function hasOpenedPrPointer(result: Pick<SelfDevJobResult, 'prNumber' | 'prUrl'>): boolean {
+  const number = result.prNumber;
+  if (typeof number === 'number' && Number.isSafeInteger(number) && number > 0) return true;
+  if (typeof result.prUrl !== 'string') return false;
+  // `stage=pr-opened` is a separate observation and may come from a non-GitHub
+  // host. Keep its host-neutral pull pointer contract, with no null or issue URL.
+  const match = /^https:\/\/[A-Za-z0-9][A-Za-z0-9.-]*\/(?:[A-Za-z0-9][A-Za-z0-9_.-]*\/)*pull\/([1-9]\d*)$/.exec(result.prUrl);
+  return match !== null && Number.isSafeInteger(Number(match[1]));
+}
+
 export function classifyFailure(
   result: SelfDevJobResult,
   preflightWarning: PreflightWarningObservation = 'unknown',
 ): FailureKind | null {
   if (result.blockReason === 'parent-unlanded') return 'parent-unlanded';
+  // A child may claim no changes after committing and opening its draft. The
+  // parent must retain the PR for review instead of reworking the same goal.
+  if (result.status === 'failed' && result.completionDisposition === 'completed-without-changes'
+    && hasConcretePrEvidence(result)) return 'awaiting-human';
+  if (result.blockReason === 'dependency-deferred' || result.error?.code === 'DEP_BLOCKED_REBASE_READY') return 'blocked-upstream';
   if (result.blockReason === 'dependency-needs-human' || result.error?.code === 'GOAL_DONE_BOUNDARY_MISSING') return 'awaiting-human';
   const ledgerKind = result.failureClassification === undefined
     ? undefined
     : result.failureClassification === 'run-deadline-exceeded'
       // 기한 사망은 transient 가 아니다. 브랜치/PR 이 있으면 수확(false-failure), 없으면 재분해.
-      ? (result.branch || result.prUrl || result.prNumber !== undefined ? 'false-failure' : 'unconverged-decomposable')
+      ? (result.branch || hasOpenedPrPointer(result) ? 'false-failure' : 'unconverged-decomposable')
       : LEDGER_FAILURE_KIND[result.failureClassification];
 
   // ⭐ 수렴 실패인데 하니스가 «쪼개는 법»을 이미 냈으면 그것은 다른 처방이다.
@@ -518,7 +544,7 @@ export function classifyFailure(
     result.status === 'done'
     && result.stage === 'pr-opened'
     && !hasLanded(result)
-    && (Boolean(result.prUrl) || result.prNumber !== undefined)
+    && hasOpenedPrPointer(result)
   ) {
     return 'awaiting-human';
   }
@@ -616,8 +642,15 @@ export function classifyFailures(
     const kind = classifyFailure(result, queryPreflightWarning(preflightIdentifiers, queryPreflight));
     if (kind === null) return [];
     const error = result.error;
-    const awaitingHuman = kind === 'awaiting-human'
-      ? failureObservationFields('AWAITING_HUMAN', openPrAwaitingHumanMessage(result))
+    const prChangeConflict = kind === 'awaiting-human' && result.status === 'failed'
+      && result.completionDisposition === 'completed-without-changes'
+      && hasConcretePrEvidence(result);
+    const prPointer = typeof result.prNumber === 'number' && Number.isSafeInteger(result.prNumber) && result.prNumber > 0
+      ? `#${result.prNumber}` : result.prUrl;
+    const awaitingHuman = prChangeConflict
+      ? failureObservationFields('PR_CHANGE_CONFLICT', `PR ${prPointer} exists while child reported completed-without-changes`)
+      : kind === 'awaiting-human'
+        ? failureObservationFields('AWAITING_HUMAN', openPrAwaitingHumanMessage(result))
       : kind === 'parent-unlanded'
         ? failureObservationFields('PARENT_UNLANDED', parentUnlandedProgressLine(result.feature.split('\n')[0]!, result.parentPrNumber, result.parentNoPr === true))
         : undefined;
@@ -1009,13 +1042,16 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           taskId: `boundary:${taskCardId}:blocked:${index + 1}`,
           feature: goal.feature,
           status: 'blocked',
-          blockReason: 'dependency-needs-human',
-          stopReason: 'needs-human',
-          error: { code: 'DEPENDENCY_NEEDS_HUMAN', message: `선행 needs-human: ${predecessor}` },
+          blockReason: 'dependency-deferred',
+          stopReason: 'rebase-ready',
+          error: { code: 'DEP_BLOCKED_REBASE_READY', message: `선행 조각 ${predecessor} 재수복 뒤 다음 런 이월` },
         });
+        try { debug.log('self-dev.slice', 'dep-blocked', { slice: goal.id ?? String(index), blockedBy: predecessor,
+          reason: 'GOAL_DONE_BOUNDARY_MISSING', disposition: 'rebase-ready' }); } catch { /* observation is fail-soft */ }
       }
       const withheld = [...blockedGoalIndexes].map((index) => index + 1);
-      try { debug.log('self-dev.orchestrate', 'done-boundary-missing', { taskCardId, boundaryMissing, withheld, action: 'needs-human', eligibleToLaunch: opts.goals.length - blockedGoalIndexes.size }); } catch { /* fail-soft */ }
+      try { debug.log('self-dev.orchestrate', 'done-boundary-missing', { taskCardId, boundaryMissing, withheld,
+        action: 'partial-needs-human', dependentDisposition: 'rebase-ready', eligibleToLaunch: opts.goals.length - blockedGoalIndexes.size }); } catch { /* fail-soft */ }
       opts = { ...opts, goals: opts.goals.flatMap((goal, index) => blockedGoalIndexes.has(index)
         ? []
         : [{ ...goal, id: goal.id ?? String(index) }]) };
@@ -1290,6 +1326,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
   const taskIdByLocal = new Map<string, string>();         // goal-local id → live taskId
   const taskIdByGoal = new Map<SelfDevGoal, string>();      // original shard → current or resumed taskId
   const created: Array<{ task: ReturnType<typeof createTask>; goal: SelfDevGoal }> = [];
+  const repairedGoals = new Set<SelfDevGoal>();
   opts.goals.forEach((g, i) => {
     const prior = resumedByGoal.get(g);
     if (prior) {
@@ -1762,8 +1799,38 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
               dispStage: fDisp?.stage ?? 'none', screenSpace: fScreen.screenSpace,
             });
           }
+          const failedGoal = taskByGoal.get(ev.taskId);
+          const failedTask = graph.getTask(ev.taskId);
           const failedResult = results.get(ev.taskId)!;
           const stopReason = opts.stopAfterFailure?.(failedResult) ?? null;
+          // A child without a PR gets one supervised, narrower attempt. Keep the original
+          // failure in the checkpoint; redirect only its actual dependents to the replacement.
+          if (stopReason === null && taskCardId?.trim() && failedGoal && failedTask?.surface.kind === 'self-implement' && !repairedGoals.has(failedGoal)
+            && !fDisp?.prUrl && fDisp?.merged !== true && fDisp?.harvestable !== true) {
+            repairedGoals.add(failedGoal);
+            const reason = `${ev.errorCode}: ${ev.errorMessage}`.slice(0, FAILURE_MESSAGE_MAX_LENGTH);
+            const repairFeature = `${failedGoal.feature.trimEnd()}\n\n## 자동 수복 1회\n앞선 조각 실패: ${reason}\n실패 범위만 좁혀 재시도하고 원래 완료 경계를 보존한다.`;
+            const replacement = createTask({
+              title: goalTitle(failedGoal),
+              description: repairFeature.slice(0, TASK_DEFAULTS.descriptionMaxLen),
+              surface: failedTask.surface.kind === 'self-implement'
+                ? { ...failedTask.surface, feature: repairFeature }
+                : failedTask.surface,
+              isolation: failedTask.isolation,
+            }, { now: now() });
+            graph.addTask(replacement);
+            graph.updateTask(replacement.id, { dependsOn: [...failedTask.dependsOn] }, { now: now() });
+            taskByGoal.set(replacement.id, failedGoal);
+            spaceIdByTask.set(replacement.id, spaceIdForTask(replacement));
+            taskIdByGoal.set(failedGoal, replacement.id);
+            created.push({ task: replacement, goal: failedGoal });
+            graph.supersede(ev.taskId, [replacement.id], { now: now() });
+            results.set(ev.taskId, { ...results.get(ev.taskId)!, status: 'superseded' });
+            try { debug.log('self-dev.slice', 'repair-retry', { slice: failedGoal.id ?? ev.taskId, failedTaskId: ev.taskId,
+              replacementTaskId: replacement.id, reason, attempt: 1 }); } catch { /* observation is fail-soft */ }
+            scheduleTick();
+            break;
+          }
           if (stopReason !== null) {
             let remainingGoals = 0;
             for (const task of created.map(({ task }) => graph.getTask(task.id)).filter((task): task is NonNullable<typeof task> => task !== undefined)) {
@@ -1781,24 +1848,56 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
             }
             if (remainingGoals > 0) opts.onStopAfterFailure?.({ reason: stopReason, remainingGoals });
           }
-          // S3 cascade — dependents of a failed task can never become
-          // ready (a dep will never be `done`) → cancel them honestly
-          // instead of leaving them `blocked` (which stalls the run onto
-          // the stuck-guard). subtree() = failed task + its downstream.
+          // A hot-file edge only serializes execution. It does not make the later
+          // slice depend on the earlier slice's result. Cancel only the explicit
+          // dependency closure; release hot-only edges so independent PRs proceed.
+          const localGoalId = (goal: SelfDevGoal): string => goal.id ?? String(opts.goals.indexOf(goal));
+          const blockedGoalIds = new Set<string>(failedGoal ? [localGoalId(failedGoal)] : []);
+          let expanded = true;
+          while (expanded) {
+            expanded = false;
+            for (const { goal } of created) {
+              const localId = localGoalId(goal);
+              if (blockedGoalIds.has(localId)) continue;
+              if ((goal.dependsOn ?? []).some((id) => blockedGoalIds.has(id))) {
+                blockedGoalIds.add(localId);
+                expanded = true;
+              }
+            }
+          }
           let cascaded = 0;
-          for (const t of graph.subtree(ev.taskId)) {
-            if (t.id === ev.taskId || isTerminalStatus(t.status)) continue;
+          for (const { task, goal } of created) {
+            const t = graph.getTask(task.id);
+            if (!t || t.id === ev.taskId || isTerminalStatus(t.status)) continue;
+            const localId = localGoalId(goal);
+            if (!blockedGoalIds.has(localId)) continue;
             try {
               graph.updateTask(t.id, { status: 'cancelled' }, { now: now() });
               results.set(t.id, {
                 taskId: t.id,
                 feature: taskByGoal.get(t.id)?.feature ?? '',
                 status: 'cancelled',
-                error: { code: 'DEP_FAILED', message: `dependency ${ev.taskId} failed` },
+                error: taskCardId?.trim()
+                  ? { code: 'DEP_BLOCKED_REBASE_READY', message: `dependency ${ev.taskId} failed; rebase-ready next run` }
+                  : { code: 'DEP_FAILED', message: `dependency ${ev.taskId} failed` },
               });
+              try { debug.log('self-dev.slice', 'dep-blocked', { slice: localId, blockedBy: failedGoal?.id ?? ev.taskId,
+                reason: ev.errorCode, disposition: 'rebase-ready' }); } catch { /* observation is fail-soft */ }
               cascaded++;
             } catch { /* best-effort */ }
           }
+          for (const { task, goal } of created) {
+            const current = graph.getTask(task.id);
+            if (!current || isTerminalStatus(current.status)) continue;
+            const independent = current.dependsOn.filter((id) => {
+              const parent = graph.getTask(id);
+              return parent && (parent.status === 'failed' || parent.status === 'cancelled' || parent.status === 'superseded')
+                && !(goal.dependsOn ?? []).includes(taskByGoal.has(id) ? localGoalId(taskByGoal.get(id)!) : '');
+            });
+            if (independent.length) graph.updateTask(task.id, {
+              dependsOn: current.dependsOn.filter((id) => !independent.includes(id)),
+            }, { now: now() });
+          }
           debug.log('self-dev.orchestrate', 'job.failed', {
             taskId: ev.taskId,
             feature: shortFeature(ev.taskId),

package/src/self-dev/review-provider-fallback.ts

@@ -107,6 +107,36 @@ export function parseTeamclaudeBaseUrl(stdout: string): string | undefined {
   return match?.[1];
 }
 
+export interface TeamclaudeReviewRoute {
+  /** Present only when teamclaude printed its proxy base URL: the cct ACP spawn (billing scrub ⊕ base-url). */
+  spawn?: ReturnType<typeof subscriptionReviewerSpawn>;
+  reason: 'teamclaude-base-url' | 'teamclaude-no-base-url' | 'teamclaude-unavailable';
+  exit?: number | null;
+}
+
+/**
+ * ACP-REVIEW-VIA-TEAMCLAUDE (0.2.35): the explicit `--acp-backend claude` review reuses the cct route of the
+ * subscription lane — `teamclaude env --no-mitm` → base URL → `subscriptionReviewerSpawn` — without the quota gate
+ * (an explicit flag is the operator's choice). teamclaude missing or silent = no spawn; the caller keeps its prior path.
+ */
+export function resolveTeamclaudeReviewRoute(
+  env: NodeJS.ProcessEnv = process.env,
+  runStatus: NonNullable<SubscriptionReviewerDeps['runStatus']> = (command, args, cleanEnv) =>
+    spawnSync(command, args, { env: { ...cleanEnv, NODE_ENV: process.env.NODE_ENV }, encoding: 'utf8', timeout: 5_000 }),
+): TeamclaudeReviewRoute {
+  const spec: SubscriptionReviewerSpec = { provider: 'claude-acp', executor: 'cct' };
+  try {
+    const proxy = runStatus('teamclaude', ['env', '--no-mitm'], subscriptionReviewerSpawn(spec, env).env);
+    // Bun reports a missing binary as `status: undefined` (Node: null) — both mean «no teamclaude here».
+    if (proxy.status == null) return { reason: 'teamclaude-unavailable' };
+    const baseUrl = proxy.status === 0 ? parseTeamclaudeBaseUrl(String(proxy.stdout ?? '')) : undefined;
+    if (!baseUrl) return { reason: 'teamclaude-no-base-url', exit: proxy.status };
+    return { spawn: subscriptionReviewerSpawn(spec, env, baseUrl), reason: 'teamclaude-base-url' };
+  } catch {
+    return { reason: 'teamclaude-unavailable' };
+  }
+}
+
 /** Guard the ACP review before spawning. An unmeasured quota never authorizes subscription use. */
 export function subscriptionReviewerAvailability(
   spec: SubscriptionReviewerSpec,
@@ -291,7 +321,7 @@ export interface ReviewFallbackObservation {
 export async function runReviewWithFallback(
   attempts: readonly ReviewProviderAttempt[],
   call: (attempt: ReviewProviderAttempt, observeResolvedProvider: (provider?: string) => void) => Promise<string>,
-  observe: (event: 'attempt' | 'resolved' | 'fallback' | 'exhausted', data: ReviewFallbackObservation) => void = () => {},
+  observe: (event: 'attempt' | 'resolved' | 'completed' | 'fallback' | 'exhausted', data: ReviewFallbackObservation) => void = () => {},
 ): Promise<{ text: string; used: ReviewProviderAttempt; attemptIndex: number }> {
   if (attempts.length === 0) throw new Error('review fallback: no attempts configured');
   let lastError: unknown;
@@ -318,6 +348,10 @@ export async function runReviewWithFallback(
       if (resolvedProvider) {
         try { observe('resolved', { ...base, resolvedProvider }); } catch { /* fail-soft */ }
       }
+      // Provider calls are attempts; only a non-empty artifact completes a logical review round.
+      if (text.trim()) {
+        try { observe('completed', { ...base, ...(resolvedProvider ? { resolvedProvider } : {}) }); } catch { /* fail-soft */ }
+      }
       return { text, used: attempt, attemptIndex: i };
     } catch (error) {
       lastError = error;