elanous 0.2.17 → 0.2.19

package/src/loops/orchestrator/tick.ts

@@ -1,34 +1,48 @@
 import { withFileLockSync } from '../../storage/file-lock.js';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { CardStore, taskCardsDir, type TaskCard } from '../../task-cards/card-store.js';
 import { Database } from 'bun:sqlite';
 import { type ChecklistItem } from '../../release-loop/checklist.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
-import { getUserConfig } from '../../user-config.js';
+import { getUserConfig, type OrchestratorLoopConfig } from '../../user-config.js';
+import { rubricPriority } from '../../release-loop/rubric.js';
 import { debug } from '../../debug/log.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../self-dev/run-store.js';
-import { planAction, runSeatLoopOnce, type SeatItem } from '../../seat-loop/seat-loop.js';
-import { harnessQueueOutcome } from '../../harness/harness-queue.js';
+import { planAction, runSeatLoopOnce, type SeatDeps, type SeatItem } from '../../seat-loop/seat-loop.js';
+import { addHarnessQueue, harnessQueueOutcome, setQueuedPoolHint } from '../../harness/harness-queue.js';
+import { placeOnGrid, type GridHost } from './grid-place.js';
+import { checkPodPool, parsePodPool, resolvePodPoolSpec } from '../../task-orchestrator/surfaces/pod-pool.js';
+import { leaseKubectl } from '../../task-orchestrator/surfaces/pod-lease.js';
+import { readTaskAgentState, TASK_SEATS, type HandTaskOptions, type TaskCard as TaskAgentCard, type HandTaskResult, type TaskLauncher, type TaskSeat } from '../../task-agent/task-hand.js';
 
 export type Window = '08' | '12' | '18';
 export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'reconcile' | 'report';
 export type Mode = 'off' | 'shadow' | 'live';
 const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cmo-seat', TC: 'tc-seat', UX: 'ux-seat' };
-export interface Cell { id: string; title: string; seat?: string; host?: string; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2'; predecessors?: string[] }
+export interface Cell { id: string; title: string; kind?: string; seat?: string; host?: string; gridHost?: boolean; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2' | 'P3' | 'P4'; predecessors?: string[] }
 export interface TickState {
   runId: string; window: Window; mode: Mode; day: string;
   cards: TaskCard[]; skippedCards: Array<{ id: string; reason: string }>; cells: Cell[]; placed: number; unplaced?: number; delegated: number; wouldDelegate: number; rebalanced?: number; rebalanceBlocked?: Array<{ id: string; reason: string }>;
   reconciled: { reached: number; progressing: number; blocked: number; unknown: number };
   runSummaries?: string[];
+  degradation?: { level: 1 | 2; reason: string };
+  /** The highest degradation actually applied in this run — the report keeps it even if the signal recovers before report. */
+  degradationPeak?: { level: 1 | 2; reason: string };
+  deferredCells?: Cell[];
+  /** place ran at L2 (skipped) in this run — its unplaced cells are carried even if the board is back by delegate. */
+  placeDegraded?: boolean;
+  delegatedKeys?: string[];
   launched?: Array<{ seat: string; status: string; key?: string; queueId?: string; runId?: string }>;
+  /** ORCH-TA-HAND — cells handed to TASK-AGENT this run (card id · mode · launched). */
+  handed?: Array<{ key: string; cell: string; cardId: string; mode: 'shadow' | 'live'; launched: boolean }>;
   queueOutcomes?: Array<{ queueId: string; key?: string; outcome: string }>;
   steps: Array<{ node: Node; reason: string; count: number; targetLoopId?: string }>;
   nodes: Partial<Record<Node, 'ok' | 'skipped'>>;
   missing: string[];
 }
 /** FLOW1a contract: with `{ shadow: true }` the splitter only proposes cells and writes nothing (cards, ledgers, LLM side effects excepted). */
-export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Promise<Array<{ id: string; title: string; seat?: string; host?: string }>> | Array<{ id: string; title: string; seat?: string; host?: string }>;
+export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Promise<Array<{ id: string; title: string; kind?: string; seat?: string; host?: string }>> | Array<{ id: string; title: string; kind?: string; seat?: string; host?: string }>;
 /** RELPLAN1 `placeCell(input: PlacementCell)` — owner·priority·predecessors are required; the result carries no seat. */
 export type PlacementInput = { id: string; title: string; owner: string; priority: 'P0' | 'P1' | 'P2'; predecessors: string[] };
 export type PlaceAdapter = (cell: PlacementInput, deps?: { dryRun?: boolean; now?: Date }) => Promise<{ version?: string } | null> | { version?: string } | null;
@@ -36,12 +50,51 @@ export type RebalanceAdapter = (version: string) => Promise<{ decisions: unknown
 export interface TickDeps {
   root?: string; now?: Date; mode?: Mode; runId?: string; window?: Window;
   cards?: () => TaskCard[]; split?: SplitAdapter; placeCell?: PlaceAdapter;
-  seatTurn?: (seat: string, root: string) => Promise<{ status: string; queueId?: string; runId?: string; item?: { source: string; id: string } }>;
+  degradation?: () => { llm: boolean; board: boolean };
+  gridHosts?: readonly GridHost[];
+  seatTurn?: (seat: string, root: string, host?: string, options?: Pick<SeatDeps, 'enqueue'>) => Promise<{ status: string; queueId?: string; runId?: string; item?: { source: string; id: string } }>;
   queueOutcome?: (queueId: string, root: string) => 'pending' | 'unknown' | 'retryable' | 'succeeded';
+  /** 발사 전 대기열 항목의 풀 힌트 갱신(주입 안 하면 harness-queue `setQueuedPoolHint`). */
+  setPoolHint?: (queueId: string, poolHint: string | undefined, root: string) => Promise<boolean>;
   loadAdapter?: (path: string, name: string) => Promise<unknown>;
   checklist?: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[];
   observe?: (event: string, data: { loopId: string; runId: string; window: Window; node: Node; reason: string; count: number; targetLoopId?: string }) => void;
   print?: (line: string) => void;
+  /** ORCH-TA-HAND seams — absent = config `loops.orchestrator.handToTaskAgent(Cell)` · real `handTask` · `defaultTaskLauncher`. */
+  handToTaskAgent?: 'off' | 'shadow' | 'live';
+  handToTaskAgentCell?: string;
+  handTask?: (opts: HandTaskOptions) => Promise<HandTaskResult>;
+  taskLauncher?: TaskLauncher;
+}
+
+/** ORCH-TA-HAND ledger — one row per handed `orch:<card>:<cell>` key so a cell is handed once across ticks and processes. */
+function handedLedger(root: string): string { return join(root, 'loop', 'orchestrator', 'handed.jsonl'); }
+type HandedRow = { key: string; cell: string; cardId: string; mode: 'shadow' | 'live'; launched: boolean; runId?: string };
+/** Completed hands (`status: 'handed'`) by ledger key — a re-entered run restores its `handed[]` from these. */
+function handedRows(path: string): Map<string, HandedRow> {
+  const rows = new Map<string, HandedRow>();
+  if (!existsSync(path)) return rows;
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    let row: Partial<HandedRow> & { status?: unknown };
+    try { row = JSON.parse(line) as typeof row; } catch { throw new Error('invalid orchestrator handed ledger'); }
+    if (row.status === 'handed' && typeof row.key === 'string' && typeof row.cardId === 'string' && typeof row.cell === 'string'
+      && (row.mode === 'shadow' || row.mode === 'live')) rows.set(row.key, { key: row.key, cell: row.cell, cardId: row.cardId, mode: row.mode, launched: row.launched === true, ...(typeof row.runId === 'string' ? { runId: row.runId } : {}) });
+  }
+  return rows;
+}
+function handedKeys(path: string): Set<string> {
+  if (!existsSync(path)) return new Set();
+  const keys = new Set<string>();
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    let row: { key?: unknown; status?: unknown };
+    try { row = JSON.parse(line) as typeof row; } catch { throw new Error('invalid orchestrator handed ledger'); }
+    if (typeof row.key !== 'string') continue;
+    // A released claim (a shadow hand that failed before its card) frees the key again — the last row decides.
+    if (row.status === 'released') keys.delete(row.key); else keys.add(row.key);
+  }
+  return keys;
 }
 
 export function kstWindow(now: Date): Window {
@@ -88,7 +141,9 @@ export function reportLine(state: TickState): string {
   const r = state.reconciled;
   const line = `orchestrator ${state.window} cards=${state.cards.length} cells=${state.cells.length} placed=${state.missing.includes('relplan1-absent') ? 'missing' : state.placed} delegated=${state.mode === 'shadow' ? `would ${state.wouldDelegate}` : state.delegated} reconciled=${r.reached}/${r.progressing}/${r.blocked}/${r.unknown} mode=${state.mode}`;
   const details = [...(state.rebalanceBlocked ?? []).map(row => `⛔ 이월 거부 ${row.id}: ${row.reason}`), ...(state.runSummaries ?? [])];
-  return details.length ? `${line}\n${details.join('\n')}` : line;
+  const body = details.length ? `${line}\n${details.join('\n')}` : line;
+  const applied = state.degradationPeak ?? state.degradation;
+  return applied ? `강등 L${applied.level}: ${applied.reason}\n${body}` : body;
 }
 function readCardSnapshot(root: string): { cards: TaskCard[]; skippedCards: TickState['skippedCards'] } {
   const dir = taskCardsDir(root);
@@ -122,10 +177,138 @@ function readChecklist(root: string, version: string): Pick<ChecklistItem, 'id'
   try { return db.query('SELECT feature_id AS id, status FROM assignments WHERE version = ?').all(version) as Pick<ChecklistItem, 'id' | 'status'>[]; }
   finally { db.close(); }
 }
+/** 명시 인벤토리: 없으면 undefined, «있는데 못 읽으면» null — null 은 풀 명부로 대체하지 않는다. */
+function readGridHosts(): readonly GridHost[] | null | undefined {
+  const supplied = process.env.ELANOUS_GRID_HOSTS;
+  if (supplied === undefined) return undefined;
+  try {
+    const inventory: unknown = JSON.parse(supplied);
+    if (!Array.isArray(inventory) || !inventory.every(row => row && typeof row === 'object' &&
+      typeof row.name === 'string' && row.name.trim() !== '' && Array.isArray(row.capabilities) &&
+      row.capabilities.every((capability: unknown) => typeof capability === 'string') &&
+      typeof row.available === 'boolean')) return null;
+    return inventory.map(row => ({ name: row.name as string, capabilities: new Set<string>(row.capabilities), available: row.available as boolean }));
+  } catch { return null; }
+}
+/** 주입 > 명시 인벤토리 > 풀 명부. 명시 인벤토리를 못 읽으면 제안하지 않는다(기존 경로 그대로). */
+function resolveGridHosts(deps: TickDeps, observe: (event: string, reason: string, count: number) => void): readonly GridHost[] | undefined {
+  if (deps.gridHosts) return deps.gridHosts;
+  const supplied = readGridHosts();
+  if (supplied === null) { observe('node-missing', 'grid-inventory-unreadable', 0); return undefined; }
+  return supplied ?? gridHostsFromPodPool();
+}
+function preferredPoolSpec(host: string): string | undefined {
+  const config = getUserConfig();
+  const spec = resolvePodPoolSpec(undefined, process.env, () => config.harness?.podPool ?? config.pod?.pool);
+  if (!spec) return undefined;
+  try {
+    const members = parsePodPool(spec);
+    const member = members.find(candidate => (candidate.sshHost ?? candidate.context) === host);
+    if (!member) return undefined;
+    const parts = spec.split(',').map(part => part.trim());
+    const preferred = parts.find(part => part === member.context ||
+      ['@', ':', '#'].some(separator => part.startsWith(`${member.context}${separator}`)));
+    return preferred ? [preferred, ...parts.filter(part => part !== preferred)].join(',') : undefined;
+  } catch { return undefined; }
+}
+function gridHostsFromPodPool(): readonly GridHost[] | undefined {
+  try {
+    const config = getUserConfig();
+    const spec = resolvePodPoolSpec(undefined, process.env, () => config.harness?.podPool ?? config.pod?.pool);
+    if (!spec) return undefined;
+    const members = parsePodPool(spec);
+    const checked = checkPodPool(members, leaseKubectl);
+    const ready = new Set(checked.ready.map(member => member.context));
+    return members.map(member => ({
+      name: member.sshHost ?? member.context,
+      capabilities: new Set(['pod']),
+      available: ready.has(member.context),
+    }));
+  } catch { return undefined; }
+}
 function journal(root: string): string { return join(root, 'seat-requests', 'requests.jsonl'); }
-function readRequests(root: string): Array<{ key: string; status: string }> {
+function readRequests(root: string): Array<{ key: string; status: string; seat?: string; kind?: string; host?: string; gridHost?: boolean }> {
   const path = journal(root);
-  return existsSync(path) ? readFileSync(path, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line) as { key: string; status: string }) : [];
+  return existsSync(path) ? readFileSync(path, 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line) as { key: string; status: string; seat?: string; kind?: string; host?: string; gridHost?: boolean }) : [];
+}
+function refreshGridHosts(cells: Cell[], hosts: readonly GridHost[] | undefined, mode: Mode,
+  root: string, observe: (event: string, reason: string, count: number, targetLoopId?: string) => void): void {
+  if (hosts === undefined) return;
+  for (const cell of cells) {
+    if (mode !== 'live' || cell.origin !== 'flow1a' || !cell.seat || !SEAT_LOOP_IDS[cell.seat]) {
+      observe('exchange', `would-host:${cell.id}:${placeOnGrid(cell, hosts).host ?? 'null'}`, 1);
+      continue;
+    }
+    const path = journal(root);
+    const key = `orch:${cell.cardId}:${cell.id}`;
+    // 의뢰가 이미 대기열을 떠났으면(발사·완료) 제안만 관측하고 칸의 호스트는 그 행의 확정 호스트로 되돌린다.
+    const keepLaunched = (row: { host?: string; gridHost?: boolean }): void => {
+      if (row.host) cell.host = row.host; else delete cell.host;
+      if (row.gridHost) cell.gridHost = true; else delete cell.gridHost;
+    };
+    let changedFrom: string | undefined;
+    mkdirSync(dirname(path), { recursive: true });
+    // 상태 확인 · 칸 변경 · 행 갱신은 모두 같은 잠금 안의 한 결정이다 — 다른 틱이 그 사이 행을 만들거나 바꿔도 덮지 않는다.
+    withFileLockSync(`${path}.lock`, () => {
+      const current = readRequests(root).filter(row => row.key === key).at(-1);
+      // 호스트 결정도 잠금 안 — 상태 확인과 같은 순간의 명부로 고른다.
+      const choice = placeOnGrid(cell, hosts);
+      observe('exchange', `would-host:${cell.id}:${choice.host ?? 'null'}`, 1);
+      if (current && current.status !== 'queued') { keepLaunched(current); return; }
+      if (choice.host) { cell.host = choice.host; cell.gridHost = true; }
+      else if (cell.gridHost || current?.gridHost) { delete cell.host; delete cell.gridHost; }
+      if (!current || (current.host === cell.host && current.gridHost === cell.gridHost && (current.kind === cell.kind || !cell.kind))) return;
+      if (current.host !== cell.host) changedFrom = current.host;
+      const updated = { ...current };
+      delete updated.host;
+      delete updated.gridHost;
+      if (cell.host) updated.host = cell.host;
+      if (cell.gridHost) updated.gridHost = true;
+      if (cell.kind) updated.kind = cell.kind;
+      appendFileSync(path, `${JSON.stringify(updated)}\n`);
+    });
+    if (changedFrom !== undefined) observe('exchange', `rehost:${cell.id}:${changedFrom}→${cell.host ?? 'none'}`, 1, SEAT_LOOP_IDS[cell.seat]);
+  }
+}
+/**
+ * 재배치된 의뢰가 앞 틱에서 이미 대기열에 들어갔다면(아직 발사 전) 그 항목의 풀 힌트도 의뢰 행의 새 호스트로 맞춘다.
+ * 의뢰 키 ↔ 대기열 id 는 live 틱 상태들의 `launched` 에서 찾는다(날짜를 넘겨 대기 중인 항목도). 의뢰 행이 아직 queued 일 때만 옮긴다.
+ */
+async function syncQueuedPoolHints(root: string, current: NonNullable<TickState['launched']>, deps: TickDeps,
+  observe: (event: string, reason: string, count: number) => void): Promise<void> {
+  const dir = join(root, 'loop', 'orchestrator');
+  const turns = [...current];
+  if (existsSync(dir)) for (const name of readdirSync(dir).filter(file => /^[a-zA-Z0-9._-]+\.json$/.test(file))) {
+    try {
+      const other = JSON.parse(readFileSync(join(dir, name), 'utf8')) as TickState;
+      if (other.mode === 'live') turns.push(...(other.launched ?? []));
+    } catch { /* 깨진 상태 파일은 건너뛴다 */ }
+  }
+  const latest = new Map(readRequests(root).map(row => [row.key, row]));
+  const seen = new Set<string>();
+  for (const turn of turns) {
+    if (!turn.queueId || !turn.key || seen.has(turn.queueId)) continue;
+    seen.add(turn.queueId);
+    const row = latest.get(turn.key);
+    if (!row || row.kind !== 'pod' || row.status !== 'queued') continue;
+    // GRID 가 고른 행이면 그 호스트 쪽 힌트로, GRID 가 호스트를 거둔 행(둘 다 막힘)이면 GRID 가 넣었던 힌트만 지운다.
+    // GRID 와 무관한 기존 pod 의뢰의 힌트(ORCH1·명시 풀)는 건드리지 않는다.
+    const gridChosen = !!(row.gridHost && row.host);
+    if (!gridChosen && row.host) continue;
+    const hint = gridChosen ? preferredPoolSpec(row.host!) : undefined;
+    if (gridChosen && !hint) continue;
+    const key = turn.key;
+    // 갱신 직전 대기열 잠금 안에서: 의뢰가 아직 queued 이고 행의 호스트가 계산 때와 같으며,
+    // 지우는 경우엔 지금 대기열 힌트가 GRID 가 만든 꼴일 때만.
+    const stillQueued = (item: { poolHint?: string; poolHintSource?: 'grid' }): boolean => {
+      const now = readRequests(root).filter(r => r.key === key).at(-1);
+      if (now?.status !== 'queued' || now.host !== row.host || now.gridHost !== row.gridHost) return false;
+      // 지우는 쪽은 GRID 가 소유한 힌트만(소유 기록 확인) — 같은 문자열이라도 사람이 넣은 힌트는 남긴다.
+      return gridChosen || item.poolHintSource === 'grid';
+    };
+    if (await (deps.setPoolHint ?? ((id: string, value: string | undefined, stateRoot: string) => setQueuedPoolHint(id, value, { root: stateRoot }, stillQueued)))(turn.queueId, hint, root))
+      observe('exchange', `rehost-queue:${turn.key}:${hint ?? 'none'}`, 1);
+  }
 }
 function stateFile(root: string, runId: string): string {
   if (!/^[a-zA-Z0-9._-]+$/.test(runId) || runId === '.' || runId === '..') throw new Error('Invalid orchestrator runId');
@@ -149,6 +332,22 @@ function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState,
   }
   return { cards: [...cards.values()], cells: [...cells.values()], launched: [...launched.values()] };
 }
+function previousDelegations(root: string, day: string, mode: Mode, runId: string): { deferred: Cell[]; keys: string[] } {
+  const dir = join(root, 'loop', 'orchestrator');
+  if (!existsSync(dir)) return { deferred: [], keys: [] };
+  const states = readdirSync(dir).filter(name => /^[a-zA-Z0-9._-]+\.json$/.test(name))
+    .flatMap(name => {
+      try {
+        const path = join(dir, name);
+        const state = JSON.parse(readFileSync(path, 'utf8')) as TickState;
+        return state.runId !== runId && state.day <= day && state.mode === mode && state.window === '08' &&
+          state.nodes?.delegate === 'ok' && Array.isArray(state.deferredCells)
+          ? [{ name, state, mtime: statSync(path).mtimeMs }] : [];
+      } catch { return []; }
+    });
+  states.sort((a, b) => a.state.day.localeCompare(b.state.day) || a.mtime - b.mtime || a.name.localeCompare(b.name));
+  return { deferred: states.at(-1)?.state.deferredCells ?? [], keys: states.flatMap(({ state }) => Array.isArray(state.delegatedKeys) ? state.delegatedKeys : []) };
+}
 function initial(runId: string, window: Window, mode: Mode, day: string): TickState {
   return { runId, window, mode, day, cards: [], skippedCards: [], cells: [], placed: 0, delegated: 0, wouldDelegate: 0,
     reconciled: { reached: 0, progressing: 0, blocked: 0, unknown: 0 }, steps: [], nodes: {}, missing: [] };
@@ -177,11 +376,20 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   const root = deps.root ?? effectiveInstanceRoot();
   const runId = deps.runId ?? graphRunId() ?? `${kstDay(now)}-${window}`;
   const path = stateFile(root, runId);
-  const configured = deps.mode ?? getUserConfig().loops?.orchestrator?.mode;
+  const orchestratorConfig = getUserConfig().loops?.orchestrator;
+  const configured = deps.mode ?? orchestratorConfig?.mode;
   const mode: Mode = configured === 'off' || configured === 'live' ? configured : 'shadow';
   const state: TickState = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as TickState : initial(runId, window, mode, kstDay(now));
   state.steps ??= [];
   if (state.window !== window || state.mode !== mode) throw new Error('orchestrator run window/mode changed');
+  if (deps.degradation) {
+    const signal = deps.degradation();
+    state.degradation = !signal.board ? { level: 2, reason: signal.llm ? 'board 불가' : 'LLM·board 불가' }
+      : !signal.llm ? { level: 1, reason: 'LLM 불가' } : undefined;
+    // Only nodes that act on the degradation (split · place · delegate · launch) count toward the reported peak.
+    const applies = (['split', 'place', 'delegate', 'launch'] as Node[]).includes(node) && activeNode(node, window);
+    if (applies && state.degradation && (!state.degradationPeak || state.degradation.level >= state.degradationPeak.level)) state.degradationPeak = state.degradation;
+  }
   const predecessor: Partial<Record<Node, Node>> = { split: 'intake', place: 'split', delegate: 'place', launch: 'delegate', reconcile: 'launch', report: 'reconcile' };
   const preceding = predecessor[node];
   if (preceding && !state.nodes[preceding]) throw new Error(`orchestrator ${node}: missing ${preceding} result`);
@@ -208,14 +416,17 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       observe('exchange', 'wish-cards', state.cards.length);
     } else if (node === 'split') {
       // Shadow also asks the splitter (it only proposes cells); only live records `orch:split` on the card.
-      const split = deps.split ?? await adapter<SplitAdapter>('../../flow-loop/split.js', 'splitCard');
-      if (!split) { state.missing.push('flow1a-absent'); observe('node-missing', 'flow1a-absent', state.cards.length); }
+      const ruleOnly = (state.degradation?.level ?? 0) >= 1;
+      const split = ruleOnly ? undefined : deps.split ?? await adapter<SplitAdapter>('../../flow-loop/split.js', 'splitCard');
+      if (!split && !ruleOnly) { state.missing.push('flow1a-absent'); observe('node-missing', 'flow1a-absent', state.cards.length); }
       state.cells = [];
       for (const card of state.cards) {
-        const cells = split ? await split(card, { shadow: mode === 'shadow' }) : [{ id: card.id, title: card.title }];
+        const cells = ruleOnly ? [{ id: card.id, title: card.title }] : split ? await split(card, { shadow: mode === 'shadow' }) : [{ id: card.id, title: card.title }];
         for (const cell of cells) {
           if (!cell.id?.trim() || !cell.title?.trim()) throw new Error('invalid split cell');
-          state.cells.push({ cardId: card.id, id: cell.id, title: cell.title, origin: split ? 'flow1a' : 'candidate', ...(cell.seat ? { seat: cell.seat } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}) });
+          state.cells.push({ cardId: card.id, id: cell.id, title: cell.title, origin: split ? 'flow1a' : 'candidate',
+            ...(ruleOnly ? { priority: rubricPriority(card.sections.map(section => section.content).join('\n')) } : {}),
+            ...(cell.kind !== undefined ? { kind: cell.kind } : {}), ...(cell.seat ? { seat: cell.seat } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}) });
         }
         observe('exchange', `split:${card.id}`, cells.length);
         if (split && cells.length && mode === 'live') {
@@ -226,63 +437,213 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         }
       }
     } else if (node === 'place') {
-      const place = deps.placeCell ?? await adapter<PlaceAdapter>('../../release-loop/placement.js', 'placeCell');
-      const available = typeof place === 'function';
-      if (!available) { state.missing.push('relplan1-absent'); observe('node-missing', 'relplan1-absent', state.cells.length); }
-      if (mode === 'shadow' && deps.placeCell) observe('exchange', 'relplan1-shadow-not-invoked', state.cells.length);
-      // 담당 없는 칸은 배치를 부르든 안 부르든 센다 — 배치 호출 여부와 집계를 묶지 않는다.
-      for (const cell of state.cells) {
-        if (cell.origin === 'flow1a' && (!cell.seat || !SEAT_LOOP_IDS[cell.seat])) { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-owner', 1); }
+      // Carry unfinished assignments into the same place/delegate path before applying this tick's cap.
+      const carry = previousDelegations(root, state.day, mode, runId).deferred;
+      if (carry.length) {
+        // Carried cells keep their place ahead of this tick's new cells (deduplicated) — a cell deferred by the cap is not
+        // pushed back again by a newly split cell.
+        const carried = new Set(carry.map(cell => `orch:${cell.cardId}:${cell.id}`));
+        state.cells = [...carry, ...state.cells.filter(cell => !carried.has(`orch:${cell.cardId}:${cell.id}`))];
       }
-      if (available && (mode === 'live' || !deps.placeCell)) for (const cell of state.cells) {
-        if (cell.origin !== 'flow1a' || !cell.seat || !SEAT_LOOP_IDS[cell.seat]) continue;
-        // RELPLAN's dryRun calculates the same release without writing a checklist in shadow.
-        try {
-          const placed = await place({ id: cell.id, title: cell.title, owner: cell.seat, priority: cell.priority ?? 'P2', predecessors: cell.predecessors ?? [] }, { dryRun: mode === 'shadow', now });
-          if (validVersion(placed?.version)) {
-            cell.version = placed.version;
-            state.placed++;
-            observe('exchange', mode === 'shadow' ? `would-place:${cell.id}:${cell.version}` : `placed:${cell.id}:${cell.version}`, 1);
-          } else { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-release', 1); }
-        } catch (error) {
-          state.unplaced = (state.unplaced ?? 0) + 1;
-          observe('exchange', `unplaced:${cell.id}:${String(error).slice(0, 160)}`, 1);
+      if (state.degradation?.level === 2) {
+        state.placeDegraded = true;
+        observe('degraded-skip', 'place', 0);
+      } else {
+        const gridHosts = resolveGridHosts(deps, observe);
+        refreshGridHosts(state.cells, gridHosts, mode, root, observe);
+        if (mode === 'live') await syncQueuedPoolHints(root, state.launched ?? [], deps, observe);
+        const place = deps.placeCell ?? await adapter<PlaceAdapter>('../../release-loop/placement.js', 'placeCell');
+        const available = typeof place === 'function';
+        if (!available) { state.missing.push('relplan1-absent'); observe('node-missing', 'relplan1-absent', state.cells.length); }
+        if (mode === 'shadow' && deps.placeCell) observe('exchange', 'relplan1-shadow-not-invoked', state.cells.length);
+        // 담당 없는 칸은 배치를 부르든 안 부르든 센다 — 배치 호출 여부와 집계를 묶지 않는다.
+        for (const cell of state.cells) {
+          if (cell.origin === 'flow1a' && (!cell.seat || !SEAT_LOOP_IDS[cell.seat])) { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-owner', 1); }
+        }
+        if (available && (mode === 'live' || !deps.placeCell)) for (const cell of state.cells) {
+          if (cell.origin !== 'flow1a' || !cell.seat || !SEAT_LOOP_IDS[cell.seat]) continue;
+          // RELPLAN's dryRun calculates the same release without writing a checklist in shadow.
+          try {
+            const priority = cell.priority === 'P3' || cell.priority === 'P4' ? 'P2' : cell.priority ?? 'P2';
+            const placed = await place({ id: cell.id, title: cell.title, owner: cell.seat, priority, predecessors: cell.predecessors ?? [] }, { dryRun: mode === 'shadow', now });
+            if (validVersion(placed?.version)) {
+              cell.version = placed.version;
+              state.placed++;
+              observe('exchange', mode === 'shadow' ? `would-place:${cell.id}:${cell.version}` : `placed:${cell.id}:${cell.version}`, 1);
+            } else { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-release', 1); }
+          } catch (error) {
+            state.unplaced = (state.unplaced ?? 0) + 1;
+            observe('exchange', `unplaced:${cell.id}:${String(error).slice(0, 160)}`, 1);
+          }
         }
       }
     } else if (node === 'delegate') {
+      if (state.degradation?.level === 2) observe('degraded-skip', 'delegate', 0);
+      const cap = orchestratorConfig?.maxDelegatePerTick;
+      const previous = previousDelegations(root, state.day, mode, runId);
+      if (cap !== undefined || state.degradation?.level === 2 || state.placeDegraded || previous.deferred.length) {
+        state.deferredCells = [];
+        state.delegatedKeys = [];
+      }
       const path = journal(root);
-      const keys = new Set(readRequests(root).map(row => row.key));
+      // 모드와 칸 필터는 따로 푼다 — 주입으로 모드만 줘도 설정의 칸 필터는 그대로 먹는다.
+      const handConfig: Partial<OrchestratorLoopConfig> = deps.handToTaskAgent !== undefined && deps.handToTaskAgentCell !== undefined ? {} : getUserConfig().loops?.orchestrator ?? {};
+      // live 로 넘긴 칸은 지금 설정(off·칸 필터)과 무관하게 자리 경로로 다시 안 간다 — 발사 주체가 둘이 되지 않게.
+      // ⭐ 넘김 claim 과 자리 저널 기록은 «같은 잠금»(자리 저널 잠금) 아래에서 서로를 다시 읽는다 — 동시 틱이 낡은 값을 보지 않게.
+      const ledger = handedLedger(root);
+      const liveHanded = handedKeys(ledger);
+      // Earlier runs' (would-)assignments only count while a cap is configured — they are what the cap carried over.
+      // With no cap the tick behaves as before: shadow would-delegates every cell again, live dedups on the seat journal.
+      const keys = new Set([...readRequests(root).map(row => row.key), ...(cap !== undefined ? previous.keys : [])]);
+      // 넘김 뒤 상태 저장 전에 죽은 같은 run 이 다시 돌면 원장에서 handed[] 를 되살린다.
+      const ledgerHanded = handedRows(ledger);
+      const restoreHanded = (handKey: string, key: string, rows: Map<string, HandedRow> = handedRows(ledger)): void => {
+        const row = rows.get(handKey);
+        // 이 run 이 넘긴 것만 되살린다 — 다른 run 의 넘김을 «이 run 에서 넘겼다»로 적지 않게.
+        if (!row || row.runId !== runId || (state.handed ?? []).some(entry => entry.key === key && entry.mode === row.mode)) return;
+        (state.handed ??= []).push({ key, cell: row.cell, cardId: row.cardId, mode: row.mode, launched: row.launched });
+      };
+      // A retried delegate (died after assigning, before saving state) rebuilds this run's cap usage from what it already
+      // wrote: seat rows tagged with this run and live hands claimed by this run.
+      if (cap !== undefined && state.delegatedKeys) {
+        const used = new Set(state.delegatedKeys);
+        if (existsSync(path)) for (const line of readFileSync(path, 'utf8').split('\n')) {
+          if (!line) continue;
+          let row: { key?: unknown; source?: unknown; orchRunId?: unknown };
+          try { row = JSON.parse(line) as typeof row; } catch { throw new Error('invalid seat request journal'); }
+          if (row.source === 'orchestrator' && row.orchRunId === runId && typeof row.key === 'string') used.add(row.key);
+        }
+        for (const row of handedRows(ledger).values()) if (row.runId === runId && row.mode === 'live') used.add(row.key);
+        if (existsSync(ledger)) for (const line of readFileSync(ledger, 'utf8').split('\n')) {
+          if (!line) continue;
+          try {
+            const claim = JSON.parse(line) as { key?: unknown; runId?: unknown; mode?: unknown; status?: unknown };
+            if (claim.runId === runId && claim.mode === 'live' && claim.status === 'claimed' && typeof claim.key === 'string') used.add(claim.key);
+          } catch { /* handedKeys already rejects a broken ledger */ }
+        }
+        state.delegatedKeys = [...used];
+      }
+      const journalHas = (key: string): boolean => {
+        if (!existsSync(path)) return false;
+        return readFileSync(path, 'utf8').split('\n').some(line => {
+          if (!line) return false;
+          try { return (JSON.parse(line) as { key?: string }).key === key; } catch { throw new Error('invalid seat request journal'); }
+        });
+      };
       for (const cell of state.cells) {
         if (cell.origin !== 'flow1a' || !cell.seat) continue;
         const targetLoopId = SEAT_LOOP_IDS[cell.seat];
         if (!targetLoopId) continue;
         const key = `orch:${cell.cardId}:${cell.id}`;
+        // 저널 키로 건너뛰기 «전에» 원장에서 복구한다 — shadow 넘김 ⊕ 자리 기록 뒤 상태 저장 전에 죽은 run 도 handed[] 를 되찾게.
+        restoreHanded(key, key, ledgerHanded);
+        restoreHanded(`shadow:${key}`, key, ledgerHanded);
         if (keys.has(key)) continue;
+        if (liveHanded.has(key)) { keys.add(key); observe('exchange', `handed-to-task-agent:${key}`, 1, 'task-agent'); continue; }
+        // COORD-HA ②: a live tick skips unplaced cells for assignment; L2 assigns nothing new (live hands included) and the
+        // per-tick cap defers the rest to the next tick — both before the TASK-AGENT hand so a hand never bypasses them.
+        const unplacedLive = mode === 'live' && !validVersion(cell.version);
+        // L2 carries every cell — placed or not — to the next tick: split already marked the card, so a cell skipped here
+        // would never be split again.
+        if (state.degradation?.level === 2 || (unplacedLive && state.placeDegraded)) {
+          state.deferredCells?.push(cell);
+          continue;
+        }
+        // The cap limits assignments (a live hand or a seat row); a shadow card is not an assignment and is still written.
+        const capped = !unplacedLive && cap !== undefined && state.delegatedKeys!.length >= cap;
+        // ORCH-TA-HAND: hand the picked cell to TASK-AGENT. shadow = card only (the seat path below is unchanged);
+        // live (tick live ⊕ hand live) = launch through TASK-AGENT and skip the seat journal so the cell launches once.
+        const handMode = deps.handToTaskAgent ?? handConfig.handToTaskAgent ?? 'off';
+        const handCell = deps.handToTaskAgentCell ?? handConfig.handToTaskAgentCell;
+        if (handMode !== 'off' && (!handCell || handCell === cell.id) && (TASK_SEATS as readonly string[]).includes(cell.seat)) {
+          // live 는 tick 도 live 이고 배치(유효한 판)가 된 칸만 — 나머지는 카드만(shadow · 배치 전 칸도 표본이 된다).
+          const handLive = handMode === 'live' && mode === 'live' && validVersion(cell.version) && !capped;
+          // shadow 표본은 따로 센다 — 자리 경로로 아직 안 간 칸(shadow 틱·배치 전)이 나중에 live 로 바뀌면 그때 뜬다.
+          // ⚠️ 이미 자리 저널에 들어간 칸은 live 로 바꿔도 다시 안 넘긴다(keys.has 에서 끝) — 한 칸의 발사 주체는 하나다(의도).
+          const handKey = handLive ? key : `shadow:${key}`;
+          mkdirSync(dirname(ledger), { recursive: true });
+          mkdirSync(dirname(path), { recursive: true });
+          // Claim under the seat-journal lock — the same lock the seat append takes, so a live claim and a seat row never both land.
+          const claimed = withFileLockSync(`${path}.lock`, () => {
+            if (handedKeys(ledger).has(handKey)) return false;
+            if (handLive && journalHas(key)) return false;
+            appendFileSync(ledger, `${JSON.stringify({ key: handKey, cell: cell.id, seat: cell.seat, mode: handLive ? 'live' : 'shadow', status: 'claimed', runId, at: now.toISOString() })}\n`);
+            return true;
+          });
+          if (claimed) {
+            try {
+              const result = await (deps.handTask ?? (async (opts: HandTaskOptions) => (await import('../../task-agent/task-hand.js')).handTask(opts)))({
+                text: cell.title, seat: cell.seat as TaskSeat, checklistId: cell.id, live: handLive, now: () => now,
+                statePath: join(root, 'task-agent-actions.json'),
+                ...(handLive ? { launcher: deps.taskLauncher ?? (async (args: string[], _cwd?: string, context?: Parameters<TaskLauncher>[2]) => (await import('../../cli/tasks-cli.js')).defaultTaskLauncher(args, undefined, context)) } : {}),
+              });
+              withFileLockSync(`${path}.lock`, () => appendFileSync(ledger, `${JSON.stringify({ key: handKey, cell: cell.id, cardId: result.card.id, mode: result.mode, launched: result.launched, status: 'handed', runId, at: now.toISOString() })}\n`));
+              (state.handed ??= []).push({ key, cell: cell.id, cardId: result.card.id, mode: result.mode, launched: result.launched });
+              observe('hand-to-task-agent', `${key}:${result.card.id}:${result.mode}${result.launched ? ':launched' : ''}`, 1, 'task-agent');
+              // A live hand is an assignment: it counts toward maxDelegatePerTick like a seat row (COORD-HA ②).
+              if (handLive) { keys.add(key); state.delegatedKeys?.push(key); continue; }
+            } catch (error) {
+              observe('hand-to-task-agent-failed', `${key}:${String(error).slice(0, 160)}`, 1, 'task-agent');
+              // A failed live hand stays claimed (no relaunch loop) and does not fall back to the seat path — one launcher per cell.
+              if (handLive) { keys.add(key); continue; }
+              // A failed shadow hand launched nothing — release the claim so a later tick can write the card,
+              // but only when no card for this cell was written (a failure after the card must not make a second one).
+              let cardWritten = true;
+              try {
+                const storePath = join(root, 'task-agent-actions.json');
+                if (!existsSync(storePath)) cardWritten = false;
+                else {
+                  // 상태를 믿을 수 있을 때만 «카드 0장»으로 읽는다 — tasks 가 없거나 꼴이 틀리면 claim 을 남긴다.
+                  const tasks = readTaskAgentState<{ tasks?: unknown }>(storePath).tasks;
+                  if (tasks && typeof tasks === 'object' && !Array.isArray(tasks)
+                    && Object.values(tasks).every(card => card && typeof card === 'object' && !Array.isArray(card))) {
+                    cardWritten = Object.values(tasks as Record<string, TaskAgentCard>).some(card => card.checklistId === cell.id && card.text === cell.title);
+                  }
+                }
+              } catch { cardWritten = true; /* unreadable store → keep the claim (never risk a duplicate) */ }
+              if (!cardWritten) withFileLockSync(`${path}.lock`, () => appendFileSync(ledger, `${JSON.stringify({ key: handKey, cell: cell.id, status: 'released', runId, reason: String(error).slice(0, 160), at: now.toISOString() })}\n`));
+            }
+          } else {
+            restoreHanded(handKey, key);
+            if (handLive) { keys.add(key); continue; }
+          }
+        }
+        if (capped) {
+          state.deferredCells!.push(cell);
+          observe('cap-deferred', key, 1, targetLoopId);
+          continue;
+        }
+        if (unplacedLive) continue;
         if (!validVersion(cell.version)) {
-          if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', `${key} (unplaced)`, 1, targetLoopId); }
+          if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; state.delegatedKeys?.push(key); observe('would-delegate', `${key} (unplaced)`, 1, targetLoopId); }
           continue;
         }
-        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', key, 1, targetLoopId); continue; }
+        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; state.delegatedKeys?.push(key); observe('would-delegate', key, 1, targetLoopId); continue; }
         keys.add(key);
         mkdirSync(dirname(path), { recursive: true });
         // TC review must-fix ①: the seat-requests journal contract needs receiptId, and appends are serialized under the
         // same lock as the traffic node — an invalid row stops request intake for every seat.
-        const appended = withFileLockSync(`${path}.lock`, () => {
-          const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
-          if (existing.split('\n').some(line => {
-            if (!line) return false;
-            try { return (JSON.parse(line) as { key?: string }).key === key; } catch { throw new Error('invalid seat request journal'); }
-          })) return false;
-          appendFileSync(path, `${JSON.stringify({ key, receiptId: key, seat: cell.seat, ...(cell.host !== undefined ? { host: cell.host } : {}), loopId: targetLoopId, text: cell.title, status: 'queued', queuedAt: now.toISOString(), source: 'orchestrator', cell: cell.id, version: cell.version })}\n`);
+        const appended = withFileLockSync(`${path}.lock`, (): boolean | 'handed' => {
+          if (journalHas(key)) return false;
+          // 잠금 안에서 다시 본다 — 동시 틱이 이 칸을 방금 live 로 넘겼으면 자리 경로로 보내지 않는다.
+          if (handedKeys(ledger).has(key)) return 'handed';
+          appendFileSync(path, `${JSON.stringify({ key, receiptId: key, seat: cell.seat, ...(cell.kind !== undefined ? { kind: cell.kind } : {}), ...(cell.host !== undefined ? { host: cell.host } : {}), ...(cell.gridHost ? { gridHost: true } : {}), loopId: targetLoopId, text: cell.title, status: 'queued', queuedAt: now.toISOString(), source: 'orchestrator', cell: cell.id, version: cell.version, orchRunId: runId })}\n`);
           return true;
         });
+        if (appended === 'handed') { observe('exchange', `seat-suppressed-handed:${key}`, 1, 'task-agent'); continue; }
         if (!appended) continue;
         state.delegated++;
+        state.delegatedKeys?.push(key);
         observe('exchange', 'queued', 1, targetLoopId);
       }
     } else if (node === 'launch') {
-      const eligible = state.cells.filter(cell => cell.origin === 'flow1a' && cell.seat && SEAT_LOOP_IDS[cell.seat]
-        && validVersion(cell.version) && (mode === 'shadow' || readRequests(root).some(row => row.key === `orch:${cell.cardId}:${cell.id}` && row.status === 'queued')));
+      if (state.degradation?.level === 2) observe('degraded-skip', 'launch', 0);
+      // shadow 는 저널을 읽지 않는다 — 깨진 live 저널이 관측 전용 틱을 넘어뜨리지 않게.
+      const latestRequests = new Map(mode === 'live' && state.degradation?.level !== 2 ? readRequests(root).map(row => [row.key, row]) : []);
+      const eligible = state.cells.filter(cell => state.degradation?.level !== 2 && cell.origin === 'flow1a' && cell.seat && SEAT_LOOP_IDS[cell.seat]
+        && validVersion(cell.version) && (mode === 'shadow' || latestRequests.get(`orch:${cell.cardId}:${cell.id}`)?.status === 'queued')
+        && (orchestratorConfig?.maxDelegatePerTick === undefined || state.delegatedKeys?.includes(`orch:${cell.cardId}:${cell.id}`)
+          || (mode === 'live' && latestRequests.has(`orch:${cell.cardId}:${cell.id}`))));
       const seats = [...new Set(eligible.map(cell => cell.seat!))];
       state.launched = [];
       for (const seat of seats) {
@@ -293,9 +654,23 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           state.launched.push({ seat, key: item.id, status: action.kind === 'harness' ? 'would-launch' : `would-${action.kind}` });
           observe('exchange', `would-${action.kind}:${seat}`, 1, SEAT_LOOP_IDS[seat]);
         } else {
-          const turn = await (deps.seatTurn ?? ((assigned: string, stateRoot: string) => runSeatLoopOnce(assigned, {
-            root: stateRoot, config: { ...getUserConfig().loops?.seat, mode: 'live-safe', seats: [assigned] },
-          })))(seat, root);
+          const selected = eligible.find(cell => cell.seat === seat && latestRequests.get(`orch:${cell.cardId}:${cell.id}`)?.status === 'queued');
+          const host = selected && latestRequests.get(`orch:${selected.cardId}:${selected.id}`)?.host;
+          const pools = new Map<string, string>([...latestRequests].flatMap(([key, row]) => {
+            if (row.status !== 'queued' || row.seat !== seat || row.kind !== 'pod' || !row.gridHost || !row.host || !key.startsWith('orch:')) return [];
+            const pool = preferredPoolSpec(row.host);
+            // 풀 힌트는 «설정된 풀»의 순서 바꾸기다 — 고른 호스트가 풀에 없으면 힌트를 지어내지 않고 그 사실을 남긴다.
+            if (!pool) observe('exchange', `grid-host-unmapped:${key}:${row.host}`, 1, SEAT_LOOP_IDS[seat]);
+            return pool ? [[key, pool] as const] : [];
+          }));
+          const enqueue: SeatDeps['enqueue'] | undefined = pools.size
+            ? (queuedSeat, text, queuedRoot, idempotencyKey, item) => addHarnessQueue({ seat: queuedSeat, say: text, idempotencyKey,
+              ...(item.source === 'request' && pools.has(item.id) ? { poolHint: pools.get(item.id), poolHintSource: 'grid' as const } : {}) }, { root: queuedRoot })
+            : undefined;
+          const options = enqueue ? { enqueue } : undefined;
+          const turn = await (deps.seatTurn ?? ((assigned: string, stateRoot: string, _preferred?: string, overrides?: Pick<SeatDeps, 'enqueue'>) =>
+            runSeatLoopOnce(assigned, { root: stateRoot,
+              config: { ...getUserConfig().loops?.seat, mode: 'live-safe', seats: [assigned] }, ...overrides })))(seat, root, host, options);
           // 자리 턴이 «이 틱이 넣은 의뢰»를 처리했을 때만 칸에 잇는다 — 대기열의 다른 의뢰는 이 카드의 발사가 아니다.
           const targets = new Set(eligible.filter(row => row.seat === seat).map(row => `orch:${row.cardId}:${row.id}`));
           const handled = 'item' in turn && turn.item?.source === 'request' ? turn.item.id : undefined;
@@ -318,6 +693,10 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           state.cells = merge(previous.cells, state.cells, cell => `${cell.cardId}:${cell.id}`);
           state.launched = merge(previous.launched ?? [], state.launched ?? [], turn => turn.queueId ?? `${turn.seat}:${turn.key ?? ''}`);
         }
+        if (mode === 'live') {
+          refreshGridHosts(state.cells, resolveGridHosts(deps, observe), mode, root, observe);
+          await syncQueuedPoolHints(root, state.launched ?? [], deps, observe);
+        }
       }
       state.queueOutcomes = (state.launched ?? []).filter(turn => turn.queueId).map(turn => {
         const outcome = (deps.queueOutcome ?? ((id: string, stateRoot: string) => harnessQueueOutcome(id, { root: stateRoot })))(turn.queueId!, root);
@@ -362,19 +741,36 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   return state;
 }
 
+/** COORD-HA — the production supply of `TickDeps.degradation` (config `loops.orchestrator.degradationSignal`). Shadow (the
+ *  default) probes and logs what the tick would have done; only live hands the signal to the tick. */
+export async function degradationDeps(node: Node, deps: { config?: () => Partial<OrchestratorLoopConfig> | undefined; root?: string;
+  probe?: (root: string) => { llm: boolean; board: boolean; why: string[] } } = {}): Promise<Pick<TickDeps, 'degradation'>> {
+  const mode = (deps.config ?? (() => getUserConfig().loops?.orchestrator))()?.degradationSignal ?? 'shadow';
+  if (mode === 'off') return {};
+  const root = deps.root ?? effectiveInstanceRoot();
+  const signal = (deps.probe ?? (await import('./degradation.js')).probeDegradation)(root);
+  const level = !signal.board ? 2 : !signal.llm ? 1 : 0;
+  debug.log('loop.orchestrator', 'degradation-signal', { node, mode, llm: signal.llm, board: signal.board, level, why: signal.why });
+  return mode === 'live' ? { degradation: () => ({ llm: signal.llm, board: signal.board }) } : {};
+}
+
 if (import.meta.main) {
   const node = process.argv[2];
   const index = process.argv.indexOf('--window');
-  const window = index < 0 ? undefined : process.argv[index + 1];
+  // ORCH-LIVE-1008: `graph run` recipes pass no flags, so a manual/rehearsal tick picks its window through the
+  // environment (`ELANOUS_ORCH_WINDOW=08 elanous graph run graphs/orchestrator/orchestrator.yaml`). The flag wins.
+  const window = index < 0 ? process.env.ELANOUS_ORCH_WINDOW : process.argv[index + 1];
+  // A given flag (even without a value) or a set variable must name a real window — never fall back to «now».
+  const windowGiven = index >= 0 || process.env.ELANOUS_ORCH_WINDOW !== undefined;
   if (!['intake', 'split', 'place', 'delegate', 'launch', 'reconcile', 'report'].includes(node ?? '') ||
-      (window !== undefined && !['08', '12', '18'].includes(window))) {
-    console.error('orchestrator: expected <intake|split|place|delegate|launch|reconcile|report> [--window 08|12|18]');
+      (windowGiven && !['08', '12', '18'].includes(window ?? ''))) {
+    console.error('orchestrator: expected <intake|split|place|delegate|launch|reconcile|report> [--window 08|12|18] (or ELANOUS_ORCH_WINDOW=08|12|18)');
     process.exitCode = 2;
   } else {
     void (async () => {
       try { await (await import('../../domains/standalone-log-sink.js')).registerStandaloneLogSink('orchestrator'); }
       catch { /* local execution can still use the per-run file */ }
-      await runOrchestratorNode(node as Node, { window: window as Window | undefined });
+      await runOrchestratorNode(node as Node, { window: window as Window | undefined, ...await degradationDeps(node as Node) });
     })().catch(error => { console.error(`orchestrator ${node}: ${String(error)}`); process.exitCode = 1; });
   }
 }