elanous 0.2.32 → 0.2.35

package/src/task-agent/repair-branch-cas.ts

@@ -24,7 +24,8 @@ export interface RepairCasRequest {
   result: RepairCommitResult;
   /** A previous push succeeded. Confirmation may inspect the remote and PR, but must never push again. */
   confirmationOnly?: boolean;
-  branch?: string;
+  /** PR branch captured when this repair was requested. A rename cannot retarget its push. */
+  branch: string;
   /** Persist a single-use push intent after bundle/ancestry checks and before the push side effect. */
   claimBeforePush?: () => boolean;
 }
@@ -99,6 +100,8 @@ export function applyRepairBundle(request: RepairCasRequest, deps: RepairCasDeps
   try { bytes = readFileSync(bundlePath); } catch { return fail('repair bundle unreadable'); }
   if (createHash('sha256').update(bytes).digest('hex') !== result.bundleSha256.toLowerCase()) return fail('repair bundle sha256 mismatch');
   if (!initial || !originRepo || initial.headRepo.toLowerCase() !== originRepo) return fail('PR head repository differs from git origin');
+  if (!request.branch || git(['check-ref-format', '--branch', request.branch]).status !== 0) return fail('bound repair branch name invalid');
+  if (initial.branch !== request.branch) return fail('bound repair branch changed');
   const alreadyApplied = initial?.head.toLowerCase() === result.commit.toLowerCase();
   if (!initial || initial.state !== 'OPEN' || initial.crossRepository || (!alreadyApplied && initial.head.toLowerCase() !== expectedHead.toLowerCase()))
     return fail('PR head CAS mismatch or PR unavailable');

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

@@ -92,14 +92,15 @@ export async function repairModelAvailability(readInputs: () => Promise<Pick<Bud
   } catch { return { codexSubscription: false, grokSubscription: false }; }
 }
 
-/** Repair stays inside the dispatch tier. A missing legacy tier is high, with Sol allowed only on measured subscription quota. */
+/** Repair stays inside the dispatch tier. A missing legacy tier is mid ('중'); Sol is reserved for the 특 tier and measured-subscription 상 repairs. */
 export function alternateRepairModel(card: TaskCard, availability: RepairModelAvailability = { codexSubscription: false, grokSubscription: false }): { from: string; to: TaskChildLlm } {
   const last = card.repairs?.at(-1);
   const from = last?.toModel ?? (card.childLlm ? `${card.childLlm.provider}/${card.childLlm.model}` : 'unknown');
   const glm: TaskChildLlm = { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3' };
   const sol: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-sol' };
   const grok: TaskChildLlm = { provider: 'grok', model: 'grok-4.6' };
-  const tier = card.tier ?? '상';
+  const luna: TaskChildLlm = { provider: 'openai-codex', model: 'gpt-6-luna' };
+  const tier = card.tier ?? '중';
   const pr = typeof card.pr === 'number' ? card.pr : card.pr?.number;
   const mixEven = ((pr ?? [...card.id].reduce((sum, ch) => sum + ch.charCodeAt(0), 0)) % 2) === 0;
   let to: TaskChildLlm;
@@ -108,6 +109,8 @@ export function alternateRepairModel(card: TaskCard, availability: RepairModelAv
   else if (tier === '상') to = availability.grokSubscription && from.includes('glm') ? grok
     : from.includes('glm-5.3-flash') ? glm
     : from.includes('glm-5.3') ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
+  else if (tier === '하') to = from.includes('glm-5.3-flash') ? luna : from.includes('glm-5.3')
+    ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
   else to = from.includes('glm-5.3-flash') ? glm : from.includes('glm-5.3')
     ? { provider: 'openrouter', model: 'openrouter/z-ai/glm-5.3-flash' } : glm;
   return { from, to };
@@ -192,7 +195,7 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
         const bundlePath = join(artifactDir, 'commit.bundle');
         let pushClaimed = false;
         applied = (input.apply ?? applyRepairBundle)({ repo, pr, expectedHead: latest.head,
-          bundlePath, result: result.result,
+          bundlePath, result: result.result, branch: latest.branch,
           claimBeforePush: () => {
             let claimed = false;
             updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === latest.runId && entry.status === 'requested')
@@ -308,6 +311,16 @@ export async function runRepairCycle(input: RepairCycleInput): Promise<RepairCyc
       ? { ...current, repairs: current.repairs.map((entry) => entry.runId === runId ? { ...entry, status: 'failed' as const, detail: reason } : entry) } : undefined);
     return { decision: 'repair-failed', reason };
   }
+  // The request may throw before a worker exists. A post-launch observation
+  // failure must not turn an accepted worker into a failed launch.
+  try {
+    updateTaskCard(statePath, card.id, (current) => current?.repairs?.some((entry) => entry.runId === runId)
+      && !current.history.some((entry) => entry.event === 'harness.role-llm' && entry.runId === runId)
+      ? { ...current, history: [...current.history, { at: now.toISOString(), event: 'harness.role-llm', pr, head, runId,
+        detail: `repair child model ${to.provider}/${to.model}` }] } : undefined);
+  } catch (error) {
+    try { debug.log('task-agent', 'repair-role-llm-observation-failed', { card: card.id, pr, head, runId, error: String(error) }); } catch { /* fail-soft */ }
+  }
   try {
     if (input.observeLaunch) input.observeLaunch(judged.judgement.move, runId);
     else {

package/src/task-agent/run-identity.ts

@@ -6,7 +6,8 @@
  *   디스패처 배선은 RUN-IDENTITY-ADMIT).
  * - parse/validate: 목록 밖 값은 거부한다(조용히 다듬지 않는다).
  * - 출생 신분 자동(`deriveBirthIdentity`): 칸 우선순위(P0 = critical·special·protect ·
- *   P1 = normal · 그 외 normal)·대표 표시에서 단다.
+ *   P1 = normal · 그 외 normal)·대표 표시에서 단다. 권한(rights)은 명시 `--tag rights=…`만 기록한다
+ *   (RUN-IDENTITY-RIGHTS — 체크리스트에는 권한 근거가 없으므로 출생값으로 추정하지 않는다).
  * - 태그 덮기(`applyRunIdentityTags`): `tasks hand --tag k=v`(반복) 이 출생 신분을 덮는다.
  * - ⛔ 모르는 칸을 기본값으로 확정하지 않는다: 칸 조회가 실패하면 명시 태그만 담고 나머지는 «미기록».
  * - 태그 바꾸기 감사(`runTagChange` — task-hand.ts): 카드 history 에 `run-tag-change`
@@ -129,7 +130,8 @@ const CROWN_MARK = '\u{1F451}';
 
 /**
  * 출생 신분 자동 — «조회에 성공한» 칸의 우선순위(P0 = critical·special·protect · P1 = normal · 그 외 normal)·대표 표시에서 단다.
- * 권한(rights)은 출생에서 올리지 않는다(기본 s · 올림은 `--tag rights=…` 명시만).
+ * 권한(rights)은 추정하지 않는다(RUN-IDENTITY-RIGHTS): 체크리스트 출생 정보에는 권한 근거가 없으므로
+ * `--tag rights=…` 명시 태그로만 기록하고, 태그가 없으면 «미기록».
  * ⛔ 칸을 못 읽었으면 부르지 않는다 — 그때는 `{ origin }` 에 명시 태그만 얹는다(나머지 «미기록»).
  * ⛔ 읽은 칸이라도 `priority`·`title` 이 비면 그 값에서 파생되는 칸을 확정하지 않는다(«미기록»):
  *   class 는 priority 가 있어야 · care·protect 는 P0 이거나 대표 가 보이면 올리고, «안 올림»(standard·false)은
@@ -145,7 +147,6 @@ export function deriveBirthIdentity(cell: RunIdentityCell, origin: RunIdentityOr
   return {
     ...(priority !== undefined ? { class: critical ? 'critical' as const : 'normal' as const } : {}),
     ...(careKnown ? { care: raised ? 'special' as const : 'standard' as const, protect: raised } : {}),
-    rights: 's',
     origin,
   };
 }

package/src/task-agent/shadow.ts

@@ -15,6 +15,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { extname, join, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
+import { readJourneyEdge, recordJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
 import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-supervisor.js';
 import { executeNextAction, type ActionDeps, type DeliveryKind, type NextAction } from './actions.js';
@@ -327,14 +329,28 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       checklistId: delivery ? card?.checklistId ?? '' : '',
       ...(delivery ? { delivery } : {}),
     };
-    const liveRetry = !delivery && deps.command !== undefined && deps.loadGate !== undefined
-      && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move) && liveMoves.has(judgement.move as TaskAgentLiveMove);
+    const retryMove = !delivery && (LIVE_RETRY_MOVES as readonly string[]).includes(judgement.move);
+    const route = retryMove ? readJourneyEdge('next-move', judgement.move,
+      { move: judgement.move, source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, runId: input.runId }) : null;
+    const liveRetry = retryMove && route?.source === 'graph' && route.to === 'dispatch'
+      && deps.command !== undefined && deps.loadGate !== undefined && liveMoves.has(judgement.move as TaskAgentLiveMove);
     executorResult = await executeNextAction(action, {
       mode: delivery ? (deps.mode ?? 'shadow') : liveRetry ? 'live' : 'shadow',
       command: deps.command ?? (async () => { throw new Error('task-agent shadow path must not run commands'); }),
-      observe: (_event, data) => { wouldDo = data.reason; },
+      observe: (event, data) => {
+        wouldDo = data.reason;
+        // Keep new denominator rows out of the legacy task-agent/action aggregate.
+        if (event !== 'task-agent.entrance-denominator') return;
+        try { (deps.log ?? ((category, name, row) => debug.log(category, name, row)))('task-agent', 'entrance-denominator', { ...data }); }
+        catch { /* Observation must not alter the selected move. */ }
+      },
       ...(liveRetry ? { liveMoves, retryLaunches, loadGate: deps.loadGate } : {}),
     });
+    if (liveRetry && executorResult === 'done' && route) {
+      passJourneyNode('next-move', { provenance: 'task-agent-terminal', outcome: judgement.move,
+        runId: input.runId ?? undefined, data: { source: judgeInput.pr ? `pr:${judgeInput.pr}` : `run:${input.runId ?? 'unknown'}`, pr: judgeInput.pr ?? null } });
+      recordJourneyEdge(route, 'dispatch');
+    }
   }
   const move: TaskAgentShadowMove = {
     runId: input.runId,

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

@@ -10,13 +10,14 @@
 import { execFileSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync, statSync, writeFileSync, type Stats } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, posix, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import { validateUnitCalls } from '../graph-runner/runner.js';
 import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.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 { withFileLockSync } from '../storage/file-lock.js';
@@ -29,7 +30,8 @@ import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type Work
 import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDoneCandidate,
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftReleaseComment } from '../self-dev/draft-triage-rules.js';
-import { parseAskTargetPathHints } from '../self-dev/launch-preflight-text.js';
+import { parseAskTargetPathHints, parseAskTargetPathHintsResult } from '../self-dev/launch-preflight-text.js';
+import { inspectGoalDoneBoundary } from '../self-implement/goal-author.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
 
 export interface ResolveHandTextDeps {
@@ -50,38 +52,35 @@ function missingOrReadFailure(error: unknown): '없다' | '읽기 실패' {
   return code === 'ENOENT' || code === 'ENOTDIR' ? '없다' : '읽기 실패';
 }
 
-/**
- * TA-WORK-ORDER — `.work-order.json` 골 파일의 내용을 지시서로 검증한다.
- * 통과하면 골 문면으로 펼쳐 `work-order` 로, 깨진 JSON·칸 id 없음은 `rejected`(사유) 로 돌린다.
- * 관측: `debug.log('task-agent.work-order', 'parsed' | 'rejected', { cellId, unknownFields })`.
- */
-function resolveWorkOrderFile(content: string, path: string): ResolvedHandText {
-  const parsed = parseWorkOrder(content);
-  if (!parsed.ok) {
-    try { debug.log('task-agent.work-order', 'rejected', { cellId: null, unknownFields: [] }); } catch { /* fail-soft */ }
-    return { kind: 'rejected', path, reason: parsed.reason };
-  }
-  try { debug.log('task-agent.work-order', 'parsed', { cellId: parsed.order.cellId, unknownFields: parsed.order.unknownFields }); } catch { /* fail-soft */ }
-  return { kind: 'work-order', text: renderWorkOrderGoal(parsed.order), path, order: parsed.order };
-}
-
-/** 파일 판정만 한다. 관측과 카드 작성은 호출자가 결과에 따라 수행한다. */
+/** 파일 판정만 한다. 카드 작성은 호출자가 결과에 따라 수행한다. */
 export function resolveHandText(text: string, deps: ResolveHandTextDeps = { cwd: process.cwd(), stat: statSync, readFile: readFileSync }): ResolvedHandText {
-  if (!text || /\s/.test(text)) return { kind: 'unchanged', text };
+  const workOrder = WORK_ORDER_FILE_PATTERN.test(text);
+  if (!text || (/\s/.test(text) && !workOrder)) return { kind: 'unchanged', text };
   const path = resolve(deps.cwd, text);
   const extension = /\.(?:md|markdown|txt)$/i.test(text);
+  const reject = (reason: string): ResolvedHandText => {
+    if (workOrder) {
+      try { debug.log('task-agent.work-order', 'rejected', { cellId: null, unknownFields: [] }); } catch { /* fail-soft */ }
+    }
+    return { kind: 'rejected', path, reason };
+  };
   let file: Pick<Stats, 'isFile' | 'isDirectory'>;
   try { file = deps.stat(path); } catch (error) {
-    if (!extension) return { kind: 'unchanged', text };
-    return { kind: 'rejected', path, reason: missingOrReadFailure(error) };
+    if (!extension && !workOrder) return { kind: 'unchanged', text };
+    return reject(missingOrReadFailure(error));
   }
-  if (!file.isFile() && !extension && !file.isDirectory()) return { kind: 'unchanged', text };
-  if (!file.isFile()) return { kind: 'rejected', path, reason: file.isDirectory() ? '디렉터리' : '읽기 실패' };
+  if (!file.isFile() && !extension && !workOrder && !file.isDirectory()) return { kind: 'unchanged', text };
+  if (!file.isFile()) return reject(file.isDirectory() ? '디렉터리' : '읽기 실패');
   let content: string;
   // stat 과 read 사이에 지워지거나 경로가 바뀌어도 사유는 같은 규칙(없다/읽기 실패)으로 가른다.
-  try { content = deps.readFile(path, 'utf8'); } catch (error) { return { kind: 'rejected', path, reason: missingOrReadFailure(error) }; }
+  try { content = deps.readFile(path, 'utf8'); } catch (error) { return reject(missingOrReadFailure(error)); }
   // TA-WORK-ORDER — 지시서 골 파일은 인라인하지 않고 지시서로 검증해 골 문면으로 펼친다.
-  if (WORK_ORDER_FILE_PATTERN.test(text)) return resolveWorkOrderFile(content, path);
+  if (workOrder) {
+    const parsed = parseWorkOrder(content);
+    if (!parsed.ok) return reject(parsed.reason);
+    try { debug.log('task-agent.work-order', 'parsed', { cellId: parsed.order.cellId, unknownFields: parsed.order.unknownFields }); } catch { /* fail-soft */ }
+    return { kind: 'work-order', text: renderWorkOrderGoal(parsed.order), path, order: parsed.order };
+  }
   const carried = content.trim();
   if (!carried) return { kind: 'rejected', path, reason: '비었다' };
   return { kind: 'inlined', text: content, path, chars: carried.length, sha256: createHash('sha256').update(carried).digest('hex') };
@@ -210,6 +209,8 @@ export interface TaskCardMove { kind: 'launch' | 'wait'; command?: string[]; rea
 export interface TaskCard {
   id: string;
   text: string;
+  /** 첫 줄 대상 경로 라벨에서 확인한 저장소 상대 경로. 필드 부재는 경로를 모른다는 뜻이다. */
+  targetPaths?: string[];
   seat?: TaskSeat;
   checklistId?: string;
   /** Explicit release version for an adopted PR; post-land still confirms the cell exists there. */
@@ -231,8 +232,11 @@ export interface TaskCard {
    * launch-failed = 발사기가 띄우기에 실패했다(사유는 history 마지막 칸) — 다음 수는 다시 발사.
    * failed = 발사된 런이 PR·수확 가지 없이 죽었거나 끝내 안 떴다(TA-JUDGE-DEAD-RUN · `card-evidence.ts`) — 사유
    * (`failed/needs-owner|needs-relaunch — …`)는 history 마지막 칸 · 자동 재발사하지 않는다(사람/판단부 몫).
+   * landed-by-hand = 실패 카드에 묶인 PR을 사람이 손수 병합해 main 에 안착시켰다(TA-CARD-MERGE-RECONCILE ·
+   * `postland-card.ts` `reconcileHandMergedCard`) — 이전 status·사유는 history `hand-move` 줄에 보존된다.
+   * landed = 병합된 merge 커밋이 카드의 land attempt head 와 정확히 일치해 에이전트 착지로 확정했다(같은 정산 경로).
    */
-  status: 'handed' | 'launched' | 'launch-failed' | 'failed' | 'done';
+  status: 'handed' | 'launched' | 'launch-failed' | 'failed' | 'landed-by-hand' | 'landed' | 'done';
   history: TaskCardEvent[];
   /** 미션 카드만 — 조각 카드 id(순서대로) · 쪼갠 출처(`mission.ts` splitMission). */
   pieces?: string[];
@@ -292,13 +296,18 @@ export interface TaskCard {
    * REJUDGE base-stale — `base-stale` (overlap evidence gate base went stale with PR-file overlap) waits for a re-gate on a new base;
    * only after that re-gate passes is the attempt consumed (`openLandAttempts`) and the same head may land once more.
    */
-  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string; class?: 'infra' | 'judgement' | 'base-stale'; reason?: string }>;
+  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string; class?: 'infra' | 'judgement' | 'base-stale' | 'recovery'; reason?: string }>;
   /** TA-LIVE-LAND-2 — `tasks hand --ta-land`: this card's run leaves the merge to the task agent (propose-land). */
   taLand?: true;
   /** TASKS-HAND-CHILD-LLM — `tasks hand --child-llm <provider>/<model> [--child-llm-effort <level>]` → 발사 인자 `--child-llm-provider/-model/-effort`. */
   childLlm?: TaskChildLlm;
   /** Dispatch difficulty, fixed at handoff so repair uses the same judgement. */
   tier?: '하' | '중' | '상' | '특';
+  /**
+   * TIER-SPLIT-BEFORE-LAUNCH — 상·특 hand 를 분해해 나온 조각 카드(`tier-split.ts`). group = 같은 hand 에서 나온 조각들의 묶음 id
+   * (칸 연결은 `checklistId` 가 그대로 잇는다) · fromTier = 원래 난이도 · unavoidable = 상으로 남은 조각의 불가피 이유.
+   */
+  tierSplit?: { group: string; fromTier: '상' | '특'; index: number; total: number; unavoidable?: string };
   /** RUN-IDENTITY-TAGS — 출생 신분 묶음(`run-identity.js` 정본): 칸 우선순위·대표 표시에서 태어나고 `--tag k=v` 가 덮는다. 카드 상태 파일이 원장 정본이다. */
   identity?: RunIdentity;
   /** Same-PR repair launches; exact source head and worker result are retained for CAS and retry limits. */
@@ -434,6 +443,25 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+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)
+      && !path.startsWith('../') && !path.includes('\\') && !/^[A-Za-z]:\//.test(path)))].sort();
+}
+
+/** 같은 저장소 경로를 만지는 착지 전 카드만 돌려준다. 경로 미기록 카드는 추측하지 않는다. */
+export function cardsTouchingPaths(cards: readonly TaskCard[], paths: readonly string[]): Array<{
+  card: TaskCard; checklistId?: string; runId?: string; pr?: number; paths: string[];
+}> {
+  const wanted = new Set(canonicalTargetPaths(paths));
+  if (wanted.size === 0) return [];
+  return cards.filter((card) => card.status === 'launched' && !card.postLand && !card.trainLanding && !card.prTerminal)
+    .map((card) => ({ card, paths: canonicalTargetPaths(card.targetPaths ?? []).filter((path) => wanted.has(path)) }))
+    .filter((item) => item.paths.length > 0)
+    .map(({ card, paths }) => ({ card, ...(card.checklistId ? { checklistId: card.checklistId } : {}),
+      ...(card.runId ? { runId: card.runId } : {}), ...(cardPrNumber(card) !== undefined ? { pr: cardPrNumber(card) } : {}), paths }));
+}
+
 export const CLOSED_BY_HAND_EVENT = 'closed-by-hand';
 
 /** 카드를 손으로 닫는다 — 상태를 `failed` 로 두고 history 에 한 줄(`closed-by-hand`)을 남긴다. 이미 손으로 닫은 카드는 그대로 돌려준다(멱등). */
@@ -552,7 +580,7 @@ export function shellQuote(arg: string): string {
 }
 
 /** 발사기에 넘기는 연결 — env(`ELANOUS_RUN_ID`)를 자식 환경에 얹으면 하니스 런이 `runId` 로 돈다(`resolveRunIdentity` 상속). launchId 는 카드에만 남는 발사 토큰이다. */
-export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string>; cardLabelContext?: TaskCardLabelContext }
+export interface TaskLaunchContext { runId: string; launchId: string; env: Record<string, string>; /** exact untrimmed hand text (launch-utterance ledger pair) */ launchUtterance?: string; cardLabelContext?: TaskCardLabelContext; substrate?: 'pod'; podGoal?: string; effectiveChildProvider?: string }
 /** 발사기가 «이 런 id 로 띄웠다»고 돌려주는 영수증 — 없으면 카드에 런 id 를 적지 않는다(추측하지 않는다). */
 export interface TaskLaunchReceipt {
   runId?: string;
@@ -572,12 +600,18 @@ export interface HandTaskOptions {
   goal?: string;
   milestone?: string;
   live?: boolean;
+  /** Production `tasks hand --live` guard; test launchers opt in explicitly. */
+  preflightGoalDoneBoundary?: boolean;
   /** TA-LIVE-LAND-2 — `--ta-land`: card field `taLand` ⊕ launch env `ELANOUS_TA_LAND=1`. */
   taLand?: boolean;
   /** TASKS-HAND-CHILD-LLM — `<provider>/<model>`(`parseChildLlm`) ⊕ 선택 추론 노력. effort 만 주면 거부. */
   childLlm?: string;
   childLlmEffort?: string;
   tier?: TaskCard['tier'];
+  /** TIER-SPLIT-BEFORE-LAUNCH — 조각 카드에 싣는 분해 연결(`tier-split.ts` 만 준다). */
+  tierSplit?: TaskCard['tierSplit'];
+  /** TIER-SPLIT-BEFORE-LAUNCH — 분해 실패 사유. 주면 카드를 발사 없이 failed(history `tier-split-failed`)로 남기고 launched:false 로 돌아온다. */
+  tierSplitBlocked?: string;
   /** RUN-IDENTITY-TAGS — `tasks hand --tag k=v`(반복): 출생 신분을 덮는다. 목록 밖 값은 거부한다(`run-identity.js`). */
   tags?: string[];
   /** RUN-IDENTITY-TAGS — 칸 읽기 seam(우선순위·대표 표시). 주면 그 답이 최종이다(«칸 없음» 포함). */
@@ -657,6 +691,9 @@ export function dispatchDeliverableCompletion(id: string, input: { ref: string;
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const text = opts.text.trim();
   if (!text) throw new Error('과제 한 줄이 비어 있다');
+  const path = opts.statePath ?? taskAgentStatePath();
+  const targetPathHints = parseAskTargetPathHintsResult(text);
+  const targetPaths = canonicalTargetPaths(targetPathHints.paths);
   if (opts.seat !== undefined && !TASK_SEATS.includes(opts.seat)) throw new Error(`자리는 ${TASK_SEATS.join('|')} 중 하나다: ${opts.seat}`);
   if (opts.completion !== undefined && !COMPLETION_KINDS.includes(opts.completion)) throw new Error(`종결 종류는 ${COMPLETION_KINDS.join('|')} 중 하나다: ${opts.completion}`);
   for (const [flag, value] of [['--goal', opts.goal], ['--milestone', opts.milestone]] as const) {
@@ -664,6 +701,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   }
   if (opts.childLlmEffort !== undefined && opts.childLlm === undefined) throw new Error('--child-llm-effort 는 --child-llm <provider>/<model> 과 함께 준다');
   if (opts.tier !== undefined && !['하', '중', '상', '특'].includes(opts.tier)) throw new Error(`--tier 는 하|중|상|특 중 하나다: ${opts.tier}`);
+  const tierSplitBlocked = opts.tierSplitBlocked;
   // RUN-IDENTITY-TAGS — 출생 신분: 칸 우선순위(P0 = critical·special·protect · P1 = normal · 그 외 normal)·대표 표시에서 단다.
   // `--tag k=v`(반복) 이 덮는다 — 칸·태그 없는 손은 오늘 모양 그대로다(신분 없음). 목록 밖 값은 카드를 적기 전에 거부한다(`run-identity.js` 정본).
   const birthCell = opts.checklistId === undefined ? undefined
@@ -705,9 +743,9 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   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';
-  const path = opts.statePath ?? taskAgentStatePath();
   const card: TaskCard = {
     id, text,
+    ...(!targetPathHints.labelMissing ? { targetPaths } : {}),
     ...(opts.seat ? { seat: opts.seat } : {}),
     ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
     ...(opts.checklistVersion !== undefined ? { checklistVersion: opts.checklistVersion } : {}),
@@ -721,18 +759,21 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.taLand === true ? { taLand: true as const } : {}),
     ...(childLlm ? { childLlm } : {}),
     ...(opts.tier ? { tier: opts.tier } : {}),
+    ...(opts.tierSplit ? { tierSplit: opts.tierSplit } : {}),
     ...(identity ? { identity } : {}),
     createdAt: now.toISOString(),
-    status: selectionFailure ? 'failed' : 'handed',
+    status: selectionFailure || tierSplitBlocked !== undefined ? 'failed' : 'handed',
     history: selectionFailure ? [{ at: now.toISOString(), event: !selected.composition ? 'composition-missing'
-      : selected.error ? 'composition-invalid' : 'composition-launcher-unavailable', detail: selectionFailure }] : [],
+      : selected.error ? 'composition-invalid' : 'composition-launcher-unavailable', detail: selectionFailure }]
+      : tierSplitBlocked !== undefined ? [{ at: now.toISOString(), event: 'tier-split-failed', detail: `tier-split-failed: ${tierSplitBlocked}` }] : [],
     ...(opts.mission ? { mission: opts.mission, after: [...(opts.after ?? [])] } : {}),
     ...(opts.cardFields?.pr !== undefined ? { pr: opts.cardFields.pr } : {}),
     ...(opts.cardFields?.goalId !== undefined ? { goalId: opts.cardFields.goalId } : {}),
     ...(opts.cardFields?.handed !== undefined ? { handed: opts.cardFields.handed } : {}),
   };
   const move = selectionFailure ? undefined : nextMoveFor(card, opts.landed);
-  if (move && move.kind !== 'launch') throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
+  // 분해 실패로 막은 카드는 wait(failed 사유)가 정답이다 — 던지지 않고 카드를 적은 뒤 발사 0 으로 돌아간다.
+  if (move && move.kind !== 'launch' && tierSplitBlocked === undefined) throw new Error(`발사할 수 없는 과제다 — ${move.reason}`);
   const guard = opts.writeGuard;
   const writeCard = (target: string, next: TaskCard): void => {
     if (!guard) { writeTaskCards(target, [next]); return; }
@@ -747,13 +788,24 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     });
     if (!owned.ok) throw new TaskCardSupersededError(next.id);
   };
+  // Production Pod launches use the remote-parent lint's shared boundary judge.
+  // Injected launchers are test seams and opt in explicitly at the contract test.
+  if (opts.live && opts.preflightGoalDoneBoundary && !selectionFailure && move?.kind === 'launch') {
+    readTaskAgentState(path);
+    const { missing } = inspectGoalDoneBoundary(text);
+    if (missing.length > 0) {
+      throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.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`,
     unitsResolved: selected.unitsResolved, missingUnits: selected.missingUnits,
     ...(selected.error ? { error: selected.error } : {}),
   }); } catch { /* fail-soft */ }
   if (selectionFailure) throw new Error(`${selectionFailure} (카드 ${id})`);
+  if (tierSplitBlocked !== undefined && move) return { card, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   if (!move || move.kind !== 'launch') throw new Error('조합 선택 뒤 발사 수가 없다');
   try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode, projectId: project?.id ?? null, targetIsGit, taLand: card.taLand === true, runPriority: card.identity ? runPriorityClass(card.identity) : null }); } catch { /* fail-soft */ }
   if (childLlm) {
@@ -777,11 +829,17 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     return { card: candidate, move: nextMoveFor(candidate), mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   }
   const runId = mintRunId();
-  const launchId = `tl-${randomBytes(6).toString('hex')}`;
-  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id,
+  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,
+    ...(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 } : {}),
-    ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
+    ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card),
+    // 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 } : {}) };
   let receipt: void | TaskLaunchReceipt;
   try {
     receipt = await opts.launcher(move.command!, project?.target, context);
@@ -812,9 +870,11 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   // INFLIGHT-REGISTRY — 출발 때 맥락을 남긴다(머지 때 같은 파일 줄의 의도를 스마트 머지가 읽는다 · 착지하면 지운다).
   try {
     const [head = '', ...rest] = text.split(/\r?\n/);
+    const intentLines = (/^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]/i.test(head) ? rest : [head, ...rest])
+      .filter((line) => !/^\s*(?:[-*]\s*)?완료 경계 (?:코드|실물|증거 명령)\s*:/.test(line));
     registerInflight({
       runId: boundRunId ?? runId, cell: card.checklistId ?? card.id, cardId: card.id,
-      intent: (/^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]/i.test(head) ? rest.join(' ') : text) || text,
+      intent: intentLines.join(' ').trim() || text,
       files: parseAskTargetPathHints(text),
     }, { path: join(dirname(path), INFLIGHT_REGISTRY_FILE), ...(opts.now ? { now: opts.now } : {}) });
   } catch (error) {

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

@@ -0,0 +1,127 @@
+/**
+ * TIER-SPLIT-BEFORE-LAUNCH (0.2.35 P0) — `tasks hand --tier 상|특 --live` 를 한 덩어리로 쏘지 않고, 저작 분해
+ * (TC TIER-SIZED-DECOMPOSE `decomposeToTierSizedSlices`)가 만든 «중 이하 조각»으로 나눠 조각마다 hand 발사한다.
+ * 대표: «최우선으로 중·하 난이도로 쪼개기를 정착 · 구독 sol 은 웬만해선 소진 안 함».
+ *
+ * - 분해 규칙은 TC 몫 — 여기는 그 함수를 «주입 seam» 으로 받는다. 기본 seam 은 이 파일 한 곳(`DEFAULT_TIER_SIZED_DECOMPOSE`)에서만 정한다.
+ * - 분해기 «미배선»(seam 에 undefined 명시) = `decomposer-unavailable` → 종전처럼 한 덩어리 발사 ⊕ 기록. 기본 seam 은 TC 함수다.
+ * - 분해 «실패»(ok:false · throw · 불가피 이유 없는 상 조각 · 빈/잘못된 조각) → 발사 0 · 카드 failed(history `tier-split-failed`).
+ * - 관측: `debug.log('task-agent.hand', 'tier-split', {cid, fromTier, outcome, reason?, slices, unavoidable})`.
+ */
+import { randomBytes } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import { handTask, TASK_CARD_PREFIX, type HandTaskOptions, type HandTaskResult } from './task-hand.js';
+
+// 분해 규칙·타입 정본 = TC `src/self-implement/goal-author-decompose.ts`(TIER-SIZED-DECOMPOSE · #29987).
+import { decomposeToTierSizedSlices, type SizedSlice, type TierSizedDecomposeResult } from '../self-implement/goal-author-decompose.js';
+export type { SizedSlice, TierSizedDecomposeResult };
+export type TierSizedDecompose = (goal: string, opts?: { signal?: AbortSignal }) => Promise<TierSizedDecomposeResult>;
+
+/** 기본 분해기 — TC `decomposeToTierSizedSlices`. seam 에 undefined 를 명시하면 «미배선»(decomposer-unavailable). */
+export const DEFAULT_TIER_SIZED_DECOMPOSE: TierSizedDecompose | undefined = decomposeToTierSizedSlices;
+
+export const TIER_SPLIT_UNAVAILABLE = 'decomposer-unavailable';
+
+/** 분해 시간 상한 — LLM 이 매달려도 디스패처의 손 넘김 한 번을 끝없이 붙잡지 않는다. 넘으면 막힘(decompose-timeout). */
+export const TIER_SPLIT_DECOMPOSE_TIMEOUT_MS = 300_000;
+
+/** 조각이 부모 칸에서 물려받는 줄 머리 — hand 의 골 검사(완료 경계 셋)와 계약·경계 문맥. */
+const INHERITED_PARENT_LABELS = /^\s*(?:[-*]\s*)?(현재 계약|완료 경계 코드|완료 경계 실물|완료 경계 증거 명령|경계|증거 보충)\s*:/;
+
+/**
+ * 조각 hand 문면 = 조각 골(대상 경로·동작 — 첫 줄 유지) ⊕ 조각 표지 ⊕ 부모 칸의 계약·완료 경계·경계 줄.
+ * 분해기의 조각 골은 짧은 제목뿐이라 그대로 넘기면 hand 의 골 검사(완료 경계 누락)가 막는다(10-21 DEVICE-FIRST-AUTHORING 발사 0).
+ * 부모에 그 줄이 없으면 아무것도 더하지 않는다 — 검사가 지금처럼 거부한다(보수 쪽).
+ */
+export function composeSliceHandText(sliceGoal: string, parentText: string, marker: { index: number; total: number; fromTier: '상' | '특'; cid: string | null }): string {
+  const sliceLines = sliceGoal.trim().split('\n');
+  const sliceHas = new Set(sliceLines.map((line) => INHERITED_PARENT_LABELS.exec(line)?.[1]).filter(Boolean));
+  const inherited = parentText.split('\n').filter((line) => {
+    const label = INHERITED_PARENT_LABELS.exec(line)?.[1];
+    return label !== undefined && !sliceHas.has(label);
+  });
+  if (inherited.length === 0) return sliceGoal;
+  const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫. 아래 계약·완료 경계는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.`;
+  return [...sliceLines, tag, ...inherited].join('\n');
+}
+
+export type TierSplitPlan =
+  | { kind: 'split'; slices: SizedSlice[] }
+  | { kind: 'blocked'; reason: string };
+
+/** 순수 판정 — 분해 결과 → 발사 계획. 이유 없는 상 조각이 하나라도 있으면 결과 전체를 실패로 본다(이유 없는 상 0). */
+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}` };
+  }
+  return { kind: 'split', slices: result.slices };
+}
+
+export interface TierSplitSliceOutcome { slice: SizedSlice; result?: HandTaskResult; error?: string }
+export type TierSplitHandResult =
+  | { kind: 'whole'; result: HandTaskResult; reason?: string }
+  | { kind: 'blocked'; result: HandTaskResult; reason: string }
+  | { kind: 'split'; group: string; fromTier: '상' | '특'; slices: TierSplitSliceOutcome[] };
+
+export interface TierSplitHandOptions extends HandTaskOptions {
+  /** 분해기 seam — 키를 안 주면 기본(`DEFAULT_TIER_SIZED_DECOMPOSE`) · undefined 를 명시하면 «미배선». */
+  decompose?: TierSizedDecompose;
+  /** 분해 시간 상한(시험 주입) — 기본 `TIER_SPLIT_DECOMPOSE_TIMEOUT_MS`. */
+  decomposeTimeoutMs?: number;
+}
+
+function record(data: Record<string, unknown>): void {
+  try { debug.log('task-agent.hand', 'tier-split', data); } catch { /* fail-soft */ }
+}
+
+/**
+ * `tasks hand` 의 발사 앞단. 분해는 `--live` ⊕ tier 상|특 일 때만 — 중·하·tier 없음·shadow 는 `handTask` 그대로(분해 호출 0).
+ */
+export async function handTaskWithTierSplit(opts: TierSplitHandOptions): Promise<TierSplitHandResult> {
+  const { decompose: injected, decomposeTimeoutMs = TIER_SPLIT_DECOMPOSE_TIMEOUT_MS, ...hand } = opts;
+  const fromTier = hand.tier;
+  if (!hand.live || (fromTier !== '상' && fromTier !== '특')) return { kind: 'whole', result: await handTask(hand) };
+  const decompose = 'decompose' in opts ? injected : DEFAULT_TIER_SIZED_DECOMPOSE;
+  const cid = hand.checklistId ?? null;
+  if (!decompose) {
+    record({ cid, fromTier, outcome: 'whole', reason: TIER_SPLIT_UNAVAILABLE, slices: [], unavoidable: [] });
+    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 }), 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); }
+  if (plan.kind === 'blocked') {
+    record({ cid, fromTier, outcome: 'blocked', reason: plan.reason, slices: [], unavoidable: [] });
+    return { kind: 'blocked', result: await handTask({ ...hand, tierSplitBlocked: plan.reason }), reason: plan.reason };
+  }
+  const group = `${TASK_CARD_PREFIX}split-${randomBytes(4).toString('hex')}`;
+  const total = plan.slices.length;
+  const unavoidable = plan.slices.filter((slice) => slice.tier === '상').map((slice) => slice.unavoidable!.trim());
+  // 조각은 새 카드다 — 호출자 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 });
+  const { id: _wholeId, cardFields, ...rest } = hand;
+  const base = { ...rest, ...(cardFields?.handed !== undefined ? { cardFields: { handed: cardFields.handed } } : {}) };
+  const slices: TierSplitSliceOutcome[] = [];
+  for (const [index, slice] of plan.slices.entries()) {
+    try {
+      const result = await handTask({ ...base, text: composeSliceHandText(slice.goal, hand.text, { index: index + 1, total, fromTier, cid }), tier: slice.tier,
+        tierSplit: { group, fromTier, index: index + 1, total, ...(slice.tier === '상' ? { unavoidable: slice.unavoidable!.trim() } : {}) } });
+      slices.push({ slice, result });
+    } catch (error) {
+      slices.push({ slice, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { kind: 'split', group, fromTier, slices };
+}

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

@@ -0,0 +1,24 @@
+import { parseWorkOrder, type WorkOrder } from './work-order.js';
+
+export interface BuildWorkOrderInput {
+  cellId: string;
+  version: string;
+  lifeId?: string;
+  priority?: string;
+  peers?: string;
+  boundary?: string;
+}
+
+/** Build the normalized nine-field core from already-grounded inputs; no CLI, filesystem, or launch side effects. */
+export function buildWorkOrder(input: BuildWorkOrderInput): WorkOrder {
+  const parsed = parseWorkOrder(JSON.stringify({
+    cellId: input.cellId,
+    lifeId: input.lifeId,
+    version: input.version,
+    priority: input.priority,
+    peers: input.peers,
+    boundary: input.boundary,
+  }));
+  if (!parsed.ok) throw new Error(parsed.reason);
+  return parsed.order;
+}

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

@@ -79,8 +79,9 @@ export function parseWorkOrder(source: string): ParseWorkOrderResult {
   const unknownFields: string[] = [];
   const cells = {} as Record<WorkOrderField, string>;
   for (const field of WORK_ORDER_FIELDS) {
-    const text = cellText(record[field]);
-    if (text === WORK_ORDER_UNKNOWN) unknownFields.push(field);
+    const value = record[field];
+    const text = cellText(value);
+    if (value == null || (typeof value === 'string' && !value.trim())) unknownFields.push(field);
     cells[field] = text;
   }
   return { ok: true, order: { cellId: rawCellId.trim(), ...cells, unknownFields } };