elanous 0.2.35 → 0.2.37

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/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

@@ -18,7 +18,7 @@
 //   📏 실측이 그 분리를 뒷받침한다: 폴백 판정 전수 493 중 `action=grok` ***0건*** —
 //     쿼터 축은 과부하에 «반응하지 않는다».
 import { resolveModelAlias } from '../intelligence-map/model-alias.js';
-import type { LLMProvider } from '../llm.js';
+import { getProvider, inferProviderFromModel, resolveReviewModelAlias, type LLMProvider } from '../llm.js';
 import { spawnSync } from 'node:child_process';
 import { claudeBackend, resolveBackendSpawn } from '../agent-mission/driver.js';
 import { checkClaudeSubscription } from '../agent-mission/claude-subscription.js';
@@ -279,19 +279,57 @@ export function buildReviewProviderAttempts(
   primary: ReviewProviderAttempt,
   fallbacks: readonly ReviewProviderAttempt[],
 ): ReviewProviderAttempt[] {
-  const out: ReviewProviderAttempt[] = [primary];
-  const seen = new Set([primary.model]);
+  const model = resolveReviewModelAlias(primary.model);
+  const inferred = inferProviderFromModel(model);
+  const supported = Boolean(inferred && (inferred !== 'local' || model.startsWith('local:') || model.startsWith('local-llm:')));
+  let selectedProvider: LLMProvider | undefined;
+  if (supported) {
+    const provider = getProvider(model);
+    if (!primary.provider || primary.provider.name === provider.name) selectedProvider = primary.provider ?? provider;
+  }
+  if (!selectedProvider) {
+    // A malformed/ambiguous configured primary is diagnostic, not fatal: the configured/default
+    // fallback attempts below still provide the review. Preserve an unresolved attempt so the
+    // runner records its reason, and expose a stable event for operational diagnosis.
+    try {
+      debug.log('review.fallback', 'primary-unresolved', {
+        model: primary.model,
+        configuredProvider: primary.provider?.name ?? null,
+      }, { level: 'warn' });
+    } catch { /* fail-soft */ }
+  }
+  const normalizedPrimary: ReviewProviderAttempt = {
+    ...primary,
+    model,
+    ...(selectedProvider ? { provider: selectedProvider } : { provider: undefined }),
+  };
+  const out: ReviewProviderAttempt[] = [normalizedPrimary];
+  const seen = new Set(selectedProvider ? [model] : []);
   for (const f of fallbacks) {
-    if (!f.model.trim() || seen.has(f.model) || (primary.provider && f.provider?.name === primary.provider.name)) continue;
-    seen.add(f.model);
-    out.push(f);
+    if (!f.model.trim()) continue;
+    const fallbackModel = resolveReviewModelAlias(f.model);
+    if (seen.has(fallbackModel)) continue;
+    const fallbackInference = inferProviderFromModel(fallbackModel);
+    if (!fallbackInference || (fallbackInference === 'local' && !fallbackModel.startsWith('local:') && !fallbackModel.startsWith('local-llm:'))) {
+      throw new Error(`review fallback: ambiguous or unsupported fallback model "${f.model}"`);
+    }
+    const fallbackProvider = getProvider(fallbackModel);
+    if (f.provider && f.provider.name !== fallbackProvider.name) {
+      throw new Error(`review fallback: unsupported provider "${f.provider.name}" for model "${fallbackModel}"`);
+    }
+    if (normalizedPrimary.provider && (f.provider ?? fallbackProvider).name === normalizedPrimary.provider.name) continue;
+    seen.add(fallbackModel);
+    const selectedFallbackProvider = f.provider ?? fallbackProvider;
+    out.push(f.model === fallbackModel && f.provider === selectedFallbackProvider
+      ? f : { ...f, model: fallbackModel, provider: selectedFallbackProvider });
   }
   return out;
 }
 
 /** A distinct provider is available even when the optional config list is empty. */
 export function defaultReviewFallbackModel(primaryProvider?: string): string {
-  return resolveModelAlias(primaryProvider === 'grok' ? 'claude' : 'grok')!;
+  // `claude` is a family label, not a model alias; use the canonical Opus alias for the Claude lane.
+  return resolveModelAlias(primaryProvider === 'grok' ? 'opus' : 'grok')!;
 }
 
 export interface ReviewFallbackObservation {

package/src/self-dev/run-supervisor.ts

@@ -10,7 +10,7 @@ import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
-import { recordTaskAgentShadowMove, runCardFor, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import type { TaskAgentShadowInput } from '../task-agent/shadow.js';
 import { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
 import {
   classifyMustFixRound, inferMustFixEvidence, judgeMustFixScope, proposeMustFixSplit,
@@ -40,6 +40,8 @@ export interface SupervisorRound {
   mainSyncRelaunchTaskIds?: string[];
   /** Original feature and relaunch goal text of those tasks — a rerun may mint a new taskId, so the piece is also found by goal. */
   mainSyncRelaunchFeatures?: string[];
+  /** PR 없는 미분류 실패에 대해 실제 분해 실행기로 수복한 원래 골. 새 taskId에도 한 번 상한을 지킨다. */
+  selfHealDecomposeFeatures?: string[];
   /**
    * Tasks of this round that ended `status=failed` without a PR. Omitted when there are none — and on older
    * history, which never measured it, so the no-PR streak guard reads it as «not measured» and stays off.
@@ -130,6 +132,7 @@ export interface SupervisorDecision {
   };
   oscillation?: { taskIds: string[]; helper: 'review-oscillation'; signature: string; repairGoals?: Record<string, string>; heldTaskIds?: string[] };
   pendingDecision?: 'attempt-care-escalation';
+  selfHeal?: { reason: 'supervisor-unclassified-decompose'; attempt: 1; taskIds: string[] };
 }
 
 export interface SupervisorLimits {
@@ -352,6 +355,8 @@ export function decideNextRun(input: {
   reviewMustFixTrend?: ReviewRework['trend'];
   /** True: the rerun consumes the authored goal. False: it cannot, so oscillation stops for a human. Undefined: pure decision. */
   repairGoalExecution?: boolean;
+  /** 분해 제안을 실제 조각 실행으로 승격할 수 있는 supervisor 경로에만 true. */
+  decompositionExecution?: boolean;
 }): SupervisorDecision {
   const results = [...input.results];
   const history = [...(input.history ?? [])];
@@ -502,6 +507,29 @@ export function decideNextRun(input: {
   }
 
   if (!t.actionable) {
+    const spent = new Set(history.flatMap((entry) => entry.selfHealDecomposeFeatures ?? []).map(resumeKey));
+    const candidates = input.decompositionExecution === true && round + 1 <= maxRounds
+      ? activeResults.filter((result) => result.status === 'failed' && result.prNumber === undefined && !result.prUrl
+        && !result.providerErrors && !result.blockReason
+        && (result.decomposeProposal?.pieces.length ?? 0) >= 2
+        && t.needsHuman.includes(result.taskId)
+        && t.classifications.some((classification) => classification.taskId === result.taskId && classification.kind === 'unclassified')
+        && !spent.has(resumeKey(result.feature)))
+      : [];
+    // rerun은 라운드 전체를 받는다. 다른 needs-human 조각을 함께 다시 띄우지 않도록 첫 조각은 단독 후보로만 허용한다.
+    const candidate = candidates.length === 1 && t.needsHuman.every((id) => id === candidates[0]!.taskId)
+      ? candidates[0] : undefined;
+    if (candidate) {
+      const taskIds = [candidate.taskId];
+      return { ...base, action: 'relaunch',
+        decomposable: taskIds,
+        needsHuman: t.needsHuman.filter((id) => !taskIds.includes(id)),
+        classifications: t.classifications.map((classification) => taskIds.includes(classification.taskId)
+          ? { ...classification, action: 'decompose-and-retry' as const } : classification),
+        selfHeal: { reason: 'supervisor-unclassified-decompose', attempt: 1, taskIds },
+        why: `supervisor-unclassified-decompose (attempt: 1/1) — PR 없는 미분류 조각 ${taskIds.length}개를 실증된 분해 제안으로 한 번 재걸기`,
+      };
+    }
     if (t.needsHuman.length > 0) {
       return {
         ...base,
@@ -772,6 +800,12 @@ export function appendRound(
         decision.relaunchGoals?.[id],
       ].filter((feature): feature is string => feature !== undefined)),
     } : {}),
+    ...(decision?.action !== 'stop' && decision?.selfHeal ? {
+      selfHealDecomposeFeatures: decision.selfHeal.taskIds.flatMap((id) => {
+        const feature = results.find((result) => result.taskId === id)?.feature;
+        return feature === undefined ? [] : [feature];
+      }),
+    } : {}),
     ...(decision?.action === 'add-repair-task' && decision.oscillation ? (() => {
       // Each repaired task is recorded under its original goal feature and, when a rerun runs the authored goal as
       // the piece's new feature (orchestrate), under that repair text too — so the repair's own oscillation stops.
@@ -1028,6 +1062,7 @@ export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
   external?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
 } = {}): Promise<void> {
   const statePath = deps.statePath ?? taskAgentStatePath();
+  const { runCardFor } = await import('../task-agent/shadow.js');
   const card = runCardFor(runId, { statePath, ...(deps.env ? { env: deps.env } : {}) });
   if (!card || card.status !== 'launched' || card.taLand !== true || cardPrNumber(card) === undefined) return;
   const { rejudgeAsyncResultCard } = await import('../task-agent/rejudge-on-head.js');
@@ -1081,9 +1116,10 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     const allUnreviewedAreNoDiff = unreviewed.length > 0
       && unreviewed.every((result) => result.reviewReason === 'no-diff');
 
-    const decision = decideNextRun({
+    let decision = decideNextRun({
       results,
       history,
+      decompositionExecution: opts.promoteDecomposition !== undefined,
       // Undeclared = cannot run the repair goal: an add-repair-task would otherwise be a same-strategy relaunch.
       repairGoalExecution: opts.repairGoalExecution === true,
       ...(aggregateReviewTrend(results) ? { reviewMustFixTrend: aggregateReviewTrend(results) } : {}),
@@ -1118,6 +1154,20 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         decomposePromotion = { attempted: true, reason: `shim-failed: ${String(error)}` };
       }
     }
+    if (decision.selfHeal) {
+      const promoted = decomposePromotion.attempted && (decomposePromotion.pieceCount ?? 0) >= 2;
+      try { opts.observe?.('supervisor-self-heal', { runId, reason: decision.selfHeal.reason,
+        attempt: decision.selfHeal.attempt, taskIds: decision.selfHeal.taskIds,
+        outcome: promoted ? 'promoted' : 'needs-human', promotionReason: decomposePromotion.reason }); } catch { /* fail-open */ }
+      if (!promoted) {
+        decision = { ...decision, action: 'stop', stopReason: 'needs-human',
+          decomposable: decision.decomposable.filter((id) => !decision.selfHeal!.taskIds.includes(id)),
+          needsHuman: [...new Set([...decision.needsHuman, ...decision.selfHeal.taskIds])],
+          classifications: decision.classifications.map((classification) => decision.selfHeal!.taskIds.includes(classification.taskId)
+            ? { ...classification, action: 'needs-human' as const } : classification),
+          why: `${decision.selfHeal.reason} (attempt: 1/1) — 분해 승격 실패(${decomposePromotion.reason}); 자동 재실행 없이 사람 확인` };
+      }
+    }
 
     try {
       const walkSummary = results.some((r) => r.walk !== undefined)
@@ -1145,6 +1195,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         kinds: decision.classifications.map((c) => `${c.kind}:${c.action}`),
         decomposePromotionAttempted: decomposePromotion.attempted,
         decomposePromotionReason: decomposePromotion.reason,
+        ...(decision.selfHeal ? { selfHealReason: decision.selfHeal.reason, selfHealAttempt: decision.selfHeal.attempt } : {}),
         ...(decomposePromotion.pieceCount === undefined ? {} : { decomposePieceCount: decomposePromotion.pieceCount }),
         ...(decomposePromotion.dependsOnEdges === undefined ? {} : { decomposeDependsOnEdges: decomposePromotion.dependsOnEdges }),
         ...(decomposePromotion.hotPathEdges === undefined ? {} : { decomposeHotPathEdges: decomposePromotion.hotPathEdges }),
@@ -1188,6 +1239,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
             runId,
             reason: decision.stopReason,
             outcome: persistence.outcome,
+            ...(decision.selfHeal ? { selfHealReason: decision.selfHeal.reason, selfHealAttempt: decision.selfHeal.attempt } : {}),
             ...storageObservation,
           });
         } catch { /* fail-open */ }
@@ -1195,6 +1247,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       if (decision.stopReason && opts.taskAgentShadow !== false) {
         // TASK-AGENT-SHADOW — 판단부를 그림자로 부른다(실행 0). 어떤 오류도 런의 결말을 바꾸지 않는다.
         try {
+          const { recordTaskAgentShadowMove } = await import('../task-agent/shadow.js');
           const pr = results.find((result) => typeof result.prNumber === 'number' && result.prNumber > 0)?.prNumber;
           const reviewed = results.filter((result) => result.prNumber === pr && result.selfReview && result.merged !== true);
           const selfReview = pr && reviewed.length === 1 ? reviewed[0]!.selfReview : undefined;

package/src/self-dev/run-types.ts

@@ -98,7 +98,7 @@ export interface SelfDevJobResult {
   /** Commits this child added against its own `--base`. 0 is not completion progress. */
   commitsAheadOfBase?: number;
   /** A dependency is done but its result is not on main; no child was launched. */
-  blockReason?: 'parent-unlanded' | 'dependency-needs-human';
+  blockReason?: 'parent-unlanded' | 'dependency-needs-human' | 'dependency-deferred';
   parentPrNumber?: number;
   /** The upstream completed in a worktree without opening a PR. */
   parentNoPr?: true;