elanous 0.2.22 → 0.2.24

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/checker.ts

@@ -1,12 +1,13 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
 import { Database } from 'bun:sqlite';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import * as registry from './registry.js';
 import { cronMatches } from '../domains/cron-match.js';
 import { resolveTimeZone } from '../time/format.js';
+import type { ScheduleRow } from '../domains/schedule-registry.js';
 import type { LoopEntry, LoopRun } from './registry.js';
 
 type LoopState = 'off' | 'unregistered' | 'failing' | 'late' | 'unknown' | 'alive';
@@ -23,6 +24,15 @@ export interface CheckEntry {
   lastRunAt?: string;
   lastStatus?: string;
   recentStatuses?: string[];
+  /** Inventory sighting of the scheduled registration (schedule-registry `last_seen`, refreshed on each inventory — not the first sighting); never represented as an execution. */
+  observedSince?: string;
+  /** Optional launcher evidence; absent values are not inferred from a missing heartbeat. */
+  health?: 'healthy' | 'degraded';
+  endsAt?: string;
+  installedVersion?: string;
+  expectedVersion?: string;
+  /** Registry graph path, supplied only by graph inventory. */
+  file?: string;
   enabled: boolean;
   registered: boolean;
 }
@@ -59,6 +69,110 @@ export function checkLoops(entries: CheckEntry[], now: Date, opts: { failureStat
   });
 }
 
+export type ScheduleFinding = { id: string; owner?: string; kind: 'late' | 'failing' | 'degraded' | 'end-expired' | 'version-mismatch'; reason: string; lastRunAt?: string };
+
+/** Additional scheduler evidence is evaluated only when supplied; the six-state CLI contract stays intact. */
+export function scheduleFindings(results: CheckResult[], now: Date): ScheduleFinding[] {
+  const findings: ScheduleFinding[] = [];
+  for (const row of results) {
+    if (!row.enabled || !row.registered) continue;
+    const common = { id: row.id, ...(row.owner ? { owner: row.owner } : {}),
+      ...(row.lastRunAt ? { lastRunAt: row.lastRunAt } : {}) };
+    if (row.state === 'late' || row.state === 'failing') findings.push({ ...common, kind: row.state, reason: row.reason });
+    else if (row.state === 'unknown' && !row.lastRunAt && row.observedSince && row.dueAt &&
+        Number.isFinite(Date.parse(row.observedSince)) && Number.isFinite(Date.parse(row.dueAt)) &&
+        Date.parse(row.observedSince) < Date.parse(row.dueAt))
+      findings.push({ ...common, kind: 'late', reason: `no run since observed registration ${row.observedSince}` });
+    if (row.health === 'degraded') findings.push({ ...common, kind: 'degraded', reason: 'launcher degraded' });
+    if (row.endsAt && Number.isFinite(Date.parse(row.endsAt)) && Date.parse(row.endsAt) <= now.getTime())
+      findings.push({ ...common, kind: 'end-expired', reason: `launcher ended at ${row.endsAt}` });
+    if (row.installedVersion && row.expectedVersion && row.installedVersion !== row.expectedVersion)
+      findings.push({ ...common, kind: 'version-mismatch', reason: `installed ${row.installedVersion}; expected ${row.expectedVersion}` });
+  }
+  return findings;
+}
+
+export function daemonScheduleEntries(rows: readonly ScheduleRow[], now: Date): CheckEntry[] {
+  return rows.filter(row => row.enabled && row.cron && (row.run_via === 'elanous' || row.run_via === 'trigger'))
+    .map(row => ({ id: row.id, owner: 'OP', enabled: true, registered: true, dueAt: dueBefore(row.cron!, now) ?? undefined,
+      ...(row.last_seen ? { observedSince: row.last_seen } : {}),
+      ...(row.last_run ? { lastRunAt: row.last_run } : {}),
+      ...(row.last_status ? { lastStatus: row.last_status, recentStatuses: [row.last_status] } : {}),
+    }));
+}
+
+export function versionEvidence(entries: CheckEntry[], repoRoot: string, stateRoot: string): CheckEntry[] {
+  return entries.map(entry => {
+    if (!entry.file || !/^[\w./-]+\.ya?ml$/.test(entry.file) || entry.file.split('/').includes('..')) return entry;
+    const graphPath = resolve(repoRoot, entry.file);
+    if (!graphPath.startsWith(resolve(repoRoot) + '/')) return entry;
+    const runsPath = join(stateRoot, 'graph-runs', entry.id);
+    try {
+      if (!existsSync(graphPath) || !existsSync(runsPath)) return entry;
+      const latest = readdirSync(runsPath).filter(name => name.endsWith('.json') && !name.endsWith('.decision.json'))
+        .sort((a, b) => statSync(join(runsPath, b)).mtimeMs - statSync(join(runsPath, a)).mtimeMs)[0];
+      if (!latest) return entry;
+      const run = JSON.parse(readFileSync(join(runsPath, latest), 'utf8')) as { graphId?: string; variant?: unknown; graphSnapshot?: { graphSha?: string } };
+      if (run.graphId !== entry.id || run.variant || !run.graphSnapshot?.graphSha) return entry;
+      const installedVersion = run.graphSnapshot.graphSha;
+      const current = createHash('sha256').update(readFileSync(graphPath)).digest('hex');
+      return { ...entry, installedVersion, expectedVersion: current };
+    } catch (error) {
+      debug.log('loop.checker', 'version-unavailable', { id: entry.id, reason: String(error) });
+      return entry;
+    }
+  });
+}
+
+export function launcherEvidence(entries: CheckEntry[], root: string): CheckEntry[] {
+  const path = join(root, 'msg', 'messages.db');
+  if (!existsSync(path)) return entries;
+  try {
+    const db = new Database(path, { readonly: true });
+    try {
+      if (!db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name='loop_signals'").get()) return entries;
+      const signals = db.query('SELECT loop_id, health, ends_at FROM loop_signals').all() as Array<{
+        loop_id: string; health: string; ends_at: string | null;
+      }>;
+      const byId = new Map(signals.map(signal => [signal.loop_id, signal]));
+      return entries.map(entry => {
+        const signal = byId.get(entry.id);
+        return signal ? { ...entry, ...(signal.health === 'degraded' ? { health: 'degraded' as const } : {}),
+          ...(signal.ends_at ? { endsAt: signal.ends_at } : {}) } : entry;
+      });
+    } finally { db.close(); }
+  } catch (error) {
+    debug.log('loop.checker', 'launcher-evidence-unavailable', { reason: String(error) });
+    return entries;
+  }
+}
+
+// Extend only an observed healthy launcher that is still heartbeating. The CAS prevents replacing a renewed lease.
+export function extendHealthyLauncher(root: string, finding: ScheduleFinding, now: Date): boolean {
+  if (finding.kind !== 'end-expired' || !Number.isFinite(now.getTime())) return false;
+  const path = join(root, 'msg', 'messages.db');
+  if (!existsSync(path)) return false;
+  const db = new Database(path);
+  try {
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      const row = db.query('SELECT at, health, ends_at FROM loop_signals WHERE loop_id=?')
+        .get(finding.id) as { at: string; health: string; ends_at: string | null } | null;
+      const age = row ? now.getTime() - Date.parse(row.at) : NaN;
+      if (!row || row.health !== 'healthy' || !Number.isFinite(age) || age < 0 || age > 15 * 60_000 ||
+          !row.ends_at || !Number.isFinite(Date.parse(row.ends_at)) || Date.parse(row.ends_at) > now.getTime()) {
+        db.exec('COMMIT');
+        return false;
+      }
+      const result = db.query('UPDATE loop_signals SET ends_at=? WHERE loop_id=? AND at=? AND health=? AND ends_at=?')
+        .run(new Date(now.getTime() + 15 * 60_000).toISOString(), finding.id, row.at, row.health, row.ends_at);
+      db.exec('COMMIT');
+      return result.changes === 1;
+    } catch (error) { db.exec('ROLLBACK'); throw error; }
+  } finally { db.close(); }
+}
+
 export function countLoopStates(results: CheckResult[]): LoopCounts {
   const counts: LoopCounts = { alive: 0, late: 0, failing: 0, off: 0, unregistered: 0, unknown: 0 };
   for (const result of results) counts[result.state]++;
@@ -118,8 +232,14 @@ export interface CheckerDeps {
 }
 
 /** Appends only new daily keys to the seat request journal; never rewrites existing lines. */
-export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): number {
-  const eligible = results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'));
+export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}, findings: ScheduleFinding[] = [], escalation = false): number {
+  const eligible = [
+    ...results.filter(result => result.owner && (result.state === 'late' || result.state === 'failing'))
+      .map(result => ({ ...result, alertState: result.state })),
+    ...findings.filter(result => result.owner && (result.kind !== 'late' && result.kind !== 'failing' ||
+      !results.some(row => row.id === result.id && row.state === result.kind)))
+      .map(result => ({ ...result, alertState: result.kind })),
+  ].filter(result => escalation ? result.owner !== 'OP' : true);
   if (!eligible.length) return 0;
   const now = deps.now ?? new Date();
   const path = join(deps.root ?? effectiveInstanceRoot(), 'seat-requests', 'requests.jsonl');
@@ -132,19 +252,38 @@ export function notifyOwners(results: CheckResult[], deps: CheckerDeps = {}): nu
     lock.exec('BEGIN EXCLUSIVE');
     try {
       const existing = new Set<string>();
+      const ownerRequests = new Map<string, { queuedAt?: string; status?: string }>();
       if (existsSync(path)) {
         for (const line of readFileSync(path, 'utf8').split('\n')) {
           if (line.trim()) {
-            const row = JSON.parse(line) as { key?: string };
-            if (row.key) existing.add(row.key);
+            const row = JSON.parse(line) as { key?: string; queuedAt?: string; status?: string };
+            if (row.key) {
+              existing.add(row.key);
+              ownerRequests.set(row.key, row);
+            }
           }
         }
       }
       let added = 0;
       for (const result of eligible) {
-        const key = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.state}`;
+        const ownerKey = `loopcheck:${result.id}:${now.toISOString().slice(0, 10)}:${result.alertState}`;
+        let requestKey = ownerKey;
+        if (escalation) {
+          const yesterday = new Date(now.getTime() - 24 * 3600_000).toISOString().slice(0, 10);
+          const priorKey = `loopcheck:${result.id}:${yesterday}:${result.alertState}`;
+          const prior = ownerRequests.get(priorKey);
+          if (prior?.status === 'queued' && prior.queuedAt &&
+              now.getTime() - Date.parse(prior.queuedAt) >= 30 * 60_000 && !existing.has(`${priorKey}:op`))
+            requestKey = priorKey;
+        }
+        const key = escalation ? `${requestKey}:op` : ownerKey;
         if (existing.has(key)) continue;
-        const row = { key, receiptId: key, seat: result.owner, text: `${result.id} ${result.state} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
+        if (escalation) {
+          const request = ownerRequests.get(requestKey);
+          if (!request || request.status !== 'queued' || !request.queuedAt ||
+              now.getTime() - Date.parse(request.queuedAt) < 30 * 60_000) continue;
+        }
+        const row = { key, receiptId: key, seat: escalation ? 'OP' : result.owner, text: `${result.id} ${result.alertState} — 마지막 ${result.lastRunAt ?? '없음'} · ${result.reason}`,
           status: 'queued', queuedAt: now.toISOString(), source: 'loop-checker' };
         appendFileSync(path, JSON.stringify(row) + '\n');
         existing.add(key);

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

@@ -10,11 +10,15 @@ import {
   type LlmMergeOutcome, type MergeGitSeam,
 } from '../../autopilot/build/llm-conflict-merge.js';
 
-type ResyncVerdict = 'saved' | 'merge-ok-tests-failed' | 'merge-ok-no-tests' | 'unresolved' | 'guard-tripped' | 'error';
+type ResyncVerdict = 'saved' | 'merge-ok-tests-failed' | 'merge-ok-no-tests' | 'unresolved' | 'guard-tripped' | 'push-rejected' | 'error';
+export type ResyncShadowMode = 'shadow' | 'live';
 interface ResyncShadowEntry {
   at: string;
   pr: number;
   head: string;
+  mode: ResyncShadowMode;
+  pushed: boolean;
+  labelRemoved: boolean;
   verdict: ResyncVerdict;
   status: LlmMergeOutcome['status'] | 'error';
   resolvedFiles: string[];
@@ -28,6 +32,7 @@ export interface ResyncShadowDeps {
   repoRoot?: string;
   instanceRoot?: string;
   runGh?: (args: string[]) => string;
+  runGit?: (args: string[]) => void;
   resolve?: (file: string, conflicted: string) => Promise<string>;
   gitSeam?: MergeGitSeam;
   runTests?: (cwd: string, files: string[]) => { ok: boolean; failedTests?: string[]; noTests?: boolean };
@@ -134,9 +139,10 @@ function defaultRunTests(cwd: string, files: string[]): { ok: boolean; failedTes
   return failedTests.length ? { ok: false, failedTests } : { ok: true };
 }
 
-/** Re-merge open conflicts only in disposable detached worktrees; no remote writes. */
-export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Promise<ResyncShadowSummary> {
+/** Re-merge open conflicts only in disposable detached worktrees; shadow mode never writes to remotes. */
+export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}, mode: ResyncShadowMode = 'shadow'): Promise<ResyncShadowSummary> {
   if (!Number.isSafeInteger(max) || max < 0) throw new Error('--max must be a nonnegative integer');
+  if (mode !== 'shadow' && mode !== 'live') throw new Error('mode must be shadow or live');
   const repoRoot = deps.repoRoot ?? resolve(import.meta.dir, '../../..');
   const gh = deps.runGh ?? ((args: string[]) => command('gh', args, repoRoot));
   const observed: unknown = JSON.parse(gh(['pr', 'list', '--state', 'open', '--json', 'number,headRefName,mergeable,isDraft,labels', '--limit', '1000']));
@@ -146,6 +152,7 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
     throw new Error('incomplete or invalid PR observation');
   const candidates = (observed as OpenPr[]).filter(pr => pr.headRefName.startsWith('self-impl/')
     && pr.mergeable === 'CONFLICTING'
+    && (mode === 'shadow' || pr.labels.some(label => label.name === 'elanous:needs-rebase'))
     && !pr.labels.some(label => label.name === 'elanous:stalled' || label.name === 'elanous:superseded'))
     .sort((a, b) => a.number - b.number).slice(0, max);
   const ledger = join(deps.instanceRoot ?? effectiveInstanceRoot(), 'orchestrator', 'resync-shadow.jsonl');
@@ -154,6 +161,7 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
   for (const pr of candidates) {
     const entry: ResyncShadowEntry = {
       at: (deps.now?.() ?? new Date()).toISOString(), pr: pr.number, head: pr.headRefName,
+      mode, pushed: false, labelRemoved: false,
       verdict: 'error', status: 'error', resolvedFiles: [], testFiles: [],
     };
     let tmp: string | undefined;
@@ -179,6 +187,21 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
           if (!test.ok) entry.failedTests = test.failedTests?.length ? test.failedTests : ['test runner failed'];
         }
       } else entry.verdict = outcome.status === 'conflict-unresolved' || outcome.status === 'up-to-date' ? 'unresolved' : 'error';
+      if (mode === 'live' && entry.verdict === 'saved') {
+        try {
+          (deps.runGit ?? (args => { command('git', args, tmp!); }))(
+            ['push', 'origin', `HEAD:refs/heads/${pr.headRefName}`]);
+          entry.pushed = true;
+          gh(['pr', 'edit', String(pr.number), '--remove-label', 'elanous:needs-rebase']);
+          entry.labelRemoved = true;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          // push 가 이미 됐으면 원격은 살았다 — verdict 는 saved 로 두고 라벨 실패만 남긴다(다음 회차가 같은 PR 을 다시 고를 수 있다).
+          // push 실패는 거부 문구(rejected · non-fast-forward)일 때만 push-rejected · 인증·네트워크·시간초과는 error.
+          if (!entry.pushed) entry.verdict = /rejected|non-fast-forward|fetch first/i.test(message) ? 'push-rejected' : 'error';
+          entry.failedTests = [message];
+        }
+      }
     } catch (error) {
       entry.verdict = 'error';
       entry.failedTests = [error instanceof Error ? error.message : String(error)];
@@ -199,6 +222,9 @@ export async function runResyncShadow(max = 3, deps: ResyncShadowDeps = {}): Pro
     mkdirSync(dirname(ledger), { recursive: true });
     appendFileSync(ledger, `${JSON.stringify(entry)}\n`);
     debug.log('loop.orchestrator', 'resync-shadow', { pr: entry.pr, verdict: entry.verdict, status: entry.status });
+    if (mode === 'live') debug.log('loop.orchestrator', 'resync-live', {
+      pr: entry.pr, verdict: entry.verdict, pushed: entry.pushed, labelRemoved: entry.labelRemoved,
+    });
     if (entry.verdict !== 'error') tried++;
     if (entry.verdict === 'saved') saved++;
   }
@@ -211,13 +237,14 @@ if (import.meta.main) {
   try {
     const args = process.argv.slice(2);
     if (args.includes('--help')) {
-      console.log('Usage: bun src/loops/orchestrator/resync-shadow.ts [--max N] [--json]');
+      console.log('Usage: bun src/loops/orchestrator/resync-shadow.ts [--max N] [--live] [--json]');
     } else {
       const index = args.indexOf('--max');
-      if (args.some((arg, i) => arg !== '--json' && arg !== '--max' && (index < 0 || i !== index + 1))
-        || (index >= 0 && (index === args.length - 1 || args.lastIndexOf('--max') !== index))) throw new Error('usage: resync-shadow.ts [--max N] [--json]');
+      if (args.some((arg, i) => arg !== '--json' && arg !== '--live' && arg !== '--max' && (index < 0 || i !== index + 1))
+        || (index >= 0 && (index === args.length - 1 || args.lastIndexOf('--max') !== index))) throw new Error('usage: resync-shadow.ts [--max N] [--live] [--json]');
       const max = index < 0 ? 3 : Number(args[index + 1]);
-      const summary = await runResyncShadow(max);
+      const mode: ResyncShadowMode = args.includes('--live') ? 'live' : 'shadow';
+      const summary = await runResyncShadow(max, {}, mode);
       console.log(process.argv.includes('--json') ? JSON.stringify(summary) : `resync-shadow candidates=${summary.candidates} tried=${summary.tried} saved=${summary.saved} savedRatio=${summary.savedRatio === null ? 'n/a' : `${(summary.savedRatio * 100).toFixed(1)}%`}`);
     }
   } catch (error) {

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/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,88 +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 const isTrafficLaunch = (command: string): boolean => IS_LAUNCH.test(command);
+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 {