elanous 0.2.11 → 0.2.13

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

@@ -24,11 +24,12 @@ import { debug } from '../debug/log.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 { CODEX_PROVIDER, GROK_PROVIDER, decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.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';
 import { getUserConfig } from '../user-config.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
+import { addHarnessQueue, listHarnessQueue, reconcileHarnessQueue, removeHarnessQueue, tickHarnessQueue, type HarnessQueueDeps } from './harness-queue.js';
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
 import { runHarnessPlanRfc } from './harness-plan-rfc.js';
 import { classifyGarbage, isGarbageProcessTarget, type GarbageProcess } from './process-garbage.js';
@@ -338,6 +339,8 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
 }
 type PodExit = { status: number | null; signal?: string | null };
 type PodExitReason = 'signal' | 'human-stop' | 'supervisor' | 'no-launch' | 'unknown';
+/** GitHub lists at most this many files for one pull request; a list that reaches it is not provably complete. */
+export const GITHUB_PR_FILES_LIST_CAP = 3000;
 const STOPPING_SUPERVISOR_VERDICTS = new Set(['UNCONVERGEABLE', 'CONTRACT-CONFLICT']);
 // Ledger events that only exist once the child actually ran — any of them rules out «never reached the Pod».
 const LAUNCH_EVIDENCE_EVENTS = new Set(['job-applied', 'pod-child-run', 'reviewed', 'rework-budget', 'pr-opened']);
@@ -578,8 +581,12 @@ const LAUNCH_BUDGET_PROVIDER: Readonly<Record<string, string>> = { 'codex-rotate
 export function harnessLaunchBudgetDecision(
   inputs: BudgetInputs,
   opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
-): { readonly decision: BudgetDecision; readonly warning?: string } {
+): { readonly decision: BudgetDecision; readonly warning?: string; readonly unmeasuredProvider?: string } {
   const explicit = opts.childLlmProvider?.trim();
+  const judged = (selected: BudgetInputs) => {
+    const { decision, unmeasuredProvider } = decideLaunchBudget(selected);
+    return { decision, ...(unmeasuredProvider ? { unmeasuredProvider, warning: `budget: ${unmeasuredProvider} usage unmeasured — launching` } : {}) };
+  };
   if (explicit) {
     if (explicit !== CODEX_PROVIDER && explicit !== GROK_PROVIDER) {
       return {
@@ -588,13 +595,14 @@ export function harnessLaunchBudgetDecision(
       };
     }
     const chain = [{ provider: explicit, ...(opts.childLlmModel ? { model: opts.childLlmModel } : {}) }];
-    return { decision: decideBudget({ ...inputs, preference: { ...inputs.preference, chain } }) };
+    return judged({ ...inputs, preference: { ...inputs.preference, chain } });
   }
-  if (inputs.preference.chain.length > 0) return { decision: decideBudget(inputs) };
+  if (inputs.preference.chain.length > 0) return judged(inputs);
   const chain = DEFAULT_FALLBACK_CHAIN.map((step) => ({ provider: LAUNCH_BUDGET_PROVIDER[step] ?? step }));
+  const result = judged({ ...inputs, preference: { ...inputs.preference, chain } });
   return {
-    decision: decideBudget({ ...inputs, preference: { ...inputs.preference, chain } }),
-    warning: `budget: no chain in this universe's config — judged with the code default ${DEFAULT_FALLBACK_CHAIN.join(',')}`,
+    ...result,
+    warning: `budget: no chain in this universe's config — judged with the code default ${DEFAULT_FALLBACK_CHAIN.join(',')}${result.warning ? ` · ${result.warning}` : ''}`,
   };
 }
 
@@ -602,10 +610,13 @@ async function readHarnessLaunchBudget(
   opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
 ): Promise<BudgetDecision | 'unknown'> {
   try {
-    const { decision, warning } = harnessLaunchBudgetDecision(await readBudgetInputsLive(), opts);
+    const { decision, warning, unmeasuredProvider } = harnessLaunchBudgetDecision(await readBudgetInputsLive(), opts);
     if (warning) {
       console.error(`⚠️ launch gate: ${warning}`);
-      try { debug.log('execution-loop.launch-gate', 'budget-chain-defaulted', { warning, action: decision.action, provider: decision.provider }); } catch { /* observation is fail-soft */ }
+      try {
+        if (unmeasuredProvider) debug.log('execution-loop.launch-gate', 'budget-unmeasured', { provider: unmeasuredProvider });
+        if (!opts.childLlmProvider?.trim() && warning.includes('code default')) debug.log('execution-loop.launch-gate', 'budget-chain-defaulted', { warning, action: decision.action, provider: decision.provider });
+      } catch { /* observation is fail-soft */ }
     }
     return decision;
   }
@@ -644,8 +655,8 @@ async function dispatchHarnessAskSay(
     }
     goalId ??= launchRequestId(identity);
     // Under bun test with no injected gate deps, skip the live reads (≈5 s of codex rotation + run scans) —
-    // CLI wiring tests time out on them. Gate tests inject deps and still run the gate (0.2.11 gate 10-03).
-    if (process.env.NODE_ENV === 'test' && Object.keys(gate).length === 0) {
+    // 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 */ }
       await dispatch(resolved);
       return;
@@ -1461,7 +1472,7 @@ export function readProcessOwnership(
   }
 }
 
-function defaultListHarnessProcesses(): HarnessProcessListObservation {
+export function defaultListHarnessProcesses(): HarnessProcessListObservation {
   let out: string;
   try {
     out = execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
@@ -1577,10 +1588,13 @@ type GithubPull = {
   draft: boolean;
   state: 'open' | 'closed';
   head: { ref: string };
+  base?: { ref: string };
   labels: Array<{ name: string }>;
   created_at: string;
   updated_at?: string;
   merged_at: string | null;
+  body?: string | null;
+  merge_commit_sha?: string | null;
 };
 
 type GhExecute = (args: string[]) => string;
@@ -1629,9 +1643,25 @@ export function draftSweepRunStatus(ledgerMatches: readonly RunLedgerMatch[], ru
       ['completed', 'failed', 'cancelled', 'abandoned'].includes(terminal) ? terminal : undefined);
     if (status && status !== 'unknown') statuses.add(status);
   }
+  if (statuses.has('running')) return 'running';
+  if (statuses.has('probable-running')) return 'probable-running';
   return statuses.size === 1 ? [...statuses][0] : undefined;
 }
 
+function currentDraftSweepRunId(matches: readonly RunLedgerMatch[], repository: string, number: number): string | undefined {
+  const owners = matches.flatMap((match) => {
+    const events = match.entries.filter((entry) => entry.event === 'pr-opened' && entry.data.number === number);
+    if (events.length === 0 || events.some((entry) => ledgerPrRepository(entry.data, number) !== repository)) return [];
+    const times = events.map((entry) => Date.parse(entry.timestamp ?? ''));
+    return [{ runId: match.runId, time: times.every(Number.isFinite) ? Math.max(...times) : NaN }];
+  });
+  if (owners.length === 1) return owners[0]!.runId;
+  if (owners.some((owner) => !Number.isFinite(owner.time))) return undefined;
+  owners.sort((a, b) => b.time - a.time);
+  if (owners.length > 1 && owners[0]!.time === owners[1]!.time) return undefined;
+  return owners[0]?.runId;
+}
+
 type DraftSweepGitExecute = (cwd: string, args: string[]) => Pick<ReturnType<typeof runGitCommand>, 'status' | 'stdout' | 'stderr'>;
 
 function githubRemoteRepository(url: string): string | undefined {
@@ -1669,24 +1699,117 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     if (!cache.has(repository)) cache.set(repository, inventory(repository, state));
     return cache.get(repository)!;
   };
+  // GitHub stops listing a pull request's files at 3,000, and the cut looks like a normal last page.
+  // A list that reaches the cap cannot prove it is complete, so it is reported as unknown (undefined):
+  // a draft without a provable file list never qualifies for the all-files-landed close.
+  const filesFor = (repository: string, number: number): string[] | undefined => {
+    const files: string[] = [];
+    for (let page = 1; page <= 100; page++) {
+      const batch = ghJson<Array<{ filename: string }>>(['api', `repos/${repository}/pulls/${number}/files?per_page=100&page=${page}`], execute);
+      if (!Array.isArray(batch) || batch.length > 100 || batch.some((file) => typeof file.filename !== 'string')) throw new Error('Incomplete PR file inventory');
+      files.push(...batch.map((file) => file.filename));
+      if (files.length >= GITHUB_PR_FILES_LIST_CAP) {
+        debug.log('drafts.cleanup', 'file-inventory-capped', { number, listed: files.length });
+        return undefined;
+      }
+      if (batch.length < 100) return files;
+    }
+    throw new Error('PR file inventory exceeded pagination limit');
+  };
+  const latestFileChangesFor = (draft: SweepDraft, repository: string): Record<string, string> | undefined => {
+    if (!draft.changedFiles?.length) return undefined;
+    const changes: Record<string, string> = {};
+    for (let page = 1; page <= 100; page++) {
+      const batch = ghJson<Array<{ sha: string; commit: { committer: { date: string } } }>>(
+        ['api', `repos/${repository}/pulls/${draft.number}/commits?per_page=100&page=${page}`], execute);
+      if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete draft commit inventory');
+      for (const commit of batch) {
+        const changedAt = commit.commit?.committer?.date;
+        if (!commit.sha || !changedAt || !Number.isFinite(Date.parse(changedAt))) return undefined;
+        const detail = ghJson<{ files?: Array<{ filename: string; previous_filename?: string }> }>(
+          ['api', `repos/${repository}/commits/${commit.sha}?per_page=100`], execute);
+        // GitHub truncates very large commit file lists; never infer coverage from a partial list.
+        if (!Array.isArray(detail.files) || detail.files.length >= 100) return undefined;
+        for (const file of detail.files) {
+          for (const name of [file.filename, file.previous_filename]) {
+            if (!name || !draft.changedFiles.includes(name)) continue;
+            if (!changes[name] || Date.parse(changes[name]) < Date.parse(changedAt)) changes[name] = changedAt;
+          }
+        }
+      }
+      if (batch.length < 100) return draft.changedFiles.every((file) => changes[file]) ? changes : undefined;
+    }
+    return undefined;
+  };
+  const landingCommentsFor = (repository: string, number: number): string[] => {
+    const comments: string[] = [];
+    for (let page = 1; page <= 100; page++) {
+      const batch = ghJson<Array<{ body?: string }>>(['api', `repos/${repository}/issues/${number}/comments?per_page=100&page=${page}`], execute);
+      if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete landing comment inventory');
+      comments.push(...batch.filter((comment) => /\blanding-verified\b/i.test(comment.body ?? '')).map((comment) => comment.body!));
+      if (batch.length < 100) return comments;
+    }
+    throw new Error('Landing comment inventory exceeded pagination limit');
+  };
   let ledgerMatches: readonly RunLedgerMatch[] | undefined;
   let running: ReadonlyMap<string, string> | undefined;
-  const runStatusFor = (repository: string, number: number): string | undefined => {
+  const runStatusFor = (draft: SweepDraft, repository: string): string | undefined => {
     ledgerMatches ??= listRunLedgers().matches;
     running ??= new Map(queryRunningRuns().entries.map((entry) => [entry.runId, entry.status]));
-    return draftSweepRunStatus(ledgerMatches, running, repository, number);
+    if (draft.runId) {
+      const match = ledgerMatches.find((entry) => entry.runId === draft.runId);
+      return match ? draftSweepRunStatus([match], running, repository, draft.number) : undefined;
+    }
+    return draftSweepRunStatus(ledgerMatches, running, repository, draft.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 } : {}) })),
+          labels: pr.labels.map((item) => item.name), createdAt: pr.created_at, body: pr.body ?? undefined,
+          changedFiles: filesFor(repository, pr.number), ...(pr.updated_at ? { updatedAt: pr.updated_at } : {}),
+          runId: currentDraftSweepRunId(ledgerMatches ??= listRunLedgers().matches, repository, pr.number) })),
     listMerged: async (page, perPage, repository): Promise<SweepMergedPr[]> =>
-      (await listed(closed, repository, 'closed')).filter((pr) => pr.merged_at !== null)
+      (await listed(closed, repository, 'closed')).filter((pr) => pr.merged_at !== null && pr.base?.ref === 'main')
         .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),
+        .map((pr) => ({ number: pr.number, title: pr.title, branch: pr.head.ref, body: pr.body ?? undefined,
+          mergedAt: pr.merged_at ?? undefined, changedFiles: filesFor(repository, pr.number),
+          mergeCommitMessage: pr.merge_commit_sha ? ghJson<{ commit: { message: string } }>(
+            ['api', `repos/${repository}/commits/${pr.merge_commit_sha}`], execute).commit.message : undefined,
+          landingVerifiedComments: landingCommentsFor(repository, pr.number) })),
+    getRunStatus: async (draft, repository) => runStatusFor(draft, repository),
+    getLatestFileChanges: async (draft, repository) => latestFileChangesFor(draft, repository),
+    hasFinalRunResult: async (draft, repository) => {
+      ledgerMatches ??= listRunLedgers().matches;
+      const ownedRuns = new Set(ledgerMatches.filter((match) => {
+        const prEvents = match.entries.filter((entry) => entry.event === 'pr-opened' && entry.data.number === draft.number);
+        return prEvents.length > 0 && prEvents.every((entry) => ledgerPrRepository(entry.data, draft.number) === repository);
+      }).map((match) => match.runId));
+      if (ownedRuns.size === 0) return false;
+      // A previous owner's final does not establish finality for a later owner of this PR.
+      if (draft.runId && !ownedRuns.has(draft.runId)) return false;
+      if (!draft.runId && ownedRuns.size > 1) return false;
+      const currentOwners = draft.runId ? new Set([draft.runId]) : ownedRuns;
+      const path = logsDbPath();
+      if (!existsSync(path)) return false;
+      const store = LogStore.openReadOnly(path);
+      try {
+        let beforeId: number | undefined;
+        for (;;) {
+          const rows = store.query({ exactCategories: ['self-implement.result'], events: ['final'], grep: String(draft.number),
+            limit: 1_000, ...(beforeId === undefined ? {} : { beforeId }) });
+          for (const row of rows) {
+            try {
+              const data = JSON.parse(row.data ?? '{}') as { runId?: string; prNumber?: number };
+              if (data.prNumber === draft.number && data.runId && currentOwners.has(data.runId)) return true;
+            } catch { /* A malformed result cannot establish finality. */ }
+          }
+          if (rows.length < 1_000) return false;
+          beforeId = rows.at(-1)!.id;
+        }
+      } finally { store.close(); }
+    },
     listLiveBranches: async (repository) => {
       const cwd = process.cwd();
       const remote = git(cwd, ['config', '--get', 'remote.origin.url']);
@@ -1982,6 +2105,7 @@ export interface HarnessCliCommandDeps {
   deliverableVerify?: InstallDeliverableVerifyCliDeps;
   processObservation?: HarnessProcessObservationDeps;
   draftSweep?: HarnessDraftSweepDeps;
+  queue?: HarnessQueueDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
   /** Observe-only Pod host dispatch seam. */
@@ -2034,6 +2158,30 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   installHarnessProcessObservationCommand(harnessCmd, deps.processObservation);
   installHarnessBudgetCommand(harnessCmd);
   installHarnessDraftSweepCommand(harnessCmd, deps.draftSweep);
+  const queue = harnessCmd.command('queue').description('자리별 영속 발사 대기열');
+  const queueDeps = deps.queue ?? {};
+  const queueAction = (action: () => Promise<void>): Promise<void> => runInjectedHarnessHandler(action);
+  queue.command('add').requiredOption('--seat <seat>', 'OP|TC|MK|UX')
+    .option('--say <sentence>', '원문 문장').option('--ask <goal-path>', '골 문서 경로')
+    .option('--hold', '자동 병합 금지').option('--heavy', 'Pod high 메모리')
+    .action((opts: { seat: string; say?: string; ask?: string; hold?: boolean; heavy?: boolean }) => queueAction(async () => {
+      const row = await addHarnessQueue(opts, queueDeps);
+      console.log(`${row.id} ${row.seat} ${row.kind} queued`);
+    }));
+  queue.command('list').description('대기·발사 원장 조회').action(() => queueAction(async () => {
+    for (const row of listHarnessQueue(queueDeps)) console.log(`${row.id} ${row.seat} ${row.status} ${row.kind} ${row.input}`);
+  }));
+  queue.command('remove <id>').description('대기 중 또는 종료 확인된 항목 제거').action((id: string) => queueAction(async () => {
+    if (!await removeHarnessQueue(id, queueDeps)) throw new Error(`queue item active or not found: ${id}`);
+    console.log(`${id} removed`);
+  }));
+  queue.command('reconcile <id>').description('불확정 발사를 확인하고 종료 또는 미발사 증거가 있으면 예약 해소').action((id: string) => queueAction(async () => {
+    console.log(`${id} ${await reconcileHarnessQueue(id, queueDeps)}`);
+  }));
+  queue.command('tick').description('맨 앞 한 건의 자리 몫과 Pod 풀 여유를 확인하고 발사').action(() => queueAction(async () => {
+    const result = await tickHarnessQueue(queueDeps);
+    console.log(`${result.outcome}${result.item ? ` ${result.item.id}` : ''}: ${result.reason}`);
+  }));
 
   const ask = deps.ask;
   if (ask) {

package/src/harness/harness-queue-child.ts

@@ -0,0 +1,37 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { renameSync, writeFileSync } from 'node:fs';
+
+/** Only a confirmed terminal observation allows reconciliation to release an uncertain launch. */
+export function writeHarnessQueueReceipt(receiptPath: string, state: 'started' | 'finished' | 'not-started'): void {
+  const temp = `${receiptPath}.${randomUUID()}.tmp`;
+  writeFileSync(temp, JSON.stringify({ state, at: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+  renameSync(temp, receiptPath);
+}
+
+export async function runHarnessQueueChild(
+  receiptPath: string, command: string, args: string[],
+  start: typeof spawn = spawn,
+): Promise<number> {
+  const record = (state: 'started' | 'finished' | 'not-started') => writeHarnessQueueReceipt(receiptPath, state);
+  let child: ReturnType<typeof spawn>;
+  try { child = start(process.execPath, [command, ...args], { stdio: 'inherit', env: process.env }); }
+  catch { record('not-started'); return 1; }
+  return await new Promise<number>((done) => {
+    let started = false;
+    child.once('spawn', () => {
+      started = true;
+      record('started');
+      child.once('exit', (code) => { record('finished'); done(code ?? 1); });
+    });
+    child.once('error', () => {
+      if (!started) { record('not-started'); done(1); }
+    });
+  });
+}
+
+if (import.meta.main) {
+  const [receiptPath, command, ...args] = process.argv.slice(2);
+  if (!receiptPath || !command) throw new Error('queue child requires receipt path and command');
+  process.exitCode = await runHarnessQueueChild(receiptPath, command, args);
+}

package/src/harness/harness-queue.ts

@@ -0,0 +1,306 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig } from '../user-config.js';
+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';
+
+export type QueueSeat = 'OP' | 'TC' | 'MK' | 'UX';
+export type QueueItem = {
+  id: string; seat: QueueSeat; kind: 'say' | 'ask'; input: string; hold: boolean; heavy: boolean;
+  at: string; status: 'queued' | 'launching' | 'launched' | 'finished'; pid?: number; launchId?: string;
+};
+export type QueuePool = { running: number; pending: number; reserved: number; limit: number };
+export type QueueTick = { outcome: 'launched' | 'waiting' | 'skipped'; item?: QueueItem; reason: string };
+export type QueueProcess = { pid: number; seat?: QueueSeat; launchId?: string };
+
+export interface HarnessQueueDeps {
+  root?: string;
+  cap?: (seat: QueueSeat) => number;
+  pool?: () => QueuePool;
+  launch?: (item: QueueItem, args: string[], root: string) => Promise<number>;
+  alive?: (pid: number) => boolean;
+  processes?: () => readonly QueueProcess[];
+  receipt?: (root: string, launchId: string) => 'started' | 'finished' | 'not-started' | null;
+  log?: (event: 'enqueued' | 'launched' | 'waiting' | 'skipped', data: Record<string, unknown>) => void;
+}
+
+export function harnessQueuePath(root = effectiveInstanceRoot()): string {
+  return join(root, 'harness', 'queue.json');
+}
+
+function observe(event: 'enqueued' | 'launched' | 'waiting' | 'skipped', data: Record<string, unknown>, deps: HarnessQueueDeps): void {
+  try { (deps.log ?? ((name, payload) => debug.log('harness.queue', name, payload)))(event, data); }
+  catch { /* Logging cannot affect dispatch. */ }
+}
+
+function read(path: string): QueueItem[] {
+  if (!existsSync(path)) return [];
+  const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+  if (!Array.isArray(value) || !value.every((row) => row && typeof row === 'object'
+    && typeof row.id === 'string' && /^(OP|TC|MK|UX)$/.test(row.seat)
+    && (row.kind === 'say' || row.kind === 'ask') && typeof row.input === 'string'
+    && typeof row.at === 'string' && typeof row.hold === 'boolean' && typeof row.heavy === 'boolean'
+    && ['queued', 'launching', 'launched', 'finished'].includes(row.status)
+    && (row.pid === undefined || Number.isSafeInteger(row.pid))
+    && (row.launchId === undefined || typeof row.launchId === 'string'))) {
+    throw new Error('harness queue: invalid queue file (no launch)');
+  }
+  return value as QueueItem[];
+}
+
+function save(path: string, items: QueueItem[]): void {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, `${JSON.stringify(items, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, path);
+  } catch (error) {
+    try { unlinkSync(temporary); } catch { /* write did not finish */ }
+    throw error;
+  }
+}
+
+// SQLite OS locks release on process death, including death while awaiting a launch.
+async function locked<T>(root: string, action: (path: string) => Promise<T>): Promise<T> {
+  const path = harnessQueuePath(root);
+  mkdirSync(join(root, 'harness'), { recursive: true, mode: 0o700 });
+  const db = new Database(`${path}.mutex.sqlite`, { create: true, strict: true });
+  try {
+    const deadline = Date.now() + 30_000;
+    for (;;) {
+      try { db.exec('BEGIN IMMEDIATE'); break; }
+      catch (error) {
+        if ((error as { code?: string }).code !== 'SQLITE_BUSY' || Date.now() >= deadline) throw error;
+        await Bun.sleep(25);
+      }
+    }
+    try { return await action(path); }
+    finally { db.exec('ROLLBACK'); }
+  } finally { db.close(); }
+}
+
+function seat(value: string): QueueSeat {
+  if (!/^(OP|TC|MK|UX)$/.test(value)) throw new Error(`harness queue: unknown seat ${value}`);
+  return value as QueueSeat;
+}
+
+export async function addHarnessQueue(input: { seat: string; say?: string; ask?: string; hold?: boolean; heavy?: boolean }, deps: HarnessQueueDeps = {}): Promise<QueueItem> {
+  const assigned = seat(input.seat);
+  if ((input.say === undefined) === (input.ask === undefined)) throw new Error('harness queue add: --say 또는 --ask 중 하나만 필요');
+  const kind = input.ask === undefined ? 'say' : 'ask';
+  const text = kind === 'say' ? input.say! : input.ask!;
+  if (!text.trim()) throw new Error('harness queue add: 빈 입력');
+  const value = kind === 'ask' ? resolve(text) : text;
+  if (kind === 'ask' && !existsSync(value)) throw new Error(`harness queue add: goal file not found: ${value}`);
+  const root = deps.root ?? effectiveInstanceRoot();
+  return locked(root, async (path) => {
+    const item: QueueItem = { id: `hq-${randomUUID()}`, seat: assigned, kind, input: value,
+      hold: input.hold === true, heavy: input.heavy === true, at: new Date().toISOString(), status: 'queued' };
+    save(path, [...read(path), item]);
+    observe('enqueued', { id: item.id, seat: item.seat, kind }, deps);
+    return item;
+  });
+}
+
+export function listHarnessQueue(deps: HarnessQueueDeps = {}): QueueItem[] {
+  return read(harnessQueuePath(deps.root ?? effectiveInstanceRoot()));
+}
+
+export async function removeHarnessQueue(id: string, deps: HarnessQueueDeps = {}): Promise<boolean> {
+  const root = deps.root ?? effectiveInstanceRoot();
+  return locked(root, async (path) => {
+    const rows = read(path);
+    const item = rows.find((row) => row.id === id);
+    if (!item) return false;
+    if (item.status !== 'queued' && item.status !== 'finished') {
+      if ((item.status !== 'launched' && item.status !== 'launching') || !item.launchId) return false;
+      const state = (deps.receipt ?? receipt)(root, item.launchId);
+      if (state !== 'finished' && state !== 'not-started'
+        || (deps.processes ?? readHarnessQueueProcesses)().some((row) => row.launchId === item.launchId)) return false;
+    }
+    save(path, rows.filter((row) => row.id !== id));
+    observe('skipped', { id, seat: item.seat, reason: 'removed' }, deps);
+    return true;
+  });
+}
+
+export function queueLaunchArgs(item: QueueItem): string[] {
+  return ['harness', item.kind, item.input, '--substrate', 'pod',
+    ...(item.hold ? ['--no-auto-merge'] : []), ...(item.heavy ? ['--pod-memory', 'high'] : [])];
+}
+
+export function readHarnessQueuePool(): QueuePool {
+  const config = getUserConfig();
+  const spec = resolvePodPoolSpec(undefined, process.env, () => config.harness?.podPool ?? config.pod?.pool);
+  const current = spec ? null : leaseKubectl(['config', 'current-context']);
+  const context = spec ?? (current?.status === 0 ? current.stdout.trim() : '');
+  if (!context) throw new Error('pod lease status: no pool/context');
+  const members = parsePodPool(context);
+  const observed = measurePoolLease(members);
+  if (observed.members.some((member) => member.running === null || member.pending === null)) throw new Error('pod lease status: incomplete running/pending measurement');
+  const pendingJobs = observed.members.flatMap((member) => member.pendingJobs ?? []);
+  const records = podPoolHostLease(members).live();
+  return {
+    running: observed.members.reduce((sum, member) => sum + member.running!, 0),
+    pending: observed.members.reduce((sum, member) => sum + member.pending!, 0),
+    reserved: hostLeaseCounts(records).reserved + records.filter((row) => row.stage === 'job' && !leaseHasPendingPod(row, pendingJobs)).length,
+    limit: members.reduce((sum, member) => sum + member.capacity, 0),
+  };
+}
+
+function alive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+/** Host inventory includes harness authoring before it has a run ledger. Unattributed processes count for every seat. */
+export function readHarnessQueueProcesses(): readonly QueueProcess[] {
+  const result = spawnSync('ps', ['-eo', 'pid=,args='], { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 });
+  if (result.error || result.status !== 0 || typeof result.stdout !== 'string') throw new Error('harness process inventory unavailable');
+  const rows: QueueProcess[] = [];
+  for (const line of result.stdout.split('\n')) {
+    const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+    if (!match) continue;
+    const command = match[2]!;
+    if (!/^(?:\S*\/)?(?:bun|node)(?:\s|$)/.test(command)
+      || !/(?:elanous\.mjs|harness-queue-child\.ts)/.test(command)
+      || !/(?:\bharness\s+(?:say|ask)\b|\bdev\s+.*(?:--say|--ask|--file|--implement)\b|\bself\s+(?:implement|orchestrate)\b|harness-queue-child\.ts)/.test(command)) continue;
+    const pid = Number(match[1]);
+    if (!Number.isSafeInteger(pid) || pid <= 0) throw new Error('invalid harness pid');
+    let envSeat: string | undefined;
+    let envLaunch: string | undefined;
+    if (process.platform === 'linux') {
+      try {
+        const env = readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0');
+        envSeat = env.find((entry) => entry.startsWith('ELANOUS_HARNESS_SEAT='))?.slice('ELANOUS_HARNESS_SEAT='.length);
+        envLaunch = env.find((entry) => entry.startsWith('ELANOUS_HARNESS_QUEUE_LAUNCH='))?.slice('ELANOUS_HARNESS_QUEUE_LAUNCH='.length);
+      } catch { /* Unknown attribution is charged to all seats. */ }
+    }
+    const assigned = envSeat ?? /--seat[=\s]+(OP|TC|MK|UX)(?:\s|$)/.exec(command)?.[1];
+    rows.push({ pid, ...(assigned && /^(OP|TC|MK|UX)$/.test(assigned) ? { seat: assigned as QueueSeat } : {}),
+      ...(envLaunch ? { launchId: envLaunch } : {}) });
+  }
+  return rows;
+}
+
+export function harnessQueueReceiptPath(root: string, launchId: string): string {
+  if (!/^hq-[0-9a-f-]{36}$/.test(launchId)) throw new Error('invalid queue launch id');
+  return join(root, 'harness', `${launchId}.receipt.json`);
+}
+
+function receipt(root: string, launchId: string): 'started' | 'finished' | 'not-started' | null {
+  try {
+    const record = JSON.parse(readFileSync(harnessQueueReceiptPath(root, launchId), 'utf8')) as { state?: string };
+    return record.state === 'started' || record.state === 'finished' || record.state === 'not-started' ? record.state : null;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+async function launch(item: QueueItem, args: string[], root: string): Promise<number> {
+  const repo = resolve(import.meta.dir, '../..');
+  const logPath = join(root, 'harness', `${item.id}.log`);
+  const fd = openSync(logPath, 'a', 0o600);
+  try {
+    const child = spawn(process.execPath, [join(repo, 'src', 'harness', 'harness-queue-child.ts'),
+      harnessQueueReceiptPath(root, item.launchId!), join(repo, 'bin', 'elanous.mjs'),
+      ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
+      cwd: repo, detached: true, stdio: ['ignore', fd, fd],
+      env: { ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_HARNESS_SEAT: item.seat,
+        ELANOUS_HARNESS_QUEUE_LAUNCH: item.launchId! },
+    });
+    const pid = await new Promise<number>((done, reject) => {
+      child.once('spawn', () => done(child.pid!));
+      child.once('error', (error) => {
+        try { writeHarnessQueueReceipt(harnessQueueReceiptPath(root, item.launchId!), 'not-started'); }
+        catch { /* A failed receipt write leaves the reservation safely indeterminate. */ }
+        reject(error);
+      });
+    });
+    child.unref();
+    return pid;
+  } finally { closeSync(fd); }
+}
+
+/** Only a wrapper receipt proving no active child can clear an uncertain reservation. */
+export async function reconcileHarnessQueue(id: string, deps: HarnessQueueDeps = {}): Promise<'released' | 'running' | 'unknown'> {
+  const root = deps.root ?? effectiveInstanceRoot();
+  return locked(root, async (path) => {
+    const rows = read(path);
+    const item = rows.find((row) => row.id === id);
+    if (!item || !['launching', 'launched'].includes(item.status) || !item.launchId) return 'unknown';
+    const state = (deps.receipt ?? receipt)(root, item.launchId);
+    const processes = (deps.processes ?? readHarnessQueueProcesses)();
+    if (processes.some((row) => row.launchId === item.launchId)
+      || (item.pid !== undefined && (deps.alive ?? alive)(item.pid) && state !== 'finished' && state !== 'not-started')) return 'running';
+    if (state !== 'finished' && state !== 'not-started') return 'unknown';
+    // A finished receipt proves the child exited; a reused wrapper PID alone is not its identity.
+    // Keep completed launches in the ledger, but never charge their seat again.
+    save(path, state === 'finished' && item.status === 'launched'
+      ? rows.map((row) => row.id === id ? { ...row, status: 'finished' } : row)
+      : rows.filter((row) => row.id !== id));
+    observe('skipped', { id, seat: item.seat, reason: `reconciled ${state}`, launchId: item.launchId }, deps);
+    return 'released';
+  });
+}
+
+export async function tickHarnessQueue(deps: HarnessQueueDeps = {}): Promise<QueueTick> {
+  const root = deps.root ?? effectiveInstanceRoot();
+  return locked(root, async (path) => {
+    const items = read(path);
+    const item = items.find((row) => row.status === 'queued');
+    if (!item) { observe('skipped', { reason: 'empty' }, deps); return { outcome: 'skipped', reason: 'empty' }; }
+    const cap = (deps.cap ?? ((s: QueueSeat) => getUserConfig().harness?.queue?.seatCap?.[s] ?? 8))(item.seat);
+    if (!Number.isSafeInteger(cap) || cap < 1) throw new Error(`harness queue: invalid seat cap for ${item.seat}`);
+    const wait = (reason: string, active: number): QueueTick => {
+      observe('waiting', { id: item.id, seat: item.seat, reason, active, cap }, deps);
+      return { outcome: 'waiting', item, reason };
+    };
+    let processes: readonly QueueProcess[];
+    try { processes = (deps.processes ?? readHarnessQueueProcesses)(); }
+    catch (error) { return wait(`harness process inventory unavailable: ${String(error)}`, 0); }
+    const current = items.flatMap((row) => {
+      if ((row.status !== 'launched' && row.status !== 'launching') || !row.launchId) return [row];
+      const state = (deps.receipt ?? receipt)(root, row.launchId);
+      if (state !== 'finished' && state !== 'not-started'
+        || processes.some((process) => process.launchId === row.launchId)) return [row];
+      return state === 'finished' && row.status === 'launched' ? [{ ...row, status: 'finished' as const }] : [];
+    });
+    if (current.length !== items.length || current.some((row, index) => row !== items[index])) save(path, current);
+    const charged = processes.filter((row) => !row.seat || row.seat === item.seat);
+    const launchIds = new Set(charged.map((row) => row.launchId));
+    const active = new Set(charged.map((row) => row.launchId ?? `pid:${row.pid}`)).size + current.filter((row) => row.seat === item.seat &&
+      (row.status === 'launching' || row.status === 'launched')
+      && (!row.launchId || !launchIds.has(row.launchId))).length;
+    if (active >= cap) return wait(`seat ${item.seat}: ${active}/${cap}`, active);
+    let pool: QueuePool;
+    try { pool = (deps.pool ?? readHarnessQueuePool)(); }
+    catch (error) { return wait(`pod lease status unavailable: ${String(error)}`, active); }
+    if (![pool.running, pool.pending, pool.reserved, pool.limit].every((n) => Number.isSafeInteger(n) && n >= 0) || pool.limit < 1) {
+      return wait('pod lease status incomplete', active);
+    }
+    const queueLaunching = current.filter((row) => row.status === 'launching' || row.status === 'launched').length;
+    if (pool.running + pool.pending + pool.reserved + queueLaunching >= pool.limit) {
+      return wait(`pool: ${pool.running}+${pool.pending}+${pool.reserved}+${queueLaunching}/${pool.limit}`, active);
+    }
+    const launching: QueueItem = { ...item, status: 'launching', launchId: `hq-${randomUUID()}` };
+    save(path, current.map((row) => row.id === item.id ? launching : row));
+    try {
+      const pid = await (deps.launch ?? launch)(launching, queueLaunchArgs(launching), root);
+      if (!Number.isSafeInteger(pid) || pid < 1) throw new Error('launcher returned no pid');
+      const launched: QueueItem = { ...launching, pid, status: 'launched' };
+      save(path, current.map((row) => row.id === item.id ? launched : row));
+      observe('launched', { id: item.id, seat: item.seat, pid, kind: item.kind, launchId: launched.launchId }, deps);
+      return { outcome: 'launched', item: launched, reason: 'spawned' };
+    } catch (error) {
+      observe('skipped', { id: item.id, seat: item.seat, reason: `launch uncertain: ${String(error)}`, launchId: launching.launchId }, deps);
+      throw error;
+    }
+  });
+}