@kbediako/codex-orchestrator 0.1.38 → 0.2.0

package/dist/scripts/lib/review-execution-state.js

@@ -0,0 +1,1144 @@
+import { ARCHITECTURE_CONTEXT_META_SURFACE_KIND, isTouchedScopePath, normalizeActiveCloseoutBundleRoot, normalizeAuditMetaSurfaceEnvVarPathMap, normalizeAuditStartupAnchorPath, normalizeScopePath, normalizeScopeRoot } from './review-meta-surface-normalization.js';
+import { classifyShellProbeCommandLine, detectHeavyReviewCommand, isLikelyReviewCommandLine } from './review-command-probe-classification.js';
+import { classifyCommandIntentCommandLine, classifyCommandIntentToolLine, formatCommandIntentViolationLabel } from './review-command-intent-classification.js';
+import { extractInspectionTargets } from './review-inspection-target-parsing.js';
+import { REVIEW_ACTIVE_CLOSEOUT_BUNDLE_KIND, analyzeStartupAnchorBoundaryProgress, classifyMetaSurfaceCommandLine, classifyMetaSurfaceOutputLine, classifyMetaSurfaceToolLine } from './review-meta-surface-boundary-analysis.js';
+import { buildReviewTelemetryPayload, inferTerminationBoundaryKindsFromErrorMessage, } from './review-execution-telemetry.js';
+const REVIEW_DELEGATION_STARTUP_LINE_RE = /\bmcp:\s*delegation\s+(starting|ready)\b/i;
+const REVIEW_PROGRESS_SIGNAL_LINE_RE = /^(thinking|exec|codex)\b/i;
+const DEFAULT_REVIEW_OUTPUT_PREVIEW_LIMIT = 32_768;
+const DEFAULT_REVIEW_OUTPUT_SUMMARY_TAIL_LINE_LIMIT = 20;
+const DEFAULT_REVIEW_OUTPUT_SUMMARY_HEAVY_COMMAND_LIMIT = 8;
+const DEFAULT_REVIEW_OUTPUT_SUMMARY_COMMAND_LIMIT = 64;
+const DEFAULT_LOW_SIGNAL_TIMEOUT_MS = 180_000;
+const DEFAULT_VERDICT_STABILITY_TIMEOUT_MS = 180_000;
+const DEFAULT_META_SURFACE_TIMEOUT_MS = 180_000;
+const RELEVANT_REINSPECTION_MIN_COMMAND_STARTS = 8;
+const RELEVANT_REINSPECTION_BASE_MAX_DISTINCT_TARGETS = 4;
+const RELEVANT_REINSPECTION_MIN_REPEAT_TARGET_HITS = 3;
+const STARTUP_ANCHOR_META_SURFACE_SIGNAL_BUDGET = 1;
+const STARTUP_ANCHOR_ALLOWED_META_SURFACE_KINDS = new Set(['review-support']);
+export const ARCHITECTURE_ALLOWED_META_SURFACE_KINDS = [
+    ARCHITECTURE_CONTEXT_META_SURFACE_KIND,
+    'review-support',
+    'review-docs'
+];
+export const AUDIT_ALLOWED_META_SURFACE_KINDS = ['run-manifest', 'run-runner-log'];
+const ALLOWED_META_SURFACE_KIND_SET = new Set([
+    ...AUDIT_ALLOWED_META_SURFACE_KINDS,
+    ...ARCHITECTURE_ALLOWED_META_SURFACE_KINDS
+]);
+const COMMAND_LEVEL_ALLOWED_META_SURFACE_KIND_SET = new Set(ARCHITECTURE_ALLOWED_META_SURFACE_KINDS);
+const LOW_SIGNAL_MIN_THINKING_BLOCKS = 10;
+const LOW_SIGNAL_MIN_COMMAND_STARTS = 10;
+const LOW_SIGNAL_MAX_DISTINCT_TARGETS = 4;
+const LOW_SIGNAL_MIN_REPEAT_TARGET_HITS = 3;
+const LOW_SIGNAL_MIN_REPEAT_SIGNATURE_HITS = 4;
+const LOW_SIGNAL_RECENT_COMMAND_WINDOW = LOW_SIGNAL_MIN_COMMAND_STARTS;
+const VERDICT_STABILITY_MIN_THINKING_BLOCKS = 4;
+const VERDICT_STABILITY_MIN_COMMAND_STARTS = 4;
+const VERDICT_STABILITY_MIN_OUTPUT_TARGET_SIGNALS = 4;
+const VERDICT_STABILITY_MIN_OUTPUT_NARRATIVE_SIGNALS = 4;
+const VERDICT_STABILITY_MAX_DISTINCT_OUTPUT_TARGETS = 4;
+const VERDICT_STABILITY_MAX_DISTINCT_OUTPUT_SIGNATURES = 8;
+const VERDICT_STABILITY_MIN_REPEAT_OUTPUT_TARGET_HITS = 2;
+const VERDICT_STABILITY_MIN_REPEAT_OUTPUT_SIGNATURE_HITS = 2;
+const VERDICT_STABILITY_RECENT_OUTPUT_WINDOW = 16;
+const META_SURFACE_MIN_COMMAND_STARTS = 6;
+const META_SURFACE_MIN_SIGNALS = 4;
+const META_SURFACE_MIN_DISTINCT_SURFACES = 3;
+const META_SURFACE_MIN_REPEAT_HITS = 2;
+const META_SURFACE_RECENT_SIGNAL_WINDOW = 8;
+const REVIEW_NARRATIVE_INSPECTION_MIN_LINE_LENGTH = 32;
+const REVIEW_SPECULATIVE_NARRATIVE_LINE_RE = /^(?:I\b|I['’]m\b|It\s+(?:might|may|seems|feels)\b|Maybe\b|Perhaps\b)/iu;
+const REVIEW_COMMAND_INTENT_VIOLATION_SAMPLE_LIMIT = 8;
+export class ReviewExecutionState {
+    startedAtMs;
+    blockHeavyCommands;
+    allowValidationCommandIntents;
+    activeCloseoutBundleRoots;
+    previewLimit;
+    tailLineLimit;
+    heavyCommandLimit;
+    commandLimit;
+    lowSignalTimeoutMs;
+    verdictStabilityTimeoutMs;
+    metaSurfaceTimeoutMs;
+    allowedMetaSurfaceKinds;
+    touchedPaths;
+    enforceStartupAnchorBoundary;
+    enforceActiveCloseoutBundleRereadBoundary;
+    enforceRelevantReinspectionDwellBoundary;
+    startupAnchorScopeMode;
+    startupAnchorMode;
+    repoRoot;
+    auditStartupAnchorPaths;
+    auditStartupAnchorEnvVarPaths;
+    allowedMetaSurfacePaths;
+    allowedMetaSurfaceEnvVarPaths;
+    lastOutputAtMs;
+    preview = '';
+    lineCount = 0;
+    completionCount = 0;
+    startupEvents = 0;
+    reviewProgressSignals = 0;
+    thinkingBlocks = 0;
+    reviewProgressObserved = false;
+    startupAnchorObserved = false;
+    awaitingCommandLine = false;
+    blockedHeavyCommand = null;
+    lowSignalCandidateSinceMs = null;
+    verdictStabilityCandidateSinceMs = null;
+    metaSurfaceCandidateSinceMs = null;
+    relevantReinspectionDwellCandidateSinceMs = null;
+    startupAnchorViolationAtMs = null;
+    preAnchorCommandStarts = 0;
+    commandStarts = [];
+    heavyCommandStarts = [];
+    recentInspectionTargetSamples = [];
+    recentInspectionSignatures = [];
+    recentOutputInspectionTargetSamples = [];
+    recentOutputNarrativeSignatures = [];
+    recentConcreteOutputTargetSamples = [];
+    recentMetaSurfaceSamples = [];
+    preAnchorMetaSurfaceSamples = [];
+    commandIntentViolationSamples = [];
+    shellProbeSamples = [];
+    lastLines = [];
+    pendingFragmentsByStream = {
+        stdout: '',
+        stderr: ''
+    };
+    commandIntentViolation = null;
+    shellProbeViolation = null;
+    activeCloseoutBundleRereadViolation = null;
+    relevantReinspectionDwellViolation = null;
+    activeCloseoutBundleRereadCount = 0;
+    shellProbeCount = 0;
+    lastInspectionCommandLine = null;
+    constructor(options = {}) {
+        this.startedAtMs = options.startedAtMs ?? Date.now();
+        this.lastOutputAtMs = this.startedAtMs;
+        this.blockHeavyCommands = options.blockHeavyCommands ?? false;
+        this.allowValidationCommandIntents = options.allowValidationCommandIntents ?? false;
+        this.previewLimit = options.previewLimit ?? DEFAULT_REVIEW_OUTPUT_PREVIEW_LIMIT;
+        this.tailLineLimit = options.tailLineLimit ?? DEFAULT_REVIEW_OUTPUT_SUMMARY_TAIL_LINE_LIMIT;
+        this.heavyCommandLimit =
+            options.heavyCommandLimit ?? DEFAULT_REVIEW_OUTPUT_SUMMARY_HEAVY_COMMAND_LIMIT;
+        this.commandLimit = options.commandLimit ?? DEFAULT_REVIEW_OUTPUT_SUMMARY_COMMAND_LIMIT;
+        const configuredLowSignalTimeoutMs = options.lowSignalTimeoutMs;
+        this.lowSignalTimeoutMs =
+            configuredLowSignalTimeoutMs === undefined
+                ? DEFAULT_LOW_SIGNAL_TIMEOUT_MS
+                : configuredLowSignalTimeoutMs === null || configuredLowSignalTimeoutMs <= 0
+                    ? null
+                    : configuredLowSignalTimeoutMs;
+        const configuredVerdictStabilityTimeoutMs = options.verdictStabilityTimeoutMs;
+        this.verdictStabilityTimeoutMs =
+            configuredVerdictStabilityTimeoutMs === undefined
+                ? DEFAULT_VERDICT_STABILITY_TIMEOUT_MS
+                : configuredVerdictStabilityTimeoutMs === null || configuredVerdictStabilityTimeoutMs <= 0
+                    ? null
+                    : configuredVerdictStabilityTimeoutMs;
+        const configuredMetaSurfaceTimeoutMs = options.metaSurfaceTimeoutMs;
+        this.metaSurfaceTimeoutMs =
+            configuredMetaSurfaceTimeoutMs === undefined
+                ? DEFAULT_META_SURFACE_TIMEOUT_MS
+                : configuredMetaSurfaceTimeoutMs === null || configuredMetaSurfaceTimeoutMs <= 0
+                    ? null
+                    : configuredMetaSurfaceTimeoutMs;
+        this.allowedMetaSurfaceKinds = new Set((options.allowedMetaSurfaceKinds ?? []).filter((kind) => ALLOWED_META_SURFACE_KIND_SET.has(kind)));
+        this.repoRoot = normalizeScopeRoot(options.repoRoot);
+        this.touchedPaths = new Set((options.touchedPaths ?? []).map((entry) => normalizeScopePath(entry)).filter(Boolean));
+        this.activeCloseoutBundleRoots = new Set((options.activeCloseoutBundleRoots ?? [])
+            .map((entry) => normalizeActiveCloseoutBundleRoot(entry, this.repoRoot))
+            .filter((entry) => Boolean(entry)));
+        this.startupAnchorMode = options.startupAnchorMode ?? null;
+        this.auditStartupAnchorPaths = new Set((options.auditStartupAnchorPaths ?? [])
+            .map((entry) => normalizeAuditStartupAnchorPath(entry, this.repoRoot))
+            .filter((entry) => Boolean(entry)));
+        this.auditStartupAnchorEnvVarPaths = normalizeAuditMetaSurfaceEnvVarPathMap(options.auditStartupAnchorEnvVarPaths, this.repoRoot);
+        this.allowedMetaSurfacePaths = new Set((options.allowedMetaSurfacePaths ?? [])
+            .map((entry) => normalizeAuditStartupAnchorPath(entry, this.repoRoot))
+            .filter((entry) => Boolean(entry)));
+        this.allowedMetaSurfaceEnvVarPaths = normalizeAuditMetaSurfaceEnvVarPathMap(options.allowedMetaSurfaceEnvVarPaths, this.repoRoot);
+        this.enforceStartupAnchorBoundary =
+            (options.enforceStartupAnchorBoundary ?? false) &&
+                (this.startupAnchorMode === 'audit' || this.touchedPaths.size > 0);
+        this.enforceActiveCloseoutBundleRereadBoundary =
+            (options.enforceActiveCloseoutBundleRereadBoundary ?? this.enforceStartupAnchorBoundary) &&
+                this.activeCloseoutBundleRoots.size > 0;
+        this.enforceRelevantReinspectionDwellBoundary =
+            (options.enforceRelevantReinspectionDwellBoundary ?? this.enforceStartupAnchorBoundary) &&
+                this.touchedPaths.size > 0;
+        this.startupAnchorScopeMode = options.scopeMode ?? 'uncommitted';
+    }
+    observeChunk(chunk, stream, nowMs = Date.now()) {
+        const next = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk;
+        this.lastOutputAtMs = nowMs;
+        if (this.preview.length < this.previewLimit) {
+            this.preview = `${this.preview}${next}`.slice(0, this.previewLimit);
+        }
+        const combined = `${this.pendingFragmentsByStream[stream]}${next}`;
+        const lines = combined.split(/\r?\n/u);
+        this.pendingFragmentsByStream[stream] = lines.pop() ?? '';
+        for (const line of lines) {
+            this.processLine(line, nowMs);
+        }
+    }
+    getPreview() {
+        return this.preview;
+    }
+    getBlockedHeavyCommand() {
+        return this.blockedHeavyCommand;
+    }
+    getLastOutputAtMs() {
+        return this.lastOutputAtMs;
+    }
+    getStartupLoopState() {
+        return {
+            startupEvents: this.startupEvents,
+            reviewProgressObserved: this.reviewProgressObserved
+        };
+    }
+    buildOutputSummary() {
+        const inspectionTargetSummary = this.buildInspectionTargetSummary();
+        const outputNarrativeSummary = this.buildOutputNarrativeSummary();
+        const preAnchorMetaSurfaceSummary = this.buildPreAnchorMetaSurfaceSummary();
+        return {
+            lineCount: this.lineCount,
+            commandStarts: [...this.commandStarts],
+            completionCount: this.completionCount,
+            startupEvents: this.startupEvents,
+            reviewProgressSignals: this.reviewProgressSignals,
+            thinkingBlocks: this.thinkingBlocks,
+            heavyCommandStarts: [...this.heavyCommandStarts],
+            distinctInspectionTargets: inspectionTargetSummary.distinctTargets,
+            maxInspectionTargetHits: inspectionTargetSummary.maxHits,
+            distinctInspectionSignatures: inspectionTargetSummary.distinctSignatures,
+            maxInspectionSignatureHits: inspectionTargetSummary.maxSignatureHits,
+            outputInspectionSignals: outputNarrativeSummary.outputInspectionSignals,
+            outputNarrativeSignals: outputNarrativeSummary.outputNarrativeSignals,
+            concreteOutputSignals: outputNarrativeSummary.concreteOutputSignals,
+            distinctOutputInspectionTargets: outputNarrativeSummary.distinctOutputTargets,
+            maxOutputInspectionTargetHits: outputNarrativeSummary.maxOutputTargetHits,
+            distinctOutputNarrativeSignatures: outputNarrativeSummary.distinctNarrativeSignatures,
+            maxOutputNarrativeSignatureHits: outputNarrativeSummary.maxNarrativeSignatureHits,
+            metaSurfaceSignals: inspectionTargetSummary.metaSurfaceSignals,
+            distinctMetaSurfaces: inspectionTargetSummary.distinctMetaSurfaces,
+            maxMetaSurfaceHits: inspectionTargetSummary.maxMetaSurfaceHits,
+            metaSurfaceKinds: inspectionTargetSummary.metaSurfaceKinds,
+            startupAnchorObserved: this.startupAnchorObserved,
+            preAnchorCommandStarts: this.preAnchorCommandStarts,
+            preAnchorMetaSurfaceSignals: preAnchorMetaSurfaceSummary.signals,
+            preAnchorDistinctMetaSurfaces: preAnchorMetaSurfaceSummary.distinctSurfaces,
+            preAnchorMetaSurfaceKinds: preAnchorMetaSurfaceSummary.kinds,
+            commandIntentViolationCount: this.commandIntentViolationSamples.length,
+            commandIntentViolationKinds: [
+                ...new Set(this.commandIntentViolationSamples.map((sample) => sample.kind))
+            ].sort(),
+            commandIntentViolationSamples: this.commandIntentViolationSamples.map((sample) => `[${sample.kind}] ${sample.sample}`),
+            shellProbeCount: this.shellProbeCount,
+            lastLines: [...this.lastLines]
+        };
+    }
+    getLowSignalDriftState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const triggered = this.lowSignalTimeoutMs !== null &&
+            this.lowSignalCandidateSinceMs !== null &&
+            Math.max(0, nowMs - this.lowSignalCandidateSinceMs) >= this.lowSignalTimeoutMs;
+        return {
+            triggered,
+            reason: triggered
+                ? `low-signal review drift detected after ${formatDurationMs(Math.max(0, nowMs - this.startedAtMs))}: ${this.thinkingBlocks} thinking blocks, ${this.commandStarts.length} command starts, ${summary.distinctInspectionTargets} repeated inspection targets (max hit count ${summary.maxInspectionTargetHits}), ${summary.distinctInspectionSignatures} repeated inspection signatures (max hit count ${summary.maxInspectionSignatureHits}), sustained for ${formatDurationMs(Math.max(0, nowMs - this.lowSignalCandidateSinceMs))}.`
+                : null,
+            thinkingBlocks: this.thinkingBlocks,
+            commandStarts: this.commandStarts.length,
+            distinctInspectionTargets: summary.distinctInspectionTargets,
+            maxInspectionTargetHits: summary.maxInspectionTargetHits,
+            distinctInspectionSignatures: summary.distinctInspectionSignatures,
+            maxInspectionSignatureHits: summary.maxInspectionSignatureHits,
+            timeoutMs: this.lowSignalTimeoutMs
+        };
+    }
+    getVerdictStabilityState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const triggered = this.verdictStabilityTimeoutMs !== null &&
+            this.verdictStabilityCandidateSinceMs !== null &&
+            Math.max(0, nowMs - this.verdictStabilityCandidateSinceMs) >=
+                this.verdictStabilityTimeoutMs;
+        return {
+            triggered,
+            reason: triggered
+                ? summary.distinctOutputInspectionTargets > 0
+                    ? `bounded review verdict-stability drift detected after ${formatDurationMs(Math.max(0, nowMs - this.startedAtMs))}: ${this.thinkingBlocks} thinking blocks, ${this.commandStarts.length} command starts, ${summary.outputInspectionSignals} repeated output inspection signals across ${summary.distinctOutputInspectionTargets} target(s) (max hit count ${summary.maxOutputInspectionTargetHits}), ${summary.distinctOutputNarrativeSignatures} repeated narrative signature(s) (max hit count ${summary.maxOutputNarrativeSignatureHits}), sustained for ${formatDurationMs(Math.max(0, nowMs - this.verdictStabilityCandidateSinceMs))}.`
+                    : `bounded review verdict-stability drift detected after ${formatDurationMs(Math.max(0, nowMs - this.startedAtMs))}: ${this.thinkingBlocks} thinking blocks, ${this.commandStarts.length} command starts, ${summary.outputNarrativeSignals} repeated speculative narrative signal(s) with no concrete output targets, ${summary.distinctOutputNarrativeSignatures} repeated narrative signature(s) (max hit count ${summary.maxOutputNarrativeSignatureHits}), sustained for ${formatDurationMs(Math.max(0, nowMs - this.verdictStabilityCandidateSinceMs))}.`
+                : null,
+            thinkingBlocks: this.thinkingBlocks,
+            commandStarts: this.commandStarts.length,
+            outputInspectionSignals: summary.outputInspectionSignals,
+            outputNarrativeSignals: summary.outputNarrativeSignals,
+            concreteOutputSignals: summary.concreteOutputSignals,
+            distinctOutputInspectionTargets: summary.distinctOutputInspectionTargets,
+            maxOutputInspectionTargetHits: summary.maxOutputInspectionTargetHits,
+            distinctOutputNarrativeSignatures: summary.distinctOutputNarrativeSignatures,
+            maxOutputNarrativeSignatureHits: summary.maxOutputNarrativeSignatureHits,
+            timeoutMs: this.verdictStabilityTimeoutMs
+        };
+    }
+    getMetaSurfaceExpansionState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const activeCloseoutBundleRereadTriggered = this.enforceActiveCloseoutBundleRereadBoundary &&
+            this.activeCloseoutBundleRereadViolation !== null;
+        const triggered = !activeCloseoutBundleRereadTriggered &&
+            this.metaSurfaceTimeoutMs !== null &&
+            this.metaSurfaceCandidateSinceMs !== null &&
+            Math.max(0, nowMs - this.metaSurfaceCandidateSinceMs) >= this.metaSurfaceTimeoutMs;
+        return {
+            triggered,
+            reason: triggered
+                ? `bounded review meta-surface expansion detected after ${formatDurationMs(Math.max(0, nowMs - this.startedAtMs))}: ${this.commandStarts.length} command starts, ${summary.metaSurfaceSignals} meta-surface signals, ${summary.distinctMetaSurfaces} distinct meta-surfaces [${summary.metaSurfaceKinds.join(', ')}] (max hit count ${summary.maxMetaSurfaceHits}), sustained for ${formatDurationMs(Math.max(0, nowMs - this.metaSurfaceCandidateSinceMs))}.`
+                : null,
+            commandStarts: this.commandStarts.length,
+            metaSurfaceSignals: summary.metaSurfaceSignals,
+            distinctMetaSurfaces: summary.distinctMetaSurfaces,
+            maxMetaSurfaceHits: summary.maxMetaSurfaceHits,
+            timeoutMs: this.metaSurfaceTimeoutMs
+        };
+    }
+    getStartupAnchorBoundaryState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const triggered = this.startupAnchorViolationAtMs !== null;
+        return {
+            triggered,
+            reason: triggered
+                ? `bounded review startup-anchor boundary violated after ${formatDurationMs(Math.max(0, this.startupAnchorViolationAtMs - this.startedAtMs))}: ${summary.preAnchorCommandStarts} pre-anchor command starts, ${summary.preAnchorMetaSurfaceSignals} pre-anchor meta-surface signals across ${summary.preAnchorDistinctMetaSurfaces} surface kind(s) [${summary.preAnchorMetaSurfaceKinds.join(', ')}] before the first startup anchor.`
+                : null,
+            anchorObserved: this.startupAnchorObserved,
+            preAnchorCommandStarts: summary.preAnchorCommandStarts,
+            preAnchorMetaSurfaceSignals: summary.preAnchorMetaSurfaceSignals,
+            preAnchorDistinctMetaSurfaces: summary.preAnchorDistinctMetaSurfaces,
+            preAnchorMetaSurfaceKinds: summary.preAnchorMetaSurfaceKinds
+        };
+    }
+    getCommandIntentBoundaryState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const violation = this.commandIntentViolation;
+        return {
+            triggered: violation !== null,
+            reason: violation
+                ? `bounded review command-intent boundary violated after ${formatDurationMs(Math.max(0, nowMs - this.startedAtMs))}: ${formatCommandIntentViolationLabel(violation.kind)} via ${violation.sample}.`
+                : null,
+            violationKind: violation?.kind ?? null,
+            violationSample: violation?.sample ?? null,
+            violationCount: summary.commandIntentViolationCount,
+            violationKinds: summary.commandIntentViolationKinds
+        };
+    }
+    getShellProbeBoundaryState(nowMs = Date.now()) {
+        return {
+            triggered: this.shellProbeViolation !== null,
+            reason: this.shellProbeViolation
+                ? `bounded review shell-probe boundary violated after ${formatDurationMs(Math.max(0, this.shellProbeViolation.detectedAtMs - this.startedAtMs))}: repeated direct shell verification via ${this.shellProbeViolation.sample}.`
+                : null,
+            probeCount: this.shellProbeCount,
+            violationSample: this.shellProbeViolation?.sample ?? null
+        };
+    }
+    getActiveCloseoutBundleRereadBoundaryState(nowMs = Date.now()) {
+        return {
+            triggered: this.activeCloseoutBundleRereadViolation !== null,
+            reason: this.activeCloseoutBundleRereadViolation
+                ? `bounded review active-closeout-bundle reread boundary violated after ${formatDurationMs(Math.max(0, this.activeCloseoutBundleRereadViolation.detectedAtMs - this.startedAtMs))}: ${this.activeCloseoutBundleRereadViolation.rereadCount} repeated direct reread command(s) into the active closeout bundle after earlier bounded inspection via ${this.activeCloseoutBundleRereadViolation.sample}.`
+                : null,
+            rereadCount: this.activeCloseoutBundleRereadCount,
+            violationSample: this.activeCloseoutBundleRereadViolation?.sample ?? null,
+            anchorObserved: this.startupAnchorObserved
+        };
+    }
+    getRelevantReinspectionDwellBoundaryState(nowMs = Date.now()) {
+        const summary = this.buildOutputSummary();
+        const relevantInspectionSummary = this.buildInspectionTargetSummary(this.getRelevantReinspectionWindowSize());
+        const derivedTriggered = this.relevantReinspectionDwellViolation !== null ||
+            (this.enforceRelevantReinspectionDwellBoundary &&
+                this.lowSignalTimeoutMs !== null &&
+                this.relevantReinspectionDwellCandidateSinceMs !== null &&
+                Math.max(0, nowMs - this.relevantReinspectionDwellCandidateSinceMs) >=
+                    this.lowSignalTimeoutMs);
+        const detectedAtMs = this.relevantReinspectionDwellViolation?.detectedAtMs ??
+            (derivedTriggered && this.relevantReinspectionDwellCandidateSinceMs !== null && this.lowSignalTimeoutMs !== null
+                ? this.relevantReinspectionDwellCandidateSinceMs + this.lowSignalTimeoutMs
+                : null);
+        const violationSample = this.relevantReinspectionDwellViolation?.sample ?? this.lastInspectionCommandLine;
+        const commandStarts = this.relevantReinspectionDwellViolation?.commandStarts ?? this.commandStarts.length;
+        const distinctTargets = this.relevantReinspectionDwellViolation?.distinctTargets ??
+            relevantInspectionSummary.distinctTargets;
+        const maxTargetHits = this.relevantReinspectionDwellViolation?.maxTargetHits ?? relevantInspectionSummary.maxHits;
+        return {
+            triggered: derivedTriggered,
+            reason: derivedTriggered && detectedAtMs !== null
+                ? `bounded review relevant-reinspection dwell boundary violated after ${formatDurationMs(Math.max(0, detectedAtMs - this.startedAtMs))}: ${commandStarts} command start(s) repeatedly revisited ${distinctTargets} bounded relevant target(s) (max target hit count ${maxTargetHits}) ${this.enforceStartupAnchorBoundary
+                    ? 'after startup-anchor success'
+                    : 'within the current bounded review surface'} without concrete findings or meta-surface drift${violationSample
+                    ? ` via ${violationSample}`
+                    : ''}.`
+                : null,
+            anchorObserved: this.startupAnchorObserved,
+            commandStarts: this.commandStarts.length,
+            distinctTargets: relevantInspectionSummary.distinctTargets,
+            maxTargetHits: relevantInspectionSummary.maxHits,
+            metaSurfaceSignals: summary.metaSurfaceSignals,
+            concreteOutputSignals: summary.concreteOutputSignals,
+            violationSample
+        };
+    }
+    snapshot(nowMs = Date.now()) {
+        return {
+            startedAtMs: this.startedAtMs,
+            lastOutputAtMs: this.lastOutputAtMs,
+            elapsedMs: Math.max(0, nowMs - this.startedAtMs),
+            idleMs: Math.max(0, nowMs - this.lastOutputAtMs),
+            awaitingCommandLine: this.awaitingCommandLine,
+            blockedHeavyCommand: this.blockedHeavyCommand,
+            startupEvents: this.startupEvents,
+            reviewProgressObserved: this.reviewProgressObserved,
+            summary: this.buildOutputSummary()
+        };
+    }
+    formatCheckpoint(nowMs = Date.now()) {
+        const snapshot = this.snapshot(nowMs);
+        const startupStatus = snapshot.reviewProgressObserved
+            ? 'review progress observed'
+            : `${snapshot.startupEvents} delegation startup events, no review progress yet`;
+        return `[run-review] waiting on codex review (${formatDurationMs(snapshot.elapsedMs)} elapsed, ${formatDurationMs(snapshot.idleMs)} idle; ${startupStatus}).`;
+    }
+    buildTelemetryPayload(options) {
+        const explicitTerminationBoundaryProvided = Object.prototype.hasOwnProperty.call(options, 'terminationBoundary');
+        return buildReviewTelemetryPayload({
+            status: options.status,
+            error: options.error ?? null,
+            terminationBoundary: explicitTerminationBoundaryProvided
+                ? options.terminationBoundary ?? null
+                : options.status === 'failed'
+                    ? this.getTerminationBoundaryRecord(options.error ?? null)
+                    : null,
+            outputLogPath: options.outputLogPath,
+            repoRoot: options.repoRoot,
+            includeRawTelemetry: options.includeRawTelemetry,
+            telemetryDebugEnvKey: options.telemetryDebugEnvKey,
+            launchContext: options.launchContext ?? null,
+            summary: this.buildOutputSummary()
+        });
+    }
+    recordCommandIntentViolationsFrom(other) {
+        for (const violation of other.commandIntentViolationSamples) {
+            this.recordCommandIntentViolation(violation);
+        }
+    }
+    getTerminationBoundaryRecordForKind(kind, nowMs = Date.now()) {
+        return this.buildTerminationBoundaryRecord(kind, nowMs);
+    }
+    getTerminationBoundaryRecord(errorMessage = null, nowMs = Date.now()) {
+        const matchedKinds = inferTerminationBoundaryKindsFromErrorMessage(errorMessage);
+        for (const kind of matchedKinds) {
+            if (kind === 'timeout' && errorMessage) {
+                return {
+                    kind: 'timeout',
+                    provenance: 'review-timeout',
+                    reason: errorMessage,
+                    sample: null
+                };
+            }
+            if (kind === 'stall' && errorMessage) {
+                return {
+                    kind: 'stall',
+                    provenance: 'output-stall',
+                    reason: errorMessage,
+                    sample: null
+                };
+            }
+            if (kind === 'startup-loop' && errorMessage) {
+                return {
+                    kind: 'startup-loop',
+                    provenance: 'delegation-startup-loop',
+                    reason: errorMessage,
+                    sample: null
+                };
+            }
+            const record = this.buildTerminationBoundaryRecord(kind, nowMs);
+            if (record) {
+                return record;
+            }
+        }
+        return null;
+    }
+    buildTerminationBoundaryRecord(kind, nowMs) {
+        if (kind === 'command-intent') {
+            const boundary = this.getCommandIntentBoundaryState(nowMs);
+            if (!boundary.triggered || !boundary.reason || !boundary.violationKind) {
+                return null;
+            }
+            return {
+                kind,
+                provenance: boundary.violationKind,
+                reason: boundary.reason,
+                sample: normalizeTerminationBoundarySample(boundary.violationSample)
+            };
+        }
+        if (kind === 'shell-probe') {
+            const boundary = this.getShellProbeBoundaryState(nowMs);
+            if (!boundary.triggered || !boundary.reason) {
+                return null;
+            }
+            return {
+                kind,
+                provenance: 'direct-shell-verification',
+                reason: boundary.reason,
+                sample: normalizeTerminationBoundarySample(boundary.violationSample)
+            };
+        }
+        if (kind === 'active-closeout-bundle-reread') {
+            const boundary = this.getActiveCloseoutBundleRereadBoundaryState(nowMs);
+            if (!boundary.triggered || !boundary.reason) {
+                return null;
+            }
+            return {
+                kind,
+                provenance: boundary.anchorObserved ? 'post-startup-anchor' : 'bounded-surface',
+                reason: boundary.reason,
+                sample: normalizeTerminationBoundarySample(boundary.violationSample)
+            };
+        }
+        if (kind === 'startup-anchor') {
+            const boundary = this.getStartupAnchorBoundaryState(nowMs);
+            if (!boundary.triggered || !boundary.reason) {
+                return null;
+            }
+            return {
+                kind,
+                provenance: 'pre-anchor-meta-surface',
+                reason: boundary.reason,
+                sample: boundary.preAnchorMetaSurfaceKinds[0] ?? null
+            };
+        }
+        if (kind === 'meta-surface-expansion') {
+            const boundary = this.getMetaSurfaceExpansionState(nowMs);
+            if (!boundary.triggered || !boundary.reason) {
+                return null;
+            }
+            const summary = this.buildOutputSummary();
+            const isPureActiveCloseoutSearch = summary.metaSurfaceKinds.length === 1 &&
+                summary.metaSurfaceKinds[0] === REVIEW_ACTIVE_CLOSEOUT_BUNDLE_KIND;
+            return {
+                kind,
+                provenance: isPureActiveCloseoutSearch
+                    ? 'active-closeout-self-reference-search'
+                    : 'meta-surface-kinds',
+                reason: boundary.reason,
+                sample: summary.metaSurfaceKinds[0] ?? null
+            };
+        }
+        if (kind === 'verdict-stability') {
+            const boundary = this.getVerdictStabilityState(nowMs);
+            if (!boundary.triggered || !boundary.reason) {
+                return null;
+            }
+            return {
+                kind,
+                provenance: boundary.distinctOutputInspectionTargets > 0
+                    ? 'repeated-output-inspection'
+                    : 'targetless-speculative-narrative',
+                reason: boundary.reason,
+                sample: null
+            };
+        }
+        const boundary = this.getRelevantReinspectionDwellBoundaryState(nowMs);
+        if (!boundary.triggered || !boundary.reason) {
+            return null;
+        }
+        return {
+            kind,
+            provenance: boundary.anchorObserved ? 'post-startup-anchor' : 'bounded-surface',
+            reason: boundary.reason,
+            sample: normalizeTerminationBoundarySample(boundary.violationSample)
+        };
+    }
+    processLine(line, nowMs) {
+        this.lineCount += 1;
+        const trimmed = line.trim();
+        let handledAsCommandLine = false;
+        if (trimmed.length > 0) {
+            this.lastLines.push(trimmed);
+            if (this.lastLines.length > this.tailLineLimit) {
+                this.lastLines.shift();
+            }
+        }
+        if (REVIEW_DELEGATION_STARTUP_LINE_RE.test(trimmed)) {
+            this.startupEvents += 1;
+        }
+        if (trimmed === 'thinking') {
+            this.thinkingBlocks += 1;
+        }
+        if (REVIEW_PROGRESS_SIGNAL_LINE_RE.test(trimmed)) {
+            this.reviewProgressSignals += 1;
+            this.reviewProgressObserved = true;
+        }
+        const metaSurfaceToolSample = classifyMetaSurfaceToolLine(trimmed);
+        if (metaSurfaceToolSample) {
+            this.recordMetaSurfaceToolSample(metaSurfaceToolSample, nowMs);
+        }
+        const commandIntentToolViolation = classifyCommandIntentToolLine(trimmed);
+        if (commandIntentToolViolation) {
+            this.recordCommandIntentViolation(commandIntentToolViolation);
+        }
+        if (trimmed === 'exec') {
+            this.awaitingCommandLine = true;
+            return;
+        }
+        if (this.awaitingCommandLine && trimmed.length > 0) {
+            const commandLine = normalizeReviewCommandLine(trimmed);
+            if (isLikelyReviewCommandLine(commandLine)) {
+                if (this.commandStarts.length >= this.commandLimit) {
+                    this.commandStarts.shift();
+                }
+                this.commandStarts.push(commandLine);
+                const metaSurfaceSample = classifyMetaSurfaceCommandLine(commandLine, this.touchedPaths, this.repoRoot, this.activeCloseoutBundleRoots, {
+                    allowedMetaSurfacePaths: this.allowedMetaSurfacePaths,
+                    allowedMetaSurfaceEnvVarPaths: this.allowedMetaSurfaceEnvVarPaths
+                });
+                this.recordMetaSurfaceCommandSample(metaSurfaceSample, commandLine, nowMs);
+                this.recordInspectionTargets(commandLine);
+                this.recordStartupAnchorProgress(commandLine, nowMs);
+                const shellProbeSample = classifyShellProbeCommandLine(commandLine);
+                if (shellProbeSample) {
+                    this.recordShellProbe(shellProbeSample, nowMs);
+                }
+                const commandIntentViolation = classifyCommandIntentCommandLine(commandLine, {
+                    allowValidationCommandIntents: this.allowValidationCommandIntents
+                });
+                if (commandIntentViolation) {
+                    this.recordCommandIntentViolation(commandIntentViolation);
+                }
+                const heavyCommand = detectHeavyReviewCommand(commandLine);
+                if (heavyCommand) {
+                    if (this.heavyCommandStarts.length < this.heavyCommandLimit) {
+                        this.heavyCommandStarts.push(commandLine);
+                    }
+                    if (this.blockHeavyCommands && !this.blockedHeavyCommand) {
+                        this.blockedHeavyCommand = commandLine;
+                    }
+                }
+                handledAsCommandLine = true;
+                this.awaitingCommandLine = false;
+            }
+            else if (REVIEW_PROGRESS_SIGNAL_LINE_RE.test(trimmed) ||
+                /\bsucceeded in\b|\bexited\b/i.test(trimmed)) {
+                this.awaitingCommandLine = false;
+            }
+        }
+        if (!handledAsCommandLine) {
+            const outputMetaSurfaceSample = classifyMetaSurfaceOutputLine(trimmed, this.activeCloseoutBundleRoots, this.repoRoot);
+            if (outputMetaSurfaceSample) {
+                this.recordMetaSurfaceSample(outputMetaSurfaceSample, nowMs);
+            }
+            this.recordConcreteOutputSignals(trimmed);
+            this.recordNarrativeInspectionSignals(trimmed);
+        }
+        if (/\bsucceeded in\b|\bexited\b/i.test(trimmed)) {
+            this.completionCount += 1;
+        }
+        this.updateLowSignalCandidate(nowMs);
+        this.updateVerdictStabilityCandidate(nowMs);
+        this.updateMetaSurfaceCandidate(nowMs);
+        this.updateRelevantReinspectionDwellCandidate(nowMs);
+    }
+    recordInspectionTargets(commandLine) {
+        const targets = extractInspectionTargets(commandLine, {
+            touchedPaths: this.touchedPaths,
+            repoRoot: this.repoRoot
+        });
+        if (targets.length === 0) {
+            return targets;
+        }
+        this.lastInspectionCommandLine = commandLine;
+        this.recentInspectionTargetSamples.push(targets);
+        while (this.recentInspectionTargetSamples.length > this.getRecordedInspectionSignalWindowSize()) {
+            this.recentInspectionTargetSamples.shift();
+        }
+        const signature = extractInspectionCommandSignature(commandLine, targets);
+        if (!signature) {
+            return targets;
+        }
+        this.recentInspectionSignatures.push(signature);
+        while (this.recentInspectionSignatures.length > this.getRecordedInspectionSignalWindowSize()) {
+            this.recentInspectionSignatures.shift();
+        }
+        return targets;
+    }
+    recordStartupAnchorProgress(commandLine, nowMs) {
+        if (!this.enforceStartupAnchorBoundary || this.startupAnchorObserved) {
+            return;
+        }
+        const startupBoundaryProgress = analyzeStartupAnchorBoundaryProgress(commandLine, {
+            repoRoot: this.repoRoot,
+            activeCloseoutBundleRoots: this.activeCloseoutBundleRoots,
+            touchedPaths: this.touchedPaths,
+            scopeMode: this.startupAnchorScopeMode,
+            startupAnchorMode: this.startupAnchorMode,
+            auditStartupAnchorPaths: this.auditStartupAnchorPaths,
+            auditStartupAnchorEnvVarPaths: this.auditStartupAnchorEnvVarPaths
+        });
+        for (const preAnchorMetaSurfaceSample of startupBoundaryProgress.preAnchorMetaSurfaceSamples) {
+            this.recordPreAnchorMetaSurfaceSample(preAnchorMetaSurfaceSample, nowMs);
+        }
+        if (startupBoundaryProgress.anchorObserved) {
+            this.startupAnchorObserved = true;
+        }
+        else {
+            this.preAnchorCommandStarts += 1;
+        }
+    }
+    updateLowSignalCandidate(nowMs) {
+        if (this.lowSignalTimeoutMs === null) {
+            this.lowSignalCandidateSinceMs = null;
+            return;
+        }
+        const summary = this.buildOutputSummary();
+        const driftShaped = this.reviewProgressObserved &&
+            this.thinkingBlocks >= LOW_SIGNAL_MIN_THINKING_BLOCKS &&
+            this.commandStarts.length >= LOW_SIGNAL_MIN_COMMAND_STARTS &&
+            summary.distinctInspectionTargets > 0 &&
+            summary.distinctInspectionTargets <= LOW_SIGNAL_MAX_DISTINCT_TARGETS &&
+            summary.maxInspectionTargetHits >= LOW_SIGNAL_MIN_REPEAT_TARGET_HITS &&
+            summary.distinctInspectionSignatures > 0 &&
+            summary.distinctInspectionSignatures <= LOW_SIGNAL_MAX_DISTINCT_TARGETS &&
+            summary.maxInspectionSignatureHits >= LOW_SIGNAL_MIN_REPEAT_SIGNATURE_HITS;
+        if (!driftShaped) {
+            this.lowSignalCandidateSinceMs = null;
+            return;
+        }
+        if (this.lowSignalCandidateSinceMs === null) {
+            this.lowSignalCandidateSinceMs = nowMs;
+        }
+    }
+    updateRelevantReinspectionDwellCandidate(nowMs) {
+        if (!this.enforceRelevantReinspectionDwellBoundary ||
+            this.lowSignalTimeoutMs === null ||
+            this.relevantReinspectionDwellViolation) {
+            this.relevantReinspectionDwellCandidateSinceMs = null;
+            return;
+        }
+        const summary = this.buildOutputSummary();
+        const relevantInspectionSummary = this.buildInspectionTargetSummary(this.getRelevantReinspectionWindowSize());
+        const anchorSatisfied = !this.enforceStartupAnchorBoundary || this.startupAnchorObserved;
+        const dwellShaped = anchorSatisfied &&
+            this.reviewProgressObserved &&
+            this.commandStarts.length >= RELEVANT_REINSPECTION_MIN_COMMAND_STARTS &&
+            relevantInspectionSummary.distinctTargets > 0 &&
+            relevantInspectionSummary.distinctTargets <= this.getRelevantReinspectionMaxDistinctTargets() &&
+            relevantInspectionSummary.maxHits >= RELEVANT_REINSPECTION_MIN_REPEAT_TARGET_HITS &&
+            relevantInspectionSummary.metaSurfaceSignals === 0 &&
+            summary.concreteOutputSignals === 0;
+        if (!dwellShaped) {
+            this.relevantReinspectionDwellCandidateSinceMs = null;
+            return;
+        }
+        if (this.relevantReinspectionDwellCandidateSinceMs === null) {
+            this.relevantReinspectionDwellCandidateSinceMs = nowMs;
+            return;
+        }
+        if (nowMs - this.relevantReinspectionDwellCandidateSinceMs >= this.lowSignalTimeoutMs &&
+            this.relevantReinspectionDwellViolation === null) {
+            this.relevantReinspectionDwellViolation = {
+                sample: this.lastInspectionCommandLine,
+                detectedAtMs: nowMs,
+                commandStarts: this.commandStarts.length,
+                distinctTargets: relevantInspectionSummary.distinctTargets,
+                maxTargetHits: relevantInspectionSummary.maxHits
+            };
+        }
+    }
+    recordNarrativeInspectionSignals(line) {
+        const signature = normalizeNarrativeInspectionSignature(line);
+        if (!signature) {
+            this.recordOutputNarrativeMiss();
+            return;
+        }
+        this.recentOutputNarrativeSignatures.push(signature);
+        while (this.recentOutputNarrativeSignatures.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+            this.recentOutputNarrativeSignatures.shift();
+        }
+        const targets = extractInspectionTargets(signature);
+        if (targets.length === 0) {
+            this.recentOutputInspectionTargetSamples.push(null);
+            while (this.recentOutputInspectionTargetSamples.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+                this.recentOutputInspectionTargetSamples.shift();
+            }
+            return;
+        }
+        this.recentOutputInspectionTargetSamples.push(targets);
+        while (this.recentOutputInspectionTargetSamples.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+            this.recentOutputInspectionTargetSamples.shift();
+        }
+    }
+    recordOutputNarrativeMiss() {
+        this.recentOutputInspectionTargetSamples.push(null);
+        while (this.recentOutputInspectionTargetSamples.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+            this.recentOutputInspectionTargetSamples.shift();
+        }
+        this.recentOutputNarrativeSignatures.push(null);
+        while (this.recentOutputNarrativeSignatures.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+            this.recentOutputNarrativeSignatures.shift();
+        }
+    }
+    recordConcreteOutputSignals(line) {
+        if (this.touchedPaths.size === 0) {
+            this.recentConcreteOutputTargetSamples.push(null);
+            while (this.recentConcreteOutputTargetSamples.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+                this.recentConcreteOutputTargetSamples.shift();
+            }
+            return;
+        }
+        const targets = extractConcreteOutputTargets(line, this.touchedPaths, this.repoRoot);
+        this.recentConcreteOutputTargetSamples.push(targets.length > 0 ? targets : null);
+        while (this.recentConcreteOutputTargetSamples.length > VERDICT_STABILITY_RECENT_OUTPUT_WINDOW) {
+            this.recentConcreteOutputTargetSamples.shift();
+        }
+    }
+    recordMetaSurfaceCommandSample(sample, commandLine, nowMs) {
+        const nextSample = sample &&
+            COMMAND_LEVEL_ALLOWED_META_SURFACE_KIND_SET.has(sample) &&
+            this.allowedMetaSurfaceKinds.has(sample)
+            ? null
+            : sample;
+        this.recentMetaSurfaceSamples.push(nextSample);
+        while (this.recentMetaSurfaceSamples.length > META_SURFACE_RECENT_SIGNAL_WINDOW) {
+            this.recentMetaSurfaceSamples.shift();
+        }
+        if (this.enforceActiveCloseoutBundleRereadBoundary &&
+            nextSample === REVIEW_ACTIVE_CLOSEOUT_BUNDLE_KIND &&
+            this.commandStarts.length > 1) {
+            this.activeCloseoutBundleRereadCount += 1;
+            if (!this.activeCloseoutBundleRereadViolation && this.activeCloseoutBundleRereadCount > 1) {
+                this.activeCloseoutBundleRereadViolation = {
+                    sample: commandLine,
+                    detectedAtMs: nowMs,
+                    rereadCount: this.activeCloseoutBundleRereadCount
+                };
+            }
+        }
+    }
+    recordMetaSurfaceToolSample(sample, nowMs) {
+        this.recordMetaSurfaceSample(sample, nowMs);
+    }
+    recordCommandIntentViolation(violation) {
+        if (this.commandIntentViolationSamples.some((sample) => sample.kind === violation.kind && sample.sample === violation.sample)) {
+            return;
+        }
+        if (!this.commandIntentViolation) {
+            this.commandIntentViolation = violation;
+        }
+        this.commandIntentViolationSamples.push(violation);
+        while (this.commandIntentViolationSamples.length > REVIEW_COMMAND_INTENT_VIOLATION_SAMPLE_LIMIT) {
+            this.commandIntentViolationSamples.shift();
+        }
+    }
+    recordShellProbe(sample, nowMs) {
+        this.shellProbeCount += 1;
+        this.shellProbeSamples.push(sample);
+        while (this.shellProbeSamples.length > REVIEW_COMMAND_INTENT_VIOLATION_SAMPLE_LIMIT) {
+            this.shellProbeSamples.shift();
+        }
+        if (!this.shellProbeViolation && this.shellProbeCount > 1) {
+            this.shellProbeViolation = {
+                sample,
+                detectedAtMs: nowMs
+            };
+        }
+    }
+    recordMetaSurfaceSample(sample, _nowMs) {
+        const nextSample = sample && this.allowedMetaSurfaceKinds.has(sample) ? null : sample;
+        this.recentMetaSurfaceSamples.push(nextSample);
+        while (this.recentMetaSurfaceSamples.length > META_SURFACE_RECENT_SIGNAL_WINDOW) {
+            this.recentMetaSurfaceSamples.shift();
+        }
+    }
+    recordPreAnchorMetaSurfaceSample(sample, nowMs) {
+        if (STARTUP_ANCHOR_ALLOWED_META_SURFACE_KINDS.has(sample)) {
+            return;
+        }
+        this.preAnchorMetaSurfaceSamples.push(sample);
+        if (this.startupAnchorViolationAtMs === null &&
+            this.preAnchorMetaSurfaceSamples.length > STARTUP_ANCHOR_META_SURFACE_SIGNAL_BUDGET) {
+            this.startupAnchorViolationAtMs = nowMs;
+        }
+    }
+    updateMetaSurfaceCandidate(nowMs) {
+        if (this.metaSurfaceTimeoutMs === null) {
+            this.metaSurfaceCandidateSinceMs = null;
+            return;
+        }
+        const summary = this.buildOutputSummary();
+        const expansionShaped = this.reviewProgressObserved &&
+            this.commandStarts.length >= META_SURFACE_MIN_COMMAND_STARTS &&
+            summary.metaSurfaceSignals >= META_SURFACE_MIN_SIGNALS &&
+            (summary.distinctMetaSurfaces >= META_SURFACE_MIN_DISTINCT_SURFACES ||
+                summary.maxMetaSurfaceHits >= META_SURFACE_MIN_REPEAT_HITS);
+        if (!expansionShaped) {
+            this.metaSurfaceCandidateSinceMs = null;
+            return;
+        }
+        if (this.metaSurfaceCandidateSinceMs === null) {
+            this.metaSurfaceCandidateSinceMs = nowMs;
+        }
+    }
+    updateVerdictStabilityCandidate(nowMs) {
+        if (this.verdictStabilityTimeoutMs === null) {
+            this.verdictStabilityCandidateSinceMs = null;
+            return;
+        }
+        const summary = this.buildOutputSummary();
+        const fileTargetDriftShaped = this.reviewProgressObserved &&
+            this.thinkingBlocks >= VERDICT_STABILITY_MIN_THINKING_BLOCKS &&
+            this.commandStarts.length >= VERDICT_STABILITY_MIN_COMMAND_STARTS &&
+            summary.outputInspectionSignals >= VERDICT_STABILITY_MIN_OUTPUT_TARGET_SIGNALS &&
+            summary.distinctOutputInspectionTargets > 0 &&
+            summary.distinctOutputInspectionTargets <= VERDICT_STABILITY_MAX_DISTINCT_OUTPUT_TARGETS &&
+            summary.maxOutputInspectionTargetHits >= VERDICT_STABILITY_MIN_REPEAT_OUTPUT_TARGET_HITS &&
+            summary.distinctOutputNarrativeSignatures > 0 &&
+            summary.distinctOutputNarrativeSignatures <=
+                VERDICT_STABILITY_MAX_DISTINCT_OUTPUT_SIGNATURES &&
+            summary.maxOutputNarrativeSignatureHits >=
+                VERDICT_STABILITY_MIN_REPEAT_OUTPUT_SIGNATURE_HITS;
+        const genericNarrativeDriftShaped = this.reviewProgressObserved &&
+            this.thinkingBlocks >= VERDICT_STABILITY_MIN_THINKING_BLOCKS &&
+            this.commandStarts.length >= VERDICT_STABILITY_MIN_COMMAND_STARTS &&
+            summary.outputNarrativeSignals >= VERDICT_STABILITY_MIN_OUTPUT_NARRATIVE_SIGNALS &&
+            summary.distinctOutputInspectionTargets === 0 &&
+            summary.concreteOutputSignals === 0 &&
+            summary.distinctOutputNarrativeSignatures > 0 &&
+            summary.distinctOutputNarrativeSignatures <=
+                VERDICT_STABILITY_MAX_DISTINCT_OUTPUT_SIGNATURES &&
+            summary.maxOutputNarrativeSignatureHits >=
+                VERDICT_STABILITY_MIN_REPEAT_OUTPUT_SIGNATURE_HITS;
+        const driftShaped = fileTargetDriftShaped || genericNarrativeDriftShaped;
+        if (!driftShaped) {
+            this.verdictStabilityCandidateSinceMs = null;
+            return;
+        }
+        if (this.verdictStabilityCandidateSinceMs === null) {
+            this.verdictStabilityCandidateSinceMs = nowMs;
+        }
+    }
+    buildInspectionTargetSummary(windowSize = LOW_SIGNAL_RECENT_COMMAND_WINDOW) {
+        const recentTargetHits = new Map();
+        const relevantTargetSamples = this.recentInspectionTargetSamples.slice(-windowSize);
+        for (const targets of relevantTargetSamples) {
+            for (const target of targets) {
+                recentTargetHits.set(target, (recentTargetHits.get(target) ?? 0) + 1);
+            }
+        }
+        let maxHits = 0;
+        for (const hits of recentTargetHits.values()) {
+            if (hits > maxHits) {
+                maxHits = hits;
+            }
+        }
+        const recentSignatureHits = new Map();
+        const relevantSignatures = this.recentInspectionSignatures.slice(-windowSize);
+        for (const signature of relevantSignatures) {
+            recentSignatureHits.set(signature, (recentSignatureHits.get(signature) ?? 0) + 1);
+        }
+        let maxSignatureHits = 0;
+        for (const hits of recentSignatureHits.values()) {
+            if (hits > maxSignatureHits) {
+                maxSignatureHits = hits;
+            }
+        }
+        const recentMetaSurfaceHits = new Map();
+        for (const sample of this.recentMetaSurfaceSamples) {
+            if (!sample) {
+                continue;
+            }
+            recentMetaSurfaceHits.set(sample, (recentMetaSurfaceHits.get(sample) ?? 0) + 1);
+        }
+        let maxMetaSurfaceHits = 0;
+        for (const hits of recentMetaSurfaceHits.values()) {
+            if (hits > maxMetaSurfaceHits) {
+                maxMetaSurfaceHits = hits;
+            }
+        }
+        return {
+            distinctTargets: recentTargetHits.size,
+            maxHits,
+            distinctSignatures: recentSignatureHits.size,
+            maxSignatureHits,
+            metaSurfaceSignals: [...recentMetaSurfaceHits.values()].reduce((sum, hits) => sum + hits, 0),
+            distinctMetaSurfaces: recentMetaSurfaceHits.size,
+            maxMetaSurfaceHits,
+            metaSurfaceKinds: [...recentMetaSurfaceHits.keys()].sort()
+        };
+    }
+    getRelevantReinspectionMaxDistinctTargets() {
+        return Math.max(RELEVANT_REINSPECTION_BASE_MAX_DISTINCT_TARGETS, this.touchedPaths.size);
+    }
+    getRelevantReinspectionWindowSize() {
+        return Math.max(LOW_SIGNAL_RECENT_COMMAND_WINDOW, this.getRelevantReinspectionMaxDistinctTargets() * RELEVANT_REINSPECTION_MIN_REPEAT_TARGET_HITS);
+    }
+    getRecordedInspectionSignalWindowSize() {
+        return this.getRelevantReinspectionWindowSize();
+    }
+    buildOutputNarrativeSummary() {
+        const outputTargetHits = new Map();
+        for (const targets of this.recentOutputInspectionTargetSamples) {
+            if (!targets) {
+                continue;
+            }
+            for (const target of targets) {
+                outputTargetHits.set(target, (outputTargetHits.get(target) ?? 0) + 1);
+            }
+        }
+        let maxOutputTargetHits = 0;
+        for (const hits of outputTargetHits.values()) {
+            if (hits > maxOutputTargetHits) {
+                maxOutputTargetHits = hits;
+            }
+        }
+        const outputNarrativeSignatureHits = new Map();
+        for (const signature of this.recentOutputNarrativeSignatures) {
+            if (!signature) {
+                continue;
+            }
+            outputNarrativeSignatureHits.set(signature, (outputNarrativeSignatureHits.get(signature) ?? 0) + 1);
+        }
+        let maxNarrativeSignatureHits = 0;
+        for (const hits of outputNarrativeSignatureHits.values()) {
+            if (hits > maxNarrativeSignatureHits) {
+                maxNarrativeSignatureHits = hits;
+            }
+        }
+        let concreteOutputSignals = 0;
+        for (const targets of this.recentConcreteOutputTargetSamples) {
+            if (!targets) {
+                continue;
+            }
+            concreteOutputSignals += targets.length;
+        }
+        return {
+            outputInspectionSignals: [...outputTargetHits.values()].reduce((sum, hits) => sum + hits, 0),
+            outputNarrativeSignals: [...outputNarrativeSignatureHits.values()].reduce((sum, hits) => sum + hits, 0),
+            concreteOutputSignals,
+            distinctOutputTargets: outputTargetHits.size,
+            maxOutputTargetHits,
+            distinctNarrativeSignatures: outputNarrativeSignatureHits.size,
+            maxNarrativeSignatureHits
+        };
+    }
+    buildPreAnchorMetaSurfaceSummary() {
+        const preAnchorMetaSurfaceHits = new Map();
+        for (const sample of this.preAnchorMetaSurfaceSamples) {
+            preAnchorMetaSurfaceHits.set(sample, (preAnchorMetaSurfaceHits.get(sample) ?? 0) + 1);
+        }
+        return {
+            signals: [...preAnchorMetaSurfaceHits.values()].reduce((sum, hits) => sum + hits, 0),
+            distinctSurfaces: preAnchorMetaSurfaceHits.size,
+            kinds: [...preAnchorMetaSurfaceHits.keys()].sort()
+        };
+    }
+}
+function normalizeTerminationBoundarySample(sample) {
+    if (!sample) {
+        return null;
+    }
+    const trimmed = sample.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export function formatDurationMs(durationMs) {
+    const roundedMs = Math.max(0, Math.round(durationMs));
+    if (roundedMs < 1000) {
+        return `${roundedMs}ms`;
+    }
+    const totalSeconds = Math.max(0, Math.floor(durationMs / 1000));
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes < 60) {
+        return `${minutes}m ${seconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m ${seconds}s`;
+}
+function normalizeReviewCommandLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return '';
+    }
+    const succeededIndex = trimmed.indexOf(' succeeded in ');
+    if (succeededIndex >= 0) {
+        return trimmed.slice(0, succeededIndex).trimEnd();
+    }
+    const exitedIndex = trimmed.indexOf(' exited ');
+    if (exitedIndex >= 0) {
+        return trimmed.slice(0, exitedIndex).trimEnd();
+    }
+    return trimmed;
+}
+function normalizeNarrativeInspectionSignature(line) {
+    const normalized = line.trim().replace(/\s+/gu, ' ');
+    if (normalized.length < REVIEW_NARRATIVE_INSPECTION_MIN_LINE_LENGTH) {
+        return null;
+    }
+    if (normalized === 'thinking' ||
+        normalized === 'exec' ||
+        REVIEW_PROGRESS_SIGNAL_LINE_RE.test(normalized) ||
+        isLikelyReviewCommandLine(normalized) ||
+        /^mcp:/iu.test(normalized) ||
+        /^(?:diff --git|index |--- |\+\+\+ |@@|```)/u.test(normalized) ||
+        /\bsucceeded in\b|\bexited\b/iu.test(normalized)) {
+        return null;
+    }
+    if (!REVIEW_SPECULATIVE_NARRATIVE_LINE_RE.test(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+function extractConcreteOutputTargets(line, touchedPaths, repoRoot) {
+    const normalized = line.trim().replace(/\s+/gu, ' ');
+    if (normalized.length === 0 ||
+        normalized === 'thinking' ||
+        normalized === 'exec' ||
+        REVIEW_PROGRESS_SIGNAL_LINE_RE.test(normalized) ||
+        isLikelyReviewCommandLine(normalized) ||
+        /^mcp:/iu.test(normalized) ||
+        /^(?:diff --git|index |--- |\+\+\+ |@@|```)/u.test(normalized) ||
+        /^[`"']/u.test(normalized) ||
+        /\bsucceeded in\b|\bexited\b/iu.test(normalized) ||
+        normalizeNarrativeInspectionSignature(normalized)) {
+        return [];
+    }
+    const concreteTargets = new Set();
+    for (const touchedPath of touchedPaths) {
+        const normalizedTouchedPath = normalizeScopePath(touchedPath);
+        if (normalizedTouchedPath.length === 0) {
+            continue;
+        }
+        const escapedTouchedPath = escapeRegex(normalizedTouchedPath);
+        const lineMarkerRe = new RegExp(`${escapedTouchedPath}(?::\\d+(?::\\d+)?)\\b|${escapedTouchedPath}#L\\d+(?:C\\d+)?\\b`, 'iu');
+        if (lineMarkerRe.test(normalized) && isTouchedScopePath(normalizedTouchedPath, touchedPaths, repoRoot)) {
+            concreteTargets.add(normalizedTouchedPath);
+        }
+    }
+    return [...concreteTargets];
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+function extractInspectionCommandSignature(commandLine, targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    return normalizeReviewCommandLine(commandLine);
+}