elanous 0.2.36 → 0.2.38

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

@@ -16,6 +16,8 @@ import { parse as parseYaml } from 'yaml';
 import { runGraph, validateUnitCalls, type GraphRunOptions, type GraphRunState } from '../graph-runner/runner.js';
 import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
+import { getUserConfig } from '../user-config.js';
+import { readBudgetInputsLive, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harness-space.js';
 import { newLaunchUtteranceId, recordLaunchUtterance } from '../harness/launch-utterance-ledger.js';
 import { debug } from '../debug/log.js';
@@ -32,10 +34,11 @@ import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type Work
 import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDoneCandidate,
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
-import { parseAskTargetPathHints, parseAskTargetPathHintsResult } from '../self-dev/launch-preflight-text.js';
-import { inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { parseAskTargetPathHints, parseAskTargetPathHintsResult, type AskTargetPathHintsParseResult } from '../self-dev/launch-preflight-text.js';
+import { draftMissingGoalDoneBoundary, inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
-import { taskParentRoleEnv } from './task-parent-role-llm.js';
+import { taskParentRoleEnv, taskParentRolePinsForChild } from './task-parent-role-llm.js';
 import { runHarvestUnit, type ReviewInvocation } from './harvest-unit.js';
 import { TASK_CARD_PREFIX } from './task-card-prefix.js';
 
@@ -124,6 +127,43 @@ export function taskCardLabelContext(card: Pick<TaskCard, 'id'>): TaskCardLabelC
 export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support', 'deliverable'] as const;
 export type CompletionKind = typeof COMPLETION_KINDS[number];
 
+/** «실행·조사» 손의 조합 — 종결 종류별 조합이 아직 없을 때 그 손이 기본으로 쓰는 판(조사 make-doc ⊕ 확인 verify). */
+export const RUN_RESEARCH_COMPOSITION = 'graphs/work/run-research.yaml';
+
+/** 기본 손 묶음 — «개발»(자식 구현 런·PR 착지 = 코드 하니스) 또는 «실행·조사»(비코드 종결 다섯 ⊕ 콘텐츠·전달). */
+export type DefaultHand = 'develop' | 'run-research';
+
+/**
+ * DEFAULT-HANDS — 종결 종류마다 과제 담당이 기본으로 쥐는 손과 그 «확인 증거»(RFC-loop-agent-map §A4c).
+ * 기본은 «개발»이 아니라 «실행·조사»다: 마케터·산업 현장·선생님·C 레벨이 자기 일을 그대로 맡긴다.
+ * 코드 하니스(`harness-say` 자식 구현 런 · PR 착지)는 개발자 팩(`code-pr`)만 쓴다.
+ */
+export interface DefaultHandSpec {
+  hand: DefaultHand;
+  /** 확인 증거 — 종류별 판정 규칙의 이름(정본 = `completion-evidence.ts` `checkCompletionEvidence`). */
+  evidence: string;
+  /** 종류별 조합 파일이 없을 때 그 손이 기본으로 쓰는 조합. */
+  composition: string;
+  /** 코드 하니스(자식 구현 런·PR 병합)를 쓰나 — 개발자 팩 전용. */
+  codeHarness: boolean;
+}
+
+export const DEFAULT_HANDS: Record<CompletionKind, DefaultHandSpec> = {
+  'code-pr': { hand: 'develop', evidence: '구현 — PR 병합', composition: 'graphs/work/code-pr.yaml', codeHarness: true },
+  'research-report': { hand: 'run-research', evidence: '조사 — 출처 인용 보고(출처 ⊕ 반대 근거)', composition: 'graphs/work/research-report.yaml', codeHarness: false },
+  artifact: { hand: 'run-research', evidence: '산출물 — 파일 ⊕ 미리보기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  content: { hand: 'run-research', evidence: '콘텐츠 — 파일 ⊕ 미리보기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'ops-action': { hand: 'run-research', evidence: '실행 — 실행 기록 ⊕ 되읽기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'watch-brief': { hand: 'run-research', evidence: '감시·브리핑 — 일정 ⊕ 도착', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'decision-support': { hand: 'run-research', evidence: '결정 지원 — 카드 ⊕ 기록', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  deliverable: { hand: 'run-research', evidence: '전달 — 산출물 ⊕ 수신 확인', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+};
+
+/** 카드의 종결 종류가 기본으로 받는 손 — 비면 code-pr(=개발)다. */
+export function defaultHandOf(completion: CompletionKind | undefined): DefaultHand {
+  return DEFAULT_HANDS[completion ?? 'code-pr'].hand;
+}
+
 export interface TaskComposition {
   file: string;
   /** null = 파일은 있으나 파싱 실패로 판을 확인하지 못했다. */
@@ -143,13 +183,27 @@ export const COMPOSITION_ROOT = join(dirname(fileURLToPath(import.meta.url)), '.
 
 /** 1판은 조합을 고르고 단위 해석 결과를 기록한다. 단위 실행은 2판의 몫이다. */
 export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT): CompositionSelection {
-  const file = `graphs/work/${completion}.yaml`;
-  const path = join(root, file);
+  const requested = `graphs/work/${completion}.yaml`;
+  // DEFAULT-HANDS — 종류별 조합이 없으면 그 손의 기본 조합(«실행·조사»)으로 내려간다.
+  // 비개발 종결이 «조합 없음»으로 막히면 사람별 표본이 과제 담당에 닿지도 못한다.
+  let file = requested;
+  let path = join(root, file);
   let source: string;
   try { source = readFileSync(path, 'utf8'); } catch (error) {
-    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return { unitsResolved: false, missingUnits: [] };
-    return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
-      error: `조합 읽기 오류: ${file}: ${error instanceof Error ? error.message : String(error)}` };
+    const missing = (error as NodeJS.ErrnoException)?.code === 'ENOENT';
+    if (!missing) {
+      return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
+        error: `조합 읽기 오류: ${file}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const fallback = DEFAULT_HANDS[completion].composition;
+    if (fallback === requested) return { unitsResolved: false, missingUnits: [] };
+    file = fallback;
+    path = join(root, file);
+    try { source = readFileSync(path, 'utf8'); } catch (fallbackError) {
+      if ((fallbackError as NodeJS.ErrnoException)?.code === 'ENOENT') return { unitsResolved: false, missingUnits: [] };
+      return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
+        error: `조합 읽기 오류: ${file}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}` };
+    }
   }
   const parsed = parseGraphTemplateYaml(source, path);
   if (!parsed.template || parsed.errors.length) {
@@ -332,6 +386,11 @@ export interface TaskCard {
   repairs?: Array<{ pr: number; head: string; branch: string; at: string; move: string; runId: string;
     resultPath: string; fromModel: string; toModel: string; status: 'requested' | 'unconfirmed' | 'failed' | 'applied';
     detail?: string; commit?: string; bundleSha256?: string; bundlePath?: string;
+    /** Hash of exact review must-fix text at launch; old records have no comparable input. */
+    reviewSignature?: string;
+    /** Stable worker failure class; absent means retry policy remains unchanged. */
+    failureSignature?: string;
+    gateFailureTests?: string[];
     /** HARNESS-FULL-GRAPH-NEXTMOVE — next-move 결정 순간 만든 수 id. 이 칸 전 원장 줄엔 없다. */
     moveId?: string }>;
 }
@@ -727,6 +786,23 @@ export function writeTaskCards(path: string, cards: readonly TaskCard[]): void {
   });
 }
 
+/** 여러 카드의 관계 변경을 한 잠금 안에서 검사·기록한다(예: 기존 PR 결속 이동). */
+export function updateTaskCardsAtomically(path: string,
+  update: (tasks: Readonly<Record<string, TaskCard>>) => readonly TaskCard[] | undefined): TaskCard[] | undefined {
+  return withFileLockSync(`${path}.lock`, () => {
+    const disk = readState(path);
+    const current = disk.tasks ?? {};
+    const replacements = update(current);
+    if (!replacements) return undefined;
+    if (!replacements.length || replacements.some((card) => !card.id)) throw new Error('카드 원자 갱신은 id가 있는 카드가 필요하다');
+    const tasks = { ...current };
+    for (const card of replacements) tasks[card.id] = card;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...disk, tasks }));
+    return [...replacements];
+  });
+}
+
 /** 카드 하나를 잠금 안에서 읽고 고쳐 쓴다 — `update` 가 undefined 를 돌려주면 쓰지 않는다. 쓴(또는 그대로인) 카드를 돌려준다. */
 export function updateTaskCard(path: string, id: string, update: (card: TaskCard | undefined, tasks: Readonly<Record<string, TaskCard>>) => TaskCard | undefined,
   options: { doctorLedgerDir?: string } = {}): TaskCard | undefined {
@@ -763,6 +839,46 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+/** TA-REVIEW-PASS — runId 기준 단일 카드 멱등 생성 결과. `ok: false` 는 임의 생성 없이 사유만 남긴 보류(fail-closed)다. */
+export type IdempotentRunCardCreate =
+  | { ok: true; card: TaskCard; created: boolean }
+  | { ok: false; reason: string };
+
+/**
+ * TA-REVIEW-PASS — runId 기준 단일 카드 결속(멱등 생성). 단일 파일 잠금 안에서 원장을 읽어
+ * (a) 같은 runId 카드가 정확히 1건이면 그대로 재사용, (b) 0건이면 runId 해시로 재진입에 안정적인 id 를 만들어
+ * `card.runId` 를 검증된 부모 런 ID 와 정확히 일치시켜 원장에 추가한다(종전 칸·다른 카드·원장 기타 필드 보존),
+ * (c) 복수 카드·원격 Pod 자식 런·불명 runId·읽기 실패는 임의 생성하지 않고 사유를 남겨 보류한다.
+ */
+export function idempotentCreateCardForRun(path: string, input: { runId: string; text: string; now?: () => Date; env?: NodeJS.ProcessEnv }): IdempotentRunCardCreate {
+  const runId = input.runId.trim();
+  if (!runId) return { ok: false, reason: 'runId 불명 — 고유한 런 소유를 검증할 수 없어 카드를 만들지 않는다' };
+  const env = input.env ?? process.env;
+  if (env.ELANOUS_POD_NAME) return { ok: false, reason: `원격 Pod 자식 런(${env.ELANOUS_POD_NAME}) — HQ 결속만 허용한다` };
+  const at = (input.now ?? (() => new Date()))().toISOString();
+  return withFileLockSync(`${path}.lock`, (): IdempotentRunCardCreate => {
+    let disk: TaskAgentStateFile;
+    try {
+      disk = readState(path);
+    } catch (error) {
+      return { ok: false, reason: `원장 읽기 실패 — 임의 생성하지 않는다: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const tasks = { ...(disk.tasks ?? {}) };
+    const bound = Object.values(tasks).filter((candidate) => candidate.runId === runId);
+    if (bound.length === 1) return { ok: true, card: bound[0]!, created: false };
+    if (bound.length > 1) return { ok: false, reason: `runId ${runId} 카드 ${bound.length}건(모호) — 고유한 런 소유가 아니므로 결속하지 않는다` };
+    const id = `${TASK_CARD_PREFIX}run-${createHash('sha256').update(runId).digest('hex').slice(0, 12)}`;
+    if (tasks[id]) return { ok: false, reason: `카드 id ${id} 충돌 — 종전 카드를 덮어쓰지 않는다` };
+    const card: TaskCard = {
+      id, text: input.text, createdAt: at, status: 'launched', runId,
+      history: [{ at, event: 'card-created-for-run', detail: `카드 없는 runId(${runId})의 리뷰 필요 판정 — 단일 카드 멱등 결속`, runId }],
+    };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...disk, tasks: { ...tasks, [id]: card } }));
+    return { ok: true, card, created: true };
+  });
+}
+
 function canonicalTargetPaths(paths: readonly string[]): string[] {
   return [...new Set(paths.filter((path): path is string => typeof path === 'string').map((path) => posix.normalize(path))
     .filter((path) => path !== '.' && path !== '..' && !posix.isAbsolute(path)
@@ -864,6 +980,7 @@ export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm' | '
     ? ['--child-llm-provider', card.childLlm.provider, '--child-llm-model', card.childLlm.model, ...(card.childLlm.effort ? ['--child-llm-effort', card.childLlm.effort] : [])]
     : [];
   const runPriority = runIdentityQueuePriority(card.identity);
+  // Exact role model pins travel in ELANOUS_ROLE_LLM_*: harness say's argv parser only accepts provider[/tier].
   return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', ...(runPriority !== undefined ? ['--run-priority', String(runPriority)] : []), ...child, card.text];
 }
 
@@ -927,6 +1044,8 @@ export interface HandTaskOptions {
   /** TASKS-HAND-CHILD-LLM — `<provider>/<model>`(`parseChildLlm`) ⊕ 선택 추론 노력. effort 만 주면 거부. */
   childLlm?: string;
   childLlmEffort?: string;
+  /** Injected budget facts for a mission child; production reads the live launch-budget inputs just before launch. */
+  childBudgetInputs?: () => Promise<BudgetInputs> | BudgetInputs;
   parentRoleLlm?: string[];
   tier?: TaskCard['tier'];
   /** TIER-SPLIT-BEFORE-LAUNCH — 조각 카드에 싣는 분해 연결(`tier-split.ts` 만 준다). */
@@ -1028,6 +1147,7 @@ export function dispatchDeliverableCompletion(id: string, input: { ref: string;
 const GOAL_EVIDENCE_COMMAND_LINE = /^\s*(?:[-*]\s*)?완료 경계 증거 명령\s*:\s*(.*?)\s*$/;
 const GOAL_EVIDENCE_COMMAND_DESCRIPTION_SUFFIX = /->|→/;
 const GOAL_EVIDENCE_COMMAND_BACKTICK_DECORATION = /`/;
+const GOAL_EVIDENCE_COMMAND_TYPECHECK_DECORATION = /·\s*typecheck\b/i;
 
 function goalEvidenceCommandFormViolations(document: string): string[] {
   const violations: string[] = [];
@@ -1036,13 +1156,51 @@ function goalEvidenceCommandFormViolations(document: string): string[] {
     if (value === undefined || !value.trim()) continue;
     if (GOAL_EVIDENCE_COMMAND_BACKTICK_DECORATION.test(value)) violations.push(`백틱 장식: ${value}`);
     else if (GOAL_EVIDENCE_COMMAND_DESCRIPTION_SUFFIX.test(value)) violations.push(`설명 접미: ${value}`);
+    else if (GOAL_EVIDENCE_COMMAND_TYPECHECK_DECORATION.test(value)) violations.push(`설명 접미: ${value}`);
+  }
+  return violations;
+}
+
+/**
+ * FIRST-LINE-PATH-LIST-ONLY — 골 «첫 줄»의 형태 판정: `대상 경로:` 뒤의 «경로 조각» 에는 괄호·줄번호·덧말이 붙지 않는다.
+ * 첫 줄만 보는 판정은 `parseAskTargetPathHintsResult` 가 이미 하므로 새 파서를 만들지 않고 그 결과에 얹는다:
+ * 파서가 통과시킨 경로(`paths`)와 버린 조각(`rejected`)을 한 줄씩 보고, «경로 조각»(디렉터리 구분자·확장자가 있는 것)에
+ * 장식이 붙었을 때만 이유를 붙여 거부한다. `· 동작: a 고침` 같은 «산문 조각» 은 경로 조각이 아니다 —
+ * 조각 분해가 합성하는 손 문면(`handTaskWithTierSplit` 경로)이 그 모양으로 첫 줄을 만든다.
+ * 라벨이 없는 문면(첫 줄이 대상 경로 목록이 아닌 손)은 이 축의 몫이 아니다 — 그 모양은 지금과 같다.
+ */
+const FIRST_LINE_PATH_DECORATIONS: readonly { readonly label: string; readonly pattern: RegExp }[] = [
+  { label: '괄호 장식', pattern: /[()[\]{}（）【】]/ },
+  { label: '줄번호', pattern: /:\d/ },
+  { label: '덧말', pattern: /->|→|—|–/ },
+];
+
+function firstLinePathListViolations(hints: AskTargetPathHintsParseResult): string[] {
+  if (hints.labelMissing) return [];
+  const violations: string[] = [];
+  for (const piece of [...hints.paths, ...hints.rejected.map((rejection) => rejection.fragment.trim())]) {
+    if (!/[/.]/.test(piece)) continue;
+    const decoration = FIRST_LINE_PATH_DECORATIONS.find((entry) => entry.pattern.test(piece));
+    if (decoration) violations.push(`${decoration.label}: ${piece}`);
+    // 공백만으로 거부하지 않는다 — «경로 자체에 공백»(`docs/foo bar.md`)은 지금처럼 통과한다.
+    // 덧말은 공백 뒤에 «경로가 아닌 말»이 붙은 경우만이다(마지막 조각에 구분자·확장자가 없다).
+    else {
+      const trailing = piece.split(/\s+/).slice(1).join(' ').trim();
+      if (trailing !== '' && !/[/.]/.test(trailing)) violations.push(`덧말(공백 섞임): ${piece}`);
+    }
   }
   return violations;
 }
 
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
-  const text = opts.text.trim();
+  const { normalizeEvidenceCommandLines } = await import('./evidence-command-normalize.js');
+  const normalized = normalizeEvidenceCommandLines(opts.text.trim());
+  let text = normalized.text;
   if (!text) throw new Error('과제 한 줄이 비어 있다');
+  for (const warning of normalized.warnings) {
+    console.error(`⚠ ${warning}`);
+    try { debug.log('task-agent.hand', 'evidence-command-warning', { warning }); } catch { /* fail-soft */ }
+  }
   const path = opts.statePath ?? taskAgentStatePath();
   const targetPathHints = parseAskTargetPathHintsResult(text);
   const targetPaths = canonicalTargetPaths(targetPathHints.paths);
@@ -1072,7 +1230,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       launcher: 'hand',
     }, birthTags);
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
-  const parentRoleEnv = taskParentRoleEnv(opts.parentRoleLlm ?? []); // validate before writing the card
+  const parentRolePins = taskParentRolePinsForChild(opts.parentRoleLlm ?? [], childLlm);
+  let parentRoleEnv = taskParentRoleEnv(parentRolePins); // validate before writing the card
   const completion = opts.completion ?? 'code-pr';
   const selected = selectTaskComposition(completion, opts.compositionRoot);
   // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1083,8 +1242,11 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     : !selected.composition ? `조합 없음: graphs/work/${completion}.yaml`
     : selected.error ?? (selected.launcher === 'graph-run' && !selected.unitsResolved
       ? `조합 단위 미해석: ${selected.composition.file} — 대상 unit: ${selected.missingUnits.length ? selected.missingUnits.join(', ') : '해석 실패'} (graph-run 발사는 단위 해석이 필요하다)`
-      : completion !== 'code-pr' || selected.launcher !== 'harness-say'
-        ? `조합 실행기 없음: ${selected.composition.file} (발사 가능한 launcher: code-pr harness-say · graph-run)` : undefined);
+      // DEFAULT-HANDS — 코드 하니스(harness-say 자식 구현 런)는 개발자 팩(code-pr)만 쓴다.
+      : !DEFAULT_HANDS[completion].codeHarness && selected.launcher === 'harness-say'
+        ? `조합 실행기 없음: ${selected.composition.file} — ${completion} 은 «실행·조사» 손이라 코드 하니스(harness-say)를 쓰지 않는다(개발자 팩 전용)`
+        : selected.launcher === undefined
+          ? `조합 실행기 없음: ${selected.composition.file} (발사 가능한 launcher: harness-say · graph-run)` : undefined);
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -1126,7 +1288,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.milestone ? { milestone: opts.milestone } : {}),
     ...(opts.taLand === true ? { taLand: true as const } : {}),
     ...(childLlm ? { childLlm } : {}),
-    ...(opts.parentRoleLlm?.length ? { parentRoleLlm: [...opts.parentRoleLlm] } : {}),
+    ...(parentRolePins.length ? { parentRoleLlm: parentRolePins } : {}),
     ...(opts.tier ? { tier: opts.tier } : {}),
     ...(opts.tierSplit ? { tierSplit: opts.tierSplit } : {}),
     ...(identity ? { identity } : {}),
@@ -1144,7 +1306,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(draftClaim ? { draftClaim } : {}),
   };
   // 2판 graph-run 조합의 다음 수는 실제 graph run — harness say 인자를 조립하지 않는다.
-  const move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } satisfies TaskCardMove
+  let move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } satisfies TaskCardMove
     : selectionFailure ? undefined : nextMoveFor(card, opts.landed);
   // 분해 실패로 막은 카드는 wait(failed 사유)가 정답이다 — 던지지 않고 카드를 적은 뒤 발사 0 으로 돌아간다.
   if (move && move.kind !== 'launch' && tierSplitBlocked === undefined) throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
@@ -1193,20 +1355,34 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   // Injected launchers are test seams and opt in explicitly at the contract test.
   if (opts.live && opts.preflightGoalDoneBoundary && !selectionFailure && tierSplitBlocked === undefined && move?.kind === 'launch') {
     readTaskAgentState(path);
-    const { missing } = inspectGoalDoneBoundary(text);
-    if (missing.length > 0) {
-      throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.join(' · ')} — 골 문면에 완료 경계 코드·완료 경계 실물·완료 경계 증거 명령을 적은 뒤 다시 넘기세요`);
+    const drafted = draftMissingGoalDoneBoundary(text, targetPaths);
+    if (drafted.added.length > 0) {
+      text = drafted.document;
+      card = { ...card, text };
+      move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } : nextMoveFor(card, opts.landed);
+      try { debug.log('task-agent.hand', 'boundary-autodrafted', { taskId: id, labels: drafted.added, targetPathCount: targetPaths.length }); } catch { /* fail-soft */ }
     }
+    const { missing } = inspectGoalDoneBoundary(text);
+    if (missing.length > 0) throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.join(' · ')}`);
     // ENTRANCE-EVIDENCE-COMMAND-ONLY — 존재 검사와 구분된 형태 판정: 증거 명령 줄은 명령 원문만 받는다.
     const formViolations = goalEvidenceCommandFormViolations(text);
     if (formViolations.length > 0) {
       throw new Error(`goal-revision-required: 완료 경계 증거 명령은 명령 원문이어야 한다 ${formViolations.join(' · ')} — 증거 명령 줄에 설명 접미(예: → 0 fail)나 백틱 장식을 붙이지 말고 명령만 적은 뒤 다시 넘기세요`);
     }
+    // FIRST-LINE-PATH-LIST-ONLY — 첫 줄 형태 판정(발사 전 거부): 괄호·줄번호·덧말이 붙은 골은 자식을 띄우지 않는다.
+    // 카드 기록(writeCard)과 launcher 호출 뒤로 밀리면 «발사 전 거부·카드 0» 이 깨지므로 이 자리에서 던진다.
+    const firstLineViolations = firstLinePathListViolations(targetPathHints);
+    if (firstLineViolations.length > 0) {
+      try { debug.log('task-agent.hand', 'first-line-path-list-rejected', { card: id, violations: firstLineViolations }); } catch { /* fail-soft */ }
+      throw new Error(`goal-revision-required: 골 첫 줄은 «대상 경로:» 뒤에 경로 목록만 적어야 한다 ${firstLineViolations.join(' · ')} — 괄호·줄번호·덧말을 떼고 경로만 적은 뒤 다시 넘기세요`);
+    }
   }
   writeCard(path, card);
   try { debug.log('task-agent.hand', 'target-paths', { card: id, count: targetPaths.length, labelMissing: targetPathHints.labelMissing }); } catch { /* fail-soft */ }
   try { debug.log('task-agent.graph-select', !selected.composition ? 'composition-missing' : selected.error ? 'composition-invalid' : 'composition-selected', {
     completion, file: selected.composition?.file ?? `graphs/work/${completion}.yaml`,
+    // DEFAULT-HANDS — 어느 손으로 나가는지(«개발»/«실행·조사»)와 코드 하니스 여부를 선택 관측에 싣는다.
+    hand: DEFAULT_HANDS[completion].hand, codeHarness: DEFAULT_HANDS[completion].codeHarness,
     unitsResolved: selected.unitsResolved, missingUnits: selected.missingUnits,
     ...(selected.error ? { error: selected.error } : {}),
   }); } catch { /* fail-soft */ }
@@ -1282,6 +1458,59 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     writeCard(path, candidate);
     return { card: candidate, move: nextMoveFor(candidate), mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   }
+  // A mission parent can carry its original explicit child model into later pieces. Recheck that model
+  // immediately before each launch; an exhausted provider must not pin every following child to the same stop.
+  if (opts.mission && card.childLlm && (card.childLlm.provider === 'grok' || card.childLlm.provider === 'openai-codex')) {
+    let inputs: BudgetInputs | undefined;
+    try { inputs = await (opts.childBudgetInputs ?? readBudgetInputsLive)(); }
+    catch (error) {
+      try { debug.log('task-agent', 'child-model-reselect-unavailable', { taskId: id,
+        reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' }); }
+      catch { /* observation is fail-soft */ }
+    }
+    if (inputs) {
+      const { harnessLaunchBudgetDecision } = await import('../execution-loop/launch-gate.js');
+      const current = harnessLaunchBudgetDecision(inputs, { childLlmProvider: card.childLlm.provider,
+        childLlmModel: card.childLlm.model }).decision;
+      if (current.action === 'stop' || current.action === 'wait-reset') {
+        const alternatives = inputs.preference.chain.filter((slot) => slot.provider !== card.childLlm!.provider);
+        const next = alternatives.map((slot) => harnessLaunchBudgetDecision(inputs, {
+          childLlmProvider: slot.provider, ...(slot.model ? { childLlmModel: slot.model } : {}),
+        }).decision).find((decision) => decision.action === 'proceed' || decision.action === 'next-provider');
+        if (next?.provider) {
+          const from = card.childLlm;
+          const model = next.model ?? (await import('../self-dev/dev-cli.js')).defaultChildLlmModel(next.provider);
+          const to: TaskChildLlm = { provider: next.provider, model };
+          const nextParentRoleEnv = taskParentRoleEnv(taskParentRolePinsForChild(opts.parentRoleLlm ?? [], to));
+          const at = (opts.now ?? (() => new Date()))().toISOString();
+          card = { ...card, childLlm: to, history: [...card.history, { at, event: 'child-model-reselected',
+            detail: `${from.provider}/${from.model} → ${to.provider}/${to.model}: ${current.reasons.join(' · ')}` }] };
+          parentRoleEnv = nextParentRoleEnv;
+          move = { ...move!, command: launchArgs(card) };
+          writeCard(path, card);
+          try { debug.log('task-agent', 'child-model-reselected', { taskId: id, from, to, reason: current.reasons, mission: opts.mission }); }
+          catch { /* observation is fail-soft */ }
+        }
+      }
+    }
+  }
+  // Only the code-PR harness Pod consumes podGoal. Keep the card and other launchers unchanged.
+  const podLaunch = completion === 'code-pr' && selected.launcher === 'harness-say';
+  let childGoal = card.text;
+  if (podLaunch) {
+    const configuredRepo = project ? undefined : getUserConfig().harness?.defaultRepo;
+    const knowhowRepo = project?.target ?? configuredRepo ?? resolve(import.meta.dir, '../..');
+    const knowhow = selectKnowhowPack(knowhowRepo, card.text, targetPaths);
+    if (knowhow.text) childGoal = `${knowhow.text}\n\n${card.text}`;
+    let repoRevision: string | null = null;
+    try {
+      const head = execFileSync('git', ['-C', knowhowRepo, 'rev-parse', '--verify', 'HEAD'], { encoding: 'utf8', timeout: 10_000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+      if (/^[0-9a-f]{40,64}$/i.test(head)) repoRevision = head;
+    } catch { /* The source may be absent; reason=source-unreadable records that boundary. */ }
+    try { debug.log('task-agent', 'knowhow-pack', { taskId: id, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0,
+      reason: knowhow.reason, repoPath: knowhowRepo, repoRevision,
+      repoSource: project ? 'project' : configuredRepo ? 'harness.defaultRepo' : 'package' }); } catch { /* fail-soft */ }
+  }
   const runId = mintRunId();
   const launchId = newLaunchUtteranceId();
   recordLaunchUtterance({ source: 'hand', utterance: opts.text, launchId });
@@ -1294,13 +1523,16 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     // An omitted card provider uses the established Pod default. Carry the effective value explicitly so
     // remote-parent code never has to infer a provider from the serialized CLI argv.
     effectiveChildProvider: card.childLlm?.provider ?? 'openai-codex',
-    ...(completion === 'code-pr' && selected.launcher === 'harness-say' ? { substrate: 'pod' as const, podGoal: card.text } : {}) };
+    ...(podLaunch ? { substrate: 'pod' as const, podGoal: childGoal } : {}) };
   let receipt: void | TaskLaunchReceipt;
   try {
-    receipt = await opts.launcher(move.command!, project?.target, context);
+    receipt = await opts.launcher(podLaunch ? [...move.command!.slice(0, -1), childGoal] : move.command!, project?.target, context);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    const failed: TaskCard = { ...card, status: 'launch-failed', history: [{ at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason }] };
+    const failed: TaskCard = { ...card, status: 'launch-failed', history: [
+      ...card.history.filter((entry) => entry.event === 'child-model-reselected'),
+      { at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason },
+    ] };
     writeCard(path, failed);
     try { debug.log('task-agent', 'launch-failed', { taskId: id, seat: card.seat ?? null, reason }); } catch { /* fail-soft */ }
     throw new TaskLaunchError(failed, reason);
@@ -1317,6 +1549,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(boundRunId ? { runId: boundRunId, launchId } : {}),
     ...(receipt && receipt.parentHost && typeof receipt.parentHost.host === 'string' ? { parentHost: receipt.parentHost } : {}),
     history: [
+      ...card.history.filter((entry) => entry.event === 'child-model-reselected'),
       { 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 }] : []),
     ],

package/src/task-agent/task-parent-role-llm.ts

@@ -34,3 +34,12 @@ export function taskParentRoleEnv(values: readonly string[]): Record<string, str
   }
   return env;
 }
+
+/** A child model also powers planning unless the caller pinned planning explicitly. */
+export function taskParentRolePinsForChild(
+  values: readonly string[], child?: { provider: string; model: string },
+): string[] {
+  const env = taskParentRoleEnv(values);
+  if (!child || env[roleLlmEnvName('planning')] !== undefined) return [...values];
+  return [...values, `planning=${JSON.stringify({ provider: child.provider, model: child.model })}`];
+}

package/src/task-agent/tier-split.ts

@@ -30,9 +30,38 @@ export const TIER_SPLIT_DECOMPOSE_TIMEOUT_MS = 300_000;
 
 /** 조각이 부모 칸에서 물려받는 줄 머리 — hand 의 골 검사(완료 경계 셋)와 계약·경계 문맥. */
 const INHERITED_PARENT_LABELS = /^\s*(?:[-*]\s*)?(현재 계약|완료 경계 코드|완료 경계 실물|완료 경계 증거 명령|경계|증거 보충)\s*:/;
+const VERIFICATION_PLAN_HEADING = '### 검증 계획(TDD)';
+
+/** Read a real Markdown section, ignoring headings inside fenced verbatim asks. */
+function parentVerificationPlan(text: string): string[] {
+  const lines = text.split(/\r?\n/u);
+  let fence: { char: string; length: number } | null = null;
+  let start = -1;
+  const section: string[] = [];
+  for (const [index, line] of lines.entries()) {
+    const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+    if (marker) {
+      if (!fence) fence = { char: marker[0]!, length: marker.length };
+      else if (marker[0] === fence.char && marker.length >= fence.length) fence = null;
+      if (start >= 0 && fence) break;
+      continue;
+    }
+    if (fence) continue;
+    if (start < 0) {
+      if (line.trim() === VERIFICATION_PLAN_HEADING) {
+        start = index;
+        section.push(line);
+      }
+      continue;
+    }
+    if (/^ {0,3}#{1,6}\s/u.test(line)) break;
+    section.push(line);
+  }
+  return section;
+}
 
 /**
- * 조각 hand 문면 = 조각 골(대상 경로·동작 — 첫 줄 유지) ⊕ 조각 표지 ⊕ 부모 칸의 계약·완료 경계·경계 줄.
+ * 조각 hand 문면 = 조각 골(대상 경로·동작 — 첫 줄 유지) ⊕ 조각 표지 ⊕ 부모 칸의 계약·완료 경계·경계 줄·TDD 계획.
  * 분해기의 조각 골은 짧은 제목뿐이라 그대로 넘기면 hand 의 골 검사(완료 경계 누락)가 막는다(10-21 DEVICE-FIRST-AUTHORING 발사 0).
  * 부모에 그 줄이 없으면 아무것도 더하지 않는다 — 검사가 지금처럼 거부한다(보수 쪽).
  */
@@ -43,10 +72,15 @@ export function composeSliceHandText(sliceGoal: string, parentText: string, mark
     const label = INHERITED_PARENT_LABELS.exec(line)?.[1];
     return label !== undefined && !sliceHas.has(label);
   });
-  // The slice marker also carries review scope. Device slices now own their
-  // completion boundary, so inherited can be empty while the marker is needed.
+  const sliceHasVerificationPlan = sliceLines.some((line) => line.trim() === VERIFICATION_PLAN_HEADING);
+  const verificationPlan = sliceHasVerificationPlan ? [] : parentVerificationPlan(parentText);
+  inherited.push(...verificationPlan);
+  // 표지는 리뷰 범위를 나르므로 장치 우선 조각(총 2 이상)은 상속 줄이 없어도 남는다 —
+  // 다만 «물려받았다» 는 물려받은 줄에 대한 주장이므로 그 줄이 있을 때만 붙인다.
   if (inherited.length === 0 && (marker.total < 2 || !sliceGoal.includes(`동작: ${DEVICE_FIRST_STEP}`))) return sliceGoal;
-  const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫. 아래 계약·완료 경계는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.`;
+  const inheritedTopics = `계약·완료 경계${verificationPlan.length > 0 ? '·검증 계획' : ''}`;
+  const inheritanceClaim = inherited.length > 0 ? ` 아래 ${inheritedTopics}는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.` : '';
+  const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫.${inheritanceClaim}`;
   return [...sliceLines, tag, ...inherited].join('\n');
 }
 
@@ -180,7 +214,8 @@ export async function handTaskWithTierSplit(opts: TierSplitHandOptions): Promise
         markFirstLaunchFailure(reason);
       }
     }
-    record({ cid, fromTier, outcome: 'device-first-deferred', group, first: ids[0], blockedUntilLanded: ids.slice(1) });
+    record({ cid, fromTier, outcome: 'device-first-deferred', group, first: ids[0], blockedUntilLanded: ids.slice(1),
+      unavoidable: [...unavoidable], ...counts });
     return { kind: 'split', group, fromTier, slices };
   }
   for (const [index, slice] of plan.slices.entries()) {

package/src/task-agent/work-order.ts

@@ -11,7 +11,8 @@
  *   4. 판정 신호(`verdictSignal` — 조건·관측·기대) ⊕ 현재 계약 한 줄(`contract`)
  *   5. 경계(`boundary` — 대상 경로 · 건드리지 말 곳)
  *   6. 예산(`budget` — 시간 · 모델 티어 · Pod 자리 · 재작업 상한)
- *   7. 선행·짝 칸(`peers`)
+ *   7. 선행·짝 칸(`peers`) — 항목마다 조회된 상태(`state`)와 조회 시각(`observedAt`)을 보존한다
+ *      (칸 이름만으로는 발사 시점의 상태를 알 수 없다 · 조회하지 않은 항목은 «모름»).
  *   8. 선례 묶음(`precedents` — 같은 칸 앞 생애 결말·must-fix 서명)
  *   9. 올림 규칙(`escalation` — 무엇이면 누구에게 · 돈·보안은 대표)
  *
@@ -50,6 +51,21 @@ export interface WorkOrder {
   escalation: string;
   /** 입력에 없어 «모름»으로 채운 키. */
   unknownFields: string[];
+  /**
+   * 선행 항목별 관측 — 지시서가 선행을 배열로 적었을 때만 있다(문자열 한 줄이면 종전 그대로 없다).
+   * 항목마다 조회된 상태와 그 상태를 조회한 시각을 보존하고, 조회하지 않은 값은 «모름»이다.
+   */
+  dependencies?: WorkOrderDependency[];
+}
+
+/** 선행 칸 하나의 관측 — 칸 이름 ⊕ 조회된 상태 ⊕ 그 상태를 본 시각. */
+export interface WorkOrderDependency {
+  /** 선행 칸 id(또는 칸 이름). */
+  cell: string;
+  /** 조회된 상태(yellow·green·red …) — 조회하지 않았으면 «모름». */
+  state: string;
+  /** 상태를 조회한 시각(ISO 8601) — 조회하지 않았으면 «모름». */
+  observedAt: string;
 }
 
 export type ParseWorkOrderResult = { ok: true; order: WorkOrder } | { ok: false; reason: string };
@@ -63,6 +79,26 @@ function cellText(value: unknown): string {
   catch { return WORK_ORDER_UNKNOWN; }
 }
 
+/**
+ * 선행 칸을 항목별 관측으로 읽는다 — 배열 원소가 객체면 `state`·`observedAt` 을 보존하고,
+ * 이름만 적힌 항목(문자열 등)은 조회하지 않은 것이므로 상태·시각 모두 «모름»으로 둔다.
+ * 선행 칸이 배열이 아니면(문자열 한 줄·없음) 항목 목록은 비어 있다 — 종전 문면 그대로다.
+ */
+function parseDependencies(value: unknown): WorkOrderDependency[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      const record = item as Record<string, unknown>;
+      return {
+        cell: cellText(record['cell'] ?? record['cellId']),
+        state: cellText(record['state']),
+        observedAt: cellText(record['observedAt']),
+      };
+    }
+    return { cell: cellText(item), state: WORK_ORDER_UNKNOWN, observedAt: WORK_ORDER_UNKNOWN };
+  });
+}
+
 /**
  * 지시서 JSON 원문을 검증한다. 깨진 JSON 은 `JSON 이 깨졌다: …`, 칸 id(문자열)가 없으면 `칸 id 가 없다`
  * 하나로 거부하고, 그 밖의 빠진 칸은 «모름»으로 채운다(거부 아님).
@@ -84,7 +120,21 @@ export function parseWorkOrder(source: string): ParseWorkOrderResult {
     if (value == null || (typeof value === 'string' && !value.trim())) unknownFields.push(field);
     cells[field] = text;
   }
-  return { ok: true, order: { cellId: rawCellId.trim(), ...cells, unknownFields } };
+  const dependencies = parseDependencies(record['peers']);
+  return {
+    ok: true,
+    order: {
+      cellId: rawCellId.trim(), ...cells,
+      ...(dependencies.length ? { dependencies } : {}),
+      unknownFields,
+    },
+  };
+}
+
+/** 선행 항목별 «상태 ⊕ 조회 시각» 한 줄 — 이름만 있는 항목은 «모름 (관측 모름)»으로 드러난다. */
+function renderDependencies(dependencies: WorkOrderDependency[]): string {
+  const items = dependencies.map((dep) => `${dep.cell}=${dep.state} (관측 ${dep.observedAt})`);
+  return `선행 상태: ${items.join(' · ')}`;
 }
 
 /** 검증된 지시서를 사람이 읽는 골 문면으로 펼친다 — 첫 줄 «대상 경로:»(경계), 둘째 줄 «현재 계약:». */
@@ -99,6 +149,7 @@ export function renderWorkOrderGoal(order: WorkOrder): string {
     `판정 신호: ${order.verdictSignal}`,
     `예산: ${order.budget}`,
     `선행·짝 칸: ${order.peers}`,
+    ...(order.dependencies?.length ? [renderDependencies(order.dependencies)] : []),
     `선례: ${order.precedents}`,
     `올림 규칙: ${order.escalation}`,
   ].join('\n');