elanous 0.2.14 → 0.2.16

package/src/loops/orchestrator/seat-share.ts

@@ -0,0 +1,56 @@
+import type { ChecklistItem } from '../../release-loop/checklist.js';
+import type { OrchestratorSeat } from '../../user-config.js';
+
+const SEATS: readonly OrchestratorSeat[] = ['OP', 'TC', 'MK', 'UX'];
+type WorkCell = Pick<ChecklistItem, 'owner' | 'status'>;
+
+/** Allocate whole base slots by remaining work; this calculation does not decide launches. */
+export function calculateSeatBaseShares({ totalSlots, currentRound, nextRound, seatCaps }: {
+  totalSlots: number;
+  currentRound: readonly WorkCell[];
+  nextRound: readonly WorkCell[];
+  seatCaps: Readonly<Record<OrchestratorSeat, number>>;
+}): Record<OrchestratorSeat, number> {
+  if (!Number.isSafeInteger(totalSlots) || totalSlots < 0 ||
+    SEATS.some(seat => !Number.isSafeInteger(seatCaps[seat]) || seatCaps[seat] < 0)) {
+    throw new RangeError('totalSlots and seatCaps must be nonnegative safe integers');
+  }
+  const shares: Record<OrchestratorSeat, number> = { OP: 0, TC: 0, MK: 0, UX: 0 };
+  const weights: Record<OrchestratorSeat, number> = { OP: 0, TC: 0, MK: 0, UX: 0 };
+  for (const [cells, weight] of [[currentRound, 2], [nextRound, 1]] as const) {
+    for (const cell of cells) {
+      if (cell.status !== 'yellow') continue;
+      const seat = cell.owner?.split('/')[0];
+      if (SEATS.some(id => id === seat)) weights[seat as OrchestratorSeat] += weight;
+    }
+  }
+
+  let available = Math.min(totalSlots, SEATS.reduce((sum, seat) => sum + seatCaps[seat], 0));
+  let eligible = SEATS.filter(seat => weights[seat] > 0 && seatCaps[seat] > 0);
+  while (available > 0 && eligible.length > 0) {
+    const totalWeight = eligible.reduce((sum, seat) => sum + weights[seat], 0);
+    const ideal = (seat: OrchestratorSeat) => available * weights[seat] / totalWeight;
+    const capped = eligible.filter(seat => ideal(seat) >= seatCaps[seat]);
+    if (capped.length > 0) {
+      for (const seat of capped) {
+        shares[seat] = seatCaps[seat];
+        available -= seatCaps[seat];
+      }
+      eligible = eligible.filter(seat => !capped.includes(seat));
+      continue;
+    }
+    const remainders = eligible.map(seat => ({ seat, exact: ideal(seat) }));
+    for (const { seat, exact } of remainders) {
+      shares[seat] = Math.floor(exact);
+      available -= shares[seat];
+    }
+    remainders.sort((a, b) => (b.exact - Math.floor(b.exact)) - (a.exact - Math.floor(a.exact)));
+    for (const { seat } of remainders) {
+      if (available === 0) break;
+      shares[seat]++;
+      available--;
+    }
+    break;
+  }
+  return shares;
+}

package/src/loops/orchestrator/tick.ts

@@ -8,17 +8,22 @@ import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { getUserConfig } 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';
 
 export type Window = '08' | '12' | '18';
-export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'reconcile' | 'report';
+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 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;
+  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 }>;
+  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[];
 }
@@ -26,11 +31,13 @@ export interface TickState {
 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 }>;
 /** 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) => Promise<{ version?: string } | null> | { version?: string } | null;
-export type RebalanceAdapter = (version: string) => Promise<unknown[]> | unknown[];
+export type PlaceAdapter = (cell: PlacementInput, deps?: { dryRun?: boolean; now?: Date }) => Promise<{ version?: string } | null> | { version?: string } | null;
+export type RebalanceAdapter = (version: string) => Promise<{ decisions: unknown[]; blocked: Array<{ id: string; reason: string }> }> | { decisions: unknown[]; blocked: Array<{ id: string; reason: string }> };
 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 } }>;
+  queueOutcome?: (queueId: string, root: string) => 'pending' | 'unknown' | 'retryable' | 'succeeded';
   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;
@@ -54,7 +61,10 @@ export function wishCards(cards: readonly TaskCard[]): TaskCard[] {
   return cards.filter(card => card.status === 'open' && card.goalId.startsWith('wish:') &&
     !card.sections.some(section => section.key === 'orch:split' || section.key.startsWith('orch:split:')));
 }
-export function reconciliation(cells: readonly Cell[], requests: readonly { key: string; status: string }[], checklist: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[]): TickState['reconciled'] {
+export function reconciliation(cells: readonly Cell[], requests: readonly { key: string; status: string }[], checklist: (version: string) => Pick<ChecklistItem, 'id' | 'status'>[],
+  queue: readonly { key: string; outcome: string }[] = []): TickState['reconciled'] {
+  // 체크리스트가 정본이고, 칸이 아직 체크리스트에 없을 때만 «그 칸의 의뢰 키»로 발사된 대기열 결과를 본다.
+  const queueByKey = new Map(queue.map(row => [row.key, row.outcome]));
   const result = { reached: 0, progressing: 0, blocked: 0, unknown: 0 };
   const byVersion = new Map<string, Pick<ChecklistItem, 'id' | 'status'>[]>();
   const keys = new Set(requests.filter(row => row.status === 'queued').map(row => row.key));
@@ -65,14 +75,20 @@ export function reconciliation(cells: readonly Cell[], requests: readonly { key:
     if (status === 'green' || status === 'done') result.reached++;
     else if (status === 'yellow') result.progressing++;
     else if (status === 'red') result.blocked++;
-    else result.unknown++;
+    else {
+      const outcome = queueByKey.get(`orch:${cell.cardId}:${cell.id}`);
+      if (outcome === 'pending' || outcome === 'succeeded') result.progressing++;
+      else if (outcome === 'retryable') result.blocked++;
+      else result.unknown++;
+    }
   }
   return result;
 }
 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}`;
-  return state.runSummaries?.length ? `${line}\n${state.runSummaries.join('\n')}` : line;
+  const details = [...(state.rebalanceBlocked ?? []).map(row => `⛔ 이월 거부 ${row.id}: ${row.reason}`), ...(state.runSummaries ?? [])];
+  return details.length ? `${line}\n${details.join('\n')}` : line;
 }
 function readCardSnapshot(root: string): { cards: TaskCard[]; skippedCards: TickState['skippedCards'] } {
   const dir = taskCardsDir(root);
@@ -115,7 +131,7 @@ function stateFile(root: string, runId: string): string {
   if (!/^[a-zA-Z0-9._-]+$/.test(runId) || runId === '.' || runId === '..') throw new Error('Invalid orchestrator runId');
   return join(root, 'loop', 'orchestrator', `${runId}.json`);
 }
-function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState, 'cards' | 'cells'> | null {
+function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState, 'cards' | 'cells' | 'launched'> | null {
   const dir = join(root, 'loop', 'orchestrator');
   if (!existsSync(dir)) return null;
   const states = readdirSync(dir).filter(name => /^[a-zA-Z0-9._-]+\.json$/.test(name))
@@ -125,15 +141,17 @@ function restorePrevious(root: string, day: string, mode: Mode): Pick<TickState,
   states.sort((a, b) => a.name.localeCompare(b.name));
   const cards = new Map<string, TaskCard>();
   const cells = new Map<string, Cell>();
+  const launched = new Map<string, NonNullable<TickState['launched']>[number]>();
   for (const { state } of states) {
     for (const card of state.cards) cards.set(card.id, card);
     for (const cell of state.cells) cells.set(`${cell.cardId}:${cell.id}`, cell);
+    for (const turn of state.launched ?? []) if (turn.queueId) launched.set(turn.queueId, turn);
   }
-  return { cards: [...cards.values()], cells: [...cells.values()] };
+  return { cards: [...cards.values()], cells: [...cells.values()], launched: [...launched.values()] };
 }
 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 }, nodes: {}, missing: [] };
+    reconciled: { reached: 0, progressing: 0, blocked: 0, unknown: 0 }, steps: [], nodes: {}, missing: [] };
 }
 function graphRunId(): string | undefined {
   const context = process.env.ELANOUS_GRAPH_CONTEXT;
@@ -162,8 +180,9 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   const configured = deps.mode ?? getUserConfig().loops?.orchestrator?.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');
-  const predecessor: Partial<Record<Node, Node>> = { split: 'intake', place: 'split', delegate: 'place', reconcile: 'delegate', report: 'reconcile' };
+  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`);
   const loadAdapter = deps.loadAdapter ?? optionalAdapter;
@@ -173,6 +192,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   };
   const observe = (event: string, reason = '', count = 0, targetLoopId?: string): void => {
     const data = { loopId: 'orchestrator', runId, window, node, reason, count, ...(targetLoopId ? { targetLoopId } : {}) };
+    if (event !== 'tick') state.steps.push({ node, reason, count, ...(targetLoopId ? { targetLoopId } : {}) });
     try { (deps.observe ?? ((name, payload) => debug.log('loop.orchestrator', name, payload)))(event, data); }
     catch { /* observation must not change the run */ }
   };
@@ -197,6 +217,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           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 } : {}) });
         }
+        observe('exchange', `split:${card.id}`, cells.length);
         if (split && cells.length && mode === 'live') {
           const store = new CardStore(root);
           try {
@@ -208,15 +229,24 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
       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); }
-      else if (mode === 'shadow') observe('exchange', 'relplan1-shadow-not-invoked', state.cells.length);
-      if (mode === 'live' && available) for (const cell of state.cells) {
-        if (cell.origin !== 'flow1a') continue;
-        // TC review must-fix ②: map to the placer's required shape; a cell without an owner is unplaced, not a crash.
-        if (!cell.seat) { state.unplaced = (state.unplaced ?? 0) + 1; observe('exchange', 'unplaced-no-owner', 1); continue; }
-        const placed = await place({ id: cell.id, title: cell.title, owner: cell.seat, priority: cell.priority ?? 'P2', predecessors: cell.predecessors ?? [] });
-        if (validVersion(placed?.version)) {
-          cell.version = placed.version;
-          state.placed++;
+      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 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);
         }
       }
     } else if (node === 'delegate') {
@@ -228,9 +258,11 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         if (!targetLoopId) continue;
         const key = `orch:${cell.cardId}:${cell.id}`;
         if (keys.has(key)) continue;
-        // Shadow shows what it would hand over even before a release is chosen (placement is not invoked in shadow).
-        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', validVersion(cell.version) ? key : `${key} (unplaced)`, 1, targetLoopId); continue; }
-        if (!validVersion(cell.version)) continue;
+        if (!validVersion(cell.version)) {
+          if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; observe('would-delegate', `${key} (unplaced)`, 1, targetLoopId); }
+          continue;
+        }
+        if (mode === 'shadow') { keys.add(key); state.wouldDelegate++; 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
@@ -248,13 +280,53 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         state.delegated++;
         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')));
+      const seats = [...new Set(eligible.map(cell => cell.seat!))];
+      state.launched = [];
+      for (const seat of seats) {
+        if (mode === 'shadow') {
+          const cell = eligible.find(row => row.seat === seat)!;
+          const item: SeatItem = { source: 'request', id: `orch:${cell.cardId}:${cell.id}`, title: cell.title, text: cell.title };
+          const action = planAction(item, seat);
+          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 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;
+          const key = handled && targets.has(handled) ? handled : undefined;
+          if (handled && !key) observe('exchange', `seat-turn-other-request:${seat}`, 1, SEAT_LOOP_IDS[seat]);
+          state.launched.push({ seat, status: turn.status, ...(key ? { key } : {}),
+            ...('queueId' in turn && turn.queueId ? { queueId: turn.queueId } : {}),
+            ...('runId' in turn && turn.runId ? { runId: turn.runId } : {}) });
+          observe('exchange', `seat-turn:${seat}:${turn.status}`, 1, SEAT_LOOP_IDS[seat]);
+        }
+      }
     } else if (node === 'reconcile') {
-      if (window !== '08' && state.cells.length === 0) {
+      if (window !== '08') {
+        // 새 카드가 있어도 앞 틱의 의뢰·발사를 같이 대조한다 — 지금 틱 것이 같은 키를 이긴다.
         const previous = restorePrevious(root, state.day, mode);
-        if (previous) { state.cards = previous.cards; state.cells = previous.cells; }
+        if (previous) {
+          const merge = <T>(older: readonly T[], newer: readonly T[], key: (row: T) => string) =>
+            [...new Map([...older, ...newer].map(row => [key(row), row])).values()];
+          state.cards = merge(previous.cards, state.cards, card => card.id);
+          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 ?? ''}`);
+        }
       }
+      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);
+        observe('exchange', `queue-outcome:${turn.queueId}:${outcome}`, 1, SEAT_LOOP_IDS[turn.seat]);
+        return { queueId: turn.queueId!, ...(turn.key ? { key: turn.key } : {}), outcome };
+      });
       const requests = readRequests(root);
-      state.reconciled = reconciliation(state.cells, requests, mode === 'shadow' ? version => readChecklist(root, version) : (deps.checklist ?? (version => readChecklist(root, version))));
+      state.reconciled = reconciliation(state.cells, requests, mode === 'shadow' ? version => readChecklist(root, version) : (deps.checklist ?? (version => readChecklist(root, version))),
+        state.queueOutcomes.flatMap(row => row.key ? [{ key: row.key, outcome: row.outcome }] : []));
       const from = new Date(`${state.day}T00:00:00+09:00`).getTime();
       state.runSummaries = listSelfDevRuns(selfDevRunsDir(root))
         .filter(run => run.updatedAt >= from && run.updatedAt < from + 86_400_000)
@@ -268,7 +340,13 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           if (mode === 'shadow') observe('exchange', 'rebalance-shadow-not-invoked', versions.length);
           else {
             state.rebalanced = 0;
-            for (const version of versions) state.rebalanced += (await rebalance(version)).length;
+            state.rebalanceBlocked = [];
+            for (const version of versions) {
+              const result = await rebalance(version);
+              state.rebalanced += result.decisions.length;
+              state.rebalanceBlocked.push(...result.blocked);
+              for (const blocked of result.blocked) observe('exchange', `rebalance-blocked: ${blocked.id} ${blocked.reason}`, 1);
+            }
           }
         }
       }
@@ -288,9 +366,9 @@ if (import.meta.main) {
   const node = process.argv[2];
   const index = process.argv.indexOf('--window');
   const window = index < 0 ? undefined : process.argv[index + 1];
-  if (!['intake', 'split', 'place', 'delegate', 'reconcile', 'report'].includes(node ?? '') ||
+  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|reconcile|report> [--window 08|12|18]');
+    console.error('orchestrator: expected <intake|split|place|delegate|launch|reconcile|report> [--window 08|12|18]');
     process.exitCode = 2;
   } else {
     void (async () => {

package/src/loops/orchestrator/traffic.ts

@@ -2,16 +2,19 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync } fro
 import { dirname, isAbsolute, join, resolve, sep } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { defaultListHarnessProcesses, type HarnessProcessRecord } from '../../harness/harness-cli-command.js';
-import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../instance/resolve.js';
 import { devVersion, listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
+import { listSchedules } from '../../release-loop/release-schedule.js';
 import { withFileLockSync } from '../../storage/file-lock.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorLoopConfig, type OrchestratorSeat } from '../../user-config.js';
 import { finishAdvice, measureFinish, type FinishAdvice, type FinishMetrics, type MeasureFinishDeps } from './finish-rate.js';
+import { collectAuthorDepth, type AuthorDepthResult, type CollectAuthorDepthDeps } from './author-depth.js';
+import { calculateSeatBaseShares } from './seat-share.js';
 
 export const TRAFFIC_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 export type TrafficCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'>;
 export type TrafficProcess = Pick<HarnessProcessRecord, 'command' | 'elapsedSeconds' | 'cwd'> & { seat: OrchestratorSeat | null };
-export type TrafficSeatRow = { seat: OrchestratorSeat; running: number; cap: number; idleFor: number | null; idle: boolean; nextCell: TrafficCell | null };
+export type TrafficSeatRow = { seat: OrchestratorSeat; running: number; cap: number; baseShare: number | null; borrowed: number; lent: number; launchCap: number; idleFor: number | null; idle: boolean; nextCell: TrafficCell | null };
 export type TrafficResult = { seats: TrafficSeatRow[]; unassigned: number; now: Date; idleMinutes: number; finish?: { metrics: FinishMetrics; advice: FinishAdvice } };
 
 /** Same bounded walk as the CTX1 hook: a marker at the git root is checked before stopping. */
@@ -49,15 +52,23 @@ function realOrResolved(path: string): string {
 const IS_LAUNCH = /(?:^|\s)(?:\S*\/)?elanous\.mjs\s+(?:(?:--test|--config-dir\s+\S+)\s+)?harness\s+(?:ask|say)(?=\s|$)/;
 
 /** Process-to-seat resolution occurs at the boundary; this decision does no IO. */
-export function trafficTick({ processes, now, caps, lastLaunchAt, openCells, idleMinutes = 30 }: {
+export function trafficTick({ processes, now, caps, lastLaunchAt, idleSince, openCells, nextRound, totalSlots, idleMinutes = 30 }: {
   processes: readonly TrafficProcess[];
   now: Date;
   caps: Readonly<Record<OrchestratorSeat, number>>;
   lastLaunchAt?: Partial<Record<OrchestratorSeat, Date | null>>;
+  idleSince?: Partial<Record<OrchestratorSeat, Date | null>>;
   openCells: readonly TrafficCell[];
+  nextRound?: readonly TrafficCell[];
+  totalSlots?: number;
   idleMinutes?: number;
 }): TrafficResult {
   const launches = processes.filter(process => IS_LAUNCH.test(process.command));
+  const slotBudget = totalSlots ?? TRAFFIC_SEATS.reduce((sum, seat) => sum + caps[seat], 0);
+  // A missing next round is unknown, not an empty round with zero remaining work.
+  const baseShares = nextRound === undefined ? null : calculateSeatBaseShares({
+    totalSlots: slotBudget, currentRound: openCells, nextRound, seatCaps: caps,
+  });
   const seats = TRAFFIC_SEATS.map((seat): TrafficSeatRow => {
     const owned = launches.filter(process => process.seat === seat);
     const latest = owned.reduce<number | null>((current, process) => {
@@ -66,12 +77,57 @@ export function trafficTick({ processes, now, caps, lastLaunchAt, openCells, idl
       return current === null ? start : Math.max(current, start);
     }, null);
     const fallback = owned.length ? lastLaunchAt?.[seat]?.getTime() : undefined;
-    const last = latest ?? (fallback !== undefined && Number.isFinite(fallback) ? fallback : null);
+    const idleStart = idleSince?.[seat]?.getTime();
+    const last = idleStart !== undefined && Number.isFinite(idleStart) ? idleStart
+      : latest ?? (fallback !== undefined && Number.isFinite(fallback) ? fallback : null);
     const idleFor = last === null ? null : Math.max(0, Math.floor((now.getTime() - last) / 60_000));
-    const idle = owned.length < caps[seat] && last !== null && now.getTime() - last > idleMinutes * 60_000;
-    return { seat, running: owned.length, cap: caps[seat], idleFor, idle,
-      nextCell: idle ? openCells.find(cell => cell.status !== 'done' && cell.owner?.split('/')[0] === seat) ?? null : null };
+    const nextCell = openCells.find(cell => cell.status !== 'done' && cell.owner?.split('/')[0] === seat) ?? null;
+    const baseShare = baseShares?.[seat] ?? null;
+    return { seat, running: owned.length, cap: caps[seat], baseShare, borrowed: 0, lent: 0,
+      launchCap: baseShare === null ? caps[seat] : Math.max(owned.length, baseShare), idleFor,
+      idle: owned.length < caps[seat] && last !== null && now.getTime() - last > idleMinutes * 60_000, nextCell };
   });
+  if (baseShares !== null) {
+    // Account for outstanding loans before lending new capacity. A returning
+    // lender cannot launch into a slot still occupied by the borrower's run.
+    for (const borrower of seats) {
+      let excess = Math.max(0, borrower.running - borrower.baseShare!);
+      borrower.borrowed += excess;
+      for (const lender of seats) {
+        if (!excess) break;
+        if (lender === borrower) continue;
+        const amount = Math.min(excess, Math.max(0, lender.baseShare! - lender.running - lender.lent));
+        lender.lent += amount;
+        excess -= amount;
+      }
+    }
+    for (const lender of seats) {
+      if (lender.nextCell) continue;
+      let available = Math.max(0, lender.baseShare! - lender.running - lender.lent);
+      for (const borrower of seats) {
+        if (!available) break;
+        if (borrower === lender || !borrower.nextCell) continue;
+        const needed = Math.max(0, Math.min(borrower.cap, borrower.running + 1) - borrower.launchCap);
+        const amount = Math.min(available, needed);
+        lender.lent += amount;
+        borrower.borrowed += amount;
+        borrower.launchCap += amount;
+        available -= amount;
+      }
+    }
+    for (const lender of seats) lender.launchCap = Math.max(lender.running, lender.launchCap - lender.lent);
+  }
+  // Reserve one available global slot per possible request, including unknown-seat
+  // launches in the occupied count; returning a lent share does not end its old run.
+  let freeSlots = Math.max(0, slotBudget - launches.length);
+  for (const row of seats) {
+    if (row.nextCell && row.idle && row.running < row.launchCap) {
+      if (freeSlots > 0) freeSlots--;
+      else row.launchCap = row.running;
+    }
+    row.idle = row.idle && (row.nextCell === null || row.running < row.launchCap);
+    if (!row.idle) row.nextCell = null;
+  }
   return { seats, unassigned: launches.filter(process => process.seat === null).length, now, idleMinutes };
 }
 
@@ -92,7 +148,8 @@ export interface TrafficApplyDeps {
 export function applyTraffic(result: TrafficResult, deps: TrafficApplyDeps = {}): number {
   const log = deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data));
   const mode = deps.mode ?? 'shadow';
-  log('loop.orchestrator', 'tick', { mode, seats: result.seats.map(({ seat, running, cap, idleFor, idle }) => ({ seat, running, cap, idleFor, idle })), unassigned: result.unassigned });
+  log('loop.orchestrator', 'tick', { mode, seats: result.seats.map(({ seat, running, cap, baseShare, borrowed, lent, launchCap, idleFor, idle }) =>
+    ({ seat, running, cap, baseShare, borrowed, lent, launchCap, idleFor, idle })), unassigned: result.unassigned });
   if (result.finish) {
     const { finishSlots, launchSlots, state, reasons } = result.finish.advice;
     log('loop.orchestrator', 'would-rebalance', { finishSlots, launchSlots, state, reasons });
@@ -140,6 +197,49 @@ export function trafficLine(result: TrafficResult, mode: 'shadow' | 'live'): str
   return `${prefix} · finish rate=${rate(metrics.landingRate)} stale=${metrics.staleDrafts ?? '?'} conflict=${rate(metrics.conflictRatio)} → finish=${advice.finishSlots}/${advice.finishSlots + advice.launchSlots}`;
 }
 
+export type AuthorShadow = { cells: number; held: number; queuedForAuthor: number; status: 'complete' | 'incomplete'; receiptFailures: number };
+
+/** Traffic stays authoritative: shadow collection and its ledger cannot change its decision or exit status. */
+export function runTrafficTick({ processes, now, caps, openCells, nextRound, totalSlots, mode, finishDeps, applyDeps, authorDeps, collectAuthor = collectAuthorDepth, log = debug.log.bind(debug) }: {
+  processes: readonly TrafficProcess[];
+  now: Date;
+  caps: Readonly<Record<OrchestratorSeat, number>>;
+  openCells: readonly TrafficCell[];
+  nextRound?: readonly TrafficCell[];
+  totalSlots?: number;
+  mode: 'shadow' | 'live';
+  finishDeps?: MeasureFinishDeps;
+  applyDeps?: TrafficApplyDeps;
+  authorDeps?: Omit<CollectAuthorDepthDeps, 'caps' | 'running' | 'now'>;
+  collectAuthor?: (deps: CollectAuthorDepthDeps) => AuthorDepthResult;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}): { result: TrafficResult; queued: number; authorShadow: AuthorShadow | null } {
+  const metrics = measureFinish(finishDeps, now);
+  const advice = finishAdvice(metrics, TRAFFIC_SEATS.reduce((sum, seat) => sum + caps[seat], 0));
+  const result = { ...trafficTick({ processes, now, caps, openCells, nextRound, totalSlots: totalSlots ?? advice.launchSlots }),
+    finish: { metrics, advice } };
+  const queued = applyTraffic(result, { ...applyDeps, mode });
+  let authorShadow: AuthorShadow | null = null;
+  let shadowFailure: Record<string, unknown> | null = null;
+  try {
+    const depth = collectAuthor({ ...authorDeps, now, caps: () => caps,
+      running: () => Object.fromEntries(result.seats.map(row => [row.seat, row.running])) });
+    const receiptFailures = depth.receiptFailures ?? depth.unreadable.filter(item => item.source === 'author-ledger').length;
+    const incomplete = depth.unreadable.length > 0 || !depth.receiptCounts;
+    authorShadow = { cells: depth.seats.reduce((total, row) => total + row.wouldAuthor.length, 0),
+      held: depth.receiptCounts?.held ?? 0, queuedForAuthor: depth.receiptCounts?.queuedForAuthor ?? 0,
+      status: incomplete ? 'incomplete' : 'complete', receiptFailures };
+    if (incomplete) shadowFailure = { unreadable: depth.unreadable, ...(depth.receiptCounts ? {} : { reason: 'receipt counts unavailable' }) };
+  } catch (error) {
+    shadowFailure = { reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (shadowFailure) {
+    try { log('loops.author-depth', 'shadow-failed', shadowFailure); }
+    catch { /* Shadow logging cannot change traffic's outcome. */ }
+  }
+  return { result, queued, authorShadow };
+}
+
 if (import.meta.main) {
   try {
     const args = process.argv.slice(2);
@@ -154,9 +254,15 @@ if (import.meta.main) {
     if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
     const now = new Date();
     const processes = observation.records.map(process => ({ ...process, seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) }));
-    const result = withFinishAdvice(trafficTick({ processes, now, caps: cfg.seatCaps, openCells: listChecklist(version).items }));
-    const queued = applyTraffic(result, { mode: cfg.trafficMode });
-    if (args.includes('--json')) console.log(JSON.stringify({ ...result, mode: cfg.trafficMode, queued, version }));
+    const upcoming = listSchedules(releaseLedgerRoot()).filter(row => Date.parse(row.cutAt) > now.getTime())
+      .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
+    const currentIndex = upcoming.findIndex(row => row.version === version);
+    const nextVersion = currentIndex < 0 ? upcoming[0]?.version : upcoming[currentIndex + 1]?.version;
+    const { result, queued, authorShadow } = runTrafficTick({
+      processes, now, caps: cfg.seatCaps, openCells: listChecklist(version).items,
+      ...(nextVersion ? { nextRound: listChecklist(nextVersion).items } : {}), mode: cfg.trafficMode,
+    });
+    if (args.includes('--json')) console.log(JSON.stringify({ ...result, mode: cfg.trafficMode, queued, version, authorShadow }));
     else console.log(trafficLine(result, cfg.trafficMode));
   } catch (error) {
     console.error(`traffic: ${error instanceof Error ? error.message : String(error)}`);