elanous 0.2.21 → 0.2.23

package/src/loops/budget.ts

@@ -1,4 +1,61 @@
 import { ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../user-config.js';
+import type { ChecklistItem } from '../release-loop/checklist.js';
+import type { TrafficCell, TrafficProcess, TrafficResult, TrafficSeatRow } from './orchestrator/traffic.js';
+
+const RESOURCE_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 ||
+    RESOURCE_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 (RESOURCE_SEATS.some(id => id === seat)) weights[seat as OrchestratorSeat] += weight;
+    }
+  }
+
+  let available = Math.min(totalSlots, RESOURCE_SEATS.reduce((sum, seat) => sum + seatCaps[seat], 0));
+  let eligible = RESOURCE_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;
+}
 
 export interface SpawnBudgetInput {
   seat: OrchestratorSeat;
@@ -97,3 +154,96 @@ export function seatCapExclusion(subject: SeatCapSubject, now: number,
   if (idle !== null && now - subject.progressAt! >= staleRunMinutes * 60_000) return { reason: 'stale', idleMin: idle };
   return null;
 }
+
+/** Only harness ask/say launches occupy ORCH traffic seats. */
+export const isTrafficLaunch = (command: string): boolean =>
+  /(?:^|\s)(?:\S*\/)?elanous\.mjs\s+(?:(?:--test|--config-dir\s+\S+)\s+)?harness\s+(?:ask|say)(?=\s|$)/.test(command);
+
+/** ORCH traffic supplies a physical cap, which can exceed the default spawn release gate. */
+function decideTrafficLaunch(row: TrafficSeatRow): boolean {
+  return decideSpawn({ seat: row.seat, running: row.running, caps: { [row.seat]: row.cap },
+    gate: { [row.seat]: row.cap }, injectedCap: row.launchCap }).allow;
+}
+
+/** Process-to-seat resolution occurs at the boundary; this decision does no IO. */
+export function budgetTrafficTick({ processes, now, caps, lastLaunchAt, idleSince, openCells, nextRound, totalSlots, idleMinutes = 30, retainQueuedCells = false }: {
+  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;
+  /** Observation only: expose queued work even when no launch has been observed yet. */
+  retainQueuedCells?: boolean;
+}): TrafficResult {
+  const launches = processes.filter(process => isTrafficLaunch(process.command));
+  const slotBudget = totalSlots ?? RESOURCE_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 = RESOURCE_SEATS.map((seat): TrafficSeatRow => {
+    const owned = launches.filter(process => process.seat === seat);
+    const latest = owned.reduce<number | null>((current, process) => {
+      if (!Number.isFinite(process.elapsedSeconds) || process.elapsedSeconds < 0) return current;
+      const start = now.getTime() - process.elapsedSeconds * 1000;
+      return current === null ? start : Math.max(current, start);
+    }, null);
+    const fallback = owned.length ? lastLaunchAt?.[seat]?.getTime() : undefined;
+    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 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: decideSpawn({ seat, running: owned.length, caps: { [seat]: caps[seat] },
+        gate: { [seat]: caps[seat] } }).allow && 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 && decideTrafficLaunch(row)) {
+      if (freeSlots > 0) freeSlots--;
+      else row.launchCap = row.running;
+    }
+    row.idle = row.idle && (row.nextCell === null || decideTrafficLaunch(row));
+    if (!row.idle && !retainQueuedCells) row.nextCell = null;
+  }
+  return { seats, unassigned: launches.filter(process => process.seat === null).length, now, idleMinutes };
+}

package/src/loops/neighbor-runtime.ts

@@ -0,0 +1,88 @@
+import { debug } from '../debug/log.js';
+import { openMsgStore } from '../msg/msg-store.js';
+import { judgeNeighbor, type Neighbor } from './neighbors.js';
+import { join } from 'node:path';
+
+export type LoopHealth = 'healthy' | 'degraded';
+export type NeighborIncident = { observer: string; neighbor: string; state: 'absent'; reason: string; action: Neighbor['onAbsent']['action']; to: string; at: string; lastSeenAt: string | null };
+
+export const SEAT_NEIGHBORS: Record<string, Neighbor[]> = Object.fromEntries(['OP', 'TC', 'MK', 'UX'].map(seat => [seat,
+  [
+    ...['OP', 'TC', 'MK', 'UX'].filter(peer => peer !== seat).map(peer => ({
+      id: peer === 'MK' ? 'cmo-seat' : `${peer.toLowerCase()}-seat`, exchange: ['status'] as Neighbor['exchange'],
+      heartbeat: { everyMinutes: 15, missedTicks: 2 },
+      onAbsent: peer === 'OP' ? { action: 'delegate' as const, delegateTo: 'steward' }
+        : peer === 'TC' ? { action: 'escalate' as const, delegateTo: 'orchestrator' }
+          : { action: 'defer' as const, delegateTo: 'orchestrator' },
+    })),
+    { id: 'orchestrator', exchange: ['status'], heartbeat: { everyMinutes: 120, missedTicks: 2 },
+      onAbsent: { action: 'escalate', delegateTo: 'human' } },
+  ],
+]));
+
+type Signal = { at: string; health: LoopHealth; ends_at: string | null };
+
+function withStore<T>(root: string, fn: (store: ReturnType<typeof openMsgStore>) => T): T {
+  const store = openMsgStore(join(root, 'msg', 'messages.db'));
+  try {
+    store.db.exec(`CREATE TABLE IF NOT EXISTS loop_signals (loop_id TEXT PRIMARY KEY, at TEXT NOT NULL, health TEXT NOT NULL, ends_at TEXT);
+      CREATE TABLE IF NOT EXISTS loop_watches (observer TEXT NOT NULL, neighbor TEXT NOT NULL, first_at TEXT NOT NULL, PRIMARY KEY(observer, neighbor));
+      CREATE TABLE IF NOT EXISTS loop_incidents (observer TEXT NOT NULL, neighbor TEXT NOT NULL, signal_at TEXT NOT NULL,
+        reason TEXT NOT NULL, action TEXT NOT NULL, recipient TEXT NOT NULL, at TEXT NOT NULL,
+        PRIMARY KEY(observer, neighbor, signal_at, reason));`);
+    return fn(store);
+  } finally { store.close(); }
+}
+
+/** Durable signal, independent of chat sessions or the seat work-item ledger. */
+export function emitLoopHeartbeat(root: string, loopId: string, health: LoopHealth, now: Date, endsAt?: string): void {
+  if (!/^[a-z][a-z0-9-]*$/.test(loopId) || !Number.isFinite(now.getTime())) throw new Error('invalid loop heartbeat');
+  if (endsAt && !Number.isFinite(Date.parse(endsAt))) throw new Error('invalid heartbeat end');
+  withStore(root, store => {
+    store.db.query(`INSERT INTO loop_signals(loop_id, at, health, ends_at) VALUES(?, ?, ?, ?)
+      ON CONFLICT(loop_id) DO UPDATE SET at=excluded.at, health=excluded.health, ends_at=excluded.ends_at
+      WHERE loop_signals.at <= excluded.at`).run(loopId, now.toISOString(), health, endsAt ?? null);
+  });
+  debug.log(`loop.${loopId}`, 'heartbeat', { loopId, at: now.toISOString(), health, endsAt: endsAt ?? null });
+}
+
+/** First watch starts the missing-signal clock. Action receipt and message commit atomically. */
+export function checkLoopNeighbors(root: string, observer: string, neighbors: readonly Neighbor[], now: Date): NeighborIncident[] {
+  return withStore(root, store => {
+    const incidents: NeighborIncident[] = [];
+    for (const neighbor of neighbors) {
+      if (neighbor.id === observer) continue;
+      try {
+        store.db.exec('BEGIN IMMEDIATE');
+        store.db.query('INSERT OR IGNORE INTO loop_watches(observer, neighbor, first_at) VALUES(?, ?, ?)').run(observer, neighbor.id, now.toISOString());
+        const signal = store.db.query('SELECT at, health, ends_at FROM loop_signals WHERE loop_id=?').get(neighbor.id) as Signal | null;
+        const watch = store.db.query('SELECT first_at FROM loop_watches WHERE observer=? AND neighbor=?').get(observer, neighbor.id) as { first_at: string };
+        const judgment = judgeNeighbor({ neighbor, lastSeenAt: signal?.at ?? watch.first_at, now });
+        const expired = !!signal?.ends_at && Date.parse(signal.ends_at) <= now.getTime();
+        // A declared lease (ends_at in the future) outranks the heartbeat interval: a scheduled loop idle between
+        // windows is not absent until its own declared end passes.
+        const leased = !!signal?.ends_at && !expired;
+        const absent = expired || signal?.health === 'degraded' || (!leased && judgment.state === 'absent');
+        if (!absent) { store.db.exec('COMMIT'); continue; }
+        const reason = expired ? 'end-expired' : signal?.health === 'degraded' ? 'degraded' : judgment.reason;
+        const signalAt = signal?.at ?? watch.first_at;
+        const { action, delegateTo: to } = neighbor.onAbsent;
+        const inserted = store.db.query(`INSERT OR IGNORE INTO loop_incidents(observer, neighbor, signal_at, reason, action, recipient, at)
+          VALUES(?, ?, ?, ?, ?, ?, ?)`).run(observer, neighbor.id, signalAt, reason, action, to, now.toISOString());
+        if (inserted.changes) {
+          const incident: NeighborIncident = { observer, neighbor: neighbor.id, state: 'absent', reason, action, to,
+            at: now.toISOString(), lastSeenAt: signal?.at ?? null };
+          store.append({ from: observer, to, kind: `neighbor-${action}`,
+            body: `[${observer} → ${to}] ${neighbor.id} ${reason}: ${action}` });
+          incidents.push(incident);
+        }
+        store.db.exec('COMMIT');
+      } catch (error) {
+        try { store.db.exec('ROLLBACK'); } catch { /* no open transaction */ }
+        debug.log('loop.neighbors', 'check-failed', { observer, neighbor: neighbor.id, error: String(error) }, { level: 'warn' });
+      }
+    }
+    for (const incident of incidents) debug.log('loop.neighbors', 'absent', incident, { level: 'warn' });
+    return incidents;
+  });
+}

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

@@ -12,7 +12,7 @@ import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../
 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';
+import { isTrafficLaunch, seatOfTree, trafficTick, TRAFFIC_SEATS } from './traffic.js';
 
 export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status' | 'evidence'> & { version: string };
 export type AuthorQueueRow = Pick<QueueItem, 'seat' | 'status'> & Partial<Pick<QueueItem, 'input' | 'kind'>>;
@@ -101,8 +101,12 @@ export interface CollectAuthorDepthDeps {
   versions?: () => readonly [string, string];
   ledger?: Pick<AuthorLedger, 'request'>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  listProcesses?: typeof defaultListHarnessProcesses;
 }
 
+/** Budget for the shadow's process read (it runs inside the queue lock, whose waiters give up after 30 s). */
+export const AUTHOR_DEPTH_PROCESS_DEADLINE_MS = 10_000;
+
 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())
@@ -122,15 +126,6 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
   };
   const cfg = deps.caps && deps.running ? null : observe('config', () => getUserConfig().loops?.orchestrator ?? ORCHESTRATOR_DEFAULTS);
   const caps = deps.caps ? observe('caps', deps.caps) : cfg === null ? null : observe('caps', () => cfg.seatCaps);
-  const running = deps.running ? observe('running', deps.running) : cfg === null ? null : observe('running', () => {
-    const observation = defaultListHarnessProcesses();
-    if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
-    const processes = observation.records.map(process => ({ ...process,
-      seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) }));
-    const measured = trafficTick({ processes, now, caps: cfg.seatCaps, openCells: [] });
-    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({ root: deps.root })));
   const releaseRoot = deps.root ?? releaseLedgerRoot();
   const versions = observe('versions', deps.versions ?? (() => defaultVersions(now, releaseRoot)));
@@ -139,7 +134,30 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
       throw new Error('checklist ledger unavailable');
     return deps.cells?.(version) ?? listChecklist(version, deps.root).items.map(item => ({ ...item, version }));
   }));
-  const overlaps = observe('overlap', deps.overlaps ?? (() => {
+  // Without release cells there is no candidate to compare, and the host reads below are the expensive ones (every launch's
+  // cwd · open PRs over the network) — a fresh --test universe has no release ledger, so it skips them (10-08 tick hang).
+  const noCells = cells === null && !deps.cells;
+  if (noCells && !deps.running && cfg !== null) unreadable.push({ source: 'running', reason: 'skipped: no release cells to compare' });
+  const running = deps.running ? observe('running', deps.running) : cfg === null || noCells ? null : observe('running', () => {
+    // Only launch processes are counted, so only they need a cwd; the whole read is bounded because the queue tick runs
+    // this shadow inside its lock (10-08: ~490 host processes × lsof kept a --test tick for minutes).
+    const started = Date.now();
+    const observation = (deps.listProcesses ?? defaultListHarnessProcesses)({ include: record => isTrafficLaunch(record.command),
+      cwdOnly: true, deadlineMs: AUTHOR_DEPTH_PROCESS_DEADLINE_MS });
+    if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
+    const late = observation.records.filter(process => process.cwdFailureReason?.startsWith('observation deadline')).length;
+    (deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data)))(
+      'loop.orchestrator', 'author-depth-processes', { launches: observation.records.length, late, ms: Date.now() - started,
+        deadlineMs: AUTHOR_DEPTH_PROCESS_DEADLINE_MS });
+    if (late) throw new Error(`process observation deadline ${AUTHOR_DEPTH_PROCESS_DEADLINE_MS}ms: ${late} launch cwd(s) unread`);
+    const processes = observation.records.map(process => ({ ...process,
+      seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) }));
+    const measured = trafficTick({ processes, now, caps: cfg.seatCaps, openCells: [] });
+    if (measured.unassigned) throw new Error(`${measured.unassigned} unassigned harness launch process(es)`);
+    return Object.fromEntries(measured.seats.map(row => [row.seat, row.running]));
+  });
+  if (noCells && !deps.overlaps) unreadable.push({ source: 'overlap', reason: 'skipped: no release cells to compare' });
+  const overlaps = noCells && !deps.overlaps ? null : observe('overlap', deps.overlaps ?? (() => {
     const observed = collectWork();
     if (observed.unreadableTrees || observed.unreadableGoals || observed.work.some(item => item.unreadable))
       throw new Error(`incomplete work observation: trees=${observed.unreadableTrees} goals=${observed.unreadableGoals}`);

package/src/loops/orchestrator/overlap.ts

@@ -19,6 +19,9 @@ export interface CollectWorkDeps {
   config?: Pick<OrchestratorLoopConfig, 'seatTrees'>;
 }
 
+/** Budget for collectWork's per-process cwd reads. */
+export const COLLECT_WORK_PROCESS_DEADLINE_MS = 10_000;
+
 const repoRoot = resolve(import.meta.dir, '../../..');
 const defaultRunGh = (args: string[]): string => execFileSync('bun', ['bin/elanous.mjs', '--test', 'gh', ...args], {
   cwd: repoRoot, encoding: 'utf8', timeout: 60_000, maxBuffer: 20 * 1024 * 1024,
@@ -63,7 +66,10 @@ function goalFiles(text: string): string[] {
 export function collectWork(deps: CollectWorkDeps = {}): CollectWorkResult {
   const prs = JSON.parse((deps.runGh ?? defaultRunGh)(['pr', 'list', '--state', 'open', '--limit', '1000', '--json', 'number,title,body,headRefName,files,isDraft,labels'])) as OpenPr[];
   if (!Array.isArray(prs)) throw new Error('PR observation is not a list');
-  const observation = (deps.listProcesses ?? defaultListHarnessProcesses)();
+  // Only goal-carrying launches become work, so only they need a cwd; bounded so a host with hundreds of harness processes
+  // cannot hold the queue lock for minutes (10-08). Records past the budget stay cwd-unknown → their goal reads unreadable.
+  const observation = deps.listProcesses ? deps.listProcesses()
+    : defaultListHarnessProcesses({ include: record => goalPath(record.command) !== null, cwdOnly: true, deadlineMs: COLLECT_WORK_PROCESS_DEADLINE_MS });
   if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
   const cfg = deps.config ?? getUserConfig().loops?.orchestrator ?? ORCHESTRATOR_DEFAULTS;
   const excluded = { stalled: 0, superseded: 0, draft: 0 };

package/src/loops/orchestrator/resync-shadow.ts

@@ -171,7 +171,7 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
       entry.resolvedFiles = outcome.resolvedFiles ?? [];
       if (outcome.sizeCollapse?.length || outcome.providerFailure?.length || outcome.testDeclarationLoss?.length) {
         entry.verdict = 'guard-tripped';
-      } else if (outcome.status === 'merged' || outcome.status === 'llm-resolved') {
+      } else if (outcome.status === 'merged' || outcome.status === 'llm-resolved' || outcome.status === 'deterministic-resolved') {
         if (entry.testFiles.length === 0) entry.verdict = 'merge-ok-no-tests';
         else {
           const test = (deps.runTests ?? defaultRunTests)(tmp, entry.testFiles);

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

@@ -1,56 +1,13 @@
 import type { ChecklistItem } from '../../release-loop/checklist.js';
 import type { OrchestratorSeat } from '../../user-config.js';
+import { calculateSeatBaseShares as budgetSeatBaseShares } from '../budget.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 }: {
+/** Existing orchestrator callers keep their signature; the resource loop owns the decision. */
+export function calculateSeatBaseShares(input: {
   totalSlots: number;
-  currentRound: readonly WorkCell[];
-  nextRound: readonly WorkCell[];
+  currentRound: readonly Pick<ChecklistItem, 'owner' | 'status'>[];
+  nextRound: readonly Pick<ChecklistItem, 'owner' | 'status'>[];
   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;
+  return budgetSeatBaseShares(input);
 }

package/src/loops/orchestrator/tick.ts

@@ -8,6 +8,7 @@ import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { getUserConfig, type OrchestratorLoopConfig } from '../../user-config.js';
 import { rubricPriority } from '../../release-loop/rubric.js';
 import { debug } from '../../debug/log.js';
+import { emitLoopHeartbeat } from '../neighbor-runtime.js';
 import { listSelfDevRuns, runSummaryLine, selfDevRunsDir } from '../../self-dev/run-store.js';
 import { planAction, runSeatLoopOnce, type SeatDeps, type SeatItem } from '../../seat-loop/seat-loop.js';
 import { addHarnessQueue, harnessQueueOutcome, setQueuedPoolHint } from '../../harness/harness-queue.js';
@@ -48,7 +49,8 @@ export type PlacementInput = { id: string; title: string; owner: string; priorit
 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;
+  root?: string; now?: Date | (() => Date); mode?: Mode; runId?: string; window?: Window;
+  heartbeatIntervalMs?: number;
   cards?: () => TaskCard[]; split?: SplitAdapter; placeCell?: PlaceAdapter;
   degradation?: () => { llm: boolean; board: boolean };
   gridHosts?: readonly GridHost[];
@@ -101,6 +103,19 @@ export function kstWindow(now: Date): Window {
   const hour = Number(new Intl.DateTimeFormat('en-US', { timeZone: 'Asia/Seoul', hour: '2-digit', hourCycle: 'h23' }).format(now));
   return hour < 12 ? '08' : hour < 18 ? '12' : '18';
 }
+/** KST schedule of graphs/orchestrator/orchestrator.yaml (`0 8,12,18 * * *`). */
+const ORCHESTRATOR_HOURS_KST = [8, 12, 18] as const;
+/** Grace past the next scheduled window before neighbors may call the orchestrator absent. */
+export const ORCHESTRATOR_LEASE_GRACE_MS = 60 * 60_000;
+/** The next scheduled window strictly after `now` — the orchestrator is idle, not absent, until then. */
+export function nextOrchestratorWindowAt(now: Date): Date {
+  const kst = new Date(now.getTime() + 9 * 3_600_000);
+  for (let day = 0; day < 2; day++) for (const hour of ORCHESTRATOR_HOURS_KST) {
+    const at = Date.UTC(kst.getUTCFullYear(), kst.getUTCMonth(), kst.getUTCDate() + day, hour) - 9 * 3_600_000;
+    if (at > now.getTime()) return new Date(at);
+  }
+  throw new Error('unreachable: no orchestrator window within two days');
+}
 function kstDay(now: Date): string {
   return new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(now);
 }
@@ -371,7 +386,8 @@ async function optionalAdapter<T>(path: string, name: string): Promise<T | undef
 
 /** A graph command invokes one node; only the per-run file carries data across processes. */
 export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Promise<TickState> {
-  const now = deps.now ?? new Date();
+  const currentTime = () => typeof deps.now === 'function' ? deps.now() : deps.now ?? new Date();
+  const now = currentTime();
   const window = deps.window ?? kstWindow(now);
   const root = deps.root ?? effectiveInstanceRoot();
   const runId = deps.runId ?? graphRunId() ?? `${kstDay(now)}-${window}`;
@@ -379,6 +395,16 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   const orchestratorConfig = getUserConfig().loops?.orchestrator;
   const configured = deps.mode ?? orchestratorConfig?.mode;
   const mode: Mode = configured === 'off' || configured === 'live' ? configured : 'shadow';
+  const pulse = (health: 'healthy' | 'degraded', at: Date): void => {
+    try { emitLoopHeartbeat(root, 'orchestrator', health, at,
+      new Date(nextOrchestratorWindowAt(at).getTime() + ORCHESTRATOR_LEASE_GRACE_MS).toISOString()); }
+    catch (error) { debug.log('loop.orchestrator', 'heartbeat-failed', { error: String(error).slice(0, 200) }, { level: 'warn' }); }
+  };
+  if (mode !== 'off') pulse('healthy', now);
+  const heartbeatTimer = mode === 'off' ? undefined : setInterval(() => pulse('healthy', currentTime()), deps.heartbeatIntervalMs ?? 60 * 60_000);
+  heartbeatTimer?.unref();
+  let nodeError: unknown;
+  try {
   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');
@@ -739,6 +765,13 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, JSON.stringify(state));
   return state;
+  } catch (error) {
+    nodeError = error;
+    throw error;
+  } finally {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (mode !== 'off') pulse(nodeError === undefined ? 'healthy' : 'degraded', currentTime());
+  }
 }
 
 /** COORD-HA — the production supply of `TickDeps.degradation` (config `loops.orchestrator.degradationSignal`). Shadow (the

package/src/loops/orchestrator/traffic.ts

@@ -9,7 +9,7 @@ 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';
+import { budgetTrafficTick } from '../budget.js';
 
 export const TRAFFIC_SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
 export type TrafficCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'>;
@@ -49,86 +49,12 @@ function realOrResolved(path: string): string {
   try { return realpathSync(path); } catch { return resolve(path); }
 }
 
-const IS_LAUNCH = /(?:^|\s)(?:\S*\/)?elanous\.mjs\s+(?:(?:--test|--config-dir\s+\S+)\s+)?harness\s+(?:ask|say)(?=\s|$)/;
+/** A `harness ask|say` launch command line — the only processes `trafficTick` counts. */
+export { isTrafficLaunch } from '../budget.js';
 
-/** Process-to-seat resolution occurs at the boundary; this decision does no IO. */
-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) => {
-      if (!Number.isFinite(process.elapsedSeconds) || process.elapsedSeconds < 0) return current;
-      const start = now.getTime() - process.elapsedSeconds * 1000;
-      return current === null ? start : Math.max(current, start);
-    }, null);
-    const fallback = owned.length ? lastLaunchAt?.[seat]?.getTime() : undefined;
-    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 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 };
+/** Process observation stays at the boundary; the shared resource loop owns the decision. */
+export function trafficTick(input: Parameters<typeof budgetTrafficTick>[0]): TrafficResult {
+  return budgetTrafficTick(input);
 }
 
 export function withFinishAdvice(result: TrafficResult, deps: MeasureFinishDeps = {}): TrafficResult {

package/src/loops/registry.ts

@@ -685,6 +685,11 @@ export function unregisteredCronLoops(entries: AllLoopEntry[], opts: LoopRegistr
   return warnings;
 }
 
+/** Newest-first run history of one loop without re-listing the registry (health reads a longer window than `loop status`). */
+export function loopRecentRuns(id: string, opts: LoopRegistryOptions = {}, count = 5): LoopRun[] {
+  return recentRuns(id, opts.stateRoot ?? effectiveInstanceRoot(), count);
+}
+
 export function loopStatus(id: string, opts: LoopRegistryOptions = {}): LoopEntry & { recentRuns: LoopRun[] } {
   const loop = listLoops(opts).find(entry => entry.id === id);
   if (!loop) throw new Error(`loop not found: ${id}`);