elanous 0.2.21 → 0.2.23

package/src/task-agent/shadow.ts

@@ -16,12 +16,19 @@ import { readTaskAgentState, readTaskCard, taskAgentStatePath, type CompletionKi
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import { executeNextAction, type DeliveryKind, type NextAction } from './actions.js';
 import { judgeNextMove, type TaskJudgeInput, type TaskJudgement } from './judge.js';
-import { configuredTaskAgentLiveMoves, executeLiveGreenProposal, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
+import { HARNESS_RUN_ID_ENV } from '../harness/harness-space.js';
+import { recordLiveMoveHistory } from './live-move-history.js';
+import { capturedSelfReview, captureReviewResults, hasCapturedPass } from './review-result-capture.js';
+import { configuredTaskAgentLiveMoves, defaultPrHead, executeLiveGreenProposal, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
 
 export interface TaskAgentShadowInput {
   runId: string | null;
   stopReason: SupervisorStopReason;
   results: readonly SupervisorJobResult[];
+  /** One judgement cycle can attempt at most one land, even across PRs. */
+  cycleId?: string;
+  /** Reviewed SHA is mandatory for land; a bare pass cannot authorize merging. */
+  selfReview?: { verdict: 'pass' | 'fail'; head: string; mustFixCount?: number };
 }
 
 export interface TaskAgentShadowMove {
@@ -47,10 +54,12 @@ export interface TaskAgentShadowDeps {
   readCard?: (taskId: string) => TaskCard | undefined;
   /** Explicit live invocation only; supervisor's default hook always uses shadow. */
   mode?: 'shadow' | 'live';
-  /** TA-JUDGE-LIVE-SAFE — 실제로 할 안전한 수(`review`·`propose-green`). 비면 설정 `taskAgent.liveMoves` 를 읽는다. */
+  /** TA-JUDGE-LIVE-SAFE — 실제로 할 수(`review`·`propose-green`·`propose-land`). 없으면 설정 `taskAgent.liveMoves` 를 읽는다. */
   liveMoves?: ReadonlySet<TaskAgentLiveMove>;
   /** live 수의 부작용(리뷰 띄우기·PR 머리 조회·상태 파일) — 시험은 주입한다. */
   live?: LiveMoveDeps;
+  /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
+  env?: NodeJS.ProcessEnv;
 }
 
 /** 파일 산출물로 전달(elanous-out)하는 종결 종류 — 그 밖의 code-pr 밖 종류는 확인 증거를 판단부에서 기다린다. */
@@ -145,6 +154,15 @@ function shadowCompletion(card: TaskCard | undefined, lookupFailed: boolean): Co
 }
 
 export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, deps: TaskAgentShadowDeps = {}): Promise<TaskAgentShadowMove> {
+  // TA-REVIEW-RESULT-CAPTURE — 판단 «전»에 지난 live review 의 결과 파일을 회수한다(카드 원장을 아는 때만 · 던지지 않는다).
+  //   대기 중인 요청이 없으면 아무것도 쓰지 않는다(결과 파일 없는 카드의 동작은 종전과 같다).
+  const reviewLedger = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+  if (reviewLedger) {
+    try { captureReviewResults(reviewLedger, { ...(deps.live?.now ? { now: deps.live.now } : {}), ...(deps.log ? { log: deps.log } : {}) }); } catch (error) {
+      // fail-soft — 판단은 계속하되 원인은 남긴다.
+      try { (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'review-result-capture-failed', { statePath: reviewLedger, reason: (error instanceof Error ? error.message : String(error)).slice(-300) }); } catch { /* fail-soft */ }
+    }
+  }
   const successful = input.results.find(result => result.ok === true && result.worktreePath);
   let card: TaskCard | undefined;
   let cardLookupFailed = false;
@@ -161,6 +179,34 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   }
   const kind = card?.completion;
   const judgeInput = shadowJudgeInput(input.stopReason, input.results, kind);
+  // 슈퍼바이저가 나른 리뷰가 없으면 그 PR 카드에 회수된 리뷰 결과(pass · 실제로 돈 리뷰 · 머리 sha)를 같은 입력 칸으로 쓴다.
+  let selfReview = input.selfReview;
+  let reviewFromCapture = false;
+  if (!selfReview && reviewLedger && typeof judgeInput.pr === 'number') {
+    try {
+      const reviewedPr = judgeInput.pr;
+      const prRun = input.results.find((result) => result.prNumber === reviewedPr);
+      const prCard = prRun ? (card && successful?.taskId === prRun.taskId ? card : liveCardFor([prRun], deps, input.runId)) : undefined;
+      // 회수한 판정은 «리뷰한 머리»의 것이다 — 지금 PR 머리의 결과만 입력으로 쓴다(A 의 pass 로 B 를 land 쪽으로 보내지 않게 ·
+      //   여러 머리 결과가 역순으로 회수돼도 지금 머리 것을 고른다). 지금 머리 = 그 런 작업 트리에서 PR 머리 조회 ·
+      //   작업 트리가 없으면(Pod) 런이 낸 머리. 못 정하면 쓰지 않는다(종전처럼 review 수 → 새 머리면 새 리뷰).
+      if (prRun && hasCapturedPass(prCard, reviewedPr)) {
+        let currentHead: string | undefined;
+        if (prRun.worktreePath) {
+          const view = await (deps.live?.prHead ?? defaultPrHead)(reviewedPr, prRun.worktreePath).catch(() => null);
+          currentHead = view?.state === 'OPEN' ? view.head : undefined;
+        } else if (prRun.checkedHeadCommit && /^[0-9a-f]{40}$/i.test(prRun.checkedHeadCommit)) {
+          currentHead = prRun.checkedHeadCommit;
+        }
+        if (currentHead) selfReview = capturedSelfReview(prCard, reviewedPr, currentHead);
+      }
+      reviewFromCapture = selfReview !== undefined;
+    } catch (error) {
+      selfReview = undefined;
+      try { (deps.log ?? ((c, e, d) => debug.log(c, e, d, { level: 'warn' })))('task-agent', 'review-result-capture-failed', { pr: judgeInput.pr, reason: (error instanceof Error ? error.message : String(error)).slice(-300) }); } catch { /* fail-soft */ }
+    }
+  }
+  if (selfReview) judgeInput.review = selfReview.verdict;
   const delivery = successful?.worktreePath && card?.project?.target && isDeliveryKind(kind)
     ? { kind, worktreePath: successful.worktreePath, projectTarget: card.project.target, files: selectDeliveryCandidates(successful.worktreePath, kind) }
     : undefined;
@@ -209,8 +255,8 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     move.reason = wouldDo ?? judgement.reason;
     move.wouldDo = null;
   }
-  const liveKind: TaskAgentLiveMove | null = move.move === 'review' || move.move === 'propose-green' ? move.move : null;
-  // 판단마다 해석한다 — 안전하지 않은 수를 판단할 때도 모르는 항목 경고가 남게(실행은 아래 두 수뿐).
+  const liveKind: TaskAgentLiveMove | null = move.move === 'review' || move.move === 'propose-green' || move.move === 'propose-land' ? move.move : null;
+  // 판단마다 해석한다 — 허용되지 않은 수를 판단할 때도 모르는 항목 경고가 남게.
   const liveMoves = deps.liveMoves ?? await configuredTaskAgentLiveMoves();
   const live = liveKind !== null && liveMoves.has(liveKind);
   // 카드 id 는 모든 판단 관측에 싣는다(그림자 일치율을 카드로 잇는다) — 읽기 전용 조회.
@@ -219,10 +265,10 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   const boundCard = delivery
     ? card
     : prResult
-      ? (card && successful?.taskId === prResult.taskId ? card : liveCardFor([prResult], deps))
+      ? (card && successful?.taskId === prResult.taskId ? card : liveCardFor([prResult], deps, input.runId))
       : undefined;
   // PR 에 묶인 수는 그 PR 의 카드만 관측에 싣는다(못 찾으면 null — 다른 결과의 카드로 대체하지 않는다).
-  const liveCard = prResult || delivery ? boundCard : card ?? (cardLookupFailed ? undefined : liveCardFor(input.results, deps));
+  const liveCard = prResult || delivery ? boundCard : card ?? (cardLookupFailed ? undefined : liveCardFor(input.results, deps, input.runId));
   let liveMove: LiveMoveResult | undefined;
   if (live) {
     if (liveKind === 'review') {
@@ -237,6 +283,16 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
         }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+    } else if (liveKind === 'propose-land') {
+      liveMove = await executeLiveLand(boundCard, prResult?.prNumber,
+        { runId: input.runId, cycleId: input.cycleId, review: selfReview,
+          ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}),
+          ...(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}`;
@@ -247,12 +303,59 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   // 판단한 수마다 live/shadow 를 남긴다 — OP 가 «오판 건수»·«그림자 일치율»을 카드·수 종류로 잰다.
   (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'shadow-move', {
     ...move, completion: shadowCompletion(card, cardLookupFailed), card: liveCard?.id ?? null, live, liveExecuted: liveMove?.executed ?? false, ...(liveMove ? { liveOk: liveMove.ok } : {}),
+    ...(reviewFromCapture ? { reviewSource: 'captured-review-result' } : {}),
   });
+  // TA-LIVE-MOVE-CARD-HISTORY — live-move 수(review·propose-green·propose-land)는 실행이든 그림자든 그 카드 history 에 한 줄.
+  // 결정·실행이 끝난 «뒤»에 덧붙이기만 한다(반환값·관측 무변경) · 실패는 관측만(live-move 를 막지 않는다).
+  if (liveKind !== null) recordLiveMoveOnCard({
+    liveKind, live, liveMove, card: live ? boundCard : liveCard, runId: input.runId,
+    pr: prResult?.prNumber ?? (typeof judgeInput.pr === 'number' ? judgeInput.pr : undefined),
+    shadowDetail: move.wouldDo ?? move.reason,
+  }, deps);
   return liveMove ? { ...move, liveMove } : move;
 }
 
+/**
+ * 카드 history 에 live-move 한 줄 — 상태 파일은 카드를 읽은 곳과 같아야 한다: 주입한 경로(`live.statePath`) 또는
+ * 기본 리더를 썼을 때의 기본 경로. 주입한 카드 리더(`readCard`)만 있고 경로가 없으면 그 카드의 원장을 모른다 — 적지 않는다.
+ */
+function recordLiveMoveOnCard(
+  move: { liveKind: TaskAgentLiveMove; live: boolean; liveMove: LiveMoveResult | undefined; card: TaskCard | undefined; runId: string | null; pr: number | undefined; shadowDetail: string },
+  deps: TaskAgentShadowDeps,
+): void {
+  const log = deps.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d, { level: 'warn' }));
+  // 모든 기록 실패(경로 해석 · 시각 · 쓰기 · 카드 없음)는 이유 한 줄로 남기고, live-move 의 반환은 막지 않는다.
+  const fail = (reason: string) => {
+    try {
+      log('task-agent', 'live-move-history-failed', {
+        card: move.card?.id ?? null, kind: move.liveKind, executorResult: move.live ? 'live' : 'shadow', executed: move.liveMove?.executed ?? false, reason,
+      });
+    } catch { /* fail-soft — 관측 seam 자체가 던져도 live-move 는 계속 */ }
+  };
+  try {
+    if (!move.card) { fail('no task card bound to this move'); return; }
+    const statePath = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+    if (!statePath) { fail('card ledger unknown (injected readCard without live.statePath)'); return; }
+    const card = move.card;
+    // live 인데 실행부 결과가 없으면 «무엇이 일어났는지» 모른다 — 줄을 지어내지 않고 이유를 남긴다.
+    if (move.live && !move.liveMove) { fail('live move returned no executor result'); return; }
+    // recordLiveMoveHistory 는 쓰기 실패를 스스로 관측하고 던지지 않는다.
+    recordLiveMoveHistory(statePath, card.id, {
+      at: (deps.live?.now ?? (() => new Date()))().toISOString(),
+      kind: move.liveKind,
+      ...(move.live ? { executorResult: 'live' as const, result: move.liveMove! } : { executorResult: 'shadow' as const, shadowDetail: move.shadowDetail }),
+      runId: move.runId,
+      ...(move.pr !== undefined ? { pr: move.pr } : {}),
+      // 실행부가 받은 카드(수 «전» 읽음) — 이번 수가 새로 적은 기록만 머리로 읽는다.
+      before: { reviewRequests: card.reviewRequests, landAttempts: card.landAttempts },
+    }, deps.log ? (c, e, d) => deps.log!(c, e, d) : undefined);
+  } catch (error) {
+    fail(`record preparation failed: ${(error instanceof Error ? error.message : String(error)).slice(-250)}`);
+  }
+}
+
 /** live 수의 카드 — 성공한 결과가 없어도(수확 가능 런은 ok 가 아닐 수 있다) 결과의 taskId · 유일한 발사 문장으로 찾는다. */
-function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentShadowDeps): TaskCard | undefined {
+function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentShadowDeps, runId?: string | null): TaskCard | undefined {
   try {
     for (const result of results) {
       const found = deps.readCard ? deps.readCard(result.taskId) : readTaskCard(result.taskId, deps.live?.statePath);
@@ -260,6 +363,14 @@ function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentSha
     }
     if (deps.readCard) return undefined;
     const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.live?.statePath ?? taskAgentStatePath()).tasks ?? {};
+    // TA-LIVE-LAND-2 — a Pod run's results carry the orchestrator task id, not the card id, and its feature may be the
+    // authored goal rather than the handed sentence. `tasks hand --live` launched this process with ELANOUS_RUN_ID = the
+    // card's runId (TA-CARD-RUN-LINK); the supervisor's runId may be the Pod child's. Either id bound to exactly one card is the match.
+    const inherited = (deps.env ?? process.env)[HARNESS_RUN_ID_ENV]?.trim();
+    for (const id of new Set([runId?.trim(), inherited].filter((value): value is string => !!value))) {
+      const bound = Object.values(tasks).filter((candidate) => candidate.runId === id);
+      if (bound.length === 1) return bound[0];
+    }
     const features = new Set(results.map((result) => result.feature));
     const matches = Object.values(tasks).filter(candidate => candidate.status === 'launched' && features.has(candidate.text));
     return matches.length === 1 ? matches[0] : undefined;

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

@@ -8,8 +8,8 @@
  * - 관측: `debug.log('task-agent', 'handed', {taskId, seat, checklistId, mode})`.
  */
 import { execFileSync } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { createHash, randomBytes } from 'node:crypto';
+import { mkdirSync, readFileSync, statSync, writeFileSync, type Stats } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
 import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harness-space.js';
@@ -17,10 +17,68 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 
+export interface ResolveHandTextDeps {
+  cwd: string;
+  stat: (path: string) => Pick<Stats, 'isFile' | 'isDirectory'>;
+  readFile: (path: string, encoding: 'utf8') => string;
+}
+
+export type ResolvedHandText =
+  | { kind: 'unchanged'; text: string }
+  | { kind: 'inlined'; text: string; path: string; chars: number; sha256: string }
+  | { kind: 'rejected'; path: string; reason: '없다' | '디렉터리' | '읽기 실패' | '비었다' };
+
+function missingOrReadFailure(error: unknown): '없다' | '읽기 실패' {
+  const code = (error as NodeJS.ErrnoException | undefined)?.code;
+  return code === 'ENOENT' || code === 'ENOTDIR' ? '없다' : '읽기 실패';
+}
+
+/** 파일 판정만 한다. 관측과 카드 작성은 호출자가 결과에 따라 수행한다. */
+export function resolveHandText(text: string, deps: ResolveHandTextDeps = { cwd: process.cwd(), stat: statSync, readFile: readFileSync }): ResolvedHandText {
+  if (!text || /\s/.test(text)) return { kind: 'unchanged', text };
+  const path = resolve(deps.cwd, text);
+  const extension = /\.(?:md|markdown|txt)$/i.test(text);
+  let file: Pick<Stats, 'isFile' | 'isDirectory'>;
+  try { file = deps.stat(path); } catch (error) {
+    if (!extension) return { kind: 'unchanged', text };
+    return { kind: 'rejected', path, reason: missingOrReadFailure(error) };
+  }
+  if (!file.isFile() && !extension && !file.isDirectory()) return { kind: 'unchanged', text };
+  if (!file.isFile()) return { kind: 'rejected', path, reason: file.isDirectory() ? '디렉터리' : '읽기 실패' };
+  let content: string;
+  // stat 과 read 사이에 지워지거나 경로가 바뀌어도 사유는 같은 규칙(없다/읽기 실패)으로 가른다.
+  try { content = deps.readFile(path, 'utf8'); } catch (error) { return { kind: 'rejected', path, reason: missingOrReadFailure(error) }; }
+  const carried = content.trim();
+  if (!carried) return { kind: 'rejected', path, reason: '비었다' };
+  return { kind: 'inlined', text: content, path, chars: carried.length, sha256: createHash('sha256').update(carried).digest('hex') };
+}
+
 export const TASK_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 export type TaskSeat = typeof TASK_SEATS[number];
 /** 과제 카드 id 접두 — `task show <id>` 가 이 접두로 TOX 태스크와 갈린다. */
 export const TASK_CARD_PREFIX = 'ta-';
+/** Pod Job 의 metadata.labels 에 붙일 카드 식별자 — 원장의 카드 id 와 정확히 같아야 한다. */
+export const TASK_CARD_LABEL = 'elanous.task-card';
+/**
+ * TA-LIVE-LAND-2 — run-level marker set by `tasks hand --ta-land` on the launched `harness say`. The Pod surface
+ * (`self-implement-pod.ts`) reads it: with `taskAgent.liveMoves` ∋ `propose-land` the host re-gates without merging so
+ * the task agent's `executeLiveLand` → `pr land --expected-head` owns the land. Without propose-land it is ignored.
+ */
+export const TA_LAND_ENV = 'ELANOUS_TA_LAND';
+export interface TaskCardLabelContext {
+  cardId: string;
+  labels: Record<typeof TASK_CARD_LABEL, string>;
+}
+
+/** 카드 원장을 변경하지 않는 Pod 라벨 맥락. 정규화하면 다른 카드와 충돌할 수 있으므로 유효하지 않은 id 는 거부한다. */
+export function taskCardLabelContext(card: Pick<TaskCard, 'id'>): TaskCardLabelContext {
+  const id = card.id;
+  if (!id.startsWith(TASK_CARD_PREFIX) || id.length > 63 || !/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
+    throw new Error(`Pod 라벨에 쓸 수 없는 과제 카드 id: ${id}`);
+  }
+  return { cardId: id, labels: { [TASK_CARD_LABEL]: id } };
+}
+
 /**
  * 과제 종결 종류(RFC-loop-agent-map §A4b③) — 비면 code-pr(PR 병합)로 읽는다.
  * code-pr 밖의 종류는 «확인 증거»(`judge.ts` TaskJudgeInput.evidence)로 종결한다 — 증거를 만드는 일은 DEFAULT-HANDS 몫.
@@ -28,8 +86,22 @@ export const TASK_CARD_PREFIX = 'ta-';
 export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support'] as const;
 export type CompletionKind = typeof COMPLETION_KINDS[number];
 
-/** `run-bound`·`goal-bound`·`pr-bound` 은 runId(⊕ pr)를 싣는다 — 옛 카드의 칸은 at·event·detail 뿐이다. */
-export interface TaskCardEvent { at: string; event: string; detail?: string; runId?: string; pr?: number }
+/**
+ * `run-bound`·`goal-bound`·`pr-bound` 은 runId(⊕ pr)를 싣는다 — 옛 카드의 칸은 at·event·detail 뿐이다.
+ * TA-LIVE-MOVE-CARD-HISTORY — `live-move` 줄만 kind·executed·ok·executorResult·head·effect 를 더 싣는다(`live-move-history.ts`).
+ */
+export interface TaskCardEvent {
+  at: string; event: string; detail?: string; runId?: string; pr?: number;
+  kind?: string; executed?: boolean; ok?: boolean; executorResult?: 'shadow' | 'live'; head?: string; effect?: string;
+  /** TA-REVIEW-RESULT-CAPTURE — review live-move 줄 · 결과 줄(`live-move-result`)의 결과 파일 경로. */
+  resultPath?: string;
+  /** TA-REVIEW-RESULT-CAPTURE — `live-move-result` 줄만: 회수한 `self review --json` 의 칸(못 읽은 칸은 null). */
+  verdict?: string | null; reviewed?: boolean | null; mustFix?: number | null; reviewRoute?: string | null;
+}
+/** 카드 history 의 live-move 줄 이벤트 이름 — 상태 사유(«마지막 칸») 판정에서 뺀다. */
+export const LIVE_MOVE_HISTORY_EVENT = 'live-move';
+/** TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 리뷰의 결과(또는 «결과 없음») 줄 — live-move 줄처럼 상태 사유 판정에서 뺀다. */
+export const LIVE_MOVE_RESULT_EVENT = 'live-move-result';
 export interface TaskCardMove { kind: 'launch' | 'wait'; command?: string[]; reason: string }
 export interface TaskCard {
   id: string;
@@ -82,7 +154,38 @@ export interface TaskCard {
   /** 미션 카드만 — 모든 조각 착지 → 칸 green «제안»(체크리스트는 손대지 않는다 · OP/주인이 뒤집는다). */
   greenProposal?: { at: string; checklistId: string | null; evidence: Record<string, string> };
   /** TA-JUDGE-LIVE-SAFE — live `review` 수가 리뷰를 요청한 PR 머리들(머리마다 한 번 · 띄우기 실패면 error · 이력은 지우지 않는다). */
-  reviewRequests?: Array<{ pr: number; head: string; at: string; error?: string }>;
+  reviewRequests?: Array<{ pr: number; head: string; at: string; error?: string; /** TA-REVIEW-RESULT-CAPTURE — 자식 `--json` stdout 을 받는 파일. */ resultPath?: string }>;
+  /**
+   * TA-REJUDGE-ON-HEAD — 런 멈춤 «뒤» 머리마다 한 번 돌린 호스트 재게이트(병합 없음 · 떼어 띄움). 결과는 `resultPath` 파일에서
+   * 다음 틱이 회수해 passed·status·baseCommit·detail 을 채운다(비어 있으면 아직 도는 중 · 없는 칸을 «통과»로 읽지 않는다).
+   */
+  regates?: Array<{ pr: number; head: string; at: string; resultPath?: string; passed?: boolean; status?: string; baseCommit?: string; detail?: string }>;
+  /** Live land attempts, claimed before invocation, once per PR head even if the command fails. */
+  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string }>;
+  /** TA-LIVE-LAND-2 — `tasks hand --ta-land`: this card's run leaves the merge to the task agent (propose-land). */
+  taLand?: true;
+  /** TASKS-HAND-CHILD-LLM — `tasks hand --child-llm <provider>/<model> [--child-llm-effort <level>]` → 발사 인자 `--child-llm-provider/-model/-effort`. */
+  childLlm?: TaskChildLlm;
+}
+
+/** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 그대로 넘긴다(검증 권위는 하니스). */
+export interface TaskChildLlm { provider: string; model: string; effort?: string }
+
+/**
+ * `<provider>/<model>` 을 «첫» `/` 에서만 가른다(모델 id 가 `/` 를 담을 수 있다).
+ * openrouter 는 하니스의 모델 id 가 `openrouter/` 접두를 포함하므로(`openrouter/z-ai/glm-5.3`) 전체 문자열을 모델로 둔다
+ * (`openrouter/openrouter/…` 처럼 접두를 이미 단 입력은 두 번 붙이지 않는다).
+ */
+export function parseChildLlm(value: string, effort?: string): TaskChildLlm {
+  // 원 값 그대로 본다 — 앞뒤 공백·개행도 «잘못된 값»이다(조용히 다듬지 않는다).
+  const slash = value.indexOf('/');
+  const provider = slash < 0 ? '' : value.slice(0, slash);
+  const rest = slash < 0 ? '' : value.slice(slash + 1);
+  if (!provider || !rest || /[\s\p{Cc}]/u.test(value)) throw new Error(`--child-llm 은 <provider>/<model> 이다(예: grok/grok-4.7): ${JSON.stringify(value)}`);
+  const model = provider === 'openrouter' && !rest.startsWith('openrouter/') ? `openrouter/${rest}` : rest;
+  if (effort === undefined) return { provider, model };
+  if (!effort || /[\s\p{Cc}]/u.test(effort)) throw new Error(`--child-llm-effort 가 비었거나 공백·제어 문자를 담았다: ${JSON.stringify(effort)}`);
+  return { provider, model, effort };
 }
 
 /** 런 원장에서 묶은 PR — url 은 원장(pr-opened · Pod job-finished)에 있을 때만(지어내지 않는다). */
@@ -93,6 +196,14 @@ export function cardPrNumber(card: Pick<TaskCard, 'pr'>): number | undefined {
   return typeof card.pr === 'number' ? card.pr : card.pr?.number;
 }
 
+/** A uniquely launched code-PR card may own a draft through its PR or its opening run. */
+export function draftTaskOwner(cards: readonly TaskCard[], draft: { number: number; runId?: string | null }): TaskCard | undefined {
+  const owners = cards.filter((card) => card.status === 'launched' && (card.completion ?? 'code-pr') === 'code-pr'
+    && card.seat && (card.runId || card.runChildId) && (cardPrNumber(card) === draft.number
+      || (draft.runId && (card.runId === draft.runId || card.runChildId === draft.runId))));
+  return owners.length === 1 ? owners[0] : undefined;
+}
+
 interface TaskAgentStateFile { tasks?: Record<string, TaskCard>; [key: string]: unknown }
 
 function isGitWorkTree(path: string): boolean {
@@ -169,8 +280,11 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
 }
 
 /** 첫 수의 elanous 인자(진입점·--config-dir 앞붙임은 launcher 몫). */
-export function launchArgs(card: Pick<TaskCard, 'text' | 'seat'>): string[] {
-  return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', card.text];
+export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm'>): string[] {
+  const child = card.childLlm
+    ? ['--child-llm-provider', card.childLlm.provider, '--child-llm-model', card.childLlm.model, ...(card.childLlm.effort ? ['--child-llm-effort', card.childLlm.effort] : [])]
+    : [];
+  return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', ...child, card.text];
 }
 
 /**
@@ -184,7 +298,8 @@ 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·수확 가지 없음' };
+  // live-move 줄(관측 기록)은 실패 사유가 아니다 — 그 줄을 뺀 마지막 칸이 사유다(live-move 줄 없는 카드는 종전과 같다).
+  if (card.status === 'failed') return { kind: 'wait', reason: card.history.filter((item) => item.event !== LIVE_MOVE_HISTORY_EVENT && item.event !== LIVE_MOVE_RESULT_EVENT).at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
   return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
 }
 
@@ -193,7 +308,7 @@ export function shellQuote(arg: string): string {
 }
 
 /** 발사기에 넘기는 연결 — env(`ELANOUS_RUN_ID`)를 자식 환경에 얹으면 하니스 런이 `runId` 로 돈다(`resolveRunIdentity` 상속). launchId 는 카드에만 남는 발사 토큰이다. */
-export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string> }
+export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string>; cardLabelContext?: TaskCardLabelContext }
 /** 발사기가 «이 런 id 로 띄웠다»고 돌려주는 영수증 — 없으면 카드에 런 id 를 적지 않는다(추측하지 않는다). */
 export interface TaskLaunchReceipt {
   runId?: string;
@@ -213,6 +328,11 @@ export interface HandTaskOptions {
   goal?: string;
   milestone?: string;
   live?: boolean;
+  /** TA-LIVE-LAND-2 — `--ta-land`: card field `taLand` ⊕ launch env `ELANOUS_TA_LAND=1`. */
+  taLand?: boolean;
+  /** TASKS-HAND-CHILD-LLM — `<provider>/<model>`(`parseChildLlm`) ⊕ 선택 추론 노력. effort 만 주면 거부. */
+  childLlm?: string;
+  childLlmEffort?: string;
   statePath?: string;
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
@@ -258,6 +378,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   for (const [flag, value] of [['--goal', opts.goal], ['--milestone', opts.milestone]] as const) {
     if (value !== undefined && (!value.trim() || /\p{Cc}/u.test(value))) throw new Error(`${flag} id 가 비었거나 제어 문자를 담았다: ${JSON.stringify(value)}`);
   }
+  if (opts.childLlmEffort !== undefined && opts.childLlm === undefined) throw new Error('--child-llm-effort 는 --child-llm <provider>/<model> 과 함께 준다');
+  const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -285,6 +407,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(project ? { project } : {}),
     ...(opts.goal ? { goal: opts.goal } : {}),
     ...(opts.milestone ? { milestone: opts.milestone } : {}),
+    ...(opts.taLand === true ? { taLand: true as const } : {}),
+    ...(childLlm ? { childLlm } : {}),
     createdAt: now.toISOString(),
     status: 'handed',
     history: [],
@@ -308,12 +432,15 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (!owned.ok) throw new TaskCardSupersededError(next.id);
   };
   writeCard(path, card);
-  try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode, projectId: project?.id ?? null, targetIsGit }); } catch { /* fail-soft */ }
+  try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode, projectId: project?.id ?? null, targetIsGit, taLand: card.taLand === true }); } catch { /* fail-soft */ }
+  if (childLlm) {
+    try { debug.log('task-agent', 'child-llm', { taskId: id, input: opts.childLlm, provider: childLlm.provider, model: childLlm.model, effort: childLlm.effort ?? null, mode }); } catch { /* fail-soft */ }
+  }
   if (mode === 'shadow') return { card, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
   const runId = mintRunId();
   const launchId = `tl-${randomBytes(6).toString('hex')}`;
-  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId } };
+  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
   let receipt: void | TaskLaunchReceipt;
   try {
     receipt = await opts.launcher(move.command!, project?.target, context);

package/src/task-orchestrator/surfaces/pod-child-providers.ts

@@ -0,0 +1,29 @@
+/**
+ * POD-ANTHROPIC-PROVIDER (0.2.24) — Pod 자식이 받을 수 있는 provider 의 «한 목록».
+ *
+ * 🩸 10-10 17:36: 발사 관문은 `anthropic` 을 «예산 판정 밖 — launched as requested» 로 통과시켰고,
+ *   Pod 단계(`podNamedChildProvider`)가 «openai-codex|grok|openrouter 만» 으로 rc=2 를 냈다 — 관문과 Pod 가 서로 다른 목록을 봤다.
+ * ⭐ 이제 발사 관문(`harness ask/say --substrate pod`)과 Pod(`self-implement-pod.ts`)가 이 상수 하나를 본다.
+ *   목록 밖 provider 는 발사 «전»에 같은 문면으로 거부된다.
+ * ⛔ 이 모듈은 가볍게 둔다(무거운 import 0) — 하니스 CLI 가 Pod 표면 전체를 끌어오지 않게.
+ */
+export const POD_CHILD_PROVIDERS = ['openai-codex', 'grok', 'openrouter', 'anthropic'] as const;
+export type PodChildProvider = typeof POD_CHILD_PROVIDERS[number];
+
+/** 사람이 쓰는 별칭 → 정식 이름. */
+const POD_CHILD_PROVIDER_ALIASES: Readonly<Record<string, PodChildProvider>> = { codex: 'openai-codex' };
+
+/** 이름을 Pod 자식 provider 로 — 목록 밖이면 undefined. */
+export function podChildProviderOf(named: string | undefined): PodChildProvider | undefined {
+  const id = named?.trim();
+  if (!id) return undefined;
+  if ((POD_CHILD_PROVIDERS as readonly string[]).includes(id)) return id as PodChildProvider;
+  return POD_CHILD_PROVIDER_ALIASES[id];
+}
+
+/** 목록 밖이면 거부 문면(관문과 Pod 가 «같은» 문면을 낸다), 안이면 undefined. 이름이 비면 판정하지 않는다. */
+export function podChildProviderRefusal(named: string | undefined): string | undefined {
+  const id = named?.trim();
+  if (!id || podChildProviderOf(id)) return undefined;
+  return `pod: Pod 자식 provider 는 ${POD_CHILD_PROVIDERS.join('|')} 만 — 받음 ${id}`;
+}

package/src/task-orchestrator/surfaces/pod-command-job.ts

@@ -15,6 +15,7 @@ import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { collectPodArtifacts } from './pod-artifact-return.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
 import { podBunCacheVolume } from './pod-bun-cache.js';
+import { POD_JOB_TTL_AFTER_FINISHED_SECONDS } from './pod-lease.js';
 import { podHostDirsInit, podInstallSlotsVolume } from './pod-install-slots.js';
 import { type PodPoolMember, PodPoolScheduler, resolvePodPoolSpec, parsePodPool, checkPodPool, syncPoolImages, type PoolKubectl } from './pod-pool.js';
 import { podSkillsDigest, readSkillEnvFiles, resolvePodSkills } from './pod-skills.js';
@@ -41,8 +42,10 @@ export const POD_LITE_MEMORY_LIMIT = '2Gi';
 /** 요청은 한도를 넘을 수 없다(쿠버네티스가 Job 을 거부한다) — lite 2Gi 처럼 한도가 기본 요청보다 작으면 한도로 맞춘다. */
 /** The command Job container's CPU limit when the caller names none (GATE-SPEED A3①: unchanged default). */
 export const POD_COMMAND_CPU_LIMIT_DEFAULT = '4';
+/** 게이트 조각·pod-command 의 CPU 요청 기본 — 하니스 Pod(POD_CHILD_REQUESTS.cpu)와 따로 둔다(조각은 bun test 로 CPU 를 실제로 쓴다). */
+export const POD_COMMAND_CPU_REQUEST_DEFAULT = '1';
 
-/** Container CPU request/limit override. Omitted fields keep the defaults (request `POD_CHILD_REQUESTS.cpu` · limit 4). */
+/** Container CPU request/limit override. Omitted fields keep the defaults (request `POD_COMMAND_CPU_REQUEST_DEFAULT` · limit 4). */
 export interface PodCpu { request?: string; limit?: string }
 
 /** Kubernetes CPU quantity → millicores (`1` · `0.5` · `500m`); null when it is not a positive quantity we accept. */
@@ -55,7 +58,7 @@ export function podCpuMillis(value: string): number | null {
 
 /** Resolve a CPU override against the defaults; throws when a value is malformed or the request exceeds the limit (k8s would refuse the Job). */
 export function resolvePodCpu(cpu: PodCpu | undefined): { request: string; limit: string } {
-  const request = cpu?.request?.trim() || POD_CHILD_REQUESTS.cpu;
+  const request = cpu?.request?.trim() || POD_COMMAND_CPU_REQUEST_DEFAULT;
   const limit = cpu?.limit?.trim() || POD_COMMAND_CPU_LIMIT_DEFAULT;
   const r = podCpuMillis(request), l = podCpuMillis(limit);
   if (r === null) throw new Error(`pod cpu request is not a positive CPU quantity: ${request}`);
@@ -250,7 +253,7 @@ export function podCommandJobManifest(o: PodCommandJobInput): Record<string, unk
     metadata: { name: o.name, namespace: o.namespace, labels: { 'elanous.substrate': 'pod', 'elanous.job': o.name, 'elanous.kind': 'command', ...(o.launch ? { 'elanous.launch': o.launch } : {}) } },
     spec: {
       backoffLimit: 0,
-      ttlSecondsAfterFinished: 7200,
+      ttlSecondsAfterFinished: POD_JOB_TTL_AFTER_FINISHED_SECONDS,
       activeDeadlineSeconds: o.deadlineSeconds,
       template: {
         metadata: { labels: { 'elanous.job': o.name, 'elanous.kind': 'command', ...(o.launch ? { 'elanous.launch': o.launch } : {}) } },

package/src/task-orchestrator/surfaces/pod-failure-reason.ts

@@ -21,11 +21,25 @@ export function nestedPodResult(row: Record<string, unknown>): { stage: string;
   return { stage: result.stage, ok: false, ...(error ? { error } : {}) };
 }
 
+/** One line naming each preflight blocker (`(대상 경로 0) — …`), or '' when the row carries none. */
+function preflightBlockerText(blockers: unknown): string {
+  if (!Array.isArray(blockers)) return '';
+  return blockers.flatMap((blocker) => {
+    if (!blocker || typeof blocker !== 'object' || Array.isArray(blocker)) return [];
+    const { name, detail } = blocker as Record<string, unknown>;
+    const parts = [name, detail].filter((part): part is string => typeof part === 'string' && part.trim().length > 0).map((part) => part.trim().replace(/\s+/gu, ' '));
+    return parts.length ? [parts.join(' — ')] : [];
+  }).join(' · ');
+}
+
 /** A child terminal row: the legacy flat form {stage, ok, error?} (no kind, or a child kind) or the nested dev result. Any other kind is not a result. */
 export function podTerminalRow(row: Record<string, unknown>): { stage: string; ok: boolean; error?: string } | null {
   if (typeof row.kind === 'string' && !CHILD_RESULT_KINDS.has(row.kind)) return null;
   if (typeof row.stage === 'string' && typeof row.ok === 'boolean') {
-    return { stage: row.stage, ok: row.ok, ...(typeof row.error === 'string' ? { error: row.error } : {}) };
+    if (typeof row.error === 'string') return { stage: row.stage, ok: row.ok, error: row.error };
+    // PREFLIGHT-RESULT-LINE: `{kind:'self', ok:false, stage:'preflight-blocked', blockers}` carries its reason in the blockers, not in `error`.
+    const blockers = row.ok === false && row.stage === 'preflight-blocked' ? preflightBlockerText(row.blockers) : '';
+    return { stage: row.stage, ok: row.ok, ...(blockers ? { error: blockers } : {}) };
   }
   return nestedPodResult(row);
 }
@@ -46,7 +60,7 @@ export function extractPodFailureReason(input: {
   if (input.containerReason === 'OOMKilled') return 'OOMKilled: 컨테이너 메모리 한도 초과';
 
   const isBookkeeping = (line: string): boolean =>
-    /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] )/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
+    /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] |\[ask\]\s+\d+\)\s)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
   const isError = (line: string): boolean =>
     /\berror\b|\bfail(?:ed|ure)?\b|exception|fatal|denied|timed?\s*out|exceeded|overloaded|unavailable|exhausted|오류|실패/iu.test(line);
   const meaningful: Array<{ text: string; terminal: boolean }> = [];