elanous 0.2.17 → 0.2.18

package/src/loops/budget.ts

@@ -61,3 +61,39 @@ export function decideSpawn({ seat, running, caps, gate, injectedCap }: SpawnBud
     ? { allow: true, reason: 'within-cap', cap }
     : { allow: false, reason: 'seat-cap', cap };
 }
+
+/** SEAT-CAP-STALE: why a run or a queue row is left out of a seat's running count (counting only — nothing is stopped). */
+export type SeatCapExclusionReason = 'stale' | 'soft-stopped' | 'unknown-seat' | 'dead-row';
+export const SEAT_CAP_STALE_RUN_MINUTES = 30;
+export const SEAT_CAP_UNKNOWN_SEAT_CAP = 2;
+/** A just-launched row has no process yet; it keeps its seat for this long. */
+export const SEAT_CAP_LAUNCH_GRACE_MINUTES = 5;
+
+export type SeatCapSubject =
+  | { kind: 'run'; seat?: OrchestratorSeat; progressAt?: number; stopReason?: string }
+  | { kind: 'row'; status: string; receipt: 'started' | 'finished' | 'not-started' | null; live: boolean; launchedAt?: number };
+
+export type SeatCapExclusion = { reason: SeatCapExclusionReason; idleMin: number | null } | null;
+
+/**
+ * Pure judgement: null = the subject holds a seat. A run without a seat goes to the unknown-seat bucket; a run whose
+ * supervisor already stopped (awaiting harvest) or whose last progress is older than staleRunMinutes is excluded; a
+ * launched row with no live process past the launch grace is a dead row. A run with no progress signal still counts.
+ */
+export function seatCapExclusion(subject: SeatCapSubject, now: number,
+  { staleRunMinutes = SEAT_CAP_STALE_RUN_MINUTES, launchGraceMinutes = SEAT_CAP_LAUNCH_GRACE_MINUTES }:
+  { staleRunMinutes?: number; launchGraceMinutes?: number } = {}): SeatCapExclusion {
+  const minutes = (at: number | undefined): number | null =>
+    at !== undefined && Number.isFinite(at) ? Math.max(0, Math.floor((now - at) / 60_000)) : null;
+  if (subject.kind === 'row') {
+    if (subject.status !== 'launched' && subject.status !== 'launching') return null;
+    if (subject.live || subject.receipt === 'finished' || subject.receipt === 'not-started') return null;
+    const idle = minutes(subject.launchedAt);
+    return idle !== null && now - subject.launchedAt! >= launchGraceMinutes * 60_000 ? { reason: 'dead-row', idleMin: idle } : null;
+  }
+  const idle = minutes(subject.progressAt);
+  if (!subject.seat) return { reason: 'unknown-seat', idleMin: idle };
+  if (subject.stopReason) return { reason: 'soft-stopped', idleMin: idle };
+  if (idle !== null && now - subject.progressAt! >= staleRunMinutes * 60_000) return { reason: 'stale', idleMin: idle };
+  return null;
+}

package/src/loops/orchestrator/finish-rate.ts

@@ -1,8 +1,9 @@
 import { execFileSync } from 'node:child_process';
-import { readdirSync, realpathSync, statSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { loadRunLedger, resolveFederatedRunLedgerTargets } from '../../self-implement/run-ledger.js';
+import { withFileLockSync } from '../../storage/file-lock.js';
 import type { LogTarget } from '../../cli/logs-cli.js';
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
@@ -24,6 +25,77 @@ export type FinishMetrics = {
 export type FinishAdvice = { finishSlots: number; launchSlots: number; state: 'healthy' | 'backlogged' | 'unknown'; reasons: string[] };
 export type FinishThresholds = { landingRate?: number; staleDrafts?: number; conflictRatio?: number };
 
+export type FinishTrend = 'worsening' | 'improving' | 'flat' | 'unknown';
+export type FinishTrendInput = Pick<FinishMetrics, 'landingRate' | 'staleDrafts' | 'conflictRatio'>;
+export type FinishHistoryRow = {
+  hour: string; at: string; launched: number | null; landed: number | null;
+  landingRate: number | null; staleDrafts: number | null; conflictRatio: number | null; trend: FinishTrend;
+};
+
+/** FINISH-RATE 추세 — landingRate 는 내려가면 나쁨 · staleDrafts·conflictRatio 는 올라가면 나쁨.
+ *  양쪽 다 유한한 숫자인 지표만 비교한다(못 잰 값은 좋음도 나쁨도 아니다) · 임의 임계 없음.
+ *  나쁨 수 > 좋음 수 = worsening · 작으면 improving · 같으면 flat · 비교한 지표가 0 이면 unknown. */
+export function finishTrend(previous: FinishTrendInput | null, current: FinishTrendInput): FinishTrend {
+  if (!previous) return 'unknown';
+  let compared = 0, worse = 0, better = 0;
+  for (const key of ['landingRate', 'staleDrafts', 'conflictRatio'] as const) {
+    const before = previous[key], after = current[key];
+    if (typeof before !== 'number' || !Number.isFinite(before) || typeof after !== 'number' || !Number.isFinite(after)) continue;
+    compared++;
+    const delta = key === 'landingRate' ? before - after : after - before;
+    if (delta > 0) worse++;
+    else if (delta < 0) better++;
+  }
+  if (compared === 0) return 'unknown';
+  return worse > better ? 'worsening' : worse < better ? 'improving' : 'flat';
+}
+
+export function finishHistoryPath(root: string): string {
+  return join(root, 'harness', 'finish-history.jsonl');
+}
+
+/** «한 시간 한 줄» 이력 — 같은 UTC 시간 줄이 이미 있으면 안 쓴다(null) · trend 는 지금보다 이른 가장 최근 시간 줄 대비.
+ *  읽을 수 없는 줄은 건너뛴다(이력 한 줄이 깨졌다고 측정을 멈추지 않는다). 쓰기 실패는 호출자에게 던진다. */
+export function recordFinishHistory(root: string, metrics: FinishMetrics, now: Date): FinishHistoryRow | null {
+  const path = finishHistoryPath(root);
+  const hour = now.toISOString().slice(0, 13);
+  mkdirSync(join(root, 'harness'), { recursive: true });
+  // 확인과 덧붙이기를 한 잠금 안에서 — 같은 root 를 쓰는 두 틱이 같은 시간에 둘 다 «없음»을 보고 두 줄을 쓰지 않게.
+  const row = withFileLockSync(`${path}.lock`, (): FinishHistoryRow | null => {
+    const rows: FinishHistoryRow[] = [];
+    let text = '';
+    if (existsSync(path)) {
+      text = readFileSync(path, 'utf8');
+      for (const line of text.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line) as FinishHistoryRow;
+          if (parsed && typeof parsed.hour === 'string') rows.push(parsed);
+        } catch { /* a broken line is skipped */ }
+      }
+    }
+    if (rows.some((existing) => existing.hour === hour)) return null;
+    // 앞 시간 = 지금보다 이른 줄 중 «가장 최근 UTC 시간»(파일 순서가 아니다 — 늦게 덧붙은 옛 시간 줄이 있을 수 있다) · 같은 시간이면 마지막 줄.
+    let previous: FinishHistoryRow | null = null;
+    for (const existing of rows) if (existing.hour < hour && (!previous || existing.hour >= previous.hour)) previous = existing;
+    const next: FinishHistoryRow = {
+      hour, at: now.toISOString(), launched: metrics.launched, landed: metrics.landed,
+      landingRate: metrics.landingRate, staleDrafts: metrics.staleDrafts, conflictRatio: metrics.conflictRatio,
+      trend: finishTrend(previous, metrics),
+    };
+    // 부분 쓰기로 끝 개행이 없으면 먼저 보정한다 — 새 줄이 깨진 꼬리에 붙어 둘 다 못 읽게 되지 않게.
+    appendFileSync(path, `${text && !text.endsWith('\n') ? '\n' : ''}${JSON.stringify(next)}\n`);
+    return next;
+  });
+  if (!row) return null;
+  try {
+    debug.log('loop.orchestrator', 'finish-history', {
+      hour, trend: row.trend, landingRate: row.landingRate, staleDrafts: row.staleDrafts, conflictRatio: row.conflictRatio,
+    });
+  } catch { /* the row is written; observation is fail-soft */ }
+  return row;
+}
+
 type Start = { runId: string; startedAt: string };
 type StartObservation = { starts: readonly Start[]; unreadable: readonly { runId: string; reason: string }[]; unreadableDirectories?: number };
 type Pr = { number: number; headRefName: string; mergedAt?: string; createdAt?: string; mergeable?: string; labels?: { name: string }[] };

package/src/loops/orchestrator/grid-place.ts

@@ -0,0 +1,11 @@
+interface GridCell { kind?: string }
+export interface GridHost { name: string; capabilities: ReadonlySet<string>; available: boolean }
+
+/** A proposal only: the caller owns the host inventory and the actual launch. */
+export function placeOnGrid(cell: GridCell, hosts: readonly GridHost[]): { host: string; reason?: never } | { host: null; reason: string } {
+  const kind = cell.kind ?? 'unknown';
+  const host = hosts.find(candidate => candidate.available && candidate.capabilities.has(kind));
+  if (host) return { host: host.name };
+  return { host: null, reason: hosts.some(candidate => candidate.capabilities.has(kind))
+    ? `no available host for ${kind}` : `no host with ${kind} capability` };
+}

package/src/loops/orchestrator/tick.ts

@@ -5,30 +5,36 @@ import { CardStore, taskCardsDir, type TaskCard } from '../../task-cards/card-st
 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 { 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'; 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[];
   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 +42,50 @@ 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 } }>;
+  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 {
@@ -122,10 +166,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');
@@ -215,7 +387,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         const cells = 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', ...(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,6 +398,9 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         }
       }
     } else if (node === 'place') {
+      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); }
@@ -251,13 +426,94 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       }
     } else if (node === 'delegate') {
       const path = journal(root);
+      // 모드와 칸 필터는 따로 푼다 — 주입으로 모드만 줘도 설정의 칸 필터는 그대로 먹는다.
+      const handConfig: Partial<OrchestratorLoopConfig> = deps.handToTaskAgent !== undefined && deps.handToTaskAgentCell !== undefined ? {} : getUserConfig().loops?.orchestrator ?? {};
+      // live 로 넘긴 칸은 지금 설정(off·칸 필터)과 무관하게 자리 경로로 다시 안 간다 — 발사 주체가 둘이 되지 않게.
+      // ⭐ 넘김 claim 과 자리 저널 기록은 «같은 잠금»(자리 저널 잠금) 아래에서 서로를 다시 읽는다 — 동시 틱이 낡은 값을 보지 않게.
+      const ledger = handedLedger(root);
+      const liveHanded = handedKeys(ledger);
       const keys = new Set(readRequests(root).map(row => row.key));
+      // 넘김 뒤 상태 저장 전에 죽은 같은 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 });
+      };
+      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; }
+        // 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);
+          // 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[]) => (await import('../../cli/tasks-cli.js')).defaultTaskLauncher(args)) } : {}),
+              });
+              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');
+              if (handLive) { keys.add(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 (!validVersion(cell.version)) {
           if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', `${key} (unplaced)`, 1, targetLoopId); }
           continue;
@@ -267,22 +523,23 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         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 })}\n`);
           return true;
         });
+        if (appended === 'handed') { observe('exchange', `seat-suppressed-handed:${key}`, 1, 'task-agent'); continue; }
         if (!appended) continue;
         state.delegated++;
         observe('exchange', 'queued', 1, targetLoopId);
       }
     } else if (node === 'launch') {
+      // shadow 는 저널을 읽지 않는다 — 깨진 live 저널이 관측 전용 틱을 넘어뜨리지 않게.
+      const latestRequests = new Map(mode === 'live' ? readRequests(root).map(row => [row.key, row]) : []);
       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')));
+        && validVersion(cell.version) && (mode === 'shadow' || latestRequests.get(`orch:${cell.cardId}:${cell.id}`)?.status === 'queued'));
       const seats = [...new Set(eligible.map(cell => cell.seat!))];
       state.launched = [];
       for (const seat of seats) {
@@ -293,9 +550,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 +589,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);

package/src/maturity/feature-maturity.ts

@@ -46,6 +46,7 @@ export const FEATURE_MATURITY = {
     '/ops/seats': { pwa: 'ops' },
     '/ops/checklist': { pwa: 'ops' },
     '/ceo': { pwa: 'ops' },
+    '/decisions': { pwa: 'ops' },
     '/dashboard': { pwa: 'ops' },
     '/bots': { pwa: 'ops' },
     '/botlab': { pwa: 'ops' },
@@ -75,7 +76,7 @@ export const FEATURE_MATURITY = {
     schedule: 'beta', intake: 'beta', logs: 'stable', ad: 'beta', docs: 'beta',
     decisions: 'beta', directives: 'beta', claims: 'beta', lesson: 'beta', fleet: 'beta', ops: 'stable', outputs: 'beta', publish: 'beta',
     env: 'beta', 'agent-mission': 'beta', dev: 'beta', keys: 'beta', finance: 'beta',
-    config: 'stable', tasks: 'stable', brief: 'beta', labels: 'beta', msg: 'beta', ask: 'stable',
+    config: 'stable', tasks: 'stable', brief: 'beta', notify: 'beta', labels: 'beta', msg: 'beta', ask: 'stable',
     onboarding: 'beta', login: 'stable', session: 'beta', chat: 'stable', repl: 'stable',
     agent: 'stable', registry: 'beta', tier: 'stable', local: 'beta', scheduler: 'beta',
     attach: 'beta', wf: 'beta', nexus: 'stable', phone: 'beta', token: 'beta',
@@ -166,7 +167,7 @@ export const FEATURE_MATURITY = {
   },
   discordCommand: {
     status: 'stable', sessions: 'stable', new: 'stable', fork: 'stable',
-    persona: 'beta', poll: 'beta', attach: 'beta', now: 'beta',
+    persona: 'beta', poll: 'beta', attach: 'beta', now: 'beta', loops: 'beta',
     brain: 'tool', cc: 'tool', cdx: 'tool', gem: 'tool',
     relay: 'ops', showroom: 'ops', bots: 'ops', bot: 'ops', screen: 'ops', chart: 'ops',
     routines: 'ops', botsay: 'ops', 'voice-join': 'ops', 'voice-leave': 'ops', 'voice-status': 'ops',

package/src/nexus/api/decisions-route.ts

@@ -1,5 +1,6 @@
 import { debug } from '../../debug/log.js';
 import { DecisionLedger, type DecisionEntry } from '../../decisions/decision-ledger.js';
+import { isIrreversible } from '../../decisions/decision-cards.js';
 import { jsonResponse } from './json-response.js';
 
 export const DECISIONS_PATH = '/v1/decisions';
@@ -27,10 +28,19 @@ export async function handleDecisions(req: Request, deps: DecisionsRouteDeps = {
       id: entry.id,
       title: entry.title,
       situation: entry.scqa.s.slice(0, 200),
-      options: entry.options.map(option => ({ id: option.key, label: option.label })),
+      options: entry.options.map(option => ({ id: option.key, label: option.label, consequence: option.consequence })),
       recommendation: entry.recommendation,
       raisedAt: entry.raisedAt,
       dueAt: entry.dueAt,
+      scqa: entry.scqa,
+      category: entry.category,
+      irreversible: isIrreversible(entry),
+      raisedBy: { agent: entry.raisedBy.agent, ...(entry.raisedBy.track ? { track: entry.raisedBy.track } : {}) },
+      alternative: entry.alternative,
+      dissent: entry.dissent,
+      crossCheck: entry.crossCheck,
+      crossCheckSkipped: entry.crossCheckSkipped,
+      pendingQuestion: entry.pendingQuestion,
     }));
     debug.log('decisions.api', 'listed', { count: decisions.length });
     return jsonResponse({ decisions });