elanous 0.2.28 → 0.2.31

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

@@ -0,0 +1,200 @@
+/**
+ * RUN-IDENTITY-TAGS(칸 0.2.32 · P0) — 런 신분 묶음 정본(RFC adaptive-graph-ops §9.9).
+ *
+ * - 닫힌 목록 신분 묶음 `RunIdentity`: GATE-PRIORITY 의 «run priority» 를 `class` 로
+ *   흡수한다(승인·선점이 `RUN_IDENTITY_QUEUE_PRIORITY` 로 이 문을 읽는다 — 나머지
+ *   디스패처 배선은 RUN-IDENTITY-ADMIT).
+ * - parse/validate: 목록 밖 값은 거부한다(조용히 다듬지 않는다).
+ * - 출생 신분 자동(`deriveBirthIdentity`): 칸 우선순위(P0 = critical·special·protect ·
+ *   P1 = normal · 그 외 normal)·대표 표시에서 단다.
+ * - 태그 덮기(`applyRunIdentityTags`): `tasks hand --tag k=v`(반복) 이 출생 신분을 덮는다.
+ * - ⛔ 모르는 칸을 기본값으로 확정하지 않는다: 칸 조회가 실패하면 명시 태그만 담고 나머지는 «미기록».
+ * - 태그 바꾸기 감사(`runTagChange` — task-hand.ts): 카드 history 에 `run-tag-change`
+ *   {from, to, by, reason} 을 남긴다.
+ */
+
+/** 신분 계급 — GATE-PRIORITY «run priority» 흡수: 게이트|착지|비상|보통|유휴. */
+export const RUN_IDENTITY_CLASSES = ['gate', 'landing', 'critical', 'normal', 'idle'] as const;
+export type RunIdentityClass = (typeof RUN_IDENTITY_CLASSES)[number];
+/** 돌봄: 표준|특별|집중돌봄. */
+export const RUN_IDENTITY_CARES = ['standard', 'special', 'icu'] as const;
+export type RunIdentityCare = (typeof RUN_IDENTITY_CARES)[number];
+/** 권한 크기: 보통|중간|큰. */
+export const RUN_IDENTITY_RIGHTS = ['s', 'm', 'l'] as const;
+export type RunIdentityRights = (typeof RUN_IDENTITY_RIGHTS)[number];
+/** 출생 자리: 디스패처|손|대기열|의사. */
+export const RUN_IDENTITY_LAUNCHERS = ['dispatcher', 'hand', 'queue', 'doctor'] as const;
+export type RunIdentityLauncher = (typeof RUN_IDENTITY_LAUNCHERS)[number];
+
+/** 출생 기록 — 칸마다 optional: 없는 칸은 «미기록»(모른다)이다. 출생 자리를 모르면 `launcher` 를 비운다(지어내지 않는다). */
+export interface RunIdentityOrigin {
+  checklistId?: string;
+  version?: string;
+  seat?: string;
+  launcher?: RunIdentityLauncher;
+}
+
+/**
+ * 런 신분 묶음 — 카드 상태 파일(원장 정본)에 실린다(`TaskCard.identity`).
+ * ⛔ 모르는 칸을 기본값으로 확정하지 않는다 — 칸마다 optional 이고 없는 칸은 «미기록»이다.
+ * 확인된 칸만 담는다: 명시 태그(`--tag k=v`) ⊕ 조회에 성공한 칸에서 단 출생값(`deriveBirthIdentity`).
+ * 승인·선점이 `class` 를 못 찾으면 normal 로 «읽을» 뿐(`runPriorityClass`) 원장엔 적지 않는다.
+ */
+export interface RunIdentity {
+  class?: RunIdentityClass;
+  care?: RunIdentityCare;
+  rights?: RunIdentityRights;
+  protect?: boolean;
+  origin: RunIdentityOrigin;
+}
+
+/** 화면·감사 줄의 «미기록» 표기 — 원장에 없는 칸(모른다). */
+export const RUN_IDENTITY_UNRECORDED = '미기록';
+
+/** 신분 칸 하나를 글로 — 없으면 «미기록»(기본값으로 채우지 않는다). */
+export function runIdentityFieldText(identity: RunIdentity | undefined, key: RunTagKey): string {
+  const value = identity?.[key];
+  return value === undefined ? RUN_IDENTITY_UNRECORDED : String(value);
+}
+
+/** `--tag k=v` 칸(닫힌 목록) — 신분의 어느 칸을 바꾸는지. */
+export const RUN_TAG_KEYS = ['class', 'care', 'rights', 'protect'] as const;
+export type RunTagKey = (typeof RUN_TAG_KEYS)[number];
+export type RunIdentityTag =
+  | { key: 'class'; value: RunIdentityClass }
+  | { key: 'care'; value: RunIdentityCare }
+  | { key: 'rights'; value: RunIdentityRights }
+  | { key: 'protect'; value: boolean };
+
+/** 칸(체크리스트 셀) — 출생 신분이 단다: 우선순위·대표 표시(제목)·칸보드 판. */
+export interface RunIdentityCell {
+  title?: string;
+  priority?: string;
+  version?: string;
+}
+
+export function parseRunIdentityClass(value: string): RunIdentityClass {
+  if (!RUN_IDENTITY_CLASSES.includes(value as RunIdentityClass)) throw new Error(`run identity class 는 ${RUN_IDENTITY_CLASSES.join('|')} 중 하나다: ${JSON.stringify(value)}`);
+  return value as RunIdentityClass;
+}
+
+export function parseRunIdentityCare(value: string): RunIdentityCare {
+  if (!RUN_IDENTITY_CARES.includes(value as RunIdentityCare)) throw new Error(`run identity care 는 ${RUN_IDENTITY_CARES.join('|')} 중 하나다: ${JSON.stringify(value)}`);
+  return value as RunIdentityCare;
+}
+
+export function parseRunIdentityRights(value: string): RunIdentityRights {
+  if (!RUN_IDENTITY_RIGHTS.includes(value as RunIdentityRights)) throw new Error(`run identity rights 는 ${RUN_IDENTITY_RIGHTS.join('|')} 중 하나다: ${JSON.stringify(value)}`);
+  return value as RunIdentityRights;
+}
+
+export function parseRunIdentityProtect(value: string): boolean {
+  if (value !== 'true' && value !== 'false') throw new Error(`run identity protect 는 true|false 다: ${JSON.stringify(value)}`);
+  return value === 'true';
+}
+
+/** `k=v` 한 줄을 신분 태그로 — 모르는 칸·목록 밖 값은 거부한다. */
+export function parseRunIdentityTag(tag: string): RunIdentityTag {
+  const eq = tag.indexOf('=');
+  const key = eq < 0 ? '' : tag.slice(0, eq);
+  const value = eq < 0 ? '' : tag.slice(eq + 1);
+  if (!RUN_TAG_KEYS.includes(key as RunTagKey)) throw new Error(`run identity 태그 칸은 ${RUN_TAG_KEYS.join('|')} 중 하나다: ${JSON.stringify(tag)}`);
+  switch (key) {
+    case 'class': return { key: 'class', value: parseRunIdentityClass(value) };
+    case 'care': return { key: 'care', value: parseRunIdentityCare(value) };
+    case 'rights': return { key: 'rights', value: parseRunIdentityRights(value) };
+    default: return { key: 'protect', value: parseRunIdentityProtect(value) };
+  }
+}
+
+/** 이미 검증한 태그 하나를 신분에 얹는다(검증은 `parseRunIdentityTag` 몫). */
+export function applyRunIdentityTag(identity: RunIdentity, tag: RunIdentityTag): RunIdentity {
+  switch (tag.key) {
+    case 'class': return { ...identity, class: tag.value };
+    case 'care': return { ...identity, care: tag.value };
+    case 'rights': return { ...identity, rights: tag.value };
+    default: return { ...identity, protect: tag.value };
+  }
+}
+
+/** `--tag k=v`(반복) 이 출생 신분을 덮는다 — 순서대로 얹는다. */
+export function applyRunIdentityTags(identity: RunIdentity, tags: readonly string[]): RunIdentity {
+  let next = identity;
+  for (const tag of tags) next = applyRunIdentityTag(next, parseRunIdentityTag(tag));
+  return next;
+}
+
+/** 대표 표시(왕관) — 이스케이프로 적어 이 줄이 누출 검사(ceo-mark)에 걸리지 않게 한다. */
+const CROWN_MARK = '\u{1F451}';
+
+/**
+ * 출생 신분 자동 — «조회에 성공한» 칸의 우선순위(P0 = critical·special·protect · P1 = normal · 그 외 normal)·대표 표시에서 단다.
+ * 권한(rights)은 출생에서 올리지 않는다(기본 s · 올림은 `--tag rights=…` 명시만).
+ * ⛔ 칸을 못 읽었으면 부르지 않는다 — 그때는 `{ origin }` 에 명시 태그만 얹는다(나머지 «미기록»).
+ * ⛔ 읽은 칸이라도 `priority`·`title` 이 비면 그 값에서 파생되는 칸을 확정하지 않는다(«미기록»):
+ *   class 는 priority 가 있어야 · care·protect 는 P0 이거나 대표 가 보이면 올리고, «안 올림»(standard·false)은
+ *   priority 와 title 이 둘 다 있을 때만 확정한다.
+ */
+export function deriveBirthIdentity(cell: RunIdentityCell, origin: RunIdentityOrigin): RunIdentity {
+  const priority = cell.priority?.trim() ? cell.priority.trim() : undefined;
+  const title = cell.title?.trim() ? cell.title : undefined;
+  const critical = priority === 'P0';
+  const crown = title?.includes(CROWN_MARK) === true;
+  const raised = critical || crown;
+  const careKnown = raised || (priority !== undefined && title !== undefined);
+  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,
+  };
+}
+
+/** GATE-PRIORITY «run priority» 흡수 — 신분 `class` 가 런 우선순위다(승인·선점이 읽는다 · 없거나 «미기록»이면 normal 로 «읽는다» — 원장엔 적지 않는다). */
+export function runPriorityClass(identity?: Pick<RunIdentity, 'class'> | null): RunIdentityClass {
+  return identity?.class ?? 'normal';
+}
+
+/**
+ * 승인·선점 가늠자 — 신분 `class` 를 대기열 줄 우선순위로 옮긴다(RUN-IDENTITY-ADMIT 첫 배선).
+ * 게이트 > 착지 > 비상 순, 셋 다 칸 러브릭·CEO 보너스(`harness-queue.ts` ≈ 125.5 이하)보다
+ * 위에 줄 선다 — `tasks hand` 발사 인자가 이 값을 싣고 승인·선점이 읽는다.
+ * 보통·유휴는 칸 러브릭을 그대로 쓴다(값 없음).
+ */
+export const RUN_IDENTITY_QUEUE_PRIORITY: Record<RunIdentityClass, number | undefined> = { gate: 200, landing: 175, critical: 150, normal: undefined, idle: undefined };
+
+/** 신분의 대기열 줄 우선순위 — 보통·유휴는 칸 러브릭으로 흐른다(값 없음). */
+export function runIdentityQueuePriority(identity?: Pick<RunIdentity, 'class'> | null): number | undefined {
+  return RUN_IDENTITY_QUEUE_PRIORITY[runPriorityClass(identity)];
+}
+
+/** 평범한 객체인가 — 원형이 Object.prototype 또는 null 인 객체만(배열·Date·클래스 인스턴스·null 아님). 원장에서 읽은 값의 형태 검사. */
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+/**
+ * 원장에서 읽은 신분도 닫힌 목록으로 검증한다 — 목록 밖 값·형태가 틀린 값은 거부한다.
+ * 출생 기록(origin)은 없으면 «미기록»(빈 출생 기록 `{}` 으로 읽는다 — 지어내지 않는다) ·
+ * 있으면 평범한 객체여야 하고 checklistId·version·seat 는 문자열, launcher 는 닫힌 목록이다.
+ */
+export function validateRunIdentity(identity: RunIdentity): RunIdentity {
+  if (!isPlainRecord(identity)) throw new Error(`run identity 는 객체다: ${JSON.stringify(identity)}`);
+  // 칸마다 optional(없으면 «미기록») — 있는 칸만 닫힌 목록으로 검증한다.
+  const { class: klass, care, rights, protect, origin } = identity as Partial<RunIdentity>;
+  if (klass !== undefined && !RUN_IDENTITY_CLASSES.includes(klass)) throw new Error(`run identity class 는 ${RUN_IDENTITY_CLASSES.join('|')} 중 하나다: ${JSON.stringify(klass)}`);
+  if (care !== undefined && !RUN_IDENTITY_CARES.includes(care)) throw new Error(`run identity care 는 ${RUN_IDENTITY_CARES.join('|')} 중 하나다: ${JSON.stringify(care)}`);
+  if (rights !== undefined && !RUN_IDENTITY_RIGHTS.includes(rights)) throw new Error(`run identity rights 는 ${RUN_IDENTITY_RIGHTS.join('|')} 중 하나다: ${JSON.stringify(rights)}`);
+  if (protect !== undefined && typeof protect !== 'boolean') throw new Error(`run identity protect 는 true|false 다: ${JSON.stringify(protect)}`);
+  if (origin === undefined) return { ...identity, origin: {} };   // 출생 기록 «미기록» — 칸을 지어내지 않는다.
+  if (!isPlainRecord(origin)) throw new Error(`run identity origin 은 객체다: ${JSON.stringify(origin)}`);
+  for (const key of ['checklistId', 'version', 'seat'] as const) {
+    const value = origin[key];
+    if (value !== undefined && typeof value !== 'string') throw new Error(`run identity origin.${key} 는 문자열이다: ${JSON.stringify(value)}`);
+  }
+  const launcher = origin.launcher;
+  if (launcher !== undefined && !RUN_IDENTITY_LAUNCHERS.includes(launcher as RunIdentityLauncher)) throw new Error(`run identity 출생 자리는 ${RUN_IDENTITY_LAUNCHERS.join('|')} 중 하나다: ${JSON.stringify(launcher)}`);
+  return identity;
+}

package/src/task-agent/shadow.ts

@@ -2,8 +2,8 @@
  * TASK-AGENT-SHADOW — 슈퍼바이저가 런의 멈춤을 확정한 자리에서 판단부를 «그림자»로 부른다.
  *
  * RFC-task-agent-any-task-to-completion-2026-10-06 §A9 «판단부 호출부 0»을 메운다.
- * - 입력은 슈퍼바이저 결과에 «이미 실려 있는» 값만 쓴다(네트워크 호출 0): 종료 어휘 ·
- *   PR 번호/병합 여부(`prNumber`·`merged`). 리뷰 판정·must-fix 는 결과에 없으므로 비운다
+ * - 기본 판단은 슈퍼바이저 결과에 이미 실린 종료 어휘·PR 번호·병합 여부를 쓴다.
+ *   카드가 묶인 코드 PR의 target diff는 저장소가 고정된 gh 조회로 별도 측정한다. 리뷰 판정·must-fix 는 결과에 없으므로 비운다
  *   («통과»로 읽지 않는다 — 판단부가 review 수를 고른다).
  * - 슈퍼바이저의 기본 호출은 shadow: «했을 수»만 기록하고 명령·복사는 하나도 돌리지 않는다.
  *   전달 과제의 명시적 live 호출만 파일을 복사한다. 설정 `taskAgent.mode=live` 는 기본 호출에 먹지 않는다.
@@ -11,6 +11,8 @@
  */
 import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
+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 { readTaskAgentState, readTaskCard, taskAgentStatePath, TASK_CARD_PREFIX, type CompletionKind, type TaskCard } from './task-hand.js';
@@ -72,12 +74,32 @@ export interface TaskAgentShadowDeps {
   statePath?: string;
   /** TA-WIRING-CHECK — 배선 근거 수집 의존(시험 주입 · 기본 = gh pr diff 한 번 ⊕ 카드 런 원장). */
   wiring?: Omit<WiringEvidenceDeps, 'card'>;
+  /** Complete PR target paths; undefined means unmeasured, never goal-only. */
+  prFiles?: (pr: number, prUrl: string | undefined) => Promise<readonly string[] | undefined>;
   /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
   env?: NodeJS.ProcessEnv;
   /** Remote pending-move ledger seam; defaults to the run ledger. */
   queueMove?: typeof appendRunLedgerEntry;
 }
 
+const execFileAsync = promisify(execFile);
+export function prRepositoryFromUrl(pr: number, prUrl: string | undefined): string | undefined {
+  const match = prUrl?.match(/^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/(\d+)\/?$/);
+  return match && Number(match[3]) === pr ? `${match[1]}/${match[2]}` : undefined;
+}
+
+export async function defaultPrFiles(pr: number, prUrl: string | undefined,
+  run: (args: readonly string[]) => Promise<string> = async (args) => {
+    const { stdout } = await execFileAsync('gh', [...args],
+      { encoding: 'utf8', timeout: 20_000, maxBuffer: 4 * 1024 * 1024 });
+    return stdout;
+  }): Promise<readonly string[]> {
+  const repository = prRepositoryFromUrl(pr, prUrl);
+  if (!repository) throw new Error('bound PR repository unavailable');
+  const stdout = await run(['pr', 'diff', String(pr), '--name-only', '-R', repository]);
+  return stdout.split(/\r?\n/).filter(Boolean);
+}
+
 export const REMOTE_CARD_MOVE_PENDING = 'task-agent-card-move-pending';
 
 /** 카드 조회 상태 파일 — 조회 경로 전부가 같은 파일을 본다. */
@@ -258,6 +280,17 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     }
   }
   if (selfReview) judgeInput.review = selfReview.verdict;
+  if (card && typeof judgeInput.pr === 'number' && (!kind || kind === 'code-pr')) {
+    try {
+      const prUrl = typeof card.pr === 'object' && card.pr.number === judgeInput.pr && card.pr.url
+        ? card.pr.url : successful?.prUrl;
+      const files = await (deps.prFiles ?? defaultPrFiles)(judgeInput.pr, prUrl);
+      if (files) judgeInput.prTargetPaths = files;
+    } catch (error) {
+      try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'pr-target-diff-unavailable',
+        { runId: input.runId, pr: judgeInput.pr, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+    }
+  }
   const delivery = successful?.worktreePath && card?.project?.target && isDeliveryKind(kind)
     ? { kind, worktreePath: successful.worktreePath, projectTarget: card.project.target, files: selectDeliveryCandidates(successful.worktreePath, kind) }
     : undefined;
@@ -266,6 +299,16 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
       ? { move: 'wait', stage: 'observing', reason: '전달 후보 확인 — 산출물 판독 대기', executorKind: 'deliver' }
       : { move: 'wait', stage: 'waiting', reason: '전달 후보 없음' }
     : judgeNextMove(judgeInput);
+  if (judgement.reason.startsWith('goal-only-pr —') && input.runId) {
+    try {
+      (deps.queueMove ?? appendRunLedgerEntry)({ timestamp: new Date().toISOString(), runId: input.runId,
+        event: 'task-agent-goal-only-pr', data: { pr: judgeInput.pr, paths: judgeInput.prTargetPaths,
+          targetDiff: 0, reason: judgement.reason, requeue: 'stopped' } });
+    } catch (error) {
+      try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'goal-only-pr-ledger-failed',
+        { runId: input.runId, pr: judgeInput.pr, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+    }
+  }
   if (cardLookupFailed) judgement.reason = `${judgement.reason} · 종결 종류 미확인(카드 조회 실패)`;
   // 판단마다 해석한다 — 허용되지 않은 수를 판단할 때도 모르는 항목 경고가 남게.
   const liveMoves = deps.liveMoves ?? await configuredTaskAgentLiveMoves();
@@ -342,8 +385,12 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
           } } : {}),
         }, liveMoveDeps(deps));
     } else if (liveKind === 'propose-land') {
+      // A supervisor live move can reach land before the periodic rejudge tick. Carry
+      // the captured review file for this PR/head so queue mode can verify its bytes.
+      const reviewResultPath = boundCard?.reviewRequests?.find((request) => request.pr === prResult?.prNumber
+        && request.head.toLowerCase() === selfReview?.head.toLowerCase() && request.resultPath && !request.error)?.resultPath;
       liveMove = await executeLiveLand(boundCard, prResult?.prNumber,
-        { runId: input.runId, cycleId: input.cycleId, review: selfReview,
+        { runId: input.runId, cycleId: input.cycleId, review: selfReview, ...(reviewResultPath ? { reviewResultPath } : {}),
           ...(prResult?.worktreePath ? { cwd: prResult.worktreePath } : {}),
           ...(prResult && !prResult.worktreePath ? { produced: {
             ...(prResult.checkedHeadCommit !== undefined ? { headCommit: prResult.checkedHeadCommit } : {}),

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,12 @@ 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';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -33,13 +38,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 +77,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 +187,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 +248,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 +269,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 +294,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';
@@ -397,12 +431,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 +514,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 +564,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 +650,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 +697,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 +707,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 +742,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,