elanous 0.2.41 → 0.2.42

package/src/cli/pr-land-overlap-evidence.ts

@@ -119,6 +119,17 @@ function checkSelectedReviewAttempts(input: VerifyOverlapEvidenceInput, e: Parti
   let selectedRecord: Record<string, unknown> | undefined;
   try { selectedRecord = lastReviewRecord(input.readFile(selected)); } catch { return { ok: false, reason: 'review-unreadable' }; }
   const hasResolvedPrior = hasResolvedPriorDeclaration(selectedRecord);
+  if (selectedRecord?.reviewer === 'OP-waiver') {
+    const waiver = validOpWaiver(selectedRecord, input.pr, selectedHead);
+    if (!waiver.ok) return { ok: false, reason: waiver.reason };
+    const linkedSameHeadFailure = candidates.some((path) => {
+      if (path === selected || !adjudicatesReviewFile(waiver.adjudicates, path)) return false;
+      const failed = checkReview(input, { reviewResult: path }, selectedHead);
+      return !failed.ok && /^review-(?:verdict-fail|must-fix-[1-9][0-9]*)$/.test(failed.reason)
+        && reviewAttemptHasExactSameHeadFail(input, path, selectedHead);
+    });
+    if (!linkedSameHeadFailure) return { ok: false, reason: 'review-op-waiver-same-head-failure-missing' };
+  }
   if (entries?.length || hasResolvedPrior) {
     try { selectedTime = input.reviewMtime(selected); } catch { return { ok: false, reason: 'review-attempt-time-unmeasured' }; }
     if (!Number.isFinite(selectedTime)) return { ok: false, reason: 'review-attempt-time-unmeasured' };
@@ -196,8 +207,77 @@ function lastReviewRecord(text: string): Record<string, unknown> | undefined {
   return undefined;
 }
 
+const OP_WAIVER_DISPOSITIONS = new Set(['already-fixed', 'out-of-scope-followup', 'reviewer-error']);
+
+function canonicalWaiverDisposition(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  if (OP_WAIVER_DISPOSITIONS.has(value)) return value;
+  // These labels occur in OP's saved, approved adjudications; accept only their
+  // narrow semantic aliases while new decisions use the canonical vocabulary.
+  if (value === 'fixed-in-this-head') return 'already-fixed';
+  if (value === 'evidence-provided' || value === 'reviewer-misread-contract') return 'reviewer-error';
+  return undefined;
+}
+
+function opWaiverTestResult(value: unknown, head: string): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const run = value as Record<string, unknown>;
+  if (typeof run.sha !== 'string' || run.sha.toLowerCase() !== head || (run.exit !== undefined && run.exit !== 0)) return false;
+  const hasRunDescription = ['command', 'scope', 'rawOutput'].some((key) => typeof run[key] === 'string' && (run[key] as string).trim());
+  if (!hasRunDescription) return false;
+  let pass = typeof run.pass === 'number' && Number.isSafeInteger(run.pass) ? run.pass : undefined;
+  let fail = typeof run.fail === 'number' && Number.isSafeInteger(run.fail) ? run.fail : undefined;
+  if ((pass === undefined || fail === undefined) && run.tests && typeof run.tests === 'object' && !Array.isArray(run.tests)) {
+    const rows = Object.values(run.tests as Record<string, unknown>);
+    const parsed = rows.map((row) => typeof row === 'string' ? /^(\d+)\/(\d+)$/.exec(row) : null);
+    if (rows.length > 0 && parsed.every(Boolean)) {
+      pass = parsed.reduce((sum, row) => sum + Number(row![1]), 0);
+      fail = parsed.reduce((sum, row) => sum + Number(row![2]), 0);
+    }
+  }
+  return pass !== undefined && pass > 0 && fail === 0;
+}
+
+function validOpWaiver(record: Record<string, unknown> | undefined, pr: number, head: string):
+  | { ok: true; adjudicates: string; findingCount: number }
+  | { ok: false; reason: string } {
+  if (!record || record.reviewer !== 'OP-waiver') return { ok: false, reason: 'review-op-waiver-reviewer' };
+  const waiver = record.waiver;
+  if (!waiver || typeof waiver !== 'object' || Array.isArray(waiver)) return { ok: false, reason: 'review-op-waiver-missing' };
+  const value = waiver as Record<string, unknown>;
+  if (value.by !== 'OP' || typeof value.approvedBy !== 'string' || !value.approvedBy.trim()) {
+    return { ok: false, reason: 'review-op-waiver-approval-missing' };
+  }
+  if (typeof value.adjudicates !== 'string' || !value.adjudicates.trim()) return { ok: false, reason: 'review-op-waiver-adjudication-missing' };
+  if (!opWaiverTestResult(value.headTestRun, head)) return { ok: false, reason: 'review-op-waiver-head-test-missing' };
+  if (!Array.isArray(value.dispositions) || value.dispositions.length === 0) return { ok: false, reason: 'review-op-waiver-dispositions-missing' };
+  const findings = new Set<number>();
+  for (const raw of value.dispositions) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, reason: 'review-op-waiver-disposition-invalid' };
+    const item = raw as Record<string, unknown>;
+    if (!Number.isSafeInteger(item.finding) || (item.finding as number) < 1 || findings.has(item.finding as number)
+      || !canonicalWaiverDisposition(item.disposition)
+      || typeof item.evidence !== 'string' || !item.evidence.trim()) return { ok: false, reason: 'review-op-waiver-disposition-invalid' };
+    if (canonicalWaiverDisposition(item.disposition) === 'out-of-scope-followup'
+      && !/(?:#[1-9]\d*|\b[A-Z][A-Z0-9]+(?:-[A-Z0-9]+)+\b)/.test(item.evidence)) {
+      return { ok: false, reason: 'review-op-waiver-followup-missing' };
+    }
+    findings.add(item.finding as number);
+  }
+  const ordered = [...findings].sort((a, b) => a - b);
+  if (ordered.some((finding, index) => finding !== index + 1)) return { ok: false, reason: 'review-op-waiver-findings-incomplete' };
+  const recordPr = typeof record.pr === 'number' ? record.pr : Number(record.pr);
+  if (!Number.isSafeInteger(recordPr) || recordPr !== pr) return { ok: false, reason: 'review-op-waiver-pr-mismatch' };
+  return { ok: true, adjudicates: value.adjudicates, findingCount: findings.size };
+}
+
+function adjudicatesReviewFile(adjudicates: string, path: string): boolean {
+  return adjudicates.split(/[\s,;()]+/).includes(basename(path));
+}
+
 function hasResolvedPriorDeclaration(review: Record<string, unknown> | undefined): boolean {
   if (!review) return false;
+  if (review.reviewer === 'OP-waiver' && review.waiver && typeof review.waiver === 'object' && !Array.isArray(review.waiver)) return true;
   const value = review.resolvedPrior;
   if (value === true) return true;
   if (Array.isArray(value) && value.length > 0) return true;
@@ -250,12 +330,18 @@ function reviewAttemptExplicitlyResolved(input: VerifyOverlapEvidenceInput, sele
   let failed: Record<string, unknown> | undefined;
   try { failed = lastReviewRecord(input.readFile(failedPath)); } catch { return false; }
   if (!failed || failed.pr === undefined || String(failed.pr) !== String(input.pr)
-    || (typeof failed.headCommit === 'string' && failed.headCommit.toLowerCase() !== head)
+    || typeof failed.headCommit !== 'string' || failed.headCommit.toLowerCase() !== head
     || (typeof failed.currentHeadCommit === 'string' && failed.currentHeadCommit.toLowerCase() !== head)) return false;
   const rawFindings = findingList(failed.mustFix).map((finding) => finding.trim());
   const findings = rawFindings.map(normalizedFinding);
   if (findings.length === 0) return false;
 
+  const waiver = validOpWaiver(selected, input.pr, head);
+  if (waiver.ok) {
+    if (failed.reviewed !== true || failed.verdict !== 'fail' || rawFindings.length === 0) return false;
+    return adjudicatesReviewFile(waiver.adjudicates, failedPath) && waiver.findingCount === rawFindings.length;
+  }
+
   const declared = selected.resolvedPrior;
   if (declared !== undefined && declared !== false && containsUnresolvedDeclaration(declared)) return false;
   const intentBlocks = [selected.intent, selected.intentBlock, selected.reviewIntent, selected.reviewIntentBlock]
@@ -327,6 +413,15 @@ function reviewAttemptExplicitlyResolved(input: VerifyOverlapEvidenceInput, sele
   return findings.every((finding) => resolvedSet.has(finding));
 }
 
+function reviewAttemptHasExactSameHeadFail(input: VerifyOverlapEvidenceInput, failedPath: string, head: string): boolean {
+  let failed: Record<string, unknown> | undefined;
+  try { failed = lastReviewRecord(input.readFile(failedPath)); } catch { return false; }
+  return Boolean(failed && failed.pr !== undefined && String(failed.pr) === String(input.pr)
+    && failed.reviewed === true && failed.verdict === 'fail'
+    && typeof failed.headCommit === 'string' && failed.headCommit.toLowerCase() === head
+    && findingList(failed.mustFix).length > 0);
+}
+
 type Checked = { ok: false; reason: string; baseTip?: string; gateBase?: string; windowCommits?: number }
   | (OverlapEvidenceVerdict & { ok: true; baseTip?: string });
 
@@ -359,6 +454,10 @@ function checkReview(input: Pick<VerifyOverlapEvidenceInput, 'pr' | 'readFile'>
   // The capture parser projects away model provenance; inspect the same last result-shaped line here.
   const raw = lastReviewRecord(text);
   if (raw) {
+    if (raw.reviewer === 'OP-waiver') {
+      const waiver = validOpWaiver(raw, input.pr, head);
+      if (!waiver.ok) return { ok: false, reason: waiver.reason, baseTip };
+    }
     const actualBackend = typeof raw.actualBackend === 'string' ? raw.actualBackend.trim().toLowerCase() : '';
     const model = typeof raw.model === 'string' ? raw.model.trim().toLowerCase() : '';
     const route = typeof raw.reviewRoute === 'string' ? raw.reviewRoute.trim().toLowerCase() : '';

package/src/cli/pr-land-pod-shadow-job.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { runPodCommand, type RunPodCommandOptions, type PodCommandResult } from '../task-orchestrator/surfaces/pod-command-job.js';
 import { redactSecretText } from '../debug/log.js';
 import type { RootPlanSummary } from './pr-land-heavy-remote.js';
+import type { WarmReuseEvidence, WarmReuseEvidenceByConsumer } from '../task-orchestrator/surfaces/pod-warm-switch.js';
 
 const SHA = /^[0-9a-f]{40}$/i;
 const MARKER = 'ELANOUS_PRLAND_SHADOW';
@@ -107,3 +108,62 @@ export async function runLandingPodShadowJob(input: LandingPodShadowInput, deps:
   const gateRc = Number(match[2]);
   return { measured: true, ok: tscRc === 0 && gateRc === 0, rootPlan, tscRc, gateRc, job: job.job };
 }
+
+/** WARM-REUSE-LAND-CONSUMER-WIRE — land shadow Job 결과 표본(착지쌍·lock·lease·카나리아·그림자 일치). */
+export interface LandingShadowSample {
+  /** shadow Job 이 잰 착지쌍 — 원격 게이트가 잰 head/main 와 정확히 같아야 표본으로 센다. */
+  head: string;
+  main: string;
+  /** shadow Job 이 돈 Pod generation lock — 원값 그대로 대조한다. */
+  lock: string;
+  /** shadow Job 이 lease 를 잡고 끝까지 쟀나. */
+  leaseValid: boolean;
+  /** shadow Job 카나리아(착지 tsc+gate) 통과. */
+  canaryPassed: boolean;
+  /** 같은 착지의 fresh(원격 게이트) 판정과 그림자 비교 일치 — 불일치 표본은 최근 mismatch 로 센다. */
+  agree: boolean;
+}
+
+/** land 소비자 판정 증거 입력 — 최근 창 표본 ⊕ 이번 착지가 기대하는 warm 워커 lock ⊕ 선행 소비자 증거. */
+export interface LandShadowSampleWindow {
+  /** 최근 창 — 마지막 원소가 가장 최근 shadow 결과다. */
+  samples: LandingShadowSample[];
+  /** 이번 착지가 기대하는 warm 워커 lock(현재 Pod generation). */
+  lock: string;
+  /** 선행 소비자(gate-recheck)의 자기 증거 — land 는 이 칸이 live 여야 live 가 될 수 있다(비면 off). */
+  gateRecheck?: WarmReuseEvidence;
+}
+
+/**
+ * WARM-REUSE-LAND-CONSUMER-WIRE — land shadow Job 결과에서 소비자('land') 판정 증거를 만든다.
+ * 판정 본체는 pod-warm-switch.ts `decideWarmReuse` — 이 모듈은 증거의 산지만 담당한다.
+ * 창이 없거나 비면 land 증거 칸이 비어 off 다 — 못 잰 증거는 통과가 아니다.
+ * 원값은 고쳐 읽지 않고 정확히 비교한다(신원 형식 어긋남은 pod-warm-switch 판정이 끊는다).
+ */
+export function buildLandWarmEvidence(
+  window: LandShadowSampleWindow | undefined,
+  expected: { head: string; main: string },
+): WarmReuseEvidenceByConsumer {
+  const evidence: WarmReuseEvidenceByConsumer = window?.gateRecheck ? { 'gate-recheck': window.gateRecheck } : {};
+  if (!window || window.samples.length === 0) return evidence;
+  const latest = window.samples[window.samples.length - 1]!;
+  let consecutiveMatchSamples = 0;
+  for (let index = window.samples.length - 1; index >= 0; index--) {
+    const sample = window.samples[index]!;
+    if (sample.head !== expected.head || sample.main !== expected.main || sample.lock !== window.lock
+      || sample.leaseValid !== true || sample.canaryPassed !== true || sample.agree !== true) break;
+    consecutiveMatchSamples++;
+  }
+  const recentMismatchCount = window.samples.filter((sample) => sample.agree === false).length;
+  return {
+    ...evidence,
+    land: {
+      consecutiveMatchSamples,
+      recentMismatchCount,
+      leaseValid: latest.leaseValid,
+      canaryPassed: latest.canaryPassed,
+      expected: { head: expected.head, main: expected.main, lock: window.lock },
+      worker: { head: latest.head, main: latest.main, lock: latest.lock },
+    },
+  };
+}

package/src/cli/release-checklist-read-cli.ts

@@ -109,8 +109,11 @@ export function collectChecklistEvidenceStages(item: ReturnType<typeof listCheck
       const origin = run('git', ['remote', 'get-url', 'origin']);
       const pinObject = run('git', ['cat-file', '-e', `${pinSha}^{commit}`]);
       const repoUrl = origin.stdout.trim().replace(/^git@github\.com:/i, 'https://github.com/').replace(/\.git$/i, '').replace(/\/$/u, '').toLowerCase();
-      const expectedRepo = 'https://github.com/elanvitalai/elanous';
-      if (repoRoot.status !== 0 || !repoRoot.stdout.trim() || origin.status !== 0 || repoUrl !== expectedRepo || pinObject.status !== 0) {
+      const expectedRepos = new Set([
+        'https://github.com/elanvitalai/elanous',
+        'https://github.com/ElanvitalAI/elanous',
+      ]);
+      if (repoRoot.status !== 0 || !repoRoot.stdout.trim() || origin.status !== 0 || !expectedRepos.has(repoUrl) || pinObject.status !== 0) {
         e3.reason = '현재 git 저장소가 elanous 원본이 아니거나 설치본 pin 객체가 없어 조상 관계를 판정할 수 없다';
       } else {
       const ancestry = run('git', ['merge-base', '--is-ancestor', mergeSha, pinSha]);
@@ -122,11 +125,15 @@ export function collectChecklistEvidenceStages(item: ReturnType<typeof listCheck
     }
   }
 
-  const runId = /\b(run-[a-f0-9]{8}-[a-f0-9-]{27,})\b/i.exec(evidence)?.[1]
-    ?? /\b([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})\b/i.exec(evidence)?.[1];
+  const identityToken = '(?:run-[a-f0-9]{8}-[a-f0-9-]{27,}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}|[a-z0-9][a-z0-9._:-]{2,})';
+  const labelledIdentity = new RegExp(`\\b(runId|missionId|taskId)\\s*[:=]?\\s*(${identityToken})\\b`, 'i').exec(evidence);
+  const runId = labelledIdentity?.[2]
+    ?? /\b(run-[a-f0-9]{8}-[a-f0-9-]{27,}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})\b/i.exec(evidence)?.[1];
+  const identityLabel = labelledIdentity?.[1]?.toLowerCase();
+  const identityField = identityLabel === 'missionid' ? 'missionId' : identityLabel === 'taskid' ? 'taskId' : 'runId';
   const event = /(?:event|이벤트)\s*[:=]\s*([A-Za-z0-9_.:-]+)/iu.exec(evidence)?.[1];
   const verificationCommand = /(?:완료 경계 증거 명령|증거 명령|verification command)\s*[:=]\s*([^\r\n]+)/iu.exec(`${item.title}\n${evidence}`)?.[1]?.trim() ?? null;
-  const e4: ChecklistEvidenceStage = { id: 'E4', state: 'missing', source: null, measuredAt, verificationCommand, reason: '근거에 runId·event·원문 검증 명령이 모두 필요하다' };
+  const e4: ChecklistEvidenceStage = { id: 'E4', state: 'missing', source: null, measuredAt, verificationCommand, reason: '근거에 runId·missionId·taskId 중 하나와 event·원문 검증 명령이 모두 필요하다' };
   if (runId && event && verificationCommand) {
     const logs = run('eln', ['logs', '--grep', runId, '--since', '365d', '--all', '--include-test', '--limit', '1000', '--json'], 30_000);
     if (logs.status !== 0) { e4.state = 'unmeasurable'; e4.reason = `runId 로그 조회 실패${logs.error ? `: ${logs.error}` : ''}`; }
@@ -135,16 +142,19 @@ export function collectChecklistEvidenceStages(item: ReturnType<typeof listCheck
       const truncated = rows.length >= 1000 || rows.some((row) => row._meta && typeof row._meta === 'object' && (row._meta as { limitReached?: unknown }).limitReached === true);
       const observed = rows.some((row) => {
         if (row.event !== event || typeof row.data !== 'string') return false;
-        try { return (JSON.parse(row.data) as { runId?: unknown }).runId === runId; } catch { return false; }
+        try {
+          const data = JSON.parse(row.data) as { runId?: unknown; missionId?: unknown; taskId?: unknown };
+          return data[identityField] === runId;
+        } catch { return false; }
       });
-      e4.source = `eln logs --grep ${runId} --since 365d --all --include-test --limit 1000 --json (event=${event})`;
-      if (observed) { e4.state = 'observed'; e4.reason = `같은 runId의 ${event} 실물 이벤트를 찾았다`; }
+      e4.source = `eln logs --grep ${runId} --since 365d --all --include-test --limit 1000 --json (${identityField}=${runId}, event=${event})`;
+      if (observed) { e4.state = 'observed'; e4.reason = `같은 ${identityField}의 ${event} 실물 이벤트를 찾았다`; }
       else if (truncated) { e4.state = 'unmeasurable'; e4.reason = '로그 결과가 잘려 사건 부재를 판정할 수 없다'; }
-      else { e4.reason = `같은 runId의 ${event} 이벤트가 없다`; }
+      else { e4.reason = `같은 ${identityField}의 ${event} 이벤트가 없다`; }
     }
   }
 
-  const acceptance = /- 완료 경계 실물:([^\r\n]+)/u.exec(item.title)?.[1]?.trim();
+  const acceptance = /^\s*(?:[-*]\s*)?완료 경계 실물\s*:\s*([^\r\n]+)/mu.exec(item.title)?.[1]?.trim();
   const e5Observed = Boolean(acceptance && evidence.includes(acceptance));
   const e5: ChecklistEvidenceStage = { id: 'E5', state: e5Observed ? 'observed' : 'missing', source: 'checklist title/evidence exact acceptance-text comparison', measuredAt,
     reason: e5Observed ? '완료 경계 실물 문구가 기록된 근거와 일치한다' : '완료 경계 실물 문구와 일치하는 근거가 없다' };

package/src/cli/research-cli.ts

@@ -1,12 +1,11 @@
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { isLiveDetailOn } from '../live/detail-switch.js';
-import { dispatchOmniSearch } from '../skills/tools/omni-search.js';
-import { getAvailableWebSearchProviders } from '../web-search/index.js';
+import { dispatchResearchOmniSearch, getAvailableResearchSearchEngineIds } from '../skills/tools/omni-search.js';
 
 export interface ResearchCliDeps {
   readonly out?: { log: (line: string) => void; error: (line: string) => void };
-  readonly search?: typeof dispatchOmniSearch;
+  readonly search?: typeof dispatchResearchOmniSearch;
   readonly availableEngines?: () => string[];
   readonly maxDetailOn?: (runId?: string) => boolean;
   readonly log?: typeof debug.log;
@@ -23,7 +22,7 @@ export function registerResearchCommand(program: Command, deps: ResearchCliDeps
       const query = parts.join(' ').trim();
       const limit = Number(opts.limit);
       const engines = opts.engines?.split(',').map(id => id.trim()).filter(Boolean);
-      const available = (deps.availableEngines ?? (() => getAvailableWebSearchProviders().map(p => p.id)))();
+      const available = (deps.availableEngines ?? getAvailableResearchSearchEngineIds)();
       const unknown = engines?.filter(id => !available.some(p => p.toLowerCase() === id.toLowerCase())) ?? [];
       if (!query || !Number.isInteger(limit) || limit < 1 || limit > 20 || (opts.engines !== undefined && !engines?.length) || unknown.length) {
         out.error(unknown.length ? `research: 사용할 수 없는 엔진: ${unknown.join(', ')} (사용 가능: ${available.join(', ') || '없음'})`
@@ -41,7 +40,7 @@ export function registerResearchCommand(program: Command, deps: ResearchCliDeps
       if (!wanted.length) log('research.query', 'query', { query, engines: [], limit });
       for (const engine of wanted) log('research.query', 'query', { query, engine, limit });
       try {
-        const result = await (deps.search ?? dispatchOmniSearch)({ query, ...(engines?.length ? { engines } : {}), limit }, {
+        const result = await (deps.search ?? dispatchResearchOmniSearch)({ query, ...(engines?.length ? { engines } : {}), limit }, {
           onEngine: event => {
             if (event.phase === 'complete') log('research.result', 'result', { query, engine: event.engine, hits: event.hits, durationMs: event.durationMs, ...(event.error ? { error: event.error } : {}) });
           },

package/src/cli/tasks-cli.ts

@@ -66,6 +66,10 @@ export interface TasksCliDeps {
   taskStatePath?: string;
   /** 조합 선택 시험에서만 그래프 저장소 루트를 바꾼다. */
   taskCompositionRoot?: string;
+  /** COORD-ENTRANCE-FOLD test seam; production uses the invoking repository root. */
+  coordinatorShadowRoot?: string;
+  /** Deterministic task-hand time in isolated tests. */
+  taskNow?: () => Date;
   /** DRAFT-CLAIM-AUTO-2-FU — `tasks hand --draft-claim <pr>` 의 관측·게시·수확 리뷰 포트(시험 주입). 기본 = `defaultDraftClaimGhPorts()`(gh CLI ⊕ 생산 리뷰 러너). */
   draftClaimGh?: DraftClaimGhPorts;
   /** logs.db 싱크 등록(시험 주입). 기본 = `registerStandaloneLogSink`. `hand`·`show` 가 부른다. */
@@ -2336,6 +2340,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         }
         const handOpts = {
           text: resolved.text,
+          ...(resolved.kind === 'work-order' ? { workOrder: resolved.order } : {}),
+          ...(deps.coordinatorShadowRoot ? { coordinatorShadowRoot: deps.coordinatorShadowRoot } : {}),
+          ...(deps.taskNow ? { now: deps.taskNow } : {}),
           ...(opts.project !== undefined && opts.target !== undefined ? { project: { id: opts.project, target: opts.target } } : {}),
           ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
           ...(opts.milestone !== undefined ? { milestone: opts.milestone } : {}),

package/src/compact/auto.ts

@@ -31,8 +31,15 @@ export function shouldAutoCompact(
   messages: MessageLike[],
   modelId: string | undefined,
   config: ChatAutoCompactConfig,
+  observedInputTokens?: number,
 ): AutoCompactDecision {
-  const usedTokens = estimateMessagesTokens(messages);
+  const hasObservedInputTokens = typeof observedInputTokens === 'number'
+    && Number.isFinite(observedInputTokens)
+    && observedInputTokens >= 0;
+  const estimatedTokens = estimateMessagesTokens(messages);
+  // Provider usage captures model/tokenizer overhead; current history also
+  // includes tool output appended since that provider response.
+  const usedTokens = hasObservedInputTokens ? Math.max(observedInputTokens, estimatedTokens) : estimatedTokens;
   const windowTokens = resolveModelContextWindow(modelId) ?? inferContextWindow(modelId);
   const configuredBudget = config.workingBudgetTokens;
   const budgetTokens = typeof configuredBudget === 'number'

package/src/control-plane/ledger.ts

@@ -20,7 +20,7 @@ export interface ResourceRecord {
 export type ResourceView = ResourceRecord & { ageMs: number; expired: boolean };
 
 export interface PodWorkerKey { context: string; imageDigest: string; lockHash: string; architecture: string }
-type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'quarantined';
+type PodWorkerState = 'idle' | 'leased' | 'sanitizing' | 'timeout-fenced' | 'quarantined';
 interface PodWorkerLeaseAttrs {
   key: PodWorkerKey;
   podUid: string;
@@ -32,6 +32,9 @@ interface PodWorkerLeaseAttrs {
   /** The just-sanitized generation remains fenceable until the next acquisition. */
   lastLeaseId?: string;
   lastLeaseOwner?: string;
+  timeoutFenceUntil?: number;
+  timeoutRunId?: string;
+  timeoutAttemptId?: string;
   runId?: string;
   attemptId?: string;
   reason?: string;
@@ -231,17 +234,35 @@ export class ResourceLedger {
     return this.mutate(() => {
     const at = now ?? Date.now();
     const rows = this.read();
+    let expiredFenceChanged = false;
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      const candidate = rows[rowIndex]!;
+      if (candidate.kind !== 'pod-worker-lease') continue;
+      const candidateAttrs = workerAttrs(candidate);
+      if (candidateAttrs.state !== 'timeout-fenced' || candidateAttrs.timeoutFenceUntil === undefined
+        || candidateAttrs.timeoutFenceUntil > at || candidateAttrs.leaseId) continue;
+      const idleAttrs: PodWorkerLeaseAttrs = { ...candidateAttrs, state: 'idle' };
+      delete idleAttrs.leaseId; delete idleAttrs.leaseOwner; delete idleAttrs.runId; delete idleAttrs.attemptId;
+      delete idleAttrs.timeoutFenceUntil; delete idleAttrs.timeoutRunId; delete idleAttrs.timeoutAttemptId;
+      rows[rowIndex] = { ...candidate, attrs: idleAttrs as unknown as Record<string, unknown>, observedAt: at,
+        ttlMs: candidateAttrs.idleTtlMs };
+      expiredFenceChanged = true;
+    }
     const index = rows.findIndex(row => row.kind === 'pod-worker-lease' && (!request.machine || row.machine === request.machine)
       && Math.max(0, at - row.observedAt) < row.ttlMs && workerAttrs(row).state === 'idle'
       && typeof workerAttrs(row).podUid === 'string' && workerAttrs(row).podUid.trim().length > 0
       && sameWorkerKey(workerAttrs(row).key, request.key));
-    if (index < 0) throw new ResourceLedgerError(409, 'no-warm-worker');
+    if (index < 0) {
+      if (expiredFenceChanged) this.write(rows);
+      throw new ResourceLedgerError(409, 'no-warm-worker');
+    }
     const row = rows[index]!;
     const attrs = workerAttrs(row);
     const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state: 'leased', generation: attrs.generation + 1,
       leaseId: randomUUID(), leaseOwner: request.owner, runId: request.runId, attemptId: request.attemptId };
     delete nextAttrs.lastLeaseId;
     delete nextAttrs.lastLeaseOwner;
+    delete nextAttrs.timeoutFenceUntil; delete nextAttrs.timeoutRunId; delete nextAttrs.timeoutAttemptId;
     const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>,
       observedAt: at, ttlMs: request.ttlMs };
     rows[index] = next;
@@ -250,6 +271,31 @@ export class ResourceLedger {
     });
   }
 
+  fenceTimedOutPodWorker(id: string, request: { owner: string; runId: string; attemptId: string; fenceMs: number }, now?: number): ResourceRecord {
+    return this.mutate(() => {
+      const at = now ?? Date.now();
+      const rows = this.read();
+      const index = rows.findIndex(row => row.id === id && row.kind === 'pod-worker-lease');
+      if (index < 0) throw new ResourceLedgerError(404, 'not-found');
+      const row = rows[index]!;
+      const attrs = workerAttrs(row);
+      const sameFence = attrs.state === 'timeout-fenced' && attrs.timeoutRunId === request.runId
+        && attrs.timeoutAttemptId === request.attemptId;
+      const sameLease = attrs.state === 'leased' && attrs.leaseOwner === request.owner
+        && attrs.runId === request.runId && attrs.attemptId === request.attemptId;
+      const available = attrs.state === 'idle';
+      if (!request.owner || !request.runId || !request.attemptId || !Number.isSafeInteger(request.fenceMs)
+        || request.fenceMs < 1 || !(sameFence || sameLease || available))
+        throw new ResourceLedgerError(409, 'stale-timeout-fence');
+      const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state: 'timeout-fenced',
+        timeoutFenceUntil: at + request.fenceMs, timeoutRunId: request.runId, timeoutAttemptId: request.attemptId };
+      const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: at };
+      rows[index] = next;
+      this.write(rows);
+      return next;
+    });
+  }
+
   transitionPodWorker(id: string, request: { owner: string; leaseId: string; generation: number; action: 'renew' | 'release' | 'sanitize' | 'quarantine'; ttlMs?: number; reason?: string }, now?: number): ResourceRecord {
     return this.mutate(() => {
     now ??= Date.now();
@@ -260,11 +306,14 @@ export class ResourceLedger {
     const attrs = workerAttrs(row);
     const lateIdleQuarantine = request.action === 'quarantine' && attrs.state === 'idle'
       && attrs.lastLeaseId === request.leaseId && attrs.generation === request.generation;
+    const timeoutFencedQuarantine = request.action === 'quarantine' && attrs.state === 'timeout-fenced'
+      && attrs.leaseId === request.leaseId && attrs.generation === request.generation;
     if (!request.leaseId || (attrs.leaseId !== request.leaseId && !lateIdleQuarantine)
       || attrs.generation !== request.generation) throw new ResourceLedgerError(409, 'stale-worker-lease');
     const permitted = request.action === 'sanitize' ? row.owner === request.owner
       : request.action === 'quarantine' ? row.owner === request.owner || attrs.leaseOwner === request.owner
         || (lateIdleQuarantine && attrs.lastLeaseOwner === request.owner)
+        || (timeoutFencedQuarantine && attrs.leaseOwner === request.owner)
       : attrs.leaseOwner === request.owner;
     if (!permitted) {
       throw new ResourceLedgerError(403, 'not-owner');
@@ -283,6 +332,7 @@ export class ResourceLedger {
     } else if (state === 'quarantined') {
       delete nextAttrs.lastLeaseId;
       delete nextAttrs.lastLeaseOwner;
+      delete nextAttrs.timeoutFenceUntil; delete nextAttrs.timeoutRunId; delete nextAttrs.timeoutAttemptId;
     }
     const ttlMs = state === 'idle' ? attrs.idleTtlMs : request.ttlMs ?? row.ttlMs;
     const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: now, ttlMs };

package/src/control-plane/server.ts

@@ -10,6 +10,7 @@ import type { LeaseHolderView } from './lease-holder.js';
 export const DEFAULT_CONTROL_PORT = PORT_BANDS.reserved[0];
 export const CONTROL_HOSTNAME = '127.0.0.1';
 const MAX_POD_WORKER_TTL_MS = 24 * 60 * 60 * 1000;
+const POD_WORKER_TIMEOUT_FENCE_MS = 150_000;
 
 export function allowedControlHostname(hostname: string): boolean {
   if (hostname === '127.0.0.1' || hostname === '::1') return true;
@@ -126,7 +127,7 @@ export function startControlServer(opts: ControlServerOptions = {}): {
         const leaseRenewal = /^\/v1\/leases\/port\/([^/]+)\/heartbeat$/.exec(path);
         const workerRegister = path === '/v1/workers/pod' && method === 'POST';
         const workerAcquire = path === '/v1/leases/pod-worker' && method === 'POST';
-        const workerTransition = /^\/v1\/leases\/pod-worker\/([^/]+)\/(renew|release|sanitize|quarantine)$/.exec(path);
+        const workerTransition = /^\/v1\/leases\/pod-worker\/([^/]+)\/(renew|release|sanitize|quarantine|timeout)$/.exec(path);
         if (!resourcePath && !registerPath && !leaseRequest && !workerRegister && !workerAcquire && !(workerTransition && method === 'POST') && !(leaseDeletion && method === 'DELETE') && !(leaseRenewal && method === 'POST') && !(heartbeat && method === 'POST') && !(deletion && method === 'DELETE')) {
           return json({ error: 'not-found' }, 404);
         }
@@ -191,7 +192,20 @@ export function startControlServer(opts: ControlServerOptions = {}): {
           if (workerTransition) {
             const workerId = decodeURIComponent(workerTransition[1]!);
             if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,95}$/.test(workerId)) throw new ResourceLedgerError(400, 'invalid-worker-id');
-            const action = workerTransition[2] as 'renew' | 'release' | 'sanitize' | 'quarantine';
+            const action = workerTransition[2] as 'renew' | 'release' | 'sanitize' | 'quarantine' | 'timeout';
+            if (action === 'timeout') {
+              if (scope !== 'member') throw new ResourceLedgerError(403, 'worker-timeout-scope');
+              const body = podWorkerBody(await req.json());
+              const { runId, attemptId } = body;
+              if (typeof runId !== 'string' || !runId.trim() || typeof attemptId !== 'string' || !attemptId.trim())
+                throw new ResourceLedgerError(400, 'invalid-pod-worker-timeout');
+              const id = `pod-worker-lease:${workerId}`;
+              requireTarget(id);
+              const stale = await currentWorkerPrimary();
+              if (stale) return stale;
+              return json(await ledger.withGuardedWorkerMutation(async () => !(await currentWorkerPrimary()),
+                () => ledger.fenceTimedOutPodWorker(id, { owner, runId, attemptId, fenceMs: POD_WORKER_TIMEOUT_FENCE_MS })));
+            }
             if (action === 'sanitize' ? !machine : (action === 'renew' || action === 'release') && scope !== 'member') {
               throw new ResourceLedgerError(403, 'worker-scope');
             }