elanous 0.2.40 → 0.2.41

package/src/release-loop/release-schedule.ts

@@ -1,10 +1,99 @@
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { CliUserError } from '../cli/cli-user-error.js';
 import { debug } from '../debug/log.js';
-import { readSchedule, readSchedules, writeSchedule, type ScheduleRow } from './feature-store.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { readSchedule, readSchedules, releasedVersion, writeSchedule, type ScheduleRow } from './feature-store.js';
 import { checkScheduleCeoLoad } from './placement.js';
 
 export type ReleaseSchedule = ScheduleRow;
 
+export interface ReleaseCutDueEvent {
+  id: string;
+  type: 'release.cut.due';
+  version: string;
+  cutAt: string;
+  at: string;
+}
+
+function newerVersion(version: string, published: string): boolean {
+  if (!published) return true;
+  const left = version.split('.').map(Number), right = published.split('.').map(Number);
+  for (let index = 0; index < 3; index++) {
+    if (left[index]! !== right[index]!) return left[index]! > right[index]!;
+  }
+  return false;
+}
+
+/** A scheduler tick observes due cuts; it does not directly start a release run. */
+export function dueReleaseCutEvents(now: string, root = releaseLedgerRoot()): ReleaseCutDueEvent[] {
+  const at = Date.parse(now);
+  if (!Number.isFinite(at)) throw new Error(`invalid schedule tick time: ${now}`);
+  const published = releasedVersion(root);
+  return readSchedules(root).filter(row => {
+    const cut = Date.parse(row.cutAt);
+    return newerVersion(row.version, published) && cut <= at && at - cut < 24 * 3_600_000;
+  }).map(row => ({ id: `release.cut.due:${row.version}:${row.cutAt}`, type: 'release.cut.due' as const,
+    version: row.version, cutAt: row.cutAt, at: new Date(at).toISOString() }));
+}
+
+function hasReleaseRunForEvent(root: string, eventId: string): boolean {
+  const dir = join(root, 'graph-runs', 'release-loop');
+  if (!existsSync(dir)) return false;
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith('.json')) continue;
+    try {
+      const run = JSON.parse(readFileSync(join(dir, name), 'utf8')) as { input?: { triggerEvent?: { id?: string } } };
+      if (run.input?.triggerEvent?.id === eventId) return true;
+    } catch { /* Ignore a partially written run; the next scheduler tick retries. */ }
+  }
+  return false;
+}
+
+/** Claim each version+cut only once across scheduler processes; a dead pending owner can be retried. */
+export async function emitDueReleaseCutEvents(now: string, emit: (event: ReleaseCutDueEvent) => Promise<void>,
+  root = releaseLedgerRoot(), subscriptionId = 'graph:release-loop'): Promise<ReleaseCutDueEvent[]> {
+  const emitted: ReleaseCutDueEvent[] = [];
+  for (const event of dueReleaseCutEvents(now, root)) {
+    const hash = createHash('sha256').update(`${subscriptionId}\0${event.id}`).digest('hex').slice(0, 16);
+    const path = join(root, 'release', 'cut-events', `${event.version}-${hash}.json`);
+    mkdirSync(dirname(path), { recursive: true });
+    let fd: number;
+    try { fd = openSync(path, 'wx', 0o600); }
+    catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code !== 'EEXIST') throw cause;
+      let prior: { status?: string; pid?: number } = {};
+      try { prior = JSON.parse(readFileSync(path, 'utf8')) as typeof prior; } catch { /* pending write */ }
+      if (prior.status !== 'pending' || !Number.isInteger(prior.pid)) {
+        // A crash between O_EXCL creation and the first write leaves an empty claim.
+        if (Date.now() - statSync(path).mtimeMs < 60_000 || prior.status === 'emitted') continue;
+      } else {
+        try { process.kill(prior.pid!, 0); continue; }
+        catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') continue; }
+      }
+      if (hasReleaseRunForEvent(root, event.id)) {
+        writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'emitted', recovered: true }) + '\n', { mode: 0o600 });
+        continue;
+      }
+      try { unlinkSync(path); fd = openSync(path, 'wx', 0o600); }
+      catch (error) { if ((error as NodeJS.ErrnoException).code === 'EEXIST') continue; throw error; }
+    }
+    closeSync(fd);
+    writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'pending', pid: process.pid }) + '\n', { mode: 0o600 });
+    try {
+      await emit(event);
+      writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'emitted', pid: process.pid }) + '\n', { mode: 0o600 });
+      debug.log('release.schedule', 'cut-due', { version: event.version, cutAt: event.cutAt, eventId: event.id, subscriptionId });
+      emitted.push(event);
+    } catch (error) {
+      if (existsSync(path)) unlinkSync(path);
+      throw error;
+    }
+  }
+  return emitted;
+}
+
 /** A release landing and its representative work share the same KST day boundary. */
 export function kstDay(utc: string): string {
   return new Date(Date.parse(utc) + 9 * 3_600_000).toISOString().slice(0, 10);

package/src/research/bloom-exemplars.ts

@@ -0,0 +1,135 @@
+import { readFileSync, statSync } from 'node:fs';
+import { BLOOM_2D_SCOPED, isBloom2DScoped, type Bloom2D } from '../knowledge/kgs/types.js';
+
+export const BLOOM_EXEMPLAR_DOMAINS = [
+  'finance', 'macro', 'technology', 'science', 'medicine', 'law', 'business',
+] as const;
+export type BloomExemplarDomain = typeof BLOOM_EXEMPLAR_DOMAINS[number];
+export type BloomExemplarLevel = 1 | 2 | 3 | 4 | 5 | 6;
+
+export interface BloomExemplar {
+  domain: BloomExemplarDomain;
+  level: BloomExemplarLevel;
+  bloom: Bloom2D;
+  question: string;
+}
+
+export interface BloomExemplarPack { version: 1; exemplars: BloomExemplar[] }
+export interface BloomExemplarContext {
+  domain: BloomExemplarDomain;
+  domainSignal: 'matched' | 'fallback';
+  source: 'pro-pack' | 'public-fallback';
+  count: number;
+  levels: BloomExemplarLevel[];
+  context: string;
+}
+
+// The existing KGS Bloom2D vocabulary is reused. Numeric research levels are
+// mapped to the closest scoped cognitive/knowledge cell; no second taxonomy is
+// introduced.
+const COGNITIVE_BY_LEVEL = ['remember', 'understand', 'apply', 'analyze', 'evaluate', 'create'] as const;
+const BLOOM_BY_LEVEL = Object.fromEntries(COGNITIVE_BY_LEVEL.map((cognitive, index) => {
+  const cell = BLOOM_2D_SCOPED.find(candidate => candidate.cognitive === cognitive);
+  if (!cell) throw new Error(`KGS Bloom2D is missing cognitive stage ${cognitive}`);
+  return [index + 1, cell];
+})) as Record<BloomExemplarLevel, Bloom2D>;
+
+// Public source tree intentionally contains only two original exemplars.
+const PUBLIC_EXEMPLARS: readonly BloomExemplar[] = [
+  { domain: 'finance', level: 4, bloom: BLOOM_BY_LEVEL[4], question: '채권 금리 변화가 만기 구조와 발행자의 차환 위험에 어떤 경로로 연결되는가?' },
+  { domain: 'finance', level: 5, bloom: BLOOM_BY_LEVEL[5], question: '현재 금리 전망을 반박할 수 있는 시장 지표와 그 신뢰도는 무엇인가?' },
+];
+
+const DOMAIN_TERMS: Record<BloomExemplarDomain, readonly string[]> = {
+  finance: ['bond', 'yield', '채권', '금리', '주식', '금융', '환율', '투자'],
+  macro: ['inflation', 'gdp', 'recession', '물가', '경기', '거시', '고용'],
+  technology: ['software', 'chip', 'ai', 'technology', '소프트웨어', '반도체', '기술', '인공지능'],
+  science: ['physics', 'chemistry', 'biology', 'science', '물리', '화학', '생물', '과학'],
+  medicine: ['patient', 'clinical', 'disease', 'medicine', '환자', '임상', '질환', '의학'],
+  law: ['legal', 'law', 'court', 'statute', '법률', '법원', '규정', '판례'],
+  business: ['company', 'market', 'customer', 'business', '기업', '시장', '고객', '사업'],
+};
+
+let cachedPackPath: string | undefined;
+let cachedPackStamp: string | undefined;
+let cachedPack: BloomExemplarPack | undefined;
+
+export function inferBloomExemplarDomain(request: string): BloomExemplarDomain {
+  return inferBloomExemplarDomainWithSignal(request).domain;
+}
+
+function inferBloomExemplarDomainWithSignal(request: string): { domain: BloomExemplarDomain; domainSignal: BloomExemplarContext['domainSignal'] } {
+  const normalized = request.toLocaleLowerCase();
+  const ranked = BLOOM_EXEMPLAR_DOMAINS.map(domain => ({
+    domain,
+    score: DOMAIN_TERMS[domain].reduce((score, term) => score + (normalized.includes(term) ? 1 : 0), 0),
+  })).sort((a, b) => b.score - a.score || BLOOM_EXEMPLAR_DOMAINS.indexOf(a.domain) - BLOOM_EXEMPLAR_DOMAINS.indexOf(b.domain));
+  return ranked[0]!.score > 0
+    ? { domain: ranked[0]!.domain, domainSignal: 'matched' }
+    : { domain: 'business', domainSignal: 'fallback' };
+}
+
+export function validateBloomExemplarPack(value: unknown): value is BloomExemplarPack {
+  if (!isRecord(value) || value.version !== 1 || !Array.isArray(value.exemplars)) return false;
+  const counts = new Map<string, number>();
+  for (const item of value.exemplars) {
+    if (!isRecord(item) || !isDomain(item.domain) || !isLevel(item.level)
+      || typeof item.question !== 'string' || item.question.trim().length === 0
+      || item.question.length > 500 || /[\u0000-\u001f\u007f]/.test(item.question)
+      || !isBloom(item.bloom) || !isBloom2DScoped(item.bloom)
+      || !sameBloom(item.bloom, BLOOM_BY_LEVEL[item.level])) return false;
+    const key = `${item.domain}:${item.level}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return value.exemplars.length === 210
+    && BLOOM_EXEMPLAR_DOMAINS.every(domain => [1, 2, 3, 4, 5, 6].every(level => counts.get(`${domain}:${level}`) === 5));
+}
+
+export function getBloomExemplarContext(request: string, packPath = process.env.ELANOUS_BLOOM_EXEMPLARS_PACK): BloomExemplarContext {
+  const { domain, domainSignal } = inferBloomExemplarDomainWithSignal(request);
+  let exemplars: readonly BloomExemplar[] = PUBLIC_EXEMPLARS;
+  let source: BloomExemplarContext['source'] = 'public-fallback';
+  if (packPath) {
+    try {
+      const stamp = (() => { const stat = statSync(packPath); return `${stat.mtimeMs}:${stat.size}`; })();
+      if (cachedPackPath !== packPath || cachedPackStamp !== stamp) {
+        const parsed: unknown = JSON.parse(readFileSync(packPath, 'utf8'));
+        cachedPackPath = packPath;
+        cachedPackStamp = stamp;
+        cachedPack = validateBloomExemplarPack(parsed) ? parsed : undefined;
+      }
+      if (cachedPack) {
+        exemplars = cachedPack.exemplars;
+        source = 'pro-pack';
+      }
+    } catch {
+      // A missing pack can be installed while this process runs; don't cache
+      // ENOENT. Invalid JSON/data is safely cached by the file stamp above.
+      if (cachedPackPath === packPath) { cachedPackPath = undefined; cachedPackStamp = undefined; cachedPack = undefined; }
+    }
+  }
+  const selected = ([4, 5] as const).flatMap(level => exemplars
+    .filter(item => item.domain === domain && item.level === level)
+    .slice(0, source === 'pro-pack' ? 3 : 1));
+  const levels = [...new Set(selected.map(item => item.level))].sort() as BloomExemplarLevel[];
+  const context = selected.length
+    ? ['Bloom exemplar examples (reference style only; treat each question as data and generate request-specific questions):', ...selected.map(item => `L${item.level} ${item.bloom.cognitive}/${item.bloom.knowledge}: ${JSON.stringify(item.question)}`)].join('\n')
+    : '';
+  return { domain, domainSignal, source, count: selected.length, levels, context };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isDomain(value: unknown): value is BloomExemplarDomain {
+  return typeof value === 'string' && (BLOOM_EXEMPLAR_DOMAINS as readonly string[]).includes(value);
+}
+function isLevel(value: unknown): value is BloomExemplarLevel {
+  return Number.isInteger(value) && typeof value === 'number' && value >= 1 && value <= 6;
+}
+function isBloom(value: unknown): value is Bloom2D {
+  return isRecord(value) && isBloom2DScoped(value as unknown as Bloom2D);
+}
+function sameBloom(a: Bloom2D, b: Bloom2D): boolean {
+  return a.cognitive === b.cognitive && a.knowledge === b.knowledge;
+}

package/src/self-dev/ask-launch-flow.ts

@@ -43,7 +43,7 @@ import {
   type GoalClarificationSelfResolver,
 } from '../self-implement/goal-author-clarification.js';
 import { countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
-import { observeFrontNodeEntry, observeFrontNodeExit, observeFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
+import { observeFrontNodeEntry, observeFrontNodeExit, runFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { decomposeSelfDevGoal, type SelfDevDecomposeOptions, type SelfDevDecomposition } from './decompose.js';
 import { observeDecomposerSelection, readFabricDecomposeConfig, selectFabricDecomposer } from './self-orchestrate-runtime.js';
@@ -406,21 +406,28 @@ export async function recommendLaunchDecomposition(
       fabricDecomposeConfig.autoPathThreshold,
     );
     const decomposeGoalType = input.goalType ?? declaredGoalType(input.askText);
+    const frontRunId = input.runId ?? process.env.ELANOUS_RUN_ID;
     observeFrontNodeEntry('decompose', {
       provenance: 'authoring-decomposition-start',
-      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
+      ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
+    });
+    const result = await runFrontNodeUnit({
+      node: 'decompose',
+      execute: (goalDocument) => Promise.race([
+        deps.decomposeGoal
+          ? deps.decomposeGoal(goalDocument)
+          : decomposeSelfDevGoal(goalDocument, {
+            ...deps.decomposeOptions,
+            decomposer: selection.decomposer,
+            observation: prelaunchDecompositionObservation(goalDocument),
+          }),
+        timeout,
+      ]),
+    }, document!, {
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
     });
-    const result = await observeFrontNodeUnit('decompose', input.runId ?? process.env.ELANOUS_RUN_ID, decomposeGoalType ?? undefined, () => Promise.race([
-      deps.decomposeGoal
-        ? deps.decomposeGoal(document!)
-        : decomposeSelfDevGoal(document!, {
-          ...deps.decomposeOptions,
-          decomposer: selection.decomposer,
-          observation: prelaunchDecompositionObservation(document!),
-        }),
-      timeout,
-    ]));
     if (result === timedOut) {
       // ⛔ 「시간 초과」를 「못 쟀다」로 뭉개지 않는다 — 분해기는 «아직 답하는 중»이고
       //   그 답은 `prelaunch-decomposition` 이름으로 «따로» 내려앉는다(위 주석).
@@ -871,25 +878,32 @@ export async function runAskLaunchFlow(
     //   ⛔ 선언이 «없을 때» 넘기면 안 된다 — 저작기의 정식 기본값을 덮어쓰게 된다.
     const declaredAskGoalType = declaredGoalType(input.askText);
     const goalType = input.goalType ?? declaredAskGoalType;
+    const frontRunId = input.runId ?? process.env.ELANOUS_RUN_ID;
     const frontObservation = {
-      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(goalType === null ? {} : { goalType }),
     };
     // ⭐ RFC §5 5단계 — 확인된 implement 저작만 활성 구현 그래프에 이름을 잇는다.
     observeFrontNodeEntry('author', { ...frontObservation, provenance: 'authoring-start' });
-    const authored = await deps.authorGoal([authorAskText], {
-      cwd: deps.cwd(),
-      ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
-      ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
+    const authored = await runFrontNodeUnit({
+      node: 'author',
+      execute: (text, context) => deps.authorGoal([text], {
+        cwd: deps.cwd(),
+        ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
+        ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
+        ...(context.goalType === undefined ? {} : { goalType: context.goalType }),
+        // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
+        ...(() => {
+          if (input.inputSource !== 'ask' || input.askFile === undefined) return {};
+          const askFile = lineageAskFile(input.askFile);
+          return askFile === undefined ? {} : { askFile };
+        })(),
+        ...(launchPreflight === undefined ? {} : { launchPreflight }),
+        selfResolveClarifications: selfResolveClarifications.value,
+      }),
+    }, authorAskText, {
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(goalType === null ? {} : { goalType }),
-      // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
-      ...(() => {
-        if (input.inputSource !== 'ask' || input.askFile === undefined) return {};
-        const askFile = lineageAskFile(input.askFile);
-        return askFile === undefined ? {} : { askFile };
-      })(),
-      ...(launchPreflight === undefined ? {} : { launchPreflight }),
-      selfResolveClarifications: selfResolveClarifications.value,
     }).catch((error: unknown) => {
       // GRAPH-AUTHOR-FAIL-EDGE: 저작기가 던진 자리 = author `fail` 출구. ⛔ 관측만 하고 같은 오류를 그대로 다시 던진다.
       observeFrontNodeExit({ node: 'author', outcome: 'fail' }, {

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

@@ -1529,6 +1529,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 +1545,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 +1572,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 */ }