elanous 0.2.40 → 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/harness/progress-worker-entry.ts

@@ -0,0 +1,59 @@
+import { parentPort } from 'node:worker_threads';
+import { queryRunningRuns, type RunningRunsResult } from '../self-implement/running-runs.js';
+
+/**
+ * HARNESS-PROGRESS-HANG — `harness progress` 하위 조회의 «전용 워커 엔트리».
+ * 이 모듈은 CLI 디스패치(`src/index.ts`·`bin/elanous.mjs`)를 거치지 않고 워커에 직접 적재되므로,
+ * 번들·컴파일 산출물에서도 `parentPort` 핸들러가 반드시 이 스레드에 등록된다.
+ * 그 전에는 워커가 `import.meta.url` 로 배포 엔트리를 재진입해 핸들러가 아예 안 올랐다.
+ */
+export interface ProgressQueryWorkerRequest {
+  readonly kind?: 'query';
+  readonly caller: string;
+  readonly runIds?: readonly string[];
+  readonly timeBudgetMs?: number;
+}
+
+/** 상한 도달 뒤 부모가 보내는 정지 요청 — 워커는 «현재 행» 을 회신하고 정상 종료한다. */
+export interface ProgressQueryWorkerAbortRequest {
+  readonly kind: 'abort';
+}
+
+export type ProgressQueryWorkerMessage = ProgressQueryWorkerRequest | ProgressQueryWorkerAbortRequest;
+
+export interface ProgressQueryWorkerReply {
+  readonly ok: boolean;
+  readonly result?: RunningRunsResult;
+  readonly error?: string;
+  readonly stopped?: 'aborted';
+}
+
+/**
+ * 워커의 `parentPort` 핸들러를 등록한다.
+ * - `query`: 하위 조회를 실행해 결과를 회신한다.
+ * - `abort`: 이 스레드가 마지막으로 계산한 행(`lastResult`)을 «보존 행» 으로 회신한다 —
+ *   부모의 상한 뒤 유예 창 안에 도착하면 `progress-command-late` 관측으로 그대로 보존된다.
+ */
+export function installProgressWorkerEntry(port: NonNullable<typeof parentPort> | null | undefined = parentPort): void {
+  if (!port) return;
+  let lastResult: RunningRunsResult | undefined;
+  port.on('message', (message: ProgressQueryWorkerMessage) => {
+    if (message.kind === 'abort') {
+      port.postMessage({ ok: true, result: lastResult, stopped: 'aborted' } satisfies ProgressQueryWorkerReply);
+      return;
+    }
+    try {
+      const result = queryRunningRuns({
+        caller: message.caller,
+        ...(message.timeBudgetMs === undefined ? {} : { timeBudgetMs: message.timeBudgetMs }),
+        ...(message.runIds === undefined ? {} : { runIds: message.runIds }),
+      });
+      lastResult = result;
+      port.postMessage({ ok: true, result } satisfies ProgressQueryWorkerReply);
+    } catch (error) {
+      port.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) } satisfies ProgressQueryWorkerReply);
+    }
+  });
+}
+
+installProgressWorkerEntry();

package/src/harness/progress-worker-runtime.ts

@@ -0,0 +1,11 @@
+import { isMainThread } from 'node:worker_threads';
+
+/**
+ * HARNESS-PROGRESS-HANG — `harness progress` 하위 조회는 «전용 워커 엔트리»(`./progress-worker-entry.ts`)
+ * 를 직접 적재한다. 그 엔트리는 CLI 디스패치를 거치지 않으므로 번들·컴파일 산출물에서도 `parentPort`
+ * 핸들러가 워커 스레드에 오른다. 이 판정은 배포 엔트리(`bin/elanous.mjs`)가 워커 문맥에서 재진입됐을 때
+ * 대시보드·provider 선택·명령 디스패치를 다시 걸지 않게 가드한다.
+ */
+export function shouldRunCliEntry(): boolean {
+  return isMainThread;
+}

package/src/index.ts

@@ -4748,6 +4748,20 @@ selfCmd
   .option('--shard-position <n>', 'GATE-REMOTE-SHARD-PLAN — 조각 위치(1부터 정수). 원격 명령줄에 그대로 실린다')
   .option('--shard-plan <path>', 'GATE-REMOTE-SHARD-PLAN — 조각 계획 파일 경로. 주면 원격 명령줄에 --shard-plan 으로 실린다')
   .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; shardConcurrency?: string; fixedShardDistribution?: boolean; includeImporters?: boolean; inherit?: boolean; remote?: string | boolean; local?: boolean; artifactDir?: string; orchestrationId?: string; shardId?: string; shardPosition?: string; shardPlan?: string }) => {
+    const { observeSelfGateTrainMarker, refuseSeatSelfGateWithoutTrainMarker, writeSeatSelfGateRefusalArtifact } = require('./self-implement/gate-cli.js') as typeof import('./self-implement/gate-cli.js');
+    const trainMarker = observeSelfGateTrainMarker();
+    if (process.env.ELANOUS_TRACK) {
+      const seatRefusal = refuseSeatSelfGateWithoutTrainMarker(trainMarker);
+      if (seatRefusal) {
+        if (opts.artifactDir !== undefined) {
+          try { writeSeatSelfGateRefusalArtifact(process.cwd(), opts.artifactDir, trainMarker); }
+          catch (error) { ui.error(`self gate artifact: ${error instanceof Error ? error.message : String(error)}`); }
+        }
+        ui.error(seatRefusal.message);
+        process.exitCode = 2;
+        return;
+      }
+    }
     if (!opts.changed && opts.shards === undefined) { ui.error('self gate requires --changed or --shards'); process.exitCode = 2; return; }
     if (opts.fixedShardDistribution && opts.shards === undefined) { ui.error('self gate: --fixed-shard-distribution requires --shards <n>'); process.exitCode = 2; return; }
     if (opts.shardConcurrency !== undefined && (!/^[1-4]$/.test(opts.shardConcurrency))) { ui.error('self gate: --shard-concurrency must be 1–4'); process.exitCode = 2; return; }
@@ -4770,7 +4784,7 @@ selfCmd
       ranLocal = true;
       try {
         const { runSelfGateCliAsync } = require('./self-implement/gate-cli.js') as typeof import('./self-implement/gate-cli.js');
-        const result = await runSelfGateCliAsync(process.cwd(), { base: opts.base, pr: opts.pr, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: Number(opts.shardConcurrency) } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), includeImporterTests: !!opts.includeImporters, noInherit: opts.inherit === false, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
+        const result = await runSelfGateCliAsync(process.cwd(), { base: opts.base, pr: opts.pr, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: Number(opts.shardConcurrency) } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), includeImporterTests: !!opts.includeImporters, noInherit: opts.inherit === false, trainGate: trainMarker.received, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
         console.log(result.lines.join('\n'));
         return result.exitCode;
       } catch (error) {
@@ -4854,6 +4868,8 @@ selfCmd
       const fetched = remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.fetch : undefined;
       try {
         if (fetched?.ok) {
+          const { recordGateTrainMarker } = await import('./self-implement/gate-artifacts.js');
+          recordGateTrainMarker(fetched.summaryPath, trainMarker.received);
           console.log(`artifacts: ${fetched.summaryPath} (junit ${fetched.junitFiles.length} · fetched from remote)`);
           if (fetched.remoteDirKept) console.log(`⚠ artifacts: 원격 산출 디렉토리를 못 지웠다 — ${(remoteArtifacts as { dir: string }).dir} (판정은 그대로다)`);
         }
@@ -4861,7 +4877,7 @@ selfCmd
           const reason = remoteArtifacts && 'unsupported' in remoteArtifacts ? 'remote-unsupported' as const : 'remote-fetch-failed' as const;
           if (reason === 'remote-fetch-failed') console.log(`⚠ artifacts: 원격 산출을 못 가져왔다 — ${fetched && !fetched.ok ? fetched.reason : 'no remote fetch ran'} (판정은 그대로다)`);
           const { writeRemoteUnavailableGateArtifacts } = await import('./self-implement/gate-artifacts.js');
-          const written = writeRemoteUnavailableGateArtifacts(opts.artifactDir, process.cwd(), opts.base, Number(process.exitCode ?? 0), reason);
+          const written = writeRemoteUnavailableGateArtifacts(opts.artifactDir, process.cwd(), opts.base, Number(process.exitCode ?? 0), reason, undefined, undefined, trainMarker.received);
           console.log(`artifacts: ${written.summaryPath} (junit 0 · unavailable=${reason})`);
         }
       } catch (error) {
@@ -5614,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,
@@ -5626,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);
@@ -6922,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회 실행 →
@@ -6939,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');
@@ -7062,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(); };
@@ -7069,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);
     }
@@ -8764,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/dev-project.ts

@@ -3,10 +3,14 @@ import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { appendBoundaryResponseLine, HARNESS_BOUNDARY_RESPONSES_ENV } from '../harness/harness-space.js';
+import { anonymousExport, suggestProjectForFolder } from '../project/project-store.js';
 
 export interface DevProjectDeps {
   git?: (dir: string, args: readonly string[]) => string | null;
   stateDir?: string;
+  /** TENANT-BOUNDARY (0.2.41): 회신 mailbox 경계 채널용 env — 생산은 process.env 기본값. */
+  env?: Record<string, string | undefined>;
 }
 
 interface DevProjectRegistry {
@@ -60,9 +64,30 @@ export function resolveDevProject(dir: string, deps: DevProjectDeps = {}): strin
   try {
     writeJsonAtomically(join(root, '.elanous', 'project.json'), { identityKey, devProject: id } satisfies DevProjectCache);
   } catch { /* cache only */ }
+
+  exportTenantBoundaryRecord(root, id, deps.env ?? process.env);
   return id;
 }
 
+/**
+ * TENANT-BOUNDARY (0.2.41 · nfr:security): 고객 원장의 설치 밖 출구는 익명 내보내기 하나다.
+ * 경계 회신 mailbox(HARNESS_BOUNDARY_RESPONSES_ENV)가 열려 있을 때만, 고객 프로젝트 원장을
+ * `anonymousExport`(식별 필드 → 토큰)로 바꿔 한 줄(JSONL)로 남긴다. 원장 식별 원문은 절대
+ * 설치 밖으로 나가지 않는다. 채널이 없으면 아무 일도 일어나지 않고(기본 동작 보존),
+ * 채널 쓰기가 실패해도 id 해소를 막지 않는다(fail-open).
+ */
+function exportTenantBoundaryRecord(root: string, devProject: string, env: Record<string, string | undefined>): void {
+  const mailbox = env[HARNESS_BOUNDARY_RESPONSES_ENV]?.trim();
+  if (!mailbox) return;
+  try {
+    const project = suggestProjectForFolder(root);
+    appendBoundaryResponseLine(env as NodeJS.ProcessEnv, {
+      devProject,
+      ...(project ? { project: anonymousExport(project) } : {}),
+    });
+  } catch { /* boundary export must never block id resolution */ }
+}
+
 function runGit(dir: string, args: readonly string[]): string | null {
   try {
     return execFileSync('git', ['-C', dir, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });

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 });
 }

package/src/intelligence-map/model-alias.ts

@@ -49,7 +49,7 @@ const MODEL_ALIASES: Readonly<Record<string, string>> = {
   'pro':             'gemini-3.1-pro-preview',
   'gemini-pro':      'gemini-3.1-pro-preview',
   // OpenAI / Codex
-  'codex':           'gpt-6-sol',   // ⭐ 2026-09-25: 운영 codex 기본(gpt-6-sol)과 맞춘다 — gpt-5.5 는 두 세대 낡았다
+  'codex':           'gpt-6.1-terra',
   'gpt-5':           'gpt-5.5',
   'mini':            'gpt-5-mini',
   'nano':            'gpt-5-nano',
@@ -57,15 +57,16 @@ const MODEL_ALIASES: Readonly<Record<string, string>> = {
   //   🔑 왜 — `sol`·`luna` 라는 «같은 이름»이 두 세대에 걸쳐 있다. 세대를 안 쓰면
   //     «어느 세대인지 말하지 않은 것»이고, 그때 골라야 할 것은 ***최신***이다.
   //     (실제로 이 겹침 때문에 커뮤니티 조사기가 5.6 과 6 을 섞어 답한 일이 있었다.)
-  //   ⛔ `terra` 는 GPT-6 에 «없다» — 중간 등급이 접혔고 GPT-6 Sol 이 그 가격대를 흡수했다.
-  //     그래서 `terra` 는 5.6 을 계속 가리킨다(은퇴가 아니라 «후속이 없는» 것이다).
+  //   GPT-6.1 restores a Terra tier; unsuffixed aliases follow the current 6.1 generation.
   //   📏 세대 확인 = `curl /v1/models` ⊕ `codex debug models` (2026-09-23 둘 다 실측).
   'astra':           'gpt-6-astra',
-  'sol':             'gpt-6-sol',
+  'sol':             'gpt-6.1-sol',
   'luna':            'gpt-6-luna',
-  'terra':           'gpt-5.6-terra',   // ⛔ GPT-6 에 후속 없음
+  'terra':           'gpt-6.1-terra',
   // 세대를 «명시»해 부르는 길 — 겹치는 이름을 또렷하게 가리킬 때.
   '6-sol':           'gpt-6-sol',
+  '6.1-sol':         'gpt-6.1-sol',
+  '6.1-terra':       'gpt-6.1-terra',
   '6-luna':          'gpt-6-luna',
   '5.6-sol':         'gpt-5.6-sol',
   '5.6-terra':       'gpt-5.6-terra',