elanous 0.2.0 → 0.2.5

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

@@ -15,8 +15,12 @@
 //   self 는 backend 리스트 항목이 아니라 transport 축을 붕괴시키는 특수 갈래. 감독 축도 self=turn 레벨.
 
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
+import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
+import { getNestDepth } from '../agent/nest-depth.js';
+import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
+import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
@@ -41,6 +45,8 @@ import { buildReviewProviderAttempts, runReviewWithFallback, reviewFallbackModel
 import type { DefaultSeamsOptions } from '../self-implement/seams.js';
 import { harnessTargetOptions, resolveHarnessTarget, revalidateHarnessTarget, type HarnessTargetResolution } from '../self-implement/harness-target-options.js';
 import { provisionRepository, type RepoProvisionResult } from '../self-implement/repo-provision.js';
+import { decideNonGitInit } from '../self-implement/non-git-consent.js';
+import { createInterface } from 'node:readline/promises';
 import type { ChildLlmSelection } from '../agent/run-context.js';
 import type { SurfaceUx } from '../agent/surface-ux/types.js';
 
@@ -51,6 +57,11 @@ export type OrchestrateRuntime = Omit<OrchestrateSelfDevOptions, 'goals' | 'conc
 /** external+pty(agent-mission) 실행 옵션 — 통일 축 밖의 backend-특정 미션 실행 파라미터(무손실 재라우팅용).
  *  agent-mission-pty dispatch 에만 유효(그 외 dispatch 에 지정 시 planDevPipeline 이 거부·수락 후 무시 금지). */
 export interface DevMissionOpts {
+  chain?: readonly ('codex' | 'claude' | 'elanous')[];
+  plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
+  headless?: boolean;
   evidence?: EvidenceMode;
   maxRounds?: number;
   commit?: boolean;
@@ -65,6 +76,7 @@ export interface DevMissionOpts {
  *  self-특정 미션 실행 파라미터(무손실 재라우팅용). self-mission dispatch 에만 유효(그 외 지정 시 planDevPipeline
  *  이 거부·수락 후 무시 금지). autoMerge 는 completion:'auto-merge'·autoReview 는 spec.autoReview 로 표현(중복 축 아님). */
 export interface DevSelfOpts {
+  mergeByHost?: boolean;
   /** PR draft 여부(기본 true·안전). PR 개설 시에만 의미. */
   draft?: boolean;
   /** 진입 클래스(enhance mode-gating). CLI self implement=external-verbatim. 미지정 시 orchestrator 기본. */
@@ -86,8 +98,6 @@ export interface DevSelfOpts {
   naturalLanguageDispatch?: boolean;
   /** 호출 단위 구현 자식 두뇌(provider/model 원자 선택). 미지정 시 orchestrator 기본·승격 티어를 보존한다. */
   childLlm?: ChildLlmSelection;
-  /** 런 단위 graph authority override. 미지정이면 orchestrator가 config를 해석한다. */
-  graphAuthoritative?: boolean;
   /** Optional opaque ID for joining this request with correlated execution records. */
   correlationId?: string;
   /** Optional opaque ID for the parent correlation in a nested request. */
@@ -237,6 +247,8 @@ export interface DevPipelineSpec {
   entranceUnstamped?: 'interactive-dispatch';
   /** JSON CLI 출력에서는 사람이 읽는 진행 안내를 stdout에 섞지 않는다. */
   humanReadableOutput?: boolean;
+  /** Explicit authorization for Git initialization of a non-git project. */
+  assumeYes?: boolean;
   /** CLI 경계에서 한 번 읽은 Git 중단 상태 스냅샷. 같은 런의 plan 관측은 이 값만 기록한다. */
   /** ⛔⭐ **관측과 그 경로는 하나다**(무인 리뷰 must-fix) — 종전엔 `gitResidue` 와
    *  `gitResiduePath` 가 **독립 optional** 이라, 스냅샷만 넘기면 경로가 `process.cwd()` 로
@@ -298,7 +310,7 @@ export interface ResolvedDevPlan {
 }
 
 export class DevPipelineError extends Error {
-  constructor(message: string) { super(message); this.name = 'DevPipelineError'; }
+  constructor(message: string, readonly exitCode = 1) { super(message); this.name = 'DevPipelineError'; }
 }
 
 /** 사람이 읽는 계획 출력에 이미 결정된 base 선택을 그대로 드러낸다. */
@@ -381,6 +393,9 @@ export function planDevPipeline(spec: DevPipelineSpec): ResolvedDevPlan {
   const entrance = spec.entrance;
 
   // ── 검증(불가 조합 hard-error) ──
+  if (spec.self?.mergeByHost === true && (process.env.ELANOUS_SUBSTRATE !== 'pod' || !process.env.ELANOUS_POD_NAME || !process.env.ELANOUS_POD_NAMESPACE)) {
+    throw new DevPipelineError('--merge-by-host 는 Pod 자식 전용입니다 (호스트 재게이트 인계가 없는 로컬 실행 거부)');
+  }
   if (context === 'interactive' && completion !== 'worktree-only') {
     throw new DevPipelineError('interactive(chat) 는 PR 산출이 없어 completion 은 worktree-only 만 유효');
   }
@@ -411,6 +426,9 @@ export function planDevPipeline(spec: DevPipelineSpec): ResolvedDevPlan {
   if (dispatch === 'acp' && (spec.branch?.trim() || spec.base?.trim())) {
     throw new DevPipelineError('acp 는 cwd 세션 실행(worktree 없음) — branch/base 는 지원 안 함(pty 전용)');
   }
+  if (spec.mission?.headless === true && (dispatch !== 'agent-mission-pty' || executor.kind !== 'external' || executor.backend !== 'claude')) {
+    throw new DevPipelineError('--headless 는 external Claude mission 전용입니다');
+  }
   // mission 실행 옵션은 agent-mission-pty 에만 유효 — 그 외 dispatch 에 지정 시 거부(수락 후 무시 금지).
   const hasMissionOpts = !!spec.mission && Object.values(spec.mission).some((v) => v !== undefined);
   if (hasMissionOpts && dispatch !== 'agent-mission-pty') {
@@ -576,6 +594,7 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.draft !== undefined ? { draft: s.draft } : {}),
     completion: plan.completion,
     ...(plan.completion === 'auto-merge' ? { autoMerge: true } : {}),
+    ...(s.mergeByHost === true ? { mergeByHost: true } : {}),
     ...(plan.autoReview ? { autoReview: true } : {}),
     ...(s.deliverableHint ? { deliverableHint: s.deliverableHint } : {}),
     ...(s.memory !== undefined ? { memory: s.memory } : {}),
@@ -585,7 +604,6 @@ export function toSelfImplementOptions(text: string, plan: ResolvedDevPlan, seam
     ...(s.naturalLanguageDispatch ? { naturalLanguageDispatch: true } : {}),
     ...(s.childLlm ? { childLlm: s.childLlm } : {}),
     ...(s.correlationId !== undefined ? { correlationId: s.correlationId } : {}),
-    ...(s.graphAuthoritative !== undefined ? { graphAuthoritative: s.graphAuthoritative } : {}),
     ...(s.branchName ? { branchName: s.branchName } : {}),
     ...(s.maxReworkRounds !== undefined ? { maxReworkRounds: s.maxReworkRounds } : {}),
   };
@@ -604,6 +622,11 @@ export function toAgentMissionSpec(
     branch: plan.branch!,
     evidence: m.evidence ?? { kind: 'tsc' }, // 기본 tsc(mission 옵션 미지정 시)
     agent: resolveBackend(plan.executor.backend),
+    ...(m.headless === true ? { headless: true } : {}),
+    ...(m.chain ? { chain: m.chain } : {}),
+    ...(m.plugin ? { plugin: m.plugin } : {}),
+    ...(m.resources !== undefined ? { resources: m.resources } : {}),
+    ...(m.backendExplicit !== undefined ? { backendExplicit: m.backendExplicit } : {}),
     ...(plan.base ? { base: plan.base } : {}),
     ...(plan.enhance !== undefined ? { enhance: plan.enhance } : {}),
     ...(m.maxRounds !== undefined ? { maxRounds: m.maxRounds } : {}),
@@ -626,6 +649,11 @@ export function buildAgentMissionDevSpec(o: {
   backend: DevBackend;
   branch: string;
   base?: string;
+  headless?: boolean;
+  chain?: readonly ('codex' | 'claude' | 'elanous')[];
+  plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
   /** --no-enhance 시 false(그 외 미지정 → driver 가 entry 로 구동). */
   enhanceOff?: boolean;
   evidence: EvidenceMode;
@@ -642,6 +670,11 @@ export function buildAgentMissionDevSpec(o: {
     ...(o.enhanceOff ? { enhance: false } : {}),
     mission: {
       evidence: o.evidence,
+      ...(o.headless === true ? { headless: true } : {}),
+      ...(o.chain ? { chain: o.chain } : {}),
+      ...(o.plugin ? { plugin: o.plugin } : {}),
+      ...(o.resources !== undefined ? { resources: o.resources } : {}),
+      ...(o.backendExplicit !== undefined ? { backendExplicit: o.backendExplicit } : {}),
       maxRounds: o.maxRounds,
       commit: o.commit,
       entry: 'elanous-apparatus',
@@ -694,6 +727,8 @@ export function buildSelfImplementDevSpec(o: {
   documentReferences?: readonly DocumentReferenceStatus[];
   naturalLanguageDispatch?: boolean;
   runId?: string;
+  /** --child-llm-provider/--child-llm-model: the Pod grok fallback pins its implementation child here. */
+  childLlm?: ChildLlmSelection;
 }): DevPipelineSpec {
   // planDevPipeline() is the runtime caller of resolveLaunchCapabilities(); preserve omission
   // until that resolver applies the shared launch default.
@@ -715,6 +750,7 @@ export function buildSelfImplementDevSpec(o: {
     ...(o.runId ? { runId: o.runId } : {}),
     self: {
       draft: o.draft,
+      ...(o.childLlm ? { childLlm: o.childLlm } : {}),
       ...(o.maxWaitSec !== undefined ? { maxWaitSec: o.maxWaitSec } : {}),
       ...(o.ground ? { ground: true } : {}),
       ...(o.entry ? { entry: o.entry } : {}),
@@ -894,6 +930,10 @@ export interface DevHarnessDispatchArgs extends Record<string, unknown> {
 }
 
 export interface DevPipelineDeps {
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
+  /** Caller has already recorded this dispatch decision at an outer entrance. */
+  skipDispatchTask?: boolean;
   /** Caller-managed human progress sink (for example SurfaceUx.progress). Absent callers retain byte-for-byte CLI stdout. */
   progress?: SurfaceUx['progress'];
   runSelfImplement?: (o: SelfImplementOptions) => Promise<SelfImplementResult>;
@@ -905,6 +945,10 @@ export interface DevPipelineDeps {
   approver?: SelfImplementSeams['approvePr'];
   /** In-place repository promotion after target revalidation and before child execution. */
   provisionRepository?: (target: HarnessTargetResolution) => RepoProvisionResult;
+  /** Consent prompt seam; defaults to readline on a TTY. */
+  askNonGitInit?: (prompt: string) => Promise<string | undefined>;
+  /** Interactive detection seam; defaults to stdin TTY state (prompts go to stderr). */
+  nonGitInteractive?: boolean;
   /** elanous 도구 소스의 git 최상위(시험 seam). null = 체크아웃 아님(npm 설치). 미지정이면 실제로 잰다. */
   toolRepositoryRoot?: string | null;
   /** ACP 위임 실행(테스트 주입). signal 을 함께 받아 기본 경로와 취소 동작 일치(DI 계약 정합). */
@@ -1592,8 +1636,18 @@ export function resolveTargetRemoteCompletion(
   completion: DevCompletion,
   completionSource: DevSelectionSource,
   remote: TargetRemoteObservation,
+  options: { naturalLanguageDispatch?: boolean } = {},
 ): { completion: DevCompletion; reason?: string } {
   if (remote.state !== 'remote-absent' || completion === 'worktree-only') return { completion };
+  // 🩸 2026-09-26 베어 Ubuntu 26.04 실측(UX 15): TUI 자연어 경로에서 «모델이» 도구 인자(open_pr 등)를 채워
+  //   출처가 `request` 로 찍혔고, 원격 없는 저장소라 79초 뒤에 실패했다 — 사람은 PR 을 청한 적이 없다.
+  //   ⇒ 자연어 경로는 사람이 친 플래그가 아니므로 기본과 같이 워크트리로 내리고 «그렇게 했다»고 한 줄 말한다.
+  if (completionSource !== 'default' && options.naturalLanguageDispatch === true) {
+    return {
+      completion: 'worktree-only',
+      reason: `target has no git remote; the natural-language request asked for completion:${completion}, ran worktree-only instead (commits stay on a local branch — add a remote to get a PR)`,
+    };
+  }
   if (completionSource !== 'default') {
     // ⛔ 2026-09-23 (Phase 4 실측) — 막는 것은 옳지만 «무엇을 하면 되나»를 말해야 한다.
     //   `--no-auto-merge` 같은 완료 인자는 «PR 을 명시한 것»으로 읽힌다 — 로컬 프로젝트 사용자는 그걸 모른다.
@@ -1739,6 +1793,65 @@ export async function runDevPipeline(spec: DevPipelineSpec, deps: DevPipelineDep
   }
 }
 
+async function observeDevTaskDispatch(spec: DevPipelineSpec, plan: ResolvedDevPlan, deps: DevPipelineDeps): Promise<void> {
+  const skipped = plan.dispatch === 'interactive' && getNestDepth() > 0 ? 'nested-interactive'
+    : plan.relaunch === true ? 'relaunch'
+    : plan.dispatch === 'parallel' ? 'parallel-parent'
+    : deps.skipDispatchTask === true ? 'skipDispatchTask'
+    : process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    // `bun test` preload sets this so pipeline tests do not run the real gates (usage/recall
+    // lookups) on every launch; tests that inject a dispatcher or gates still observe.
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps.dispatchTask && !deps.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (skipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: skipped, ...(spec.runId ? { runId: spec.runId } : {}) }); } catch { /* fail-soft */ }
+    return;
+  }
+  try {
+    const goalText = 'text' in plan.input ? plan.input.text : (deps.readFile ?? ((path: string) => readFileSync(path, 'utf8')))(plan.input.file);
+    const goalId = 'file' in plan.input ? parseGoalId(goalText) : null;
+    let recordedCardId: string | undefined;
+    const recordCard = (cardId: string): void => {
+      if (!spec.runId || recordedCardId) return;
+      recordedCardId = cardId;
+      try {
+        appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: spec.runId,
+          event: 'execution-loop-card', data: { cardId } });
+      } catch (error) {
+        try { debug.log('execution-loop.gate', 'ledger-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+      }
+    };
+    const dispatchDeps: DispatchTaskDeps = {
+      ...deps.dispatchTaskDeps,
+      onCardCreated: (cardId) => {
+        recordCard(cardId);
+        deps.dispatchTaskDeps?.onCardCreated?.(cardId);
+      },
+    };
+    const work = Promise.resolve().then(() => (deps.dispatchTask ?? dispatchTask)({
+      goalId: goalId ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: 'file' in plan.input ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec,
+      ...(spec.runId ? { runKey: spec.runId } : {}),
+    }, dispatchDeps));
+    // The default dispatcher bounds its gates to five seconds. Await its completed
+    // observation so short-lived callers cannot exit before decisions reach the card.
+    // Injected dispatchers retain an outer timeout to protect the original launch.
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const result = await (deps.dispatchTask
+      ? Promise.race([
+          work,
+          new Promise<never>((_, reject) => { timeout = setTimeout(() => reject(new Error('dispatch timeout after 5000ms')), 5_000); }),
+        ]).finally(() => { if (timeout) clearTimeout(timeout); })
+      : work);
+    recordCard(result.cardId);
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
 async function runDevPipelineDispatch(
   spec: DevPipelineSpec,
   deps: DevPipelineDeps,
@@ -1747,6 +1860,7 @@ async function runDevPipelineDispatch(
 ): Promise<DevPipelineRunResult> {
   const plan = planDevPipeline(spec);
   seen.plan = plan;
+  await observeDevTaskDispatch(spec, plan, deps);
   if (!plan.wired) {
     throw new DevPipelineError(
       `runDevPipeline: '${plan.dispatch}' 경로는 U4 골격에서 미배선(NotYetUnified). ` +
@@ -1852,6 +1966,22 @@ async function runDevPipelineDispatch(
     const run = deps.runPtyDrive ?? (await import('../cli/pty-drive-cli.js')).runPtyDrive;
     return { plan, kind: 'shell-drive', result: await run(plan.drive!) };
   }
+  const confirmNonGit = async (target: string): Promise<void> => {
+    const ask = deps.askNonGitInit ?? (async (prompt: string) => {
+      const reader = createInterface({ input: process.stdin, output: process.stderr });
+      try { return await reader.question(prompt); }
+      finally { reader.close(); }
+    });
+    const decision = await decideNonGitInit({
+      target,
+      interactive: deps.nonGitInteractive ?? (process.stdin.isTTY === true),
+      assumeYes: spec.assumeYes === true,
+      ask,
+    });
+    if (decision !== 'init') {
+      throw new DevPipelineError('git 저장소가 필요합니다 — `git init` 하거나 `--yes` 로 다시 · (다음 판: 그림자 저장소 — RFC P19)', 2);
+    }
+  };
   const provisionForeignWorkingRepository = (cwd: string): void => {
     const topLevel = (dir: string): string | null => {
       const r = runGitCommand(dir, ['rev-parse', '--show-toplevel'], { encoding: 'utf8', timeout: 30_000 });
@@ -1875,7 +2005,7 @@ async function runDevPipelineDispatch(
   const applyRemoteLessCompletion = (repoRoot: string): void => {
     const remote = observeTargetRemote(repoRoot, deps.runGit);
     debug.log('dev-pipeline', 'target-remote', remote);
-    const resolved = resolveTargetRemoteCompletion(plan.completion, plan.completionSource, remote);
+    const resolved = resolveTargetRemoteCompletion(plan.completion, plan.completionSource, remote, { naturalLanguageDispatch: spec.self?.naturalLanguageDispatch === true });
     if (resolved.reason) {
       plan.completion = resolved.completion;
       debug.log('dev-pipeline', 'target-remote-completion', {
@@ -1896,10 +2026,17 @@ async function runDevPipelineDispatch(
       if (target.status !== 'git-repo' && target.status !== 'non-git-dir' && target.status !== 'file') {
         throw new DevPipelineError(`target 거부: ${target.reason ?? target.status}`);
       }
-      const provision = (deps.provisionRepository ?? provisionRepository)(target);
+      let provisionTarget = target;
+      if (target.status === 'non-git-dir') {
+        await confirmNonGit(target.canonicalTarget ?? target.target);
+        provisionTarget = revalidateHarnessTarget(target);
+        if (provisionTarget.status !== 'non-git-dir') throw new DevPipelineError(`target 거부: ${provisionTarget.reason ?? provisionTarget.status}`);
+      }
+      const provision = (deps.provisionRepository ?? provisionRepository)(provisionTarget);
       if (provision.status === 'provisioned') {
         plan.target = provision.resolution;
         emitHumanProgress(`[repo-provision] promoted ${provision.target}`, spec.humanReadableOutput !== false, deps.progress);
+        if (provision.ignoreFile.created) emitHumanProgress(`[repo-provision] .gitignore created ${provision.target}`, spec.humanReadableOutput !== false, deps.progress);
       } else {
         emitHumanProgress(`[repo-provision] ${provision.status} ${provision.target}`, spec.humanReadableOutput !== false, deps.progress);
       }
@@ -1909,12 +2046,23 @@ async function runDevPipelineDispatch(
       //   `--target` 블록에만 있어, 원격 없는 로컬 프로젝트가 `auto-merge` 로 떠서 끝에서야 PR 을 못 열고 멎었다
       //   (`gh pr list` 가 「no git remotes found」). 같은 판정을 작업 디렉토리 저장소에도 건다.
       //   원격이 있거나 못 읽으면 종전과 «동일»(elanous 자기 개발 경로 무영향).
-      applyRemoteLessCompletion(deps.cwd ?? process.cwd());
+      const cwd = deps.cwd ?? process.cwd();
+      const workingTarget = resolveHarnessTarget(cwd);
+      if (workingTarget.status === 'non-git-dir') {
+        await confirmNonGit(workingTarget.canonicalTarget ?? workingTarget.target);
+        const checked = revalidateHarnessTarget(workingTarget);
+        if (checked.status !== 'non-git-dir') throw new DevPipelineError(`target 거부: ${checked.reason ?? checked.status}`);
+        const provision = (deps.provisionRepository ?? provisionRepository)(checked);
+        if (provision.status !== 'provisioned') throw new DevPipelineError(`git 저장소 준비 실패: ${provision.status}`);
+        emitHumanProgress(`[repo-provision] promoted ${provision.target}`, spec.humanReadableOutput !== false, deps.progress);
+        if (provision.ignoreFile.created) emitHumanProgress(`[repo-provision] .gitignore created ${provision.target}`, spec.humanReadableOutput !== false, deps.progress);
+      }
+      applyRemoteLessCompletion(cwd);
       // ⛔ 2026-09-23 (벤더 A/B 실측) — 대상 저장소 준비(.gitignore 에 elanous 실행 산출물)가 `--target` 에만 걸려 있어,
       //   사용자 경로(`cd <프로젝트> && elanous harness say`)에선 `.elanous/debug/*.log`·`latest` 링크·liveness 하트비트가
       //   사용자 저장소 커밋에 섞였다 ⇒ 리뷰 must-fix(범위 이탈·diff 가 로그에 끊김·역방향 검증 실패) 로 kimi·glm 이 abandoned.
       //   ⇒ 작업 디렉토리가 «elanous 도구 자신의 저장소가 아닐 때만» 같은 준비를 건다(elanous 자기 개발 경로 무영향).
-      provisionForeignWorkingRepository(deps.cwd ?? process.cwd());
+      provisionForeignWorkingRepository(cwd);
     }
     const run = deps.runSelfImplement ?? (await import('../self-implement/orchestrator.js')).runSelfImplement;
     const defaultSeams = deps.buildSelfImplementSeams

package/src/self-dev/draft-sweep.ts

@@ -0,0 +1,231 @@
+import { CLAIM_IDLE_HOURS, PR_LABELS } from '../github/pr-labels.js';
+import { decideDraft, type DraftTriagePr } from './draft-triage-rules.js';
+
+export interface SweepDraft extends DraftTriagePr {
+  readonly title: string;
+  readonly labels: readonly string[];
+  readonly createdAt: string;
+  /** Last PR update (push, label, comment). Missing ⇒ running claim stays untouched; other drafts use legacy triage. */
+  readonly updatedAt?: string;
+  readonly runId?: string | null;
+}
+
+export interface SweepMergedPr extends DraftTriagePr {
+  readonly title: string;
+}
+
+export interface DraftSweepAdapters {
+  /** Each call returns one complete page; a rejection must not be mistaken for an empty page. */
+  listDrafts(page: number, perPage: number, repository: string): Promise<readonly SweepDraft[]>;
+  listMerged(page: number, perPage: number, repository: string): Promise<readonly SweepMergedPr[]>;
+  /** Undefined means no run assessment; it does not authorize a close. */
+  getRunStatus(draft: SweepDraft, repository: string): Promise<string | undefined>;
+  /** Undefined means liveness could not be established. */
+  listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
+  setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void>;
+  closeDraft(repository: string, number: number, comment: string): Promise<void>;
+  /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
+  getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
+}
+
+export interface DraftSweepOptions {
+  repository: string;
+  adapters: DraftSweepAdapters;
+  apply?: boolean;
+  now?: Date;
+}
+
+export interface DraftSweepEntry {
+  number: number;
+  action: 'keep' | 'close' | 'report';
+  reason: string;
+  statusLabel?: string;
+  applied: boolean;
+  /** Labels changed successfully, but the requested close failed. */
+  partialApplied?: boolean;
+  error?: string;
+}
+
+export interface DraftSweepResult {
+  repository: string;
+  apply: boolean;
+  complete: boolean;
+  entries: DraftSweepEntry[];
+  /** Drafts whose run could not be observed from here (kept, or closed by the idle rule). */
+  unobserved?: number;
+  /** Closes decided this tick (at most DRAFT_SWEEP_CLOSE_CAP). */
+  closed?: number;
+  /** Fresh running claims protected this tick. */
+  claimed?: number;
+  /** Running claims older than the idle window, including those kept by liveness. */
+  claimExpired?: number;
+  error?: string;
+}
+
+const stateLabels = PR_LABELS.filter((label) => label.axis === 'state');
+const label = (action: 'mark-stalled' | 'close', name?: string): string => {
+  const match = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === action && (name === undefined || entry.name.endsWith(name)));
+  if (!match) throw new Error(`Missing registered PR state for ${action}`);
+  return match.name;
+};
+const runningLabel = label('mark-stalled');
+const stalledLabel = label('close', 'stalled');
+const supersededLabel = label('close', 'superseded');
+const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
+const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
+const PAGE_SIZE = 100;
+/** 🅢 2026-09-28 (lead decision, channel #20798 04:1x): a run the sweeper cannot see is closed as stalled only when its branch
+ *  is not in a host worktree and the draft has been idle this long. A Pod lives at most POD_JOB_DEADLINE_SECONDS (3h), so a
+ *  draft idle for 48h cannot belong to a running Pod — the «not in a running Pod» condition follows from the idle time. */
+export const UNOBSERVED_IDLE_CLOSE_HOURS = 48;
+/** At most this many closes per tick, so a wrong rule cannot close everything at once. */
+export const DRAFT_SWEEP_CLOSE_CAP = 10;
+
+async function collectPages<T>(fetch: (page: number, perPage: number) => Promise<readonly T[]>): Promise<T[]> {
+  const rows: T[] = [];
+  for (let page = 1; page <= 100; page++) {
+    const next = await fetch(page, PAGE_SIZE);
+    if (!Array.isArray(next) || next.length > PAGE_SIZE) throw new Error('Incomplete PR page');
+    rows.push(...next);
+    if (next.length < PAGE_SIZE) return rows;
+  }
+  throw new Error('PR listing exceeded pagination limit');
+}
+
+/** A failed inventory or liveness lookup is never treated as proof that a draft can be closed. */
+export async function runDraftSweep({ repository, adapters, apply = false, now = new Date() }: DraftSweepOptions): Promise<DraftSweepResult> {
+  const result: DraftSweepResult = { repository, apply, complete: false, entries: [] };
+  let drafts: SweepDraft[];
+  let merged: SweepMergedPr[];
+  let liveBranches: ReadonlySet<string> | undefined;
+  try {
+    [drafts, merged, liveBranches] = await Promise.all([
+      collectPages((page, size) => adapters.listDrafts(page, size, repository)),
+      collectPages((page, size) => adapters.listMerged(page, size, repository)),
+      adapters.listLiveBranches(repository),
+    ]);
+    if (!liveBranches) throw new Error('Branch liveness unavailable');
+    if (drafts.some((pr) => !Number.isInteger(pr.number) || !pr.branch || !Array.isArray(pr.labels) || !Number.isFinite(Date.parse(pr.createdAt)))
+      || merged.some((pr) => !Number.isInteger(pr.number) || !pr.branch)) throw new Error('Invalid PR inventory');
+  } catch (error) {
+    result.error = String(error);
+    return result;
+  }
+  let statuses: Map<number, string | undefined>;
+  try {
+    statuses = new Map<number, string | undefined>();
+    for (const draft of drafts) statuses.set(draft.number, await adapters.getRunStatus(draft, repository));
+  } catch (error) {
+    result.error = String(error);
+    return result;
+  }
+  result.complete = true;
+  let closes = 0;
+  let unobserved = 0;
+  let claimed = 0;
+  let claimExpired = 0;
+  for (const draft of drafts) {
+    const runStatus = statuses.get(draft.number);
+    const states = stateLabels.filter((state) => draft.labels.includes(state.name));
+    const contradiction = states.length > 1 || draft.labels.includes(approvalLabel ?? '');
+    if (!contradiction && draft.labels.includes(keepLabel ?? '')) {
+      result.entries.push({ number: draft.number, action: 'keep', reason: `label:${keepLabel}`, applied: false });
+      continue;
+    }
+    const isClaimed = !contradiction && draft.labels.includes(runningLabel);
+    const ageHours = (now.getTime() - Date.parse(draft.createdAt)) / 3_600_000;
+    // An unobserved claim may still have a merged twin: liveness/holds retain their priority,
+    // but a superseded draft must not be hidden by the six-hour claim window.
+    const mergedDecision = isClaimed ? decideDraft({ draft, runStatus: runStatus ?? 'ended-unclosed', mergedTwins: merged, liveBranches, ageHours }) : undefined;
+    const supersededClaim = mergedDecision?.reason.startsWith('superseded-by #') === true;
+    // Without an observed update time, neither expiration nor a fallback to creation time can authorize mutation —
+    // but a merged twin does not need the update time, so superseded keeps its priority over the unobserved claim.
+    if (isClaimed && !supersededClaim && (typeof draft.updatedAt !== 'string' || !Number.isFinite(Date.parse(draft.updatedAt)))) {
+      result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-update-unobserved', applied: false });
+      continue;
+    }
+    const claimIdleHours = draft.updatedAt === undefined ? NaN : (now.getTime() - Date.parse(draft.updatedAt)) / 3_600_000;
+    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours < CLAIM_IDLE_HOURS) {
+      claimed += 1;
+      result.entries.push({ number: draft.number, action: 'keep', reason: `label:running(<${CLAIM_IDLE_HOURS}h)`, applied: false });
+      continue;
+    }
+    if (isClaimed && !supersededClaim && Number.isFinite(claimIdleHours) && claimIdleHours >= CLAIM_IDLE_HOURS) {
+      claimExpired += 1;
+      if (runStatus === 'running' || runStatus === 'probable-running' || liveBranches.has(draft.branch)) {
+        result.entries.push({ number: draft.number, action: 'keep', reason: 'claim-expired-but-live', applied: false });
+        continue;
+      }
+      const action = closes >= DRAFT_SWEEP_CLOSE_CAP ? 'keep' : 'close';
+      if (action === 'close') closes += 1;
+      const entry: DraftSweepEntry = { number: draft.number, action, reason: action === 'close' ? 'claim-expired' : 'close-cap',
+        ...(action === 'close' ? { statusLabel: stalledLabel } : {}), applied: false };
+      result.entries.push(entry);
+      if (!apply || action !== 'close') continue;
+      let labelsChanged = false;
+      try {
+        const owner = await adapters.getClaimOwner?.(repository, draft.number) ?? '미상';
+        await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
+        labelsChanged = true;
+        await adapters.closeDraft(repository, draft.number,
+          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — 런·워크트리 없음 · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+        entry.applied = true;
+      } catch (error) {
+        if (labelsChanged) entry.partialApplied = true;
+        entry.error = String(error);
+      }
+      continue;
+    }
+    // Unlabelled non-harness drafts are outside the sweeper's jurisdiction.
+    if (!contradiction && !states.length && !draft.branch.startsWith('self-impl/')) {
+      result.entries.push({ number: draft.number, action: 'keep', reason: 'outside-harness', applied: false });
+      continue;
+    }
+    let decision = supersededClaim ? mergedDecision! : decideDraft({ draft, runStatus, mergedTwins: merged, liveBranches, ageHours });
+    if (decision.reason === 'unobserved') {
+      unobserved += 1;
+      const idleHours = (now.getTime() - Date.parse(draft.updatedAt ?? draft.createdAt)) / 3_600_000;
+      if (!liveBranches.has(draft.branch) && Number.isFinite(idleHours) && idleHours >= UNOBSERVED_IDLE_CLOSE_HOURS) {
+        decision = { action: 'close', reason: 'unobserved-idle' };
+      }
+    }
+    if (!contradiction && decision.action === 'close') {
+      if (closes >= DRAFT_SWEEP_CLOSE_CAP) decision = { action: 'keep', reason: 'close-cap' };
+      else closes += 1;
+    }
+    const action = contradiction ? 'report' : decision.action;
+    const reason = contradiction
+      ? (states.length > 1 ? 'conflicting-state-labels' : 'approval-label-on-draft')
+      : decision.reason;
+    const isLive = decision.reason === 'live';
+    const target = action === 'report' ? undefined : action === 'close'
+      ? decision.reason.startsWith('superseded-by #') ? supersededLabel : stalledLabel
+      : isLive ? (states.length ? runningLabel : undefined) : runStatus && (states[0]?.name === runningLabel || states.length === 0) ? stalledLabel : undefined;
+    const entry: DraftSweepEntry = { number: draft.number, action, reason, ...(target ? { statusLabel: target } : {}), applied: false };
+    result.entries.push(entry);
+    if (!apply || action === 'report') continue;
+    let labelsChanged = false;
+    try {
+      if (target && !draft.labels.includes(target)) {
+        await adapters.setLabels(repository, draft.number, {
+          add: target, remove: states.map((state) => state.name).filter((name) => name !== target),
+        });
+        labelsChanged = true;
+      }
+      if (action === 'close') {
+        await adapters.closeDraft(repository, draft.number, decision.reason === 'unobserved-idle'
+          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${UNOBSERVED_IDLE_CLOSE_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
+          : `Draft sweep: ${decision.reason}. Branch preserved.`);
+      }
+      entry.applied = labelsChanged || action === 'close';
+    } catch (error) {
+      if (labelsChanged && action === 'close') entry.partialApplied = true;
+      entry.error = String(error);
+    }
+  }
+  result.unobserved = unobserved;
+  result.closed = closes;
+  result.claimed = claimed;
+  result.claimExpired = claimExpired;
+  return result;
+}

package/src/self-dev/draft-triage-rules.ts

@@ -0,0 +1,42 @@
+import { PR_LABELS, STALLED_DRAFT_HOURS } from '../github/pr-labels.js';
+
+export interface DraftTriagePr {
+  number: number;
+  title?: string;
+  branch: string;
+  labels?: readonly string[];
+}
+
+export interface DraftTriageInput {
+  draft: DraftTriagePr;
+  runStatus: string | undefined;
+  mergedTwins: readonly DraftTriagePr[];
+  ageHours: number;
+  liveBranches: ReadonlySet<string>;
+}
+
+export type DraftDecision = { action: 'close' | 'keep'; reason: string };
+
+// Labels the sweeper must never close: an approval-waiting state and the human «keep» / release holds (R-PRK3).
+const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>(PR_LABELS
+  .filter((label) => label.sweep.action === 'exclude' || (label.axis === 'state' && label.sweep.action === 'none'))
+  .map((label) => label.name));
+
+const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
+
+export function decideDraft({ draft, runStatus, mergedTwins, ageHours, liveBranches }: DraftTriageInput): DraftDecision {
+  const held = draft.labels?.find((label) => PROTECTED_LABELS.has(label));
+  if (held) return { action: 'keep', reason: `label:${held}` };
+  if (runStatus === 'running' || runStatus === 'probable-running' || (draft.branch && liveBranches.has(draft.branch))) {
+    return { action: 'keep', reason: 'live' };
+  }
+  // A missing assessment never authorizes a close; unknown is the running-run query's non-running classification.
+  if (!runStatus) return { action: 'keep', reason: 'unobserved' };   // run status unknown — kept, and said so
+  const lineage = goalId(draft.branch);
+  const twin = mergedTwins.find((pr) => pr.number !== draft.number && (
+    (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
+  ));
+  if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  if (Number.isFinite(ageHours) && ageHours >= STALLED_DRAFT_HOURS) return { action: 'close', reason: 'stale-ended-run' };
+  return { action: 'keep', reason: 'recent' };
+}