elanous 0.2.38 → 0.2.41

package/src/task-agent/postland-card.ts

@@ -2,10 +2,10 @@ import { spawnSync } from 'node:child_process';
 import { debug } from '../debug/log.js';
 import { listChecklist, setItemIfSnapshot, type Checklist } from '../release-loop/checklist.js';
 import { judgeLandedCell, parseJudgeSignals, type GreenVerdict } from '../release-loop/landed-to-green.js';
-import { HAND_MOVE_HISTORY_EVENT, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, cardPrNumber, readTaskAgentState, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
+import { HAND_MOVE_HISTORY_EVENT, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, cardPrNumber, readTaskAgentState, taskAgentStatePath, updateTaskCard, recordPostLandImplFindings, type TaskCard } from './task-hand.js';
 import { isGoalOnlyPr } from './judge.js';
 
-export interface LandedTaskPr { number: number; url: string; headRefOid: string; state: string; baseRefName: string; mergedAt: string; files?: Array<{ path: string }> }
+export interface LandedTaskPr { number: number; url: string; headRefOid: string; state: string; baseRefName: string; mergedAt: string; body?: string | null; files?: Array<{ path: string }> }
 export interface PostlandDeps {
   statePath?: string;
   versions: readonly string[];
@@ -144,6 +144,39 @@ export function closeMergedTaskCard(pr: LandedTaskPr, cwd: string, deps: Postlan
   return item.id;
 }
 
+/** Awaited postland feedback for the confirmed merge caller; card+PR URL/head must still bind exactly. */
+export async function recordMergedTaskImplFindings(
+  pr: LandedTaskPr,
+  cwd: string,
+  options: { statePath?: string; ledgerDir?: string; followUp?: NonNullable<Parameters<typeof recordPostLandImplFindings>[2]>['followUp'] } = {},
+): Promise<Awaited<ReturnType<typeof recordPostLandImplFindings>> | null> {
+  if (pr.state !== 'MERGED' || pr.baseRefName !== 'main' || !pr.url || !pr.headRefOid || pr.body == null) return null;
+  const path = options.statePath ?? taskAgentStatePath();
+  const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(path).tasks ?? {};
+  const cards = Object.values(tasks).filter((card) => card.taLand && cardPrNumber(card) === pr.number
+    && typeof card.pr === 'object' && card.pr.url?.replace(/\/+$/, '') === pr.url!.replace(/\/+$/, '')
+    && card.status === 'done' && card.prTerminal?.pr === pr.number
+    && card.prTerminal.head.toLowerCase() === pr.headRefOid!.toLowerCase()
+    && card.prTerminal.url.replace(/\/+$/, '') === pr.url!.replace(/\/+$/, '')
+    && (card.landAttempts ?? []).some((attempt) => attempt.pr === pr.number && attempt.head.toLowerCase() === pr.headRefOid!.toLowerCase()));
+  if (cards.length !== 1) {
+    debug.log('task-agent', 'impl-findings-skipped', { pr: pr.number, reason: cards.length ? 'ambiguous-postland-card' : 'postland-card-not-bound' });
+    return null;
+  }
+  const card = cards[0]!;
+  const result = await recordPostLandImplFindings(card, { prBody: pr.body, ask: card.text }, {
+    ...(options.ledgerDir ? { ledgerDir: options.ledgerDir } : {}),
+    ...(options.followUp ? { followUp: options.followUp } : {}),
+  });
+  debug.log('task-agent', 'impl-findings-postland-result', {
+    pr: pr.number, card: card.id, appended: result?.appended ?? false,
+    lessonIds: result?.lessonIds ?? [], injectedSections: result?.injectedSections ?? [], skippedSections: result?.skippedSections ?? [],
+    authoringInjectionBytes: result ? Buffer.byteLength(result.authoringInjection, 'utf8') : 0,
+    followUp: result?.followUp?.queued ?? null,
+  });
+  return result;
+}
+
 const defaultGit = (cwd: string, args: string[]): { status: number; stdout: string; stderr: string } => {
   const run = spawnSync('git', args, { cwd, encoding: 'utf8' });
   return { status: run.status ?? 1, stdout: run.stdout ?? '', stderr: run.stderr ?? '' };

package/src/task-agent/rejudge-on-head.ts

@@ -45,14 +45,14 @@ import { remoteLedgerMirrorDir } from './parent-host.js';
 import { appendLandOrderRow, joinLandOrderRow } from './land-order-ledger.js';
 import { recordLiveMoveHistory } from './live-move-history.js';
 import { advanceLandedPieceMission } from './mission.js';
-import { runRepairCycle, type RepairLaunchRequest } from './repair-cycle.js';
+import { runRepairCycle, resolveRepairOwner, type RepairLaunchRequest } from './repair-cycle.js';
 import { repairMustFixFromReview, repairReviewDigest } from './repair-review.js';
 import type { RepairCasOutcome, RepairCasRequest } from './repair-branch-cas.js';
 import { configuredMsb1Worker, defaultLandPrHead, defaultPrHead, defaultReviewRepoCandidates, executeLiveLand, executeLiveReview, landRetryPending, remoteTaWorkerCommand, type LiveMoveDeps, type LiveMoveResult, type PrHeadView, type ReviewRepoCandidate, type TaskAgentLiveMove } from './live-moves.js';
 import { capturedLandReview, captureReviewResults, parseReviewResultOutput, pendingReviewResults, reviewResultPath, type ParsedReviewResult } from './review-result-capture.js';
 import { boundPrTerminal, cardPrNumber, LIVE_MOVE_RESULT_EVENT, readTaskCard, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 import { verifiedTrainLanding, type TrainLanding } from './train-landing.js';
-import { isGoalOnlyPr } from './judge.js';
+import { isGoalOnlyPr, judgeEmptyImplementation } from './judge.js';
 import { defaultPrFiles } from './shadow.js';
 
 export const REJUDGE_ON_HEAD_EVENT = 'rejudge-on-head';
@@ -671,6 +671,50 @@ export async function rejudgeCardOnHead(cardId: string, deps: RejudgeDeps): Prom
         step('repair', 'repair-stopped', 'PR branch name unavailable', true);
         return outcomes;
       }
+      // 빈 구현 must-fix — 같은 PR 수리(narrow-relaunch)로는 수렴하지 않는다: 첫 회는 같은 칸 새 발사(시험 먼저), 두 번째는 칸 주인 이관.
+      const priorEmpty = (card.history ?? []).filter((entry) => entry.event === REJUDGE_ON_HEAD_EVENT && entry.kind === 'repair'
+        && (entry.effect === 'empty-implementation-reimplement' || entry.effect === 'empty-implementation-needs-owner')).length;
+      const emptyJudgement = mustFix?.length ? judgeEmptyImplementation(mustFix, priorEmpty) : null;
+      if (emptyJudgement) {
+        if (emptyJudgement.move === 'needs-owner') {
+          let ownerSeat: string | null = card.seat ?? null;
+          try {
+            const owner = resolveRepairOwner(card);
+            if (owner?.seat) ownerSeat = owner.seat;
+          } catch { /* 결정 실패 시 칸 좌석을 유지한다 */ }
+          if (ownerSeat) {
+            try {
+              (deps.notifyRepair ?? (() => {}))(ownerSeat,
+                `빈 구현 needs-owner: 칸 ${card.id} PR #${pr} head ${toHead.slice(0, 12)} — ${emptyJudgement.reason} · 칸 주인이 재구현 지시를 결정한다`);
+            } catch { /* 통보 실패가 이관을 막지 않는다 */ }
+          }
+          const handedOver = updateTaskCard(statePath, card.id, (current) => {
+            if (!current) return undefined;
+            if ((current.history ?? []).some((entry) => entry.event === REJUDGE_ON_HEAD_EVENT && entry.kind === 'repair'
+              && entry.pr === pr && entry.head && sameHead(entry.head, toHead) && entry.effect === 'empty-implementation-needs-owner')) return current;
+            return { ...current, status: 'failed',
+              history: [...(current.history ?? []), { at: now().toISOString(), event: 'pr-superseded-candidate', kind: 'repair', pr,
+                ...(toHead ? { head: toHead } : {}), effect: 'superseded-candidate',
+                detail: `빈 구현 needs-owner — 옛 PR #${pr} 은 superseded 후보` }] };
+          });
+          if (handedOver) step('repair', 'empty-implementation-needs-owner',
+            `${emptyJudgement.reason} · 칸 주인 ${ownerSeat ?? 'unknown'} 이관 · 옛 PR #${pr} superseded 후보`, true);
+          return outcomes;
+        }
+        const relaunched = updateTaskCard(statePath, card.id, (current) => {
+          if (!current) return undefined;
+          if ((current.history ?? []).some((entry) => entry.event === REJUDGE_ON_HEAD_EVENT && entry.kind === 'repair'
+            && entry.pr === pr && entry.head && sameHead(entry.head, toHead) && entry.effect === 'empty-implementation-reimplement')) return current;
+          return { ...current, status: 'launch-failed',
+            text: `${current.text}\n- 재구현 지시(빈 구현 판정): 시험 먼저 — 구현 전에 실패하는 시험(RED)을 먼저 쓰고 구현 파일 변경 0이 되지 않게 한다.`,
+            history: [...(current.history ?? []), { at: now().toISOString(), event: 'pr-superseded-candidate', kind: 'repair', pr,
+              ...(toHead ? { head: toHead } : {}), effect: 'superseded-candidate',
+              detail: `빈 구현 재구현 — 옛 PR #${pr} 은 superseded 후보` }] };
+        });
+        if (relaunched) step('repair', 'empty-implementation-reimplement',
+          `${emptyJudgement.reason} · 같은 칸 새 발사(시험 먼저) · 옛 PR #${pr} superseded 후보`, true);
+        return outcomes;
+      }
       const result = await runRepairCycle({ card, statePath, repo: cwd, pr, head: toHead, branch: view.branch,
         mustFix: mustFix ?? [], liveMoves: deps.liveMoves, now: now(), readFile: read,
         ...(deps.requestRepair ? { request: deps.requestRepair } : {}),

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

@@ -532,7 +532,7 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
     else {
       passJourneyNode('next-move', { provenance: 'task-agent-repair', outcome: judged.judgement.move, runId,
         data: { card: card.id, source: `pr:${pr}`, pr, head, branch, mustFix: input.mustFix, moveId } });
-      recordJourneyEdge(judged.route, 'dispatch', undefined, { moveId });
+      recordJourneyEdge(judged.route, 'dispatch', undefined, { moveId, runId, card: card.id, pr, head });
     }
   } catch (error) {
     const detail = `repair observation failed after worker launch: ${error instanceof Error ? error.message : String(error)}`;

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

@@ -14,6 +14,7 @@ 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';
@@ -22,6 +23,7 @@ import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harnes
 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';
@@ -37,10 +39,13 @@ import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseC
 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';
+// 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';
 import { TASK_CARD_PREFIX } from './task-card-prefix.js';
+import { childLlmEffortProblem } from '../intelligence-map/model-catalog.js';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -182,7 +187,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 — 종류별 조합이 없으면 그 손의 기본 조합(«실행·조사»)으로 내려간다.
   // 비개발 종결이 «조합 없음»으로 막히면 사람별 표본이 과제 담당에 닿지도 못한다.
@@ -284,7 +304,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` 가 싣는다(옛 카드엔 없을 수 있다). */
@@ -395,7 +415,7 @@ export interface TaskCard {
     moveId?: string }>;
 }
 
-/** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 그대로 넘긴다(검증 권위는 하니스). */
+/** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 넘긴다. */
 export interface TaskChildLlm { provider: string; model: string; effort?: string }
 
 /**
@@ -412,6 +432,8 @@ export function parseChildLlm(value: string, effort?: string): TaskChildLlm {
   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)}`);
+  const problem = childLlmEffortProblem(model, effort);
+  if (problem) throw new Error(problem);
   return { provider, model, effort };
 }
 
@@ -839,6 +861,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 }
@@ -900,6 +957,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();
@@ -1065,6 +1125,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;
   /**
@@ -1096,6 +1160,11 @@ export interface HandTaskOptions {
    * 거짓이면 쓰지 않고 `TaskCardSupersededError` — 다른 넘김이 그 카드를 가져갔다(발사 전이면 발사하지 않는다).
    */
   writeGuard?: (current: TaskCard | undefined) => boolean;
+  /**
+   * LAUNCH-SINGLE-DOOR-1C — 발사 직전 단일문(append 요청 원장 ⊕ requestId 단위 단일 소비 영수증).
+   * 생산은 기본 문(이 우주의 인스턴스 루트)을 쓰고, 시험은 격리 루트의 문을 주입해 같은 생산 경로로 검증한다.
+   */
+  launchRequestDoor?: LaunchRequestDoor;
 }
 
 /** `writeGuard` 가 거짓 — 다른 넘김이 카드를 가져갔다. 카드는 건드리지 않았다. */
@@ -1233,20 +1302,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   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 으로 발사한다. 더 이상 거부하지 않는다.
-  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) {
@@ -1262,8 +1319,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 은 카드를 쓰기 «전»에 판정한다(거부면 원장에 아무것도 남기지 않는다).
   // 견줄 상대는 카드 원장(디스크)의 다른 카드다 — 손이 들고 있는 사본이 아니라 정본을 본다.
@@ -1273,6 +1328,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 } : {}),
@@ -1280,7 +1354,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 } : {}),
@@ -1378,6 +1454,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`,
@@ -1418,7 +1495,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)}`;
@@ -1431,8 +1515,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})` },
@@ -1440,7 +1525,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;
@@ -1501,21 +1586,42 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     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}`;
+    // 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, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0,
+    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 } : {}),
@@ -1529,6 +1635,8 @@ 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);
+    // 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 },

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

@@ -30,6 +30,7 @@ export const TIER_SPLIT_DECOMPOSE_TIMEOUT_MS = 300_000;
 
 /** 조각이 부모 칸에서 물려받는 줄 머리 — hand 의 골 검사(완료 경계 셋)와 계약·경계 문맥. */
 const INHERITED_PARENT_LABELS = /^\s*(?:[-*]\s*)?(현재 계약|완료 경계 코드|완료 경계 실물|완료 경계 증거 명령|경계|증거 보충)\s*:/;
+const PARENT_ACCEPTANCE_LABEL = /^\s*(?:[-*]\s*)?(수용선|판정|완료 조건|완료 경계 코드|완료 경계 실물|완료 경계 증거 명령)\s*:/;
 const VERIFICATION_PLAN_HEADING = '### 검증 계획(TDD)';
 
 /** Read a real Markdown section, ignoring headings inside fenced verbatim asks. */
@@ -77,7 +78,8 @@ export function composeSliceHandText(sliceGoal: string, parentText: string, mark
   inherited.push(...verificationPlan);
   // 표지는 리뷰 범위를 나르므로 장치 우선 조각(총 2 이상)은 상속 줄이 없어도 남는다 —
   // 다만 «물려받았다» 는 물려받은 줄에 대한 주장이므로 그 줄이 있을 때만 붙인다.
-  if (inherited.length === 0 && (marker.total < 2 || !sliceGoal.includes(`동작: ${DEVICE_FIRST_STEP}`))) return sliceGoal;
+  const isAcceptanceIntegration = sliceGoal.includes('부모 수용선 몫(자동 통합 조각):');
+  if (inherited.length === 0 && (marker.total < 2 || (!isAcceptanceIntegration && !sliceGoal.includes(`동작: ${DEVICE_FIRST_STEP}`)))) return sliceGoal;
   const inheritedTopics = `계약·완료 경계${verificationPlan.length > 0 ? '·검증 계획' : ''}`;
   const inheritanceClaim = inherited.length > 0 ? ` 아래 ${inheritedTopics}는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.` : '';
   const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫.${inheritanceClaim}`;
@@ -88,22 +90,58 @@ export type TierSplitPlan =
   | { kind: 'split'; slices: SizedSlice[] }
   | { kind: 'blocked'; reason: string };
 
-/** 순수 판정 — 분해 결과 → 발사 계획. 이유 없는 상 조각이 하나라도 있으면 결과 전체를 실패로 본다(이유 없는 상 0). */
+function parentAcceptanceLines(parentText: string): string[] {
+  return parentText.split(/\r?\n/u).map((line) => line.trim()).filter((line) => PARENT_ACCEPTANCE_LABEL.test(line));
+}
+
+function coveredAcceptanceLines(slices: readonly SizedSlice[], acceptance: readonly string[], parentText: string,
+  fromTier: '상' | '특', cid: string | null): string[] {
+  const effectiveGoals = slices.map((slice, index) => composeSliceHandText(slice.goal, parentText,
+    { index: index + 1, total: slices.length, fromTier, cid }));
+  return acceptance.filter((line) => effectiveGoals.some((goal) => goal.includes(line)));
+}
+
+function annotateAcceptanceShares(slices: readonly SizedSlice[], acceptance: readonly string[], integratedAdded = false): SizedSlice[] {
+  return slices.map((slice) => {
+    const share = acceptance.filter((line) => slice.goal.includes(line));
+    if (slice.goal.includes('부모 수용선 몫')) {
+      if (!integratedAdded || share.length >= acceptance.length || slice.goal.includes('누락 수용선은 자동 통합 조각이 담당한다.')) return slice;
+      return { ...slice, goal: `${slice.goal}\n- 누락 수용선은 자동 통합 조각이 담당한다.` };
+    }
+    if (share.length > 0) return { ...slice, goal: `${slice.goal}\n부모 수용선 몫:\n${share.map((line) => `- ${line}`).join('\n')}` };
+    if (acceptance.length > 0 && integratedAdded) return { ...slice, goal: `${slice.goal}\n부모 수용선 몫: 없음 — 누락 수용선은 자동 통합 조각이 담당한다.` };
+    return slice;
+  });
+}
+
+function recordAcceptanceCoverage(data: Record<string, unknown>): void {
+  try { debug.log('tier-split', 'slice-acceptance-coverage', data); } catch { /* fail-soft */ }
+}
+
+function integratedAcceptanceSlice(parentText: string, missing: readonly string[], slices: readonly SizedSlice[]): SizedSlice {
+  const paths = [...new Set(slices.flatMap((slice) => slice.goal.match(/[\w./-]+\.[A-Za-z][\w-]*/gu) ?? []))];
+  const goal = `${parentText}\n\n부모 수용선 몫(자동 통합 조각):\n${missing.map((line) => `- ${line}`).join('\n')}`;
+  return { goal, files: Math.max(1, paths.length), behaviours: Math.max(1, slices.reduce((sum, slice) => sum + slice.behaviours, 0)),
+    newFiles: slices.reduce((sum, slice) => sum + slice.newFiles, 0), tier: '상', unavoidable: 'acceptance-coverage-integration' };
+}
+
+/** 순수 판정 — 분해 결과에 남은 상 조각은 불가피 사유가 없어도 unavoidable=auto로 발사한다. */
 export function planTierSplit(result: TierSizedDecomposeResult): TierSplitPlan {
   if (!result.ok) return { kind: 'blocked', reason: `decompose-failed: ${result.reason}` };
   if (result.slices.length === 0) return { kind: 'blocked', reason: 'no-slices' };
   for (const [index, slice] of result.slices.entries()) {
     if (!['하', '중', '상'].includes(slice.tier)) return { kind: 'blocked', reason: `invalid-slice-tier: #${index + 1} ${String(slice.tier)}` };
     if (!slice.goal?.trim()) return { kind: 'blocked', reason: `empty-slice-goal: #${index + 1}` };
-    if (slice.tier === '상' && !slice.unavoidable?.trim()) return { kind: 'blocked', reason: `unjustified-상-slice: #${index + 1}` };
   }
-  const deviceSlices = result.slices.filter((slice) => slice.deviceFirst === 'device-test');
-  if (deviceSlices.length === 0 && result.slices.some((slice) => slice.deviceFirst === 'feature'))
+  const slices = result.slices.map((slice) => slice.tier === '상'
+    ? { ...slice, unavoidable: slice.unavoidable?.trim() || 'auto' } : slice);
+  const deviceSlices = slices.filter((slice) => slice.deviceFirst === 'device-test');
+  if (deviceSlices.length === 0 && slices.some((slice) => slice.deviceFirst === 'feature'))
     return { kind: 'blocked', reason: 'device-first-stage-missing' };
-  if (deviceSlices.length > 0 && (deviceSlices.length !== 1 || result.slices[0]?.deviceFirst !== 'device-test'
-    || result.slices.slice(1).some((slice) => slice.deviceFirst !== 'feature')))
+  if (deviceSlices.length > 0 && (deviceSlices.length !== 1 || slices[0]?.deviceFirst !== 'device-test'
+    || slices.slice(1).some((slice) => slice.deviceFirst !== 'feature')))
     return { kind: 'blocked', reason: 'device-first-order-invalid' };
-  return { kind: 'split', slices: result.slices };
+  return { kind: 'split', slices };
 }
 
 export interface TierSplitSliceOutcome { slice: SizedSlice; result?: HandTaskResult; error?: string }
@@ -144,19 +182,63 @@ export async function handTaskWithTierSplit(opts: TierSplitHandOptions): Promise
     record({ cid, fromTier, outcome: 'whole', reason: TIER_SPLIT_UNAVAILABLE, slices: [], unavoidable: [], ...acceptedSliceCounts([]) });
     return { kind: 'whole', result: await handTask(hand), reason: TIER_SPLIT_UNAVAILABLE };
   }
-  let plan: TierSplitPlan;
-  const controller = new AbortController();
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timedOut = new Promise<'timeout'>((resolve) => { timer = setTimeout(() => { controller.abort(); resolve('timeout'); }, decomposeTimeoutMs); });
-  try {
-    const raced = await Promise.race([decompose(hand.text.trim(), { signal: controller.signal,
-      ...(hand.project ? { repositoryRoot: resolve(hand.project.target) } : {}) }), timedOut]);
-    plan = raced === 'timeout' ? { kind: 'blocked', reason: `decompose-timeout: ${decomposeTimeoutMs}ms` } : planTierSplit(raced);
-  } catch (error) {
-    plan = { kind: 'blocked', reason: `decompose-threw: ${String((error as Error)?.message ?? error).slice(0, 200)}` };
-  } finally { clearTimeout(timer); }
+  const runDecompose = async (goal: string): Promise<{ plan: TierSplitPlan; result?: TierSizedDecomposeResult }> => {
+    const controller = new AbortController();
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timedOut = new Promise<'timeout'>((resolve) => { timer = setTimeout(() => { controller.abort(); resolve('timeout'); }, decomposeTimeoutMs); });
+    try {
+      const raced = await Promise.race([decompose(goal, { signal: controller.signal,
+        ...(hand.project ? { repositoryRoot: resolve(hand.project.target) } : {}) }), timedOut]);
+      if (raced === 'timeout') return { plan: { kind: 'blocked', reason: `decompose-timeout: ${decomposeTimeoutMs}ms` } };
+      return { plan: planTierSplit(raced), result: raced };
+    } catch (error) {
+      return { plan: { kind: 'blocked', reason: `decompose-threw: ${String((error as Error)?.message ?? error).slice(0, 200)}` } };
+    } finally { clearTimeout(timer); }
+  };
+  const first = await runDecompose(hand.text.trim());
+  let plan = first.plan;
+  let decomposed = first.result;
+  const acceptance = parentAcceptanceLines(hand.text);
+  if (plan.kind === 'split') {
+    let candidateSlices = plan.slices;
+    let covered = coveredAcceptanceLines(candidateSlices, acceptance, hand.text, fromTier, cid);
+    let missing = acceptance.filter((line) => !covered.includes(line));
+    const inheritedByComposition = acceptance.filter((line) => INHERITED_PARENT_LABELS.test(line));
+    recordAcceptanceCoverage({ cid, fromTier, attempt: 1, coverageMode: 'exact-parent-line', inheritedByComposition, covered, missing });
+    if (missing.length > 0) {
+      const retryPrompt = `${hand.text.trim()}\n\n### 분해 필수 수용선\n각 조각의 "부모 수용선 몫"에 담당하는 원문 수용선 전체를 그대로 싣고, 조각들의 합집합으로 아래 모든 줄을 덮으세요.\n${missing.map((line) => `- ${line}`).join('\n')}`;
+      const retry = await runDecompose(retryPrompt);
+      if (retry.plan.kind === 'split') {
+        plan = retry.plan;
+        decomposed = retry.result;
+        candidateSlices = annotateAcceptanceShares(retry.plan.slices, acceptance);
+      }
+      covered = coveredAcceptanceLines(candidateSlices, acceptance, hand.text, fromTier, cid);
+      missing = acceptance.filter((line) => !covered.includes(line));
+      recordAcceptanceCoverage({ cid, fromTier, attempt: 2, coverageMode: 'exact-parent-line', inheritedByComposition, covered, missing,
+        retryReason: retry.plan.kind === 'blocked' ? retry.plan.reason : undefined });
+      let integratedAdded = false;
+      if (missing.length > 0) {
+        candidateSlices = [...candidateSlices, integratedAcceptanceSlice(hand.text, missing, candidateSlices)];
+        integratedAdded = true;
+        covered = coveredAcceptanceLines(candidateSlices, acceptance, hand.text, fromTier, cid);
+        missing = acceptance.filter((line) => !covered.includes(line));
+      }
+      candidateSlices = annotateAcceptanceShares(candidateSlices, acceptance, integratedAdded);
+      recordAcceptanceCoverage({ cid, fromTier, attempt: 'final', coverageMode: 'exact-parent-line', inheritedByComposition,
+        covered, missing, integrated: integratedAdded });
+      plan = { kind: 'split', slices: candidateSlices };
+    } else {
+      plan = { kind: 'split', slices: candidateSlices };
+    }
+  }
   if (plan.kind === 'blocked') {
-    record({ cid, fromTier, outcome: 'blocked', reason: plan.reason, slices: [], unavoidable: [], ...acceptedSliceCounts([]) });
+    const rejectedOversized = decomposed?.ok
+      ? decomposed.slices.flatMap((slice, index) => slice.tier === '상' ? [{ index: index + 1, files: slice.files, behaviours: slice.behaviours }] : [])
+      : [];
+    record({ cid, fromTier, outcome: 'blocked', reason: plan.reason, slices: [], unavoidable: [],
+      ...(decomposed?.ok ? { redecomposed: decomposed.redecomposed } : {}),
+      rejectedOversized, rejectedOversizedCount: rejectedOversized.length, ...acceptedSliceCounts([]) });
     return { kind: 'blocked', result: await handTask({ ...hand, tierSplitBlocked: plan.reason }), reason: plan.reason };
   }
   const group = `${TASK_CARD_PREFIX}split-${randomBytes(4).toString('hex')}`;
@@ -165,7 +247,9 @@ export async function handTaskWithTierSplit(opts: TierSplitHandOptions): Promise
   const unavoidable = counts.unavoidableReasons;
   // 조각은 새 카드다 — 호출자 id·pr·goalId 를 조각마다 복제하면 «PR: #N» 조회·수확이 엇갈린다. 버린 것은 기록에 남긴다.
   const dropped = { ...(hand.id ? { id: hand.id } : {}), ...(hand.cardFields?.pr !== undefined ? { pr: hand.cardFields.pr } : {}), ...(hand.cardFields?.goalId !== undefined ? { goalId: hand.cardFields.goalId } : {}) };
-  record({ cid, fromTier, outcome: 'split', group, ...(Object.keys(dropped).length ? { dropped } : {}), slices: plan.slices.map((s) => ({ tier: s.tier, files: s.files, behaviours: s.behaviours })), unavoidable: [...unavoidable],
+  record({ cid, fromTier, outcome: 'split', group, ...(Object.keys(dropped).length ? { dropped } : {}),
+    ...(decomposed?.ok ? { redecomposed: decomposed.redecomposed } : {}),
+    slices: plan.slices.map((s) => ({ tier: s.tier, files: s.files, behaviours: s.behaviours })), unavoidable: [...unavoidable],
     ...counts });
   const { id: _wholeId, cardFields, ...rest } = hand;
   const base = { ...rest, ...(cardFields?.handed !== undefined ? { cardFields: { handed: cardFields.handed } } : {}) };