elanous 0.2.0 → 0.2.5

package/src/harness/harness-cli-command.ts

@@ -1,17 +1,25 @@
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Command, Option } from 'commander';
 import { runGitCommand } from '../git-fs/runner.js';
-import { GOAL_TYPES, parseGoalType, type GoalType } from '../self-implement/goal-author.js';
-import { parseRunControlValue } from '../self-implement/run-controls.js';
+import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
-import { loadFederatedRunLedger, loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
+import { listRunLedgers, loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerMatch } from '../self-implement/run-ledger.js';
 import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
+import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
+import { runDraftSweep, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr } from '../self-dev/draft-sweep.js';
+import { debug } from '../debug/log.js';
+import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
+import { PR_LABELS } from '../github/pr-labels.js';
+import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
+import { getUserConfig } from '../user-config.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
+import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
 import { runHarnessPlanRfc } from './harness-plan-rfc.js';
 import type { MissionSolveOutcome } from './mission-solve-loop.js';
 import { formatAxis, formatAxisObservations, inspectAskMarkers, inspectUnpressedDecisionSignals } from '../../scripts/ask-marker-check.js';
@@ -74,12 +82,13 @@ export interface HarnessAskSayOptions {
   json?: boolean;
   base?: string;
   target?: string;
+  yes?: boolean;
   forcePreflight?: boolean;
   autoMerge?: boolean;
+  mergeByHost?: boolean;
   observeOnly?: boolean;
   supervise?: boolean;
   supervisorSource?: HarnessSupervisorSource;
-  graph?: boolean;
   goalType?: GoalType;
   correlation?: string;
 }
@@ -134,7 +143,7 @@ async function runInjectedHarnessHandler(run: () => Promise<void>): Promise<void
     await run();
   } catch (error) {
     console.error(humanErrorLine(error));
-    process.exitCode = 1;
+    process.exitCode = error instanceof DevPipelineError ? error.exitCode : 1;
   }
 }
 
@@ -143,13 +152,9 @@ function registerHarnessCommonOptions(command: Command): Command {
     .option('--json', '구조화 출력')
     .option('--base <branch>', '분기 base')
     .addOption(new Option('--no-auto-merge', 'self: PR 생성 후 자동 병합을 끔'))
+    .option('--merge-by-host', 'Pod: merge-ready 까지 실행하고 병합은 발사 호스트가 재게이트')
     .option('--observe-only', 'elanous: child boot부터 SelfImplement 호출을 기록만 한다')
     .addOption(new Option('--no-supervise', 'self: supervisor 재개를 끔').hideHelp())
-    .option('--graph <on|off>', 'self: graph authority를 이번 런에만 설정', (value: string) => {
-      const parsed = parseRunControlValue('graph', value);
-      if (parsed === undefined) throw new HarnessCliInputError(`--graph 값은 on 또는 off여야 함: ${value}`);
-      return parsed as boolean;
-    })
     .option('--dry-run', '변경 없이 발사 계획만 출력');
 }
 
@@ -195,13 +200,16 @@ function printHarnessAskMarkerDryRun(goalPath?: string): void {
     const warnings = inspectHarnessAskMarkerWarnings(ask);
     if (warnings.length === 0) {
       console.log('[dry-run] ✅ ask 마커 — 경고 없음');
-      return;
+    } else {
+      for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
     }
-    for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
   } catch (error) {
     const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
     console.log(`[dry-run] ⚠️ ask 마커 — 검사 실패: ${message}`);
   }
+  for (const finding of lintGoalFile(ask, 'main').filter(({ tag }) => tag === 'release-note')) {
+    console.log(`[dry-run] ⚠️ 릴리스 노트 — ${finding.message}`);
+  }
 }
 
 function printHarnessLaunchDryRun(preview: {
@@ -210,15 +218,15 @@ function printHarnessLaunchDryRun(preview: {
   readonly wouldStart: string;
   readonly goalPath?: string;
   readonly goalType?: GoalType;
-  readonly graph?: boolean;
   readonly target?: string;
 }): void {
   console.log(`[dry-run] 입력: ${preview.input}`);
   console.log(`[dry-run] 입구: ${preview.entrance}`);
   console.log(`[dry-run] 시작 예정: ${preview.wouldStart}`);
-  console.log('[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
+  console.log(preview.goalPath
+    ? '[dry-run] 전제 검사: ask 마커·릴리스 노트 린트만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음'
+    : '[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
   printHarnessAskMarkerDryRun(preview.goalPath);
-  if (preview.graph !== undefined) console.log(`[dry-run] graph authority: ${preview.graph ? 'on' : 'off'}`);
   if (preview.goalPath) console.log(renderGoalTemplateDryRun(preview.goalPath, preview.goalType));
   if (preview.target !== undefined) {
     const target = resolveHarnessTarget(preview.target);
@@ -229,12 +237,17 @@ function printHarnessLaunchDryRun(preview: {
 function registerHarnessAskSayOptions(command: Command): Command {
   return registerHarnessCommonOptions(command)
     .option('--target <path>', 'self: harness가 작업할 레포 또는 디렉터리(self-mission 전용)')
+    .option('--yes', 'git 아닌 프로젝트에 git init 및 첫 커밋을 만들도록 동의')
     .option('--correlation <id>', '요청과 런을 잇는 불투명 correlation 값')
     .addOption(new Option('--goal-type <type>', `골 종류 (${GOAL_TYPES.join('|')})`).choices([...GOAL_TYPES]))
     .option('--force-preflight', '전제 검사 막힘을 명시 요청으로 우회(관측에 남음)')
     .option('--child-llm-provider <id>', 'self: 구현 자식 LLM provider(--child-llm-model과 함께)')
     .option('--child-llm-model <id>', 'self: 구현 자식 LLM model(--child-llm-provider와 함께)')
-    .option('--child-llm-effort <level>', 'self: 구현 자식 추론 노력 minimal|low|medium|high|xhigh|max — 모델 상한을 넘으면 «거부»한다(--child-llm-provider와 함께)');
+    .option('--child-llm-effort <level>', 'self: 구현 자식 추론 노력 minimal|low|medium|high|xhigh|max — 모델 상한을 넘으면 «거부»한다(--child-llm-provider와 함께)')
+    .addOption(new Option('--substrate <kind>', '실행 칸 — local(설정 없을 때 기본 · 이 기계) | pod(k8s Pod · 같은 그래프가 원격에서 돈다)').choices(['local', 'pod']))
+    .option('--pod-pool <spec>', 'pod: 풀 — 인자 > ELANOUS_POD_POOL > harness.podPool > 기존 pod.pool > 현재 컨텍스트')
+    .addOption(new Option('--pod-memory <tier>', 'pod: 메모리 등급 — standard(16Gi) | high(32Gi) · 없으면 골 문면 `Pod 메모리: high` 줄 · 그것도 없으면 골이 apps/pwa/ 를 담을 때 high').choices(['standard', 'high']))
+    .option('--source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · `--substrate pod` 와 함께');
 }
 
 function registerHarnessPlanOptions(command: Command): Command {
@@ -257,9 +270,10 @@ function normalizeHarnessCommonOptions(opts: HarnessAskSayOptions): HarnessAskSa
     ...(opts.json ? { json: true } : {}),
     ...(opts.base !== undefined ? { base: opts.base } : {}),
     ...(opts.target !== undefined ? { target: opts.target } : {}),
+    ...(opts.yes === true ? { yes: true } : {}),
     ...(opts.autoMerge === false ? { autoMerge: false } : {}),
+    ...(opts.mergeByHost === true ? { mergeByHost: true } : {}),
     ...(opts.observeOnly ? { observeOnly: true } : {}),
-    ...(opts.graph !== undefined ? { graph: opts.graph } : {}),
     ...(opts.goalType !== undefined ? { goalType: opts.goalType } : {}),
     ...resolveHarnessSupervisor(opts),
   };
@@ -298,6 +312,83 @@ function assertHarnessChildLlmModel(opts: HarnessAskSayChildLlmOptions): void {
 }
 
 /** Shared post-parse gate: validate child model before any ask/say early return (including `--dry-run`). */
+type HarnessSubstrateOpts = { substrate?: 'local' | 'pod'; podPool?: string; podMemory?: string; autoMerge?: boolean; base?: string; json?: boolean; target?: string; source?: string };
+function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubstrate {
+  const resolved = resolveHarnessSubstrate({ flag: opts, config: getUserConfig(), env: process.env });
+  debug.log('harness.substrate', 'resolved', resolved);
+  const head = `[harness] substrate=${resolved.substrate}${resolved.substrate === 'pod' ? ` pool=${resolved.pool}` : ''} (${resolved.source})`;
+  if (opts.json) console.error(head);
+  else console.log(head);
+  return resolved;
+}
+/** ⭐ 런 계약의 실행 칸 = pod — 호스트는 그래프를 안 돌리고 Pod 로 보낸다(harness-pod-dispatch.ts). */
+async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-say', input: string, pool: string,
+  recordDispatch: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask> = dispatchTask): Promise<void> {
+  const o = opts as HarnessSubstrateOpts;
+  if (o.target !== undefined) {
+    debug.log('harness.pod', 'target-refused', { target: o.target });
+    console.error('`--target` 은 Pod 경로에서 아직 지원하지 않는다 — 로컬로 돌리거나 `--target` 을 빼라');
+    console.error('Pod 로 특정 원천을 주려면 `--source`');
+    process.exitCode = 2;
+    return;
+  }
+  let dispatchRecorded = false;
+  try {
+    const goalText = entrance === 'cli-harness-ask' ? readFileSync(input, 'utf8') : input;
+    await recordDispatch({
+      goalId: (entrance === 'cli-harness-ask' ? parseGoalId(goalText) : null)
+        ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: entrance === 'cli-harness-ask' ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec: { input: entrance === 'cli-harness-ask' ? { file: input } : { text: input }, humanReadableOutput: false },
+    });
+    dispatchRecorded = true;
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
+  const { dispatchHarnessOnPod } = await import('./harness-pod-dispatch.js');
+  let output = '';
+  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) },
+    entrance === 'cli-harness-ask' ? { onOutput: (text) => { output = (output + text).slice(-16_000); } } : {});
+  if (status !== 0) {
+    let childError: string | undefined;
+    let podFailure: string | undefined;
+    let podJobFailed = false;
+    if (entrance === 'cli-harness-ask') {
+      for (const line of output.split('\n').reverse()) {
+        if (!line.trimStart().startsWith('[{') || !line.includes('"error"')) continue;
+        try {
+          const results: unknown = JSON.parse(line);
+          if (!Array.isArray(results)) continue;
+          for (const result of results) {
+            if (!result || typeof result !== 'object') continue;
+            const error = (result as { error?: { code?: string; message?: string } }).error;
+            if (typeof error?.code !== 'string' || typeof error.message !== 'string' || !error.code.startsWith('pod-')) continue;
+            if (error.code === 'pod-job-failed') {
+              podJobFailed = true;
+              childError = error.message.split('childError=')[1]?.split('\n', 1)[0];
+            }
+            podFailure = error.message;
+            break;
+          }
+        } catch { /* Non-result stdout cannot establish that a Pod child ran. */ }
+        if (podFailure) break;
+      }
+      if (!podFailure) {
+        const summary = output.split('\n').find((line) => /\s❌\sfailed · .* — pod-[\w-]+: /.test(line));
+        podFailure = summary?.split(/\s❌\sfailed · .* — pod-[\w-]+: /)[1];
+        podJobFailed = summary?.includes(' — pod-job-failed: ') ?? false;
+        if (podJobFailed) childError = podFailure?.split('childError=')[1]?.split('\n', 1)[0];
+      }
+    }
+    if (podJobFailed && childError && childError !== 'no-result-line') console.error(`Pod 안 자식이 실패했다 — ${childError}`);
+    else if (podFailure) console.error(`Pod 실행이 실패했다 — ${podFailure.split('\n', 1)[0]}`);
+    else console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
+    process.exitCode = status;
+  }
+}
+
 async function dispatchHarnessAskSay(
   opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts,
   dryRunPreview: {
@@ -306,15 +397,16 @@ async function dispatchHarnessAskSay(
     readonly wouldStart: string;
     readonly goalPath?: string;
   },
-  dispatch: () => Promise<void>,
+  dispatch: (resolved: ResolvedHarnessSubstrate) => Promise<void>,
 ): Promise<void> {
   await runInjectedHarnessHandler(async () => {
     assertHarnessChildLlmModel(opts);
+    const resolved = resolveLaunchSubstrate(opts);
     if (isHarnessDryRun(opts)) {
       printHarnessLaunchDryRun(dryRunPreview);
       return;
     }
-    await dispatch();
+    await dispatch(resolved);
   });
 }
 
@@ -1151,6 +1243,289 @@ function defaultListHarnessWorktreePaths(): HarnessWorktreeListObservation {
   }
 }
 
+/** 사람 모드 한 줄. JSON 은 호출자가 마지막 줄에 따로 찍는다. */
+export function formatBudgetLine(decision: BudgetDecision): string {
+  const who = decision.provider
+    ? `${decision.provider}${decision.model ? `/${decision.model}` : ''}`
+    : '(provider 없음)';
+  const why = decision.reasons.length > 0 ? decision.reasons.join(' · ') : '(이유 없음)';
+  return `budget: ${decision.action} ${who} — ${why}`;
+}
+
+/** 마지막 줄 JSON. `outcome` 은 그래프 러너가 간선을 고르는 칸과 같은 이름이다. */
+export function budgetOutcomeJson(decision: BudgetDecision): string {
+  return JSON.stringify({
+    outcome: decision.action,
+    provider: decision.provider ?? null,
+    model: decision.model ?? null,
+    reasons: [...decision.reasons],
+  });
+}
+
+/**
+ * `elanous harness budget [--json]`.
+ * 읽기(`readBudgetInputs`)와 판정(`decideBudget`)을 이 순서로 부른다.
+ * dev-cli·흡수 크론에 자동 적용하지 않는다.
+ */
+export async function runHarnessBudget(opts: { json?: boolean } = {}, io: {
+  log: (line: string) => void;
+  read?: () => BudgetInputs | Promise<BudgetInputs>;
+} = { log: (line) => console.log(line) }): Promise<BudgetDecision> {
+  const inputs = await (io.read ?? readBudgetInputsLive)();
+  const decision = decideBudget(inputs);
+  try {
+    debug.log('harness.budget-gate', 'decided', {
+      action: decision.action,
+      provider: decision.provider,
+      reasons: [...decision.reasons],
+    });
+  } catch { /* observation must not block the decision */ }
+  if (opts.json) {
+    io.log(budgetOutcomeJson(decision));
+  } else {
+    io.log(formatBudgetLine(decision));
+  }
+  return decision;
+}
+
+const DRAFT_SWEEP_REPOSITORY = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+
+type GithubPull = {
+  number: number;
+  title: string;
+  draft: boolean;
+  state: 'open' | 'closed';
+  head: { ref: string };
+  labels: Array<{ name: string }>;
+  created_at: string;
+  updated_at?: string;
+  merged_at: string | null;
+};
+
+type GhExecute = (args: string[]) => string;
+
+// ⛔ `env: process.env` is required: Bun resolves the executable against the PATH it started with, not the one
+//    ensure-bin-path augments. Under cron's minimal PATH the hourly sweep died with «Executable not found: gh» (2026-09-28).
+const executeGh: GhExecute = (args) => execFileSync('gh', args, {
+  encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024,
+  stdio: ['ignore', 'pipe', 'pipe'], env: process.env,
+});
+
+function ghJson<T>(args: string[], execute: GhExecute): T {
+  return JSON.parse(execute(args)) as T;
+}
+
+function githubPullsPage(repository: string, state: 'open' | 'closed', page: number, execute: GhExecute): GithubPull[] {
+  // Closed PRs newest-updated first: a merged twin that matters was merged after the oldest open draft, so paging can stop there.
+  const order = state === 'closed' ? '&sort=updated&direction=desc' : '';
+  return ghJson<GithubPull[]>(['api', `repos/${repository}/pulls?state=${state}${order}&per_page=100&page=${page}`], execute);
+}
+
+function ledgerPrRepository(data: Record<string, unknown>, number: number): string | undefined {
+  const value = data.repository ?? data.repo ?? data.nameWithOwner;
+  const named = typeof value === 'string' ? value : value && typeof value === 'object'
+    ? (value as Record<string, unknown>).nameWithOwner ?? (value as Record<string, unknown>).full_name : undefined;
+  const url = data.url ?? data.html_url;
+  const match = typeof url === 'string'
+    ? /^https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/(\d+)(?:[/?#].*)?$/.exec(url)
+    : null;
+  if (typeof url === 'string' && (!match || Number(match[2]) !== number)) return undefined;
+  const fromUrl = match?.[1];
+  if (typeof named === 'string' && fromUrl && named !== fromUrl) return undefined;
+  const repository = typeof named === 'string' ? named : fromUrl;
+  return repository && DRAFT_SWEEP_REPOSITORY.test(repository) ? repository : undefined;
+}
+
+/** A PR number alone is not run identity; ledgers without verifiable repository ownership stay unknown. */
+export function draftSweepRunStatus(ledgerMatches: readonly RunLedgerMatch[], running: ReadonlyMap<string, string>,
+  repository: string, number: number): string | undefined {
+  const statuses = new Set<string>();
+  for (const match of ledgerMatches) {
+    const prEvents = match.entries.filter((entry) => entry.event === 'pr-opened' && entry.data.number === number);
+    if (prEvents.length === 0 || prEvents.some((entry) => ledgerPrRepository(entry.data, number) !== repository)) continue;
+    const terminal = [...match.entries].reverse().find((item) => item.event === 'run-status')?.data.runStatus;
+    const status = running.get(match.runId) ?? (typeof terminal === 'string' &&
+      ['completed', 'failed', 'cancelled', 'abandoned'].includes(terminal) ? terminal : undefined);
+    if (status && status !== 'unknown') statuses.add(status);
+  }
+  return statuses.size === 1 ? [...statuses][0] : undefined;
+}
+
+type DraftSweepGitExecute = (cwd: string, args: string[]) => Pick<ReturnType<typeof runGitCommand>, 'status' | 'stdout' | 'stderr'>;
+
+function githubRemoteRepository(url: string): string | undefined {
+  const remote = url.trim();
+  const match = /^(?:https:\/\/github\.com\/|git@github\.com:|ssh:\/\/git@github\.com\/)([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\.git)?\/?$/i.exec(remote);
+  return match?.[1];
+}
+
+export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand): DraftSweepAdapters {
+  const inventory = async (repository: string, state: 'open' | 'closed'): Promise<GithubPull[]> => {
+    // ⛔ A large repository has tens of thousands of closed PRs (2026-09-28: 21k → «exceeded pagination limit», no sweep at all).
+    //    Merged twins only matter after the oldest open draft was opened, so the closed listing stops at that time.
+    let cutoff: number | undefined;
+    if (state === 'closed') {
+      const drafts = (await listed(open, repository, 'open')).filter((pr) => pr.draft);
+      if (drafts.length === 0) return [];
+      cutoff = Math.min(...drafts.map((pr) => Date.parse(pr.created_at)));
+      if (!Number.isFinite(cutoff)) throw new Error('Incomplete GitHub PR inventory');
+    }
+    const all: GithubPull[] = [];
+    for (let page = 1; page <= 100; page++) {
+      const batch = githubPullsPage(repository, state, page, execute);
+      if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete GitHub PR inventory');
+      all.push(...batch);
+      if (batch.length < 100) return all;
+      // An unknown update time cannot prove the rest is older — keep paging.
+      const oldest = Date.parse(batch[batch.length - 1]!.updated_at ?? '');
+      if (cutoff !== undefined && Number.isFinite(oldest) && oldest < cutoff) return all;
+    }
+    throw new Error('GitHub PR inventory exceeded pagination limit');
+  };
+  const open = new Map<string, Promise<GithubPull[]>>();
+  const closed = new Map<string, Promise<GithubPull[]>>();
+  const listed = (cache: Map<string, Promise<GithubPull[]>>, repository: string, state: 'open' | 'closed') => {
+    if (!cache.has(repository)) cache.set(repository, inventory(repository, state));
+    return cache.get(repository)!;
+  };
+  let ledgerMatches: readonly RunLedgerMatch[] | undefined;
+  let running: ReadonlyMap<string, string> | undefined;
+  const runStatusFor = (repository: string, number: number): string | undefined => {
+    ledgerMatches ??= listRunLedgers().matches;
+    running ??= new Map(queryRunningRuns().entries.map((entry) => [entry.runId, entry.status]));
+    return draftSweepRunStatus(ledgerMatches, running, repository, number);
+  };
+  return {
+    listDrafts: async (page, perPage, repository): Promise<SweepDraft[]> =>
+      (await listed(open, repository, 'open')).filter((pr) => pr.draft)
+        .slice((page - 1) * perPage, page * perPage)
+        .map((pr) => ({ number: pr.number, title: pr.title, branch: pr.head.ref,
+          labels: pr.labels.map((item) => item.name), createdAt: pr.created_at, ...(pr.updated_at ? { updatedAt: pr.updated_at } : {}) })),
+    listMerged: async (page, perPage, repository): Promise<SweepMergedPr[]> =>
+      (await listed(closed, repository, 'closed')).filter((pr) => pr.merged_at !== null)
+        .slice((page - 1) * perPage, page * perPage)
+        .map((pr) => ({ number: pr.number, title: pr.title, branch: pr.head.ref })),
+    getRunStatus: async (draft, repository) => runStatusFor(repository, draft.number),
+    listLiveBranches: async (repository) => {
+      const cwd = process.cwd();
+      const remote = git(cwd, ['config', '--get', 'remote.origin.url']);
+      if (remote.status !== 0 || githubRemoteRepository(remote.stdout)?.toLowerCase() !== repository.toLowerCase()) {
+        return undefined;
+      }
+      const result = git(cwd, ['worktree', 'list', '--porcelain']);
+      if (result.status !== 0) return undefined;
+      return new Set(result.stdout.split('\n').filter((line) => line.startsWith('branch refs/heads/'))
+        .map((line) => line.slice('branch refs/heads/'.length).trim()));
+    },
+    setLabels: async (repository, number, change) => {
+      execute(['pr', 'edit', String(number), '--repo', repository, '--add-label', change.add,
+        ...change.remove.flatMap((name) => ['--remove-label', name])]);
+    },
+    closeDraft: async (repository, number, comment) => {
+      execute(['pr', 'close', String(number), '--repo', repository, '--comment', comment]);
+    },
+    getClaimOwner: async (repository, number) => claimCommentOwner(repository, number, execute),
+  };
+}
+
+export interface HarnessDraftSweepDeps {
+  readonly adapters?: DraftSweepAdapters;
+  readonly repository?: () => string;
+  readonly write?: (line: string) => void;
+  readonly execute?: GhExecute;
+  readonly now?: () => Date;
+}
+
+function draftClaimOwner(body: string): string | undefined {
+  return /^🔧 처리 중 — owner ([^\n·]+?) · /m.exec(body)?.[1]?.trim();
+}
+
+async function claimCommentOwner(repository: string, number: number, execute: GhExecute): Promise<string | undefined> {
+  const pages = ghJson<Array<Array<{ body: string }>>>(['api', '--paginate', '--slurp',
+    `repos/${repository}/issues/${number}/comments?per_page=100`], execute);
+  if (!Array.isArray(pages) || pages.some((page) => !Array.isArray(page) || page.some((comment) => typeof comment.body !== 'string'))) {
+    throw new Error('Incomplete claim comments');
+  }
+  return pages.flat().reverse().map((comment) => draftClaimOwner(comment.body)).find((owner) => owner !== undefined);
+}
+
+function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraftSweepDeps = {}): Command {
+  const drafts = harnessCmd.command('drafts').description('하니스 draft PR 정리');
+  drafts.command('claim <number>').description('세션이 처리 중인 draft 를 표식하거나 해제한다')
+    .option('--owner <name>', '처리 주인 (S|T|F|O|이름)')
+    .option('--note <text>', '한 줄 메모')
+    .option('--release', '처리 중 표식을 해제하고 stalled 상태로 전환')
+    .option('--repo <owner/name>', '조회할 GitHub 저장소')
+    .action(async (number: string, opts: { owner?: string; note?: string; release?: boolean; repo?: string }) => {
+      try {
+        const execute = deps.execute ?? executeGh;
+        const repository = opts.repo ?? deps.repository?.() ?? execute(['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner']).trim();
+        if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
+        if (!/^[1-9]\d*$/.test(number) || !Number.isSafeInteger(Number(number))) throw new HarnessCliInputError(`invalid PR number: ${number}`);
+        const owner = opts.owner?.trim();
+        if (!opts.release && (!owner || /[\r\n·]/.test(owner))) throw new HarnessCliInputError('--owner 필요 (한 줄)');
+        if (opts.note !== undefined && /[\r\n]/.test(opts.note)) throw new HarnessCliInputError('--note 는 한 줄이어야 합니다');
+        const pr = ghJson<GithubPull>(['api', `repos/${repository}/pulls/${number}`], execute);
+        const approval = PR_LABELS.find((label) => label.axis === 'state' && label.sweep.action === 'none')!.name;
+        if (pr.state !== 'open' || pr.draft !== true || !Array.isArray(pr.labels) || pr.labels.some((item) => item.name === approval)) throw new HarnessCliInputError('열린 draft 이고 idea-approval 이 아닌 PR 만 claim 할 수 있음');
+        const running = PR_LABELS.find((label) => label.axis === 'state' && label.sweep.action === 'mark-stalled')!.name;
+        const otherStates = PR_LABELS.filter((label) => label.axis === 'state' && label.name !== running && pr.labels.some((item) => item.name === label.name));
+        if (opts.release) {
+          if (!pr.labels.some((item) => item.name === running) || otherStates.length > 0) {
+            throw new HarnessCliInputError('--release 는 running 이 유일한 상태인 draft 에만 사용 가능');
+          }
+          const stalled = PR_LABELS.find((label) => label.axis === 'state' && label.sweep.action === 'close' && label.name.endsWith(':stalled'))!.name;
+          execute(['pr', 'edit', number, '--repo', repository, '--add-label', stalled, '--remove-label', running]);
+          execute(['pr', 'comment', number, '--repo', repository, '--body', `🔧 처리 끝 — ${(deps.now?.() ?? new Date()).toISOString()}`]);
+        } else {
+          execute(['pr', 'edit', number, '--repo', repository, '--add-label', running,
+            ...otherStates.flatMap((item) => ['--remove-label', item.name])]);
+          execute(['pr', 'comment', number, '--repo', repository, '--body',
+            `🔧 처리 중 — owner ${owner} · ${(deps.now?.() ?? new Date()).toISOString()}${opts.note?.trim() ? ` · ${opts.note.trim()}` : ''}`]);
+        }
+        (deps.write ?? console.log)(`#${number} ${opts.release ? 'release' : 'claim'}: ${repository}`);
+      } catch (error) {
+        console.error(humanErrorLine(error));
+        process.exitCode = 1;
+      }
+    });
+  return drafts.command('sweep').description('draft PR 을 조사한다 (기본: 변경 없음)')
+    .option('--apply', '판정한 라벨 변경과 종료를 적용')
+    .option('--json', '판정 결과를 JSON 으로 출력')
+    .option('--repo <owner/name>', '조회할 GitHub 저장소')
+    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string }) => {
+      try {
+        const write = deps.write ?? console.log;
+        const repository = opts.repo ?? deps.repository?.() ?? execFileSync('gh', ['repo', 'view', '--json', 'nameWithOwner', '--jq', '.nameWithOwner'],
+          { encoding: 'utf8', timeout: 30_000, stdio: ['ignore', 'pipe', 'pipe'], env: process.env }).trim();
+        if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) {
+          throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
+        }
+        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? githubDraftSweepAdapters(deps.execute) });
+        if (opts.json) write(JSON.stringify(result));
+        else {
+          write(`draft sweep ${result.repository}: ${result.complete ? 'complete' : `incomplete (${result.error})`} · ${result.apply ? 'apply' : 'dry-run'}`);
+          for (const entry of result.entries) write(`#${entry.number} ${entry.action}: ${entry.reason}${entry.statusLabel ? ` → ${entry.statusLabel}` : ''}${entry.error ? ` ERROR: ${entry.error}` : ''}`);
+          if (result.complete) write(`못 본 초안 ${result.unobserved ?? 0} · 이번에 닫음 ${result.closed ?? 0}${result.apply ? '' : '(dry-run)'} · 처리 중 ${result.claimed ?? 0} · 표식 만료 ${result.claimExpired ?? 0}`);
+        }
+        if (!result.complete || result.entries.some((entry) => entry.error)) process.exitCode = 1;
+      } catch (error) {
+        console.error(humanErrorLine(error));
+        process.exitCode = 1;
+      }
+    });
+}
+
+function installHarnessBudgetCommand(harnessCmd: Command): Command {
+  return harnessCmd
+    .command('budget')
+    .description('선호·사용량·상한으로 이번 판을 돌릴지 정한다. --json 이면 마지막 줄이 outcome JSON.')
+    .option('--json', '마지막 줄에 { outcome, provider, model, reasons } 를 찍는다')
+    .action(async (opts: { json?: boolean }) => {
+      await runHarnessBudget({ json: opts.json === true });
+    });
+}
+
 function installHarnessProcessObservationCommand(
   harnessCmd: Command,
   deps: HarnessProcessObservationDeps = {},
@@ -1181,8 +1556,11 @@ export interface HarnessCliCommandDeps {
   resolveSurface: () => Promise<string>;
   deliverableVerify?: InstallDeliverableVerifyCliDeps;
   processObservation?: HarnessProcessObservationDeps;
+  draftSweep?: HarnessDraftSweepDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
+  /** Observe-only Pod host dispatch seam. */
+  podDispatchTask?: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask>;
   plan?: HarnessPlanHandler;
   /** ⭐ `plan` 주입이 «없을 때» 가는 기본 분기. 시험이 이 자리로 «CLI 의 기본 배선»을 문다
    *  (⛔ 주입된 `plan` 이 파일을 스스로 만들면 그 시험은 배선을 «못 답한다» — 무인 리뷰 GOODHART 지적). */
@@ -1198,6 +1576,8 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   installHarnessCliSinkHook(harnessCmd, deps.registerSink, deps.resolveSurface);
   installDeliverableVerifyCliCommand(harnessCmd, deps.deliverableVerify);
   installHarnessProcessObservationCommand(harnessCmd, deps.processObservation);
+  installHarnessBudgetCommand(harnessCmd);
+  installHarnessDraftSweepCommand(harnessCmd, deps.draftSweep);
 
   const ask = deps.ask;
   if (ask) {
@@ -1211,10 +1591,16 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
             wouldStart: '워크트리 · 브랜치 · 자식 · 파이프라인',
             goalPath,
             ...(opts.goalType !== undefined ? { goalType: opts.goalType } : {}),
-            ...(opts.graph !== undefined ? { graph: opts.graph } : {}),
             ...(opts.target !== undefined ? { target: opts.target } : {}),
           },
-          () => ask(goalPath, normalizeHarnessAskSayOptions(opts)),
+          (resolved) => {
+            if (resolved.substrate !== 'pod' && (opts as { source?: string }).source !== undefined) {
+              console.error('`--source` 는 `--substrate pod` 와 함께');
+              process.exitCode = 2;
+              return Promise.resolve();
+            }
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-ask', goalPath, resolved.pool!, deps.podDispatchTask) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
+          },
         );
       });
   }
@@ -1229,10 +1615,16 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
             input: sentence.join(' '),
             entrance: 'cli-harness-say',
             wouldStart: '골 문서 · 워크트리 · 브랜치 · 자식 · 파이프라인',
-            ...(opts.graph !== undefined ? { graph: opts.graph } : {}),
             ...(opts.target !== undefined ? { target: opts.target } : {}),
           },
-          () => say(sentence, normalizeHarnessAskSayOptions(opts)),
+          (resolved) => {
+            if (resolved.substrate !== 'pod' && (opts as { source?: string }).source !== undefined) {
+              console.error('`--source` 는 `--substrate pod` 와 함께');
+              process.exitCode = 2;
+              return Promise.resolve();
+            }
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask) : say(sentence, normalizeHarnessAskSayOptions(opts));
+          },
         );
       });
   }