elanous 0.2.34 → 0.2.36

package/src/steward/hold-hygiene.ts

@@ -5,7 +5,7 @@ import { opSeatStatePath, readTrafficSignal } from '../seat-loop/traffic-signal.
 
 const SEATS = ['OP', 'MK', 'TC', 'UX'] as const;
 type Seat = typeof SEATS[number];
-export type HygieneCell = { id: string; owner?: string | null; status: string };
+export type HygieneCell = { id: string; owner?: string | null; status: string; title?: string };
 export type HygieneNotice = { to: Seat; key: string; body: string };
 export type HygieneDeps = {
   root: string;
@@ -45,7 +45,7 @@ export function starvingCycles(log: string): { reasons: Record<string, number> }
   return { reasons };
 }
 
-type HoldMeta = { id?: unknown; op?: unknown; reason?: unknown; until?: unknown };
+type HoldMeta = { id?: unknown; op?: unknown; reason?: unknown; until?: unknown; kind?: unknown; confirmedAt?: unknown; at?: unknown; title?: unknown };
 function holdMetadata(path: string): Map<string, HoldMeta> {
   const latest = new Map<string, HoldMeta>();
   for (const line of (readOptional(path) ?? '').split(/\r?\n/)) {
@@ -65,6 +65,10 @@ function untilTime(value: unknown): number | null {
   return Number.isFinite(time) ? time : null;
 }
 
+function confirmedTime(value: unknown): number | null {
+  return typeof value === 'string' && /^\d{12}$/.test(value) ? untilTime(value) : null;
+}
+
 export function inspectHoldHygiene(deps: HygieneDeps): HygieneNotice[] {
   const notices: HygieneNotice[] = [];
   const dir = deps.dispatcherDir ?? opSeatStatePath('feeder');
@@ -88,11 +92,25 @@ export function inspectHoldHygiene(deps: HygieneDeps): HygieneNotice[] {
     if (!SEATS.some(seat => seat === owner)) continue;
     const meta = metadata.get(cell.id);
     const reason = meta?.op === 'add' && typeof meta.reason === 'string' ? meta.reason.trim() : '';
-    const expiry = untilTime(meta?.until);
-    const expired = typeof meta?.until === 'string' && meta.until.trim() !== '' && (expiry === null || expiry <= deps.now.getTime());
-    if (reason && !expired) continue;
+    let attention = '';
+    if (meta?.kind === '손작업') {
+      const confirmed = confirmedTime(meta.confirmedAt ?? meta.at);
+      if (confirmed === null) attention = '재확인 시각 없음';
+      else if (deps.now.getTime() - confirmed >= 24 * 60 * 60_000) attention = '24h 재확인 지연';
+    } else if (meta?.kind === '재발사금지') {
+      if (typeof meta.title !== 'string' || !meta.title || typeof cell.title !== 'string' || !cell.title) attention = '제목 기준 확인 불가';
+      else if (cell.title !== meta.title) attention = '칸 제목 변경';
+    } else if (meta?.kind === '선행대기' || meta?.kind === undefined || meta?.kind === '') {
+      const expiry = untilTime(meta?.until);
+      if (expiry === null) attention = 'until 확인 불가';
+      else if (expiry <= deps.now.getTime()) attention = `until ${String(meta?.until)} 지남`;
+    } else attention = 'hold 종류 확인 불가';
+    if (reason && !attention) continue;
+    const guidance = meta?.kind === '손작업' ? '재확인 시각·사유를 판단해 OP에 알려 주세요.'
+      : meta?.kind === '재발사금지' ? '칸 제목과 기준 제목·사유를 대조해 OP에 알려 주세요.'
+        : '풀기/유지(사유·until)를 판단해 OP에 알려 주세요.';
     notices.push({ to: owner as Seat, key: `hold:${cell.id}:${owner}`,
-      body: `노랑 칸 ${cell.id} traffic hold: ${!reason ? '사유 없음' : `사유 ${reason}`} ${expired ? `· until ${String(meta?.until)} 지남` : ''}. 풀기/유지(사유·until)를 판단해 OP에 알려 주세요. 자동 해제하지 않습니다.` });
+      body: `노랑 칸 ${cell.id} traffic hold: ${!reason ? '사유 없음' : `사유 ${reason}`} ${attention ? `· ${attention}` : ''}. ${guidance} 자동 해제하지 않습니다.` });
   }
   return notices;
 }

package/src/steward/rejudge-tick.ts

@@ -63,8 +63,16 @@ function defaultStampPath(): string {
 function readStamp(path: string): string | null {
   try {
     const value = (JSON.parse(readFileSync(path, 'utf8')) as { startedAt?: unknown }).startedAt;
-    return typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
-  } catch { return null; }
+    if (typeof value !== 'string' || !Number.isFinite(Date.parse(value))) {
+      throw new Error(`invalid steward stamp startedAt: ${path}`);
+    }
+    return value;
+  } catch (error) {
+    // A missing stamp is the first tick. A corrupt or unreadable existing stamp is not:
+    // claiming it would overwrite the evidence and could launch an overlapping rejudge.
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw error;
+  }
 }
 
 /** Same universe as this process (env inherited) · same installed version (entry next to this module). */

package/src/steward/ta-repair-event-collect.ts

@@ -7,6 +7,7 @@ import { acquireLockSync } from '../storage/file-lock.js';
 import { subscribeInsideEvent, type InsideLiveEvent } from '../nexus/api/inside-events.js';
 import type { NexusEventBus } from '../nexus/api/event-bus.js';
 import { parseRepairWorkerResult } from '../task-agent/repair-worker.js';
+import { pairMoveId } from '../task-agent/repair-next-move.js';
 import { readTaskCard, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 const SHA40 = /^[0-9a-f]{40}$/i;
@@ -17,6 +18,8 @@ const OUTPUT_LIMIT = 1024 * 1024;
 export interface TaRepairCompleted {
   kind: 'ta.repair.completed'; schema: 1; card: string; pr: number; head: string;
   runId: string; resultPath: string; completedAt: string;
+  /** HARNESS-FULL-GRAPH-NEXTMOVE — worker 가 받은 수 id(옛 worker 는 없다 · 꼴이 틀려도 사건을 버리지 않고 짝짓기에서 «못 짝지음»으로 남긴다). */
+  moveId?: string;
 }
 
 export function parseTaRepairCompleted(value: unknown): TaRepairCompleted | null {
@@ -102,14 +105,22 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
   let card;
   try { card = readTaskCard(event.card, statePath); } catch { emit('deferred', { reason: 'card unreadable' }); return 'deferred'; }
   const repair = Array.isArray(card?.repairs) ? card.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
+  // NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 사건의 수 id 를 카드(발사 순간 적은 값)와 짝짓는다. 결과는 관측 칸에만 싣는다(fail-soft · 수거 판단은 그대로).
+  const observedMoveId: unknown = (event as { moveId?: unknown }).moveId;
+  const pairing = pairMoveId(repair?.moveId, observedMoveId);
+  const moveFields: Record<string, unknown> = pairing.kind === 'legacy' ? {}
+    : { moveId: pairing.kind === 'paired' ? pairing.moveId : typeof observedMoveId === 'string' ? observedMoveId : null,
+      moveIdPaired: pairing.kind === 'paired', ...(pairing.kind === 'unpaired' ? { expectedMoveId: pairing.expected } : {}) };
+  const emitPaired = (outcome: string, extra: Record<string, unknown> = {}) => emit(outcome, { ...moveFields, ...extra });
   if (!repair || repair.pr !== event.pr || typeof repair.head !== 'string' || repair.head.toLowerCase() !== event.head.toLowerCase()
     || typeof repair.resultPath !== 'string' || !repair.resultPath.startsWith('/')
+    // 카드 귀속이 안 맞는 사건엔 짝짓기 칸을 싣지 않는다 — 남의 수리와 대조한 값이 관측에 섞이지 않게(r1 should-fix).
     || resolve(repair.resultPath) !== resolve(event.resultPath)) { emit('invalid', { reason: 'event differs from card binding' }); return 'invalid'; }
-  if (repair.status !== 'requested') { emit('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
+  if (repair.status !== 'requested') { emitPaired('duplicate', { reason: `repair ${repair.status}` }); return 'duplicate'; }
   let result;
   try { result = parseRepairWorkerResult((deps.read ?? ((path) => readFileSync(path, 'utf8')))(repair.resultPath), event.pr, event.head, event.runId); }
   catch { /* periodic tick can recover a missing result */ }
-  if (!result) { emit('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
+  if (!result) { emitPaired('deferred', { reason: 'worker result missing or invalid' }); return 'deferred'; }
 
   // Existing PID-aware lock recovers a dead daemon without making later events wait forever.
   // A live holder keeps the lock through the child process; the card CAS covers periodic-tick races.
@@ -119,25 +130,25 @@ export async function collectTaRepairCompleted(input: unknown, deps: TaRepairCol
     mkdirSync(dirname(lock), { recursive: true });
     release = acquireLockSync(lock, { breakDeadHolder: true, staleMs: TIMEOUT_MS + 60_000, maxTries: 2 });
   }
-  catch { emit('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
+  catch { emitPaired('deferred', { reason: 'collector busy; periodic fallback remains' }); return 'deferred'; }
   try {
     // Recheck after claiming: another collector or the periodic tick may have consumed the file.
     const current = readTaskCard(event.card, statePath);
     const latest = Array.isArray(current?.repairs) ? current.repairs.find(entry => entry && typeof entry === 'object' && entry.runId === event.runId) : undefined;
     if (!latest || latest.status !== 'requested' || latest.pr !== event.pr || typeof latest.head !== 'string'
       || latest.head.toLowerCase() !== event.head.toLowerCase() || typeof latest.resultPath !== 'string'
-      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emit('duplicate'); return 'duplicate'; }
+      || !latest.resultPath.startsWith('/') || resolve(latest.resultPath) !== resolve(event.resultPath)) { emitPaired('duplicate'); return 'duplicate'; }
     const child = await (deps.run ?? ((card) => defaultRun(card, statePath, deps.cliBin)))(event.card);
     const after = readTaskCard(event.card, statePath)?.repairs?.find(entry => entry.runId === event.runId);
     const consumed = child.code === 0 && !child.truncated && after?.status !== 'requested' && after !== undefined
       && childConsumedRepair(child.output, event);
     const outcome = consumed ? 'collected' : child.truncated ? 'deferred' : after && after.status !== 'requested' ? 'duplicate' : 'deferred';
-    emit(outcome, { rc: child.code, repairStatus: after?.status,
+    emitPaired(outcome, { rc: child.code, repairStatus: after?.status,
       ...(child.truncated ? { reason: 'rejudge output exceeded 1 MiB; event attribution unmeasured' } : {}),
       detail: child.output.slice(-300) });
     return consumed ? 'collected' : outcome === 'duplicate' ? 'duplicate' : 'deferred';
   } catch (error) {
-    emit('deferred', { reason: String(error).slice(-300) });
+    emitPaired('deferred', { reason: String(error).slice(-300) });
     return 'deferred';
   } finally { release(); }
 }

package/src/steward/triage-budget.ts

@@ -1,4 +1,6 @@
 import { createHash } from 'node:crypto';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import type { TriageDecision, TriageIssue } from './triage.js';
 import { InvalidWorkingBackwardsDraft } from './working-backwards.js';
@@ -187,3 +189,195 @@ export async function draftWithinBudget<T>({ wishes, draft, concurrency = 4, per
   debug.log('steward.triage', 'draft-budget', stats);
   return { ...result, stats };
 }
+
+/** Consecutive healthy shadow ticks before a live move is safe to record. */
+export const LIVE_AFTER_TICKS = 3;
+
+/** Reasons a decision is a placeholder, not a judgment — they must never be reused as if they were fresh. */
+const TEMPORARY_WHYS = ['triage deferred — deadline', 'triage judgment timed out — human review',
+  'triage judgment unavailable — human review'];
+
+export function isTemporaryDecision(decision: TriageDecision): boolean {
+  return decision.rung === 'hitl' && decision.hitlReason === 'other' && TEMPORARY_WHYS.includes(decision.why);
+}
+
+export interface TriageTickCycle {
+  /** sha256 of this tick's sorted issue identifiers — the batch fingerprint. */
+  key: string;
+  /** Consecutive ticks (this one included) that carried the same fingerprint. */
+  ticks: number;
+}
+
+export interface TriageTickBudget {
+  cycle: TriageTickCycle;
+  deadlineMs: number;
+  perIssueMs: number;
+  concurrency: number;
+  /** `repeat-tick` when the same batch already arrived in the previous tick. */
+  basis: 'first-tick' | 'repeat-tick';
+}
+
+export type TriageItemOutcome = 'reused' | 'judged' | 'timed-out' | 'unavailable' | 'deferred';
+
+export interface TriageItemEvent {
+  /** 1-based position of the issue in this tick's batch. */
+  index: number;
+  /** Which tick cycle the item was judged in. */
+  cycle: number;
+  issue: string;
+  outcome: TriageItemOutcome;
+  /** No fresh judgment backs this item — the next tick (or a human) must pick it up. */
+  degraded: boolean;
+  why: string;
+}
+
+export interface TriageItemMetrics {
+  items: number;
+  fresh: number;
+  reused: number;
+  degraded: number;
+  byOutcome: Record<TriageItemOutcome, number>;
+}
+
+export interface TriageTickHealth {
+  degraded: string[];
+  /** Degraded last tick, freshly judged this tick. */
+  healed: string[];
+  health: 'healthy' | 'healing' | 'degraded';
+  /** Consecutive non-degraded shadow ticks. */
+  liveStreak: number;
+  /** Shadow has stayed healthy long enough that a live move is safe; the mode itself is not flipped here. */
+  liveEligible: boolean;
+  transition?: 'shadow→live' | 'live→shadow';
+}
+
+export interface TriageTickRecord extends TriageTickHealth {
+  at: string;
+  mode: string;
+  key: string;
+  ticks: number;
+  issues: number;
+  deadlineMs: number;
+  perIssueMs: number;
+  concurrency: number;
+  reused: number;
+  judged: number;
+  timedOut: number;
+  deferred: number;
+  events: TriageItemEvent[];
+}
+
+export function triageTickKey(issues: TriageIssue[]): string {
+  return createHash('sha256').update(JSON.stringify(issues.map(issue => issue.identifier).sort())).digest('hex').slice(0, 16);
+}
+
+/** The tick cycle: a batch that keeps re-arriving is the same cycle, counted up; a changed batch starts at 1. */
+export function triageTickCycle(previous: Pick<TriageTickRecord, 'key' | 'ticks'> | undefined, key: string): TriageTickCycle {
+  const ticks = previous && previous.key === key && Number.isFinite(previous.ticks) ? Math.max(1, previous.ticks) + 1 : 1;
+  return { key, ticks };
+}
+
+/**
+ * Budget derived from the tick cycle: the stage deadline is fixed per tick, but a repeat cycle widens each issue's
+ * slice (up to 3×) instead of re-running the same timeout on the batch that already ran out of window last tick.
+ */
+export function triageTickBudget({ cycle, issueCount, deadlineMs = 240_000, basePerIssueMs = 90_000, maxConcurrency = 8 }: {
+  cycle: TriageTickCycle;
+  issueCount: number;
+  deadlineMs?: number;
+  basePerIssueMs?: number;
+  maxConcurrency?: number;
+}): TriageTickBudget {
+  const count = Math.max(1, Math.floor(issueCount));
+  const concurrency = Math.max(1, Math.min(Math.max(1, Math.floor(maxConcurrency)), count));
+  const stretch = Math.min(Math.max(1, Math.floor(cycle.ticks)), 3);
+  return { cycle, deadlineMs, perIssueMs: Math.min(deadlineMs, basePerIssueMs * stretch), concurrency,
+    basis: cycle.ticks > 1 ? 'repeat-tick' : 'first-tick' };
+}
+
+/** One event per item: what actually happened to it this tick and whether that leaves it degraded. */
+export function triageItemEvents({ cycle, issues, decisions, previous = [] }: {
+  cycle: TriageTickCycle;
+  issues: TriageIssue[];
+  decisions: Array<TriageDecision & { inputHash?: string; deferred?: true }>;
+  previous?: Array<TriageDecision & { inputHash?: string }>;
+}): TriageItemEvent[] {
+  const judged = new Map(decisions.map(decision => [decision.issue, decision]));
+  const earlier = new Map(previous.map(decision => [decision.issue, decision]));
+  const events: TriageItemEvent[] = [];
+  for (const [index, issue] of issues.entries()) {
+    const decision = judged.get(issue.identifier);
+    const before = earlier.get(issue.identifier);
+    let outcome: TriageItemOutcome;
+    if (!decision) outcome = 'unavailable';
+    else if (decision.deferred === true) outcome = 'deferred';
+    else if (decision.why === 'triage judgment timed out — human review') outcome = 'timed-out';
+    else if (decision.why === 'triage judgment unavailable — human review') outcome = 'unavailable';
+    else if (before && before.inputHash !== undefined && before.inputHash === decision.inputHash &&
+      !before.deferred && !isTemporaryDecision(before)) outcome = 'reused';
+    else outcome = 'judged';
+    events.push({ index: index + 1, cycle: cycle.ticks, issue: issue.identifier, outcome,
+      degraded: outcome !== 'judged' && outcome !== 'reused',
+      why: decision?.why ?? 'triage decision missing' });
+  }
+  return events;
+}
+
+export function triageItemMetrics(events: TriageItemEvent[]): TriageItemMetrics {
+  const byOutcome: Record<TriageItemOutcome, number> = { reused: 0, judged: 0, 'timed-out': 0, unavailable: 0, deferred: 0 };
+  for (const event of events) byOutcome[event.outcome]++;
+  const reused = byOutcome.reused;
+  return { items: events.length, fresh: byOutcome.judged, reused,
+    degraded: events.filter(event => event.degraded).length, byOutcome };
+}
+
+/** Healing and the shadow→live transition, read off the previous real tick — never off an assumed one. */
+export function triageTickHealth({ previous, mode, events }: {
+  previous?: Pick<TriageTickRecord, 'mode' | 'degraded' | 'liveStreak'>;
+  mode: string;
+  events: TriageItemEvent[];
+}): TriageTickHealth {
+  const degraded = events.filter(event => event.degraded).map(event => event.issue);
+  const healed = (previous?.degraded ?? []).filter(issue => !degraded.includes(issue)).sort();
+  const health = healed.length ? 'healing' : degraded.length ? 'degraded' : 'healthy';
+  // Any degradation still present this tick resets the streak — a healed item next to a degraded one is not a healthy tick.
+  const liveStreak = mode === 'shadow' ? (degraded.length ? 0 : (previous?.mode === 'shadow' ? previous.liveStreak + 1 : 1)) : 0;
+  const transition = previous && previous.mode !== mode
+    ? (mode === 'live' && previous.mode === 'shadow' ? 'shadow→live'
+      : mode === 'shadow' && previous.mode === 'live' ? 'live→shadow' : undefined)
+    : undefined;
+  return { degraded, healed, health, liveStreak, liveEligible: mode === 'shadow' && liveStreak >= LIVE_AFTER_TICKS,
+    ...(transition ? { transition } : {}) };
+}
+
+export function triageTickLedgerPath(root: string): string {
+  return join(root, 'steward', 'triage-ticks.jsonl');
+}
+
+/** The real ticks that already ran, oldest first. A torn line is not a tick. */
+export function readTriageTicks(root: string, limit = 24): TriageTickRecord[] {
+  let text: string;
+  try { text = readFileSync(triageTickLedgerPath(root), 'utf8'); } catch { return []; }
+  const records: TriageTickRecord[] = [];
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const parsed: unknown = JSON.parse(line);
+      if (parsed && typeof parsed === 'object' && typeof (parsed as { mode?: unknown }).mode === 'string' &&
+        typeof (parsed as { key?: unknown }).key === 'string' && typeof (parsed as { ticks?: unknown }).ticks === 'number' &&
+        Array.isArray((parsed as { degraded?: unknown }).degraded) && Array.isArray((parsed as { events?: unknown }).events)) {
+        records.push(parsed as TriageTickRecord);
+      }
+    } catch { /* torn line */ }
+  }
+  return records.slice(-Math.max(1, limit));
+}
+
+export function appendTriageTick(root: string, record: TriageTickRecord): void {
+  try {
+    mkdirSync(join(root, 'steward'), { recursive: true });
+    appendFileSync(triageTickLedgerPath(root), `${JSON.stringify(record)}\n`);
+  } catch (error) {
+    debug.log('steward.triage', 'tick-ledger-failed', { reason: String(error) }, { level: 'warn' });
+  }
+}

package/src/steward/triage.ts

@@ -130,7 +130,7 @@ export function trackTablePrompt(tracks?: Record<string, string>): string {
   return `\n담당 트랙(owner) — 아래 중 하나(${keys.map(k => JSON.stringify(k)).join('|')}) · 이슈가 어느 트랙 일인지:\n${keys.map(k => `- ${k}: ${tracks[k]}`).join('\n')}`;
 }
 
-export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<StewardDeps['judge']>, decide: typeof emitDecision = emitDecision, tracks?: Record<string, string>, previous: Array<TriageDecision & { inputHash?: string }> = [], ask: StewardAsk = askSteward): Promise<TriageDecision[]> {
+export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<StewardDeps['judge']>, decide: typeof emitDecision = emitDecision, tracks?: Record<string, string>, previous: Array<TriageDecision & { inputHash?: string }> = [], ask: StewardAsk = askSteward, budget?: { deadlineMs: number; perIssueMs: number; concurrency: number }): Promise<TriageDecision[]> {
   const started = judge ? 0 : Date.now();
   const classified: ClassifiedIssue[] = [];
   const classifiedIds = new Set<string>();
@@ -144,7 +144,7 @@ export async function triageIssues(issues: TriageIssue[], judge?: NonNullable<St
     decide({ kind: result.rung === 'hitl' ? 'ESCALATE' : 'ROUTE', what: result.issue, reason: result.why,
       purpose: 'steward triage', target: result.owner ? `${result.rung} · ${result.owner}` : String(result.rung), refs: { issue: result.issue } });
   };
-  const { decisions } = await triageWithinBudget({ issues, previous, tracks, judge: async (issue, observedIssues) => {
+  const { decisions } = await triageWithinBudget({ issues, previous, tracks, ...(budget ?? {}), judge: async (issue, observedIssues) => {
     try {
       if (judge) return parseJudgment(issue, await judge(issue, observedIssues ?? issues, tracks), tracks);
       const byRule = ruleJudgment(issue, observedIssues ?? issues);
@@ -487,7 +487,24 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
         Array.isArray(item.dependsOn) && item.dependsOn.every((dep: unknown) => typeof dep === 'string') &&
         typeof item.priority === 'number' && Number.isFinite(item.priority) && typeof item.why === 'string')) previous = parsed;
     } catch { /* Missing or corrupt previous judgments are an empty cache. */ }
-    writeFileSync(judgments, JSON.stringify(await triageIssues(issues, judge, deps.decide, settings.tracks, previous, deps.ask)));
+    const { appendTriageTick, readTriageTicks, triageItemEvents, triageItemMetrics, triageTickBudget, triageTickCycle,
+      triageTickHealth, triageTickKey } = await import('./triage-budget.js');
+    const ticks = readTriageTicks(root);
+    const cycle = triageTickCycle(ticks.at(-1), triageTickKey(issues));
+    const budget = triageTickBudget({ cycle, issueCount: issues.length });
+    const decisions = await triageIssues(issues, judge, deps.decide, settings.tracks, previous, deps.ask, budget);
+    writeFileSync(judgments, JSON.stringify(decisions));
+    const events = triageItemEvents({ cycle, issues, decisions, previous });
+    const metrics = triageItemMetrics(events);
+    const mode = settings.mode ?? 'shadow';
+    const health = triageTickHealth({ previous: ticks.at(-1), mode, events });
+    for (const event of events) debug.log('steward.triage', 'item-event', { ...event, health: health.health });
+    debug.log('steward.triage', 'tick', { cycle, basis: budget.basis, perIssueMs: budget.perIssueMs,
+      concurrency: budget.concurrency, ...metrics, ...health });
+    appendTriageTick(root, { at: new Date().toISOString(), mode, key: cycle.key, ticks: cycle.ticks, issues: issues.length,
+      deadlineMs: budget.deadlineMs, perIssueMs: budget.perIssueMs, concurrency: budget.concurrency,
+      reused: metrics.byOutcome.reused, judged: metrics.byOutcome.judged, timedOut: metrics.byOutcome['timed-out'],
+      deferred: metrics.byOutcome.deferred, ...health, events });
   } else if (stage === 'schedule') {
     const decisions = JSON.parse(readFileSync(judgments, 'utf8')) as TriageDecision[];
     const pending = new Set(decisions.flatMap(decision => decision.dependsOn));

package/src/task-agent/actions.ts

@@ -48,6 +48,8 @@ export interface NextAction {
   cwd?: string;
   risk?: 'money' | 'security' | 'irreversible-publication';
   delivery?: { kind: DeliveryKind; worktreePath: string; projectTarget: string; files: string[] };
+  /** NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 재발사를 고른 next-move 결정의 수 id(결정 순간 한 번 · 다시 만들지 않는다). 있으면 `harness say --move-id` 로 싣는다. */
+  moveId?: string;
 }
 export interface ActionDeps {
   command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
@@ -64,7 +66,7 @@ export interface ActionDeps {
   releaseLanding?(day: string): void;
   /** 실패 한 번을 잠금 안에서 디스크에 더한다(다른 프로세스의 실패를 덮지 않게) · 더한 뒤의 값을 돌려준다. */
   incrementFailure?(key: string): number;
-  observe(event: 'task-agent.action', data: { taskId: string; kind: NextActionKind; result: string; reason: string }): void;
+  observe(event: 'task-agent.action' | 'task-agent.entrance-denominator', data: ActionObservation): void;
   /** 사다리 R4 — 실제로 할 재발사 수의 허용 목록(`taskAgent.liveMoves` 어휘). 없으면 종전 그대로(재발사에 목록 검사 없음) · 목록에 없는 수는 shadow. */
   liveMoves?: ReadonlySet<string>;
   /** 한 판단 회차의 발사 칸 — 호출부가 회차마다 새로 준다. 없으면 회당 상한 없음(종전). 발사를 시도할 때마다 `count` 가 오른다. */
@@ -76,6 +78,49 @@ export interface ActionDeps {
 /** 재발사는 한 판단 회차에 한 건만 발사한다. */
 export const RETRY_LAUNCHES_PER_CYCLE = 1;
 
+export interface ActionObservation {
+  taskId: string;
+  kind: NextActionKind | 'entrance-tick';
+  result: string;
+  reason: string;
+  reviewed?: number;
+  allowed?: number;
+  refused?: number;
+  reasons?: Record<string, number>;
+}
+
+export interface EntranceCandidateReview {
+  taskId: string;
+  kind: NextActionKind;
+  refusal?: string;
+}
+
+export interface EntranceTickCandidate {
+  action: NextAction;
+  refusal?: string;
+}
+
+export interface EntranceRefusalDenominator {
+  reviewed: number;
+  allowed: number;
+  refused: number;
+  reasons: Record<string, number>;
+}
+
+/** Count a tick's candidate refusals without confusing special object keys with prototypes. */
+export function buildEntranceRefusalDenominator(reviews: readonly EntranceCandidateReview[]): EntranceRefusalDenominator {
+  const reasonCounts = new Map<string, number>();
+  let refused = 0;
+  for (const review of reviews) {
+    const reason = typeof review.refusal === 'string' ? review.refusal.trim() : '';
+    if (!reason) continue;
+    refused += 1;
+    reasonCounts.set(reason, (reasonCounts.get(reason) ?? 0) + 1);
+  }
+  const reasons = Object.fromEntries(reasonCounts) as Record<string, number>;
+  return { reviewed: reviews.length, allowed: reviews.length - refused, refused, reasons };
+}
+
 /** live 인데도 shadow 로 내릴 사유 — 없으면 발사해도 된다(재발사 아닌 수는 늘 없다). 기다림(wait)은 발사가 아니라 부하·회당 상한을 보지 않는다. */
 function retryShadowReason(action: NextAction, deps: ActionDeps): string | undefined {
   if (action.kind !== 'retry') return undefined;
@@ -230,7 +275,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     return card('review verdict or must-fix unavailable');
   }
   // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
-  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action)];
+  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action), ...(action.moveId ? ['--move-id', action.moveId] : [])];
   const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
   if (action.kind === 'retry' && deps.retryLaunches) deps.retryLaunches.count++;
   const outcome = await deps.command(args);
@@ -264,6 +309,31 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   return record('done', action.rationale);
 }
 
+/** Execute the allowed candidates in a caller-supplied tick and emit one isolated denominator event. */
+export async function executeEntranceTick(candidates: readonly EntranceTickCandidate[], deps: ActionDeps): Promise<string[]> {
+  const denominator = buildEntranceRefusalDenominator(candidates.map(({ action, refusal }) => ({
+    taskId: action.taskId,
+    kind: action.kind,
+    ...(typeof refusal === 'string' ? { refusal } : {}),
+  })));
+  const observeDenominator = (result: string) => {
+    try {
+      deps.observe('task-agent.entrance-denominator', {
+        taskId: candidates[0]?.action.taskId ?? 'entrance-tick',
+        kind: 'entrance-tick', result, reason: 'entrance refusal denominator', ...denominator,
+      });
+    } catch { /* Logging must not change the actions selected for this tick. */ }
+  };
+  const results: string[] = [];
+  for (const { action, refusal } of candidates) {
+    if (typeof refusal === 'string' && refusal.trim()) continue;
+    try { results.push(await executeNextAction(action, deps)); }
+    catch (error) { observeDenominator('failed'); throw error; }
+  }
+  observeDenominator(results.at(-1) ?? 'refused-all');
+  return results;
+}
+
 /** 재발사 문면 — 원문은 고치지 않고 앞에 둔다 · 갈래 문면 · must-fix · 직전 런 순서. */
 export function retryText(action: NextAction): string {
   const sections = [action.original];

package/src/task-agent/green-sweep.ts

@@ -28,6 +28,8 @@ export interface GreenSweepDecision {
   source: GreenSweepCandidate['source'];
   verdict: GreenSweepVerdict;
   reason: string;
+  /** Present when traffic hold state could not be read; preserves the decision reason while exposing its cause. */
+  holdDiagnostic?: string;
   evidence: string;
   existingEvidence: string;
   /** Preview only; a later live operation may persist this complete value. */
@@ -107,6 +109,7 @@ export function decideGreenSweep(input: {
   pr: GreenSweepPr | null;
   ancestor: boolean | null;
   hold: boolean | null;
+  holdDiagnostic?: string;
   repositoryMatches?: boolean | null;
   ambiguousAcrossCells?: boolean;
 }): GreenSweepDecision {
@@ -116,6 +119,7 @@ export function decideGreenSweep(input: {
     const landing = pr?.viaTrain ? ` via train #${pr.viaTrain.integrationPr}` : '';
     const evidence = `GREEN-FROM-LEDGER: PR #${candidate.pr}${landing}${mergeSha ? ` merged ${mergeSha}` : ''} · ${verdict} · ${reason}`;
     return { cell: item.id, pr: candidate.pr, mergeSha, source: candidate.source, verdict, reason,
+      ...(reason === 'hold-state-unreadable' && input.holdDiagnostic ? { holdDiagnostic: input.holdDiagnostic } : {}),
       evidence, existingEvidence: item.evidence ?? '', plannedEvidence: appendGreenSweepEvidence(item.evidence, evidence) };
   };
   if (item.status !== 'yellow' && item.status !== 'red') return result('skip', 'cell-not-yellow');

package/src/task-agent/land-queue.ts

@@ -4,6 +4,7 @@ import { mkdirSync, readFileSync } from 'node:fs';
 import { dirname, isAbsolute, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parseReviewResultOutput } from './review-result-capture.js';
+import { executeBoundPrLandRecover, PR_LAND_CARD_ID_ENV } from '../cli/pr-land-recovery.js';
 
 type CommandResult = { status: number; stdout: string; stderr: string };
 export interface QueueLandingInput {
@@ -13,6 +14,8 @@ export interface QueueLandingInput {
 export interface QueueLandingDeps {
   run?: (command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv) => Promise<CommandResult>;
   read?: (path: string) => string;
+  /** LAND-REFUSAL-EXEC — observe a refusal on the recover@1 edge and run that unit once (never an effect). */
+  recover?: typeof executeBoundPrLandRecover;
 }
 
 async function run(command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<CommandResult> {
@@ -31,14 +34,24 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   const invoke = deps.run ?? run;
   const read = deps.read ?? ((path: string) => readFileSync(path, 'utf8'));
   const fail = (stage: string, reason: string): CommandResult => ({ status: 1, stdout: '', stderr: `${stage}: ${reason.slice(-500)}` });
+  // LAND-REFUSAL-EXEC — a judged refusal (not an unmeasured prerequisite) is bound to recover@1 with this card
+  // and that unit runs once. The returned refusal is unchanged; recovery observation never replaces it.
+  const refuse = async (stage: string, reason: string): Promise<CommandResult> => {
+    const refused = fail(stage, reason);
+    try { await (deps.recover ?? executeBoundPrLandRecover)({ refusal: refused.stderr, pr: input.pr, head: input.head, cardId: input.card }, { root: dirname(input.statePath) }); }
+    catch { /* fail-soft */ }
+    return refused;
+  };
+  // The card rides along to every child that may land or record this PR (same env as TA defaultLand).
+  const cardEnv = (extra: Record<string, string> = {}): NodeJS.ProcessEnv => ({ ...process.env, ...extra, [PR_LAND_CARD_ID_ENV]: input.card });
   if (!/^[a-f0-9]{40}$/i.test(input.head) || !Number.isSafeInteger(input.pr) || input.pr < 1) return fail('input', 'invalid PR/head');
   if (!isAbsolute(input.command) || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(input.remote)) return fail('config', 'land queue command/remote invalid');
   let review: ReturnType<typeof parseReviewResultOutput>;
   try { review = parseReviewResultOutput(read(input.reviewResult)); }
-  catch (error) { return fail('review', String(error)); }
+  catch (error) { return refuse('review', String(error)); }
   if (!review || review.pr !== input.pr || review.head?.toLowerCase() !== input.head.toLowerCase()
     || review.reviewed !== true || !['pass', 'warn'].includes(review.verdict ?? '') || review.mustFix !== 0 || review.error) {
-    return fail('review', `exact head #${input.pr} ${input.head.slice(0, 12)} PASS/WARN mf0 not proven`);
+    return refuse('review', `exact head #${input.pr} ${input.head.slice(0, 12)} PASS/WARN mf0 not proven`);
   }
   const git = async (args: string[]) => invoke(process.execPath, [input.entry, '--config-dir', input.configDir, 'git', ...args], input.cwd);
   const fetched = await git(['fetch', '--quiet', 'origin', 'main']);
@@ -52,15 +65,15 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   const artifact = join(dirname(input.statePath), 'land-queue-gates', `${safeCard}-${input.pr}-${input.head.slice(0, 12)}-${randomUUID()}`);
   mkdirSync(artifact, { recursive: true });
   const gate = await invoke(process.execPath, [input.entry, '--config-dir', input.configDir,
-    'self', 'gate', '--changed', '--base', baseHead!, '--remote', input.remote, '--shards', '4', '--artifact-dir', artifact], input.cwd);
-  if (gate.status !== 0) return fail('remote-changed-gate', gate.stderr || gate.stdout || `exit ${gate.status}`);
+    'self', 'gate', '--changed', '--base', baseHead!, '--remote', input.remote, '--shards', '4', '--artifact-dir', artifact], input.cwd, cardEnv());
+  if (gate.status !== 0) return refuse('remote-changed-gate', gate.stderr || gate.stdout || `exit ${gate.status}`);
   let summary: Record<string, unknown>;
   try { summary = JSON.parse(read(join(artifact, 'summary.json'))) as Record<string, unknown>; }
   catch (error) { return fail('remote-changed-gate', `summary unreadable: ${String(error)}`); }
   if (summary.head40 !== input.head || summary.base40 !== baseHead || summary.remoteHost !== input.remote
     || summary.verdict !== 'passed' || summary.exitCode !== 0 || summary.introduced !== 0
     || summary.unknown !== 0 || summary.preconditionUnmet !== 0) {
-    return fail('remote-changed-gate', 'summary does not prove this head/base/remote passed with zero unknown');
+    return refuse('remote-changed-gate', 'summary does not prove this head/base/remote passed with zero unknown');
   }
   const fresh = await invoke('gh', ['pr', 'view', String(input.pr), '--json', 'headRefOid,state,isDraft'], input.cwd);
   let latest: { headRefOid?: unknown; state?: unknown; isDraft?: unknown };
@@ -68,12 +81,12 @@ export async function runQueuedLanding(input: QueueLandingInput, deps: QueueLand
   catch { return fail('pr-head', `current PR state unreadable: ${fresh.stderr || fresh.stdout || fresh.status}`); }
   if (fresh.status !== 0 || latest.state !== 'OPEN' || latest.isDraft !== false
     || typeof latest.headRefOid !== 'string' || latest.headRefOid.toLowerCase() !== input.head.toLowerCase()) {
-    return fail('pr-head', `PR #${input.pr} changed after gate or is not ready`);
+    return refuse('pr-head', `PR #${input.pr} changed after gate or is not ready`);
   }
   const enrolled = await invoke(input.command, [String(input.pr), input.cwd, '--review', input.reviewResult, '--expected-head', input.head], input.cwd,
-    { ...process.env, LAND_RR_DIR: dirname(input.reviewResult) });
+    cardEnv({ LAND_RR_DIR: dirname(input.reviewResult) }));
   if (enrolled.status !== 0 || !new RegExp(`^OK #${input.pr} head=${input.head.slice(0, 12)}(?:\\s|$)`, 'm').test(enrolled.stdout)) {
-    return fail('land-enqueue-refused', enrolled.stdout || enrolled.stderr || `exit ${enrolled.status}`);
+    return refuse('land-enqueue-refused', enrolled.stdout || enrolled.stderr || `exit ${enrolled.status}`);
   }
   return { status: 0, stdout: `queued #${input.pr} head ${input.head.slice(0, 12)} gate ${artifact} · ${enrolled.stdout.slice(-250)}`, stderr: '' };
 }