elanous 0.2.23 → 0.2.25

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

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+import { launchBindingRunIds, launchRegistryDir, readLaunchBinding } from '../harness/launch-registry.js';
+import { launchStampFromLedger } from '../harness/launch-stamp.js';
+import { normalizeRunId } from '../harness/harness-space.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
+import { TASK_SEATS, updateTaskCard, type TaskCard, type TaskSeat } from './task-hand.js';
+
+export interface RunBirth {
+  runId: string;
+  goalPath?: string;
+  cwd: string;
+  runsDir?: string;
+  env: Readonly<Record<string, string | undefined>>;
+}
+
+export interface RunAdoptDeps {
+  /** 카드 상태 파일(시험 주입). 없으면 우주 뿌리(`instanceRoot`) 아래 `task-agent-actions.json` = `taskAgentStatePath()`. */
+  statePath?: string;
+  /** 우주 뿌리 해석 seam — 기본 `effectiveInstanceRoot()`(state·runsDir 를 만드는 같은 공용 해석). */
+  instanceRoot?: () => string;
+  registryDir?: string;
+  knownChecklistIds?: ReadonlySet<string>;
+  now?: () => Date;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export type RunAdoptSkipReason = 'handed' | 'already-carded' | 'pod-child' | 'other-universe' | 'universe-mismatch';
+export type RunAdoptResult = { card: TaskCard; adopted: true } | { adopted: false; reason: RunAdoptSkipReason };
+
+function seatFromGoal(path: string | undefined): TaskSeat | undefined {
+  const seat = path?.replaceAll('\\', '/').match(/\/(?:seat-state|seats)\/(OP|TC|MK|UX)\//)?.[1];
+  return seat as TaskSeat | undefined;
+}
+
+function goalText(path: string | undefined, cwd: string): string {
+  if (!path) return '';
+  try {
+    const fullPath = isAbsolute(path) ? path : resolve(cwd, path);
+    return readFileSync(fullPath, 'utf8');
+  } catch { return ''; }
+}
+
+function checklistFromText(text: string, known: ReadonlySet<string>): string | undefined {
+  const explicit = /칸\s+([A-Za-z0-9][A-Za-z0-9_-]*)/.exec(text)?.[1];
+  if (explicit) return explicit;
+  const title = /(?:^|\n)제목:\s*([A-Za-z0-9][A-Za-z0-9_-]*?)-\d+\s+—/m.exec(text)?.[1];
+  return title && known.has(title) ? title : undefined;
+}
+
+/** 경로 정규화 — 심볼릭 링크(`/var`↔`/private/var` 등)·상대·후행 슬래시를 같은 값으로. 없는 꼬리는 있는 조상의 실경로에 붙인다. */
+function canonicalPath(path: string): string {
+  const absolute = resolve(path);
+  let head = absolute;
+  const tail: string[] = [];
+  while (!existsSync(head)) {
+    const parent = dirname(head);
+    if (parent === head) return absolute;
+    tail.unshift(basename(head));
+    head = parent;
+  }
+  try { return join(realpathSync(head), ...tail); } catch { return absolute; }
+}
+
+/** Adopt only a run belonging to this universe. The universe root is resolved once (`effectiveInstanceRoot()` unless a
+ *  state path is injected) and both the card state file and the run's `runsDir` are compared against it after canonical
+ *  path resolution. The runId check and write share updateTaskCard's lock.
+ *  A birth without `runsDir` cannot prove its universe and is skipped as `other-universe` (conservative); a `runsDir` that is
+ *  not `<root>/self-dev-runs` is skipped as `universe-mismatch` with both paths observed — never silently. */
+export function adoptRunCard(birth: RunBirth, deps: RunAdoptDeps = {}): RunAdoptResult {
+  const root = deps.statePath ? dirname(deps.statePath) : (deps.instanceRoot ?? effectiveInstanceRoot)();
+  const statePath = deps.statePath ?? join(root, 'task-agent-actions.json');
+  const log = deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data));
+  const skip = (reason: RunAdoptSkipReason, extra: Record<string, unknown> = {}): RunAdoptResult => {
+    log('task-agent', 'run-adopt-skipped', { runId: birth.runId, reason, ...extra });
+    return { adopted: false, reason };
+  };
+  if (birth.env.ELANOUS_TASK_CARD_ID) return skip('handed');
+  if (birth.env.ELANOUS_POD_NAME) return skip('pod-child');
+  if (!birth.runsDir) return skip('other-universe', { statePath, runsDir: null });
+  const expectedRunsDir = canonicalPath(join(root, 'self-dev-runs'));
+  const runsDir = canonicalPath(birth.runsDir);
+  if (runsDir !== expectedRunsDir) return skip('universe-mismatch', { statePath, runsDir: birth.runsDir, expectedRunsDir, canonicalRunsDir: runsDir });
+  if (!birth.runId || birth.runId !== normalizeRunId(birth.runId) || birth.runId.includes(sep)) throw new Error(`invalid runId: ${birth.runId}`);
+  const text = goalText(birth.goalPath, birth.cwd);
+  const firstLine = text.split(/\r?\n/).find(line => line.trim())?.trim() ?? `harness run ${birth.runId}`;
+  let stamp = launchStampFromLedger(null);
+  try { stamp = launchStampFromLedger(loadRunLedger(birth.runId, runLedgerDir(root))); } catch { /* unreadable stamp is unknown */ }
+  const origin = stamp.entrance;
+  const actor = stamp.actor;
+  const seat = TASK_SEATS.find(candidate => candidate === actor) ?? seatFromGoal(birth.goalPath);
+  const checklistId = checklistFromText(text, deps.knownChecklistIds ?? new Set());
+  const id = `ta-${birth.runId}`;
+  let adopted = false;
+  const card = updateTaskCard(statePath, id, (current, tasks) => {
+    if (current || Object.values(tasks).some(candidate => candidate.runId === birth.runId)) return undefined;
+    adopted = true;
+    const at = (deps.now ?? (() => new Date()))().toISOString();
+    return {
+      id, text: firstLine, status: 'launched', runId: birth.runId,
+      ...(birth.goalPath ? { goal: birth.goalPath } : {}),
+      ...(seat ? { seat } : {}),
+      ...(checklistId ? { checklistId } : {}),
+      createdAt: at, history: [{ at, event: 'adopted', detail: origin }],
+    };
+  });
+  if (!adopted || !card) return skip('already-carded');
+  log('task-agent', 'run-adopted', { card: card.id, runId: birth.runId, origin, seat: seat ?? null, checklistId: checklistId ?? null });
+  return { card, adopted: true };
+}
+
+/** Explicit backfill for old launch bindings (`elanous tasks adopt-runs`); not part of the launch-time path.
+ *  The binding's launch-time `podName`/`taskCardId` stand in for the env, so Pod children and handed runs are skipped.
+ *  Bindings written before those fields existed carry no marker — the host registry is per-host `$TMPDIR`, and a Pod
+ *  child writes its binding inside its Pod, so such legacy rows are host-launched runs. */
+export function adoptUncardedRuns(deps: RunAdoptDeps = {}): { scanned: number; adopted: number; skipped: Partial<Record<RunAdoptSkipReason, number>> } {
+  const dir = deps.registryDir ?? launchRegistryDir();
+  const skipped: Partial<Record<RunAdoptSkipReason, number>> = {};
+  let scanned = 0;
+  let adopted = 0;
+  for (const runId of launchBindingRunIds(dir)) {
+    scanned++;
+    const binding = readLaunchBinding(runId, dir);
+    if (!binding?.runsDir) {
+      skipped['other-universe'] = (skipped['other-universe'] ?? 0) + 1;
+      (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'run-adopt-skipped', { runId, reason: 'other-universe' });
+      continue;
+    }
+    const result = adoptRunCard({ runId, cwd: binding.cwd, goalPath: binding.goalPath, runsDir: binding.runsDir, env: { ELANOUS_POD_NAME: binding.podName, ELANOUS_TASK_CARD_ID: binding.taskCardId } }, deps);
+    if (result.adopted) adopted++;
+    else skipped[result.reason] = (skipped[result.reason] ?? 0) + 1;
+  }
+  return { scanned, adopted, skipped };
+}

package/src/task-agent/shadow.ts

@@ -17,6 +17,7 @@ import type { SupervisorJobResult, SupervisorStopReason } from '../self-dev/run-
 import { executeNextAction, type DeliveryKind, type NextAction } from './actions.js';
 import { judgeNextMove, type TaskJudgeInput, type TaskJudgement } from './judge.js';
 import { HARNESS_RUN_ID_ENV } from '../harness/harness-space.js';
+import { collectWiringEvidence, type WiringEvidenceDeps } from './card-evidence.js';
 import { recordLiveMoveHistory } from './live-move-history.js';
 import { capturedSelfReview, captureReviewResults, hasCapturedPass } from './review-result-capture.js';
 import { configuredTaskAgentLiveMoves, defaultPrHead, executeLiveGreenProposal, executeLiveLand, executeLiveReview, type LiveMoveDeps, type LiveMoveResult, type TaskAgentLiveMove } from './live-moves.js';
@@ -58,10 +59,30 @@ export interface TaskAgentShadowDeps {
   liveMoves?: ReadonlySet<TaskAgentLiveMove>;
   /** live 수의 부작용(리뷰 띄우기·PR 머리 조회·상태 파일) — 시험은 주입한다. */
   live?: LiveMoveDeps;
+  /** 카드 조회 상태 파일(시험 주입 · 운영 파일을 건드리지 않게). 기본 = `live.statePath` ⊕ `taskAgentStatePath()`. */
+  statePath?: string;
+  /** TA-WIRING-CHECK — 배선 근거 수집 의존(시험 주입 · 기본 = gh pr diff 한 번 ⊕ 카드 런 원장). */
+  wiring?: Omit<WiringEvidenceDeps, 'card'>;
   /** Process env for the launched-run id (`ELANOUS_RUN_ID`) — test seam; default process.env. */
   env?: NodeJS.ProcessEnv;
 }
 
+/** 카드 조회 상태 파일 — 조회 경로 전부가 같은 파일을 본다. */
+function cardStatePath(deps: TaskAgentShadowDeps): string {
+  return deps.statePath ?? deps.live?.statePath ?? taskAgentStatePath();
+}
+
+/** 카드 «원장»(기록·회수 대상) — 카드를 읽은 파일과 같다. 주입한 카드 리더(`readCard`)만 있으면 `live.statePath` 가 없을 때 모른다. */
+function cardLedgerPath(deps: TaskAgentShadowDeps): string | undefined {
+  return deps.readCard ? deps.live?.statePath : cardStatePath(deps);
+}
+
+/** live 수의 의존 — 실행부가 적는 원장(리뷰 요청·착지 시도)도 카드를 읽은 파일과 같게 맞춘다. */
+function liveMoveDeps(deps: TaskAgentShadowDeps): LiveMoveDeps {
+  const ledger = cardLedgerPath(deps);
+  return { ...(deps.log ? { log: deps.log } : {}), ...deps.live, ...(ledger ? { statePath: ledger } : {}) };
+}
+
 /** 파일 산출물로 전달(elanous-out)하는 종결 종류 — 그 밖의 code-pr 밖 종류는 확인 증거를 판단부에서 기다린다. */
 const DELIVERY_KINDS: ReadonlySet<CompletionKind> = new Set<CompletionKind>(['research-report', 'artifact', 'content']);
 function isDeliveryKind(kind: CompletionKind | undefined): kind is DeliveryKind {
@@ -156,7 +177,7 @@ function shadowCompletion(card: TaskCard | undefined, lookupFailed: boolean): Co
 export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, deps: TaskAgentShadowDeps = {}): Promise<TaskAgentShadowMove> {
   // TA-REVIEW-RESULT-CAPTURE — 판단 «전»에 지난 live review 의 결과 파일을 회수한다(카드 원장을 아는 때만 · 던지지 않는다).
   //   대기 중인 요청이 없으면 아무것도 쓰지 않는다(결과 파일 없는 카드의 동작은 종전과 같다).
-  const reviewLedger = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+  const reviewLedger = cardLedgerPath(deps);
   if (reviewLedger) {
     try { captureReviewResults(reviewLedger, { ...(deps.live?.now ? { now: deps.live.now } : {}), ...(deps.log ? { log: deps.log } : {}) }); } catch (error) {
       // fail-soft — 판단은 계속하되 원인은 남긴다.
@@ -167,12 +188,14 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   let card: TaskCard | undefined;
   let cardLookupFailed = false;
   try {
-    card = successful ? (deps.readCard ?? readTaskCard)(successful.taskId) : undefined;
+    card = successful ? (deps.readCard ? deps.readCard(successful.taskId) : readTaskCard(successful.taskId, cardStatePath(deps))) : undefined;
     if (!card && successful && !deps.readCard) {
-      const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(taskAgentStatePath()).tasks ?? {};
+      const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {};
       const matches = Object.values(tasks).filter(candidate => candidate.status === 'launched' && candidate.text === successful.feature);
       if (matches.length === 1) card = matches[0];
     }
+    // TA-OWN-ALL-RUNS — 런 소유 카드: 입력 runId ⊕ 상속 ELANOUS_RUN_ID(Pod 자식의 부모 런) 중 카드 runId 와 «정확히» 같은 것만.
+    if (!card && !deps.readCard) card = runCardFor(input.runId, deps);
   } catch {
     // Card lookup is optional; preserve the original PR judgement when unavailable — but mark the completion kind as unmeasured.
     cardLookupFailed = true;
@@ -282,7 +305,7 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.branch ? { branch: prResult.branch } : {}),
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
-        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        }, liveMoveDeps(deps));
     } else if (liveKind === 'propose-land') {
       liveMove = await executeLiveLand(boundCard, prResult?.prNumber,
         { runId: input.runId, cycleId: input.cycleId, review: selfReview,
@@ -292,12 +315,12 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
             ...(prResult.branch ? { branch: prResult.branch } : {}),
             ...(prResult.prUrl ? { prUrl: prResult.prUrl } : {}),
           } } : {}),
-        }, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+        }, liveMoveDeps(deps));
     } else {
       const evidence: Record<string, string> = {};
       if (boundCard && !delivery && judgeInput.prState === 'MERGED' && prResult) evidence[boundCard.id] = `#${prResult.prNumber}`;
       else if (boundCard && delivery && deps.mode === 'live' && executorResult === 'done') evidence[boundCard.id] = join(delivery.projectTarget, 'elanous-out', boundCard.id);
-      liveMove = executeLiveGreenProposal(boundCard, evidence, { ...(deps.log ? { log: deps.log } : {}), ...deps.live });
+      liveMove = executeLiveGreenProposal(boundCard, evidence, liveMoveDeps(deps));
     }
   }
   // 판단한 수마다 live/shadow 를 남긴다 — OP 가 «오판 건수»·«그림자 일치율»을 카드·수 종류로 잰다.
@@ -305,6 +328,15 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
     ...move, completion: shadowCompletion(card, cardLookupFailed), card: liveCard?.id ?? null, live, liveExecuted: liveMove?.executed ?? false, ...(liveMove ? { liveOk: liveMove.ok } : {}),
     ...(reviewFromCapture ? { reviewSource: 'captured-review-result' } : {}),
   });
+  // TA-WIRING-CHECK — 병합 PR 은 판단한 «뒤» 배선 근거를 관측만 한다(move 불변 · 실패는 unknown 으로 남기고 던지지 않는다).
+  if (judgeInput.prState === 'MERGED' && typeof judgeInput.pr === 'number' && !delivery && liveCard) {
+    try {
+      const wiring = await collectWiringEvidence(judgeInput.pr, { ...deps.wiring, card: liveCard });
+      (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('task-agent', 'wiring-shadow', {
+        card: liveCard.id, pr: judgeInput.pr, required: wiring.required, liveRunRecorded: wiring.liveRunRecorded, unknown: wiring.unknown,
+      });
+    } catch { /* fail-soft — 관측일 뿐 판단을 막지 않는다 */ }
+  }
   // TA-LIVE-MOVE-CARD-HISTORY — live-move 수(review·propose-green·propose-land)는 실행이든 그림자든 그 카드 history 에 한 줄.
   // 결정·실행이 끝난 «뒤»에 덧붙이기만 한다(반환값·관측 무변경) · 실패는 관측만(live-move 를 막지 않는다).
   if (liveKind !== null) recordLiveMoveOnCard({
@@ -315,6 +347,29 @@ export async function recordTaskAgentShadowMove(input: TaskAgentShadowInput, dep
   return liveMove ? { ...move, liveMove } : move;
 }
 
+/**
+ * 런 id 폴백 — 입력 runId(슈퍼바이저 · Pod 면 자식 런) → 상속 `ELANOUS_RUN_ID`(발사기가 넘긴 부모 런) 순으로,
+ * 카드 runId 와 정확히 같고 그 카드가 하나뿐일 때만 쓴다. 못 찾으면 추측하지 않고 이유 한 줄을 남긴다(조용한 미스 0).
+ */
+function runCardFor(runId: string | null | undefined, deps: TaskAgentShadowDeps): TaskCard | undefined {
+  const own = runId?.trim() || undefined;
+  const inherited = (deps.env ?? process.env)[HARNESS_RUN_ID_ENV]?.trim() || undefined;
+  if (!own && !inherited) return undefined;
+  const tasks = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {});
+  const tried: Array<{ source: 'run' | 'env'; id: string; bound: number }> = [];
+  for (const [source, id] of [['run', own], ['env', inherited]] as const) {
+    if (!id || tried.some((entry) => entry.id === id)) continue;
+    const bound = tasks.filter((candidate) => candidate.runId === id);
+    if (bound.length === 1) return bound[0];
+    tried.push({ source, id, bound: bound.length });
+  }
+  const reason = tried.map((entry) => `${entry.source === 'env' ? `env ${HARNESS_RUN_ID_ENV}` : 'runId'} ${entry.id}: ${entry.bound === 0 ? 'no card has this runId' : `${entry.bound} cards share this runId (ambiguous)`}`).join(' · ');
+  try {
+    (deps.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d)))('task-agent', 'run-card-fallback-missed', { runId: own ?? null, inheritedRunId: inherited ?? null, tried, reason });
+  } catch { /* fail-soft */ }
+  return undefined;
+}
+
 /**
  * 카드 history 에 live-move 한 줄 — 상태 파일은 카드를 읽은 곳과 같아야 한다: 주입한 경로(`live.statePath`) 또는
  * 기본 리더를 썼을 때의 기본 경로. 주입한 카드 리더(`readCard`)만 있고 경로가 없으면 그 카드의 원장을 모른다 — 적지 않는다.
@@ -334,7 +389,7 @@ function recordLiveMoveOnCard(
   };
   try {
     if (!move.card) { fail('no task card bound to this move'); return; }
-    const statePath = deps.live?.statePath ?? (deps.readCard ? undefined : taskAgentStatePath());
+    const statePath = cardLedgerPath(deps);
     if (!statePath) { fail('card ledger unknown (injected readCard without live.statePath)'); return; }
     const card = move.card;
     // live 인데 실행부 결과가 없으면 «무엇이 일어났는지» 모른다 — 줄을 지어내지 않고 이유를 남긴다.
@@ -358,11 +413,11 @@ function recordLiveMoveOnCard(
 function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentShadowDeps, runId?: string | null): TaskCard | undefined {
   try {
     for (const result of results) {
-      const found = deps.readCard ? deps.readCard(result.taskId) : readTaskCard(result.taskId, deps.live?.statePath);
+      const found = deps.readCard ? deps.readCard(result.taskId) : readTaskCard(result.taskId, cardStatePath(deps));
       if (found) return found;
     }
     if (deps.readCard) return undefined;
-    const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.live?.statePath ?? taskAgentStatePath()).tasks ?? {};
+    const tasks = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(cardStatePath(deps)).tasks ?? {};
     // TA-LIVE-LAND-2 — a Pod run's results carry the orchestrator task id, not the card id, and its feature may be the
     // authored goal rather than the handed sentence. `tasks hand --live` launched this process with ELANOUS_RUN_ID = the
     // card's runId (TA-CARD-RUN-LINK); the supervisor's runId may be the Pod child's. Either id bound to exactly one card is the match.
@@ -373,6 +428,7 @@ function liveCardFor(results: readonly SupervisorJobResult[], deps: TaskAgentSha
     }
     const features = new Set(results.map((result) => result.feature));
     const matches = Object.values(tasks).filter(candidate => candidate.status === 'launched' && features.has(candidate.text));
+    // runId ⊕ 상속 ELANOUS_RUN_ID 는 위에서 이미 봤다(판단부의 runCardFor 가 미스 이유를 남긴다).
     return matches.length === 1 ? matches[0] : undefined;
   } catch { return undefined; }
 }

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

@@ -16,6 +16,8 @@ import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harnes
 import { debug } from '../debug/log.js';
 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';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -83,7 +85,7 @@ export function taskCardLabelContext(card: Pick<TaskCard, 'id'>): TaskCardLabelC
  * 과제 종결 종류(RFC-loop-agent-map §A4b③) — 비면 code-pr(PR 병합)로 읽는다.
  * code-pr 밖의 종류는 «확인 증거»(`judge.ts` TaskJudgeInput.evidence)로 종결한다 — 증거를 만드는 일은 DEFAULT-HANDS 몫.
  */
-export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support'] as const;
+export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support', 'deliverable'] as const;
 export type CompletionKind = typeof COMPLETION_KINDS[number];
 
 /**
@@ -92,6 +94,8 @@ export type CompletionKind = typeof COMPLETION_KINDS[number];
  */
 export interface TaskCardEvent {
   at: string; event: string; detail?: string; runId?: string; pr?: number;
+  /** `closed-by-hand` 줄만 — 닫은 사유 · 닫은 자리(`closeTaskCard`). */
+  reason?: string; by?: 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;
@@ -102,6 +106,8 @@ export interface TaskCardEvent {
 export const LIVE_MOVE_HISTORY_EVENT = 'live-move';
 /** TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 리뷰의 결과(또는 «결과 없음») 줄 — live-move 줄처럼 상태 사유 판정에서 뺀다. */
 export const LIVE_MOVE_RESULT_EVENT = 'live-move-result';
+/** HAND-MOVE-LEDGER — 자리가 손으로 마무리한 수 줄(`recordHandMove`) — 관측 기록이라 live-move 줄처럼 상태 사유 판정에서 뺀다. */
+export const HAND_MOVE_HISTORY_EVENT = 'hand-move';
 export interface TaskCardMove { kind: 'launch' | 'wait'; command?: string[]; reason: string }
 export interface TaskCard {
   id: string;
@@ -159,9 +165,17 @@ export interface TaskCard {
    * TA-REJUDGE-ON-HEAD — 런 멈춤 «뒤» 머리마다 한 번 돌린 호스트 재게이트(병합 없음 · 떼어 띄움). 결과는 `resultPath` 파일에서
    * 다음 틱이 회수해 passed·status·baseCommit·detail 을 채운다(비어 있으면 아직 도는 중 · 없는 칸을 «통과»로 읽지 않는다).
    */
-  regates?: Array<{ pr: number; head: string; at: string; resultPath?: string; passed?: boolean; status?: string; baseCommit?: string; detail?: string }>;
-  /** Live land attempts, claimed before invocation, once per PR head even if the command fails. */
-  landAttempts?: Array<{ pr: number; head: string; at: string; ok?: boolean; detail?: string }>;
+  regates?: Array<{ pr: number; head: string; at: string; resultPath?: string; passed?: boolean; status?: string; baseCommit?: string; detail?: string;
+    /** REJUDGE base-stale — 같은 머리를 새 base 위에서 다시 잰 재게이트면, land 가 낡았다고 거절한 앞 재게이트의 base(멱등 키 = 머리 ⊕ 이 base). */
+    staleBase?: string }>;
+  /**
+   * Live land attempts, claimed before invocation, once per PR head even if the command fails.
+   * TA-LAND-RETRY-ON-INFRA — a failed attempt carries `class`/`reason`: `infra` (TA-side, allow-listed) leaves one more attempt on
+   * the same head (`LAND_ATTEMPTS_PER_HEAD_ON_INFRA`); `judgement` · unknown reason · no class (older record) closes the head.
+   * 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 }>;
   /** 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`. */
@@ -279,6 +293,16 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+export const CLOSED_BY_HAND_EVENT = 'closed-by-hand';
+
+/** 카드를 손으로 닫는다 — 상태를 `failed` 로 두고 history 에 한 줄(`closed-by-hand`)을 남긴다. 이미 손으로 닫은 카드는 그대로 돌려준다(멱등). */
+export function closeTaskCard(card: TaskCard, input: { reason: string; by: string; at: string }): TaskCard {
+  const reason = input.reason.trim();
+  if (!reason) throw new Error('닫는 사유(reason)가 비어 있다');
+  if (card.status === 'failed' && card.history.some((item) => item.event === CLOSED_BY_HAND_EVENT)) return card;
+  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 }] };
+}
+
 /** 첫 수의 elanous 인자(진입점·--config-dir 앞붙임은 launcher 몫). */
 export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm'>): string[] {
   const child = card.childLlm
@@ -298,8 +322,8 @@ export function nextMoveFor(card: TaskCard, landed?: ReadonlySet<string>): TaskC
   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: '넘겨받은 과제 — 첫 발사' };
   if (card.status === 'launch-failed') return { kind: 'launch', command: launchArgs(card), reason: '직전 발사 실패 — 다시 발사' };
-  // live-move 줄(관측 기록)은 실패 사유가 아니다 — 그 줄을 뺀 마지막 칸이 사유다(live-move 줄 없는 카드는 종전과 같다).
-  if (card.status === 'failed') return { kind: 'wait', reason: card.history.filter((item) => item.event !== LIVE_MOVE_HISTORY_EVENT && item.event !== LIVE_MOVE_RESULT_EVENT).at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
+  // live-move·hand-move 줄(관측 기록)은 실패 사유가 아니다 — 그 줄을 뺀 마지막 칸이 사유다(live-move 줄 없는 카드는 종전과 같다).
+  if (card.status === 'failed') return { kind: 'wait', reason: card.history.filter((item) => item.event !== LIVE_MOVE_HISTORY_EVENT && item.event !== LIVE_MOVE_RESULT_EVENT && item.event !== HAND_MOVE_HISTORY_EVENT).at(-1)?.detail ?? '런 실패 — PR·수확 가지 없음' };
   return { kind: 'wait', reason: '발사됨 — 런 멈춤을 슈퍼바이저 그림자 판단(task-agent.shadow-move)이 받는다' };
 }
 
@@ -370,6 +394,29 @@ export class TaskLaunchError extends Error {
 
 export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean; cwd?: string }
 
+/** Dispatch evidence for a handed deliverable card; unlike handTask, this never launches work. */
+export function dispatchDeliverableCompletion(id: string, input: { ref: string; receipt?: boolean }, path: string, now: () => Date = () => new Date()): boolean {
+  const card = readTaskCard(id, path);
+  if (card?.completion !== 'deliverable' || !card.project?.target || card.pr !== undefined || card.status === 'failed' || card.status === 'launch-failed') return false;
+  const evidence = checkCompletionEvidence('deliverable', { dir: card.project.target, ...input });
+  if (judgeNextMove({ completion: card.completion, evidence }).move !== 'propose-green') {
+    try { debug.log('task-agent', 'deliverable-rejected', { taskId: id, ref: input.ref, missing: evidence.missing }); } catch { /* fail-soft */ }
+    return false;
+  }
+  const receiptEvidence = deliverableReceiptEvidence(evidence.ref);
+  const at = now().toISOString();
+  let closed = false;
+  updateTaskCard(path, id, (current) => {
+    if (current?.completion !== 'deliverable' || current.pr !== undefined || current.greenProposal || !current.project || current.project.target !== card.project?.target || current.status === 'failed' || current.status === 'launch-failed') return undefined;
+    const fresh = checkCompletionEvidence('deliverable', { dir: current.project.target, ...input });
+    if (judgeNextMove({ completion: current.completion, evidence: fresh }).move !== 'propose-green') return undefined;
+    closed = true;
+    return { ...current, greenProposal: { at, checklistId: current.checklistId ?? null, evidence: { [id]: receiptEvidence } } };
+  });
+  try { debug.log('task-agent', closed ? 'deliverable-closed' : 'deliverable-rejected', { taskId: id, ref: evidence.ref, ...(closed ? {} : { missing: ['already-proposed-or-changed'] }) }); } catch { /* fail-soft */ }
+  return closed;
+}
+
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const text = opts.text.trim();
   if (!text) throw new Error('과제 한 줄이 비어 있다');
@@ -440,7 +487,10 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   if (!opts.launcher) throw new Error('--live 인데 launcher 가 없다');
   const runId = mintRunId();
   const launchId = `tl-${randomBytes(6).toString('hex')}`;
-  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card) };
+  const context: TaskLaunchContext = { runId, launchId, env: { [HARNESS_RUN_ID_ENV]: runId, ELANOUS_TASK_CARD_ID: card.id,
+    ...(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) };
   let receipt: void | TaskLaunchReceipt;
   try {
     receipt = await opts.launcher(move.command!, project?.target, context);

package/src/task-orchestrator/surfaces/pod-account-broker.ts

@@ -5,14 +5,15 @@
 //    «모른다»라서 뒤로 보내되 빼지 않는다(못 읽었다고 갈 곳을 없애지 않는다 — 회전 규칙과 같다).
 // ⛔ `--pod-account` 를 명시하면 브로커를 쓰지 않는다 — 사람의 의도가 이긴다.
 
-import { codexAccountThresholdPercent, type RotationCandidate } from '../../oauth/codex-account-rotation.js';
+import { CODEX_CREDIT_RESERVE_DEFAULT, codexAccountThresholdPercent, creditCandidatesByBalance, type RotationCandidate } from '../../oauth/codex-account-rotation.js';
+import { debug } from '../../debug/log.js';
 
 export const POD_ACCOUNT_EXCLUDE_AT_PERCENT = 95;
 
 export interface PodAccountPlan { usable: string[]; excluded: Array<{ name: string; why: string }>; /** 크레딧으로 쓰는 계정(구독 잔량 0 · 대표 허가) — 로그에 «크레딧» 으로 보이게. */ creditAccounts?: string[] }
 
 export type PodProviderPlan =
-  | { provider: 'openai-codex'; accounts: string[]; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean; creditAccounts?: string[] }
+  | { provider: 'openai-codex'; accounts: string[]; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean; creditAccounts?: string[]; /** CODEX-CREDITS-STEP — 체인 마지막 칸으로 크레딧에 왔다. */ codexCreditsStep?: true; /** 그 칸에 온 이유(관측). */ skipped?: string[] }
   | { provider: 'grok'; excluded: PodAccountPlan['excluded']; grokSubscriptionEligible: boolean }
   | { provider: null; reasons: string[]; grokSubscriptionEligible: boolean };
 
@@ -26,14 +27,39 @@ export function planPodProvider(input: {
   thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
   /** 대표 크레딧 허가(`llm.codexCreditsAllowed`) — 구독 잔량 계정이 없으면 찬 계정을 크레딧으로 쓴다. */
   creditsAllowed?: boolean;
+  /** SUBSCRIPTION-EXHAUST-REROUTE — `llm.codexCreditReserve`. 잔액이 «알려져» 이 값 이하인 계정은 크레딧으로 쓰지 않는다. */
+  creditReserve?: number;
+  /** CODEX-CREDITS-STEP — `llm.fallbackChain` 에 `codex-credits` 칸이 있고 정책이 폴백을 허용한다(호출자가 확정). */
+  codexCreditsStep?: boolean;
+  /** grok «잔량» — `exhausted` 일 때만 grok 을 건너뛴다(「모른다」는 종전대로 grok · 돈을 쓰는 쪽으로 기울지 않는다). */
+  grokQuota?: 'usable' | 'exhausted' | 'unknown';
 }): PodProviderPlan {
   const accounts = planPodAccounts(input.codexCandidates, {
     excludeAt: input.excludeAt,
     thresholdPercentByAccount: input.thresholdPercentByAccount,
     creditsAllowed: input.creditsAllowed,
+    ...(input.creditReserve !== undefined ? { creditReserve: input.creditReserve } : {}),
   });
   if (accounts.usable.length) return { provider: 'openai-codex', accounts: accounts.usable, excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription, ...(accounts.creditAccounts ? { creditAccounts: accounts.creditAccounts } : {}) };
-  if (input.grokSubscription || (input.grokApiKey && input.grokApiKeyOptIn)) return { provider: 'grok', excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription };
+  const grokEligible = input.grokSubscription || (input.grokApiKey && input.grokApiKeyOptIn);
+  const grokSkippedAsExhausted = input.codexCreditsStep === true && input.grokQuota === 'exhausted';
+  if (grokEligible && !grokSkippedAsExhausted) return { provider: 'grok', excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription };
+  if (input.codexCreditsStep === true) {
+    // 체인 마지막 칸 — 크레딧 잔액이 «확인된» 계정만, 많은 순(모르면 안 쓴다 · 돈이라 fail-closed).
+    const credit = creditCandidatesByBalance(input.codexCandidates, input.creditReserve ?? CODEX_CREDIT_RESERVE_DEFAULT).map((c) => c.name);   // 회전 수집기와 같은 자
+    if (credit.length > 0) {
+      return {
+        // 구독 기준 제외 사유는 진단용으로 남긴다(계정 선택은 credit 순서가 정한다).
+        provider: 'openai-codex', accounts: credit, excluded: accounts.excluded, creditAccounts: credit, codexCreditsStep: true,
+        grokSubscriptionEligible: input.grokSubscription,
+        skipped: ['codex-rotate:no-candidate', grokEligible ? 'grok:grok-exhausted' : 'grok:grok-unavailable'],
+      };
+    }
+    // 칸에 «닿았지만» 잔액 확인된 계정이 없다 — 실패한 도달도 남긴다.
+    try { debug.log('self-implement.pod', 'codex-credits-step', { outcome: 'skipped', why: 'codex-credits-unavailable', grokEligible }); } catch { /* observation is fail-soft */ }
+    // 크레딧도 못 쓰면 종전 그대로 — 소진 신호가 있어도 grok 으로(새로 막지 않는다).
+    if (grokEligible) return { provider: 'grok', excluded: accounts.excluded, grokSubscriptionEligible: input.grokSubscription };
+  }
   return {
     provider: null,
     grokSubscriptionEligible: false,
@@ -50,10 +76,11 @@ export function planPodAccounts(
     thresholdPercentByAccount?: Readonly<Record<string, unknown>>;
     excludeAt?: number;
     creditsAllowed?: boolean;
+    creditReserve?: number;
   } = {},
 ): PodAccountPlan {
-  const { thresholdPercentByAccount, excludeAt = POD_ACCOUNT_EXCLUDE_AT_PERCENT, creditsAllowed = false } =
-    typeof options === 'number' ? { excludeAt: options } : options;
+  const { thresholdPercentByAccount, excludeAt = POD_ACCOUNT_EXCLUDE_AT_PERCENT, creditsAllowed = false, creditReserve } =
+    typeof options === 'number' ? { excludeAt: options } as { thresholdPercentByAccount?: undefined; excludeAt: number; creditsAllowed?: boolean; creditReserve?: number } : options;
   const excluded: PodAccountPlan['excluded'] = [];
   const known: RotationCandidate[] = [];
   const unknown: RotationCandidate[] = [];
@@ -70,11 +97,17 @@ export function planPodAccounts(
   const usable = [...known, ...unknown].map((c) => c.name);
   // 대표 크레딧 허가: 구독 잔량이 남은 계정이 «하나도» 없을 때만 찬 계정을 크레딧으로 쓴다(사용률 낮은 순) — 잔량 계정이 있으면 그쪽이 먼저다.
   if (usable.length === 0 && creditsAllowed) {
+    // SUBSCRIPTION-EXHAUST-REROUTE — 잔액이 «알려져» 예비분 이하인 계정은 크레딧 후보가 아니다(모르면 종전대로 남긴다).
+    const reserve = typeof creditReserve === 'number' && Number.isFinite(creditReserve) && creditReserve >= 0 ? creditReserve : undefined;
     const credit = candidates
       .filter((c) => excluded.some((e) => e.name === c.name))
+      .filter((c) => reserve === undefined || typeof c.creditBalance !== 'number' || c.creditBalance > reserve)
       // 크레딧 잔액이 많은 계정부터(09-28 · 한 계정 크레딧만 타던 것) — 잔액을 모르면 사용률 낮은 순.
       .sort((a, b) => ((b.creditBalance ?? -1) - (a.creditBalance ?? -1)) || ((a.usedPercent ?? 100) - (b.usedPercent ?? 100)) || a.name.localeCompare(b.name))
       .map((c) => c.name);
+    if (credit.length === 0 && reserve !== undefined && excluded.length > 0) {
+      return { usable, excluded: excluded.map((e) => ({ ...e, why: `${e.why} · credits ≤ reserve ${reserve}` })) };
+    }
     return { usable: credit, excluded: [], creditAccounts: credit };
   }
   return { usable, excluded };

package/src/task-orchestrator/surfaces/pod-bedrock-child.ts

@@ -0,0 +1,74 @@
+/**
+ * BEDROCK-PROVIDER ② (0.2.24 · MK) — bedrock 자식 Pod 의 자격·리전·이그레스.
+ *
+ * 대표 10-10 승인: AWS 자격은 «bedrock Pod 에만» `secretKeyRef` 로 싣는다 · 값은 어디에도 내보내지 않는다 ·
+ *   다른 Pod 의 매니페스트는 바이트 하나 안 바뀐다.
+ *
+ * ⭐ 자격은 «작업별 creds Secret» 이 아니라 클러스터에 미리 둔 «이름 있는 Secret»(`elanous-bedrock-aws`)에서 온다.
+ *   호스트는 그 Secret 의 «키 이름»만 읽는다(값은 kubectl 밖으로 안 나온다) — 만들기는 `scripts/fleet/bedrock-pod-secret.ts`(사람 승인 뒤).
+ *   ⛔ SSO 캐시는 Pod 안에서 못 쓴다 — Pod 용 정적 키(또는 베어러 토큰)가 그 Secret 에 있어야 한다.
+ * ⛔ Secret 이 없거나 자격 키가 모자라면 «발사 전에» 거부한다(아무것도 apply 하지 않는다 · fail-closed).
+ * ⛔ 이 모듈은 가볍게 둔다(무거운 import 0).
+ */
+
+/** 클러스터(풀 노드마다)·네임스페이스(Pod 와 같은 곳)에 미리 둔 Secret 이름. */
+export const BEDROCK_POD_SECRET_NAME = 'elanous-bedrock-aws';
+
+/** bedrock Pod 만 다는 이그레스 라벨 — `docker/h1/policy-bedrock.yaml` 이 이 라벨에만 443 을 연다. */
+export const BEDROCK_POD_EGRESS_LABEL = 'elanous.egress/bedrock';
+
+/** Secret 에서 Pod env 로 «이름 그대로» 싣는 키(있는 것만). 값은 secretKeyRef 로만 간다. */
+export const BEDROCK_POD_SECRET_KEYS = ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN', 'AWS_BEARER_TOKEN_BEDROCK', 'AWS_REGION'] as const;
+export type BedrockPodSecretKey = typeof BEDROCK_POD_SECRET_KEYS[number];
+
+/** Secret 의 «키 이름»만 뽑는 kubectl 인자 — go-template 이 값을 찍지 않는다. */
+export function bedrockPodSecretKeyNamesArgs(namespace: string, secretName = BEDROCK_POD_SECRET_NAME): string[] {
+  return ['-n', namespace, 'get', 'secret', secretName, '-o', 'go-template={{range $k, $v := .data}}{{$k}}{{"\\n"}}{{end}}'];
+}
+
+export interface BedrockPodSpec {
+  secretName: string;
+  /** Secret 에 «있는» 자격 키 이름(값 아님). */
+  keys: BedrockPodSecretKey[];
+  /** 리전 — Secret 의 `AWS_REGION` 키가 있으면 그것(secretKeyRef), 없으면 호스트가 푼 리전(평문 · 비밀 아님). */
+  region: { from: 'secret' } | { from: 'host'; value: string };
+}
+
+export type BedrockPodCheck = { ok: true; spec: BedrockPodSpec } | { ok: false; reason: string };
+
+type KubectlLike = (args: string[], stdin?: string) => { status: number | null; stdout: string; stderr: string };
+
+const AWS_REGION_SHAPE = /^[a-z]{2,4}(?:-[a-z]+)+-\d{1,2}$/;
+
+/**
+ * 발사 «전» 판정 — Secret 이 있나 · 자격 키가 갖춰졌나 · 리전이 풀리나. 어느 하나라도 아니면 거부 사유.
+ * ⛔ 사유 문면에 값·kubectl stderr 원문을 싣지 않는다(이름·고정 문면만).
+ */
+export function checkBedrockPodSecret(kubectl: KubectlLike, namespace: string, hostRegion: string | undefined, secretName = BEDROCK_POD_SECRET_NAME): BedrockPodCheck {
+  const fix = `scripts/fleet/bedrock-pod-secret.ts 로 ${namespace}/${secretName} 을 만든다(승인 뒤)`;
+  const got = kubectl(bedrockPodSecretKeyNamesArgs(namespace, secretName));
+  if (got.status !== 0) {
+    return { ok: false, reason: /not ?found/i.test(got.stderr) ? `pod: bedrock 자격 Secret 없음 — ${namespace}/${secretName} · ${fix}` : `pod: bedrock 자격 Secret 을 못 읽었다 — ${namespace}/${secretName} (kubectl rc=${got.status}) · 발사하지 않는다` };
+  }
+  const present = new Set(got.stdout.split('\n').map((line) => line.trim()).filter(Boolean));
+  const keys = BEDROCK_POD_SECRET_KEYS.filter((key) => present.has(key));
+  const staticPair = keys.includes('AWS_ACCESS_KEY_ID') && keys.includes('AWS_SECRET_ACCESS_KEY');
+  const bearer = keys.includes('AWS_BEARER_TOKEN_BEDROCK');
+  if (!staticPair && !bearer) {
+    return { ok: false, reason: `pod: bedrock 자격 Secret ${namespace}/${secretName} 에 자격 키가 없다 — AWS_ACCESS_KEY_ID ⊕ AWS_SECRET_ACCESS_KEY 또는 AWS_BEARER_TOKEN_BEDROCK 필요 · ${fix}` };
+  }
+  const host = hostRegion?.trim();
+  const region: BedrockPodSpec['region'] | undefined = keys.includes('AWS_REGION') ? { from: 'secret' }
+    : host && AWS_REGION_SHAPE.test(host) ? { from: 'host', value: host } : undefined;
+  if (!region) return { ok: false, reason: `pod: bedrock 리전 없음 — Secret ${namespace}/${secretName} 의 AWS_REGION 또는 호스트 AWS_REGION(·~/.aws/config) 필요` };
+  return { ok: true, spec: { secretName, keys: keys.filter((key) => key !== 'AWS_REGION' || region.from === 'secret'), region } };
+}
+
+/** bedrock 자식 컨테이너 env — 자격은 secretKeyRef, 리전은 secretKeyRef 또는 평문. IMDS 탐색은 끈다(Pod 에 인스턴스 역할 없음). */
+export function bedrockPodEnv(spec: BedrockPodSpec): Array<Record<string, unknown>> {
+  return [
+    ...spec.keys.map((key) => ({ name: key, valueFrom: { secretKeyRef: { name: spec.secretName, key } } })),
+    ...(spec.region.from === 'host' ? [{ name: 'AWS_REGION', value: spec.region.value }] : []),
+    { name: 'AWS_EC2_METADATA_DISABLED', value: 'true' },
+  ];
+}