elanous 0.2.19 → 0.2.21

package/src/task-agent/live-moves.ts

@@ -8,8 +8,11 @@
  * - 관측: 실행한 수마다 `debug.log('task-agent', 'live-move', {kind, card, ok, detail, live:true})`.
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { resolve } from 'node:path';
+import { statSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { findGitDir } from '../git-fs/locate.js';
+import { getUserConfig } from '../user-config.js';
 import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 
@@ -53,22 +56,98 @@ export async function configuredTaskAgentLiveMoves(): Promise<ReadonlySet<TaskAg
 export interface LiveMoveDeps {
   statePath?: string;
   now?: () => Date;
-  /** PR 머리 sha·상태 — 시험은 주입한다. 기본은 `gh pr view`(작업 트리 cwd). */
-  prHead?: (pr: number, cwd?: string) => Promise<{ head: string; state: string } | null>;
+  /** PR 머리 sha·상태(·브랜치·URL) — 시험은 주입한다. 기본은 `gh pr view`(작업 트리 cwd). */
+  prHead?: (pr: number, cwd?: string) => Promise<PrHeadView | null>;
+  /** TA-LIVE-REVIEW-POD — 작업 트리가 없는 런(Pod)의 리뷰 저장소 후보. 기본은 카드 project.target → harness.defaultRepo → 호스트 checkout. */
+  repoCandidates?: (card: TaskCard) => readonly ReviewRepoCandidate[];
   /** 리뷰 요청(떼어 띄운다) — 시험은 반드시 주입한다. */
   requestReview?: (pr: number, intent: string, cwd?: string) => Promise<void>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
 }
 
 /** `executed` = 부작용을 실제로 냈다(리뷰를 띄웠다 · 제안을 적었다). ok 이지만 이미 한 수(같은 머리·이미 제안)면 false. */
-export interface LiveMoveResult { kind: TaskAgentLiveMove; card: string | null; ok: boolean; executed: boolean; detail: string }
+export interface LiveMoveResult {
+  kind: TaskAgentLiveMove; card: string | null; ok: boolean; executed: boolean; detail: string;
+  /** TA-LIVE-REVIEW-POD — 작업 트리 없이 리뷰 저장소를 찾았을 때(또는 못 찾았을 때)의 근거 한 줄. */
+  reviewRepo?: { resolved: boolean; source?: ReviewRepoCandidate['source']; cwd?: string; proof?: 'head-sha' | 'branch'; reason: string };
+}
+
+export interface PrHeadView { head: string; state: string; branch?: string; url?: string }
+
+/** 리뷰 저장소 후보 — 과제를 넘길 때 카드가 안 대상 · 하니스 기본 저장소(harness.defaultRepo · harness.repo 의 로컬 뿌리) · 호스트 checkout. */
+export interface ReviewRepoCandidate { source: 'card.project' | 'harness.defaultRepo' | 'host'; cwd: string }
+
+/** 기본 후보 — 존재하는 디렉터리만 · 같은 경로는 한 번. 읽기 실패는 그 후보를 뺀다(없음 ≠ 통과). */
+export function defaultReviewRepoCandidates(card: TaskCard, opts: { defaultRepo?: () => string | undefined; hostRoot?: () => string | undefined } = {}): ReviewRepoCandidate[] {
+  const raw: ReviewRepoCandidate[] = [];
+  if (card.project?.target && isAbsolute(card.project.target)) raw.push({ source: 'card.project', cwd: card.project.target });
+  try {
+    const configured = opts.defaultRepo ? opts.defaultRepo() : getUserConfig().harness?.defaultRepo;
+    if (configured && isAbsolute(configured)) raw.push({ source: 'harness.defaultRepo', cwd: configured });
+  } catch { /* 후보에서 뺀다 */ }
+  try {
+    const host = opts.hostRoot ? opts.hostRoot() : findGitDir(process.cwd())?.root;
+    if (host) raw.push({ source: 'host', cwd: host });
+  } catch { /* 후보에서 뺀다 */ }
+  const seen = new Set<string>();
+  const out: ReviewRepoCandidate[] = [];
+  for (const candidate of raw) {
+    if (!isAbsolute(candidate.cwd)) continue;
+    const cwd = resolve(candidate.cwd);
+    if (seen.has(cwd)) continue;
+    seen.add(cwd);
+    try { if (statSync(cwd).isDirectory()) out.push({ source: candidate.source, cwd }); } catch { /* 없는 디렉터리는 뺀다 */ }
+  }
+  return out;
+}
+
+/**
+ * TA-LIVE-REVIEW-POD — 작업 트리가 없을 때(Pod 런) 리뷰 cwd 를 정한다.
+ * 후보 저장소에서 `gh pr view <pr>` 가 «런이 낸 머리»(기록된 sha · 없으면 런의 브랜치)를 돌려줄 때만 그 저장소를 쓴다 —
+ * «다른 저장소에서 gh·self review 를 돌리지 않는다»(TA-JUDGE-LIVE-SAFE)는 계약을 지킨다. 못 정하면 이유 한 줄.
+ */
+export async function resolveReviewRepo(
+  card: TaskCard, pr: number,
+  produced: { headCommit?: string; branch?: string; prUrl?: string } | undefined,
+  deps: LiveMoveDeps = {},
+): Promise<{ resolved: true; cwd: string; source: ReviewRepoCandidate['source']; proof: 'head-sha' | 'branch'; view: PrHeadView; reason: string } | { resolved: false; reason: string }> {
+  // 호출자가 런 근거를 «안 넘긴» 것과 런이 «기록하지 않은» 것은 다른 사실이다 — 섞어 적지 않는다.
+  if (produced === undefined) return { resolved: false, reason: 'caller passed no run evidence (produced) — head/branch not checked' };
+  // 기록된 머리가 «있으면» 그것만 근거다 — 모양이 틀린 sha 를 브랜치로 대체하지 않는다(확인 못 한 머리로 리뷰하지 않게).
+  if (produced?.headCommit !== undefined && !/^[0-9a-f]{40}$/i.test(produced.headCommit)) {
+    return { resolved: false, reason: `run head ${JSON.stringify(produced.headCommit.slice(0, 40))} is not a full commit sha` };
+  }
+  const expectedHead = produced?.headCommit?.toLowerCase();
+  const expectedBranch = produced?.branch?.trim() || undefined;
+  if (!expectedHead && !expectedBranch) return { resolved: false, reason: 'run result carries no PR head or branch to confirm against' };
+  let candidates: readonly ReviewRepoCandidate[];
+  try { candidates = (deps.repoCandidates ?? defaultReviewRepoCandidates)(card); } catch { candidates = []; }
+  if (!candidates.length) return { resolved: false, reason: 'no target repository (card project · harness.defaultRepo · host checkout)' };
+  const sameUrl = (a: string, b: string) => a.trim().replace(/\/+$/, '').toLowerCase() === b.trim().replace(/\/+$/, '').toLowerCase();
+  const misses: string[] = [];
+  for (const candidate of candidates) {
+    let view: PrHeadView | null;
+    try { view = await (deps.prHead ?? defaultPrHead)(pr, candidate.cwd); } catch { view = null; }
+    if (!view) { misses.push(`${candidate.source}: PR #${pr} unreadable`); continue; }
+    if (produced?.prUrl && view.url && !sameUrl(view.url, produced.prUrl)) { misses.push(`${candidate.source}: PR url ${view.url} ≠ run ${produced.prUrl}`); continue; }
+    if (expectedHead) {
+      if (view.head.toLowerCase() !== expectedHead) { misses.push(`${candidate.source}: head ${view.head.slice(0, 12)} ≠ run ${expectedHead.slice(0, 12)}`); continue; }
+      return { resolved: true, cwd: candidate.cwd, source: candidate.source, proof: 'head-sha', view, reason: `${candidate.source} PR #${pr} head matches run` };
+    }
+    if (view.branch !== expectedBranch) { misses.push(`${candidate.source}: branch ${view.branch ?? '?'} ≠ run ${expectedBranch}`); continue; }
+    // 브랜치 근거는 sha 보다 약하다 — 같은 PR(저장소 · 번호)임을 URL 로 «양쪽 다» 확인할 때만 쓴다.
+    if (!produced?.prUrl || !view.url) { misses.push(`${candidate.source}: branch matches but PR url unconfirmed (run ${produced?.prUrl ?? 'none'} · repo ${view.url ?? 'none'})`); continue; }
+    return { resolved: true, cwd: candidate.cwd, source: candidate.source, proof: 'branch', view, reason: `${candidate.source} PR #${pr} head branch matches run` };
+  }
+  return { resolved: false, reason: misses.join(' · ') };
+}
 
 /** 받은 환경 그대로 먼저 묻고, 실패하면 프록시만 뺀 환경으로 한 번 더(이 저장소의 gh 운영 관행 — 프록시 경유가 gh 를 깨는 호스트). */
 export type GhRun = (args: string[], options: { env: NodeJS.ProcessEnv; cwd?: string }) => { status: number | null; stdout: string };
 const runGh: GhRun = (args, options) => spawnSync('gh', args, { encoding: 'utf8', timeout: 30_000, env: options.env, ...(options.cwd ? { cwd: options.cwd } : {}) });
 
-export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh): Promise<{ head: string; state: string } | null> {
-  const view = (env: NodeJS.ProcessEnv) => gh(['pr', 'view', String(pr), '--json', 'headRefOid,state'], { env, ...(cwd ? { cwd } : {}) });
+export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh): Promise<PrHeadView | null> {
+  const view = (env: NodeJS.ProcessEnv) => gh(['pr', 'view', String(pr), '--json', 'headRefOid,headRefName,state,url'], { env, ...(cwd ? { cwd } : {}) });
   let out = view(process.env);
   if (out.status !== 0) {
     const noProxy = { ...process.env };
@@ -77,9 +156,13 @@ export async function defaultPrHead(pr: number, cwd?: string, gh: GhRun = runGh)
   }
   if (out.status !== 0) return null;
   try {
-    const value = JSON.parse(out.stdout) as { headRefOid?: unknown; state?: unknown };
+    const value = JSON.parse(out.stdout) as { headRefOid?: unknown; headRefName?: unknown; state?: unknown; url?: unknown };
     return typeof value.headRefOid === 'string' && /^[a-f0-9]{40}$/i.test(value.headRefOid) && typeof value.state === 'string'
-      ? { head: value.headRefOid, state: value.state } : null;
+      ? {
+        head: value.headRefOid, state: value.state,
+        ...(typeof value.headRefName === 'string' && value.headRefName ? { branch: value.headRefName } : {}),
+        ...(typeof value.url === 'string' && value.url ? { url: value.url } : {}),
+      } : null;
   } catch { return null; }
 }
 
@@ -121,16 +204,33 @@ function observe(deps: LiveMoveDeps, result: LiveMoveResult): LiveMoveResult {
  * 다음 틱에 한 번 더 요청될 수 있다(초과는 많아야 한 번 · 리뷰는 읽기 전용이라 착지·재발사로 번지지 않는다).
  */
 /** `review` — PR 머리마다 한 번. 카드에 먼저 적고(잠금 안) 그다음 띄운다 · 띄우기 실패는 카드에 오류로 남기고 같은 머리는 다시 안 띄운다. */
-export async function executeLiveReview(card: TaskCard | undefined, pr: number | undefined, ctx: { runId: string | null; stopReason: string; cwd?: string }, deps: LiveMoveDeps = {}): Promise<LiveMoveResult> {
+export async function executeLiveReview(
+  card: TaskCard | undefined, pr: number | undefined,
+  ctx: { runId: string | null; stopReason: string; cwd?: string; produced?: { headCommit?: string; branch?: string; prUrl?: string } },
+  deps: LiveMoveDeps = {},
+): Promise<LiveMoveResult> {
   const kind = 'review' as const;
   if (!card) return observe(deps, { kind, executed: false, card: null, ok: false, detail: 'no task card — stays shadow' });
   if (!pr || !Number.isSafeInteger(pr) || pr < 1) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: 'no PR — stays shadow' });
-  // PR 의 저장소(그 PR 을 낸 결과의 작업 트리)를 모르면 보류한다 — 다른 저장소에서 gh·self review 를 돌리지 않게.
-  if (!ctx.cwd) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} worktree unknown — stays shadow` });
-  let head: { head: string; state: string } | null;
-  try { head = await (deps.prHead ?? defaultPrHead)(pr, ctx.cwd); } catch { head = null; }
-  if (!head) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} head unknown` });
-  if (head.state !== 'OPEN') return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} is ${head.state}` });
+  // PR 의 저장소를 모르면 보류한다 — 다른 저장소에서 gh·self review 를 돌리지 않게. 작업 트리가 없으면(Pod 런 ·
+  // TA-LIVE-REVIEW-POD) 후보 저장소 중 «런이 낸 PR 머리»가 확인되는 곳만 쓰고, 못 정하면 이유 한 줄을 관측에 싣는다.
+  let cwd = ctx.cwd;
+  let head: PrHeadView | null = null;
+  let reviewRepo: LiveMoveResult['reviewRepo'];
+  if (!cwd) {
+    const found = await resolveReviewRepo(card, pr, ctx.produced, deps);
+    if (!found.resolved) {
+      return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} worktree unknown — stays shadow`, reviewRepo: { resolved: false, reason: found.reason } });
+    }
+    cwd = found.cwd;
+    head = found.view;
+    reviewRepo = { resolved: true, source: found.source, cwd: found.cwd, proof: found.proof, reason: found.reason };
+  } else {
+    try { head = await (deps.prHead ?? defaultPrHead)(pr, cwd); } catch { head = null; }
+  }
+  const withRepo = (result: LiveMoveResult): LiveMoveResult => reviewRepo ? { ...result, reviewRepo } : result;
+  if (!head) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} head unknown` }));
+  if (head.state !== 'OPEN') return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `PR #${pr} is ${head.state}` }));
   const path = deps.statePath ?? taskAgentStatePath();
   const at = (deps.now ?? (() => new Date()))().toISOString();
   const claim = { claimed: false, missing: false };
@@ -141,18 +241,18 @@ export async function executeLiveReview(card: TaskCard | undefined, pr: number |
     claim.claimed = true;
     return { ...current, reviewRequests: [...(current.reviewRequests ?? []), { pr, head: head!.head, at }] };
   });
-  if (claim.missing) return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: 'task card not in state file' });
-  if (!claim.claimed) return observe(deps, { kind, executed: false, card: card.id, ok: true, detail: `already requested for #${pr} head ${head.head.slice(0, 12)}` });
+  if (claim.missing) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: 'task card not in state file' }));
+  if (!claim.claimed) return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: true, detail: `already requested for #${pr} head ${head.head.slice(0, 12)}` }));
   try {
-    await (deps.requestReview ?? defaultRequestReview)(pr, liveReviewIntent(card, ctx.runId, ctx.stopReason), ctx.cwd);
+    await (deps.requestReview ?? defaultRequestReview)(pr, liveReviewIntent(card, ctx.runId, ctx.stopReason), cwd);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     updateTaskCard(path, card.id, (current) => current?.reviewRequests?.some((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at)
       ? { ...current, reviewRequests: current.reviewRequests.map((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at ? { ...entry, error: reason } : entry) }
       : undefined);
-    return observe(deps, { kind, executed: false, card: card.id, ok: false, detail: `review request failed for #${pr} head ${head.head.slice(0, 12)}: ${reason}` });
+    return observe(deps, withRepo({ kind, executed: false, card: card.id, ok: false, detail: `review request failed for #${pr} head ${head.head.slice(0, 12)}: ${reason}` }));
   }
-  return observe(deps, { kind, executed: true, card: card.id, ok: true, detail: `review requested for #${pr} head ${head.head.slice(0, 12)}` });
+  return observe(deps, withRepo({ kind, executed: true, card: card.id, ok: true, detail: `review requested for #${pr} head ${head.head.slice(0, 12)}` }));
 }
 
 /** `propose-green` — 비지 않은 근거가 있을 때만 카드에 제안을 적는다(한 번). 체크리스트는 쓰지 않는다. */

package/src/task-agent/mission.ts

@@ -296,7 +296,7 @@ export function recordPieceRef(pieceId: string, ref: { pr?: number; goalId?: str
 
 /** 이미 넘긴 조각인가 — live 는 live 넘김·발사·발사 실패면 다시 안 넘긴다 · shadow 는 어떤 넘김이든 있으면 안 넘긴다. */
 function alreadyHanded(card: TaskCard, mode: 'shadow' | 'live'): boolean {
-  if (card.status === 'launched' || card.status === 'launch-failed') return true;
+  if (card.status === 'launched' || card.status === 'launch-failed' || card.status === 'failed') return true;
   if (!card.handed) return false;
   return mode === 'shadow' || card.handed.mode === 'live';
 }

package/src/task-agent/parent-host.ts

@@ -0,0 +1,315 @@
+/**
+ * HARNESS-PARENT-ON-MSB1 — `tasks hand --live` 의 하니스 «부모»를 다른 호스트(ssh)에서 띄우는 첫 조각 ⊕ 낡은 부모 보고.
+ *
+ * 왜 «첫 조각»인가 (2026-10-08 실측):
+ * - 부모가 호스트에서 기대는 것이 전부 «호스트 로컬 파일»이다 — 착지 동결(`landing-freeze.json` ⊕ `landing-merges/` 표지
+ *   무용), 풀 예약(`HostPoolLease`), 런 원장(`run-ledger/`), logs.db. 원격 부모가 `--merge-by-host` 로 병합하면 HQ 의
+ *   동결·컷 배수(drain)를 «못 본 채» 병합한다.
+ * - 그래서 원격 부모는 «PR 까지만» 간다: `--merge-by-host` → `--no-auto-merge`. 병합 권한은 HQ 에 남는다(동결 안전).
+ * - 발사 전 점검(preflight)이 하나라도 막히면 원격으로 띄우지 않고 «종전 로컬 발사»로 돌아간다(fail-closed · 관측 남김).
+ * - 관측: 카드에 `parentHost` 를 적고, `tasks show` 가 원격 런 원장을 ssh 로 HQ 의 거울 디렉터리로 당겨 읽는다.
+ *
+ * 기본 OFF — `taskAgent.parentHost` 가 없고 `ELANOUS_TA_PARENT_HOST` 도 없으면 아무것도 바뀌지 않는다.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { shellQuote } from './task-hand.js';
+
+/** `taskAgent.parentHost` 설정 칸. */
+export interface ParentHostConfig {
+  /** ssh 대상(예: `node-b`). */
+  host: string;
+  /** 원격에서 부모를 띄울 git 작업 트리(절대 경로 · 원격 기준). */
+  cwd: string;
+  /** 원격 elanous 진입점 — 기본 `$HOME/.local/share/elanous/bin/elanous`(설치본). */
+  elanous?: string;
+  /** 원격 config-dir — 기본 `$HOME/.elanous`. */
+  configDir?: string;
+  /** 원격 부모에 줄 `--pod-pool`(원격 kube context 이름이 HQ 와 다를 때). */
+  podPool?: string;
+}
+
+export const PARENT_HOST_ENV = 'ELANOUS_TA_PARENT_HOST';
+const DEFAULT_REMOTE_ELANOUS = '$HOME/.local/share/elanous/bin/elanous';
+const DEFAULT_REMOTE_CONFIG_DIR = '$HOME/.elanous';
+const HOST_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]{0,127}$/;
+
+/**
+ * 켜졌나 — env 가 이긴다(`off`·`0`·빈 값이면 끔). env 가 호스트를 주면 나머지 칸(cwd 등)은 설정에서 받는다.
+ * cwd 가 없으면 켜지지 않는다(어디서 띄울지 모르는 원격 발사는 하지 않는다).
+ */
+export function resolveParentHost(config: Partial<ParentHostConfig> | undefined, env: NodeJS.ProcessEnv = process.env): ParentHostConfig | null {
+  const fromEnv = env[PARENT_HOST_ENV];
+  if (fromEnv !== undefined && ['', '0', 'off', 'false', 'local'].includes(fromEnv.trim().toLowerCase())) return null;
+  const host = (fromEnv?.trim() || config?.host || '').trim();
+  if (!host || !HOST_RE.test(host)) return null;
+  const cwd = config?.cwd?.trim();
+  if (!cwd || !cwd.startsWith('/')) return null;
+  return { host, cwd, ...(config?.elanous ? { elanous: config.elanous } : {}), ...(config?.configDir ? { configDir: config.configDir } : {}), ...(config?.podPool ? { podPool: config.podPool } : {}) };
+}
+
+/** `$HOME/…` 은 원격 셸이 풀도록 따옴표 밖에 둔다 — 나머지는 shellQuote. */
+function remotePath(path: string): string {
+  return path.startsWith('$HOME/') ? `"$HOME"/${shellQuote(path.slice('$HOME/'.length))}` : shellQuote(path);
+}
+
+/** 원격 부모 인자 — HQ 병합 권한을 넘기지 않는다: `--merge-by-host` → `--no-auto-merge` ⊕ (있으면) `--pod-pool`. */
+export function remoteParentArgs(args: readonly string[], podPool?: string): string[] {
+  const out = args.map((arg) => arg === '--merge-by-host' ? '--no-auto-merge' : arg);
+  if (!out.includes('--no-auto-merge') && out[0] === 'harness') out.splice(2, 0, '--no-auto-merge');
+  if (podPool && !out.includes('--pod-pool')) out.splice(2, 0, '--pod-pool', podPool);
+  return out;
+}
+
+/** 원격 로그 파일(원격 기준) — 부모 stdout/stderr. */
+export function remoteParentLogPath(target: ParentHostConfig, runId: string): string {
+  return `${target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR}/remote-parents/${runId}.log`;
+}
+
+/** ssh 로 넘길 원격 셸 한 줄 — 떼어 띄우고 pid 만 찍는다. */
+export function remoteLaunchScript(target: ParentHostConfig, args: readonly string[], env: Record<string, string>): string {
+  const elanous = target.elanous ?? DEFAULT_REMOTE_ELANOUS;
+  const configDir = target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR;
+  const log = remoteParentLogPath(target, env.ELANOUS_RUN_ID ?? 'unknown');
+  const envPart = Object.entries(env).filter(([key]) => /^[A-Z_][A-Z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${shellQuote(value)}`).join(' ');
+  const argv = [remotePath(elanous), '--config-dir', remotePath(configDir), ...remoteParentArgs(args, target.podPool).map(shellQuote)].join(' ');
+  // 준비가 실패하면 «확실히 안 띄웠다»(not-launched=…)를 찍고 끝낸다 — 그때만 호출부가 로컬로 돌아간다.
+  // 띄운 뒤에는 짧게 살아 있는지 보고 pid 를 찍는다(조기 종료면 early-exit — 역시 «안 돈다»가 확실).
+  return `mkdir -p ${remotePath(`${configDir}/remote-parents`)} || { echo "not-launched=mkdir"; exit 3; }; `
+    + `cd ${shellQuote(target.cwd)} || { echo "not-launched=cwd"; exit 3; }; `
+    + `${envPart ? `env ${envPart} ` : ''}nohup ${argv} >> ${remotePath(log)} 2>&1 < /dev/null & p=$!; sleep 2; `
+    + `if kill -0 "$p" 2>/dev/null; then echo "pid=$p"; else echo "not-launched=early-exit"; tail -3 ${remotePath(log)}; exit 4; fi`;
+}
+
+/** ssh 실행기(시험 주입). */
+export type SshRunner = (host: string, script: string, timeoutMs: number) => { status: number | null; stdout: string; stderr: string };
+
+export const defaultSshRunner: SshRunner = (host, script, timeoutMs) => {
+  const result = spawnSync('ssh', ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8', '-o', 'ControlPath=none', host, script], { encoding: 'utf8', timeout: timeoutMs, maxBuffer: 32 * 1024 * 1024 });
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? (result.error ? String(result.error) : '') };
+};
+
+/** 발사 전 점검 결과 — `gaps` 가 비어야 원격으로 띄운다. */
+export interface ParentHostPreflight { ok: boolean; gaps: string[]; facts: Record<string, string> }
+
+/** 원격 사실 한 번에 — key=value 줄. */
+export function preflightScript(target: ParentHostConfig): string {
+  const elanous = remotePath(target.elanous ?? DEFAULT_REMOTE_ELANOUS);
+  const configDir = remotePath(target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR);
+  return [
+    `echo "version=$(${elanous} --version 2>/dev/null | tail -1 | cut -d' ' -f1)"`,
+    `test -f ${configDir}/config.json && echo config=1`,
+    `grep -Eq '"podPool"[[:space:]]*:[[:space:]]*"[^"[:space:]]+' ${configDir}/config.json 2>/dev/null && echo podPool=1`,
+    `(cd ${shellQuote(target.cwd)} 2>/dev/null && git rev-parse --is-inside-work-tree >/dev/null 2>&1) && echo repo=1`,
+    `command -v kubectl >/dev/null 2>&1 && echo kubectl=1`,
+    `true`,
+  ].join('; ');
+}
+
+export interface PreflightInput {
+  target: ParentHostConfig;
+  /** HQ 의 elanous 판(첫 낱말). */
+  localVersion: string;
+  /** HQ 착지 동결이 «발사도 막는» 상태인가 — 원격 부모는 그 동결을 못 본다. */
+  launchHoldActive: boolean;
+  ssh?: SshRunner;
+}
+
+/** 순수 판정 — 원격 사실 → 막는 칸 목록. */
+export function judgeParentHostFacts(facts: Record<string, string>, input: Omit<PreflightInput, 'ssh' | 'target'> & { podPoolOverride?: boolean }): string[] {
+  const gaps: string[] = [];
+  if (facts.unreachable) gaps.push(`unreachable: ${facts.unreachable}`);
+  else {
+    if (!facts.version) gaps.push('remote-elanous-missing');
+    else if (facts.version !== input.localVersion) gaps.push(`version-mismatch: remote ${facts.version} ≠ HQ ${input.localVersion}`);
+    if (facts.config !== '1') gaps.push('remote-config-missing');
+    if (facts.podPool !== '1' && !input.podPoolOverride) gaps.push('remote-pod-pool-unset');
+    if (facts.repo !== '1') gaps.push('remote-repo-missing');
+    if (facts.kubectl !== '1') gaps.push('remote-kubectl-missing');
+  }
+  if (input.launchHoldActive) gaps.push('hq-launch-freeze-active');
+  return gaps;
+}
+
+export function preflightParentHost(input: PreflightInput): ParentHostPreflight {
+  const ssh = input.ssh ?? defaultSshRunner;
+  const facts: Record<string, string> = {};
+  const result = ssh(input.target.host, preflightScript(input.target), 20_000);
+  if (result.status !== 0) facts.unreachable = (result.stderr.trim().split('\n').pop() || `rc=${result.status}`).slice(0, 200);
+  else for (const line of result.stdout.split('\n')) {
+    const at = line.indexOf('=');
+    if (at > 0) facts[line.slice(0, at).trim()] = line.slice(at + 1).trim();
+  }
+  const gaps = judgeParentHostFacts(facts, { localVersion: input.localVersion, launchHoldActive: input.launchHoldActive, podPoolOverride: Boolean(input.target.podPool) });
+  return { ok: gaps.length === 0, gaps, facts };
+}
+
+/** 원격이 «확실히 안 띄웠다»고 답했다 — 호출부가 로컬로 돌아가도 중복 발사가 아니다. */
+export class RemoteParentNotLaunchedError extends Error {
+  constructor(host: string, reason: string) { super(`원격 부모 안 뜸(${host}): ${reason}`); this.name = 'RemoteParentNotLaunchedError'; }
+}
+
+/**
+ * 원격 발사 — pid 를 받으면 성공. 원격이 `not-launched=…` 로 답하면 `RemoteParentNotLaunchedError`(로컬로 가도 된다).
+ * 그 밖(ssh 끊김·시간 초과·알 수 없는 답)은 «떴는지 모른다» — 일반 Error 로 던져 카드가 launch-failed 로 남게 한다
+ * (⛔ 로컬로 또 띄우면 원격에 이미 뜬 부모와 중복이 될 수 있다).
+ */
+export function launchRemoteParent(target: ParentHostConfig, args: readonly string[], env: Record<string, string>, ssh: SshRunner = defaultSshRunner): { pid: number; log: string } {
+  const result = ssh(target.host, remoteLaunchScript(target, args, env), 30_000);
+  const log = remoteParentLogPath(target, env.ELANOUS_RUN_ID ?? 'unknown');
+  const pid = Number(/^pid=(\d+)$/m.exec(result.stdout)?.[1]);
+  if (result.status === 0 && Number.isSafeInteger(pid) && pid > 0) return { pid, log };
+  const refused = /^not-launched=(\S+)/m.exec(result.stdout)?.[1];
+  if (refused && (result.status === 3 || result.status === 4)) {
+    const tail = result.stdout.split('\n').filter((line) => line.trim() && !line.startsWith('not-launched=')).slice(-1)[0] ?? '';
+    throw new RemoteParentNotLaunchedError(target.host, `${refused}${tail ? `: ${tail.slice(0, 160)}` : ''}`);
+  }
+  throw new Error(`원격 부모 발사 결과 불확실(${target.host} · rc=${result.status}) — 중복을 피해 로컬로 다시 띄우지 않는다 · 원격에서 ELANOUS_RUN_ID=${env.ELANOUS_RUN_ID ?? '?'} 를 확인: ${(result.stderr.trim().split('\n').pop() || '').slice(0, 160)}`);
+}
+
+// ── 관측: 원격 런 원장 거울 ─────────────────────────────────────────────────────────────
+
+const RUN_ID_RE = /^run-[A-Za-z0-9_-]{4,64}$/;
+
+/** HQ 쪽 거울 디렉터리 — `<prodRoot>/remote-parents/<host>/run-ledger`. */
+export function remoteLedgerMirrorDir(prodRoot: string, host: string): string {
+  return join(prodRoot, 'remote-parents', host.replace(/[^A-Za-z0-9._-]/g, '_'), 'run-ledger');
+}
+
+/** 거울 디렉터리 전부(카드 원장 읽기가 연합 목록 뒤에 붙인다). */
+export function remoteLedgerMirrorDirs(prodRoot: string): string[] {
+  const base = join(prodRoot, 'remote-parents');
+  if (!existsSync(base)) return [];
+  try {
+    return readdirSync(base).map((host) => join(base, host, 'run-ledger')).filter((dir) => existsSync(dir));
+  } catch { return []; }
+}
+
+/**
+ * 원격 런 원장(부모 ⊕ 그 원장이 가리키는 Pod 자식)을 HQ 거울로 당긴다 — 읽기 전용(원격에 쓰지 않는다).
+ * 돌려주는 값 = 당긴 런 id. 원격을 못 읽으면 던진다(호출부가 «없음»이 아니라 실패로 적는다).
+ */
+export function mirrorRemoteRunLedgers(target: Pick<ParentHostConfig, 'host' | 'configDir'>, runId: string, prodRoot: string, ssh: SshRunner = defaultSshRunner): string[] {
+  if (!RUN_ID_RE.test(runId)) throw new Error(`invalid runId: ${runId}`);
+  const dir = remoteLedgerMirrorDir(prodRoot, target.host);
+  mkdirSync(dir, { recursive: true });
+  const remoteDir = `${target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR}/run-ledger`;
+  const pulled: string[] = [];
+  const pull = (id: string): string | null => {
+    const file = remotePath(`${remoteDir}/${id}.jsonl`);
+    // 부재만 ABSENT — 권한·읽기 오류는 cat 의 비0 종료로 올라와 던진다(«없음»으로 바꾸지 않는다).
+    const result = ssh(target.host, `if [ -e ${file} ]; then cat ${file}; else echo __ELANOUS_ABSENT__; fi`, 20_000);
+    if (result.status !== 0) throw new Error(`원격 원장 읽기 실패(${target.host} ${id}): ${(result.stderr.trim().split('\n').pop() || `rc=${result.status}`).slice(0, 200)}`);
+    const path = join(dir, `${id}.jsonl`);
+    if (result.stdout.trim() === '__ELANOUS_ABSENT__') {
+      // 원격에서 사라졌으면 낡은 거울도 걷는다 — 지난 사진을 지금 근거로 읽지 않게.
+      rmSync(path, { force: true });
+      return null;
+    }
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, result.stdout);
+    renameSync(tmp, path);
+    pulled.push(id);
+    return result.stdout;
+  };
+  const host = pull(runId);
+  if (host) {
+    const children = new Set<string>();
+    for (const line of host.split('\n')) {
+      try {
+        const entry = JSON.parse(line) as { event?: string; data?: { childRunId?: unknown } };
+        if (entry.event === 'pod-child-run' && typeof entry.data?.childRunId === 'string' && RUN_ID_RE.test(entry.data.childRunId) && entry.data.childRunId !== runId) children.add(entry.data.childRunId);
+      } catch { /* 깨진 줄은 원장 읽기가 다룬다 */ }
+    }
+    for (const child of children) pull(child);
+  }
+  try { debug.log('task-agent', 'remote-ledger-mirrored', { host: target.host, runId, pulled }); } catch { /* fail-soft */ }
+  return pulled;
+}
+
+// ── 낡은 부모 보고(읽기 전용 · 죽이지 않는다) ─────────────────────────────────────────────
+
+export interface HarnessParentProcess { pid: number; ageHours: number; runId: string | null; version: string | null; seat: string | null; kind: 'say' | 'ask' | 'queue-child' }
+
+/** macOS/Linux `etime` — `[[dd-]hh:]mm:ss`. */
+export function parseEtime(value: string): number | null {
+  const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(value.trim());
+  if (!match) return null;
+  const [, d, h, m, s] = match;
+  return Number(d ?? 0) * 86400 + Number(h ?? 0) * 3600 + Number(m) * 60 + Number(s);
+}
+
+/** `ps -axwwE -o pid=,etime=,command=` 출력 → 하니스 부모들. 런 id 는 env 꼬리의 «마지막» `ELANOUS_RUN_ID=`. */
+export function parseHarnessParents(psOutput: string): HarnessParentProcess[] {
+  const rows: HarnessParentProcess[] = [];
+  for (const line of psOutput.split('\n')) {
+    const match = /^\s*(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+    if (!match) continue;
+    const command = match[3]!;
+    const head = command.slice(0, 600);
+    const kind = /harness-queue-child\.ts/.test(head) ? 'queue-child' : /elanous\.mjs\b.*\bharness (say|ask)\b/.exec(head)?.[1] as 'say' | 'ask' | undefined;
+    if (!kind) continue;
+    const seconds = parseEtime(match[2]!);
+    if (seconds === null) continue;
+    const runIds = [...command.matchAll(/(?:^|\s)ELANOUS_RUN_ID=(run-[A-Za-z0-9_-]{4,64})(?=\s|$)/g)].map((m) => m[1]!);
+    rows.push({
+      pid: Number(match[1]),
+      ageHours: Math.round((seconds / 3600) * 10) / 10,
+      runId: runIds.at(-1) ?? null,
+      version: /\/versions\/([^/\s]+)\//.exec(head)?.[1] ?? null,
+      seat: /--seat (\S+)/.exec(head)?.[1] ?? null,
+      kind,
+    });
+  }
+  return rows;
+}
+
+export interface StaleParentRow extends HarnessParentProcess { reasons: string[]; runStatus: string | null }
+
+export interface StaleParentDeps {
+  ps?: () => string;
+  /** 런 원장(없으면 null · 못 읽으면 던진다). */
+  loadLedger?: (runId: string) => Array<{ event: string; data?: Record<string, unknown> }> | null;
+  /** 살아 있는 Pod Job 의 `elanous.run`/`elanous.child-run` 라벨 — null 이면 «못 쟀다»(Pod 근거 없음). */
+  podRuns?: () => ReadonlySet<string> | null;
+  labelOf?: (runId: string) => string;
+}
+
+/**
+ * 나이 ≥ olderThanHours 인 부모 중 «원장이 끝났다»(run-status 줄) 또는 «Pod 이 없다»(Pod 목록을 쟀고 부모·자식 라벨이 없다)인 것.
+ * 읽기만 한다 — 죽이지 않는다. 런 id 를 모르는 부모는 `run-id-unknown` 으로 따로 적는다(낡음 판정이 아니다).
+ */
+export function staleHarnessParents(olderThanHours: number, deps: StaleParentDeps = {}): { rows: StaleParentRow[]; scanned: number; podRunsMeasured: boolean } {
+  const ps = deps.ps ?? (() => spawnSync('ps', ['-axwwE', '-o', 'pid=,etime=,command='], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).stdout ?? '');
+  const parents = parseHarnessParents(ps());
+  let podRuns: ReadonlySet<string> | null = null;
+  try { podRuns = deps.podRuns ? deps.podRuns() : null; } catch { podRuns = null; }
+  const label = deps.labelOf ?? ((id: string) => id);
+  const rows: StaleParentRow[] = [];
+  for (const parent of parents) {
+    if (parent.ageHours < olderThanHours) continue;
+    const reasons: string[] = [];
+    let runStatus: string | null = null;
+    if (!parent.runId) reasons.push('run-id-unknown');
+    else {
+      let ledger: ReturnType<NonNullable<StaleParentDeps['loadLedger']>> = null;
+      try { ledger = deps.loadLedger ? deps.loadLedger(parent.runId) : null; } catch (error) { reasons.push(`ledger-unreadable: ${(error instanceof Error ? error.message : String(error)).slice(0, 80)}`); }
+      const status = [...(ledger ?? [])].reverse().find((entry) => entry.event === 'run-status' && typeof entry.data?.runStatus === 'string');
+      if (status) { runStatus = String(status.data!.runStatus); reasons.push(`ledger-terminal(${runStatus})`); }
+      if (podRuns) {
+        const ids = [parent.runId, ...(ledger ?? []).filter((entry) => entry.event === 'pod-child-run' && typeof entry.data?.childRunId === 'string').map((entry) => entry.data!.childRunId as string)];
+        if (!ids.some((id) => podRuns!.has(label(id)))) reasons.push('pod-gone');
+      }
+    }
+    if (reasons.length) rows.push({ ...parent, reasons, runStatus });
+  }
+  rows.sort((a, b) => b.ageHours - a.ageHours);
+  return { rows, scanned: parents.length, podRunsMeasured: podRuns !== null };
+}
+
+/** HQ 의 elanous 판 — 이 패키지의 package.json(첫 낱말 = `--version` 첫 낱말과 같은 모양). */
+export function localElanousVersion(): string {
+  try { return String((JSON.parse(readFileSync(resolve(import.meta.dir, '../../package.json'), 'utf8')) as { version?: string }).version ?? ''); } catch { return ''; }
+}

package/src/task-agent/shadow.ts

@@ -227,7 +227,16 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   if (live) {
     if (liveKind === 'review') {
       liveMove = await executeLiveReview(boundCard, prResult?.prNumber,
-        { runId: input.runId, stopReason: input.stopReason, ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}) }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        {
+          runId: input.runId, stopReason: input.stopReason,
+          ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}),
+          // TA-LIVE-REVIEW-POD — 작업 트리가 없는 런(Pod)은 «런이 낸 머리»로 리뷰 저장소를 확인한다.
+          ...(prResult && !prResult.worktreePath ? { produced: {
+            ...(prResult.checkedHeadCommit !== undefined ? { headCommit: prResult.checkedHeadCommit } : {}),
+            ...(prResult.branch ? { branch: prResult.branch } : {}),
+            ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
+          } } : {}),
+        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
     } else {
       const evidence: Record<string, string> = {};
       if (boundCard && !delivery && judgeInput.prState === 'MERGED' && prResult) evidence[boundCard.id] = `#${prResult.prNumber}`;

package/src/task-agent/task-hand.ts

@@ -44,8 +44,12 @@ export interface TaskCard {
   goal?: string;
   milestone?: string;
   createdAt: string;
-  /** launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사. */
-  status: 'handed' | 'launched' | 'launch-failed';
+  /**
+   * launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사.
+   * failed = 발사된 런이 PR·수확 가지 없이 죽었거나 끝내 안 떴다(TA-JUDGE-DEAD-RUN · `card-evidence.ts`) — 사유
+   * (`failed/needs-owner|needs-relaunch — …`)는 history 마지막 칸 · 자동 재발사하지 않는다(사람/판단부 몫).
+   */
+  status: 'handed' | 'launched' | 'launch-failed' | 'failed';
   history: TaskCardEvent[];
   /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
   pieces?: string[];
@@ -73,6 +77,8 @@ export interface TaskCard {
   launchId?: string;
   /** Pod 런이면 PR 을 연 자식 런 id(런 묶기가 PR 과 함께 적는다). */
   runChildId?: string;
+  /** HARNESS-PARENT-ON-MSB1 — 부모가 도는 원격 호스트(없으면 HQ 로컬). 원격 부모는 PR 까지만 간다(병합은 HQ). */
+  parentHost?: { host: string; configDir?: string; pid?: number; log?: string };
   /** 미션 카드만 — 모든 조각 착지 → 칸 green «제안»(체크리스트는 손대지 않는다 · OP/주인이 뒤집는다). */
   greenProposal?: { at: string; checklistId: string | null; evidence: Record<string, string> };
   /** TA-JUDGE-LIVE-SAFE — live `review` 수가 리뷰를 요청한 PR 머리들(머리마다 한 번 · 띄우기 실패면 error · 이력은 지우지 않는다). */
@@ -178,6 +184,7 @@ export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskC
   if (card.status !== 'launched' && unmet.length > 0) return { kind: 'wait', reason: `after ${unmet.join(', ')}${landed ? '' : ' · 착지 미확인'}` };
   if (card.status === 'handed') return { kind: 'launch', command: launchArgs(card), reason: '넘겨받은 과제 — 첫 발사' };
   if (card.status === 'launch-failed') return { kind: 'launch', command: launchArgs(card), reason: '직전 발사 실패 — 다시 발사' };
+  if (card.status === 'failed') return { kind: 'wait', reason: card.history.at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
   return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
 }
 
@@ -188,7 +195,11 @@ export function shellQuote(arg: string): string {
 /** 발사기에 넘기는 연결 — env(`ELANOUS_RUN_ID`)를 자식 환경에 얹으면 하니스 런이 `runId` 로 돈다(`resolveRunIdentity` 상속). launchId 는 카드에만 남는 발사 토큰이다. */
 export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string> }
 /** 발사기가 «이 런 id 로 띄웠다»고 돌려주는 영수증 — 없으면 카드에 런 id 를 적지 않는다(추측하지 않는다). */
-export interface TaskLaunchReceipt { runId?: string }
+export interface TaskLaunchReceipt {
+  runId?: string;
+  /** HARNESS-PARENT-ON-MSB1 — 부모를 원격 호스트에서 띄웠다(ssh). 카드에 적어 `tasks show` 가 그 호스트의 원장을 당긴다. */
+  parentHost?: { host: string; configDir?: string; pid?: number; log?: string };
+}
 export type TaskLauncher = (args: string[], cwd?: string, context?: TaskLaunchContext) => void | TaskLaunchReceipt | Promise<void | TaskLaunchReceipt>;
 
 export interface HandTaskOptions {
@@ -323,8 +334,9 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const launched: TaskCard = {
     ...card, status: 'launched',
     ...(boundRunId ? { runId: boundRunId, launchId } : {}),
+    ...(receipt && receipt.parentHost && typeof receipt.parentHost.host === 'string' ? { parentHost: receipt.parentHost } : {}),
     history: [
-      { at: launchedAt, event: 'launch', detail: move.command!.join(' ') },
+      { at: launchedAt, event: 'launch', detail: `${receipt && receipt.parentHost ? `[parent@${receipt.parentHost.host} · PR 까지만] ` : ''}${move.command!.join(' ')}` },
       ...(boundRunId ? [{ at: launchedAt, event: 'run-bound', detail: boundRunId, runId: boundRunId }] : []),
     ],
   };