elanous 0.2.0 → 0.2.4

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

@@ -4,14 +4,20 @@ 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 { 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 { 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 +80,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 +141,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 +150,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', '변경 없이 발사 계획만 출력');
 }
 
@@ -210,7 +213,6 @@ 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}`);
@@ -218,7 +220,6 @@ function printHarnessLaunchDryRun(preview: {
   console.log(`[dry-run] 시작 예정: ${preview.wouldStart}`);
   console.log('[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 +230,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 +263,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 +305,33 @@ 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): 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;
+  }
+  const { dispatchHarnessOnPod } = await import('./harness-pod-dispatch.js');
+  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) });
+  if (status !== 0) {
+    console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
+    process.exitCode = status;
+  }
+}
+
 async function dispatchHarnessAskSay(
   opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts,
   dryRunPreview: {
@@ -306,15 +340,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 +1186,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,6 +1499,7 @@ export interface HarnessCliCommandDeps {
   resolveSurface: () => Promise<string>;
   deliverableVerify?: InstallDeliverableVerifyCliDeps;
   processObservation?: HarnessProcessObservationDeps;
+  draftSweep?: HarnessDraftSweepDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
   plan?: HarnessPlanHandler;
@@ -1198,6 +1517,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 +1532,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!) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
+          },
         );
       });
   }
@@ -1229,10 +1556,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!) : say(sentence, normalizeHarnessAskSayOptions(opts));
+          },
         );
       });
   }

package/src/harness/harness-pod-dispatch.ts

@@ -0,0 +1,110 @@
+/** ⭐ `harness say/ask --substrate pod` — 호스트는 그래프를 돌리지 않고 Pod 로 보낸다(대표 2026-09-26).
+ *
+ *  대표: «pod 원격 실행은 실행 공간만 다르고 똑같이 그래프 엔지니어링 그래프를 써야» ·
+ *      «harness ask/say --substrate pod 만 써도 알아서 분배».
+ *  ⭐ 풀 해석·이미지 판 동기화(레지스트리 델타)·계정 배분·Job 수명은 이미 `self orchestrate --substrate pod` 에 있다 —
+ *    ⛔ 두 벌로 짓지 않고 그 경로로 넘긴다. Pod 안에서는 골 문서가 있으면 `harness ask`, 아니면 `self implement` 가 돌고,
+ *    매니페스트가 실은 런 계약(`ELANOUS_RUN_CONTRACT`)으로 자기가 Pod 인 줄 안다(graph-run-contract.ts).
+ */
+import { spawn } from 'node:child_process';
+import { readFileSync, realpathSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { findGitDir } from '../git-fs/locate.js';
+import { debug } from '../debug/log.js';
+import { ELANOUS_ENTRY_SCRIPT } from '../self-implement/seams.js';
+import { parsePodSourceSpec } from '../task-orchestrator/surfaces/pod-source-spec.js';
+
+export interface HarnessPodDispatchInput {
+  readonly entrance: 'cli-harness-ask' | 'cli-harness-say';
+  /** say 의 문장, 또는 ask 의 골 문서 경로. */
+  readonly input: string;
+  readonly podPool?: string;
+  /** Pod 메모리 등급(standard|high) — 오케스트레이터 환경 `ELANOUS_POD_MEMORY_TIER` 로 Job 까지 간다. */
+  readonly podMemory?: string;
+  readonly autoMerge?: boolean;
+  readonly base?: string;
+  readonly json?: boolean;
+  /** 사람이 고른 원천 spec — `commit:` · `pr:` · `worktree:` · `files:`. 검증은 발사 전. */
+  readonly source?: string;
+}
+
+/** 오케스트레이터가 `;;` 로 골을 나누므로 한 골 안의 `;;` 는 풀어 둔다(한 발 = 한 골). */
+export function podGoalText(input: HarnessPodDispatchInput, readFile: (path: string) => string = (p) => readFileSync(p, 'utf8')): string {
+  // 오케스트레이터에는 내용도 보내고, 저장소 안의 ask 는 별도로 Secret 을 통해 Pod 클론에 심는다.
+  const text = input.entrance === 'cli-harness-ask' ? readFile(input.input) : input.input;
+  return text.replace(/;;/gu, '; ;');
+}
+
+export function podOrchestrateArgs(input: HarnessPodDispatchInput, goal: string): string[] {
+  return [
+    ELANOUS_ENTRY_SCRIPT, 'self', 'orchestrate', goal,
+    '--substrate', 'pod',
+    ...(input.podPool ? ['--pod-pool', input.podPool] : []),
+    // 하니스 기본(자동 병합)을 따른다 · 끄면 PR 까지 — 어느 쪽이든 Pod 가 사라져도 결과가 남는다.
+    ...(input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
+    ...(input.base ? ['--base', input.base] : []),
+    ...(input.json ? ['--json'] : []),
+    ...(input.source ? ['--pod-source', input.source] : []),
+    '--concurrency', '1',
+  ];
+}
+
+type PodDispatchDeps = { run?: (cmd: string, args: readonly string[], env: NodeJS.ProcessEnv) => number | null; readFile?: (path: string) => string; cwd?: string; spawnChild?: typeof spawn };
+
+export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps & { run: NonNullable<PodDispatchDeps['run']> }): number;
+export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps?: PodDispatchDeps): number | Promise<number>;
+export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps = {}): number | Promise<number> {
+  const cwd = deps.cwd ?? process.cwd();
+  if (input.source !== undefined) {
+    try {
+      parsePodSourceSpec(input.source);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      debug.log('harness.substrate', 'source-refused', { entrance: input.entrance, source: input.source, reason });
+      return 2;
+    }
+  }
+  const goal = podGoalText(input, deps.readFile ?? ((p) => readFileSync(resolve(cwd, p), 'utf8')));
+  const args = podOrchestrateArgs(input, goal);
+  const env = { ...process.env };
+  delete env.ELANOUS_POD_GOAL_DOC;
+  if (input.podMemory) env.ELANOUS_POD_MEMORY_TIER = input.podMemory;
+  if (input.entrance === 'cli-harness-ask') {
+    const root = findGitDir(cwd)?.root;
+    const path = resolve(cwd, input.input);
+    const relativePath = root ? relative(realpathSync(root), realpathSync(path)) : '';
+    if (relativePath && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath)) {
+      env.ELANOUS_POD_GOAL_DOC = relativePath;
+    } else {
+      debug.log('harness.substrate', 'goal-doc-outside-repo', { path: input.input });
+    }
+  }
+  debug.log('harness.substrate', 'dispatch-pod', {
+    entrance: input.entrance, podPool: input.podPool ?? null, podMemory: input.podMemory ?? null, autoMerge: input.autoMerge !== false,
+    goalChars: goal.length, ...(input.entrance === 'cli-harness-ask' ? { goalPath: input.input } : {}),
+  });
+  const run = deps.run ?? ((cmd: string, a: readonly string[], childEnv: NodeJS.ProcessEnv) => new Promise<number>((resolveStatus) => {
+    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: 'inherit', env: childEnv });
+    let forwarded: NodeJS.Signals | undefined;
+    const forward = (signal: NodeJS.Signals) => {
+      forwarded = signal;
+      if (child.exitCode === null && child.signalCode === null) child.kill(signal);
+    };
+    const onTerm = () => forward('SIGTERM');
+    const onInt = () => forward('SIGINT');
+    process.on('SIGTERM', onTerm);
+    process.on('SIGINT', onInt);
+    const cleanup = () => { process.off('SIGTERM', onTerm); process.off('SIGINT', onInt); };
+    child.once('error', () => { cleanup(); resolveStatus(1); });
+    child.once('close', (code, signal) => { cleanup(); resolveStatus(code ?? ((signal ?? forwarded) === 'SIGINT' ? 130 : 143)); });
+  }));
+  const status = run(process.execPath, args, env);
+  if (typeof status === 'number' || status === null) {
+    debug.log('harness.substrate', 'dispatch-pod-exit', { entrance: input.entrance, status });
+    return status ?? 1;
+  }
+  return status.then((code) => {
+    debug.log('harness.substrate', 'dispatch-pod-exit', { entrance: input.entrance, status: code });
+    return code;
+  });
+}