elanous 0.2.40 → 0.2.42

package/src/self-dev/decompose.ts

@@ -107,7 +107,7 @@ export interface SelfDevDecompositionMeta {
    *  `authored-empty`           Fabric 저작이 분해할 arc를 만들지 못했다
    *  `llm-failed`               LLM 호출 자체가 «실패»했다(타임아웃·제공자 장애) ⇒ 분해를 «못 한» 것이다
    *  ⛔ 「쪼갤 필요가 없었다」와 Fabric 사전분해 실패는 다른 값이다. */
-  outcome: 'decomposed' | 'single-no-subtasks' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
+  outcome: 'decomposed' | 'single-no-subtasks' | 'slice-rejected' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
   /** `llm-failed` 일 때만 실린다 — 문면의 «머리»를 자르지 않는다. */
   error?: string;
   /** Present for Fabric decomposition, including zero, to distinguish no omissions from no report. */
@@ -399,6 +399,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '- SEPARATE DEFINE FROM WIRE: adding a new function/type/export is a SEPARATE task from wiring it into an existing runtime call site. A task that both defines a new symbol AND integrates it across modules tends to leave dead-code (defined but never called) that fails integration gates. Pattern: (a) add the function + its unit test; then (b) a dependent task that wires it into the specific existing call site — name the exact `file.ts:function` to modify.',
     '- Exception to SEPARATE DEFINE FROM WIRE: Keep a definition and its registration/wiring in the same sub-feature — a handler with its route, a command with its CLI registration, a node with its graph/recipe entry.',
     '- Each sub-feature must be a self-contained, mergeable unit of work.',
+    '- LANDABLE SLICE CONTRACT: every sub-feature must state a completionBoundary that can be implemented and verified without a later sub-feature, future component, or unwired operational path. If it cannot stand alone, split it further or omit it.',
+    '- Every sub-feature must name one existing mock scenario as mockScenario.id (MS-01, MS-02, ...), plus a concrete mockScenario.injection and mockScenario.observation. Describe the event or input injected and the output/event that proves the slice works.',
+    '- List every required earlier slice explicitly in dependsOn. An empty list means this slice has no predecessor; never rely on implicit order or a future capability.',
+    '- Declare futureAssumptions as an array. If the slice needs any future component, later slice, or unwired operational path, list it there; that slice will be rejected with a decompose.slice-rejected event containing its id and reason, and must be split or omitted.',
     '- `dependsOn`: list the `id`s of sub-features that MUST land first (e.g. a shared',
     '  type/interface before its consumers). Independent sub-features share NO dependency',
     '  so they run in parallel. No cycles.',
@@ -410,8 +414,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '',
     '## Output (STRICT JSON — no prose, no code fence)',
     '{"subtasks":[{"id":"<short-slug>","feature":"<imperative sub-feature text>",',
-    '  "dependsOn":["<id>",...],"hotPaths":["<path>",...],',
-    '  "goalType":"<implement|research|document|operate>"}]}',
+    '  "completionBoundary":"<standalone change and observable outcome>",',
+    '  "mockScenario":{"id":"MS-01","injection":"<input/event injected>","observation":"<output/event observed>"},',
+    '  "futureAssumptions":[],"dependsOn":["<explicit predecessor id>",...],',
+    '  "hotPaths":["<path>",...],"goalType":"<implement|research|document|operate>"}]}',
   ].join('\n');
 }
 
@@ -421,6 +427,19 @@ interface RawSubtask {
   dependsOn?: unknown;
   hotPaths?: unknown;
   goalType?: unknown;
+  completionBoundary?: unknown;
+  mockScenario?: unknown;
+  futureAssumptions?: unknown;
+}
+
+interface RejectedDecompositionSlice {
+  id: string | null;
+  reasons: string[];
+}
+
+interface ValidatedDecomposition {
+  goals: SelfDevGoal[];
+  rejected: RejectedDecompositionSlice[];
 }
 
 const SELF_DEV_GOAL_TYPES = new Set(['implement', 'research', 'document', 'operate'] as const);
@@ -625,6 +644,90 @@ export function parseSelfDevDecomposition(
   return goals;
 }
 
+/** Parse the production decomposition contract and keep a reason for each rejected slice. */
+function parseValidatedSelfDevDecomposition(
+  subtasks: readonly unknown[],
+  defaults: { base?: string; autoMerge?: boolean },
+): ValidatedDecomposition {
+  const goals: SelfDevGoal[] = [];
+  const rejected: RejectedDecompositionSlice[] = [];
+  const allIds = new Set(subtasks.flatMap((value) => isRawSubtask(value)
+    && typeof value.id === 'string' && value.id.trim() ? [value.id.trim()] : []));
+  const seenIds = new Set<string>();
+
+  subtasks.forEach((value, index) => {
+    if (!isRawSubtask(value)) {
+      rejected.push({ id: null, reasons: ['slice must be an object'] });
+      return;
+    }
+    const feature = typeof value.feature === 'string' ? value.feature.trim() : '';
+    const id = typeof value.id === 'string' && value.id.trim() ? value.id.trim() : String(index);
+    const reasons: string[] = [];
+    const completionBoundary = typeof value.completionBoundary === 'string' ? value.completionBoundary.trim() : '';
+    if (!feature) reasons.push('feature is missing');
+    if (!completionBoundary) reasons.push('completionBoundary is missing');
+
+    const mock = value.mockScenario as { id?: unknown; injection?: unknown; observation?: unknown } | undefined;
+    const scenarioId = typeof mock?.id === 'string' ? mock.id.trim() : '';
+    const injection = typeof mock?.injection === 'string' ? mock.injection.trim() : '';
+    const observation = typeof mock?.observation === 'string' ? mock.observation.trim() : '';
+    if (!/^MS-[A-Z0-9][A-Z0-9-]*$/i.test(scenarioId)) reasons.push('mockScenario.id must be an MS id');
+    if (!injection) reasons.push('mockScenario.injection is missing');
+    if (!observation) reasons.push('mockScenario.observation is missing');
+
+    if (!Array.isArray(value.futureAssumptions)) reasons.push('futureAssumptions must be declared as an array');
+    else if (value.futureAssumptions.length > 0) reasons.push('future assumptions require split or omission');
+
+    if (value.dependsOn === undefined) reasons.push('dependsOn is missing; declare an explicit id array');
+    else if (!Array.isArray(value.dependsOn)) reasons.push('dependsOn must be an explicit id array');
+    const dependsOn = Array.isArray(value.dependsOn)
+      ? value.dependsOn.filter((dependency): dependency is string => typeof dependency === 'string' && dependency.trim().length > 0)
+      : [];
+    if (Array.isArray(value.dependsOn) && dependsOn.length !== value.dependsOn.length) reasons.push('dependsOn contains an invalid predecessor id');
+    for (const dependency of dependsOn) {
+      if (dependency === id || !allIds.has(dependency)) reasons.push(`dependsOn references a missing or self predecessor: ${dependency}`);
+    }
+
+    let uniqueId = id;
+    if (seenIds.has(uniqueId)) uniqueId = `${uniqueId}-${index}`;
+    seenIds.add(uniqueId);
+    if (reasons.length) {
+      rejected.push({ id, reasons: [...new Set(reasons)] });
+      return;
+    }
+
+    const llmHot = Array.isArray(value.hotPaths)
+      ? value.hotPaths.filter((path): path is string => typeof path === 'string')
+      : [];
+    const hotPaths = [...new Set([...llmHot, ...inferHotPaths(feature)])];
+    goals.push({
+      id: uniqueId,
+      feature,
+      completionBoundary,
+      mockScenario: { id: scenarioId, injection, observation },
+      ...(dependsOn.length ? { dependsOn } : {}),
+      ...(hotPaths.length ? { hotPaths } : {}),
+      ...(isSelfDevGoalType(value.goalType) ? { goalType: value.goalType } : {}),
+      ...defaults,
+    });
+  });
+
+  // A dependent slice cannot stay independently landable when its predecessor was rejected.
+  let removedDependent = true;
+  while (removedDependent) {
+    removedDependent = false;
+    const validIds = new Set(goals.map((goal) => goal.id));
+    for (const goal of [...goals]) {
+      const missing = (goal.dependsOn ?? []).filter((dependency) => !validIds.has(dependency));
+      if (missing.length === 0) continue;
+      goals.splice(goals.indexOf(goal), 1);
+      rejected.push({ id: goal.id ?? null, reasons: [`dependsOn references a rejected predecessor: ${missing.join(', ')}`] });
+      removedDependent = true;
+    }
+  }
+  return { goals, rejected };
+}
+
 /**
  * Decompose a feature into a self-dev DAG via the LLM seam. Falls back to
  * a single goal (the whole feature) when decomposition yields nothing —
@@ -710,10 +813,21 @@ export async function decomposeSelfDevGoal(
   const rawSubtasks = extractRawSubtasks(raw);
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
-  const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
+  const validated = parseValidatedSelfDevDecomposition(rawSubtasks.slice(0, hardMaxTasks), defaults);
+  for (const rejection of validated.rejected) {
+    debug.log(opts.observation?.category ?? 'self-dev.decompose', 'decompose.slice-rejected', {
+      ...observationIdentity(opts.observation ?? {}),
+      sliceId: rejection.id,
+      reasons: rejection.reasons,
+    }, { level: 'warn' });
+  }
+  const parsedGoals = validated.goals;
   const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
   const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
+  const finalDecomposition = parsedGoals.length === 0 && validated.rejected.length > 0
+    ? { ...decomposition, outcome: 'slice-rejected' as const }
+    : decomposition;
+  return finalizeDecomposition(feature, goals, finalDecomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */

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

@@ -25,8 +25,7 @@ import { inspectDecisionObservations, inspectDecisionSignalKinds, inspectDecisio
 import type { EvidenceMode } from '../agent-mission/driver.js';
 import type { PreparedDevWorktree } from '../harness/harness-worktree-auto.js';
 import type { ChildLlmEffort, ChildLlmSelection } from '../agent/run-context.js';
-import { reasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
-import type { ReasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
+import { reasoningEffortCeiling, childLlmEffortProblem, type ReasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
 import { tierModel } from '../llm/model-defaults.js';
 import { LLM_TIER_MAP_BY_PROVIDER } from '../model-tier/llm-tier-map.js';
 import { MODEL_TIERS } from '../model-tier/types.js';
@@ -225,6 +224,10 @@ export interface DevSelfRunSuperviseOptions {
   queryTerminalRunStatuses?: (runIds: readonly string[], timeoutMs: number) => Readonly<Record<string, string>> | undefined;
   nowMs?: () => number;
   printDecision?: (line: string) => void;
+  /** Test-only supervisor side-effect seams. */
+  taskAgentShadow?: false;
+  taskAgentRejudge?: false;
+  sweepPendingMerges?: typeof import('../self-implement/frozen-merges.js').sweepFrozenMerges;
 }
 
 export interface DevSelfRunExecution {
@@ -1047,8 +1050,11 @@ export async function executeDevSelfRun(
     executedRounds = 1;
     if (!supervise) return { result };
 
-    const asSupervisorJobResult = (currentFeature: string, current: SelfImplementResult) => singleRunAsJobResult(currentFeature, current);
-    const initialJob = singleRunAsJobResult(feature, result);
+    const reasonRepairEnabled = getUserConfig().tools.selfImplement.supervisor?.reasonRepair === true
+      && supervise.executePiece !== undefined;
+    const asSupervisorJobResult = (currentFeature: string, current: SelfImplementResult) =>
+      singleRunAsJobResult(currentFeature, current, reasonRepairEnabled);
+    const initialJob = singleRunAsJobResult(feature, result, reasonRepairEnabled);
     const wiring = supervise.deliverableDocument === undefined
       ? undefined
       : buildDeliverableTargets(supervise.deliverableDocument, ['single'], 'all', '127.0.0.1');
@@ -1113,11 +1119,15 @@ export async function executeDevSelfRun(
     }
     await superviseRun({
       initial: [initialJob],
+      ...(supervise.taskAgentShadow === false ? { taskAgentShadow: false } : {}),
+      ...(supervise.taskAgentRejudge === false ? { taskAgentRejudge: false } : {}),
+      ...(supervise.sweepPendingMerges ? { sweepPendingMerges: supervise.sweepPendingMerges } : {}),
       // Pod worktree paths are not necessarily mounted in this parent process.
       knowhowRepo: process.cwd(),
       // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
       // authored goal as its feature). Without that executor the rerun could only replay the same goal — declare false.
       repairGoalExecution: supervise.executePiece !== undefined,
+      needsHumanReasonRepairExecution: reasonRepairEnabled,
       enrich: (results) => hydrateDevGoalCauseObserved(
         hydrateDevDecomposeProposals(results, supervise.readProposals ?? readDecomposeProposals),
       ),
@@ -1578,7 +1588,7 @@ export function __resetStaleOpenRouterSnapshotWarningForTests(): void {
   staleOpenRouterSnapshotWarned = false;
 }
 
-export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+export { CHILD_LLM_EFFORT_LADDER } from '../intelligence-map/model-catalog.js';
 
 export function childLlmEffortCeiling(_provider: string, model: string): ReasoningEffortCeiling {
   return reasoningEffortCeiling(resolveModelAlias(model.trim()) ?? model.trim());
@@ -1588,20 +1598,10 @@ export function resolveChildLlmEffort(
   provider: string, model: string, entered: string,
 ): { effort: ChildLlmEffort; ceiling: ReasoningEffortCeiling } {
   const value = entered.trim().toLowerCase();
-  const ladder: readonly string[] = CHILD_LLM_EFFORT_LADDER;
-  if (!ladder.includes(value)) {
-    throw new DevPipelineError(`--child-llm-effort 알 수 없음: ${entered} · 후보: ${CHILD_LLM_EFFORT_LADDER.join(', ')}`);
-  }
+  const problem = childLlmEffortProblem(model, entered);
+  if (problem) throw new DevPipelineError(problem);
   const effort = value as ChildLlmEffort;
   const ceiling = childLlmEffortCeiling(provider, model);
-  if (ceiling === 'none') {
-    throw new DevPipelineError(`--child-llm-effort 거부: ${model} 은 추론 노력을 «안 받는다»(ceiling=none)`);
-  }
-  if (ladder.indexOf(effort) > ladder.indexOf(ceiling)) {
-    throw new DevPipelineError(
-      `--child-llm-effort 거부: ${effort} 가 ${model} 의 상한(${ceiling})을 넘는다`,
-    );
-  }
   return { effort, ceiling };
 }
 

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

@@ -55,6 +55,19 @@ export function resetFrontVisitCountsForTesting(now?: () => number): void {
   lastFrontVisitPruneMs = Number.NEGATIVE_INFINITY;
 }
 
+/** Explicit context carried by a front-node handler. The same object can grow to
+ *  hold authoring evidence and budget/checkpoint data without changing handlers. */
+export interface FrontNodeUnitContext {
+  readonly runId?: string;
+  readonly goalType?: GoalType;
+}
+
+/** A front-half processing unit with an explicit input, context, and output. */
+export interface FrontNodeUnit<Input, Output> {
+  readonly node: FrontNodeId;
+  readonly execute: (input: Input, context: FrontNodeUnitContext) => Promise<Output>;
+}
+
 /** 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 => {
@@ -74,6 +87,16 @@ export async function observeFrontNodeUnit<T>(node: FrontNodeId, runId: string |
   finally { emit('exit'); }
 }
 
+/** Execute one typed front-node unit while preserving the caller's context and
+ *  the fail-soft graph.unit observation contract. */
+export function runFrontNodeUnit<Input, Output>(
+  unit: FrontNodeUnit<Input, Output>,
+  input: Input,
+  context: FrontNodeUnitContext,
+): Promise<Output> {
+  return observeFrontNodeUnit(unit.node, context.runId, context.goalType, () => unit.execute(input, context));
+}
+
 function pruneIdleFrontVisitRuns(nowMs: number): void {
   if (nowMs - lastFrontVisitPruneMs < FRONT_VISIT_PRUNE_INTERVAL_MS) return;
   lastFrontVisitPruneMs = nowMs;

package/src/self-dev/launch-preflight-text.ts

@@ -1,3 +1,5 @@
+import { parseTargetPathHintLine } from '../release-loop/checklist-target-path-hint.js';
+
 export type WorktreePathTouchAxis = 'touched' | 'untouched' | 'unreadable';
 
 /** 겹친 경로가 실제로 손대어졌는지의 읽기 전용 관측. */
@@ -534,15 +536,12 @@ export interface AskTargetPathHintsParseResult {
 }
 
 export function parseAskTargetPathHintsResult(askText: string): AskTargetPathHintsParseResult {
-  // ⛔ 첫 «비어 있지 않은» 줄만 본다 — 본문 전체를 훑으면 산문 속 경로까지 끌려와 오탐이 된다.
-  const firstLine = askText.split(/\r?\n/).find((line) => line.trim() !== '');
-  if (firstLine === undefined) return { paths: [], rejected: [], labelMissing: true };
-  const match = /^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]\s*(.*)$/i.exec(firstLine);
-  if (!match) return { paths: [], rejected: [], labelMissing: true };
+  const parsed = parseTargetPathHintLine(askText);
+  if (parsed.labelMissing) return { paths: [], rejected: [], labelMissing: true };
 
   const paths: string[] = [];
   const rejected: AskTargetPathHintRejection[] = [];
-  for (const fragment of match[1]!.split(/[·,]/)) {
+  for (const fragment of parsed.fragments) {
     const piece = fragment.trim().replace(/^`+|`+$/g, '');
     if (piece === '') rejected.push({ fragment, reason: 'empty' });
     // ⛔ 「경로처럼 생긴 것」만 남긴다 — 확장자나 디렉터리 구분자가 있어야 한다.

package/src/self-dev/launch-preflight.ts

@@ -695,7 +695,7 @@ export interface AskPreflightDeps {
   /** 던지면 그 축은 `unknown` 이 된다. */
   readonly listUnfinishedRuns: (path?: string) => readonly PreflightUnfinishedRun[];
   /** 실제 실행 확신 판정. 기본은 테스트 우주까지 포함한 `queryRunningRuns`이며, 실패는 경고 한 줄로만 남긴다. */
-  readonly queryRunningRuns?: (options: { includeTest: true }) => RunningRunsResult;
+  readonly queryRunningRuns?: (options: { includeTest: true; timeBudgetMs?: number }) => RunningRunsResult;
   /** 이미 완료된 런 조회. `plannedPaths`는 원장 정규화 결과라 경로 겹침 판정에 재사용한다. */
   readonly listCompletedRuns?: (limit: number, paths?: string | readonly string[]) => PreflightCompletedRunsQuery;
   /** 이미 종료된 중단 런 조회. `plannedPaths`는 원장 정규화 결과라 경로 겹침 판정에 재사용한다. */
@@ -1019,9 +1019,14 @@ export type RunningRunsConfidenceAssessment =
     readonly includesTest: true;
   };
 
-export function assessRunningRunsConfidence(query: (options: { includeTest: true }) => RunningRunsResult, nowMs: number = Date.now()): RunningRunsConfidenceAssessment {
+const LAUNCH_PREFLIGHT_RUNNING_RUNS_BUDGET_MS = 3_000;
+
+export function assessRunningRunsConfidence(query: (options: { includeTest: true; timeBudgetMs?: number }) => RunningRunsResult, nowMs: number = Date.now()): RunningRunsConfidenceAssessment {
   try {
-    const running = query({ includeTest: true });
+    const running = query({ includeTest: true, timeBudgetMs: LAUNCH_PREFLIGHT_RUNNING_RUNS_BUDGET_MS });
+    if (running.stalled) {
+      throw new Error(`조회 예산 초과(${running.stalled.stage}: ${running.stalled.reason})`);
+    }
     const confirmedCount = running.counts.running;
     const probableCount = running.counts['probable-running'];
     if (!Number.isSafeInteger(confirmedCount) || confirmedCount < 0 || !Number.isSafeInteger(probableCount) || probableCount < 0) {
@@ -1055,7 +1060,7 @@ export function assessRunningRunsConfidence(query: (options: { includeTest: true
 }
 
 /** 나이 기반 기존 집계와 별도로 실제 PTY·원장을 교차한 확신 판정을 사람이 읽는 한 줄로 만든다. */
-export function renderRunningRunsConfidenceAppendix(query: (options: { includeTest: true }) => RunningRunsResult, nowMs: number = Date.now()): string {
+export function renderRunningRunsConfidenceAppendix(query: (options: { includeTest: true; timeBudgetMs?: number }) => RunningRunsResult, nowMs: number = Date.now()): string {
   return assessRunningRunsConfidence(query, nowMs).appendix;
 }
 

package/src/self-dev/orchestrate.ts

@@ -147,6 +147,16 @@ function shardIdentityFeature(feature: string, identity: SelfDevShardIdentity |
     : `${feature}\n\n## Shard identity\n${JSON.stringify(identity)}`;
 }
 
+function selfDevGoalFeature(goal: SelfDevGoal): string {
+  const { completionBoundary, mockScenario } = goal;
+  const acceptance: string[] = [];
+  if (completionBoundary?.trim()) acceptance.push(`Completion boundary: ${completionBoundary.trim()}`);
+  if (mockScenario?.id?.trim()) acceptance.push(`Mock scenario: ${mockScenario.id.trim()}`);
+  if (mockScenario?.injection?.trim()) acceptance.push(`Injection: ${mockScenario.injection.trim()}`);
+  if (mockScenario?.observation?.trim()) acceptance.push(`Observation: ${mockScenario.observation.trim()}`);
+  return acceptance.length ? `${goal.feature}\n\n## Slice acceptance\n${acceptance.join('\n')}` : goal.feature;
+}
+
 const SHARD_WORKING_MEMORY_EMIT_HINT =
   '\n\n## Working-memory handoff\nA downstream shard depends on this work. Before your final response, emit the following marker and one JSON object so it can reuse your findings. Put reusable boundaries in `reusables` and your key choices in `decisions`; use empty arrays when there are none.\n[WORKING-MEMORY]\n{"reusables":[],"decisions":[],"summary":"What this shard established for downstream work."}';
 
@@ -1236,7 +1246,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     surfaceKind: 'self-implement',
     surface: (goal) => ({
       kind: 'self-implement',
-      feature: goal.feature,
+      feature: selfDevGoalFeature(goal),
       ...(goal.after !== undefined ? { after: goal.after } : {}),
       ...(goal.base !== undefined ? { base: goal.base } : {}),
       ...(goal.autoMerge !== undefined ? { autoMerge: goal.autoMerge } : {}),
@@ -1386,7 +1396,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
       const task = graph.getTask(taskId);
       if (task?.surface.kind === 'self-implement') {
         graph.updateTask(taskId, {
-          surface: { ...task.surface, feature: shardIdentityFeature(shard.goal.feature, identity) },
+          surface: { ...task.surface, feature: shardIdentityFeature(selfDevGoalFeature(shard.goal), identity) },
         }, { now: now() });
       }
     }
@@ -1529,6 +1539,9 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(!cancelling && disp?.stopReason ? { stopReason: disp.stopReason } : {}),
           ...(disp?.completionDisposition ? { completionDisposition: disp.completionDisposition } : {}),
           ...(disp?.failureClassification ? { failureClassification: disp.failureClassification } : {}),
+          ...(disp?.childEvidence?.classificationBasis ? { classificationBasis: disp.childEvidence.classificationBasis } : {}),
+          ...(typeof disp?.childEvidence?.terminationReason === 'string'
+            ? { terminationReason: disp.childEvidence.terminationReason } : {}),
           ...(disp?.providerErrors ? { providerErrors: disp.providerErrors } : {}),
           ...(disp?.rework ? { rework: disp.rework } : {}),
           ...(disp?.mustFix ? { reviewMustFix: disp.mustFix } : {}),
@@ -1542,7 +1555,17 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     };
 
     // S3 — persist a resumable checkpoint after each job settles (fail-soft).
+    let checkpointRound = 0;
     const doCheckpoint = (): void => {
+      checkpointRound++;
+      const progressResults = buildResults();
+      const progress = summarizeResults(progressResults);
+      const remaining = Math.max(0, progressResults.length - progress.done - progress.failed - progress.cancelled);
+      try { debug.log('self-dev.orchestrate', 'progress', {
+        runId: runId ?? null, round: checkpointRound, total: progressResults.length,
+        done: progress.done, failed: progress.failed, cancelled: progress.cancelled,
+        landed: progress.landed, remaining,
+      }); } catch { /* progress observation must not change orchestration */ }
       if (opts.checkpoint) { try { opts.checkpoint(buildResults()); } catch { /* fail-soft */ } }
       if (opts.onSnapshot) { try { opts.onSnapshot(graph.snapshot().tasks); } catch { /* fail-soft */ } }
     };
@@ -1559,6 +1582,8 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
             stage: result.stage ?? null,
             mergeReason: result.mergeReason ?? null,
             failureClassification: result.failureClassification ?? null,
+            classificationBasis: result.classificationBasis ?? null,
+            terminationReason: result.terminationReason ?? null,
             prNumber: result.prNumber ?? null,
           });
         } catch { /* terminal observation must not change the result */ }

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

@@ -230,6 +230,7 @@ export async function runSubscriptionReviewer(
 }
 
 export type ReviewFailureReason =
+  | 'credentials-unavailable'
   | 'overloaded'
   | 'rate-limited'
   | 'server-error'
@@ -238,11 +239,17 @@ export type ReviewFailureReason =
   | 'unknown-model-provider'
   | 'other';
 
-export type ReviewFallbackReason = Extract<ReviewFailureReason, 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
+export type ReviewFallbackReason = Extract<ReviewFailureReason, 'credentials-unavailable' | 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
 
 /** 실패 사유는 집계 가능한 유한 값으로 남긴다. */
 export function classifyReviewProviderFailure(message: string): ReviewFailureReason {
   const m = message.toLowerCase();
+  // Credential absence is provider-local: move to the next configured provider, then let the caller
+  // preserve its current artifact if every configured provider is keyless.
+  if ((m.includes('unavailable') && /(api\s*key|credentials?)/.test(m))
+    || /configure\s+(?:an?\s+)?api\s*key/.test(m)
+    || /(?:missing|no)\s+(?:provider\s+)?(?:api\s*)?key\b/.test(m)
+    || /credentials?\s+(?:are\s+)?unavailable/.test(m)) return 'credentials-unavailable';
   // ⭐ 실물 문면을 먼저 둔다 — `#10069` 가 낸 그 문장이다.
   if (m.includes('overloaded') || m.includes('server_overloaded')) return 'overloaded';
   if (m.includes('rate limit') || m.includes('rate_limit') || m.includes('429')) return 'rate-limited';
@@ -253,7 +260,7 @@ export function classifyReviewProviderFailure(message: string): ReviewFailureRea
 }
 
 function isReviewFallbackReason(reason: ReviewFailureReason): reason is ReviewFallbackReason {
-  return reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
+  return reason === 'credentials-unavailable' || reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
 }
 
 export interface ReviewProviderAttempt {