elanous 0.2.14 → 0.2.15

package/src/loops/orchestrator/author-depth.ts

@@ -1,5 +1,7 @@
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { debug } from '../../debug/log.js';
 import { defaultListHarnessProcesses } from '../../harness/harness-cli-command.js';
 import { listHarnessQueue, type QueueItem } from '../../harness/harness-queue.js';
@@ -7,15 +9,19 @@ import { releaseLedgerRoot } from '../../instance/resolve.js';
 import { listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
 import { listSchedules } from '../../release-loop/release-schedule.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../../user-config.js';
+import { checkAuthorInput } from './author-input-check.js';
+import { AuthorLedger } from './author-ledger.js';
 import { collectWork, findOverlaps, type WorkItem } from './overlap.js';
 import { seatOfTree, trafficTick, TRAFFIC_SEATS } from './traffic.js';
 
-export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'> & { version: string };
+export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status' | 'evidence'> & { version: string };
 export type AuthorQueueRow = Pick<QueueItem, 'seat' | 'status'> & Partial<Pick<QueueItem, 'input' | 'kind'>>;
 export type AuthorDepthResult = {
   seats: Array<{ seat: OrchestratorSeat; cap: number | null; running: number | null; queued: number | null;
     target: number | null; short: number | null; wouldAuthor: Array<{ cellId: string; version: string; title: string }> }>;
   unreadable: Array<{ source: string; reason: string }>;
+  receiptCounts?: { held: number; queuedForAuthor: number };
+  receiptFailures?: number;
 };
 export type AuthorDepthInput = {
   seats: readonly OrchestratorSeat[];
@@ -84,6 +90,7 @@ export function authorDepth({ seats, caps, running, queued, cells, overlaps, now
 }
 
 export interface CollectAuthorDepthDeps {
+  root?: string;
   seats?: readonly OrchestratorSeat[];
   now?: Date;
   caps?: () => Partial<Record<OrchestratorSeat, number>>;
@@ -92,12 +99,13 @@ export interface CollectAuthorDepthDeps {
   cells?: (version: string) => readonly AuthorCell[];
   overlaps?: () => readonly WorkItem[];
   versions?: () => readonly [string, string];
+  ledger?: Pick<AuthorLedger, 'request'>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
 }
 
-function defaultVersions(now: Date): readonly [string, string] {
-  if (!existsSync(join(releaseLedgerRoot(), 'release', 'features.sqlite'))) throw new Error('release schedule ledger unavailable');
-  const upcoming = listSchedules().filter(row => row.cutAt && Date.parse(row.cutAt) > now.getTime())
+function defaultVersions(now: Date, root = releaseLedgerRoot()): readonly [string, string] {
+  if (!existsSync(join(root, 'release', 'features.sqlite'))) throw new Error('release schedule ledger unavailable');
+  const upcoming = listSchedules(root).filter(row => row.cutAt && Date.parse(row.cutAt) > now.getTime())
     .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
   if (upcoming.length < 2) throw new Error('current and next release schedules unavailable');
   return [upcoming[0]!.version, upcoming[1]!.version];
@@ -123,12 +131,13 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
     if (measured.unassigned) throw new Error(`${measured.unassigned} unassigned harness launch process(es)`);
     return Object.fromEntries(measured.seats.map(row => [row.seat, row.running]));
   });
-  const queued = observe('queue', deps.queued ?? (() => listHarnessQueue()));
-  const versions = observe('versions', deps.versions ?? (() => defaultVersions(now)));
+  const queued = observe('queue', deps.queued ?? (() => listHarnessQueue({ root: deps.root })));
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const versions = observe('versions', deps.versions ?? (() => defaultVersions(now, releaseRoot)));
   const cells = versions === null ? null : observe('checklist', () => versions.flatMap(version => {
-    if (!deps.cells && !existsSync(join(releaseLedgerRoot(), 'release', 'features.sqlite')))
+    if (!deps.cells && !existsSync(join(releaseRoot, 'release', 'features.sqlite')))
       throw new Error('checklist ledger unavailable');
-    return deps.cells?.(version) ?? listChecklist(version).items.map(item => ({ ...item, version }));
+    return deps.cells?.(version) ?? listChecklist(version, deps.root).items.map(item => ({ ...item, version }));
   }));
   const overlaps = observe('overlap', deps.overlaps ?? (() => {
     const observed = collectWork();
@@ -141,9 +150,56 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
   for (const row of result.seats) log('loop.orchestrator', 'would-author', {
     seat: row.seat, target: row.target, have: row.queued, short: row.short, cells: row.wouldAuthor,
   });
+  const ledger = deps.ledger ?? new AuthorLedger(deps.root === undefined ? {} : { path: join(deps.root, 'orchestrator', 'author-ledger.sqlite') });
+  const receiptCounts = { held: 0, queuedForAuthor: 0 };
+  let receiptFailures = 0;
+  for (const row of result.seats) for (const candidate of row.wouldAuthor) {
+    const cell = cells?.find(item => item.id === candidate.cellId && item.version === candidate.version);
+    try {
+      if (!cell) throw new Error('selected cell unavailable');
+      const text = cell.evidence ?? '';
+      const check = checkAuthorInput({ title: cell.title, text, cellId: cell.id, version: cell.version });
+      const receipt = ledger.request({ seat: row.seat, cellId: cell.id, version: cell.version, title: cell.title,
+        text, check: { verdict: check.verdict, signals: check.signals, ratio: check.implementationRatio } });
+      if (receipt.status === 'held') receiptCounts.held++;
+      if (receipt.status === 'queued-for-author') receiptCounts.queuedForAuthor++;
+    } catch (error) {
+      receiptFailures++;
+      result.unreadable.push({ source: 'author-ledger', reason: `${candidate.version} ${candidate.cellId}: ${error instanceof Error ? error.message : String(error)}` });
+    }
+  }
+  result.receiptCounts = receiptCounts;
+  result.receiptFailures = receiptFailures;
   return result;
 }
 
+const SHADOW_INTERVAL_MS = 30 * 60_000;
+
+/** The queue tick serializes callers; stamp before collection so even a failing shadow cannot run every two minutes. */
+export function runAuthorDepthShadow(root = effectiveInstanceRoot(), now = new Date(), collect = collectAuthorDepth): void {
+  const path = join(root, 'orchestrator', 'author-depth-shadow-at');
+  const time = now.getTime();
+  if (!Number.isFinite(time)) throw new Error('invalid author-depth shadow clock');
+  if (existsSync(path)) {
+    const last = Date.parse(readFileSync(path, 'utf8').trim());
+    if (!Number.isFinite(last)) throw new Error('invalid author-depth shadow marker');
+    if (time - last < SHADOW_INTERVAL_MS) return;
+  }
+  mkdirSync(join(root, 'orchestrator'), { recursive: true });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temporary, now.toISOString(), { flag: 'wx', mode: 0o600 });
+    renameSync(temporary, path);
+  } catch (error) {
+    try { unlinkSync(temporary); } catch { /* No temporary file to remove. */ }
+    throw error;
+  }
+  const result = collect({ root, now });
+  if (result.unreadable.length || result.receiptFailures || !result.receiptCounts) {
+    throw new Error(`author-depth shadow incomplete: ${JSON.stringify({ unreadable: result.unreadable, receiptFailures: result.receiptFailures })}`);
+  }
+}
+
 export function authorDepthLines(result: AuthorDepthResult): string[] {
   return result.seats.map(row => `${row.seat} ${row.running ?? '?'}/${row.cap ?? '?'} · 대기 ${row.queued ?? '?'} · 목표 ${row.target ?? '?'} · 모자람 ${row.short ?? '?'} → ${row.wouldAuthor.map(cell => cell.cellId).join(', ') || '없음'}`);
 }

package/src/loops/orchestrator/author-input-check.ts

@@ -8,7 +8,7 @@ export interface AuthorInput {
 }
 
 export interface AuthorInputSignal {
-  kind: 'path' | 'symbol' | 'command' | 'marker';
+  kind: 'path' | 'symbol' | 'command' | 'marker' | 'missing';
   match: string;
   field: 'title' | 'text';
   reason: string;
@@ -40,15 +40,19 @@ function sentences(value: string): string[] {
 }
 
 export function checkAuthorInput({ title, text, cellId, version }: AuthorInput): AuthorInputCheck {
-  const valid = [title, text, cellId, version].every(value => typeof value === 'string' && !!value.trim())
+  const validIdentity = [title, cellId, version].every(value => typeof value === 'string' && !!value.trim())
     && /^\d+\.\d+\.\d+$/.test(version);
+  const missingText = typeof text !== 'string' || !text.trim();
+  const valid = validIdentity && !missingText;
   const signals: AuthorInputSignal[] = [];
+  if (validIdentity && missingText) signals.push({ kind: 'missing', match: '', field: 'text', reason: 'missing cell text' });
   let checked = 0;
   let candidates = 0;
   let directed = false;
 
-  if (valid) {
+  if (validIdentity) {
     for (const field of ['title', 'text'] as const) {
+      if (field === 'text' && missingText) continue;
       for (const sentence of sentences(field === 'title' ? title : text)) {
         checked++;
         let found = false;
@@ -70,6 +74,7 @@ export function checkAuthorInput({ title, text, cellId, version }: AuthorInput):
   const verdict: AuthorInputCheck['verdict'] = !valid ? 'uncheckable'
     : signals.length === 0 ? 'approved' : directed ? 'resubmit' : 'confirm';
   const implementationRatio = valid ? candidates / checked : null;
+  if (!valid) { checked = 0; candidates = 0; }
   debug.log('author.par', 'input-checked', {
     cellId, version, verdict, signals: signals.length, ratio: implementationRatio,
   });

package/src/loops/orchestrator/author-ledger.ts

@@ -120,9 +120,11 @@ export class AuthorLedger {
   }
 
   request(input: AuthorRequest): AuthorRow & { duplicate: boolean } {
-    for (const key of ['seat', 'cellId', 'version', 'title', 'text'] as const) {
+    for (const key of ['seat', 'cellId', 'version', 'title'] as const) {
       if (typeof input[key] !== 'string' || !input[key].trim()) throw new Error(`${key} is required`);
     }
+    if (typeof input.text !== 'string' || (!input.text.trim() && input.check?.verdict !== 'uncheckable'))
+      throw new Error('text is required unless uncheckable');
     if (!['approved', 'resubmit', 'confirm', 'uncheckable'].includes(input.check?.verdict)
       || !Array.isArray(input.check.signals)
       || (input.check.ratio !== null && (typeof input.check.ratio !== 'number' || !Number.isFinite(input.check.ratio))))

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

@@ -16,7 +16,7 @@ const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cm
 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[];
   nodes: Partial<Record<Node, 'ok' | 'skipped'>>;
@@ -27,7 +27,7 @@ export type SplitAdapter = (card: TaskCard, opts?: { shadow?: boolean }) => Prom
 /** 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 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;
@@ -72,7 +72,8 @@ export function reconciliation(cells: readonly Cell[], requests: readonly { key:
 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);
@@ -268,7 +269,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);
+            }
           }
         }
       }

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)}`);