elanous 0.2.37 → 0.2.40

package/src/task-agent/repair-worker.ts

@@ -22,9 +22,32 @@ export interface RepairWorkerRequest {
 
 export interface RepairWorkerResult {
   pr: number; head: string; runId: string; ok: boolean; reason?: string; moveId?: string;
+  /** A classified, stable failure only. Generic gate-failed is deliberately unsigned. */
+  failureSignature?: string;
+  /** Exact introduced test identities from the same signed gate receipt. */
+  gateFailureTests?: string[];
   job?: string; artifactDir?: string; result?: RepairCommitResult;
 }
 
+export function repairFailureSignature(output: string): string | null {
+  const gate = output.match(/^GATE_FAILURE_SIGNATURE=sha256:([a-f0-9]{64})\s*$/m);
+  if (gate) return `gate:sha256:${gate[1]}`;
+  const model = output.match(/review fallback: ambiguous or unsupported primary model ["“]([^"”\n]+)["”]/i);
+  const name = model?.[1]?.trim().toLowerCase();
+  return name && /^[a-z0-9._/-]{1,120}$/.test(name) ? `provider:ambiguous-primary:${name}` : null;
+}
+
+export function repairGateFailureTests(output: string): string[] | null {
+  const line = /^GATE_FAILURE_TESTS=(\[[^\r\n]*\])\s*$/m.exec(output)?.[1];
+  if (!line) return null;
+  try {
+    const tests: unknown = JSON.parse(line);
+    return Array.isArray(tests) && tests.length > 0 && tests.length <= 32
+      && tests.every((test) => typeof test === 'string' && test.length > 0 && test.length <= 512)
+      ? tests as string[] : null;
+  } catch { return null; }
+}
+
 export function repairHarnessArgs(request: RepairWorkerRequest): string[] {
   if (!Number.isSafeInteger(request.pr) || request.pr < 1 || !SHA40.test(request.head)
     || !request.goal.trim() || !request.runId) throw new Error('repair worker request invalid');
@@ -71,7 +94,15 @@ export async function runRepairWorker(request: RepairWorkerRequest): Promise<Rep
       child.once('close', resolve);
     });
     const marker = parseRepairMarker(output, request.pr, request.head, request.runId);
-    if (code !== 0) result.reason = `harness exited ${code}: ${output.slice(-600)}`;
+    if (code !== 0) {
+      result.reason = `harness exited ${code}: ${output.slice(-600)}`;
+      const failureSignature = repairFailureSignature(output);
+      if (failureSignature) {
+        result.failureSignature = failureSignature;
+        const tests = failureSignature.startsWith('gate:') ? repairGateFailureTests(output) : null;
+        if (tests) result.gateFailureTests = tests;
+      }
+    }
     else if (!marker) result.reason = `repair artifact marker missing or invalid: ${output.slice(-600)}`;
     else Object.assign(result, { ok: true, ...marker });
   } catch (error) {
@@ -96,6 +127,11 @@ export function parseRepairWorkerResult(text: string, pr: number, head: string,
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const v = value as RepairWorkerResult;
   if (v.pr !== pr || typeof v.head !== 'string' || v.head.toLowerCase() !== head.toLowerCase() || v.runId !== runId || typeof v.ok !== 'boolean') return null;
+  if (v.failureSignature !== undefined && (typeof v.failureSignature !== 'string'
+    || !/^(?:gate:sha256:[a-f0-9]{64}|provider:ambiguous-primary:[a-z0-9._/-]{1,120})$/.test(v.failureSignature))) delete v.failureSignature;
+  if (v.gateFailureTests !== undefined && (!v.failureSignature?.startsWith('gate:')
+    || !Array.isArray(v.gateFailureTests) || v.gateFailureTests.length < 1 || v.gateFailureTests.length > 32
+    || !v.gateFailureTests.every((test) => typeof test === 'string' && test.length > 0 && test.length <= 512))) delete v.gateFailureTests;
   if (v.ok && (typeof v.artifactDir !== 'string' || !v.artifactDir.startsWith('/') || typeof v.job !== 'string' || !v.job
     || !v.result || v.result.pr !== pr || typeof v.result.baseHead !== 'string'
     || v.result.baseHead.toLowerCase() !== head.toLowerCase() || v.result.runId !== runId || !SHA40.test(v.result.commit)

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

@@ -14,12 +14,16 @@ import { dirname, join, posix, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import { runGraph, validateUnitCalls, type GraphRunOptions, type GraphRunState } from '../graph-runner/runner.js';
+import type { GraphWizardDeps } from '../graph-wizard/generate.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';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { LAUNCH_DOOR_RECEIPT_ENV, openLaunchRequestDoor, type LaunchRequestDoor } from '../execution-loop/launch-gate.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import { checkCompletionEvidence, deliverableReceiptEvidence } from './completion-evidence.js';
 import { judgeNextMove } from './judge.js';
@@ -33,8 +37,10 @@ import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDone
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
 import { parseAskTargetPathHints, parseAskTargetPathHintsResult, type AskTargetPathHintsParseResult } from '../self-dev/launch-preflight-text.js';
-import { inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { draftMissingGoalDoneBoundary, inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
+// IMPL-FINDINGS-FEEDBACK — 병합 판정(postLand) 뒤 구현이 밝힌 절의 되먹임(원장 1회 기록·다음 저작 주입·후속 초안).
+import type { recordImplFindingsFeedback as RecordImplFindingsFeedback } from '../self-implement/impl-findings-feedback.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
 import { taskParentRoleEnv, taskParentRolePinsForChild } from './task-parent-role-llm.js';
 import { runHarvestUnit, type ReviewInvocation } from './harvest-unit.js';
@@ -180,7 +186,22 @@ export interface CompositionSelection {
 export const COMPOSITION_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
 /** 1판은 조합을 고르고 단위 해석 결과를 기록한다. 단위 실행은 2판의 몫이다. */
-export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT): CompositionSelection {
+export function selectTaskComposition(completion: CompletionKind, root?: string): CompositionSelection;
+export function selectTaskComposition(completion: CompletionKind, root: string, mission: {
+  text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+}): Promise<CompositionSelection>;
+export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT, mission?: {
+  text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+}): CompositionSelection | Promise<CompositionSelection> {
+  if (mission) {
+    const standard = selectTaskComposition(completion, root);
+    return import('../graph-wizard/mission-compose.js').then(async ({ composeMissionGraph }) => {
+      const result = await composeMissionGraph({ text: mission.text, completion, root, ledgerPath: mission.ledgerPath,
+        cardId: mission.cardId, standard }, { callLLM: mission.callLLM, deferPersistence: mission.onPersist !== undefined });
+      mission.onPersist?.(result.persist);
+      return result.selection;
+    });
+  }
   const requested = `graphs/work/${completion}.yaml`;
   // DEFAULT-HANDS — 종류별 조합이 없으면 그 손의 기본 조합(«실행·조사»)으로 내려간다.
   // 비개발 종결이 «조합 없음»으로 막히면 사람별 표본이 과제 담당에 닿지도 못한다.
@@ -282,7 +303,7 @@ export interface TaskCard {
   completion?: CompletionKind;
   /** 선택된 일 조합 파일과 판(1판: 실행은 launcher 에 위임). */
   composition?: TaskComposition;
-  graphSelectedBy?: 'completion';
+  graphSelectedBy?: 'completion' | 'mission-compose';
   unitsResolved?: boolean;
   missingUnits?: string[];
   /** 과제 대상 프로젝트(§A4b②) — target 은 절대 경로(git 이 아닐 수 있다). id 는 `task hand --project` 가 싣는다(옛 카드엔 없을 수 있다). */
@@ -384,6 +405,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 }>;
 }
@@ -779,6 +805,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 {
@@ -815,6 +858,41 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+/**
+ * IMPL-FINDINGS-FEEDBACK — 착지(landed·landed-by-hand) 판정이 난 카드의 병합 PR 본문 절을
+ * 되먹임한다: 원장 1회 기록(중복 억제) ⊕ 관련 기록만 다음 저작 입력 주입 ⊕ 후속 초안(자동 발사 없음).
+ * PR 이 묶이지 않았거나 아직 착지 판정이 아니면 아무것도 하지 않는다. 실패는 관측(`debug.log`)만.
+ */
+export async function recordPostLandImplFindings(
+  card: TaskCard,
+  input: { prBody: string; ask: string },
+  options: { ledgerDir?: string; followUp?: NonNullable<Parameters<typeof RecordImplFindingsFeedback>[1]>['followUp'] } = {},
+): Promise<Awaited<ReturnType<typeof RecordImplFindingsFeedback>> | null> {
+  const pr = cardPrNumber(card);
+  if (pr === undefined || !(card.status === 'landed' || card.status === 'landed-by-hand'
+    || (card.status === 'done' && card.prTerminal?.pr === pr))) return null;
+  if (!card.runId?.trim()) {
+    try { debug.log('task-agent', 'impl-findings-skipped', { card: card.id, pr, reason: 'run-id-missing' }); } catch { /* fail-soft */ }
+    return null;
+  }
+  try {
+    const { recordImplFindingsFeedback } = await import('../self-implement/impl-findings-feedback.js');
+    return await recordImplFindingsFeedback({
+      runId: card.runId,
+      prNumber: pr,
+      prBody: input.prBody,
+      ask: input.ask,
+      ...(card.goalId ? { goalId: card.goalId } : {}),
+    }, {
+      ...(options.ledgerDir ? { dir: options.ledgerDir } : {}),
+      ...(options.followUp ? { followUp: options.followUp } : {}),
+    });
+  } catch (error) {
+    try { debug.log('task-agent', 'impl-findings-failed', { card: card.id, pr, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+    return null;
+  }
+}
+
 /** TA-REVIEW-PASS — runId 기준 단일 카드 멱등 생성 결과. `ok: false` 는 임의 생성 없이 사유만 남긴 보류(fail-closed)다. */
 export type IdempotentRunCardCreate =
   | { ok: true; card: TaskCard; created: boolean }
@@ -876,6 +954,9 @@ export function cardsTouchingPaths(cards: readonly TaskCard[], paths: readonly s
 
 export const CLOSED_BY_HAND_EVENT = 'closed-by-hand';
 
+/** LAUNCH-SINGLE-DOOR-1C — 단일문 거절 줄 — 같은 requestId 로 이미 소비된 중복 발사를 카드 history 에 남긴다. */
+export const LAUNCH_REFUSED_DUPLICATE_EVENT = 'launch-refused-duplicate';
+
 /** 카드를 손으로 닫는다 — 상태를 `failed` 로 두고 history 에 한 줄(`closed-by-hand`)을 남긴다. 이미 손으로 닫은 카드는 그대로 돌려준다(멱등). */
 export function closeTaskCard(card: TaskCard, input: { reason: string; by: string; at: string }): TaskCard {
   const reason = input.reason.trim();
@@ -1020,6 +1101,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` 만 준다). */
@@ -1039,6 +1122,10 @@ export interface HandTaskOptions {
   statePath?: string;
   /** 시험에서만 조합 저장소를 바꿔 해석·거부를 검증한다. */
   compositionRoot?: string;
+  /** Explicit opt-in for mission graph composition; omitted is the fixed completion graph. */
+  composeGraph?: boolean;
+  /** Injectable LLM boundary for isolated composition tests. */
+  composeCallLLM?: GraphWizardDeps['callLLM'];
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
   /**
@@ -1070,6 +1157,11 @@ export interface HandTaskOptions {
    * 거짓이면 쓰지 않고 `TaskCardSupersededError` — 다른 넘김이 그 카드를 가져갔다(발사 전이면 발사하지 않는다).
    */
   writeGuard?: (current: TaskCard | undefined) => boolean;
+  /**
+   * LAUNCH-SINGLE-DOOR-1C — 발사 직전 단일문(append 요청 원장 ⊕ requestId 단위 단일 소비 영수증).
+   * 생산은 기본 문(이 우주의 인스턴스 루트)을 쓰고, 시험은 격리 루트의 문을 주입해 같은 생산 경로로 검증한다.
+   */
+  launchRequestDoor?: LaunchRequestDoor;
 }
 
 /** `writeGuard` 가 거짓 — 다른 넘김이 카드를 가져갔다. 카드는 건드리지 않았다. */
@@ -1121,6 +1213,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[] = [];
@@ -1129,6 +1222,7 @@ 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;
 }
@@ -1165,8 +1259,14 @@ function firstLinePathListViolations(hints: AskTargetPathHintsParseResult): stri
 }
 
 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);
@@ -1197,22 +1297,10 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     }, birthTags);
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
   const parentRolePins = taskParentRolePinsForChild(opts.parentRoleLlm ?? [], childLlm);
-  const parentRoleEnv = taskParentRoleEnv(parentRolePins); // validate before writing the card
+  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 으로 발사한다. 더 이상 거부하지 않는다.
-  const graphRun = selected.composition && selected.launcher === 'graph-run' && !selected.error && selected.unitsResolved
-    ? selected.composition : undefined;
-  const graphRunPath = graphRun ? join(opts.compositionRoot ?? COMPOSITION_ROOT, graphRun.file) : undefined;
-  const selectionFailure = graphRun ? undefined
-    : !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 발사는 단위 해석이 필요하다)`
-      // 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);
+  const now = (opts.now ?? (() => new Date()))();
+  const id = opts.id ?? `${TASK_CARD_PREFIX}${now.toISOString().slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -1228,8 +1316,6 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (!selection.ok) throw new Error(`코드 종결은 git 대상이 필요 — --completion 을 고르거나 git init: ${target}`);
     project = { id: opts.project.id, target: selection.repo };
   }
-  const now = (opts.now ?? (() => new Date()))();
-  const id = opts.id ?? `${TASK_CARD_PREFIX}${now.toISOString().slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
   const mode = opts.live ? 'live' : 'shadow';
   // DRAFT-CLAIM-AUTO-2-FU — claim 은 카드를 쓰기 «전»에 판정한다(거부면 원장에 아무것도 남기지 않는다).
   // 견줄 상대는 카드 원장(디스크)의 다른 카드다 — 손이 들고 있는 사본이 아니라 정본을 본다.
@@ -1239,6 +1325,25 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       ...(opts.seat !== undefined ? { seat: opts.seat } : {}), now, ask: text,
     })
     : undefined;
+  let persistComposition: (() => void) | undefined;
+  const selected = (opts.composeGraph ?? (process.env.ELANOUS_MISSION_GRAPH_COMPOSE === '1'))
+    ? await selectTaskComposition(completion, opts.compositionRoot ?? COMPOSITION_ROOT,
+      { text, ledgerPath: path, cardId: id, callLLM: opts.composeCallLLM,
+        onPersist: persist => { persistComposition = persist; } })
+    : selectTaskComposition(completion, opts.compositionRoot);
+  // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
+  const graphRun = selected.composition && selected.launcher === 'graph-run' && !selected.error && selected.unitsResolved
+    ? selected.composition : undefined;
+  const graphRunPath = graphRun ? resolve(opts.compositionRoot ?? COMPOSITION_ROOT, graphRun.file) : undefined;
+  const selectionFailure = graphRun ? undefined
+    : !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 발사는 단위 해석이 필요하다)`
+      // 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 card: TaskCard = {
     id, text,
     ...(!targetPathHints.labelMissing ? { targetPaths } : {}),
@@ -1246,7 +1351,9 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
     ...(opts.checklistVersion !== undefined ? { checklistVersion: opts.checklistVersion } : {}),
     ...(opts.completion ? { completion: opts.completion } : {}),
-    ...(selected.composition ? { composition: selected.composition, graphSelectedBy: 'completion' as const } : {}),
+    ...(selected.composition ? { composition: selected.composition,
+      graphSelectedBy: selected.composition.file === join(dirname(path), `${id}.generated.yaml`)
+        ? 'mission-compose' as const : 'completion' as const } : {}),
     unitsResolved: selected.unitsResolved,
     missingUnits: selected.missingUnits,
     ...(project ? { project } : {}),
@@ -1272,7 +1379,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}`);
@@ -1321,10 +1428,15 @@ 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) {
@@ -1339,6 +1451,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     }
   }
   writeCard(path, card);
+  if (!selectionFailure && tierSplitBlocked === undefined && move?.kind === 'launch') persistComposition?.();
   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`,
@@ -1379,7 +1492,14 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     recordLaunchUtterance({ source: 'hand', utterance: opts.text, launchId });
     let state: GraphRunState;
     try {
-      state = await (opts.graphRunner ?? runGraph)(graphRunPath, { runId, input: { ask: text }, quiet: true });
+      // Graph-run unit contracts consume all three envelope fields. `make-doc` forwards
+      // context.worktree to its headless goal loop, so preserve the card's project target
+      // when available; otherwise keep absence explicit for units that can decide safely.
+      state = await (opts.graphRunner ?? runGraph)(graphRunPath, {
+        runId,
+        input: { ask: text, context: project ? { worktree: project.target } : {}, prior: {} },
+        quiet: true,
+      });
     } catch (error) {
       // 조합 파일·대상 node가 없으면 runGraph 가 구체 사유로 던진다 — 임의 성공 처리하지 않는다.
       const reason = `graph run 실패: ${error instanceof Error ? error.message : String(error)}`;
@@ -1392,8 +1512,9 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     const at = (opts.now ?? (() => new Date()))().toISOString();
     const ok = state.status === 'done';
     // 실패 종료도 구체 blocker(종료 상태·이유·마지막 node)를 기록한다 — 임의 성공 처리하지 않는다.
+    const lastNode = state.nodes.at(-1);
     const blocker = ok ? undefined : `graph run 종료 상태 ${state.status}${state.reason ? ` — ${state.reason}` : ''}`
-      + `${state.nodes.length ? ` — 마지막 node ${state.nodes.at(-1)?.nodeId} (ok=${state.nodes.at(-1)?.ok})` : ' — node 없음'}`;
+      + `${lastNode ? ` — 마지막 node ${lastNode.nodeId} (ok=${lastNode.ok})${lastNode.failure?.message ?? lastNode.reason ?? lastNode.error ? ` — ${lastNode.failure?.errorCode ?? 'GRAPH_NODE_FAILED'}: ${lastNode.failure?.message ?? lastNode.reason ?? lastNode.error}` : ''}` : ' — node 없음'}`;
     const launchedGraph: TaskCard = { ...card, status: ok ? 'launched' : 'failed', runId: state.runId, launchId,
       history: [...card.history,
         { at, event: 'launch', detail: `graph run ${graphRunPath} (run ${state.runId})` },
@@ -1401,7 +1522,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
         ...(blocker ? [{ at, event: 'graph-run-failed', detail: blocker, runId: state.runId }] : [])] };
     writeCard(path, launchedGraph);
     try { debug.log('task-agent', 'launched', { taskId: id, seat: card.seat ?? null, runId: state.runId }); } catch { /* fail-soft */ }
-    return { card: launchedGraph, move, mode, launched: true, ...(project ? { cwd: project.target } : {}) };
+    return { card: launchedGraph, move: ok ? move : nextMoveFor(launchedGraph), mode, launched: true, ...(project ? { cwd: project.target } : {}) };
   }
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
   let prelaunch: AlreadyDoneDecision;
@@ -1419,19 +1540,85 @@ 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 knowhow = selectKnowhowPack(project?.target ?? resolve(import.meta.dir, '../..'), card.text, targetPaths);
-    if (knowhow.text) childGoal = `${knowhow.text}\n\n${card.text}`;
-    try { debug.log('task-agent', 'knowhow-pack', { taskId: id, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0 }); } catch { /* fail-soft */ }
+    const configuredRepo = project ? undefined : getUserConfig().harness?.defaultRepo;
+    const knowhowRepo = project?.target ?? configuredRepo ?? resolve(import.meta.dir, '../..');
+    const knowhow = selectKnowhowPack(knowhowRepo, card.text, targetPaths);
+    // Keep the card's target-path first line intact for launch preflight and PR title derivation.
+    const injectKnowhow = getUserConfig().harness?.knowhowChildInjection === true;
+    if (injectKnowhow && knowhow.text) childGoal = `${card.text}\n\n${knowhow.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, goal: card.text.slice(0, 4096), ids: knowhow.ids, bytes: knowhow.bytes, injected: injectKnowhow && knowhow.bytes > 0,
+      reason: knowhow.reason, repoPath: knowhowRepo, repoRevision,
+      repoSource: project ? 'project' : configuredRepo ? 'harness.defaultRepo' : 'package' }); } catch { /* fail-soft */ }
+  }
+  // LAUNCH-SINGLE-DOOR-1C — 발사 직전 단일문: 모든 요청(중복 포함)은 원장에 append 되고, 소비 영수증은
+  // requestId 단위로 최초 1회만 발급된다. 주입된 문이 없으면 생산 우주의 기본 문을 쓴다(시험 환경은 건너뛴다).
+  const launchDoor = opts.launchRequestDoor
+    ?? (process.env.NODE_ENV === 'test' ? undefined : openLaunchRequestDoor({ source: 'hand' }));
+  const launchDoorRequestId = launchDoor?.requestId(card.text);
+  let inheritedLaunchDoorReceipt: string | undefined;
+  if (launchDoor !== undefined && launchDoorRequestId !== undefined) {
+    const doorConsumption = launchDoor.consume(launchDoorRequestId);
+    if (doorConsumption.status === 'refused') {
+      const at = (opts.now ?? (() => new Date()))().toISOString();
+      const refused: TaskCard = { ...card, history: [...card.history, { at, event: LAUNCH_REFUSED_DUPLICATE_EVENT, detail: doorConsumption.reason }] };
+      writeCard(path, refused);
+      try { debug.log('task-agent', 'launch-refused-duplicate', { taskId: id, requestId: launchDoorRequestId, reason: doorConsumption.reason }); } catch { /* fail-soft */ }
+      return { card: refused, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
+    }
+    // 소비 영수증을 자식 say 에 물려줘 그 문을 다시 두드리지 않게 한다(한 번만 상속).
+    inheritedLaunchDoorReceipt = doorConsumption.status === 'consumed' ? launchDoorRequestId : undefined;
   }
   const runId = mintRunId();
   const launchId = newLaunchUtteranceId();
   recordLaunchUtterance({ source: 'hand', utterance: opts.text, launchId });
   const context: TaskLaunchContext = { runId, launchId, launchUtterance: opts.text, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id,
     ...parentRoleEnv,
+    ...(inheritedLaunchDoorReceipt !== undefined ? { [LAUNCH_DOOR_RECEIPT_ENV]: inheritedLaunchDoorReceipt } : {}),
     ...(cardPrNumber(card) ? { ELANOUS_TASK_BOUND_PR: String(cardPrNumber(card)) } : {}),
     ...(card.checklistId ? { ELANOUS_POD_SLOT_ID: card.checklistId } : {}),
     ...(card.seat ? { ELANOUS_POD_OWNER_KIND: 'seat', ELANOUS_POD_OWNER_ID: card.seat } : {}),
@@ -1445,7 +1632,12 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     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 }] };
+    // LAUNCH-SINGLE-DOOR-1C — 발사 실패 사유를 원장에 append 한다(관측 — 소비된 영수증은 그대로다).
+    if (launchDoor !== undefined && launchDoorRequestId !== undefined) launchDoor.fail(launchDoorRequestId, 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);
@@ -1462,6 +1654,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 }] : []),
     ],