elanous 0.2.29 → 0.2.32

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

@@ -5,7 +5,7 @@
  *   종전 칸(landingDay·landingsToday·failureCounts)은 그대로 두고 덧붙이기만 한다(하위 호환 — 실행부 쓰기는 `...disk` 로 보존).
  * - 첫 수는 «launch» = `harness say [--seat <자리>] --substrate pod --merge-by-host "<원문>"`.
  * - 기본은 SHADOW: 카드와 명령만 남기고 아무것도 띄우지 않는다. `--live` 일 때만 주입된 launcher 로 띄운다.
- * - 관측: `debug.log('task-agent', 'handed', {taskId, seat, checklistId, mode})`.
+ * - 관측: `debug.log('task-agent', 'handed', {taskId, seat, checklistId, mode, runPriority})`.
  */
 import { execFileSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
@@ -22,7 +22,15 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import { checkCompletionEvidence, deliverableReceiptEvidence } from './completion-evidence.js';
 import { judgeNextMove } from './judge.js';
+import { checklistDevVersion, listChecklist } from '../release-loop/checklist.js';
 import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
+import { applyRunIdentityTag, applyRunIdentityTags, deriveBirthIdentity, parseRunIdentityTag, runIdentityFieldText, runIdentityQueuePriority, runPriorityClass, validateRunIdentity, type RunIdentity, type RunIdentityCell, type RunIdentityOrigin } from './run-identity.js';
+import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type WorkOrder } from './work-order.js';
+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 { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -33,13 +41,30 @@ export interface ResolveHandTextDeps {
 export type ResolvedHandText =
   | { kind: 'unchanged'; text: string }
   | { kind: 'inlined'; text: string; path: string; chars: number; sha256: string }
-  | { kind: 'rejected'; path: string; reason: '없다' | '디렉터리' | '읽기 실패' | '비었다' };
+  /** TA-WORK-ORDER — `.work-order.json` 골 파일이 검증을 통과해 지시서를 골 문면으로 펼친 것(`work-order.ts`). */
+  | { kind: 'work-order'; text: string; path: string; order: WorkOrder }
+  | { kind: 'rejected'; path: string; reason: string };
 
 function missingOrReadFailure(error: unknown): '없다' | '읽기 실패' {
   const code = (error as NodeJS.ErrnoException | undefined)?.code;
   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 };
@@ -55,6 +80,8 @@ export function resolveHandText(text: string, deps: ResolveHandTextDeps = { cwd:
   let content: string;
   // stat 과 read 사이에 지워지거나 경로가 바뀌어도 사유는 같은 규칙(없다/읽기 실패)으로 가른다.
   try { content = deps.readFile(path, 'utf8'); } catch (error) { return { kind: 'rejected', path, reason: missingOrReadFailure(error) }; }
+  // TA-WORK-ORDER — 지시서 골 파일은 인라인하지 않고 지시서로 검증해 골 문면으로 펼친다.
+  if (WORK_ORDER_FILE_PATTERN.test(text)) return resolveWorkOrderFile(content, path);
   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') };
@@ -163,6 +190,8 @@ export interface TaskCardEvent {
   sourceId?: string;
   /** `closed-by-hand` 줄만 — 닫은 사유 · 닫은 자리(`closeTaskCard`). */
   reason?: string; by?: string;
+  /** RUN-IDENTITY-TAGS — `run-tag-change` 줄만 — 바꾼 칸 값(from → to). */
+  from?: string; to?: string;
   kind?: string; executed?: boolean; ok?: boolean; executorResult?: 'shadow' | 'live'; head?: string; effect?: string;
   /** TA-REVIEW-RESULT-CAPTURE — review live-move 줄 · 결과 줄(`live-move-result`)의 결과 파일 경로. */
   resultPath?: string;
@@ -222,6 +251,8 @@ export interface TaskCard {
   adoptedPr?: { pr: number; url: string; head: string; at: string };
   /** Bound PR observed in a terminal GitHub state. Only applies while the card still binds the same PR and URL. */
   prTerminal?: { pr: number; url: string; head: string; state: 'MERGED' | 'CLOSED'; at: string };
+  /** Component PR closed by a verified merged integration train. Source PR remains CLOSED. */
+  trainLanding?: { componentPr: number; integrationPr: number; mergeSha: string; train: string; at: string };
   /** Post-land checklist judgement. A partial slice closes this card while leaving the checklist cell yellow. */
   postLand?: { pr: number; head: string; at: string; outcome: 'complete' | 'partial'; evidence: string[]; remaining: string[] };
   goalId?: string;
@@ -241,6 +272,8 @@ export interface TaskCard {
   parentHost?: { host: string; configDir?: string; pid?: number; log?: string };
   /** 미션 카드만 — 모든 조각 착지 → 칸 green «제안»(체크리스트는 손대지 않는다 · OP/주인이 뒤집는다). */
   greenProposal?: { at: string; checklistId: string | null; evidence: Record<string, string> };
+  /** A passed explicit evidence command on current main only proposes green to an owner. No run or checklist change. */
+  alreadyDoneCandidate?: AlreadyDoneCandidate & { at: string };
   /** TA-JUDGE-LIVE-SAFE — live `review` 수가 리뷰를 요청한 PR 머리들(머리마다 한 번 · 띄우기 실패면 error · 이력은 지우지 않는다). */
   reviewRequests?: Array<{ pr: number; head: string; at: string; error?: string; /** TA-REVIEW-RESULT-CAPTURE — 자식 `--json` stdout 을 받는 파일. */ resultPath?: string }>;
   /**
@@ -264,6 +297,10 @@ export interface TaskCard {
   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?: '하' | '중' | '상' | '특';
+  /** 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. */
   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';
@@ -304,6 +341,16 @@ export function boundPrTerminal(card: Pick<TaskCard, 'pr' | 'prTerminal'>): Task
   return marker && typeof card.pr === 'object' && card.pr.number === marker.pr && card.pr.url === marker.url ? marker : undefined;
 }
 
+/**
+ * DRAFT-CLAIM-AUTO-2 — 포기 경로(failed · launch-failed)로 끝난 카드가 PR 을 남겼으면 그 PR 에 달 «🔧 처리 끝» 문면.
+ * 이 조각은 순수 함수만 — 실제 PR 코멘트(gh) · draft-sweep 배선은 다음 조각. launched · handed · PR 없음은 null.
+ */
+export function abandonedDraftReleaseNote(card: Pick<TaskCard, 'id' | 'status' | 'pr'>, at: Date): { pr: number; body: string } | null {
+  if (card.status !== 'failed' && card.status !== 'launch-failed') return null;
+  const pr = cardPrNumber(card);
+  return pr === undefined ? null : { pr, body: draftReleaseComment(at, `${card.id} 포기 경로 — 자동`) };
+}
+
 /** A uniquely launched code-PR card may own a draft through its PR or its opening run. */
 export function draftTaskOwner(cards: readonly TaskCard[], draft: { number: number; runId?: string | null }): TaskCard | undefined {
   const owners = cards.filter((card) => card.status === 'launched' && (card.completion ?? 'code-pr') === 'code-pr'
@@ -397,12 +444,79 @@ export function closeTaskCard(card: TaskCard, input: { reason: string; by: strin
   return { ...card, status: 'failed', history: [...card.history, { at: input.at, event: CLOSED_BY_HAND_EVENT, kind: CLOSED_BY_HAND_EVENT, detail: reason, reason, by: input.by }] };
 }
 
+/** RUN-IDENTITY-TAGS — 카드 history 의 런 신분 태그 바꾸기 줄(`runTagChange`): 닫힌 목록 신분을 바꾼 감사 {from, to, by, reason}. */
+export const RUN_TAG_CHANGE_EVENT = 'run-tag-change';
+
+/** RUN-IDENTITY-TAGS — 칸 조회 seam 의 답(조회 실패·빠칸 = `undefined` = «모른다»). */
+export type RunIdentityCellLookup = (checklistId: string) => RunIdentityCell | undefined;
+
+/**
+ * RUN-IDENTITY-TAGS-2 — 조회한 칸이 «기대한 판»의 칸일 때만 쓴다. 기대 판(카드 `checklistVersion`·호출자가 넘긴 판)을
+ * 알면 칸의 `version` 이 그 판과 같아야 한다 — 다르거나 비면 다른 판의 같은 id 일 수 있으니 «모른다»(`undefined`).
+ */
+export function cellOnExpectedBoard(cell: RunIdentityCell | undefined, expectedVersion: string | undefined): RunIdentityCell | undefined {
+  if (cell === undefined || expectedVersion === undefined) return cell;
+  return cell.version === expectedVersion ? cell : undefined;
+}
+
+/**
+ * RUN-IDENTITY-TAGS — 확인된 칸만 담은 신분: 조회에 성공한 칸이 있으면 그 출생값, 없으면 `{ origin }` 뿐이고
+ * 명시 태그를 얹는다. ⛔ 칸을 못 읽었으면 나머지 칸(care·rights·protect·class)을 기본값으로 채우지 않는다(«미기록»).
+ */
+export function confirmedRunIdentity(cell: RunIdentityCell | undefined, origin: RunIdentityOrigin, tags: readonly string[]): RunIdentity {
+  return applyRunIdentityTags(cell ? deriveBirthIdentity(cell, origin) : { origin }, tags);
+}
+
+/**
+ * RUN-IDENTITY-TAGS — `tasks tag <card> k=v`: 카드 history 에 `run-tag-change` 줄 {from, to, by, reason} 을
+ * 남기고 신분을 바꾼다(카드 상태 파일 = 원장 정본 — 같은 잠금 안에서 적는다). 목록 밖 값·모르는 칸은
+ * 카드를 적기 전에 거부한다(`run-identity.js` 정본).
+ * 신분 없는 옛 카드는 `checklistId` 로 칸을 «다시 조회»해 출생값을 세운다 — 못 읽으면 명시 태그만 담고 나머지는 «미기록».
+ * 출생 자리(origin.launcher)는 그 카드가 어디서 났는지 원장이 모르므로 비운다(지어내지 않는다).
+ */
+export function runTagChange(id: string, input: { tag: string; by: string; reason?: string; checklistCell?: RunIdentityCellLookup }, path: string = taskAgentStatePath(), now: () => Date = () => new Date()): TaskCard | undefined {
+  const tag = parseRunIdentityTag(input.tag);   // 목록 밖 값·모르는 칸은 여기서 거부한다.
+  const at = now().toISOString();
+  // 재조회는 잠금 밖에서 한 번 — 잠금 안에서 칸보드를 읽지 않는다.
+  const before = readTaskCard(id, path);
+  // RUN-IDENTITY-TAGS-2 — 카드의 판(checklistVersion)을 알 때만 «그 판»에서 다시 읽는다. 판을 모르면 «판 모름»:
+  // 개발 판의 같은 id 를 그 칸이라 짐작하지 않고 명시 태그만 담는다(나머지 «미기록»).
+  const boardVersion = before?.checklistVersion;
+  const lookup: RunIdentityCellLookup | undefined = input.checklistCell
+    ?? (boardVersion !== undefined ? (checklistId: string) => readChecklistCellForBirth(checklistId, boardVersion) : undefined);
+  const relookup = before && !before.identity && before.checklistId && lookup ? lookup(before.checklistId) : undefined;
+  return updateTaskCard(path, id, (current) => {
+    if (!current) return undefined;
+    // 잠금 밖에서 읽은 칸은 «같은 칸 ⊕ 같은 판»일 때만 쓴다 — 그 사이 판이 바뀌었으면 옛 판의 신분을 새 카드에 적지 않는다.
+    const sameCell = current.checklistId !== undefined && current.checklistId === before?.checklistId && current.checklistVersion === before?.checklistVersion;
+    const cell = !current.identity && sameCell ? cellOnExpectedBoard(relookup, current.checklistVersion) : undefined;
+    const identity = current.identity ? validateRunIdentity(current.identity) : confirmedRunIdentity(cell, {
+      ...(current.checklistId ? { checklistId: current.checklistId } : {}),
+      ...(cell?.version ? { version: cell.version } : {}),
+      ...(current.seat ? { seat: current.seat } : {}),
+    }, []);
+    const from = runIdentityFieldText(identity, tag.key);   // 확인 안 된 칸은 «미기록»
+    const to = tag.key === 'protect' ? String(tag.value) : tag.value;
+    return { ...current, identity: applyRunIdentityTag(identity, tag), history: [...current.history, { at, event: RUN_TAG_CHANGE_EVENT, kind: RUN_TAG_CHANGE_EVENT, detail: `${tag.key} ${from}→${to}`, from, to, by: input.by, ...(input.reason ? { reason: input.reason } : {}) }] };
+  });
+}
+
+/** RUN-IDENTITY-TAGS — 칸 읽기(기본): 칸보드 `version`(기본 = 개발 판)에서 `checklistId` 로 읽는다. 읽기 실패·빠칸은 조용히 `undefined`(= «모른다») — 호출자는 기본 신분을 세우지 않고 명시 태그만 담는다(나머지 «미기록»). */
+export function readChecklistCellForBirth(checklistId: string, boardVersion?: string): { title?: string; priority?: string; version?: string } | undefined {
+  try {
+    const version = boardVersion ?? checklistDevVersion();
+    const cell = listChecklist(version).items.find((item) => item.id === checklistId);
+    return cell ? { title: cell.title, priority: cell.priority, version } : undefined;
+  } catch { return undefined; }
+}
+
 /** 첫 수의 elanous 인자(진입점·--config-dir 앞붙임은 launcher 몫). */
-export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm'>): string[] {
+export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm' | 'identity'>): string[] {
   const child = card.childLlm
     ? ['--child-llm-provider', card.childLlm.provider, '--child-llm-model', card.childLlm.model, ...(card.childLlm.effort ? ['--child-llm-effort', card.childLlm.effort] : [])]
     : [];
-  return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', ...child, card.text];
+  const runPriority = runIdentityQueuePriority(card.identity);
+  return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', ...(runPriority !== undefined ? ['--run-priority', String(runPriority)] : []), ...child, card.text];
 }
 
 /**
@@ -413,6 +527,7 @@ export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm'>):
 export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>, deps: { ledgerDir?: string } = {}): TaskCardMove {
   // Completion callbacks record a shadow decision; do not suggest the live CLI here.
   if (card.pieces) return { kind: 'wait', reason: `미션 — 조각 ${card.pieces.length}장이 선후대로 발사된다` };
+  if (card.alreadyDoneCandidate) return { kind: 'wait', reason: `main ${card.alreadyDoneCandidate.mainSha.slice(0, 12)} (검사 시점) 증거 명령 통과 — green 후보 · 주인 판정 대기` };
   const unmet = (card.after ?? []).filter((id) => !landed?.has(id));
   if (card.status !== 'launched' && unmet.length > 0) return { kind: 'wait', reason: `after ${unmet.join(', ')}${landed ? '' : ' · 착지 미확인'}` };
   if (card.status === 'handed') return { kind: 'launch', command: launchArgs(card), reason: '넘겨받은 과제 — 첫 발사' };
@@ -462,11 +577,26 @@ export interface HandTaskOptions {
   /** TASKS-HAND-CHILD-LLM — `<provider>/<model>`(`parseChildLlm`) ⊕ 선택 추론 노력. effort 만 주면 거부. */
   childLlm?: string;
   childLlmEffort?: string;
+  tier?: TaskCard['tier'];
+  /** RUN-IDENTITY-TAGS — `tasks hand --tag k=v`(반복): 출생 신분을 덮는다. 목록 밖 값은 거부한다(`run-identity.js`). */
+  tags?: string[];
+  /** RUN-IDENTITY-TAGS — 칸 읽기 seam(우선순위·대표 표시). 주면 그 답이 최종이다(«칸 없음» 포함). */
+  checklistCell?: RunIdentityCellLookup;
+  /**
+   * RUN-IDENTITY-TAGS-2 — 칸을 찾은 칸보드 판. 주면 그 판에서 `checklistId` 로 칸을 읽는다(`checklistCell` 이 없을 때).
+   * 안 주면 «판 모름» — 다른 판의 같은 id(우선순위가 다를 수 있다)를 그 칸이라 짐작하지 않으므로 칸에서 파생되는
+   * 신분 칸(class·care·protect·rights)을 확정하지 않는다(명시 `--tag` 만 담고 나머지 «미기록»).
+   */
+  checklistVersion?: string;
   statePath?: string;
   /** 시험에서만 조합 저장소를 바꿔 해석·거부를 검증한다. */
   compositionRoot?: string;
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
+  /** Deterministic contract seam; production uses the pinned-main verifier. */
+  prelaunchInspector?: (text: string, projectTarget?: string) => AlreadyDoneDecision;
+  /** Test-only: inject Git calls into the production verifier; no CLI/config surface. */
+  prelaunchGitRunnerForTest?: PrelaunchGitRunnerForTest;
   now?: () => Date;
   id?: string;
   /** 미션 조각으로 넘길 때 — 카드에 소속 미션·선후를 싣는다. */
@@ -533,6 +663,24 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (value !== undefined && (!value.trim() || /\p{Cc}/u.test(value))) throw new Error(`${flag} id 가 비었거나 제어 문자를 담았다: ${JSON.stringify(value)}`);
   }
   if (opts.childLlmEffort !== undefined && opts.childLlm === undefined) throw new Error('--child-llm-effort 는 --child-llm <provider>/<model> 과 함께 준다');
+  if (opts.tier !== undefined && !['하', '중', '상', '특'].includes(opts.tier)) throw new Error(`--tier 는 하|중|상|특 중 하나다: ${opts.tier}`);
+  // RUN-IDENTITY-TAGS — 출생 신분: 칸 우선순위(P0 = critical·special·protect · P1 = normal · 그 외 normal)·대표 표시에서 단다.
+  // `--tag k=v`(반복) 이 덮는다 — 칸·태그 없는 손은 오늘 모양 그대로다(신분 없음). 목록 밖 값은 카드를 적기 전에 거부한다(`run-identity.js` 정본).
+  const birthCell = opts.checklistId === undefined ? undefined
+    // 주입한 칸 조회가 있으면 그 답(«칸 없음» 포함)이 최종이다 — 칸보드는 조회기가 없을 때만 읽는다.
+    : opts.checklistCell !== undefined ? cellOnExpectedBoard(opts.checklistCell(opts.checklistId), opts.checklistVersion)
+    // 판을 받았으면 «그 판»에서 읽는다 · 판을 모르면 읽지 않는다(개발 판의 같은 id 를 그 칸이라 짐작하지 않는다 — «미기록»).
+    : opts.checklistVersion !== undefined ? readChecklistCellForBirth(opts.checklistId, opts.checklistVersion) : undefined;
+  const birthTags = opts.tags ?? [];
+  // 칸을 줬는데 칸보드에서 못 읽었으면(조회 실패·빠칸) 우선순위를 «모른다» — 기본 normal 을 사실처럼 적지 않고 신분을 비운다(화면은 «미기록»).
+  // 명시 `--tag` 가 있으면 «그 태그만» 신분에 담는다 — 칸을 못 읽었으면 덮지 않은 칸(care·rights·protect…)은 «미기록»으로 남는다(기본값으로 확정하지 않는다).
+  const identity = birthTags.length === 0 && (opts.checklistId === undefined || birthCell === undefined) ? undefined
+    : confirmedRunIdentity(birthCell, {
+      ...(opts.checklistId ? { checklistId: opts.checklistId } : {}),
+      ...(birthCell?.version ? { version: birthCell.version } : {}),
+      ...(opts.seat ? { seat: opts.seat } : {}),
+      launcher: 'hand',
+    }, birthTags);
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
   const completion = opts.completion ?? 'code-pr';
   const selected = selectTaskComposition(completion, opts.compositionRoot);
@@ -562,6 +710,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     id, text,
     ...(opts.seat ? { seat: opts.seat } : {}),
     ...(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 } : {}),
     unitsResolved: selected.unitsResolved,
@@ -571,6 +720,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.milestone ? { milestone: opts.milestone } : {}),
     ...(opts.taLand === true ? { taLand: true as const } : {}),
     ...(childLlm ? { childLlm } : {}),
+    ...(opts.tier ? { tier: opts.tier } : {}),
+    ...(identity ? { identity } : {}),
     createdAt: now.toISOString(),
     status: selectionFailure ? 'failed' : 'handed',
     history: selectionFailure ? [{ at: now.toISOString(), event: !selected.composition ? 'composition-missing'
@@ -604,12 +755,27 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   }); } catch { /* fail-soft */ }
   if (selectionFailure) throw new Error(`${selectionFailure} (카드 ${id})`);
   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 }); } catch { /* fail-soft */ }
+  try { debug.log('task-agent', 'handed', { taskId: id, seat: card.seat ?? null, checklistId: card.checklistId ?? null, mode, projectId: project?.id ?? null, targetIsGit, taLand: card.taLand === true, runPriority: card.identity ? runPriorityClass(card.identity) : null }); } catch { /* fail-soft */ }
   if (childLlm) {
     try { debug.log('task-agent', 'child-llm', { taskId: id, input: opts.childLlm, provider: childLlm.provider, model: childLlm.model, effort: childLlm.effort ?? null, mode }); } catch { /* fail-soft */ }
   }
   if (mode === 'shadow') return { card, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
+  let prelaunch: AlreadyDoneDecision;
+  try { prelaunch = completion === 'code-pr'
+    ? (opts.prelaunchInspector ?? ((input, target) => inspectPrelaunchAlreadyDone(input, target,
+      opts.prelaunchGitRunnerForTest ? { runGit: opts.prelaunchGitRunnerForTest } : {})))(text, project?.target)
+    : { reason: 'completion-not-code-pr' }; }
+  catch { prelaunch = { reason: 'prelaunch-unmeasured' }; }
+  try { debug.log('task-agent', 'prelaunch-already-done', { taskId: id, result: prelaunch.reason,
+    mainSha: prelaunch.candidate?.mainSha ?? null, command: prelaunch.candidate?.command ?? null }); } catch { /* fail-soft */ }
+  if (prelaunch.candidate) {
+    const candidate: TaskCard = { ...card, alreadyDoneCandidate: { ...prelaunch.candidate, at: (opts.now ?? (() => new Date()))().toISOString() },
+      history: [...card.history, { at: (opts.now ?? (() => new Date()))().toISOString(), event: 'already-done-candidate',
+        detail: `${prelaunch.candidate.repository} main ${prelaunch.candidate.mainSha} · rc=0 · ${prelaunch.candidate.command}` }] };
+    writeCard(path, candidate);
+    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,
@@ -643,6 +809,17 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ],
   };
   writeCard(path, launched);
+  // INFLIGHT-REGISTRY — 출발 때 맥락을 남긴다(머지 때 같은 파일 줄의 의도를 스마트 머지가 읽는다 · 착지하면 지운다).
+  try {
+    const [head = '', ...rest] = text.split(/\r?\n/);
+    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,
+      files: parseAskTargetPathHints(text),
+    }, { path: join(dirname(path), INFLIGHT_REGISTRY_FILE), ...(opts.now ? { now: opts.now } : {}) });
+  } catch (error) {
+    try { debug.log('pr-tool.inflight', 'register-failed', { taskId: id, error: String((error as Error)?.message ?? error).slice(0, 200) }, { level: 'warn' }); } catch { /* fail-soft */ }
+  }
   try { debug.log('task-agent', 'launched', { taskId: id, seat: card.seat ?? null, runId: boundRunId ?? null }); } catch { /* fail-soft */ }
   if (boundRunId) {
     try { debug.log('task-agent', 'card-run-bound', { card: id, runId: boundRunId, launchId }); } catch { /* fail-soft */ }

package/src/task-agent/train-landing.ts

@@ -0,0 +1,77 @@
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface TrainLanding {
+  componentPr: number;
+  integrationPr: number;
+  mergeSha: string;
+  train: string;
+}
+
+interface TrainLedgerRow extends Omit<TrainLanding, 'mergeSha'> { mergePrefix: string }
+
+/** HQ train ledger is advisory until the integration PR's exact merge commit is verified. */
+export function trainLedgerPath(): string {
+  return process.env.ELANOUS_TRAIN_LEDGER_PATH || join(homedir(), 'elanous-hq', 'seat-state', 'OP', 'train-ledger.tsv');
+}
+
+export function trainLedgerComponent(text: string, componentPr: number): TrainLedgerRow | null {
+  const lines = text.trim().split(/\r?\n/);
+  if (lines.shift() !== 'time\ttrain\tintegrationPr\tmergeSha\tcomponentPrs\tsideHost\tresult') return null;
+  let matched: TrainLedgerRow | null = null;
+  let matchedLine: string | null = null;
+  for (const line of lines) {
+    const fields = line.split('\t');
+    if (fields.length !== 7) return null;
+    const integrationPr = Number(fields[2]);
+    const mergePrefix = fields[3]?.toLowerCase() ?? '';
+    const componentPrs = (fields[4] ?? '').split(',').map(Number);
+    if (!componentPrs.every((pr) => Number.isSafeInteger(pr) && pr > 0)) return null;
+    if (!componentPrs.includes(componentPr)) continue;
+    if (fields[6] !== 'merged' || !Number.isSafeInteger(integrationPr) || integrationPr <= 0
+      || !/^[a-f0-9]{12,40}$/.test(mergePrefix)) return null;
+    const row = { componentPr, integrationPr, mergePrefix, train: fields[1] ?? '' };
+    if (matchedLine !== null && matchedLine !== line) return null;
+    matched = row;
+    matchedLine = line;
+  }
+  return matched;
+}
+
+export type TrainPrView = (pr: number, cwd: string) => { state: string; mergeSha?: string } | null;
+
+export function defaultTrainPrView(pr: number, cwd: string): ReturnType<TrainPrView> {
+  const run = (env: NodeJS.ProcessEnv) => spawnSync('gh', ['pr', 'view', String(pr), '--json', 'state,mergeCommit'],
+    { cwd, env, encoding: 'utf8', timeout: 20_000, maxBuffer: 512 * 1024 });
+  let result = run(process.env);
+  if (result.status !== 0) {
+    const noProxy = { ...process.env };
+    for (const key of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy']) delete noProxy[key];
+    result = run(noProxy);
+  }
+  if (result.status !== 0) return null;
+  try {
+    const parsed = JSON.parse(result.stdout) as { state?: unknown; mergeCommit?: { oid?: unknown } };
+    return typeof parsed.state === 'string' && typeof parsed.mergeCommit?.oid === 'string'
+      ? { state: parsed.state, mergeSha: parsed.mergeCommit.oid } : null;
+  } catch { return null; }
+}
+
+export function verifiedTrainLanding(componentPr: number, cwd: string, opts: {
+  ledgerText?: string;
+  readLedger?: () => string;
+  trainPrView?: TrainPrView;
+} = {}): TrainLanding | null {
+  let ledger: string;
+  try { ledger = opts.ledgerText ?? (opts.readLedger ?? (() => readFileSync(trainLedgerPath(), 'utf8')))(); }
+  catch { return null; }
+  const row = trainLedgerComponent(ledger, componentPr);
+  if (!row) return null;
+  let view: ReturnType<TrainPrView>;
+  try { view = (opts.trainPrView ?? defaultTrainPrView)(row.integrationPr, cwd); } catch { return null; }
+  const mergeSha = view?.mergeSha?.toLowerCase();
+  return view?.state === 'MERGED' && mergeSha && /^[a-f0-9]{40}$/.test(mergeSha) && mergeSha.startsWith(row.mergePrefix)
+    ? { componentPr, integrationPr: row.integrationPr, mergeSha, train: row.train } : null;
+}

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

@@ -0,0 +1,104 @@
+/**
+ * TASK-AGENT 작업 지시서(work order) 스키마 — RFC-adaptive-graph-ops-2026-10-09 §9 «작업 지시서» 칸 아홉.
+ *
+ * 조율자 → TA 호출의 계약으로 칸 제목 한 줄을 대신한다. 이 첫 조각은 스키마와 검증(`parseWorkOrder`)·
+ * 골 문면 펼치기만 담는다 — 조율자가 칸·신호·선례에서 지시서를 «자동 작성»하는 일은 다음 조각이다.
+ *
+ * 칸 아홉(RFC 목록 그대로 — 칸 1·4는 여러 키로 펼친다):
+ *   1. `lifeId` · 칸 id(`cellId`) · 판(`version`) · 착지 마감(`landBy`) — cellId 만 필수다.
+ *   2. 신분 태그(`identityTags` — class·care·rights·origin·rework)
+ *   3. 우선순위(`priority` — 신호 order 순위 · 승수 등급 · 대표 표시)
+ *   4. 판정 신호(`verdictSignal` — 조건·관측·기대) ⊕ 현재 계약 한 줄(`contract`)
+ *   5. 경계(`boundary` — 대상 경로 · 건드리지 말 곳)
+ *   6. 예산(`budget` — 시간 · 모델 티어 · Pod 자리 · 재작업 상한)
+ *   7. 선행·짝 칸(`peers`)
+ *   8. 선례 묶음(`precedents` — 같은 칸 앞 생애 결말·must-fix 서명)
+ *   9. 올림 규칙(`escalation` — 무엇이면 누구에게 · 돈·보안은 대표)
+ *
+ * 빠진 칸은 거부하지 않고 «모름»(`WORK_ORDER_UNKNOWN`)으로 채워 그 키를 `unknownFields` 에 적는다
+ * (RFC: 비우면 TA 가 추측한다). 거부는 두 가지뿐 — JSON 이 깨졌거나 칸 id 가 없거나.
+ */
+
+/** 빠진 칸을 채우는 값 — RFC «빠진 칸은 «모름»으로 적는다». */
+export const WORK_ORDER_UNKNOWN = '모름';
+/** 지시서 골 파일 이름 접미 — 이 이름으로 끝나는 파일만 지시서로 검증한다. */
+export const WORK_ORDER_FILE_PATTERN = /\.work-order\.json$/i;
+
+/** 칸 아홉 중 채울 수 있는 키(칸 id 제외) — unknownFields 는 이 순서로 적는다. */
+export const WORK_ORDER_FIELDS = [
+  'lifeId', 'version', 'landBy',
+  'identityTags', 'priority', 'verdictSignal', 'contract',
+  'boundary', 'budget', 'peers', 'precedents', 'escalation',
+] as const;
+export type WorkOrderField = typeof WORK_ORDER_FIELDS[number];
+
+/** 검증을 통과한 작업 지시서 — 모든 칸이 문자열로 채워져 있다(빠진 칸은 «모름»). */
+export interface WorkOrder {
+  lifeId: string;
+  /** 필수 칸 — 이것만 없으면 거부한다. */
+  cellId: string;
+  version: string;
+  landBy: string;
+  identityTags: string;
+  priority: string;
+  verdictSignal: string;
+  contract: string;
+  boundary: string;
+  budget: string;
+  peers: string;
+  precedents: string;
+  escalation: string;
+  /** 입력에 없어 «모름»으로 채운 키. */
+  unknownFields: string[];
+}
+
+export type ParseWorkOrderResult = { ok: true; order: WorkOrder } | { ok: false; reason: string };
+
+/** 칸 하나를 사람이 읽는 문자열로 정규화한다 — 없거나 비면 «모름», 문자열이 아니면 JSON 표기로. */
+function cellText(value: unknown): string {
+  if (value === undefined || value === null) return WORK_ORDER_UNKNOWN;
+  if (typeof value === 'string') { const carried = value.trim(); return carried || WORK_ORDER_UNKNOWN; }
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  try { const carried = JSON.stringify(value); return carried === 'null' || carried === undefined ? WORK_ORDER_UNKNOWN : carried; }
+  catch { return WORK_ORDER_UNKNOWN; }
+}
+
+/**
+ * 지시서 JSON 원문을 검증한다. 깨진 JSON 은 `JSON 이 깨졌다: …`, 칸 id(문자열)가 없으면 `칸 id 가 없다`
+ * 하나로 거부하고, 그 밖의 빠진 칸은 «모름»으로 채운다(거부 아님).
+ */
+export function parseWorkOrder(source: string): ParseWorkOrderResult {
+  let parsed: unknown;
+  try { parsed = JSON.parse(source); }
+  catch (error) {
+    return { ok: false, reason: `JSON 이 깨졌다: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const record = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  const rawCellId = record['cellId'];
+  if (typeof rawCellId !== 'string' || !rawCellId.trim()) return { ok: false, reason: '칸 id 가 없다' };
+  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);
+    cells[field] = text;
+  }
+  return { ok: true, order: { cellId: rawCellId.trim(), ...cells, unknownFields } };
+}
+
+/** 검증된 지시서를 사람이 읽는 골 문면으로 펼친다 — 첫 줄 «대상 경로:»(경계), 둘째 줄 «현재 계약:». */
+export function renderWorkOrderGoal(order: WorkOrder): string {
+  return [
+    `대상 경로: ${order.boundary}`,
+    `현재 계약: ${order.contract}`,
+    '',
+    `[${order.lifeId} · 칸 ${order.cellId} · 판 ${order.version} · 착지 마감 ${order.landBy}]`,
+    `신분 태그: ${order.identityTags}`,
+    `우선순위: ${order.priority}`,
+    `판정 신호: ${order.verdictSignal}`,
+    `예산: ${order.budget}`,
+    `선행·짝 칸: ${order.peers}`,
+    `선례: ${order.precedents}`,
+    `올림 규칙: ${order.escalation}`,
+  ].join('\n');
+}