elanous 0.2.16 → 0.2.17

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

@@ -1,9 +1,9 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { dlopen, FFIType } from 'bun:ffi';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { constants as osConstants, hostname } from 'node:os';
-import { basename, dirname, resolve, sep } from 'node:path';
+import { basename, dirname, join, resolve, sep } from 'node:path';
 import { findGitDir } from '../git-fs/locate.js';
 import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 import { loadSelfDevRun } from '../self-dev/run-store.js';
@@ -14,7 +14,7 @@ import { archiveGoals, type GoalArchiveOptions } from '../self-implement/goal-ar
 import { detectBursts, formatIncidentBurstWarning, incidentLastLines, readRunExits, recentBurst, recordRunExit } from './harness-incidents.js';
 import { Command, Option } from 'commander';
 import { runGitCommand } from '../git-fs/runner.js';
-import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, type GoalType } from '../self-implement/goal-author.js';
+import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { listRunLedgers, loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerMatch } from '../self-implement/run-ledger.js';
 import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
@@ -33,7 +33,8 @@ import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDep
 import { getUserConfig } from '../user-config.js';
 import { resolveRepositoryName } from './repository-name.js';
 import { installHarnessCliSinkHook } from './harness-cli-sink.js';
-import { addHarnessQueue, listHarnessQueue, queueSeatForCwd, reconcileHarnessQueue, removeHarnessQueue, tickHarnessQueue, type HarnessQueueDeps, type QueueSeat } from './harness-queue.js';
+import { addHarnessQueue, HarnessQueueDuplicateError, harnessQueueReceiptPath, listHarnessQueue, queueSeatForCwd, reconcileHarnessQueue, removeHarnessQueue, tickHarnessQueue, type HarnessQueueDeps, type QueueItem, type QueueSeat } from './harness-queue.js';
+import { writeHarnessQueueReceipt } from './harness-queue-child.js';
 import { parseDoorSince, queryLaunchDoors, renderLaunchDoors, type DoorTable } from './launch-stamp.js';
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from './harness-substrate-default.js';
 import { runHarnessPlanRfc } from './harness-plan-rfc.js';
@@ -110,9 +111,12 @@ export interface HarnessAskSayOptions {
   supervise?: boolean;
   supervisorSource?: HarnessSupervisorSource;
   goalType?: GoalType;
+  authorGrade?: GoalAuthorGrade;
+  authorGradeSource?: GoalAuthorGradeSelection['source'];
   correlation?: string;
   /** Depth 0 only. At depth >= 1 this flag is ignored and the launch stays refused. */
   nestedElanous?: 'allow';
+  queue?: boolean;
 }
 
 export interface ResolvedHarnessSupervisor {
@@ -263,6 +267,7 @@ function registerHarnessAskSayOptions(command: Command): Command {
     .option('--yes', 'git 아닌 프로젝트에 git init 및 첫 커밋을 만들도록 동의')
     .option('--correlation <id>', '요청과 런을 잇는 불투명 correlation 값')
     .addOption(new Option('--seat <seat>', '런 귀속 자리 (OP|TC|MK|UX)').choices(['OP', 'TC', 'MK', 'UX']))
+    .option('--no-queue', '비상시 자리별 대기열을 건너뛰고 직접 발사')
     .addOption(new Option('--goal-type <type>', `골 종류 (${GOAL_TYPES.join('|')})`).choices([...GOAL_TYPES]))
     .option('--force-preflight', '전제 검사 막힘을 명시 요청으로 우회(관측에 남음)')
     .option('--force-gate', '같은 골 실행 중 막힘을 명시 요청으로 우회(관측에 남음; 예산 막힘은 우회 불가)')
@@ -302,6 +307,8 @@ function normalizeHarnessCommonOptions(opts: HarnessAskSayOptions): HarnessAskSa
     ...(opts.mergeByHost === true ? { mergeByHost: true } : {}),
     ...(opts.observeOnly ? { observeOnly: true } : {}),
     ...(opts.goalType !== undefined ? { goalType: opts.goalType } : {}),
+    ...(opts.authorGrade !== undefined ? { authorGrade: opts.authorGrade } : {}),
+    ...(opts.authorGradeSource !== undefined ? { authorGradeSource: opts.authorGradeSource } : {}),
     ...resolveHarnessSupervisor(opts),
     ...resolveNestedElanousOption(opts),
   };
@@ -589,6 +596,16 @@ function announceLocalChildProvider(opts: unknown): void {
   console.error(`child provider 요청 = ${child.childLlmProvider.trim()}${child.childLlmModel?.trim() ? `/${child.childLlmModel.trim()}` : ''} (local)`);
 }
 
+/** `harness.queue.directSay` (ONEDOOR-2 · OP 10-06 기본 끔): config > env ELANOUS_HARNESS_QUEUE_DIRECT_SAY > false. */
+export function harnessQueueDirectSay(env: NodeJS.ProcessEnv = process.env): boolean {
+  try {
+    const configured = getUserConfig().harness?.queue?.directSay;
+    if (typeof configured === 'boolean') return configured;
+  } catch { /* An unreadable config keeps the old direct path. */ }
+  const raw = env.ELANOUS_HARNESS_QUEUE_DIRECT_SAY?.trim().toLowerCase();
+  return raw === '1' || raw === 'true';
+}
+
 /** `harness.authorOnPod` — 명시 true 만 켠다. 읽기 실패는 끔(호스트 저작)으로 둔다. */
 function harnessAuthorOnPod(): boolean {
   try { return getUserConfig().harness?.authorOnPod === true; }
@@ -633,12 +650,17 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
   let output = '';
   let runId: string | undefined;
   const child = opts as HarnessAskSayChildLlmOptions;
+  const podAuthorGrade = authorOnPod && entrance === 'cli-harness-say'
+    ? child.authorGradeSource && child.authorGrade
+      ? { grade: child.authorGrade, source: child.authorGradeSource }
+      : resolveGoalAuthorGrade(child.authorGrade, getUserConfig().harness?.authorGrade)
+    : undefined;
   // 10-05 PODPROVIDER: say which child provider the Pod will use when the launch named one.
   if (child.childLlmProvider?.trim()) console.error(`child provider 요청 = ${child.childLlmProvider.trim()}${child.childLlmModel?.trim() ? `/${child.childLlmModel.trim()}` : ''} (pod · 자격 없으면 발사 전 거부)`);
   const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(authorOnPod && entrance === 'cli-harness-say' ? { authorOnPod: true } : {}),
     ...(child.childLlmProvider?.trim() ? { childLlmProvider: child.childLlmProvider.trim() } : {}),
     ...(child.childLlmModel?.trim() ? { childLlmModel: child.childLlmModel.trim() } : {}),
-    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.seat ? { seat: o.seat } : {}) },
+    ...(child.childLlmEffort?.trim() ? { childLlmEffort: child.childLlmEffort.trim() } : {}), ...(authorOnPod && podAuthorGrade ? { authorGrade: podAuthorGrade.grade, authorGradeSource: podAuthorGrade.source } : {}), ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...((opts as HarnessAskSayChildLlmOptions).goalType ? { goalType: (opts as HarnessAskSayChildLlmOptions).goalType } : {}), ...(o.after ? { after: o.after } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}), ...(o.seat ? { seat: o.seat } : {}) },
     { onOutput: (text) => {
       runId ??= harnessPodRunId(output + text);
       output = (output + text).slice(-16_000);
@@ -716,22 +738,102 @@ async function dispatchHarnessAskSay(
   },
   dispatch: (resolved: ResolvedHarnessSubstrate, stampedOpts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => Promise<void>,
   gate: PreLaunchGateDeps & { readBudget?: () => Promise<BudgetDecision | 'unknown'> } = {},
+  queueDeps?: HarnessQueueDeps,
+  immediateLaunch?: HarnessQueueDeps['launch'],
+  immediateExit?: () => Promise<number>,
 ): Promise<void> {
   await runInjectedHarnessHandler(async () => {
     assertHarnessChildLlmModel(opts);
-    const resolved = resolveLaunchSubstrate(opts);
     if (isHarnessDryRun(opts)) {
+      resolveLaunchSubstrate(opts);
       printHarnessLaunchDryRun(dryRunPreview);
       return;
     }
     // 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;
-    const assigned = opts.seat ?? queueSeat ?? queueSeatForCwd(process.cwd(), getUserConfig().loops?.orchestrator?.seatTrees);
+    let cwdSeatMemo: { seat: QueueSeat | undefined } | undefined;
+    const cwdSeat = (): QueueSeat | undefined =>
+      (cwdSeatMemo ??= { seat: queueSeatForCwd(process.cwd(), getUserConfig().loops?.orchestrator?.seatTrees) }).seat;
+    const assigned = opts.seat ?? queueSeat ?? cwdSeat();
     const inheritedSeat = process.env.ELANOUS_HARNESS_SEAT;
+    const directSay = harnessQueueDirectSay();
+    const shouldQueue = directSay && opts.queue !== false && !process.env.ELANOUS_HARNESS_QUEUE_LAUNCH
+      && Boolean(opts.seat ?? cwdSeat());
+    const resolved = shouldQueue
+      ? resolveHarnessSubstrate({ flag: opts as HarnessSubstrateOpts, config: getUserConfig(), env: process.env })
+      : resolveLaunchSubstrate(opts);
     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;
+    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) {
+      resolveNestedElanousOption(opts);
+      const flags: string[] = [];
+      const values: Array<[string, string | undefined]> = [
+        ['--base', opts.base], ['--target', opts.target], ['--correlation', opts.correlation],
+        ['--goal-type', opts.goalType], ...(dryRunPreview.entrance === 'cli-harness-say' ? [['--author-grade', opts.authorGradeSource === 'flag' ? opts.authorGrade : undefined] as [string, string | undefined]] : []), ['--child-llm-provider', opts.childLlmProvider],
+        ['--child-llm-model', opts.childLlmModel], ['--child-llm-effort', opts.childLlmEffort],
+        ['--pod-pool', (opts as HarnessSubstrateOpts).podPool], ['--pod-memory', (opts as HarnessSubstrateOpts).podMemory],
+        ['--after', (opts as HarnessSubstrateOpts).after], ['--source', (opts as HarnessSubstrateOpts).source],
+      ];
+      for (const [flag, value] of values) if (value !== undefined) flags.push(flag, value);
+      if ((opts as HarnessSubstrateOpts).source !== undefined && resolved.substrate !== 'pod') {
+        console.error('`--source` 는 `--substrate pod` 와 함께');
+        process.exitCode = 2;
+        return;
+      }
+      if (resolved.substrate === 'pod' && opts.target !== undefined) {
+        console.error('`--target` 은 Pod 경로에서 아직 지원하지 않는다 — 로컬로 돌리거나 `--target` 을 빼라');
+        console.error('Pod 로 특정 원천을 주려면 `--source`');
+        process.exitCode = 2;
+        return;
+      }
+      for (const [enabled, flag] of [
+        [opts.json, '--json'], [opts.yes, '--yes'], [opts.autoMerge === false, '--no-auto-merge'],
+        [opts.mergeByHost, '--merge-by-host'], [opts.observeOnly, '--observe-only'],
+        [opts.supervise === false, '--no-supervise'], [opts.forcePreflight, '--force-preflight'],
+        [opts.forceGate, '--force-gate'],
+      ] as const) if (enabled) flags.push(flag);
+      let row: QueueItem;
+      try {
+        row = await addHarnessQueue({ seat: stampedSeat, launchCwd: process.cwd(), refuseDuplicate: true,
+        ...(dryRunPreview.goalPath ? { ask: dryRunPreview.goalPath } : { say: dryRunPreview.input }),
+        launchArgs: ['harness', dryRunPreview.goalPath ? 'ask' : 'say', dryRunPreview.goalPath ?? dryRunPreview.input,
+          '--seat', stampedSeat, ...((opts as HarnessSubstrateOpts).substrate ? ['--substrate', (opts as HarnessSubstrateOpts).substrate!] : []), ...flags,
+          ...(opts.nestedElanous ? ['--nested-elanous', opts.nestedElanous] : [])],
+        }, queueDeps);
+        await queueDeps?.afterEnqueue?.(row);
+      } catch (error) {
+        if (!(error instanceof HarnessQueueDuplicateError)) throw error;
+        console.error(`발사 거절 — ${error.message.replace(/[\r\n]+/g, ' ')}`);
+        process.exitCode = 1;
+        return;
+      }
+      const result = await tickHarnessQueue({ ...queueDeps, ...(immediateLaunch ? { launch: immediateLaunch } : {}) }, row.id);
+      if (result.outcome === 'launched' && result.item?.id === row.id) {
+        if (immediateExit) process.exitCode = await immediateExit();
+      } else if (result.outcome === 'waiting') {
+        const reason = listHarnessQueue(queueDeps).find((item) => item.id === row.id)?.waitingReason ?? result.reason;
+        console.log(`대기열에 들어갔다 — ${reason.replace(/[\r\n]+/g, ' ')}`);
+        process.exitCode = 0;
+      } else if (result.outcome === 'skipped' && result.item?.id === row.id && result.item.status !== 'queued') {
+        // Another tick won the race for this row. Only a confirmed launch (pid recorded) is reported as launched;
+        // a row still `launching` may yet fail, so the direct call ends non-zero instead of claiming success.
+        const confirmed = (result.item.status === 'launched' || result.item.status === 'finished') && result.item.pid !== undefined;
+        const log = join(queueDeps?.root ?? effectiveInstanceRoot(), 'harness', `${row.id}.log`);
+        if (confirmed) console.log(`다른 대기열 tick 이 이미 발사했다 — ${row.id} (pid ${result.item.pid}) · 출력: ${log}`);
+        else console.error(`다른 대기열 tick 이 발사 중이다(확정 전) — ${row.id} (${result.item.status}) · harness queue list 로 확인`);
+        try { debug.log('harness.queue', 'raced-launch', { id: row.id, seat: row.seat, status: result.item.status, confirmed }); }
+        catch { /* Observation cannot change the launch outcome. */ }
+        process.exitCode = confirmed ? 0 : 1;
+      } else {
+        throw new Error(`harness queue: ${result.reason}`);
+      }
+      return;
+    }
     // Depth >= 1 cannot re-allow. Drop the flag here so the launch sees the refusal, not the raw argv.
     const nested = resolveNestedElanousOption(opts);
     const stampedOpts = {
@@ -2413,6 +2515,30 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   installHarnessDraftSweepCommand(harnessCmd, deps.draftSweep);
   const queue = harnessCmd.command('queue').description('자리별 영속 발사 대기열');
   const queueDeps = deps.queue ?? {};
+  let launchedExit: Promise<number> | undefined;
+  const immediateLaunch: NonNullable<HarnessQueueDeps['launch']> = queueDeps.launch ?? (async (item: QueueItem, args: string[], root: string) => {
+    const child = spawn(process.execPath, [join(import.meta.dir, 'harness-queue-child.ts'),
+      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,
+        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.
+    launchedExit = new Promise<number>((done) => child.once('close', (code, signal) => {
+      const signo = signal ? (osConstants.signals as Record<string, number>)[signal] : undefined;
+      done(code ?? (signo ? 128 + signo : 1));
+    }));
+    return 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 { /* An unreadable receipt leaves the reservation indeterminate. */ }
+        reject(error);
+      });
+    });
+  });
+  const immediateExit = async (): Promise<number> => launchedExit ? await launchedExit : 0;
   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>', '골 문서 경로')
@@ -2458,7 +2584,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
             }
             return resolved.substrate === 'pod' ? onPod(stampedOpts, 'cli-harness-ask', goalPath, resolved.pool!, deps.podDispatchTask) : (announceLocalChildProvider(stampedOpts), ask(goalPath, normalizeHarnessAskSayOptions(stampedOpts)));
           },
-          deps.launchGate,
+          deps.launchGate, queueDeps, immediateLaunch, queueDeps.launch ? undefined : immediateExit,
         );
       });
   }
@@ -2466,9 +2592,15 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   const say = deps.say;
   if (say) {
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
+      .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const grade = resolveGoalAuthorGrade(opts.authorGrade, getUserConfig().harness?.authorGrade);
+        const podSource = process.env.ELANOUS_POD_AUTHOR_ON_POD === '1' && process.env.ELANOUS_POD_AUTHOR_GRADE === grade.grade
+          ? process.env.ELANOUS_POD_AUTHOR_GRADE_SOURCE : undefined;
+        const gradedOpts = grade.source === 'default' && podSource === undefined ? opts
+          : { ...opts, authorGrade: grade.grade, authorGradeSource: podSource === 'config' || podSource === 'default' || podSource === 'flag' ? podSource : grade.source };
         await dispatchHarnessAskSay(
-          opts,
+          gradedOpts,
           {
             input: sentence.join(' '),
             entrance: 'cli-harness-say',
@@ -2485,7 +2617,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               ? onPod(stampedOpts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask, harnessAuthorOnPod())
               : (announceLocalChildProvider(stampedOpts), say(sentence, normalizeHarnessAskSayOptions(stampedOpts)));
           },
-          deps.launchGate,
+          deps.launchGate, queueDeps, immediateLaunch, queueDeps.launch ? undefined : immediateExit,
         );
       });
   }

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

@@ -49,6 +49,8 @@ export interface HarnessPodDispatchInput {
   readonly childLlmEffort?: string;
   /** `harness.authorOnPod` — say 문장을 Pod 안에서 저작부터 돌린다. 호스트는 영수증만 남긴다. */
   readonly authorOnPod?: boolean;
+  readonly authorGrade?: import('../self-implement/goal-author.js').GoalAuthorGrade;
+  readonly authorGradeSource?: import('../self-implement/goal-author.js').GoalAuthorGradeSource;
 }
 
 export function podOrchestrateArgs(input: HarnessPodDispatchInput, goalFile: string): string[] {
@@ -146,6 +148,15 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
   if (input.after) env.ELANOUS_POD_AFTER = input.after;
   if (input.authorOnPod) env.ELANOUS_POD_AUTHOR_ON_POD = '1';
   else delete env.ELANOUS_POD_AUTHOR_ON_POD;
+  if (input.authorOnPod && input.authorGrade) {
+    env.ELANOUS_POD_AUTHOR_GRADE = input.authorGrade;
+    // 출처는 호스트가 알 때만 싣는다 — 모르면 «flag» 로 지어내지 않고 Pod 가 자기가 본 출처를 쓰게 둔다.
+    if (input.authorGradeSource) env.ELANOUS_POD_AUTHOR_GRADE_SOURCE = input.authorGradeSource;
+    else delete env.ELANOUS_POD_AUTHOR_GRADE_SOURCE;
+  } else {
+    delete env.ELANOUS_POD_AUTHOR_GRADE;
+    delete env.ELANOUS_POD_AUTHOR_GRADE_SOURCE;
+  }
   if (input.entrance === 'cli-harness-ask') {
     const root = findGitDir(cwd)?.root;
     const path = resolve(cwd, input.input);

package/src/harness/harness-queue.ts

@@ -22,6 +22,7 @@ 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; idempotencyKey?: string; waitingReason?: string;
+  launchArgs?: string[]; launchCwd?: string; cellId?: string;
 };
 export type QueuePool = { running: number; pending: number; reserved: number; limit: number };
 export type QueueTick = { outcome: 'launched' | 'waiting' | 'skipped'; item?: QueueItem; reason: string };
@@ -53,6 +54,10 @@ export interface HarnessQueueDeps {
   cap?: (seat: QueueSeat) => number;
   pool?: () => QueuePool;
   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>;
+  /** Script the default launcher runs under the queue child wrapper (default bin/elanous.mjs). */
+  launchCommand?: string;
   alive?: (pid: number) => boolean;
   processes?: () => readonly QueueProcess[];
   receipt?: (root: string, launchId: string) => 'started' | 'finished' | 'not-started' | null;
@@ -143,6 +148,9 @@ function read(path: string): QueueItem[] {
     && (row.pid === undefined || Number.isSafeInteger(row.pid))
     && (row.launchId === undefined || typeof row.launchId === 'string')
     && (row.idempotencyKey === undefined || typeof row.idempotencyKey === 'string')
+    && (row.launchArgs === undefined || Array.isArray(row.launchArgs) && row.launchArgs.every((arg: unknown) => typeof arg === 'string'))
+    && (row.launchCwd === undefined || typeof row.launchCwd === 'string' && row.launchCwd.startsWith('/'))
+    && (row.cellId === undefined || typeof row.cellId === 'string')
     && (row.waitingReason === undefined || typeof row.waitingReason === 'string'))) {
     throw new Error('harness queue: invalid queue file (no launch)');
   }
@@ -207,7 +215,24 @@ function seat(value: string): QueueSeat {
   return value as QueueSeat;
 }
 
-export async function addHarnessQueue(input: { seat: string; say?: string; ask?: string; hold?: boolean; heavy?: boolean; idempotencyKey?: string }, deps: HarnessQueueDeps = {}): Promise<QueueItem> {
+/** Cell id named in a goal text (`칸: ONEDOOR-2` · `칸 ONEDOOR-2`) — ids carry at least one hyphen. */
+export function queueCellId(text: string): string | undefined {
+  return /칸[:\s]\s*([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+)/u.exec(text)?.[1];
+}
+
+/** A say row names its cell in the sentence; an ask row names it inside the goal document (unreadable → none). */
+function queueRowCellId(kind: QueueItem['kind'], input: string): string | undefined {
+  if (kind === 'say') return queueCellId(input);
+  try { return queueCellId(readFileSync(input, 'utf8')); } catch { return undefined; }
+}
+
+export class HarnessQueueDuplicateError extends Error {
+  constructor(existing: QueueItem, key: string) {
+    super(`같은 ${key} 이 이미 대기열에 있거나 도는 중이다 — ${existing.id} (${existing.status})`);
+  }
+}
+
+export async function addHarnessQueue(input: { seat: string; say?: string; ask?: string; hold?: boolean; heavy?: boolean; idempotencyKey?: string; launchArgs?: string[]; launchCwd?: string; refuseDuplicate?: 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';
@@ -228,8 +253,24 @@ export async function addHarnessQueue(input: { seat: string; say?: string; ask?:
         return existing;
       }
     }
+    // Recorded at enqueue: a later edit or deletion of an ask document cannot reopen its cell.
+    const cellId = queueRowCellId(kind, value);
+    if (input.refuseDuplicate) {
+      const cell = cellId;
+      const existing = rows.find((row) => row.status !== 'finished'
+        && !['retryable', 'succeeded'].includes(queueRowOutcome(row, root))
+        && ((row.kind === kind && row.input === value) || (cell !== undefined && (row.cellId ?? queueRowCellId(row.kind, row.input)) === cell)));
+      if (existing) {
+        const key = existing.kind === kind && existing.input === value ? '골' : `칸 ${cell}`;
+        observe('skipped', { id: existing.id, seat: assigned, reason: 'duplicate', key }, deps);
+        throw new HarnessQueueDuplicateError(existing, key);
+      }
+    }
     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',
+      ...(input.launchArgs === undefined ? {} : { launchArgs: input.launchArgs }),
+      ...(input.launchCwd === undefined ? {} : { launchCwd: input.launchCwd }),
+      ...(cellId === undefined ? {} : { cellId }),
       ...(input.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }) };
     save(path, [...rows, item]);
     observe('enqueued', { id: item.id, seat: item.seat, kind }, deps);
@@ -318,6 +359,7 @@ export async function removeHarnessQueue(id: string, deps: HarnessQueueDeps = {}
 }
 
 export function queueLaunchArgs(item: QueueItem): string[] {
+  if (item.launchArgs) return item.launchArgs;
   return ['harness', item.kind, item.input, '--substrate', 'pod',
     ...(item.hold ? ['--no-auto-merge'] : []), ...(item.heavy ? ['--pod-memory', 'high'] : [])];
 }
@@ -468,15 +510,19 @@ function receipt(root: string, launchId: string): 'started' | 'finished' | 'not-
   }
 }
 
-async function launch(item: QueueItem, args: string[], root: string): Promise<number> {
+function defaultLaunch(command?: string) {
+  return (item: QueueItem, args: string[], root: string) => launch(item, args, root, command);
+}
+
+async function launch(item: QueueItem, args: string[], root: string, command?: 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'),
+      harnessQueueReceiptPath(root, item.launchId!), command ?? join(repo, 'bin', 'elanous.mjs'),
       ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
-      cwd: repo, detached: true, stdio: ['ignore', fd, fd],
+      cwd: item.launchCwd ?? 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! },
     });
@@ -675,7 +721,7 @@ export function requestIdleSeats(root: string, now: Date, items: readonly QueueI
   }
 }
 
-export async function tickHarnessQueue(deps: HarnessQueueDeps = {}): Promise<QueueTick> {
+export async function tickHarnessQueue(deps: HarnessQueueDeps = {}, requestedId?: string): Promise<QueueTick> {
   const root = deps.root ?? effectiveInstanceRoot();
   return locked(root, async (path) => {
     try {
@@ -699,10 +745,20 @@ export async function tickHarnessQueue(deps: HarnessQueueDeps = {}): Promise<Que
     }
     const heads = new Map<QueueSeat, QueueItem>();
     for (const row of items) if (row.status === 'queued' && !heads.has(row.seat)) heads.set(row.seat, row);
+    if (requestedId && ![...heads.values()].some((row) => row.id === requestedId)) {
+      const row = items.find((item) => item.id === requestedId);
+      if (!row || row.status !== 'queued') return { outcome: 'skipped', item: row, reason: '이미 처리됨 또는 항목 없음' };
+      const reason = '앞선 대기열 항목 차례';
+      if (row.waitingReason !== reason) save(path, items.map((item) => item.id === requestedId ? { ...item, waitingReason: reason } : item));
+      observe('waiting', { id: row.id, seat: row.seat, reason }, deps);
+      return { outcome: 'waiting', item: { ...row, waitingReason: reason }, reason };
+    }
     if (!heads.size) { observe('skipped', { reason: 'empty' }, deps); return { outcome: 'skipped', reason: 'empty' }; }
     const lastSeat = lastLaunchedSeat(path);
     const first = lastSeat ? (queueSeatNames.indexOf(lastSeat) + 1) % queueSeatNames.length
       : queueSeatNames.indexOf(items.find((row) => row.status === 'queued')!.seat);
+    // A requested tick (direct CLI call) keeps the seat round-robin: it launches its row only when that row is the first
+    // head with room; an earlier seat's head with room means the requested row waits for its turn.
     const candidates = [...queueSeatNames.slice(first), ...queueSeatNames.slice(0, first)]
       .flatMap((name) => heads.get(name) ? [heads.get(name)!] : []);
     const config = deps.configPath === undefined ? getUserConfig() : getUserConfig(deps.configPath);
@@ -729,7 +785,9 @@ export async function tickHarnessQueue(deps: HarnessQueueDeps = {}): Promise<Que
           ...(details.injectedCap === undefined ? {} : { injectedCap: details.injectedCap }), capKeys: details.winners,
           attributed, unattributed }, deps);
       }
-      return { outcome: 'waiting', item: { ...candidates[0]!, waitingReason: blocked.get(candidates[0]!.seat)!.reason }, reason };
+      const subject = (requestedId ? candidates.find((item) => item.id === requestedId) : undefined) ?? candidates[0]!;
+      const subjectReason = blocked.get(subject.seat)!.reason;
+      return { outcome: 'waiting', item: { ...subject, waitingReason: subjectReason }, reason: requestedId ? subjectReason : reason };
     };
     for (const item of candidates) {
       const injectedCap = deps.cap?.(item.seat);
@@ -799,11 +857,32 @@ export async function tickHarnessQueue(deps: HarnessQueueDeps = {}): Promise<Que
           + current.filter((row) => row.status === 'launching' || row.status === 'launched').length, pool!.limit, deps);
       }
       if (finishHeld) { blocked.set(item.seat, { reason: finishHeld, active }); continue; }
+      if (requestedId && item.id !== requestedId) {
+        const requested = current.find((row) => row.id === requestedId)!;
+        // The requested row's own block is the truthful reason — even when its seat comes later in the rotation and was not
+        // evaluated yet; «another seat's turn» only when the requested seat itself has room.
+        const own = blocked.get(requested.seat)?.reason ?? (() => {
+          const ownCap = deps.cap?.(requested.seat);
+          const details = seatCapDetails({ seat: requested.seat, caps, gate, injectedCap: ownCap });
+          const charged = runs.filter((run) => !run.seat || run.seat === requested.seat);
+          const launchIds = new Set(charged.flatMap((run) => [...run.launchIds]));
+          const active = charged.length + current.filter((row) => row.seat === requested.seat &&
+            (row.status === 'launching' || row.status === 'launched')
+            && (!row.launchId || !launchIds.has(row.launchId))).length;
+          if (active >= details.cap) return seatCapReason(requested.seat, active, details);
+          const budget = decideSpawn({ seat: requested.seat, running: active, caps, gate, injectedCap: ownCap });
+          return budget.allow ? undefined : `${budget.reason}: ${seatCapReason(requested.seat, active, details)}`;
+        })();
+        const reason = own ?? `다른 자리 차례 — ${item.seat}`;
+        if (requested.waitingReason !== reason) save(path, current.map((row) => row.id === requestedId ? { ...row, waitingReason: reason } : row));
+        observe('waiting', { id: requested.id, seat: requested.seat, reason }, deps);
+        return { outcome: 'waiting', item: { ...requested, waitingReason: reason }, reason };
+      }
       const launching: QueueItem = { ...item, status: 'launching', launchId: `hq-${randomUUID()}` };
       delete launching.waitingReason;
       save(path, current.map((row) => row.id === item.id ? launching : row));
       try {
-        const pid = await (deps.launch ?? launch)(launching, queueLaunchArgs(launching), root);
+        const pid = await (deps.launch ?? defaultLaunch(deps.launchCommand))(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));

package/src/harness/nested-elanous-policy.ts

@@ -13,6 +13,7 @@
 // an allow flag is ignored and the launch stays refused.
 
 import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
 
 export const ELANOUS_NESTED_DEPTH_ENV = 'ELANOUS_NESTED_DEPTH';
 
@@ -26,7 +27,7 @@ export interface NestedElanousDecision {
   readonly depth: number;
   /** True when depth >= 1 supplied allow and it was ignored. */
   readonly allowIgnored: boolean;
-  readonly reason: 'depth-0' | 'depth-0-allow' | 'depth-unknown' | 'nested-refused' | 'allow-ignored';
+  readonly reason: 'depth-0' | 'depth-0-allow' | 'depth-unknown' | 'nested-refused' | 'allow-ignored' | 'depth-cap';
 }
 
 /** Current process depth from the nested-depth marker. Unset or unreadable = 0 (outer launcher). */
@@ -56,11 +57,25 @@ export function nestedDepthCodexArgs(backendName: string, childDepth: number): s
  * Allow decision. Depth 0 allows only when `allow` is true.
  * Depth >= 1 always refuses; a supplied allow is ignored and logged.
  */
+/** Nested depth cap: explicit value, else `harness.nestedElanousMaxDepth`, else 2. */
+export function resolveNestedDepthCap(maxDepth?: number): number {
+  const configured = maxDepth ?? getUserConfig().harness?.nestedElanousMaxDepth;
+  return typeof configured === 'number' && Number.isSafeInteger(configured) && configured > 0 ? configured : 2;
+}
+
 export function decideNestedElanousLaunch(input: {
   readonly depth: number;
   readonly allow?: boolean;
+  readonly maxDepth?: number;
+  /** False for an ordinary mission spawn that did not request a nested launch — no cap log. */
+  readonly logCap?: boolean;
 }): NestedElanousDecision {
   const depth = Number.isInteger(input.depth) && input.depth >= 0 ? input.depth : 0;
+  const cap = resolveNestedDepthCap(input.maxDepth);
+  if (depth >= cap) {
+    if (input.logCap !== false) debug.log('agent-mission.nested', 'depth-cap', { depth, cap });
+    return { allowed: false, depth, allowIgnored: input.allow === true, reason: 'depth-cap' };
+  }
   if (depth >= 1) {
     if (input.allow === true) {
       debug.log('agent-mission.nested', 'allow-ignored', { depth });
@@ -101,14 +116,18 @@ export function gateNestedElanousLaunch(input: {
   readonly nestedLaunchRequested: boolean;
   readonly allow?: boolean;
   readonly configAllow?: boolean;
+  readonly maxDepth?: number;
 }): NestedElanousDecision {
   const depth = Number.isInteger(input.depth) && input.depth >= 0 ? input.depth : 0;
+  const allow = input.nestedLaunchRequested && (input.allow === true || (depth === 0 && input.configAllow === true));
   if (!input.nestedLaunchRequested) {
-    return decideNestedElanousLaunch({ depth, allow: false });
+    return decideNestedElanousLaunch({ depth, allow: false, logCap: false, ...(input.maxDepth === undefined ? {} : { maxDepth: input.maxDepth }) });
   }
   if (!backendCarriesNestedDepth(input.backendName)) {
+    // The depth-unknown refusal stands; reaching the cap is still recorded.
+    const cap = resolveNestedDepthCap(input.maxDepth);
+    if (depth >= cap) debug.log('agent-mission.nested', 'depth-cap', { depth, cap, backend: input.backendName });
     return { allowed: false, depth, allowIgnored: false, reason: 'depth-unknown' };
   }
-  const allow = input.allow === true || (depth === 0 && input.configAllow === true);
-  return decideNestedElanousLaunch({ depth, allow });
+  return decideNestedElanousLaunch({ depth, allow, ...(input.maxDepth === undefined ? {} : { maxDepth: input.maxDepth }) });
 }