elanous 0.2.20 → 0.2.22

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

@@ -1,4 +1,4 @@
-import { execFile, execFileSync, spawn } from 'node:child_process';
+import { execFile, execFileSync, spawn, spawnSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import { dlopen, FFIType } from 'bun:ffi';
 import { createHash } from 'node:crypto';
@@ -10,6 +10,7 @@ import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 import { loadSelfDevRun } from '../self-dev/run-store.js';
 import { normalizeRunId } from './harness-space.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { lookupGoal, type GoalLookupOptions, type GoalLookupResult } from '../self-implement/goal-lookup.js';
 import { archiveGoals, type GoalArchiveOptions } from '../self-implement/goal-archive.js';
 import { detectBursts, formatIncidentBurstWarning, incidentLastLines, readRunExits, recentBurst, recordRunExit } from './harness-incidents.js';
@@ -23,13 +24,15 @@ import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-
 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 { DRAFT_SWEEP_CONCURRENCY, mapBounded, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
+import { collectDraftMetrics, collectOverlapMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, resolveDraftSweepCloseCap, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type OverlapMetricAdapters, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
+import { readAskPreflightRowsSince, readSalvagedRowsSince } from '../self-dev/ask-launch-io.js';
 import { debug } from '../debug/log.js';
 import { installHarnessSalvageCommand, installHarnessSalvageRetentionCommand } from './harness-salvage-cli.js';
 import { decideNestedElanousLaunch, readNestedElanousDepth } from './nested-elanous-policy.js';
 import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { launchRequestId, preLaunchGate, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
 import { PR_LABELS } from '../github/pr-labels.js';
+import { ghAutomationEnv } from '../autopilot/pr-manager.js';
 import { CODEX_PROVIDER, GROK_PROVIDER, decideBudget, decideLaunchBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { DEFAULT_FALLBACK_CHAIN } from '../oauth/fallback-chain.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
@@ -47,6 +50,8 @@ import { runHarnessPlanRfc } from './harness-plan-rfc.js';
 import { classifyGarbage, isGarbageProcessTarget, type GarbageProcess } from './process-garbage.js';
 import type { MissionSolveOutcome } from './mission-solve-loop.js';
 import { formatAxis, formatAxisObservations, inspectAskMarkers, inspectUnpressedDecisionSignals } from '../../scripts/ask-marker-check.js';
+import { enterJourneyNode, ensureJourneyKey, exitJourneyNode, JOURNEY_KEY_ENV, passJourneyNode, withJourneyNode } from '../self-dev/graph-journey-nodes.js';
+import { intakeTakesQueue, readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 
 let harnessPlanRfcForTesting: typeof runHarnessPlanRfc | undefined;
 let harnessAskMarkerInspectorForTesting: ((ask: string) => readonly string[]) | undefined;
@@ -777,13 +782,17 @@ async function dispatchHarnessAskSay(
   immediateLaunch?: HarnessQueueDeps['launch'],
   immediateExit?: () => Promise<number>,
 ): Promise<void> {
-  await runInjectedHarnessHandler(async () => {
+  // HARNESS-FULL-GRAPH — 여정 조인 키는 이 발사 동안만 환경에 싣는다(자식은 그동안 물려받는다).
+  const journeyPreset = Boolean(process.env[JOURNEY_KEY_ENV]?.trim());
+  try { await runInjectedHarnessHandler(async () => {
     assertHarnessChildLlmModel(opts);
     if (isHarnessDryRun(opts)) {
       resolveLaunchSubstrate(opts);
       printHarnessLaunchDryRun(dryRunPreview);
       return;
     }
+    ensureJourneyKey();
+    const journey = { provenance: dryRunPreview.entrance, ...(opts.goalType ? { goalType: opts.goalType as GoalType } : {}) };
     // Resolve the launch directory once; descendants and the checkpoint retain the same identity.
     const queued = process.env.ELANOUS_HARNESS_QUEUE_LAUNCH && process.env.ELANOUS_HARNESS_SEAT;
     const queueSeat = queued === 'OP' || queued === 'TC' || queued === 'MK' || queued === 'UX' ? queued : undefined;
@@ -801,10 +810,21 @@ async function dispatchHarnessAskSay(
     const podSeat = resolved.substrate === 'pod' && ['OP', 'TC', 'MK', 'UX'].includes(inheritedSeat ?? '')
       ? inheritedSeat as QueueSeat : undefined;
     const stampedSeat = resolved.substrate === 'pod' ? opts.seat ?? queueSeat ?? podSeat ?? assigned : assigned;
+    // HARNESS-FULL-GRAPH 2판 — 대기열을 탈지는 «그래프»가 정한다. 코드는 상태 값(queued|direct)만 내고,
+    // 다음 노드는 YAML(⊕ 조건이 맞는 launch 오버레이)의 intake 간선이 고른다. 기본 YAML 은 오늘과 같은 길이다.
+    // ⛔ 대기열은 자리가 있어야 하고 대기열 자식·--no-queue 는 다시 줄 서지 않는다 — 그 셋은 그래프가 못 넘는다.
+    const intakeLabel = shouldQueue && stampedSeat ? 'queued' : 'direct';
+    // intake 는 판정만 하는 관측 노드 — 진입·출구를 한 자리에서.
+    passJourneyNode('intake', { ...journey, outcome: intakeLabel });
+    const intakeRoute = readJourneyEdge('intake', intakeLabel, { seat: stampedSeat ?? 'none', substrate: resolved.substrate });
+    const queueEligible = opts.queue !== false && !process.env.ELANOUS_HARNESS_QUEUE_LAUNCH && Boolean(stampedSeat);
+    const takeQueue = intakeTakesQueue(intakeLabel, intakeRoute, queueEligible);
+    // 실제로 탄 간선을 전제 검사 «뒤»에 남긴다(그래프 답과 다르면 honored=false · 이유).
+    recordJourneyEdge(intakeRoute, takeQueue ? 'queue' : 'launch-gate', intakeRoute.to === 'queue' && !takeQueue ? (opts.queue === false ? '--no-queue' : process.env.ELANOUS_HARNESS_QUEUE_LAUNCH ? 'queue-child' : 'no-seat') : undefined);
     if (directSay && opts.queue === false) {
       try { debug.log('harness.queue', 'bypass', { seat: stampedSeat ?? null, reason: '--no-queue' }); }
       catch { /* Observation must not prevent an emergency launch. */ }
-    } else if (shouldQueue && stampedSeat) {
+    } else if (takeQueue && stampedSeat) {
       resolveNestedElanousOption(opts);
       const flags: string[] = [];
       const values: Array<[string, string | undefined]> = [
@@ -833,6 +853,7 @@ async function dispatchHarnessAskSay(
         [opts.forceGate, '--force-gate'],
       ] as const) if (enabled) flags.push(flag);
       let row: QueueItem;
+      enterJourneyNode('queue', journey);
       try {
         row = await addHarnessQueue({ seat: stampedSeat, launchCwd: process.cwd(), refuseDuplicate: true,
         ...(dryRunPreview.goalPath ? { ask: dryRunPreview.goalPath } : { say: dryRunPreview.input }),
@@ -842,12 +863,17 @@ async function dispatchHarnessAskSay(
         }, queueDeps);
         await queueDeps?.afterEnqueue?.(row);
       } catch (error) {
-        if (!(error instanceof HarnessQueueDuplicateError)) throw error;
+        if (!(error instanceof HarnessQueueDuplicateError)) {
+          exitJourneyNode('queue', { ...journey, outcome: 'error', data: { error: error instanceof Error ? error.message : String(error) } });
+          throw error;
+        }
         console.error(`발사 거절 — ${error.message.replace(/[\r\n]+/g, ' ')}`);
+        exitJourneyNode('queue', { ...journey, outcome: 'refused' });
         process.exitCode = 1;
         return;
       }
-      const result = await tickHarnessQueue({ ...queueDeps, ...(immediateLaunch ? { launch: immediateLaunch } : {}) }, row.id);
+      const result = await withJourneyNode('queue', journey, () => tickHarnessQueue({ ...queueDeps, ...(immediateLaunch ? { launch: immediateLaunch } : {}) }, row.id));
+      exitJourneyNode('queue', { ...journey, outcome: result.outcome === 'launched' && result.item?.id === row.id ? 'launched' : 'waiting', data: { queueItemId: row.id, queueTick: result.outcome } });
       if (result.outcome === 'launched' && result.item?.id === row.id) {
         if (immediateExit) process.exitCode = await immediateExit();
       } else if (result.outcome === 'waiting') {
@@ -880,6 +906,8 @@ async function dispatchHarnessAskSay(
       const previous = process.env.ELANOUS_HARNESS_SEAT;
       if (stampedSeat) process.env.ELANOUS_HARNESS_SEAT = stampedSeat;
       else delete process.env.ELANOUS_HARNESS_SEAT;
+      // 배치 노드 — 실행 칸(local | pod)이 그 출구 라벨이고, YAML 의 decompose 간선(on: substrate)이 그 값으로 갈린다.
+      passJourneyNode('dispatch', { ...journey, outcome: resolved.substrate });
       try { await dispatch(resolved, stampedOpts); }
       finally {
         if (previous === undefined) delete process.env.ELANOUS_HARNESS_SEAT;
@@ -900,11 +928,16 @@ async function dispatchHarnessAskSay(
     // CLI wiring tests time out on them. Gate tests inject deps or opt in with ELANOUS_LAUNCH_GATE_LIVE=1.
     if (process.env.NODE_ENV === 'test' && Object.keys(gate).length === 0 && process.env.ELANOUS_LAUNCH_GATE_LIVE !== '1') {
       try { debug.log('execution-loop.launch-gate', 'skipped-test-env', { goalId }); } catch { /* observation is fail-soft */ }
+      passJourneyNode('launch-gate', { ...journey, outcome: 'pass', data: { skipped: 'test-env' } });
       await launch();
       return;
     }
-    const budget = await (gate.readBudget ?? (() => readHarnessLaunchBudget(opts)))();
-    const decision = preLaunchGate({ goalId, budget, forceLaunch: opts.forceGate === true }, gate);
+    enterJourneyNode('launch-gate', journey);
+    const decision = await withJourneyNode('launch-gate', journey, async () => {
+      const budget = await (gate.readBudget ?? (() => readHarnessLaunchBudget(opts)))();
+      return preLaunchGate({ goalId, budget, forceLaunch: opts.forceGate === true }, gate);
+    });
+    exitJourneyNode('launch-gate', { ...journey, outcome: decision.action === 'proceed' ? 'pass' : 'refuse', data: { action: decision.action } });
     if (decision.action !== 'proceed') {
       console.error(`❌ launch gate: ${decision.action} — ${decision.reason.split(/\r?\n/, 1)[0]}`);
       process.exitCode = 3;
@@ -916,7 +949,7 @@ async function dispatchHarnessAskSay(
     ];
     if (warnings.length > 0) console.error(`⚠️ launch gate: ${warnings.join(' · ').split(/\r?\n/, 1)[0]}`);
     await launch();
-  });
+  }); } finally { if (!journeyPreset) delete process.env[JOURNEY_KEY_ENV]; }
 }
 
 function normalizeHarnessPlanOptions(opts: HarnessPlanOptions): HarnessPlanOptions {
@@ -1559,6 +1592,28 @@ function readProcessCwd(pid: number): Pick<HarnessProcessRecord, 'cwd' | 'cwdSta
   }
 }
 
+/** One `lsof` for many pids (a per-pid lsof costs ~0.1–0.3 s); lsof exits 1 when some pid is gone yet prints the rest. */
+function batchProcessCwdReader(pids: readonly number[]): (pid: number) => Pick<HarnessProcessRecord, 'cwd' | 'cwdStatus' | 'cwdFailureReason'> {
+  const cwds = new Map<number, string>();
+  let failure: string | undefined;
+  if (pids.length) {
+    const result = spawnSync('lsof', ['-a', '-d', 'cwd', '-Fpn', '-p', pids.join(',')],
+      { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
+    if (result.error || typeof result.stdout !== 'string') failure = observationFailureReason(result.error ?? new Error('lsof output missing'));
+    else {
+      let current: number | undefined;
+      for (const line of result.stdout.split('\n')) {
+        if (line.startsWith('p')) current = Number(line.slice(1));
+        else if (line.startsWith('n') && current !== undefined && line.length > 1) cwds.set(current, line.slice(1).trim());
+      }
+    }
+  }
+  return (pid) => {
+    const cwd = cwds.get(pid);
+    return cwd ? { cwd, cwdStatus: 'observed' } : { cwdStatus: 'unknown', cwdFailureReason: failure ?? 'lsof cwd missing' };
+  };
+}
+
 const OWNERSHIP_ENV_KEYS = new Set<string>(Object.values(HARNESS_PROCESS_OWNERSHIP_ENV));
 
 function ownershipValueFromEntry(entry: string, key: string): string | undefined {
@@ -1714,10 +1769,23 @@ export function readProcessOwnership(
   }
 }
 
-export function defaultListHarnessProcesses(): HarnessProcessListObservation {
+/** Narrows the per-process reads (`lsof` cwd ≈ 0.1 s each · `ps eww`) of `defaultListHarnessProcesses`. */
+export interface HarnessProcessListOptions {
+  /** Keep only matching records; the others are dropped before any per-process read. */
+  readonly include?: (record: HarnessProcessRecord) => boolean;
+  /** Skip the ownership (`ps eww`) read — for callers that only need the cwd. */
+  readonly cwdOnly?: boolean;
+  /** Wall-clock budget for the per-process reads; records past it keep `cwdStatus: 'unknown'` (reason names the budget). */
+  readonly deadlineMs?: number;
+  readonly readCwd?: (pid: number) => Pick<HarnessProcessRecord, 'cwd' | 'cwdStatus' | 'cwdFailureReason'>;
+  readonly psOutput?: () => string;
+  readonly clock?: () => number;
+}
+
+export function defaultListHarnessProcesses(options: HarnessProcessListOptions = {}): HarnessProcessListObservation {
   let out: string;
   try {
-    out = execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
+    out = options.psOutput ? options.psOutput() : execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
       encoding: 'utf8',
       timeout: 5_000,
       stdio: ['ignore', 'pipe', 'ignore'],
@@ -1727,11 +1795,21 @@ export function defaultListHarnessProcesses(): HarnessProcessListObservation {
   }
   const parsed = parseHarnessProcessPsOutput(out);
   if (parsed.status === 'failed') return parsed;
-  const records = parsed.records.map((record) => ({
-    ...record,
-    ...readProcessCwd(record.pid),
-    ownership: readProcessOwnership(record.pid),
-  }));
+  const clock = options.clock ?? Date.now;
+  const selected = options.include ? parsed.records.filter(options.include) : parsed.records;
+  const readCwd = options.readCwd ?? (options.cwdOnly ? batchProcessCwdReader(selected.map((record) => record.pid)) : readProcessCwd);
+  const deadline = options.deadlineMs === undefined ? Infinity : clock() + options.deadlineMs;
+  const records = selected.map((record) => {
+    // A host with hundreds of harness processes made the serial reads take minutes (10-08 queue tick hang).
+    if (clock() >= deadline) {
+      return { ...record, cwdStatus: 'unknown' as const, cwdFailureReason: `observation deadline ${options.deadlineMs}ms exceeded` };
+    }
+    return {
+      ...record,
+      ...readCwd(record.pid),
+      ...(options.cwdOnly ? {} : { ownership: readProcessOwnership(record.pid) }),
+    };
+  });
   if (parsed.status === 'incomplete') {
     return {
       status: 'incomplete',
@@ -1847,12 +1925,30 @@ type GithubPull = {
 
 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,
-});
+// Explicit env preserves the augmented PATH under Bun (cron may start with a minimal PATH).
+// Authentication comes from the same automation policy used by the PR manager, not the user's keyring.
+// Failure details are bounded and redact the token before reaching the sweep result or debug log.
+function ghFailure(args: string[], error: unknown, token: string | undefined): Error {
+  const failure = error as { status?: number | null; code?: number | string; stderr?: string | Buffer };
+  const exit = failure.status ?? (typeof failure.code === 'number' ? failure.code : 'unknown');
+  const stderr = String(failure.stderr ?? '');
+  const stderrTail = (token ? stderr.replaceAll(token, '[REDACTED]') : stderr).slice(-300).replace(/[\r\n]+/g, ' ').trim();
+  try { debug.log('harness.drafts', 'gh-failed', { args0: args[0], exit, stderrTail }); }
+  catch { /* Logging must not hide the gh failure. */ }
+  // gh never ran (e.g. «Executable not found: gh»): no exit or stderr to report, so keep the spawn error itself.
+  if (typeof failure.status !== 'number' && !stderrTail && error instanceof Error) return error;
+  return new Error(`gh ${args.slice(0, 2).join(' ')} exit=${exit}: ${stderrTail}`);
+}
+
+const executeGh: GhExecute = (args) => {
+  const env = ghAutomationEnv(process.env);
+  try {
+    return execFileSync('gh', args, {
+      encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'], env,
+    });
+  } catch (error) { throw ghFailure(args, error, env.GH_TOKEN); }
+};
 
 /** Merge-time adapter: reuse the sweep's GitHub inventory and worktree liveness without a second triage implementation. */
 export async function supersedeMergedGoalDrafts(
@@ -1956,9 +2052,14 @@ function deliverResyncMemo(spaceId: string, memo: ControlMemoPayload,
 }
 
 const execFileAsync = promisify(execFile);
-const executeGhAsync = async (args: string[]): Promise<string> => (await execFileAsync('gh', args, {
-  encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024, env: process.env,
-})).stdout;
+const executeGhAsync = async (args: string[]): Promise<string> => {
+  const env = ghAutomationEnv(process.env);
+  try {
+    return (await execFileAsync('gh', args, {
+      encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024, env,
+    })).stdout;
+  } catch (error) { throw ghFailure(args, error, env.GH_TOKEN); }
+};
 
 /** RUN-TTL adapters: open self-impl PRs, head commit time (async, bounded by the core), owning run, memo, label. */
 export async function githubRunTtlAdapters(repository: string, execute: GhExecute = executeGh,
@@ -2420,15 +2521,16 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     },
     getClaimOwner: async (repository, number) => claimCommentOwner(repository, number, execute),
     getActiveClaimOwner: async (repository, number) => {
+      // DRAFT-METRIC: the batched GraphQL comments (oldest first, proven complete) answer without a per-draft REST call.
+      const batched = (await detailFor(repository, number))?.comments;
+      if (batched) return activeClaimOwnerFromBodies(batched);
       const pages = ghJson<Array<Array<{ body: string; created_at: 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' || !Number.isFinite(Date.parse(comment.created_at)))))
         throw new Error('Incomplete claim comments');
-      const last = pages.flat().sort((a, b) => Date.parse(b.created_at) - Date.parse(a.created_at))
-        .map((comment) => comment.body)
-        .find((body) => draftClaimOwner(body) !== undefined || body.startsWith('🔧 처리 끝 —'));
-      return last ? draftClaimOwner(last) : undefined;
+      return activeClaimOwnerFromBodies(pages.flat().sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at))
+        .map((comment) => comment.body));
     },
     getReviewGate: async (draft, repository) => reviewGateForDraft(draft, repository),
   };
@@ -2436,12 +2538,16 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
 
 export interface HarnessDraftSweepDeps {
   readonly adapters?: DraftSweepAdapters;
+  /** Optional overlap source injection; tests do not read GitHub or logs.db. */
+  readonly overlapAdapters?: OverlapMetricAdapters;
   readonly repository?: () => string;
   readonly write?: (line: string) => void;
   readonly execute?: GhExecute;
   readonly now?: () => Date;
   /** RUN-TTL step adapters. Omitted with injected `adapters` ⇒ the step is skipped (fakes never reach real gh). */
   readonly runTtl?: RunTtlAdapters;
+  /** Test seam for `tools.selfImplement.draftSweepCloseCap`; omitted ⇒ the user config. */
+  readonly closeCapConfig?: () => unknown;
 }
 
 /** RUN-TTL step inside the draft sweep — fail-soft: its failure never changes the sweep verdict. */
@@ -2464,6 +2570,12 @@ async function draftSweepRunTtl(repository: string, deps: HarnessDraftSweepDeps,
   }
 }
 
+/** Latest claim or release among comments in chronological order (oldest first); a release means no owner. */
+export function activeClaimOwnerFromBodies(bodies: readonly string[]): string | undefined {
+  const last = [...bodies].reverse().find((body) => draftClaimOwner(body) !== undefined || body.startsWith('🔧 처리 끝 —'));
+  return last ? draftClaimOwner(last) : undefined;
+}
+
 function draftClaimOwner(body: string): string | undefined {
   return /^🔧 처리 중 — owner ([^\n·]+?) · /m.exec(body)?.[1]?.trim();
 }
@@ -2520,11 +2632,43 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         process.exitCode = 1;
       }
     });
+  drafts.command('metrics').description('draft 재고·최장 나이·needs-owner·48h 전환율 (읽기 전용 · PR 근거는 GraphQL 배치)')
+    .option('--json', 'JSON 으로 출력')
+    .option('--repo <owner/name>', '조회할 GitHub 저장소')
+    .action(async (opts: { json?: boolean; repo?: string }) => {
+      try {
+        const execute = deps.execute ?? executeGh;
+        const repository = resolveRepositoryName({ repo: opts.repo ?? deps.repository?.(), executeGh: (args) => execute(args) });
+        if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
+        const started = Date.now();
+        const adapters = deps.adapters ?? githubDraftSweepAdapters(deps.execute);
+        const now = deps.now?.() ?? new Date();
+        const metrics = await collectDraftMetrics(repository, adapters, now);
+        let overlap: Awaited<ReturnType<typeof collectOverlapMetrics>> | null = null;
+        try {
+          overlap = await collectOverlapMetrics(repository, deps.overlapAdapters ?? {
+            ...adapters,
+            listPreflightRows: readAskPreflightRowsSince,
+            listSalvagedRows: readSalvagedRowsSince,
+          }, now);
+        } catch (error) {
+          try { debug.log('self-dev.draft-metrics', 'overlap-failed', { repository, reason: sweepFailureReason(error) }); } catch { /* fail-soft */ }
+        }
+        try { debug.log('self-dev.draft-metrics', 'collected', { repository, ms: Date.now() - started, ...metrics }); } catch { /* fail-soft */ }
+        const write = deps.write ?? console.log;
+        if (opts.json) write(JSON.stringify({ repository, ...metrics, overlap }));
+        else write(`draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`);
+      } 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 }) => {
+    .option('--close-cap <n>', '이번 틱 최대 종료 수 (1~100 · config tools.selfImplement.draftSweepCloseCap 보다 우선 · 기본 10)')
+    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string; closeCap?: string }) => {
       try {
         const write = deps.write ?? console.log;
         const execute = deps.execute ?? executeGh;
@@ -2537,7 +2681,16 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         }
         // One adapter instance per sweep: its open listing and ledger scan are shared with the RUN-TTL step.
         const github = deps.adapters ? undefined : githubDraftSweepAdapters(deps.execute);
-        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? github! });
+        const configCap = deps.closeCapConfig
+          ? deps.closeCapConfig()
+          : (() => { try { return getUserConfig().tools?.selfImplement?.draftSweepCloseCap; } catch { return undefined; } })();
+        const cap = resolveDraftSweepCloseCap({ flag: opts.closeCap, config: configCap });
+        for (const warning of cap.warnings) {
+          console.error(`⚠ ${warning}`);
+          try { debug.log('self-dev.draft-sweep', 'close-cap-rejected', { warning, closeCap: cap.closeCap, closeCapSource: cap.closeCapSource }); } catch { /* fail-soft */ }
+        }
+        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? github!,
+          closeCap: cap.closeCap, closeCapSource: cap.closeCapSource });
         const reason = result.error ? sweepFailureReason(result.error) : undefined;
         const ttlStarted = Date.now();
         const runTtl = await draftSweepRunTtl(repository, deps, github);
@@ -2888,7 +3041,8 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
       harnessQueueReceiptPath(root, item.launchId!), queueDeps.launchCommand ?? join(import.meta.dir, '../../bin/elanous.mjs'),
       ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
       cwd: item.launchCwd ?? resolve(import.meta.dir, '../..'), stdio: 'inherit',
-      env: { ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_HARNESS_SEAT: item.seat,
+      env: { ...process.env, ELANOUS_STATE_DIR: root,
+        ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root), ELANOUS_HARNESS_SEAT: item.seat,
         ELANOUS_HARNESS_QUEUE_LAUNCH: item.launchId! },
     });
     // Capture the end at spawn time: a child that already closed (or died by a signal) must not leave the parent waiting.

package/src/harness/harness-queue.ts

@@ -4,6 +4,7 @@ import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync
 import { join, resolve } from 'node:path';
 import { Database } from 'bun:sqlite';
 import { debug } from '../debug/log.js';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { findTreeRoot } from '../cli/test-flag.js';
 import { readLogInstances, type LogInstanceView } from '../mss/logging/instance-registry.js';
 import { effectiveInstanceRoot, prodInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
@@ -20,6 +21,7 @@ import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js'
 import { leaseKubectl, measurePoolLease } from '../task-orchestrator/surfaces/pod-lease.js';
 import { parsePodPool, podPoolHostLease, resolvePodPoolSpec } from '../task-orchestrator/surfaces/pod-pool.js';
 import { writeHarnessQueueReceipt } from './harness-queue-child.js';
+import { adviseLaunch, compareLaunchAdvice, type LaunchAdvice } from './launch-advice.js';
 import { finishAdvice, measureFinish, recordFinishHistory, type FinishMetrics } from '../loops/orchestrator/finish-rate.js';
 
 export type QueueSeat = 'OP' | 'TC' | 'MK' | 'UX';
@@ -73,6 +75,8 @@ export interface HarnessQueueDeps {
   configPath?: string;
   cap?: (seat: QueueSeat) => number;
   pool?: () => QueuePool;
+  /** Shadow-only advice seam; exceptions must not affect the queue decision. */
+  advice?: typeof adviseLaunch;
   launch?: (item: QueueItem, args: string[], root: string) => Promise<number>;
   /** Test seam: runs after a direct CLI call enqueued its row and before that call's own tick (race tests). */
   afterEnqueue?: (item: QueueItem) => void | Promise<void>;
@@ -385,24 +389,25 @@ export function listHarnessQueue(deps: HarnessQueueDeps = {}): QueueItem[] {
   return read(harnessQueuePath(deps.root ?? effectiveInstanceRoot()));
 }
 
-/** A missing row is not proof of failure unless the queue left a cancellation marker. */
-export function harnessQueueOutcome(id: string, deps: HarnessQueueDeps = {}): 'pending' | 'succeeded' | 'retryable' | 'unknown' {
+/** A missing row is not proof of failure; explicit removal and terminal receipts have distinct markers. */
+export function harnessQueueOutcome(id: string, deps: HarnessQueueDeps = {}): 'pending' | 'succeeded' | 'retryable' | 'removed' | 'unknown' {
   const root = deps.root ?? effectiveInstanceRoot();
   const row = listHarnessQueue(deps).find((item) => item.id === id);
   if (!row) {
     const marker = join(root, 'harness', `${id}.outcome`);
     if (!existsSync(marker)) return 'unknown';
     const value = readFileSync(marker, 'utf8');
-    return value === 'succeeded' || value === 'retryable' ? value : 'unknown';
+    return value === 'succeeded' || value === 'retryable' || value === 'removed' ? value : 'unknown';
   }
   return queueRowOutcome(row, root);
 }
 
 const keyMarkerPath = (root: string, key: string) => join(root, 'harness', 'by-key', `${createHash('sha256').update(key).digest('hex')}.id`);
 
-function recordQueueOutcome(root: string, id: string, outcome: 'succeeded' | 'retryable', key?: string): void {
+function recordQueueOutcome(root: string, id: string, outcome: 'succeeded' | 'retryable' | 'removed', key?: string): void {
   const path = join(root, 'harness', `${id}.outcome`);
-  if (!existsSync(path)) writeFileSync(path, outcome, { flag: 'wx', mode: 0o600 });
+  if (outcome === 'removed') writeFileSync(path, outcome, { mode: 0o600 });
+  else if (!existsSync(path)) writeFileSync(path, outcome, { flag: 'wx', mode: 0o600 });
   // The row is about to leave the queue; keep «which id last held this key» so a caller that crashed before
   // recording the id can still find the outcome (LOOP-LIVE1 · seat loop recovery).
   if (key) {
@@ -491,10 +496,8 @@ export async function removeHarnessQueue(id: string, deps: HarnessQueueDeps = {}
       if (state !== 'finished' && state !== 'not-started'
         || (deps.processes ?? readHarnessQueueProcesses)().some((row) => row.launchId === item.launchId)) return false;
     }
-    const outcome = item.status === 'queued' ? 'retryable' : queueRowOutcome(item, root);
-    if (item.idempotencyKey && (outcome === 'retryable' || outcome === 'succeeded')) {
-      recordQueueOutcome(root, id, outcome, item.idempotencyKey);
-    }
+    const outcome = queueRowOutcome(item, root) === 'succeeded' ? 'succeeded' : 'removed';
+    if (item.idempotencyKey) recordQueueOutcome(root, id, outcome, item.idempotencyKey);
     save(path, rows.filter((row) => row.id !== id));
     observe('skipped', { id, seat: item.seat, reason: 'removed' }, deps);
     return true;
@@ -699,6 +702,26 @@ export function readHarnessQueueInventory(probe: ProcessProbe = {}): QueueInvent
     if (prior && prior !== record.seat) { ledgerSeats.delete(pid); ambiguousPids.add(pid); }
     else ledgerSeats.set(pid, record.seat!);
   }
+  // One lsof for every candidate: a per-pid lsof (~0.1–0.3 s each) made a tick on a busy host take 10 s+ (10-08). lsof exits 1
+  // when some pid is gone yet still prints the others; a pid it does not print stays unattributed (charged to all seats).
+  let batchCwds: Map<number, string> | undefined;
+  const readBatchCwds = (): Map<number, string> => {
+    const cwds = new Map<number, string>();
+    const started = Date.now();
+    const lsof = run('lsof', ['-a', '-d', 'cwd', '-Fpn', '-p', candidates.map(({ pid }) => pid).join(',')],
+      { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 });
+    if (!lsof.error && typeof lsof.stdout === 'string') {
+      let current: number | undefined;
+      for (const line of lsof.stdout.split('\n')) {
+        if (line.startsWith('p')) current = Number(line.slice(1));
+        else if (line.startsWith('n/') && current !== undefined) cwds.set(current, line.slice(1));
+      }
+    }
+    try { debug.log('harness.queue', 'cwd-batch', { pids: candidates.length, read: cwds.size, ms: Date.now() - started,
+      ...(lsof.error ? { error: String(lsof.error).slice(0, 240) } : {}) }); }
+    catch { /* Observation cannot affect dispatch. */ }
+    return cwds;
+  };
   const rows: QueueProcess[] = [];
   // Attribute a run after grouping: the orchestrator may switch working trees while its launcher stays in HQ.
   for (const root of candidates.filter((row) => !byPid.has(row.ppid))) {
@@ -736,9 +759,9 @@ export function readHarnessQueueInventory(probe: ProcessProbe = {}): QueueInvent
         if (probe.cwd) cwd = probe.cwd(pid);
         else if (platform === 'linux') cwd = readlinkSync(`/proc/${pid}/cwd`);
         else {
-          const lsof = run('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', timeout: 5_000 });
-          if (lsof.error || lsof.status !== 0 || typeof lsof.stdout !== 'string') throw new Error('cwd unavailable');
-          cwd = lsof.stdout.split('\n').find((line) => line.startsWith('n/'))?.slice(1) ?? '';
+          const found = (batchCwds ??= readBatchCwds()).get(pid);
+          if (found === undefined) throw new Error('cwd unavailable');
+          cwd = found;
         }
         if (!cwd.startsWith('/')) continue;
         const found = queueSeatForCwd(cwd, trees);
@@ -816,7 +839,8 @@ async function launch(item: QueueItem, args: string[], root: string, command?: s
       harnessQueueReceiptPath(root, item.launchId!), command ?? join(repo, 'bin', 'elanous.mjs'),
       ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
       cwd: item.launchCwd ?? repo, detached: true, stdio: ['ignore', fd, fd],
-      env: { ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_HARNESS_SEAT: item.seat,
+      env: { ...process.env, ELANOUS_STATE_DIR: root,
+        ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root), ELANOUS_HARNESS_SEAT: item.seat,
         ELANOUS_HARNESS_QUEUE_LAUNCH: item.launchId! },
     });
     const pid = await new Promise<number>((done, reject) => {
@@ -1187,7 +1211,13 @@ export async function tickHarnessQueue(deps: HarnessQueueDeps = {}, requestedId?
 
 async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string | undefined, followUp: boolean): Promise<QueueTick> {
   const root = deps.root ?? effectiveInstanceRoot();
-  return locked(root, async (path) => {
+  const caller = 'harness-queue-tick' as const;
+  let advice: LaunchAdvice = { verdict: 'unknown', why: 'pool not measured before queue decision' };
+  const shadow = (pool: QueuePool | undefined): void => {
+    try { advice = (deps.advice ?? adviseLaunch)({ pool, caller }); }
+    catch { advice = { verdict: 'unknown', why: 'launch advice unavailable' }; }
+  };
+  const actual = await locked<QueueTick>(root, async (path): Promise<QueueTick> => {
     // A burst follow-up already ran the author shadow and the idle request in this tick's first pass.
     if (!followUp) try {
       const now = (deps.now ?? (() => new Date()))();
@@ -1196,7 +1226,11 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
         debug.log('loops.author-depth', 'shadow-skipped-test', {});
       } else {
         const shadow = deps.authorShadow ?? (await import('../loops/orchestrator/author-depth.js')).runAuthorDepthShadow;
+        const started = Date.now();
         await shadow(root, now);
+        // The shadow runs inside the queue lock; its duration is what other ticks wait on.
+        try { debug.log('harness.queue', 'author-shadow', { ms: Date.now() - started }); }
+        catch { /* Observation cannot affect dispatch. */ }
       }
     } catch (error) {
       try { debug.log('loops.author-depth', 'shadow-failed', { reason: String(error) }); }
@@ -1463,6 +1497,7 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
         if (pool && (![pool.running, pool.pending, pool.reserved, pool.limit].every((n) => Number.isSafeInteger(n) && n >= 0) || pool.limit < 1)) {
           poolReason = 'pod lease status incomplete';
         }
+        shadow(poolReason ? undefined : pool);
         if (pool && !poolReason) {
           const queueLaunching = current.filter((row) => row.status === 'launching' || row.status === 'launched').length;
           // CHILD-UNIV-HOLD: each unreadable child universe is charged one pool slot (conservative), never a seat slot.
@@ -1545,4 +1580,13 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
     }
     return waiting();
   });
+  // An empty queue tick has nothing to advise on; logging it would flood the advice-unknown sample.
+  if (actual.outcome === 'skipped' && !actual.item) return actual;
+  try {
+    const { kind } = compareLaunchAdvice(advice, actual.outcome);
+    debug.log('resource.advice', 'launch-advice', {
+      caller, verdict: advice.verdict, why: advice.why, actual: actual.outcome, kind, itemId: actual.item?.id ?? null,
+    });
+  } catch { /* Shadow observation cannot affect the queue result. */ }
+  return actual;
 }

package/src/harness/launch-advice.ts

@@ -0,0 +1,23 @@
+import type { QueuePool, QueueTick } from './harness-queue.js';
+
+export type LaunchAdvice = { verdict: 'launch-now' | 'wait' | 'unknown'; why: string; retryAfterHint?: string };
+export type LaunchAdviceInput = { pool: QueuePool | null | undefined; caller: 'harness-queue-tick' | 'hand-task' | 'release-run' };
+
+/** A pool-only suggestion; queue, seat, freeze and finish gates remain the dispatcher's decisions. */
+export function adviseLaunch(input: LaunchAdviceInput): LaunchAdvice {
+  const pool = input.pool;
+  if (!pool || ![pool.running, pool.pending, pool.reserved, pool.limit].every(n => Number.isSafeInteger(n) && n >= 0)
+    || pool.limit < 1) return { verdict: 'unknown', why: 'pool unavailable or incomplete' };
+  const used = pool.running + pool.pending + pool.reserved;
+  if (used >= pool.limit) return { verdict: 'wait', why: `pool ${used}/${pool.limit} occupied`, retryAfterHint: 'when a pool slot is released' };
+  return { verdict: 'launch-now', why: `pool ${used}/${pool.limit} occupied` };
+}
+
+export function compareLaunchAdvice(advice: LaunchAdvice, actualOutcome: QueueTick['outcome']): {
+  agree: boolean; kind: 'advice-launch-actual-wait' | 'advice-wait-actual-launch' | 'advice-unknown' | 'agree';
+} {
+  if (advice.verdict === 'unknown' || actualOutcome === 'skipped') return { agree: false, kind: 'advice-unknown' };
+  if (advice.verdict === 'launch-now' && actualOutcome === 'waiting') return { agree: false, kind: 'advice-launch-actual-wait' };
+  if (advice.verdict === 'wait' && actualOutcome === 'launched') return { agree: false, kind: 'advice-wait-actual-launch' };
+  return { agree: true, kind: 'agree' };
+}