elanous 0.2.4 → 0.2.5

package/src/harness/harness-stop.ts

@@ -3,25 +3,106 @@
 // 🩸 2026-09-27: 멈추려면 사람이 PID 둘(harness ask 부모 · self orchestrate 자식)과 Job 이름을 손으로 찾아야 했고,
 //   그 사이 떠 있던 조각이 main 에 병합됐다(#21048). 부모를 죽이면 자식이 PPID 1 고아로 2h36m 더 돌았다(🅞 보고).
 // B 조각(#21171)이 오케스트레이터에 `self-dev-runs/<runId>/pid.json` ⊕ SIGTERM 정리(새 잡 멈춤 · 자기 Job 삭제 · cancelled)를 넣었다.
-// 이 파일(A 조각)은 그 기록을 «읽고», 소유가 확인될 때만 신호를 보내고, `elanous.run=<runId>` 라벨 Job 을 지운다.
+// 이 파일은 그 기록과 런 원장·프로세스 표를 읽고, 시작 시각이 확인된 후보에만 신호를 보내며, `elanous.run=<runId>` 라벨 Job 을 지운다.
 //
 // ⛔ 불변식: 기록된 시작 시각과 실제 프로세스 시작 시각이 다르면 신호를 보내지 않는다(PID 재사용 방지).
 // ⛔ 불변식: `elanous.run=<runId>` 라벨이 붙은 Job 만 지운다.
 
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync, readlinkSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { debug } from '../debug/log.js';
 import { selfDevRunsDir } from '../self-dev/run-store.js';
+import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
 
 const RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
 /** `pid.json` 의 `startedAt` 은 `Date.now() − uptime` 근삿값이다 — 이만큼의 차이는 같은 프로세스로 본다. */
 export const START_TOLERANCE_MS = 5_000;
 
 export interface PidRecord { pid: number; startedAt: number; argv0?: string }
+export interface StopProcessCandidate { pid: number; startedAt: number; via: 'pid.json' | 'argv-runId' | 'argv-goal' }
+export type StopProcessScan = { status: 'ok'; candidates: StopProcessCandidate[] } | { status: 'failed'; reason: string };
+
+/** The start event, not later bookkeeping, owns the goal document path. */
+export function stopGoalPathFromLedger(runId: string, dir = runLedgerDir()): string | null {
+  try {
+    const start = loadRunLedger(runId, dir)?.find((entry) => entry.event === 'start');
+    const goal = start?.data.goalFile;
+    const root = start?.data.targetRoot;
+    if (typeof goal !== 'string' || !goal.trim()) return null;
+    return isAbsolute(goal) ? resolve(goal) : typeof root === 'string' && isAbsolute(root) ? resolve(root, goal) : goal;
+  } catch { return null; }
+}
+
+/** Parse ps rows without treating a partial or failed measurement as an empty table. Relative goal arguments require the candidate's own cwd, never the stop caller's cwd. */
+export function discoverStopProcesses(runId: string, goalPath: string | null, table: string, processCwd: (pid: number) => string | null = () => null): StopProcessScan {
+  const candidates: StopProcessCandidate[] = [];
+  for (const line of table.split(/\r?\n/)) {
+    if (!line.trim() || /^\s*PID\s/.test(line)) continue;
+    const match = /^\s*(\d+)\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\w+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.+)$/.exec(line);
+    if (!match) return { status: 'failed', reason: 'unparseable process table row' };
+    const pid = Number(match[1]);
+    const startedAt = Date.parse(match[2]!);
+    if (!Number.isSafeInteger(pid) || !Number.isFinite(startedAt)) return { status: 'failed', reason: 'invalid process table row' };
+    if (pid <= 1) continue;
+    const args = match[3]!.match(/"[^"]*"|'[^']*'|\S+/g)?.map((part) => part.replace(/^(['"])(.*)\1$/, '$2')) ?? [];
+    const entry = args.findIndex((arg) => /(?:^|\/)elanous(?:\.mjs)?$/.test(arg));
+    const executable = args[0] ?? '';
+    const runtime = /(?:^|\/)(?:bun|node)$/.test(executable);
+    if (entry < 0 || (entry !== 0 && (!runtime || entry !== 1))) continue;
+    const command = args.slice(entry + 1);
+    const launcher = command[0] === 'harness' && ['ask', 'say'].includes(command[1] ?? '')
+      || command[0] === 'dev' && command.some((arg) => arg === '--ask' || arg === '--say' || arg.startsWith('--ask=') || arg.startsWith('--say='))
+      || command[0] === 'self' && command[1] === 'orchestrate';
+    if (!launcher) continue;
+    const namedRunIds = command.flatMap((arg, i) => arg === '--run-id' || arg === '--runId'
+      ? [command[i + 1] ?? '']
+      : arg.startsWith('--run-id=') || arg.startsWith('--runId=') ? [arg.slice(arg.indexOf('=') + 1)] : []);
+    const runMatch = namedRunIds.includes(runId) || command.includes(runId);
+    // An explicitly different run takes precedence over a shared goal document.
+    if (namedRunIds.some((id) => id !== runId)) continue;
+    // A goal path is a positional or option value, not text embedded in a prompt.
+    const goalArgs = command.flatMap((arg, i) => {
+      if (arg === '--ask' || arg === '--say' || arg === '--goal-file' || arg === '--goal') return [command[i + 1] ?? ''];
+      if (arg.startsWith('--ask=') || arg.startsWith('--say=') || arg.startsWith('--goal-file=') || arg.startsWith('--goal=')) return [arg.slice(arg.indexOf('=') + 1)];
+      if (i > 0 && (command[i - 1] === '--ask' || command[i - 1] === '--say' || command[i - 1] === '--goal-file' || command[i - 1] === '--goal')) return [];
+      if (command[0] === 'harness' && i === 2 && (command[1] === 'ask' || command[1] === 'say')) return [arg];
+      if (command[0] === 'self' && command[1] === 'orchestrate' && i === 2) return [arg];
+      return [];
+    });
+    const goalMatch = goalPath !== null && goalArgs.some((arg) => {
+      if (isAbsolute(arg)) return isAbsolute(goalPath) && resolve(arg) === resolve(goalPath);
+      if (!isAbsolute(goalPath)) return false;
+      let cwd: string | null;
+      try { cwd = processCwd(pid); } catch { return false; }
+      return cwd !== null && isAbsolute(cwd) && resolve(cwd, arg) === resolve(goalPath);
+    });
+    if (runMatch || goalMatch) candidates.push({ pid, startedAt, via: runMatch ? 'argv-runId' : 'argv-goal' });
+  }
+  return { status: 'ok', candidates };
+}
+
+function stopProcessCwd(pid: number): string | null {
+  try {
+    if (process.platform === 'linux') return readlinkSync(`/proc/${pid}/cwd`);
+    const r = spawnSync('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', timeout: 5_000 });
+    if (r.error || r.status !== 0 || typeof r.stdout !== 'string') return null;
+    return r.stdout.split(/\r?\n/).find((line) => line.startsWith('n/'))?.slice(1) ?? null;
+  } catch { return null; }
+}
+
+function scanStopProcessTable(runId: string, goalPath: string | null): StopProcessScan {
+  let r: ReturnType<typeof spawnSync>;
+  try { r = spawnSync('ps', ['-eo', 'pid=,lstart=,args='], { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 }); }
+  catch (error) { return { status: 'failed', reason: String(error) }; }
+  if (r.error || r.status !== 0 || typeof r.stdout !== 'string') return { status: 'failed', reason: String(r.error ?? r.stderr ?? `ps status ${r.status}`) };
+  return discoverStopProcesses(runId, goalPath, r.stdout, stopProcessCwd);
+}
 
 export interface HarnessStopDeps {
   readPidRecord: (runId: string) => PidRecord | null;
+  readGoalPath: (runId: string) => string | null;
+  scanProcesses: (runId: string, goalPath: string | null) => StopProcessScan;
   /** 살아 있는 프로세스의 시작 시각(ms) · 없으면 null. */
   processStartMs: (pid: number) => number | null;
   kill: (pid: number, signal: NodeJS.Signals) => void;
@@ -34,8 +115,12 @@ export interface HarnessStopDeps {
 
 export interface HarnessStopResult {
   runId: string;
-  process: 'stopped' | 'killed' | 'absent' | 'owner-mismatch';
+  process: 'stopped' | 'killed' | 'absent' | 'owner-mismatch' | 'unmeasured' | 'dry-run';
   pid?: number;
+  candidates: StopProcessCandidate[];
+  scanned: boolean;
+  pidRecordFound: boolean;
+  dryRun: boolean;
   jobsDeleted: number;
   contexts: string[];
 }
@@ -69,6 +154,8 @@ export function defaultHarnessStopDeps(overrides: Partial<HarnessStopDeps> = {})
   };
   return {
     readPidRecord: (runId) => readPidRecordFrom(selfDevRunsDir(), runId),
+    readGoalPath: stopGoalPathFromLedger,
+    scanProcesses: scanStopProcessTable,
     processStartMs: psProcessStartMs,
     kill: (pid, signal) => { process.kill(pid, signal); },
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -83,49 +170,91 @@ export function defaultHarnessStopDeps(overrides: Partial<HarnessStopDeps> = {})
   };
 }
 
-export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, contexts?: readonly string[]): Promise<HarnessStopResult> {
+export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, contexts?: readonly string[], dryRun = false): Promise<HarnessStopResult> {
   if (!RUN_ID.test(runId)) throw new Error(`invalid run id: ${runId}`);
   // ── ⓐ 프로세스 ────────────────────────────────────────────
   let processState: HarnessStopResult['process'] = 'absent';
   const record = deps.readPidRecord(runId);
+  let scan: StopProcessScan;
+  let goalPath: string | null = null;
+  try { goalPath = deps.readGoalPath(runId); }
+  catch { /* 원장 판독 실패 — runId 단독 대조 */ }
+  try { scan = deps.scanProcesses(runId, goalPath); }
+  catch (error) { scan = { status: 'failed', reason: String(error) }; }
+  const candidates: StopProcessCandidate[] = [];
+  const seen = new Set<number>();
+  const add = (candidate: StopProcessCandidate) => {
+    if (!seen.has(candidate.pid)) { seen.add(candidate.pid); candidates.push(candidate); }
+  };
+  let recordMismatch = false;
   if (record) {
-    const actual = deps.processStartMs(record.pid);
-    if (actual === null) processState = 'absent';
-    else if (Math.abs(actual - record.startedAt) > START_TOLERANCE_MS) processState = 'owner-mismatch';
-    else {
-      try { deps.kill(record.pid, 'SIGTERM'); } catch { /* 방금 끝났다 */ }
+    const recordedStart = deps.processStartMs(record.pid);
+    if (recordedStart !== null && Math.abs(recordedStart - record.startedAt) <= START_TOLERANCE_MS) {
+      add({ pid: record.pid, startedAt: recordedStart, via: 'pid.json' });
+    } else if (recordedStart !== null) { processState = 'owner-mismatch'; recordMismatch = true; }
+  }
+  if (scan.status === 'ok') {
+    for (const candidate of scan.candidates) {
+      if (candidate.pid !== record?.pid || !recordMismatch) add(candidate);
+    }
+  }
+  debug.log('harness.stop', 'process-candidates', { runId, found: candidates.map(({ via, pid }) => ({ via, pid })), scanned: scan.status === 'ok' });
+  if (dryRun) processState = 'dry-run';
+  else {
+    const verified: StopProcessCandidate[] = [];
+    for (const candidate of candidates) {
+      if (candidate.via === 'pid.json') { verified.push(candidate); continue; }
+      const actual = deps.processStartMs(candidate.pid);
+      if (actual === null) continue;
+      if (Math.abs(actual - candidate.startedAt) > START_TOLERANCE_MS) { processState = 'owner-mismatch'; continue; }
+      verified.push(candidate);
+    }
+    for (const candidate of verified) {
+      try { deps.kill(candidate.pid, 'SIGTERM'); } catch { /* 방금 끝났다 */ }
+    }
+    for (const candidate of verified) {
       processState = 'stopped';
       const step = 250;
       for (let waited = 0; waited < deps.graceMs; waited += step) {
         await deps.sleep(step);
-        if (deps.processStartMs(record.pid) === null) break;
+        if (deps.processStartMs(candidate.pid) === null) break;
       }
-      const still = deps.processStartMs(record.pid);
-      if (still !== null && Math.abs(still - record.startedAt) <= START_TOLERANCE_MS) {
-        try { deps.kill(record.pid, 'SIGKILL'); processState = 'killed'; } catch { /* 끝났다 */ }
+      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 (processState === 'absent' && (scan.status === 'failed' || candidates.length > 0)) processState = 'unmeasured';
   }
   // ── ⓑ Pod Job (라벨로만) ───────────────────────────────────
-  const targets = contexts && contexts.length > 0 ? [...contexts] : deps.kubeContexts();
+  const targets = dryRun ? [] : contexts && contexts.length > 0 ? [...contexts] : deps.kubeContexts();
   let jobsDeleted = 0;
   for (const context of targets) {
     const r = deps.kubectl(['--context', context, '-n', deps.namespace, 'delete', 'job', '-l', `elanous.run=${runId}`, '--wait=false']);
     if (r.status === 0) jobsDeleted += r.stdout.split('\n').filter((line) => line.startsWith('job.batch/')).length;
     else debug.log('harness.stop', 'job-delete-failed', { runId, context, error: r.stderr.slice(0, 200) }, { level: 'warn' });
   }
-  const result: HarnessStopResult = { runId, process: processState, ...(record ? { pid: record.pid } : {}), jobsDeleted, contexts: targets };
+  const result: HarnessStopResult = { runId, process: processState, ...(record ? { pid: record.pid } : {}), candidates, scanned: scan.status === 'ok', pidRecordFound: record !== null, dryRun, jobsDeleted, contexts: targets };
   debug.log('harness.stop', 'stopped', { runId, process: processState, jobsDeleted, contexts: targets.length });
   return result;
 }
 
 export function formatHarnessStop(r: HarnessStopResult): string {
   const label: Record<HarnessStopResult['process'], string> = {
-    stopped: '멈춤(SIGTERM)', killed: '멈춤(SIGKILL — 제한 시간 안에 안 끝났다)', absent: '없음', 'owner-mismatch': '소유 불일치(건드리지 않음 — PID 가 다른 프로세스로 재사용됐다)',
+    stopped: '멈춤(SIGTERM)', killed: '멈춤(SIGKILL — 제한 시간 안에 안 끝났다)',
+    absent: `못 찾음(pid.json ${r.pidRecordFound ? '확인' : '없음'} · 프로세스 표에서 runId·골 경로 0)`,
+    unmeasured: '못 잼(프로세스 표 또는 후보 시작 시각 확인 실패 — 없음이 아님)',
+    'dry-run': 'dry-run(신호·Pod Job 삭제 없음)',
+    'owner-mismatch': '소유 불일치(건드리지 않음 — PID 가 다른 프로세스로 재사용됐다)',
   };
   return [
     `harness stop ${r.runId}`,
     `  프로세스: ${label[r.process]}${r.pid ? ` · pid ${r.pid}` : ''}`,
-    `  Pod Job: ${r.jobsDeleted}개 지움 (문맥 ${r.contexts.length}개 · 라벨 elanous.run=${r.runId})`,
+    ...(!r.scanned && r.process !== 'unmeasured' ? ['  프로세스 표: 못 잼(기록 밖 발사 프로세스는 확인하지 못함)'] : []),
+    ...r.candidates.map(({ pid, startedAt, via }) => `  후보: pid ${pid} · 시작 ${new Date(startedAt).toISOString()} · ${via}`),
+    r.dryRun
+      ? `  Pod Job: dry-run(조회·삭제하지 않음 · 라벨 elanous.run=${r.runId})`
+      : `  Pod Job: ${r.jobsDeleted}개 지움 (문맥 ${r.contexts.length}개 · 라벨 elanous.run=${r.runId})`,
   ].join('\n');
 }

package/src/harness/self-send-decide.ts

@@ -16,7 +16,7 @@ export interface SelfSendCandidateDisplay {
   readonly hiddenStaleCount: number;
 }
 
-const SELF_SEND_GOAL_ATTEMPT_SUFFIX = /^(.*)-[0-9a-f]{8}$/;
+const SELF_SEND_GOAL_ATTEMPT_SUFFIX = /^(.*)-[0-9a-f]{8}(?:-r[a-z0-9]{6})?$/;
 
 function selfSendGoalPrefix(spaceId: string): string | undefined {
   return SELF_SEND_GOAL_ATTEMPT_SUFFIX.exec(spaceId)?.[1];
@@ -104,6 +104,7 @@ export interface SelfSendDecisionInput {
 
 export interface SelfSendDecisionDeps {
   resolveRunScreen(runId: string): SelfSendRunScreen;
+  podFragmentsForRun(runId: string): readonly { spaceId: string }[];
   resolveTarget(space: string): SelfSendTargetResolution;
   isPodFragment(spaceId: string): boolean;
   screens(): readonly SelfSendCandidate[];
@@ -122,26 +123,34 @@ export function decideSelfSend(input: SelfSendDecisionInput, deps: SelfSendDecis
   if (space !== undefined && opts.run !== undefined) return refuse('--run 과 space 는 함께 사용할 수 없습니다.\n', 2);
   if (opts.run !== undefined && opts.run.trim() === '') return refuse('--run 에 빈 runId 를 줄 수 없습니다.\n', 2);
   let requestedSpace = space;
+  let podRunSpace: string | undefined;
   if (opts.run !== undefined) {
     const resolved = deps.resolveRunScreen(opts.run);
-    if (resolved.logStoreStatus !== 'read') {
+    if (resolved.logStoreStatus !== 'read' && resolved.screenKey) {
       return refuse(`run 화면 해석 불가: 로그 스토어 ${resolved.logStoreStatus} (${resolved.logStorePath})\n`, 1);
     }
     if (!resolved.screenKey) {
-      const last = resolved.lastEvent;
-      const lastDetail = last
-        ? ` 마지막 이벤트: ${last.category}/${last.event} (${Number.isFinite(Date.parse(last.timestamp)) ? `${Math.max(0, Math.floor((now - Date.parse(last.timestamp)) / 60_000))}분 전` : '시각 알 수 없음'})`
-        : ' 마지막 이벤트: 없음';
-      const status = resolved.missingStatus;
-      const guidance = status === 'awaiting-start'
-        ? '아직 화면을 띄우기 전입니다. 되묻기에 답하거나 저작이 끝날 때까지 기다리세요.'
-        : status === 'pipeline-failed' ? '파이프라인이 오류로 멈췄습니다. 해당 error를 읽어 원인을 수리하세요.'
-          : status === 'cleaned' ? '하니스가 정리되어 화면이 없습니다. 필요하면 새 런을 시작하세요.'
-            : status === 'not-found' ? '이 runId의 이벤트가 없습니다. runId와 인스턴스 우주를 확인하세요.'
-              : '화면을 아직 분류할 수 없습니다. 마지막 이벤트를 조사하세요.';
-      return refuse(`run 화면 해석 불가: ${guidance}${lastDetail} (${opts.run})\n`, 1);
-    }
-    requestedSpace = normalizeSpaceId(resolved.screenKey);
+      const fragments = deps.podFragmentsForRun(opts.run);
+      if (fragments.length === 1) requestedSpace = podRunSpace = fragments[0]!.spaceId;
+      else {
+        if (fragments.length > 1) return refuse(`run 의 Pod 조각이 여러 개입니다: ${opts.run}. space 이름으로 다시 보내세요:\n${fragments.map((fragment) => `  ${fragment.spaceId}`).join('\n')}\n`, 2);
+        if (resolved.logStoreStatus !== 'read') {
+          return refuse(`run 화면 해석 불가: 로그 스토어 ${resolved.logStoreStatus} (${resolved.logStorePath}) · Pod 조각 기록도 0\n`, 1);
+        }
+        const last = resolved.lastEvent;
+        const lastDetail = last
+          ? ` 마지막 이벤트: ${last.category}/${last.event} (${Number.isFinite(Date.parse(last.timestamp)) ? `${Math.max(0, Math.floor((now - Date.parse(last.timestamp)) / 60_000))}분 전` : '시각 알 수 없음'})`
+          : ' 마지막 이벤트: 없음';
+        const status = resolved.missingStatus;
+        const guidance = status === 'awaiting-start'
+          ? '아직 화면을 띄우기 전입니다. 되묻기에 답하거나 저작이 끝날 때까지 기다리세요.'
+          : status === 'pipeline-failed' ? '파이프라인이 오류로 멈췄습니다. 해당 error를 읽어 원인을 수리하세요.'
+            : status === 'cleaned' ? '하니스가 정리되어 화면이 없습니다. 필요하면 새 런을 시작하세요.'
+              : status === 'not-found' ? '이 runId의 이벤트가 없습니다. runId와 인스턴스 우주를 확인하세요.'
+                : '화면을 아직 분류할 수 없습니다. 마지막 이벤트를 조사하세요.';
+        return refuse(`run 화면 해석 불가: ${guidance}${lastDetail} (${opts.run}) · Pod 조각 기록도 0\n`, 1);
+      }
+    } else requestedSpace = normalizeSpaceId(resolved.screenKey);
   }
   const hasMemo = opts.memo !== undefined;
   if (opts.stop && hasMemo) return refuse('self send에서는 --stop 과 --memo를 함께 사용할 수 없습니다.\n', 2);
@@ -158,7 +167,7 @@ export function decideSelfSend(input: SelfSendDecisionInput, deps: SelfSendDecis
     }
     requestedSpace = resolution.spaceId;
   }
-  if (requestedSpace !== undefined && deps.isPodFragment(requestedSpace)) {
+  if (requestedSpace !== undefined && (podRunSpace !== undefined || deps.isPodFragment(requestedSpace))) {
     return { kind: 'send', spaceId: requestedSpace, channel: 'pod', warnings: [] };
   }
   const screens = deps.screens();

package/src/harness/self-send-target.ts

@@ -1,12 +1,15 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname } from 'node:path';
+import { normalizeRunId } from './harness-space.js';
 import { controlInboxPath, type ControlMemoPayload } from './control-inbox.js';
 import { sendPodControl } from './pod-control-send.js';
 import type { Kubectl } from '../task-orchestrator/surfaces/self-implement-pod.js';
 
 export interface PodFragmentRecord {
   spaceId: string;
+  runId?: string;
+  parentRunId?: string;
   context: string;
   namespace: string;
   job: string;
@@ -29,6 +32,24 @@ export function podFragmentFinished(spaceId: string, env?: NodeJS.ProcessEnv): b
   return existsSync(`${podRecordPath(spaceId, env)}.finished`);
 }
 
+export function listPodFragmentsForRun(runId: string, env?: NodeJS.ProcessEnv): PodFragmentRecord[] {
+  if (!runId || runId !== normalizeRunId(runId)) return [];
+  const dir = dirname(podRecordPath('fragment', env));
+  let names: string[];
+  try { names = readdirSync(dir); } catch { return []; }
+  const suffix = '.inbox.pod.json';
+  const matches: PodFragmentRecord[] = [];
+  for (const name of names) {
+    if (!name.endsWith(suffix)) continue;
+    const spaceId = name.slice(0, -suffix.length);
+    if (podFragmentFinished(spaceId, env)) continue;
+    const record = readPodFragment(spaceId, env);
+    if (record && ((record.runId === runId && normalizeRunId(record.runId) === runId)
+      || (record.parentRunId === runId && normalizeRunId(record.parentRunId) === runId))) matches.push(record);
+  }
+  return matches;
+}
+
 export function writePodFragment(record: PodFragmentRecord, env?: NodeJS.ProcessEnv): void {
   const path = podRecordPath(record.spaceId, env);
   mkdirSync(dirname(path), { recursive: true });

package/src/harness/worktree-branch-prefix.ts

@@ -22,11 +22,12 @@ export function slugifyFeature(feature: string): string {
 /** 하니스가 만드는 `self-impl/<슬러그>-<8자리 16진수>` 브랜치 이름.
  *  goalId 가 있으면 읽는 자(`branchGoalId`, `/(?:^|-)goalid-([^/-]+)-/`)와 호환되는
  *  `goalid-<id>-` 구간을 슬러그 앞에 싣는다. 없으면 기존과 바이트 단위로 같다. */
-export function plannedSelfImplBranch(feature: string, goalId?: string): string {
+export function plannedSelfImplBranch(feature: string, goalId?: string, runId?: string): string {
   const slug = slugifyFeature(feature);
   const id = goalId?.trim() ?? '';
-  if (!id) return `${WORKTREE_BRANCH_PREFIX}${slug}`;
+  const runSuffix = runId === undefined ? '' : `-r${runId.replace(/^run-/i, '').replace(/[^a-z0-9]/gi, '').slice(0, 6).toLowerCase()}`;
+  if (!id) return `${WORKTREE_BRANCH_PREFIX}${slug}${runSuffix}`;
   const readable = slug.replace(/-[0-9a-f]{8}$/, '');
   const digest = createHash('sha256').update(id).digest('hex').slice(0, 8);
-  return `${WORKTREE_BRANCH_PREFIX}goalid-${id}-${readable}-${digest}`;
+  return `${WORKTREE_BRANCH_PREFIX}goalid-${id}-${readable}-${digest}${runSuffix}`;
 }

package/src/index.ts

@@ -115,7 +115,7 @@ import { DEFAULT_REVIEW_BACKEND } from './agent-substrate/acp-reviewer.js';
 import type { ReviewResult } from './agent-substrate/pr-reviewer.js';
 import type { ReviewVerdict } from './agent-mission/review-loop.js';
 import type { SyncMode } from './types.js';
-import { runOnboarding, runOnboardingStep, runOnboardingNonInteractive, needsOnboarding, type OnboardingStepId } from './onboarding.js';
+import { runOnboarding, runOnboardingStep, runOnboardingNonInteractive, needsOnboarding, handleOnboardingRefusal, type OnboardingStepId } from './onboarding.js';
 import {
   getUserConfig, reloadUserConfig, userConfigPath, saveUserConfig,
   backupUserConfig, backupConfigPath, addRotationEntry, type RotationEntry,
@@ -2088,13 +2088,14 @@ harnessCmd
   });
 harnessCmd
   .command('stop <runId>')
-  .description('런 하나를 멈춘다 — 오케스트레이터 프로세스(pid.json 의 시작 시각이 맞을 때만) ⊕ 라벨 elanous.run=<runId> Pod Job')
+  .description('런 하나를 멈춘다 — pid.json 시작 시각 대조 ⊕ 런 발사 프로세스 표 조회 ⊕ 라벨 elanous.run=<runId> Pod Job')
   .option('--context <ctx...>', 'kube 문맥(여러 번 · 기본 = 알려진 문맥 전부)')
   .option('--json', 'JSON 출력')
-  .action(async (runId: string, opts: { context?: string[]; json?: boolean }) => {
+  .option('--dry-run', '프로세스 후보만 보고 신호·Pod Job 삭제는 하지 않는다')
+  .action(async (runId: string, opts: { context?: string[]; json?: boolean; dryRun?: boolean }) => {
     const { stopHarnessRun, defaultHarnessStopDeps, formatHarnessStop } = await import('./harness/harness-stop.js');
     try {
-      const result = await stopHarnessRun(runId, defaultHarnessStopDeps(), opts.context);
+      const result = await stopHarnessRun(runId, defaultHarnessStopDeps(), opts.context, opts.dryRun === true);
       process.stdout.write(`${opts.json ? JSON.stringify(result) : formatHarnessStop(result)}\n`);
     } catch (error) {
       process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
@@ -4238,8 +4239,9 @@ const selfOrchestrateCmd = selfCmd
             if (!opts.json) ui.info(`[pod] 이미지 다시 굽기 — ${image.reason} (~1분)`);
             const { spawnSync } = await import('node:child_process');
             const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).stdout.trim() || process.cwd();
-            const b = spawnSync('bash', [`${top}/docker/harness/build.sh`], { encoding: 'utf8', timeout: 900_000 });
-            if (b.status !== 0) { ui.error(`--substrate pod: 이미지 굽기 실패 rc=${b.status}: ${(b.stdout + b.stderr).slice(-400)}`); process.exit(2); }
+            // bun 1.4 applies the 1 MiB default maxBuffer: a docker build log past it kills the child (ENOBUFS · status null).
+            const b = spawnSync('bash', [`${top}/docker/harness/build.sh`], { encoding: 'utf8', timeout: 900_000, maxBuffer: 64 * 1024 * 1024 });
+            if (b.status !== 0) { ui.error(`--substrate pod: 이미지 굽기 실패 rc=${b.status}${b.error ? ` (${(b.error as NodeJS.ErrnoException).code ?? b.error.message})` : ''}: ${(b.stdout + b.stderr).slice(-400)}`); process.exit(2); }
             image = podImageFreshness();
           }
         }
@@ -4410,7 +4412,7 @@ const selfOrchestrateCmd = selfCmd
         ...results.map((r) => {
           const icon = r.status === 'done' ? '✅' : r.status === 'cancelled' ? '⛔' : '❌';
           const disp = r.merged ? ` → merged ${r.prUrl}` : r.prUrl ? ` → PR ${r.prUrl}` : r.stage ? ` [${r.stage}]` : '';
-          return `  ${icon} ${r.status} · ${r.feature.slice(0, 56)}${disp}${r.error ? ` — ${r.error.code}` : ''}`;
+          return `  ${icon} ${r.status} · ${r.feature.slice(0, 56)}${disp}${r.error ? ` — ${r.error.code}${r.error.code === 'pod-job-failed' ? `: ${r.error.message}` : ''}` : ''}`;
         }),
       ].join('\n'));
       await reportRun(results);
@@ -4608,7 +4610,7 @@ selfCmd
   .action(async (space: string | undefined, opts: { stop?: boolean; memo?: string; run?: string; includeStale?: boolean; readWait?: string }) => {
     const { classifyRunScreenMissing, queryRunScreenKey, listRunLedgers } = await import('./self-implement/run-ledger.js');
     const { getPtyManifest, listPtyManifestRows } = await import('./pty-shell/pty-manifest.js');
-    const { readPodFragment, podFragmentFinished, dispatchPodSelfSend } = await import('./harness/self-send-target.js');
+    const { readPodFragment, podFragmentFinished, listPodFragmentsForRun, dispatchPodSelfSend } = await import('./harness/self-send-target.js');
     const { listHarnessScreens, readHarnessHeartbeat } = await import('./harness/harness-screen.js');
     const decision = decideSelfSend({ space, opts, now: Date.now() }, {
       resolveRunScreen: (runId) => {
@@ -4616,6 +4618,7 @@ selfCmd
         return { ...resolved, missingStatus: resolved.screenKey ? undefined : classifyRunScreenMissing(resolved.lastEvent) };
       },
       resolveTarget: (target) => resolveSelfSendTarget(target, { getPtyManifest, listPtyManifestRows }),
+      podFragmentsForRun: (runId) => listPodFragmentsForRun(runId),
       isPodFragment: (spaceId) => Boolean(readPodFragment(spaceId) || podFragmentFinished(spaceId)),
       screens: () => listHarnessScreens().map((screen): SelfSendCandidate => {
         const heartbeat = readHarnessHeartbeat(screen.spaceId);
@@ -5426,6 +5429,30 @@ program.command('ad [input...]')
   });
 
 registerDocsCommands(program);
+// Private local decision ledger follows the same JS-only dispatch path as directives.
+if (existsSync(resolve(import.meta.dir, 'cli/decisions-cli.ts')) || existsSync(resolve(import.meta.dir, 'cli/decisions-cli.js'))) {
+  program.command('decisions').description('대표 결정 로컬 원장').allowUnknownOption().allowExcessArguments(true)
+    .action(async (_opts: unknown, command: Command) => {
+      try { await (await import('./domains/standalone-log-sink.js')).registerStandaloneLogSink('decisions'); }
+      catch { /* Logging must not prevent recording a decision. */ }
+      const privateDecisionsModule: string = './cli/decisions-cli.js';
+      const { registerDecisionsCommands } = await import(privateDecisionsModule) as { registerDecisionsCommands: (program: Command) => void };
+      const privateProgram = new Command();
+      registerDecisionsCommands(privateProgram);
+      await privateProgram.parseAsync(['decisions', ...command.args], { from: 'user' });
+    });
+}
+// Private command is absent from the public export; JS-only distributions still register it.
+if (existsSync(resolve(import.meta.dir, 'cli/directives-cli.ts')) || existsSync(resolve(import.meta.dir, 'cli/directives-cli.js'))) {
+  program.command('directives').description('대표 지시 로컬 색인·검색').allowUnknownOption().allowExcessArguments(true)
+    .action(async (_opts: unknown, command: Command) => {
+      const privateDirectivesModule: string = './cli/directives-cli.js';
+      const { registerDirectivesCommands } = await import(privateDirectivesModule) as { registerDirectivesCommands: (program: Command) => void };
+      const privateProgram = new Command();
+      registerDirectivesCommands(privateProgram);
+      await privateProgram.parseAsync(['directives', ...command.args], { from: 'user' });
+    });
+}
 registerFleetCommands(program);
 
 // ── ops (운영 관측 — 지금 뭐 도나·이상 없나·상태 전이) ──
@@ -5592,6 +5619,7 @@ agentCmd
   .option('--backend <id>', `외부 에이전트 backend (${agentBackendHelpList}). 각 CLI auto-approve 모드로 PTY 구동. 미등록 지정 시 명시 에러(조용한 codex 폴백 없음·애그노스틱)`)
   .option('--chain <backends>', '한 미션의 backend 사슬 (예: codex,claude,elanous)')
   .option('--plugin <name@market>', '에이전트 화면 안에서 플러그인을 설치하고 그 스킬로 미션 실행 (codex/claude)')
+  .addOption(new Option('--resources <mode>', '미션 전 자원 판단 사다리 (on|off, 기본 on)').choices(['on', 'off']).default('on'))
   .option('--headless', 'Claude 구독 CLI를 비대화형 stream-json 모드로 실행 (claude backend 전용)')
   .action(async (textParts: string[], opts: Record<string, any>) => {
     // 구독 모드 보장 — 브레인(streamLLM)·codex 둘 다 ChatGPT 구독으로 (API 과금 회피).
@@ -7815,6 +7843,16 @@ sessionCmd
     console.log(res.formatted ?? '(no context)');
   });
 
+async function runOnboardingForCli(): Promise<boolean> {
+  try {
+    await runOnboarding();
+    return true;
+  } catch (error) {
+    if (handleOnboardingRefusal(error, 'other')) return false;
+    throw error;
+  }
+}
+
 function announceChatToolsCompatibility(): void {
   process.stderr.write('`chat --tools` is a compatibility entrypoint; use `elanous agent` for tool-loop calls.\n');
   debug.log('chat.tools-compatibility', 'invoked', { toolLoopEnabled: true });
@@ -7841,7 +7879,7 @@ program
     const cfg = getUserConfig();
     if (needsOnboarding(cfg)) {
       ui.info('No config yet — launching setup wizard first.');
-      await runOnboarding();
+      if (!await runOnboardingForCli()) return;
     }
     const refreshed = reloadUserConfig();
     // ★ 관측갭 수리(2026-07-21·제1원칙·트랙A) — self-implement 자식 goal-loop(`chat --goal-loop`)은 데몬과
@@ -7885,7 +7923,7 @@ program
   .option('--new', 'Force a new session at boot instead of resuming the active one')
   .option('--session <id>', 'Resume an explicit session (id or unique prefix)')
   .option('--scenario <path>', 'Run a YAML multi-turn scenario before handing back to interactive (or exit)')
-  .option('--replay <session-id>', 'Re-execute the user prompts from a previous session in a fresh REPL run (BACKLOG #5). User prompts are extracted in order and fed through the same dispatcher as --scenario; assistant/tool messages and attachments are dropped. Mutually exclusive with --scenario.')
+  .option('--replay <session-id>', 'Re-execute the user prompts from a previous session in a fresh REPL run. User prompts are extracted in order and fed through the same dispatcher as --scenario; assistant/tool messages and attachments are dropped. Mutually exclusive with --scenario.')
   .option('--exit-after-scenario', 'Exit after the scenario / replay completes (default true when stdin is not a TTY)')
   .option('--no-exit-after-scenario', 'Stay in the interactive prompt after the scenario / replay completes (TTY default)')
   .option('--json', 'Emit one JSON line per turn (sessionId/provider/model/reply/...) instead of streaming text')
@@ -7908,7 +7946,7 @@ program
     const cfg = getUserConfig();
     if (needsOnboarding(cfg)) {
       ui.info('No config yet — launching setup wizard first.');
-      await runOnboarding();
+      if (!await runOnboardingForCli()) return;
     }
     const refreshed = reloadUserConfig();
     const { runRepl } = await import('./repl/index.js');
@@ -8471,7 +8509,7 @@ program
     'ACP client for the running elanous daemon. Three modes: handshake-only (default), one-shot (--message), interactive REPL (--interactive). Local (unix socket) or remote (--host / --url) over Tailscale.',
   )
   .option('--socket <path>', 'Override the unix socket path (default: ~/.elanous/elanous.sock)')
-  .option('--host <hostport>', 'Remote daemon host:port (e.g. mbp.tailnet:31415). Coerced to ws://<hostport>/v1/acp.')
+  .option('--host <hostport>', 'Remote daemon host:port (e.g. laptop.tailnet:31415). Coerced to ws://<hostport>/v1/acp.')
   .option('--url <wsurl>', 'Remote daemon WS URL (e.g. ws://host:31415/v1/acp). Overrides --host.')
   .option('-r, --remote [name]', 'Bookmark name (`-r` alone = default). Fills host/token-file; explicit --url/--host/--token/--token-file win.')
   .option('--token <token>', 'Bearer token for remote auth. Overrides --token-file and ELANOUS_TOKEN.')
@@ -8945,6 +8983,7 @@ const nexusRunCmd = nexusCmd
   .option('--watch', 'Static-mode: fs.watch loop inside daemon — source edits auto-rebuild apps/pwa. Default on for `nexus run` (no args), off for `--test`.')
   .option('--no-watch', 'Disable the static-mode fs.watch loop (canonical entry default-on).')
   .option('--no-mcp', 'Skip the entire MCP-client boot wire (every `mcp.servers[]` in user-config). Use when a misbehaving server (e.g. xcrun mcpbridge tools/list hang) drags every startup through its 8s timeout.')
+  .option('--no-auth', 'Explicitly disable Nexus HTTP and ACP websocket bearer authentication (unsafe).')
   .option('--dispatch', '§5-③ — enable the autonomous idle-continuation scheduler for this run (drives an active auto-mode goal on idle). Same as user-config `dispatch.enabled`. Default off — ignites self-firing turns, so opt-in.')
   .option('--force', 'Take the lock even if another nexus instance is recorded as running.')
   .option('--status', 'Alias for `elanous nexus status` (or test-mode status when combined with --test).')
@@ -8980,6 +9019,7 @@ const nexusRunCmd = nexusCmd
     autoRestart?: boolean;
     watch?: boolean;
     mcp?: boolean;
+    auth?: boolean;
     fresh?: boolean;
     force?: boolean;
     dispatch?: boolean;
@@ -9129,6 +9169,7 @@ const nexusRunCmd = nexusCmd
           preflightStaleServe: true,
           verifyListen: true,
           ...(opts.mcp === false ? { mcpEnabled: false } : {}),
+          ...(opts.auth === false ? { noAuth: true } : {}),
           ...(opts.https ? { https: true } : {}),
           ...(resolvedPort !== undefined ? { httpPort: resolvedPort } : {}),
           ...(opts.force ? { force: true } : {}),
@@ -9156,6 +9197,7 @@ const nexusRunCmd = nexusCmd
         // it — service-manager production posture stays watch-off.
         ...((bgChild ? opts.watch === true : watchOn) ? { pwaWatch: true } : {}),
         ...(opts.mcp === false ? { mcpEnabled: false } : {}),
+        ...(opts.auth === false ? { noAuth: true } : {}),
         ...(opts.force ? { force: true } : {}),
         ...(opts.dispatch ? { dispatch: true } : {}),
         ...(opts.toolCwd ? { toolCwd: opts.toolCwd } : {}),
@@ -9187,6 +9229,7 @@ const nexusRunCmd = nexusCmd
       ...(opts.rebuild ? { rebuild: true } : {}),
       ...(watchOnTty ? { watch: true } : {}),
       ...(opts.mcp === false ? { mcpEnabled: false } : {}),
+      ...(opts.auth === false ? { noAuth: true } : {}),
     });
     process.exit(result.exitCode);
   });
@@ -10560,7 +10603,7 @@ async function main(): Promise<void> {
   // gates on config completeness — no entry-mode branch.)
   const cfg = getUserConfig();
   if (needsOnboarding(cfg)) {
-    await runOnboarding();
+    if (!await runOnboardingForCli()) return;
   }
 
   // Active-provider banner so users know WHICH model/auth is about to

package/src/instance/resolve.ts

@@ -32,6 +32,12 @@ export function prodInstanceRoot(): string {
   return normRoot(join(homedir(), '.elanous'));
 }
 
+/** Release records are machine-wide except in an explicitly selected config universe. */
+export function releaseLedgerRoot(): string {
+  const { getElanousConfigDirOverride } = require('../elanous-config-dir.js') as typeof import('../elanous-config-dir.js');
+  return getElanousConfigDirOverride() ? effectiveInstanceRoot() : prodInstanceRoot();
+}
+
 export function resolveInstance(deps: ResolveDeps = {}): InstanceResolution {
   const prodRoot = normRoot(deps.prodRoot ?? prodInstanceRoot());
   if (deps.explicitFlagRoot?.trim()) {

package/src/intake-plane/collect-telegram-saved.ts

@@ -27,6 +27,11 @@ export function readSavedCursor(root: string): number {
   try { return Number(JSON.parse(readFileSync(cursorFile(root), 'utf8')).lastId) || 0; } catch { return 0; }
 }
 
+/** When the cursor last moved (= a run last found a new saved message). Undefined before the first message. */
+export function readSavedCursorAt(root: string): string | undefined {
+  try { const at = JSON.parse(readFileSync(cursorFile(root), 'utf8')).at; return typeof at === 'string' ? at : undefined; } catch { return undefined; }
+}
+
 function writeSavedCursor(root: string, lastId: number): void {
   mkdirSync(intakeLedgerDir(root), { recursive: true });
   writeFileSync(cursorFile(root), JSON.stringify({ lastId, at: new Date().toISOString() }) + '\n');