elanous 0.2.41 → 0.2.42

package/src/harness/harness-stop.ts

@@ -16,12 +16,14 @@ import { isAbsolute, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { debug } from '../debug/log.js';
+import { incidentLastLines } from './harness-incidents.js';
 import { selfDevRunsDir } from '../self-dev/run-store.js';
 import { launchBindingRunIds, launchRegistryDir, readLaunchBinding } from './launch-registry.js';
 import { loadRunLedger, resolveFederatedRunLedgerDirectories, runLedgerDir } from '../self-implement/run-ledger.js';
 
 const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 const FULL_RUN_ID = /^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const STOP_POD_OBSERVATION_BUDGET_MS = 4_000;
 
 export class AmbiguousHarnessStopRunIdError extends Error {
   constructor(given: string, candidates: readonly string[]) {
@@ -151,12 +153,14 @@ export interface HarnessStopDeps {
   kill: (pid: number, signal: NodeJS.Signals) => void;
   sleep: (ms: number) => Promise<void>;
   kubeContexts: () => string[];
-  kubectl: (args: readonly string[]) => { status: number | null; stdout: string; stderr: string };
+  kubectl: (args: readonly string[], timeoutMs?: number) => { status: number | null; stdout: string; stderr: string };
   namespace: string;
   graceMs: number;
+  observePodsBeforeDelete?: (runId: string, context: string, label: HarnessStopJobMatchedBy, budget: HarnessStopObservationBudget) => void;
 }
 
 export type HarnessStopJobMatchedBy = 'elanous.run' | 'elanous.child-run';
+type HarnessStopObservationBudget = { startedAt: number | null; budgetMs: number; observedPods: number };
 
 /**
  * 문맥 하나의 Pod Job 삭제 결과(HARNESS-STOP-POD-LABEL) — «0개 지움» 의 종류를 가른다.
@@ -218,12 +222,130 @@ export function psProcessStartMs(pid: number): number | null {
 
 export function defaultHarnessStopDeps(overrides: Partial<HarnessStopDeps> = {}, opts: { launchRegistryDir?: string } = {}): HarnessStopDeps {
   const registry = opts.launchRegistryDir ?? launchRegistryDir();
+  const namespace = overrides.namespace ?? 'elanous-test';
+  const graceMs = overrides.graceMs ?? 10_000;
   const env = { ...process.env };
   for (const key of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete env[key];
-  const kubectl = (args: readonly string[]) => {
-    const r = spawnSync('kubectl', [...args], { encoding: 'utf8', timeout: 15_000, env, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  const kubectl = (args: readonly string[], timeoutMs = 15_000) => {
+    const r = spawnSync('kubectl', [...args], { encoding: 'utf8', timeout: timeoutMs, env, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
     return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? String(r.error ?? '') };
   };
+  const runKubectl = overrides.kubectl ?? kubectl;
+  const maxObservedPods = 2;
+  const listTimeoutMs = 1_500;
+  const logTimeoutMs = 750;
+  const observePodsBeforeDelete = (runId: string, context: string, label: HarnessStopJobMatchedBy, budget: HarnessStopObservationBudget): void => {
+    const requestedAt = new Date().toISOString();
+    const reporterSeat = process.env.ELANOUS_HARNESS_SEAT ?? null;
+    budget.startedAt ??= performance.now();
+    const remainingMs = () => Math.max(0, budget.budgetMs - (performance.now() - budget.startedAt!));
+    const emit = (data: Record<string, unknown>) => debug.log('harness.stop', 'job-termination-predelete', {
+      runId, context, matchedBy: label, requestedAt, reporter: 'harness-stop', reporterSeat, reporterCommand: 'harness stop', ...data,
+    });
+    if (remainingMs() <= 0) {
+      emit({ status: 'budget-exhausted', pods: [], omittedPods: null, observationBudgetMs: budget.budgetMs });
+      return;
+    }
+    try {
+      const listed = runKubectl(['--context', context, '-n', namespace, 'get', 'pods', '-l', `${label}=${runId}`, '-o', 'json'], Math.min(listTimeoutMs, remainingMs()));
+      let pods: unknown[] = [];
+      let listStatus: 'observed' | 'unavailable' | 'invalid' = 'observed';
+      if (listed.status !== 0) listStatus = 'unavailable';
+      else {
+        try {
+          const parsed = JSON.parse(listed.stdout) as { items?: unknown };
+          if (!Array.isArray(parsed.items)) listStatus = 'invalid';
+          else pods = parsed.items;
+        } catch { listStatus = 'invalid'; }
+      }
+      const selectedPods = pods.slice(0, Math.max(0, maxObservedPods - budget.observedPods));
+      budget.observedPods += selectedPods.length;
+      const evidence = selectedPods.map((raw) => {
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { status: 'invalid-pod-record' };
+        const pod = raw as {
+          metadata?: { name?: unknown; labels?: unknown; ownerReferences?: unknown };
+          spec?: { nodeName?: unknown; activeDeadlineSeconds?: unknown; containers?: unknown };
+          status?: { phase?: unknown; reason?: unknown; message?: unknown; startTime?: unknown; conditions?: unknown; containerStatuses?: unknown };
+        };
+        const meta = pod.metadata && typeof pod.metadata === 'object' ? pod.metadata : {};
+        const spec = pod.spec && typeof pod.spec === 'object' ? pod.spec : {};
+        const status = pod.status && typeof pod.status === 'object' ? pod.status : {};
+        const arraysValid = (meta.ownerReferences === undefined || Array.isArray(meta.ownerReferences))
+          && (spec.containers === undefined || Array.isArray(spec.containers))
+          && (status.conditions === undefined || Array.isArray(status.conditions))
+          && (status.containerStatuses === undefined || Array.isArray(status.containerStatuses));
+        if (!arraysValid) return { status: 'invalid-pod-record' };
+        const name = typeof meta.name === 'string' ? meta.name : null;
+        const deadlineSeconds = typeof spec.activeDeadlineSeconds === 'number' && Number.isFinite(spec.activeDeadlineSeconds) && spec.activeDeadlineSeconds >= 0 ? spec.activeDeadlineSeconds : null;
+        const startedAt = typeof status.startTime === 'string' ? status.startTime : null;
+        let deadlineAt: string | null = null;
+        if (deadlineSeconds !== null && startedAt) {
+          const startMs = Date.parse(startedAt);
+          const deadlineMs = startMs + deadlineSeconds * 1000;
+          if (Number.isFinite(startMs) && Number.isFinite(deadlineMs)) {
+            try { deadlineAt = new Date(deadlineMs).toISOString(); } catch { deadlineAt = null; }
+          }
+        }
+        let tail: string[] | null = null;
+        let tailStatus: 'observed' | 'unavailable' | 'not-requested' | 'budget-exhausted' = 'not-requested';
+        if (name && remainingMs() > 0) {
+          const logs = runKubectl(['--context', context, '-n', namespace, 'logs', `pod/${name}`, '-c', 'child', '--tail=20'], Math.min(logTimeoutMs, remainingMs()));
+          if (logs.status === 0) { tail = incidentLastLines(logs.stdout); tailStatus = 'observed'; }
+          else { tail = incidentLastLines(logs.stderr); tailStatus = 'unavailable'; }
+        } else if (name) tailStatus = 'budget-exhausted';
+        const owners = Array.isArray(meta.ownerReferences) ? (meta.ownerReferences as Array<{ kind?: unknown; name?: unknown }>).slice(0, 20) : [];
+        const labels = meta.labels && typeof meta.labels === 'object' ? meta.labels as Record<string, unknown> : {};
+        const containers = Array.isArray(spec.containers) ? (spec.containers as Array<{ name?: unknown; image?: unknown; imagePullPolicy?: unknown }>).slice(0, 20) : [];
+        const conditions = Array.isArray(status.conditions) ? (status.conditions as Array<{ type?: unknown; status?: unknown; reason?: unknown; message?: unknown; lastTransitionTime?: unknown }>).slice(0, 20) : [];
+        const containerStatuses = Array.isArray(status.containerStatuses) ? (status.containerStatuses as Array<{ name?: unknown; imageID?: unknown; state?: unknown }>).slice(0, 20) : [];
+        return {
+          pod: name,
+          job: owners.find((owner) => owner?.kind === 'Job' && typeof owner.name === 'string')?.name ?? null,
+          childRunId: typeof labels['elanous.child-run'] === 'string' ? labels['elanous.child-run'] : null,
+          nodeName: typeof spec.nodeName === 'string' ? spec.nodeName : null,
+          images: containers.map((container) => container && typeof container === 'object' ? ({
+            name: typeof container.name === 'string' ? container.name : null,
+            image: typeof container.image === 'string' ? container.image : null,
+            imagePullPolicy: typeof container.imagePullPolicy === 'string' ? container.imagePullPolicy : null,
+          }) : { status: 'invalid-container-record' }),
+          phase: typeof status.phase === 'string' ? status.phase : null,
+          reason: typeof status.reason === 'string' ? status.reason : null,
+          message: typeof status.message === 'string' ? incidentLastLines(status.message).at(-1) ?? null : null,
+          startTime: startedAt, activeDeadlineSeconds: deadlineSeconds, deadlineAt,
+          conditions: conditions.map((condition) => condition && typeof condition === 'object' ? ({
+            type: typeof condition.type === 'string' ? condition.type : null,
+            status: typeof condition.status === 'string' ? condition.status : null,
+            reason: typeof condition.reason === 'string' ? condition.reason : null,
+            message: typeof condition.message === 'string' ? incidentLastLines(condition.message).at(-1) ?? null : null,
+            lastTransitionTime: typeof condition.lastTransitionTime === 'string' ? condition.lastTransitionTime : null,
+          }) : { status: 'invalid-condition-record' }),
+          containers: containerStatuses.map((container) => {
+            if (!container || typeof container !== 'object') return { status: 'invalid-container-status-record' };
+            const state = container.state && typeof container.state === 'object' ? container.state as Record<string, unknown> : {};
+            const waiting = state.waiting && typeof state.waiting === 'object' ? state.waiting as { reason?: unknown; message?: unknown } : null;
+            const terminated = state.terminated && typeof state.terminated === 'object' ? state.terminated as { reason?: unknown; exitCode?: unknown; signal?: unknown; finishedAt?: unknown } : null;
+            return {
+              name: typeof container.name === 'string' ? container.name : null,
+              imageID: typeof container.imageID === 'string' ? container.imageID : null,
+              waiting: waiting ? { reason: typeof waiting.reason === 'string' ? waiting.reason : null, message: typeof waiting.message === 'string' ? incidentLastLines(waiting.message).at(-1) ?? null : null } : null,
+              terminated: terminated ? {
+                reason: typeof terminated.reason === 'string' ? terminated.reason : null,
+                exitCode: typeof terminated.exitCode === 'number' && Number.isFinite(terminated.exitCode) ? terminated.exitCode : null,
+                signal: typeof terminated.signal === 'number' && Number.isFinite(terminated.signal) ? terminated.signal : null,
+                finishedAt: typeof terminated.finishedAt === 'string' ? terminated.finishedAt : null,
+              } : null,
+            };
+          }),
+          tailSource: 'kubectl-logs-merged-streams', tailStatus, tail,
+        };
+      });
+      emit({ status: listStatus, pods: evidence, omittedPods: Math.max(0, pods.length - selectedPods.length), observationBudgetMs: budget.budgetMs,
+        ...(listStatus === 'unavailable' ? { reason: incidentLastLines(listed.stderr).at(-1) ?? 'kubectl failed' } : {}) });
+    } catch (error) {
+      emit({ status: 'invalid', pods: [], omittedPods: null, observationBudgetMs: budget.budgetMs,
+        reason: incidentLastLines(error instanceof Error ? error.message : String(error)).at(-1) ?? 'observation failed' });
+    }
+  };
   return {
     // This universe first; then the host-wide launch binding, so a run launched from another worktree is still found.
     readPidRecord: (runId) => readPidRecordFrom(selfDevRunsDir(), runId) ?? pidRecordFromLaunchBinding(runId, registry),
@@ -243,12 +365,13 @@ export function defaultHarnessStopDeps(overrides: Partial<HarnessStopDeps> = {},
     kill: (pid, signal) => { process.kill(pid, signal); },
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     kubeContexts: () => {
-      const r = kubectl(['config', 'get-contexts', '-o', 'name']);
+      const r = runKubectl(['config', 'get-contexts', '-o', 'name']);
       return r.status === 0 ? r.stdout.split('\n').map((l) => l.trim()).filter(Boolean) : [];
     },
-    kubectl,
-    namespace: 'elanous-test',
-    graceMs: 10_000,
+    kubectl: runKubectl,
+    observePodsBeforeDelete,
+    namespace,
+    graceMs,
     ...overrides,
   };
 }
@@ -271,7 +394,7 @@ function countDeletedJobLines(stdout: string): number {
 }
 
 /** 문맥 하나의 Pod Job 삭제 — 결과를 넷(deleted·none·unreachable·pods-only)으로 가르고 문맥마다 관측 `harness.stop` `job-delete` 를 남긴다. */
-function deleteRunPodJobs(deps: HarnessStopDeps, runId: string, context: string): HarnessStopJobDelete {
+function deleteRunPodJobs(deps: HarnessStopDeps, runId: string, context: string, budget: HarnessStopObservationBudget): HarnessStopJobDelete {
   const unreachable = (stderr: string): HarnessStopJobDelete => {
     const error = stderr.slice(0, 200);
     debug.log('harness.stop', 'job-delete', { runId, context, outcome: 'unreachable', matchedBy: null, error }, { level: 'warn' });
@@ -281,6 +404,14 @@ function deleteRunPodJobs(deps: HarnessStopDeps, runId: string, context: string)
   for (const label of POD_JOB_LABELS) {
     // `-o name` → «job.batch/<name>» 한 줄씩. 맨 출력은 «job.batch "<name>" deleted» 라 «job.batch/» 로만 세면
     //   지워도 늘 0 이었다(10-11 · 여섯 번 «0개 지움» 뒤 Pod Terminating). 두 꼴을 다 센다(#26194).
+    try { deps.observePodsBeforeDelete?.(runId, context, label, budget); }
+    catch (error) {
+      debug.log('harness.stop', 'job-termination-predelete', {
+        runId, context, matchedBy: label, reporter: 'harness-stop', reporterSeat: process.env.ELANOUS_HARNESS_SEAT ?? null,
+        reporterCommand: 'harness stop', status: 'invalid', pods: [], omittedPods: null,
+        reason: incidentLastLines(error instanceof Error ? error.message : String(error)).at(-1) ?? 'observation failed',
+      }, { level: 'warn' });
+    }
     const r = deps.kubectl(['--context', context, '-n', deps.namespace, 'delete', 'job', '-l', `${label}=${runId}`, '--wait=false', '-o', 'name']);
     if (r.status !== 0) return unreachable(r.stderr);
     const deleted = countDeletedJobLines(r.stdout);
@@ -326,6 +457,18 @@ export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, conte
   const add = (candidate: StopProcessCandidate) => {
     if (!seen.has(candidate.pid)) { seen.add(candidate.pid); candidates.push(candidate); }
   };
+  const requestSignal = (candidate: StopProcessCandidate, signal: NodeJS.Signals) => {
+    const requestAt = new Date().toISOString();
+    let delivery: 'accepted' | 'failed' = 'accepted';
+    try { deps.kill(candidate.pid, signal); }
+    catch { delivery = 'failed'; }
+    debug.log('harness.stop', 'process-signal-request', {
+      runId, signal, requestAt, targetPid: candidate.pid, targetStartedAt: new Date(candidate.startedAt).toISOString(),
+      targetDiscovery: candidate.via, delivery, reporter: 'harness-stop',
+      reporterSeat: process.env.ELANOUS_HARNESS_SEAT ?? null, reporterCommand: 'harness stop',
+    });
+    return delivery === 'accepted';
+  };
   let recordMismatch = false;
   if (record) {
     const recordedStart = deps.processStartMs(record.pid);
@@ -350,7 +493,7 @@ export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, conte
       verified.push(candidate);
     }
     for (const candidate of verified) {
-      try { deps.kill(candidate.pid, 'SIGTERM'); } catch { /* 방금 끝났다 */ }
+      requestSignal(candidate, 'SIGTERM');
     }
     for (const candidate of verified) {
       processState = 'stopped';
@@ -362,14 +505,15 @@ export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, conte
       const still = deps.processStartMs(candidate.pid);
       const expectedStart = candidate.via === 'pid.json' ? record!.startedAt : candidate.startedAt;
       if (still !== null && Math.abs(still - expectedStart) <= START_TOLERANCE_MS) {
-        try { deps.kill(candidate.pid, 'SIGKILL'); processState = 'killed'; } catch { /* 끝났다 */ }
+        if (requestSignal(candidate, 'SIGKILL')) processState = 'killed';
       }
     }
     if (processState === 'absent' && (scan.status === 'failed' || candidates.length > 0)) processState = 'unmeasured';
   }
   // ── ⓑ Pod Job (라벨로만) ───────────────────────────────────
   const targets = dryRun ? [] : contexts && contexts.length > 0 ? [...contexts] : deps.kubeContexts();
-  const jobDeletes = targets.map((context) => deleteRunPodJobs(deps, runId, context));
+  const observationBudget: HarnessStopObservationBudget = { startedAt: null, budgetMs: STOP_POD_OBSERVATION_BUDGET_MS, observedPods: 0 };
+  const jobDeletes = targets.map((context) => deleteRunPodJobs(deps, runId, context, observationBudget));
   const jobsDeleted = jobDeletes.reduce((sum, job) => sum + job.deleted, 0);
   const result: HarnessStopResult = { runId, ...(given !== runId ? { givenRunId: given } : {}), process: processState, ...(record ? { pid: record.pid } : {}), candidates, scanned: scan.status === 'ok', pidRecordFound: record !== null, dryRun, jobsDeleted, jobDeletes, contexts: targets };
   debug.log('harness.stop', 'stopped', { runId, process: processState, jobsDeleted, contexts: targets.length });

package/src/index.ts

@@ -5630,7 +5630,7 @@ const selfOrchestrateCmd = selfCmd
           catch (e) { ui.error(`--pod-source: ${e instanceof Error ? e.message : String(e)}`); process.exit(2); }
           const outDir = join(elanousStateRoot(), 'pod-sources', runId);
           const baseRef = opts.base ?? 'origin/HEAD';
-          try { podSource = resolvePodSource(parsed, { base: baseRef, outDir }); }
+          try { podSource = resolvePodSource(parsed, { base: baseRef, outDir, mirrorHead: image.imageCommit }); }
           catch (e) { ui.error(`--pod-source: ${e instanceof Error ? e.message : String(e)}`); process.exit(2); }
           debug.log('self-implement.pod', 'source', {
             kind: podSource.kind,
@@ -5642,7 +5642,7 @@ const selfOrchestrateCmd = selfCmd
         if (childFlags.childLlmProvider?.trim()) debug.log('self-implement.pod', 'child-provider-named', { provider: childFlags.childLlmProvider.trim(), model: childFlags.childLlmModel ?? null, podProvider });
         // BEDROCK-POD-PROVIDER-DROP — provider·account 는 한 곳(podLaunchProviderOptions)에서 — 손 나열이 bedrock 을 떨궈 codex(team)로 돌았다(10-11).
         const podProviderOptions = (await import('./task-orchestrator/surfaces/pod-child-providers.js')).podLaunchProviderOptions(podProvider, { explicitPodAccount, grokApiKeyOptIn });
-        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}), ...(repairBaseHead && podSource?.kind === 'pr' ? { repairCommitOnly: { pr: podSource.number, baseHead: repairBaseHead } } : {}) };
+        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, warmReuseConfig: () => getUserConfig().pod?.warmReuse, warmReuseEvidence: () => undefined, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}), ...(repairBaseHead && podSource?.kind === 'pr' ? { repairCommitOnly: { pr: podSource.number, baseHead: repairBaseHead } } : {}) };
         if (benchArms) {
           const { benchPodSpawn } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
           podSpawn = benchPodSpawn(benchArms, podBase);
@@ -6938,6 +6938,21 @@ const agentCmd = program
   .alias('codex')
   .description(`Agent-mission CLI — 외부 에이전트 backend(${agentBackendHelpList}) 미션·리뷰 워치·셋업. \`codex\` 는 deprecated alias(하위호환).`);
 
+let agentMissionCliDepsForTesting: Partial<import('./agent-mission/mission-cli.js').MissionCliDeps> | undefined;
+let agentMissionLogSinkForTesting: ((surface: string) => Promise<boolean>) | undefined;
+/** 실제 agent-mission mission 진입점의 탐지·실행 순서를 검증한다. */
+export function setAgentMissionCliDepsForTesting(
+  deps: Partial<import('./agent-mission/mission-cli.js').MissionCliDeps> | undefined,
+): void {
+  agentMissionCliDepsForTesting = deps;
+}
+/** 진입점 회귀 테스트에서 logs.db 쓰기를 차단한다. */
+export function setAgentMissionLogSinkForTesting(
+  register: ((surface: string) => Promise<boolean>) | undefined,
+): void {
+  agentMissionLogSinkForTesting = register;
+}
+
 // ★ 제1원칙 관측 — agent-mission 전 서브커맨드에 logs.db 싱크를 중앙 배선(preAction 훅)하고, 레거시
 //   `codex` alias 진입이면 브레드크럼(명명 중립화 이행률 추적 → alias 제거 안전시점 판정 근거).
 //   • 균일 커버리지: 훅은 mission/review-*/setup/models/config-migrate 모든 액션 앞에 1회 실행 →
@@ -6955,8 +6970,11 @@ const AGENT_MISSION_SURFACE_BY_SUB: Record<string, string> = {
 agentCmd.hook('preAction', async (_thisCommand, actionCommand) => {
   const surface = AGENT_MISSION_SURFACE_BY_SUB[actionCommand.name()] ?? 'agent-mission';
   try {
-    const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
-    await registerStandaloneLogSink(surface);
+    if (agentMissionLogSinkForTesting) await agentMissionLogSinkForTesting(surface);
+    else {
+      const { registerStandaloneLogSink } = await import('./domains/standalone-log-sink.js');
+      await registerStandaloneLogSink(surface);
+    }
   } catch { /* fail-open */ }
   try {
     const { isLegacyCodexInvocation, AGENT_ALIAS_LOG_CATEGORY } = await import('./agent-mission/legacy-alias.js');
@@ -7078,6 +7096,7 @@ agentCmd
     // ★ U4b — 액션 글루(backend 검증·mission-file/text·evidence·spec 빌드·통일 진입점 실행)는
     //   runAgentMissionCliCommand(테스트 가능 seam)로 추출. 액션은 I/O(print/exit)만 담당.
     const { resolveBackend } = await import('./agent-mission/driver.js');
+    const { detectAgentCli } = await import('./agent-mission/tool-install.js');
     const { runAgentMissionCliCommand } = await import('./agent-mission/mission-cli.js');
     const controller = new AbortController();
     const onSigint = (): void => { controller.abort(); };
@@ -7085,7 +7104,8 @@ agentCmd
     let outcome: Awaited<ReturnType<typeof runAgentMissionCliCommand>>;
     try {
       outcome = await runAgentMissionCliCommand(textParts, opts as import('./agent-mission/mission-cli.js').MissionCliOpts,
-        { resolveBackend, signal: controller.signal });
+        { resolveBackend, detectAgentCli, onStatus: (line) => console.error(`[agent-mission] ${line}`), signal: controller.signal,
+          ...agentMissionCliDepsForTesting });
     } finally {
       process.removeListener('SIGINT', onSigint);
     }
@@ -8780,6 +8800,15 @@ missionCmd
     persistMissionOutcome(setMissionMode(cfg.llm.missionRouting, mode));
   });
 
+// Stateless shell bridge for Codex/Claude agent missions. State is scoped to
+// the active Elanous instance; replies are persisted and mirrored to logs.db.
+if (!INDEX_FAST_ROOT) {
+  const { registerMissionOutCommand } = require('./agent-mission/mission-out.js') as typeof import('./agent-mission/mission-out.js');
+  registerMissionOutCommand(program, {
+    emit: (event) => debug.log('mission.reply', 'reply', event),
+  });
+}
+
 registerTasksCommands(program);
 registerBriefCommands(program);
 registerLabelsCommands(program);

package/src/instance/spawn-elanous.ts

@@ -11,6 +11,8 @@ export interface SpawnElanousOptions {
   stateDir?: string;
   /** 실행할 elanous 진입 스크립트. 생략하면 이 트리의 bin/elanous.mjs. */
   bin?: string;
+  /** Installed command entry (for callers that must honor the user's installed CLI). */
+  executable?: string;
   cwd?: string;
   env?: NodeJS.ProcessEnv;
 }
@@ -26,20 +28,20 @@ export function elanousInvocation(args: readonly string[], opts: SpawnElanousOpt
   const root = opts.stateDir?.trim() || effectiveInstanceRoot();
   const base = opts.env ?? process.env;
   return {
-    command: process.execPath,
-    args: [opts.bin ?? DEFAULT_BIN, ...args],
+    command: opts.executable?.trim() || process.execPath,
+    args: opts.executable?.trim() ? [...args] : [opts.bin ?? DEFAULT_BIN, ...args],
     env: { ...base, ELANOUS_STATE_DIR: root, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root, base) },
   };
 }
 
 export function spawnElanous(args: readonly string[], opts: SpawnElanousOptions & Omit<SpawnOptions, 'env' | 'cwd'> = {}): ChildProcess {
-  const { stateDir: _s, bin: _b, env: _e, ...rest } = opts;
+  const { stateDir: _s, bin: _b, executable: _x, env: _e, ...rest } = opts;
   const inv = elanousInvocation(args, opts);
   return spawn(inv.command, inv.args, { ...rest, cwd: opts.cwd, env: inv.env });
 }
 
 export function spawnElanousSync(args: readonly string[], opts: SpawnElanousOptions & Omit<SpawnSyncOptions, 'env' | 'cwd'> = {}): SpawnSyncReturns<string | Buffer> {
-  const { stateDir: _s, bin: _b, env: _e, ...rest } = opts;
+  const { stateDir: _s, bin: _b, executable: _x, env: _e, ...rest } = opts;
   const inv = elanousInvocation(args, opts);
   return spawnSync(inv.command, inv.args, { ...rest, cwd: opts.cwd, env: inv.env });
 }