elanous 0.2.21 → 0.2.23

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

@@ -0,0 +1,178 @@
+import type { TaskStatus } from '../task-orchestrator/types.js';
+
+type WorkingMemoryEntry = {
+  phaseId: string;
+  phaseTitle: string;
+  kind: 'investigation' | 'implementation' | 'operational';
+  at: string;
+  summary: string;
+  reusables: string[];
+  decisions: string[];
+  artifacts: string[];
+  provenance?: 'self' | 'external' | 'reconcile' | 'decision' | 'build';
+  arcId?: string;
+  deviation?: { kind: 'scope_reduction' | 'deferred' | 'asked_user' | 'env_improved' | 'regrounded' | 'other' | 'satisfied_skip' | 'blocked_dependency' | 'arc_surgery' | 'phase_failed' | 'self_heal' | 'deadlock' | 'review_fail'; note: string };
+  scope?: 'agent' | 'subteam' | 'global';
+};
+
+type AbandonedClassification = 'report-deficit' | 'implementation-deficit' | 'artifact-deficit' | 'contract-conflict' | 'goal-unconvergeable-candidate' | 'pr-declined' | 'merge-approved-abandoned' | 'run-deadline-exceeded' | 'quota-exhausted' | 'credential-failure' | 'provider-error' | 'already-satisfied';
+
+type ResumeDisposition = 'skip' | 'rerun' | 'rerun-duplicate-risk';
+
+export type JobKind = 'dev' | 'search' | 'deploy' | 'media';
+export type SelfDevGoalType = 'implement' | 'research' | 'document' | 'operate';
+
+export interface SelfDevGoal {
+  /** F1 job kind. Omitted remains the legacy `dev` self-implement job. */
+  kind?: JobKind;
+  /** Decomposition intent; deliberately distinct from executable `kind`. */
+  goalType?: SelfDevGoalType;
+  /** Feature/goal text → `elanous self implement <feature>` for dev jobs. */
+  feature: string;
+  /** Pod lease predecessor goal ID or PR number. */
+  after?: string | number;
+  base?: string;
+  autoMerge?: boolean;
+  /** G8 — attach `auto-review` opt-in label on PR (subject to eligibility self-assessment). */
+  autoReview?: boolean;
+  /** S3 — open a draft PR via the job's own merge-decision node (HITL).
+   *  Promotion flows through the review node → disposition recorded
+   *  internally (no external hand-merge). */
+  openPr?: boolean;
+  draft?: boolean;
+  /** Optional short title (≤ 80 chars). Default = feature head. */
+  title?: string;
+  /** 계획 브랜치가 알려지면 같은 워크트리의 실행을 직렬화한다. */
+  planBranch?: string;
+  /** 계획 브랜치가 없는 저작 골의 안정 식별자. */
+  goalId?: string;
+  /** S2 — goal-local id for dependency wiring (default = array index). */
+  id?: string;
+  /** S2 — goal-local ids this goal depends on (must complete first).
+   *  The task becomes `ready` only after every dependency is `done`
+   *  (topological parallel via the graph). Unknown/self ids are dropped. */
+  dependsOn?: string[];
+  /** Read-only handoff memory emitted by this shard for dependent child input.
+   *  `[]` is a completed shard with no entries; null/undefined is unreadable. */
+  workingMemory?: readonly WorkingMemoryEntry[] | null;
+  /** 그 기억을 남긴 이 조각이 «착지했나». ⛔ 생략은 「모른다」이지 「착지」가 아니다. */
+  workingMemoryOutcome?: 'landed' | 'blocked' | 'unknown';
+  /** S2 — repo paths this job will touch. Two goals sharing a hot path
+   *  are serialized (an implicit dependency edge is added, earlier-first)
+   *  so their worktrees never merge concurrently. Cf. PLAN §8 risk 2. */
+  hotPaths?: string[];
+}
+
+export interface SelfDevJobResult {
+  taskId: string;
+  feature: string;
+  /** Run outcome — done | failed | cancelled | blocked (awaiting parent landing). */
+  status: TaskStatus;
+  error?: { code: string; message: string };
+  durationMs?: number;
+  /** S3 — real pipeline disposition from the child `--json`
+   *  (merged / pr-opened / gate-failed / review-blocked / pr-declined). */
+  stage?: string;
+  branch?: string;
+  /** Child confirmed the finished implementation was pushed for manual harvest. */
+  harvestable?: true;
+  worktreePath?: string;
+  prUrl?: string;
+  prNumber?: number;
+  merged?: boolean;
+  /** Child commit SHA, when observed by the Pod/host. */
+  checkedHeadCommit?: string;
+  /**
+   * This run's own `--base` (not main). A non-main completion mode
+   * (worktree-only, draft, `--base` other than main) lands commits here.
+   */
+  base?: string;
+  /** Child finished with GOAL-COMPLETE (`ok=true`). Distinct from a main merge. */
+  ok?: boolean;
+  /** 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';
+  parentPrNumber?: number;
+  /** The upstream completed in a worktree without opening a PR. */
+  parentNoPr?: true;
+  // ⭐⭐⭐ `A1`(2026-08-19 · 대표 *"R3 가 서브 프로세스여도 잘 도는 안"*) — ***판정 3종***.
+  //   🚨 이 셋이 트리아지의 입력 전부인데 종전엔 자식 → 부모 경계에서 «전부» 사라졌다.
+  //     값은 전선에 «실려 있었고»(자식이 `r.result` 를 통째로 낸다) 파서가 버렸다.
+  //   ⇒ 📌 서브프로세스에서 «먼저» 옳아야 한다 — 실행 방식을 바꾸지 않고 고치는 자리다.
+  /** auto-merge 를 «왜» 건너뛰었나 — 「도구 한계」와 「자식이 못 함」을 가르는 근거. */
+  mergeReason?: string;
+  /** 런이 «왜» 멈췄나. 없으면 「부모가 잘랐다」다. */
+  stopReason?: string;
+  /** 자식이 스스로 낸 완료 성격. */
+  completionDisposition?: string;
+  /** Abandoned-run classification from the child. Independent of completionDisposition. */
+  failureClassification?: AbandonedClassification;
+  /** Provider failure evidence from the child result; absent when unobserved. */
+  providerErrors?: { count: number; provider: string; category: 'quota' | 'credential' | 'request' | 'other' };
+  /** Stable child run identity used to join its run-ledger proposal. */
+  runId?: string;
+  /** Self review verdict bound to the PR head observed by the child; absent if either observation is missing. */
+  /** TA-LAND-MUSTFIX-ZERO — `mustFixCount` is the review's must-fix list length; absent = unknown (the land gate fails closed). */
+  selfReview?: { verdict: 'pass' | 'fail'; head: string; mustFixCount?: number };
+  /** Whether the child review actually ran; omitted preserves legacy producers. */
+  reviewed?: boolean;
+  /** Why the child did not run review; omitted preserves legacy review-unobserved handling. */
+  reviewReason?: string;
+  /** The abandoned-run classifier observed a goal-side cause for this failed convergence. */
+  goalCauseObserved?: true;
+  /** Resume selection that decided whether this shard was carried forward or retried. */
+  resumeDisposition?: ResumeDisposition;
+  /**
+   * ⭐ 하니스가 이 조각에 대해 낸 「이렇게 쪼개라」(2026-08-19).
+   *
+   * ⛔ 이 값은 자식 결과로 «안 온다» — 전선 타입(SelfImplementDisposition)에 칸이 없다.
+   *   그래서 «중앙»이 원장에서 읽어 채운다(decompose-proposal.ts). 트리아지는 그것을 그냥 본다.
+   *   ⇒ 📌 출구 모듈은 ***「이 값이 어디서 왔는지 몰라야」*** 한다 — 알면 실행 방식마다 갈래가 는다.
+   * ⚠️ undefined = 「제안이 없다」와 「아직 안 읽었다」가 «같은 값»이다. 채우는 자가 그것을 구분해 관측한다.
+   */
+  decomposeProposal?: { pieces: Array<{ id: string; feature: string; dependsOn: readonly string[]; goalType?: string }> };
+  /**
+   * Parent-side observation of CONTRACT-CONFLICT goal-plan revision application attempts.
+   * undefined = the parent has not read the run ledger yet; it is not the same as attempted=0.
+   */
+  goalPlanRevision?:
+    | { status: 'read'; attempted: number; applied: number; failureReasons: string[] }
+    | { status: 'read-failed'; reason: 'directory-missing' | 'unreadable-directory' | 'unreadable-files'; scannedFiles: number; unreadableFiles: number; ledgerDirectory: string };
+  /** ⭐ 관측(2026-07-21 대표 co-design·"재현 없이 진단") — 자식 goal-loop 화면 버퍼 tail
+   *  (ANSI 제거·"docker logs <id>" 등가물). detached PTY goal-loop 은 스폰 프로세스 stdout 이
+   *  아니라 file-based 화면 버퍼에만 남으므로, 실패 진단의 유일한 cross-process 진실원. */
+  screenTail?: string;
+  /** 화면 버퍼에서 판정한 goal-loop 종결 상태(complete=성공 마커·incomplete·null=불명). */
+  screenOutcome?: 'complete' | 'incomplete' | null;
+  /** 화면 버퍼 공간 id — `elanous self screen --space <id>` 로 전체 전사 재생 가능. */
+  screenSpace?: string;
+  /** ⚠️ exit-code 실패인데 화면은 GOAL-COMPLETE = 스폰-신호 단절(false-failure). 조정 플래그. */
+  reconcileMismatch?: boolean;
+  /** ⭐ 이 시도의 «걸음» — 노드 진입 순서(2026-09-08 · 대표 지시).
+   *  🩸 그 전까지 이 배열엔 「요약 판정」만 있었고 걸음은 런 «안»에서 끝났다.
+   *  ⛔ 관측용이다 — 슈퍼바이저가 이것으로 «무엇을 할지»는 별개 결정이다. */
+  walk?: readonly { node: string; round: number }[];
+}
+
+export type SupervisorStopReason =
+  | 'converged'
+  /** 사람이 명시적으로 이 런을 중단했다. */
+  | 'human-stopped'
+  /** 승격 분해는 끝났지만 부모 결정 신호가 적색이라 완주를 승인할 수 없다. */
+  | 'parent-signals-red'
+  | 'needs-human'
+  | 'no-actionable-work'
+  | 'harvestable-awaiting-human'
+  | 'handed-off-to-salvage'
+  | 'max-rounds'
+  | 'no-progress'
+  | 'provider-exhausted'
+  /** 제자리인데 이번 라운드 재시도 후보가 전부 단계 시간 초과(`timed-out`) — 판정을 못 내고 다시 걸었다. */
+  | 'step-timeout'
+  | 'decomposable-no-progress'
+  | 'review-unobserved'
+  | 'deliverable-unobserved'
+  | 'deliverable-merged';
+
+export type SupervisorNext = 'harvest' | 'scope-decompose' | 'self-review' | 'human-gate' | 'proposal';

package/src/self-dev/shard-aggregate.ts

@@ -16,6 +16,9 @@ export interface GateShardAttempt {
   baselineExitCode: number | null;
   currentSignal?: string | null;
   baselineSignal?: string | null;
+  /** LIGHT-RC-MEASURE — the shard files that exist in the baseline tree, i.e. what the baseline side actually ran.
+   *  Absent = every shard file (the old shape). Empty = the baseline side was not run and contributes zero cases. */
+  baselineFiles?: readonly string[];
 }
 
 export interface GateShardAggregate {
@@ -25,7 +28,7 @@ export interface GateShardAggregate {
   report?: GateBaselineReport;
 }
 
-interface JUnitCase { file: string; name: string; failure?: string }
+interface JUnitCase { file: string; name: string; failure?: string; skipped?: true }
 
 const decode = (text: string): string => text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (entity, key: string) => {
   if (key[0] === '#') {
@@ -128,6 +131,7 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
   const cases: JUnitCase[] = [];
   const counts = new Map<string, number>();
   const executed = new Set<string>();
+  const occurrences = new Map<string, number>();
   let failures = 0;
   let errors = 0;
   const matchesCount = (value: string | undefined, actual: number) => value === undefined
@@ -149,12 +153,20 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
         if (!caseFile || !expected.has(caseFile) || !leaf || (file && file !== caseFile)) return undefined;
         total.tests++;
         counts.set(caseFile, (counts.get(caseFile) ?? 0) + 1);
-        if (child.children.some((c) => c.name === 'skipped')) return undefined;
+        // A skipped case is neither a pass nor a failure; it no longer voids the shard (LIGHT-RC-MEASURE ②).
+        const skipped = child.children.some((c) => c.name === 'skipped');
         const classname = child.attrs.classname;
-        const name = classname && classname !== caseFile ? `${classname} > ${leaf}` : leaf;
+        const declaredName = classname && classname !== caseFile ? `${classname} > ${leaf}` : leaf;
+        // Bun emits one name for every `test.each` row and for same-named cases in one describe; such repeats are
+        // told apart by their order in the file (#2, #3 …) on both sides instead of voiding the shard (LIGHT-RC-MEASURE).
+        const declaredIdentity = `${caseFile}\u0000${declaredName}`;
+        const ordinal = (occurrences.get(declaredIdentity) ?? 0) + 1;
+        occurrences.set(declaredIdentity, ordinal);
+        const name = ordinal === 1 ? declaredName : `${declaredName} #${ordinal}`;
         const identity = `${caseFile}\u0000${name}`;
         if (executed.has(identity)) return undefined;
         executed.add(identity);
+        if (skipped) { cases.push({ file: caseFile, name, skipped: true }); continue; }
         const failure = child.children.find((c) => c.name === 'failure' || c.name === 'error');
         if (failure?.name === 'failure') { failures++; total.failures++; }
         else if (failure) { errors++; total.errors++; }
@@ -179,6 +191,30 @@ function readJUnit(xml: string, files: readonly string[]): JUnitCase[] | undefin
   return cases;
 }
 
+const SKIPPED_PASSED_AT_BASE = 'skipped now · passed at base — a skip must not hide a regression (LIGHT-RC-MEASURE ②)';
+
+/** Cases that passed at the baseline but were skipped now are counted as `unknown` failures — never green. */
+function withSkippedRegressions(report: GateBaselineReport | undefined, skipped: readonly JUnitCase[], baselineStatus: GateBaselineReport['baselineStatus']): GateBaselineReport {
+  const base: GateBaselineReport = report ?? {
+    introduced: 0, preexisting: 0, unknown: 0, preconditionUnmet: 0, missingAtBase: 0, timedOut: 0, timeoutPassedAtBase: 0,
+    flakyRerun: 0, rerunNotRun: 0, mayVaryNonTimeout: 0, rerunAttempted: 0, rerunRecovered: 0,
+    timeoutVariabilityCounts: { mayVary: 0, same: 0, unknown: 0 }, worktreeFailuresParsed: true,
+    failures: [], files: [], baselineStatus, log: 'shard baseline JUnit complete',
+  };
+  // An unknown failure means the child is not exonerated: `childResponsibility: 'none'` only holds when every remaining
+  // failure is flaky/preexisting (decideGateChildResponsibility), which an added unknown breaks.
+  const { childResponsibility: _dropped, ...rest } = base;
+  const added = skipped.map(({ file, name }) => ({
+    name: `${file} > ${name}`, file, diagnostic: SKIPPED_PASSED_AT_BASE, attribution: 'unknown' as const, baselinePresence: 'present' as const,
+  }));
+  return {
+    ...rest,
+    unknown: base.unknown + added.length,
+    failures: [...base.failures, ...added],
+    files: [...new Set([...base.files, ...added.map((failure) => failure.file)])],
+  };
+}
+
 function asGateLog(cases: readonly JUnitCase[]): string {
   return cases.map(({ file, name, failure }) => `${file}:\n${failure === undefined ? `(pass) ${name}` : `${failure}\n(fail) ${name}`}`).join('\n');
 }
@@ -196,35 +232,47 @@ export function aggregateGateTestShards(shards: readonly GateTestShard[], attemp
   const retryShardIds: string[] = [];
   const current: JUnitCase[] = [];
   const baseline: JUnitCase[] = [];
+  const skippedRegressions: JUnitCase[] = [];
   for (const shard of shards) {
     const attempt = selected.get(shard.id);
     const head = attempt?.currentJUnit === undefined ? undefined : readJUnit(attempt.currentJUnit, shard.files);
-    const base = attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, shard.files);
-    if (!attempt || attempt.currentExitCode === null || attempt.baselineExitCode === null
-      || attempt.currentSignal || attempt.baselineSignal
-      || ![0, 1].includes(attempt.currentExitCode) || ![0, 1].includes(attempt.baselineExitCode)
+    // LIGHT-RC-MEASURE ① — the baseline side reads only the files that exist in the baseline tree; none = not run.
+    const baselineFiles = attempt?.baselineFiles ?? shard.files;
+    const baselineSkipped = baselineFiles.length === 0;
+    const base = baselineSkipped ? [] : attempt?.baselineJUnit === undefined ? undefined : readJUnit(attempt.baselineJUnit, baselineFiles);
+    if (!attempt || attempt.currentExitCode === null || attempt.currentSignal
+      || ![0, 1].includes(attempt.currentExitCode)
+      || baselineFiles.some((file) => !shard.files.includes(file))
+      || (!baselineSkipped && (attempt.baselineExitCode === null || attempt.baselineSignal || ![0, 1].includes(attempt.baselineExitCode)))
       || !head || !base
       || (attempt.currentExitCode === 0 && head.some((test) => test.failure !== undefined))
-      || (attempt.baselineExitCode === 0 && base.some((test) => test.failure !== undefined))
+      || (!baselineSkipped && attempt.baselineExitCode === 0 && base.some((test) => test.failure !== undefined))
       || (attempt.currentExitCode !== 0 && head.every((test) => test.failure === undefined))
-      || (attempt.baselineExitCode !== 0 && base.every((test) => test.failure === undefined))) {
+      || (!baselineSkipped && attempt.baselineExitCode !== 0 && base.every((test) => test.failure === undefined))) {
       retryShardIds.push(shard.id);
       continue;
     }
-    current.push(...head);
-    baseline.push(...base);
+    current.push(...head.filter((test) => !test.skipped));
+    baseline.push(...base.filter((test) => !test.skipped));
+    const passedAtBase = new Set(base.filter((test) => !test.skipped && test.failure === undefined).map((test) => `${test.file}\u0000${test.name}`));
+    skippedRegressions.push(...head.filter((test) => test.skipped && passedAtBase.has(`${test.file}\u0000${test.name}`)));
   }
   if (retryShardIds.length > 0 || shards.length === 0) return { status: 'unmeasured', retryShardIds };
-  if (current.every((test) => test.failure === undefined)) return { status: 'passed', retryShardIds: [] };
+  const baselineStatus = baseline.some((test) => test.failure !== undefined) ? 'test-fail' as const : 'pass' as const;
+  if (current.every((test) => test.failure === undefined)) {
+    if (skippedRegressions.length === 0) return { status: 'passed', retryShardIds: [] };
+    return { status: 'failed', retryShardIds: [], report: withSkippedRegressions(undefined, skippedRegressions, baselineStatus) };
+  }
   const passedTestEvidence: GatePassedTestEvidence = {
     status: 'available',
     tests: baseline.filter((test) => test.failure === undefined).map(({ file, name }) => ({ file, name: `${file} > ${name}` })),
   };
   const report = buildGateBaselineReport(asGateLog(current), {
-    status: baseline.some((test) => test.failure !== undefined) ? 'test-fail' : 'pass',
+    status: baselineStatus,
     output: asGateLog(baseline),
     passedTestEvidence,
     log: 'shard baseline JUnit complete',
   });
+  if (skippedRegressions.length > 0) return { status: 'failed', retryShardIds: [], report: withSkippedRegressions(report, skippedRegressions, baselineStatus) };
   return { status: allowsBaselineOnlyFailure(report) ? 'passed' : 'failed', retryShardIds: [], report };
 }

package/src/self-dev/shard-plan.ts

@@ -39,7 +39,11 @@ export function planGateTestShards(
       shard = { id: `shard-${shards.length + 1}`, files: [], plannedRssMb: 0, plannedSeconds: 0 };
       shards.push(shard);
     }
-    if (!shard) throw new Error(`test files exceed ${shardCount} shard memory budgets`);
+    if (!shard) {
+      const totalRssMb = sorted.reduce((sum, candidate) => sum + rssMb.get(candidate)!, 0);
+      const largestRssMb = rssMb.get(sorted[0]!)!;
+      throw new Error(`test files exceed ${shardCount} shard memory budgets (files=${unique.length} · totalRssMb=${Math.round(totalRssMb)} · largestRssMb=${Math.round(largestRssMb)} · budgetMb=${capacity} · neededShards≥${Math.ceil(totalRssMb / capacity)})`);
+    }
     shard.files.push(file);
     shard.plannedRssMb += rss;
     shard.plannedSeconds += duration;

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

@@ -1,6 +1,7 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { debug } from '../debug/log.js';
 import { prepareDeterministicChildEnvironment } from '../../scripts/lib/deterministic-env.js';
 import { withBaselineWorktree } from '../self-implement/gate-baseline.js';
 import { aggregateGateTestShards, type GateShardAttempt, type GateShardAggregate } from './shard-aggregate.js';
@@ -22,6 +23,13 @@ export type ShardProcess = (cwd: string, files: readonly string[]) => {
   seconds?: number;
 };
 
+/** Absent only when the path provably is not a file there (missing, or not a regular file); any other stat error
+ *  (permissions …) is not evidence of absence, so the file stays in the baseline run (fail-closed: unmeasured). */
+const absentAtBaseline = (path: string): boolean => {
+  try { return !statSync(path).isFile(); }
+  catch (error) { const code = (error as NodeJS.ErrnoException).code; return code === 'ENOENT' || code === 'ENOTDIR'; }
+};
+
 /** One process per bundle and per revision; a failed runner is retried only for its own bundle. */
 export function runShardedGateTests(
   cwd: string,
@@ -71,20 +79,30 @@ export function runShardedGateTests(
   }
   const attempts: GateShardAttempt[] = [];
   const baseline = baselineWorktree(cwd, baseRef, (dir) => {
+    // LIGHT-RC-MEASURE ① — bun silently skips a path that is not in the baseline tree (exit 0), so a shard holding a
+    // new test file could never yield a complete baseline JUnit. Run the baseline side on the files the base has; an
+    // unreadable tree is not evidence of absence, so then every file stays in (the old shape).
+    const treeReadable = (() => { try { return statSync(dir).isDirectory(); } catch { return false; } })();
+    const atBase = (shard: GateTestShard) => treeReadable ? shard.files.filter((file) => !absentAtBaseline(join(dir, file))) : [...shard.files];
     let pending = shards;
     for (let round = 1; round <= 2 && pending.length; round++) {
       for (const shard of pending) {
-        const runSafely = (location: string): ReturnType<ShardProcess> => {
-          try { return run(location, shard.files); }
+        const runSafely = (location: string, selected: readonly string[]): ReturnType<ShardProcess> => {
+          try { return run(location, selected); }
           catch { return { exitCode: null }; }
         };
-        const current = runSafely(cwd);
-        const base = runSafely(dir);
+        const baselineFiles = atBase(shard);
+        if (baselineFiles.length < shard.files.length) {
+          debug.log('self-dev.shard', 'baseline-files-absent', { shardId: shard.id, round, absent: shard.files.filter((file) => !baselineFiles.includes(file)) });
+        }
+        const current = runSafely(cwd, shard.files);
+        const base = baselineFiles.length ? runSafely(dir, baselineFiles) : { exitCode: 0 };
         attempts.push({
           shardId: shard.id, attempt: round,
           currentJUnit: current.junit, baselineJUnit: base.junit,
           currentExitCode: current.exitCode, baselineExitCode: base.exitCode,
           currentSignal: current.signal, baselineSignal: base.signal,
+          baselineFiles,
         });
       }
       const retry = new Set(aggregateGateTestShards(shards, attempts).retryShardIds);

package/src/self-dev/supervisor-verdict-edges.ts

@@ -1,7 +1,5 @@
-import type { SelfDevJobResult } from './orchestrate.js';
-import type { SupervisorStopReason } from './run-supervisor.js';
-
-export type SupervisorNext = 'harvest' | 'scope-decompose' | 'self-review' | 'human-gate' | 'proposal';
+import type { SelfDevJobResult, SupervisorStopReason, SupervisorNext } from './run-types.js';
+export type { SupervisorNext } from './run-types.js';
 export type SupervisorVerdictEdge = { readonly meaning: string; readonly next: SupervisorNext };
 
 // 목표 규칙: 사람 관문은 결제·공개·자격·비가역 결정에만. 지금 max-rounds·provider-exhausted·step-timeout 이 human-gate 인 것은

package/src/self-implement/blocked-draft-policy.ts

@@ -1,4 +1,7 @@
 import type { AbandonedClassification } from './abandoned-classification.js';
+import type { DraftOnStopMode } from './draft-on-stop-mode.js';
+export { DRAFT_ON_STOP_MODES, DEFAULT_DRAFT_ON_STOP, parseDraftOnStopMode } from './draft-on-stop-mode.js';
+export type { DraftOnStopMode } from './draft-on-stop-mode.js';
 
 /** Environment interruptions have a resumable branch, not a human draft decision. */
 export function blockedDraftDisposition(classification: string | undefined): 'open-draft' | 'preserve-branch' {
@@ -7,19 +10,6 @@ export function blockedDraftDisposition(classification: string | undefined): 'op
     : 'open-draft';
 }
 
-/**
- * DRAFT-NOT-ARCHIVE (RFC-draft-pr-accumulation-root-fix R1 · 첫 조각)
- *
- * S: 멈춘 런은 산출을 draft PR 로 남겼다 — PR 이 «실패 보관소»가 되어 열린 PR 이 200 을 넘고 겹침 검사가 눈이 멀었다.
- * C: 닫힌 147건 중 사람이 실제로 봐야 했던 것은 «주인 자리» 47건뿐이었다.
- * Q: 어느 멈춤이 PR 을 열 자격이 있나?
- * A: 사람 판단이 필요한 멈춤(needs-owner)만. 나머지(harvestable)는 수확 가지 `salvage/<run>/<leaf>` ⊕ 런 원장의 «사유 · 다음 수»로 남긴다.
- *    `tools.selfImplement.draftOnStop` = 'always'(기본 · 종전) | 'needs-owner-only'.
- */
-export type DraftOnStopMode = 'needs-owner-only' | 'always';
-export const DRAFT_ON_STOP_MODES = ['needs-owner-only', 'always'] as const satisfies readonly DraftOnStopMode[];
-export const DEFAULT_DRAFT_ON_STOP: DraftOnStopMode = 'always';
-
 /** landable = 승인된 산출(merge-approved-abandoned) — 다음 수가 `pr land` 이므로 수확 가지로 숨기지 않고 PR 로 남긴다(⛔ needs-owner 라벨은 안 단다). */
 export type StopClass = 'needs-owner' | 'harvestable' | 'landable';
 
@@ -99,9 +89,3 @@ export function salvageBranchForRun(runId: string, branch: string): string {
   const leaf = branch.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').replace(/\.\.+/g, '.').replace(/\.lock$/i, '-lock') || 'branch';
   return `salvage/${runShort}/${leaf}`;
 }
-
-export function parseDraftOnStopMode(raw: unknown): { mode: DraftOnStopMode; invalid: boolean } {
-  if (raw === undefined) return { mode: DEFAULT_DRAFT_ON_STOP, invalid: false };
-  if (typeof raw === 'string' && (DRAFT_ON_STOP_MODES as readonly string[]).includes(raw)) return { mode: raw as DraftOnStopMode, invalid: false };
-  return { mode: DEFAULT_DRAFT_ON_STOP, invalid: true };
-}

package/src/self-implement/draft-on-stop-mode.ts

@@ -0,0 +1,18 @@
+/**
+ * DRAFT-NOT-ARCHIVE (RFC-draft-pr-accumulation-root-fix R1 · 첫 조각)
+ *
+ * S: 멈춘 런은 산출을 draft PR 로 남겼다 — PR 이 «실패 보관소»가 되어 열린 PR 이 200 을 넘고 겹침 검사가 눈이 멀었다.
+ * C: 닫힌 147건 중 사람이 실제로 봐야 했던 것은 «주인 자리» 47건뿐이었다.
+ * Q: 어느 멈춤이 PR 을 열 자격이 있나?
+ * A: 사람 판단이 필요한 멈춤(needs-owner)만. 나머지(harvestable)는 수확 가지 `salvage/<run>/<leaf>` ⊕ 런 원장의 «사유 · 다음 수»로 남긴다.
+ *    `tools.selfImplement.draftOnStop` = 'always'(기본 · 종전) | 'needs-owner-only'.
+ */
+export type DraftOnStopMode = 'needs-owner-only' | 'always';
+export const DRAFT_ON_STOP_MODES = ['needs-owner-only', 'always'] as const satisfies readonly DraftOnStopMode[];
+export const DEFAULT_DRAFT_ON_STOP: DraftOnStopMode = 'always';
+
+export function parseDraftOnStopMode(raw: unknown): { mode: DraftOnStopMode; invalid: boolean } {
+  if (raw === undefined) return { mode: DEFAULT_DRAFT_ON_STOP, invalid: false };
+  if (typeof raw === 'string' && (DRAFT_ON_STOP_MODES as readonly string[]).includes(raw)) return { mode: raw as DraftOnStopMode, invalid: false };
+  return { mode: DEFAULT_DRAFT_ON_STOP, invalid: true };
+}