elanous 0.2.4 → 0.2.6

package/src/grounding/token.ts

@@ -3,7 +3,7 @@
  *  Pod 는 호스트 우주를 «직접» 읽지 않는다(4우주·최소 자격). 대신 호스트 `POST /v1/grounding/query` 에
  *  «질의 → 인용»만 묻는다. 그 문을 여는 것이 이 토큰이다.
  *  - 모양: `base64url(payload).base64url(HMAC-SHA256)` · payload = `{v:1, runId, job, scope, exp}`.
- *    scope 는 `'grounding'` 또는 `'llm-credential'` — 같은 서명·검증·회수. 문은 scope 를 엄격히 가른다.
+ *    scope 는 `'grounding'` · `'llm-credential'` · `'gh-credential'` — 같은 서명·검증·회수. 문은 scope 를 엄격히 가른다.
  *  - 상태 없는 검증 — 엔드포인트는 `verifyGroundingToken` 하나만 부른다.
  *  - 키: 비밀 백엔드 `grounding/hmac`(없으면 처음 발급 때 무작위 32바이트로 만든다) — 호스트 밖으로 안 나간다.
  *  - 수명: `exp`(Job 기한) ⊕ 조기 회수 `revokeGroundingRun(runId)`(Job 이 끝나면 호스트가 부른다).
@@ -19,13 +19,15 @@ export const GROUNDING_TOKEN_ENV = 'ELANOUS_GROUNDING_TOKEN';
 export const GROUNDING_URL_ENV = 'ELANOUS_GROUNDING_URL';
 export const GROUNDING_HMAC_SECRET_ID = 'grounding/hmac';
 
-export const GROUNDING_TOKEN_SCOPES = ['grounding', 'llm-credential'] as const;
+export const GROUNDING_TOKEN_SCOPES = ['grounding', 'llm-credential', 'gh-credential'] as const;
 export type GroundingTokenScope = (typeof GROUNDING_TOKEN_SCOPES)[number];
 
 export interface GroundingClaims {
   readonly runId: string;
   readonly job: string;
   readonly scope: GroundingTokenScope;
+  /** GitHub credential relay only: full owner/repository bound by the host at issuance. */
+  readonly repository?: string;
   readonly exp: number;
 }
 
@@ -59,19 +61,22 @@ function sign(payload: string, key: string): string {
 }
 
 export async function mintGroundingToken(
-  claims: { runId: string; job: string; ttlMs: number; scope?: GroundingTokenScope },
+  claims: { runId: string; job: string; ttlMs: number; scope?: GroundingTokenScope; repository?: string },
   deps: GroundingTokenDeps = {},
 ): Promise<{ token: string; exp: number }> {
   const key = await (deps.key ?? (() => readKey(true)))();
   if (!key) throw new Error('grounding: 서명 키를 만들 수 없다(비밀 백엔드)');
   const scope: GroundingTokenScope = claims.scope ?? 'grounding';
+  if (claims.repository !== undefined && (scope !== 'gh-credential' || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(claims.repository) || claims.repository.split('/').some((part) => part === '.' || part === '..'))) {
+    throw new Error('grounding: invalid credential repository');
+  }
   const exp = (deps.now ?? Date.now)() + claims.ttlMs;
-  const payload = Buffer.from(JSON.stringify({ v: 1, runId: claims.runId, job: claims.job, scope, exp })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({ v: 1, runId: claims.runId, job: claims.job, scope, ...(scope === 'gh-credential' ? { repository: claims.repository } : {}), exp })).toString('base64url');
   debug.log('grounding.token', 'minted', { runId: claims.runId, job: claims.job, scope, exp });
   return { token: `${payload}.${sign(payload, key)}`, exp };
 }
 
-/** 그라운딩 문은 scope `'grounding'` 만 받는다. `llm-credential` 은 `expectedScope` 로 따로 연다. */
+/** 그라운딩 문은 scope `'grounding'` 만 받는다. 자격 증명 scope 는 `expectedScope` 로 따로 연다. */
 export async function verifyGroundingToken(
   token: string,
   deps: GroundingTokenDeps & { readonly expectedScope?: GroundingTokenScope } = {},
@@ -92,9 +97,10 @@ export async function verifyGroundingToken(
   if (claims.v !== 1 || typeof claims.runId !== 'string' || typeof claims.job !== 'string' || typeof claims.exp !== 'number') return reject('malformed');
   const expected: GroundingTokenScope = deps.expectedScope ?? 'grounding';
   if (claims.scope !== expected) return reject('scope', claims.runId);
+  if (expected === 'gh-credential' && claims.repository !== undefined && (typeof claims.repository !== 'string' || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(claims.repository) || claims.repository.split('/').some((part) => part === '.' || part === '..'))) return reject('malformed', claims.runId);
   if ((deps.now ?? Date.now)() >= claims.exp) return reject('expired', claims.runId);
   if (isRevoked(claims.runId, deps)) return reject('revoked', claims.runId);
-  return { ok: true, runId: claims.runId, job: claims.job, scope: expected, exp: claims.exp };
+  return { ok: true, runId: claims.runId, job: claims.job, scope: expected, ...(expected === 'gh-credential' && claims.repository !== undefined ? { repository: claims.repository } : {}), exp: claims.exp };
 }
 
 /** Job 이 끝나면 호스트가 부른다 — 그 런의 토큰은 기한 전이라도 더는 안 통한다. */

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

@@ -1,9 +1,10 @@
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Command, Option } from 'commander';
 import { runGitCommand } from '../git-fs/runner.js';
-import { GOAL_TYPES, parseGoalType, type GoalType } from '../self-implement/goal-author.js';
+import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { listRunLedgers, loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerMatch } from '../self-implement/run-ledger.js';
 import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
@@ -12,6 +13,7 @@ import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
 import { runDraftSweep, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr } from '../self-dev/draft-sweep.js';
 import { debug } from '../debug/log.js';
+import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
@@ -198,13 +200,16 @@ function printHarnessAskMarkerDryRun(goalPath?: string): void {
     const warnings = inspectHarnessAskMarkerWarnings(ask);
     if (warnings.length === 0) {
       console.log('[dry-run] ✅ ask 마커 — 경고 없음');
-      return;
+    } else {
+      for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
     }
-    for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
   } catch (error) {
     const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
     console.log(`[dry-run] ⚠️ ask 마커 — 검사 실패: ${message}`);
   }
+  for (const finding of lintGoalFile(ask, 'main').filter(({ tag }) => tag === 'release-note')) {
+    console.log(`[dry-run] ⚠️ 릴리스 노트 — ${finding.message}`);
+  }
 }
 
 function printHarnessLaunchDryRun(preview: {
@@ -218,7 +223,9 @@ function printHarnessLaunchDryRun(preview: {
   console.log(`[dry-run] 입력: ${preview.input}`);
   console.log(`[dry-run] 입구: ${preview.entrance}`);
   console.log(`[dry-run] 시작 예정: ${preview.wouldStart}`);
-  console.log('[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
+  console.log(preview.goalPath
+    ? '[dry-run] 전제 검사: ask 마커·릴리스 노트 린트만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음'
+    : '[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
   printHarnessAskMarkerDryRun(preview.goalPath);
   if (preview.goalPath) console.log(renderGoalTemplateDryRun(preview.goalPath, preview.goalType));
   if (preview.target !== undefined) {
@@ -315,7 +322,8 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
   return resolved;
 }
 /** ⭐ 런 계약의 실행 칸 = pod — 호스트는 그래프를 안 돌리고 Pod 로 보낸다(harness-pod-dispatch.ts). */
-async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-say', input: string, pool: string): Promise<void> {
+async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-say', input: string, pool: string,
+  recordDispatch: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask> = dispatchTask): Promise<void> {
   const o = opts as HarnessSubstrateOpts;
   if (o.target !== undefined) {
     debug.log('harness.pod', 'target-refused', { target: o.target });
@@ -324,10 +332,59 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
     process.exitCode = 2;
     return;
   }
+  let dispatchRecorded = false;
+  try {
+    const goalText = entrance === 'cli-harness-ask' ? readFileSync(input, 'utf8') : input;
+    await recordDispatch({
+      goalId: (entrance === 'cli-harness-ask' ? parseGoalId(goalText) : null)
+        ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: entrance === 'cli-harness-ask' ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec: { input: entrance === 'cli-harness-ask' ? { file: input } : { text: input }, humanReadableOutput: false },
+    });
+    dispatchRecorded = true;
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
   const { dispatchHarnessOnPod } = await import('./harness-pod-dispatch.js');
-  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) });
+  let output = '';
+  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) },
+    entrance === 'cli-harness-ask' ? { onOutput: (text) => { output = (output + text).slice(-16_000); } } : {});
   if (status !== 0) {
-    console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
+    let childError: string | undefined;
+    let podFailure: string | undefined;
+    let podJobFailed = false;
+    if (entrance === 'cli-harness-ask') {
+      for (const line of output.split('\n').reverse()) {
+        if (!line.trimStart().startsWith('[{') || !line.includes('"error"')) continue;
+        try {
+          const results: unknown = JSON.parse(line);
+          if (!Array.isArray(results)) continue;
+          for (const result of results) {
+            if (!result || typeof result !== 'object') continue;
+            const error = (result as { error?: { code?: string; message?: string } }).error;
+            if (typeof error?.code !== 'string' || typeof error.message !== 'string' || !error.code.startsWith('pod-')) continue;
+            if (error.code === 'pod-job-failed') {
+              podJobFailed = true;
+              childError = error.message.split('childError=')[1]?.split('\n', 1)[0];
+            }
+            podFailure = error.message;
+            break;
+          }
+        } catch { /* Non-result stdout cannot establish that a Pod child ran. */ }
+        if (podFailure) break;
+      }
+      if (!podFailure) {
+        const summary = output.split('\n').find((line) => /\s❌\sfailed · .* — pod-[\w-]+: /.test(line));
+        podFailure = summary?.split(/\s❌\sfailed · .* — pod-[\w-]+: /)[1];
+        podJobFailed = summary?.includes(' — pod-job-failed: ') ?? false;
+        if (podJobFailed) childError = podFailure?.split('childError=')[1]?.split('\n', 1)[0];
+      }
+    }
+    if (podJobFailed && childError && childError !== 'no-result-line') console.error(`Pod 안 자식이 실패했다 — ${childError}`);
+    else if (podFailure) console.error(`Pod 실행이 실패했다 — ${podFailure.split('\n', 1)[0]}`);
+    else console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
     process.exitCode = status;
   }
 }
@@ -1502,6 +1559,8 @@ export interface HarnessCliCommandDeps {
   draftSweep?: HarnessDraftSweepDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
+  /** Observe-only Pod host dispatch seam. */
+  podDispatchTask?: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask>;
   plan?: HarnessPlanHandler;
   /** ⭐ `plan` 주입이 «없을 때» 가는 기본 분기. 시험이 이 자리로 «CLI 의 기본 배선»을 문다
    *  (⛔ 주입된 `plan` 이 파일을 스스로 만들면 그 시험은 배선을 «못 답한다» — 무인 리뷰 GOODHART 지적). */
@@ -1540,7 +1599,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               process.exitCode = 2;
               return Promise.resolve();
             }
-            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-ask', goalPath, resolved.pool!) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-ask', goalPath, resolved.pool!, deps.podDispatchTask) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
           },
         );
       });
@@ -1564,7 +1623,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               process.exitCode = 2;
               return Promise.resolve();
             }
-            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-say', sentence.join(' '), resolved.pool!) : say(sentence, normalizeHarnessAskSayOptions(opts));
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask) : say(sentence, normalizeHarnessAskSayOptions(opts));
           },
         );
       });

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

@@ -19,6 +19,8 @@ export interface HarnessPodDispatchInput {
   /** say 의 문장, 또는 ask 의 골 문서 경로. */
   readonly input: string;
   readonly podPool?: string;
+  /** Host already recorded the observe-only dispatch; suppress a second decision in the Pod. */
+  readonly dispatchRecorded?: boolean;
   /** Pod 메모리 등급(standard|high) — 오케스트레이터 환경 `ELANOUS_POD_MEMORY_TIER` 로 Job 까지 간다. */
   readonly podMemory?: string;
   readonly autoMerge?: boolean;
@@ -49,7 +51,7 @@ export function podOrchestrateArgs(input: HarnessPodDispatchInput, goal: string)
   ];
 }
 
-type PodDispatchDeps = { run?: (cmd: string, args: readonly string[], env: NodeJS.ProcessEnv) => number | null; readFile?: (path: string) => string; cwd?: string; spawnChild?: typeof spawn };
+type PodDispatchDeps = { run?: (cmd: string, args: readonly string[], env: NodeJS.ProcessEnv) => number | null; readFile?: (path: string) => string; cwd?: string; spawnChild?: typeof spawn; onOutput?: (text: string) => void };
 
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps & { run: NonNullable<PodDispatchDeps['run']> }): number;
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps?: PodDispatchDeps): number | Promise<number>;
@@ -68,6 +70,8 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
   const args = podOrchestrateArgs(input, goal);
   const env = { ...process.env };
   delete env.ELANOUS_POD_GOAL_DOC;
+  delete env.ELANOUS_DISPATCH_RECORDED;
+  if (input.dispatchRecorded) env.ELANOUS_DISPATCH_RECORDED = '1';
   if (input.podMemory) env.ELANOUS_POD_MEMORY_TIER = input.podMemory;
   if (input.entrance === 'cli-harness-ask') {
     const root = findGitDir(cwd)?.root;
@@ -84,7 +88,9 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     goalChars: goal.length, ...(input.entrance === 'cli-harness-ask' ? { goalPath: input.input } : {}),
   });
   const run = deps.run ?? ((cmd: string, a: readonly string[], childEnv: NodeJS.ProcessEnv) => new Promise<number>((resolveStatus) => {
-    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: 'inherit', env: childEnv });
+    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: deps.onOutput ? ['inherit', 'pipe', 'inherit'] : 'inherit', env: childEnv });
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => { process.stdout.write(chunk); deps.onOutput?.(chunk); });
     let forwarded: NodeJS.Signals | undefined;
     const forward = (signal: NodeJS.Signals) => {
       forwarded = signal;

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