imprint-mcp 0.6.2 → 0.6.3

package/src/imprint/live-verifier.ts

@@ -32,6 +32,7 @@ import {
   type probeResolvedTool,
   rebindBackendsCacheToWorkflow,
 } from './probe-backends.ts';
+import { ensureImprintRuntimeLink } from './runtime-link.ts';
 import { loadCredentialStore } from './runtime.ts';
 import { isSensitiveKey } from './sensitive-keys.ts';
 import { buildZodValidator } from './tool-loader.ts';
@@ -43,9 +44,18 @@ const SYSTEM_PROMPT_PATH = pathJoin(REPO_ROOT, 'prompts', 'live-verifier-agent.m
 const MCP_SERVER_NAME = 'imprint-live-verifier';
 export const LIVE_VERIFICATION_EVIDENCE_FILE = '.live-verification-evidence.json';
 const LIVE_VERIFIER_LOG_FILE = '.live-verifier-log.jsonl';
-const BACKEND_PREPARATION_BUDGET_MS = 2 * 60_000;
+// Cheap probes normally finish well inside the original two-minute window and
+// skip browser transports. The larger ceiling is for the fallback path: a cold
+// CDP request must finish before fetch-bootstrap gets its own browser attempt.
+// Comprehensive preparation is sequential on purpose: concurrent browser
+// transports can trip shared anti-bot/session defenses. Reserve enough time
+// for the normal fetch/stealth/playbook candidates plus CDP and fetch-bootstrap
+// fallbacks; the former 240s cap could kill CDP after a 150s playbook attempt.
+const BACKEND_PREPARATION_BUDGET_MS = 8 * 60_000;
 const MAX_CREDITED_BACKEND_PREPARATIONS = 2;
 const BACKEND_PROBE_SHUTDOWN_GRACE_MS = 5_000;
+const MAX_PROMPT_EVIDENCE_RECORDS = 48;
+const MAX_PROMPT_EVIDENCE_RECORD_CHARS = 8_000;
 let evidenceTempSequence = 0;
 
 const BaselineSchema = z
@@ -158,6 +168,17 @@ export const LiveVerificationReportSchema = z
 
 type LiveVerificationReport = z.infer<typeof LiveVerificationReportSchema>;
 
+export function isInfrastructureOnlyInconclusiveReport(report: LiveVerificationReport): boolean {
+  return (
+    report.status === 'inconclusive' &&
+    report.baseline.verdict === 'infrastructure' &&
+    report.issues.length === 0 &&
+    report.parameters.every(
+      (parameter) => parameter.verdict === 'works' || parameter.verdict === 'untestable',
+    )
+  );
+}
+
 interface LiveIntegrationSuiteResult {
   exitCode: number;
   timedOut: boolean;
@@ -251,6 +272,11 @@ export async function runLiveIntegrationSuite(opts: {
   reason?: string;
   sessionLabel?: string;
 }): Promise<LiveIntegrationSuiteResult> {
+  // The suite is launched directly from the generated tool directory, bypassing
+  // normal tool discovery. Repair a stale global/worktree runtime link here so
+  // imports such as `imprint/compile-verification` resolve against this running
+  // Imprint installation.
+  ensureImprintRuntimeLink(dirname(dirname(opts.toolDir)));
   const integrationPath = pathJoin(opts.toolDir, 'integration.test.ts');
   if (!existsSync(integrationPath)) throw new Error('integration.test.ts is missing');
   const workflowPath = pathJoin(opts.toolDir, 'workflow.json');
@@ -461,7 +487,11 @@ export function readPersistedLiveVerificationEvidence(
 
 export function hasSuiteReceiptForSession(path: string, sessionLabel: string): boolean {
   return readPersistedLiveVerificationEvidence(path).some(
-    (item) => item.kind === 'suite' && item.verifierSession === sessionLabel,
+    (item) =>
+      item.kind === 'suite' &&
+      item.verifierSession === sessionLabel &&
+      item.status !== 'running' &&
+      typeof item.finishedAt === 'string',
   );
 }
 
@@ -628,6 +658,11 @@ async function runBackendProbeSubprocess(opts: {
   attempt?: number;
   label: string;
 }): Promise<Awaited<ReturnType<typeof probeResolvedTool>>> {
+  const previousCacheContents = existsSync(opts.outPath)
+    ? readFileSync(opts.outPath, 'utf8')
+    : undefined;
+  const tool = resolveWorkflowTool(opts.workflowPath);
+  const assetRoot = pathJoin(tool.dir, '..', '..');
   const child = spawn(
     process.execPath,
     [
@@ -674,6 +709,30 @@ async function runBackendProbeSubprocess(opts: {
     unregisterParentCleanup();
   }
   if (outcome.timedOut) {
+    // probeResolvedTool checkpoints every successful candidate. If a later
+    // optional rung consumed the aggregate deadline, use the new valid cache
+    // instead of discarding an already-proven backend. Do not reuse an unchanged
+    // pre-probe cache: forceReprobe may have been requested because it failed.
+    const currentCacheContents = existsSync(opts.outPath)
+      ? readFileSync(opts.outPath, 'utf8')
+      : undefined;
+    const cacheStatus = loadBackendsCacheStatus(tool.site, assetRoot, tool.dir, {
+      warn: false,
+      toolName: tool.workflow.toolName,
+    });
+    if (
+      currentCacheContents !== undefined &&
+      currentCacheContents !== previousCacheContents &&
+      cacheStatus.status === 'ok'
+    ) {
+      appendLiveVerifierLog(opts.logPath, {
+        type: 'backend.probe.partial-cache-recovered',
+        attempt: opts.attempt,
+        label: opts.label,
+        preferredOrder: cacheStatus.cache.preferredOrder,
+      });
+      return { cache: cacheStatus.cache, outPath: opts.outPath };
+    }
     throw new Error(
       `backend probe exceeded its separate ${Math.round(BACKEND_PREPARATION_BUDGET_MS / 1_000)}s budget and was terminated`,
     );
@@ -684,8 +743,6 @@ async function runBackendProbeSubprocess(opts: {
     );
   }
 
-  const tool = resolveWorkflowTool(opts.workflowPath);
-  const assetRoot = pathJoin(tool.dir, '..', '..');
   const cacheStatus = loadBackendsCacheStatus(tool.site, assetRoot, tool.dir, {
     warn: false,
     toolName: tool.workflow.toolName,
@@ -701,6 +758,10 @@ interface LiveSemanticVerificationResult {
   provider: ProviderName;
   model: string;
   attempts: number;
+  /** True only when an independent verifier returned a schema-valid report.
+   * Provider startup/input failures synthesize an inconclusive report for
+   * compiler feedback but do not consume a semantic-review cycle. */
+  completedReview: boolean;
 }
 
 export async function runLiveSemanticVerification(opts: {
@@ -828,6 +889,7 @@ export async function runLiveSemanticVerification(opts: {
         provider: opts.provider,
         model,
         attempts: attempt,
+        completedReview: true,
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -890,7 +952,13 @@ export async function runLiveSemanticVerification(opts: {
     status: 'inconclusive',
     attempts: 2,
   });
-  return { report: inconclusive, provider: opts.provider, model, attempts: 2 };
+  return {
+    report: inconclusive,
+    provider: opts.provider,
+    model,
+    attempts: 2,
+    completedReview: false,
+  };
 }
 
 function mergePersistedRecords(
@@ -955,13 +1023,106 @@ function buildInitialMessage(
         timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
       },
       artifactContext: buildVerifierArtifactContext(toolDir, workflow.toolName),
-      baselineEvidence: evidence,
+      baselineEvidence: compactVerifierEvidenceContext(evidence),
     },
     null,
     2,
   )}`;
 }
 
+/** Keep the verifier prompt bounded without weakening the durable evidence
+ * artifact. Full, sanitized receipts remain on disk; the model gets recent
+ * records with representative payload previews and navigation metadata. */
+export function compactVerifierEvidenceContext(
+  evidence: Array<LiveIntegrationEvidence | PersistedLiveVerificationRecord>,
+): unknown[] {
+  const omittedRecords = Math.max(0, evidence.length - MAX_PROMPT_EVIDENCE_RECORDS);
+  const selected = evidence.slice(-MAX_PROMPT_EVIDENCE_RECORDS);
+  const compacted = selected.map((record) => compactVerifierEvidenceRecord(record));
+  return omittedRecords > 0
+    ? [
+        {
+          kind: 'prompt-compaction',
+          omittedRecords,
+          note: `Full receipts remain in ${LIVE_VERIFICATION_EVIDENCE_FILE}.`,
+        },
+        ...compacted,
+      ]
+    : compacted;
+}
+
+function compactVerifierEvidenceRecord(
+  record: LiveIntegrationEvidence | PersistedLiveVerificationRecord,
+): unknown {
+  const compacted = compactVerifierValue(record, 0);
+  const serialized = JSON.stringify(compacted);
+  if (serialized.length <= MAX_PROMPT_EVIDENCE_RECORD_CHARS) return compacted;
+
+  const navigationKeys = [
+    'schemaVersion',
+    'kind',
+    'label',
+    'caseName',
+    'toolName',
+    'status',
+    'verifierSession',
+    'startedAt',
+    'finishedAt',
+    'requestedParams',
+    'effectiveParams',
+    'preferredBackend',
+    'usedBackend',
+    'attempts',
+    'durationMs',
+    'exitCode',
+    'timedOut',
+    'passedTests',
+    'failedTests',
+    'completedCallLabels',
+    'reason',
+    'error',
+  ] as const;
+  const source = record as Record<string, unknown>;
+  const navigation: Record<string, unknown> = {};
+  for (const key of navigationKeys) {
+    if (source[key] !== undefined) navigation[key] = compactVerifierValue(source[key], 0);
+  }
+  return {
+    ...navigation,
+    payloadPreview: clipVerifierString(serialized, MAX_PROMPT_EVIDENCE_RECORD_CHARS),
+    promptCompacted: true,
+    note: `Full receipt remains in ${LIVE_VERIFICATION_EVIDENCE_FILE}.`,
+  };
+}
+
+function compactVerifierValue(value: unknown, depth: number): unknown {
+  if (typeof value === 'string') return clipVerifierString(value, 2_000);
+  if (value === null || typeof value !== 'object') return value;
+  if (depth >= 6) return clipVerifierString(JSON.stringify(value), 2_000);
+  if (Array.isArray(value)) {
+    if (value.length <= 4) return value.map((item) => compactVerifierValue(item, depth + 1));
+    return [
+      ...value.slice(0, 3).map((item) => compactVerifierValue(item, depth + 1)),
+      { promptCompactedItems: value.length - 4 },
+      compactVerifierValue(value.at(-1), depth + 1),
+    ];
+  }
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+      key,
+      compactVerifierValue(item, depth + 1),
+    ]),
+  );
+}
+
+function clipVerifierString(value: string, maxChars: number): string {
+  const redacted = redactFreeformText(value).redacted;
+  if (redacted.length <= maxChars) return redacted;
+  const headChars = Math.ceil(maxChars * 0.6);
+  const tailChars = Math.floor(maxChars * 0.4);
+  return `${redacted.slice(0, headChars)}\n...[prompt preview truncated ${redacted.length - maxChars} chars]...\n${redacted.slice(-tailChars)}`;
+}
+
 function creditBackendPreparation(
   budget: { creditedCount: number; creditMs: number },
   durationMs: number,

package/src/imprint/llm.ts

@@ -1254,6 +1254,10 @@ export function preferredVerificationModel(provider: ProviderName): string {
   throw new Error(`Provider ${provider} does not support live semantic verification`);
 }
 
+/** The semantic reviewer intentionally uses a provider independent from the
+ * compiler. Claude/Sonnet compilation therefore still receives a Terra review. */
+export const DEFAULT_VERIFICATION_PROVIDER: ProviderName = 'codex-cli';
+
 interface ModelOption {
   model: string;
   isDefault: boolean;

package/src/imprint/mcp-compile-server.ts

@@ -35,6 +35,10 @@ import {
   type SharedModuleManifestEntry,
   resolvePlanSliceFromFile,
 } from './build-plan.ts';
+import {
+  advanceIncompleteSemanticVerificationRuns,
+  advanceSemanticVerificationCycle,
+} from './compile-agent-types.ts';
 import {
   applyLiveVerification,
   applyParamVerification,
@@ -42,10 +46,12 @@ import {
   externalVerification,
 } from './compile-tools.ts';
 import {
+  isInfrastructureOnlyInconclusiveReport,
   mergeSemanticParamVerification,
   runLiveSemanticVerification,
   semanticVerificationFailures,
 } from './live-verifier.ts';
+import { DEFAULT_VERIFICATION_PROVIDER } from './llm.ts';
 import type { ProviderName } from './llm.ts';
 import { loadJsonFile } from './load-json.ts';
 import { createLog } from './log.ts';
@@ -210,22 +216,45 @@ export function compileArtifactFingerprint(toolDir: string): string {
 }
 
 export function canAcceptInconclusiveDecision(opts: {
+  semanticVerificationCycles: number;
+  maxVerificationCycles: number;
+  completedReview: boolean;
+  infrastructureOnly: boolean;
   pendingFingerprint?: string;
   currentFingerprint: string;
   acceptInconclusive?: boolean;
   inconclusiveReason?: string;
 }): boolean {
   return (
+    opts.completedReview &&
+    opts.infrastructureOnly &&
+    opts.semanticVerificationCycles >= opts.maxVerificationCycles &&
     opts.acceptInconclusive === true &&
     Boolean(opts.inconclusiveReason?.trim()) &&
     opts.pendingFingerprint === opts.currentFingerprint
   );
 }
 
+export function inconclusiveDecisionAtSemanticCap(opts: {
+  semanticVerificationCycles: number;
+  maxVerificationCycles: number;
+  pendingFingerprint?: string;
+  currentFingerprint: string;
+}): 'continue-verification' | 'await-compiler-decision' | 'fail-artifact-changed' {
+  if (!opts.pendingFingerprint || opts.semanticVerificationCycles < opts.maxVerificationCycles) {
+    return 'continue-verification';
+  }
+  return opts.pendingFingerprint === opts.currentFingerprint
+    ? 'await-compiler-decision'
+    : 'fail-artifact-changed';
+}
+
 export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Promise<void> {
   const isAuthMode = !!opts.authToolPlan;
   const maxVerificationCycles = opts.maxVerificationCycles ?? 5;
+  const maxIncompleteVerifierRuns = 2;
   let pendingInconclusive: PendingInconclusiveDecision | undefined;
+  let incompleteVerifierRuns = 0;
 
   // Load + auto-redact the session, exactly as compile-agent.ts does.
   let session: Session = loadJsonFile(
@@ -412,7 +441,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
       ]
     : [];
 
-  let verificationFailures = 0;
+  let semanticVerificationCycles = 0;
   /** One pending checkpoint per segment — refuse a second so the orchestrator
    *  acts on exactly one request. Cleared implicitly: each segment is a fresh
    *  process with the sentinel removed before spawn. */
@@ -487,15 +516,15 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
           };
         }
 
-        verificationFailures++;
-        log(`auth verification failed (cycle ${verificationFailures})`);
+        semanticVerificationCycles++;
+        log(`auth verification failed (cycle ${semanticVerificationCycles})`);
 
         return {
           isError: true,
           content: [
             {
               type: 'text',
-              text: `You called done but verification failed (cycle ${verificationFailures}):
+              text: `You called done but verification failed (cycle ${semanticVerificationCycles}):
 
 ${failures.map((f) => `- ${f}`).join('\n')}
 
@@ -507,6 +536,8 @@ Fix the issues in workflow.json, re-test with run_verification, and call done ag
 
       const finishVerification = beginCompileVerification(opts.toolDir);
       try {
+        let semanticReviewCompleted = false;
+        let semanticReviewAttempted = false;
         const { failures, warnings, paramVerification, integrationEvidence } =
           await externalVerification(opts.toolDir, session, opts.sessionPath, {
             expectedToolName: opts.candidate?.toolName,
@@ -536,6 +567,12 @@ Fix the issues in workflow.json, re-test with run_verification, and call done ag
             if (
               pendingInconclusive &&
               canAcceptInconclusiveDecision({
+                semanticVerificationCycles,
+                maxVerificationCycles,
+                completedReview: pendingInconclusive.report.completedReview,
+                infrastructureOnly: isInfrastructureOnlyInconclusiveReport(
+                  pendingInconclusive.report.report,
+                ),
                 pendingFingerprint: pendingInconclusive.artifactFingerprint,
                 currentFingerprint,
                 acceptInconclusive: doneArgs.accept_inconclusive,
@@ -601,89 +638,154 @@ Fix the issues in workflow.json, re-test with run_verification, and call done ag
               };
             }
 
-            if (
-              pendingInconclusive &&
-              pendingInconclusive.artifactFingerprint !== currentFingerprint
-            ) {
-              log(
-                'compile artifacts changed after inconclusive review; running verification again',
-              );
-              pendingInconclusive = undefined;
-            }
-            const semantic = await runLiveSemanticVerification({
-              provider: opts.provider,
-              toolDir: opts.toolDir,
-              evidence: integrationEvidence,
+            const capDecision = inconclusiveDecisionAtSemanticCap({
+              semanticVerificationCycles,
+              maxVerificationCycles,
+              pendingFingerprint: pendingInconclusive?.artifactFingerprint,
+              currentFingerprint,
             });
-            if (semantic.report.status === 'inconclusive') {
-              pendingInconclusive = {
-                artifactFingerprint: compileArtifactFingerprint(opts.toolDir),
-                report: semantic,
-              };
-            } else {
+            if (capDecision === 'fail-artifact-changed') {
               pendingInconclusive = undefined;
-            }
-            const semanticFailures = semanticVerificationFailures(semantic.report);
-            failures.push(...semanticFailures);
-            if (semantic.report.status === 'approved_with_gaps') {
-              warnings.push(
-                `independent semantic verification approved with gaps: ${semantic.report.gaps.join('; ')}`,
+              failures.push(
+                'compile artifacts changed after the final allowed inconclusive semantic review; refusing to run an additional review beyond the semantic cycle cap',
               );
-            }
-            if (semanticFailures.length === 0) {
-              const semanticParams = mergeSemanticParamVerification(
-                paramVerification,
-                semantic.report,
+            } else if (capDecision === 'await-compiler-decision') {
+              failures.push(
+                'semantic review limit reached with an unchanged infrastructure-only inconclusive result; explicitly accept the unverified artifact with reasoning or revise it',
               );
-              // Only the independent semantic agent can mint liveVerified=true.
-              applyLiveVerification(opts.toolDir, undefined);
-              const paramWarnings = applyParamVerification(opts.toolDir, semanticParams);
-              // liveVerified/parameter annotations are metadata-only, but they
-              // change the hash-strict workflow cache key. Keep the verifier's
-              // already-proven backend preference current without probing again.
-              rebindExistingBackendsCacheToWorkflow(opts.toolDir);
-              if (paramWarnings.length > 0) {
-                log(`parameter verification:\n${paramWarnings.join('\n')}`);
+            } else {
+              if (
+                pendingInconclusive &&
+                pendingInconclusive.artifactFingerprint !== currentFingerprint
+              ) {
+                log(
+                  'compile artifacts changed after inconclusive review; running verification again',
+                );
+                pendingInconclusive = undefined;
               }
-              const allWarnings = [...warnings, ...paramWarnings];
-              const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
-              writeFileSync(
-                sentinel,
-                JSON.stringify(
-                  {
-                    summary,
-                    verification: 'passed',
-                    semanticVerification: {
-                      status: semantic.report.status,
-                      provider: semantic.provider,
-                      model: semantic.model,
-                      attempts: semantic.attempts,
-                      evidenceArtifact: semantic.report.evidenceArtifact,
-                      logArtifact: semantic.report.logArtifact,
+              semanticReviewAttempted = true;
+              const semantic = await runLiveSemanticVerification({
+                provider: DEFAULT_VERIFICATION_PROVIDER,
+                toolDir: opts.toolDir,
+                evidence: integrationEvidence,
+              });
+              semanticReviewCompleted = semantic.completedReview;
+              if (semantic.report.status === 'inconclusive') {
+                pendingInconclusive = {
+                  artifactFingerprint: compileArtifactFingerprint(opts.toolDir),
+                  report: semantic,
+                };
+              } else {
+                pendingInconclusive = undefined;
+              }
+              const semanticFailures = semanticVerificationFailures(semantic.report);
+              failures.push(...semanticFailures);
+              if (semantic.report.status === 'approved_with_gaps') {
+                warnings.push(
+                  `independent semantic verification approved with gaps: ${semantic.report.gaps.join('; ')}`,
+                );
+              }
+              if (semanticFailures.length === 0) {
+                const semanticParams = mergeSemanticParamVerification(
+                  paramVerification,
+                  semantic.report,
+                );
+                // Only the independent semantic agent can mint liveVerified=true.
+                applyLiveVerification(opts.toolDir, undefined);
+                const paramWarnings = applyParamVerification(opts.toolDir, semanticParams);
+                // liveVerified/parameter annotations are metadata-only, but they
+                // change the hash-strict workflow cache key. Keep the verifier's
+                // already-proven backend preference current without probing again.
+                rebindExistingBackendsCacheToWorkflow(opts.toolDir);
+                if (paramWarnings.length > 0) {
+                  log(`parameter verification:\n${paramWarnings.join('\n')}`);
+                }
+                const allWarnings = [...warnings, ...paramWarnings];
+                const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
+                writeFileSync(
+                  sentinel,
+                  JSON.stringify(
+                    {
+                      summary,
+                      verification: 'passed',
+                      semanticVerification: {
+                        status: semantic.report.status,
+                        provider: semantic.provider,
+                        model: semantic.model,
+                        attempts: semantic.attempts,
+                        evidenceArtifact: semantic.report.evidenceArtifact,
+                        logArtifact: semantic.report.logArtifact,
+                      },
+                      warnings: allWarnings,
+                      timestamp: Date.now(),
                     },
-                    warnings: allWarnings,
-                    timestamp: Date.now(),
-                  },
-                  null,
-                  2,
-                ),
-                'utf8',
-              );
-              log(`verification passed; wrote ${sentinel}`);
-              return {
-                content: [
-                  {
-                    type: 'text',
-                    text: `DONE_VERIFIED — deterministic checks and independent live semantic verification passed (${semantic.report.status}). Evidence: ${semantic.report.evidenceArtifact ?? '.live-verification-evidence.json'}. Verifier log: ${semantic.report.logArtifact ?? '.live-verifier-log.jsonl'}. The orchestrator will exit shortly. Do not call any more tools.`,
-                  },
-                ],
-              };
+                    null,
+                    2,
+                  ),
+                  'utf8',
+                );
+                log(`verification passed; wrote ${sentinel}`);
+                return {
+                  content: [
+                    {
+                      type: 'text',
+                      text: `DONE_VERIFIED — deterministic checks and independent live semantic verification passed (${semantic.report.status}). Evidence: ${semantic.report.evidenceArtifact ?? '.live-verification-evidence.json'}. Verifier log: ${semantic.report.logArtifact ?? '.live-verifier-log.jsonl'}. The orchestrator will exit shortly. Do not call any more tools.`,
+                    },
+                  ],
+                };
+              }
             }
           }
         }
-        verificationFailures++;
-        log(`verification failed (cycle ${verificationFailures}/${maxVerificationCycles})`);
-        if (verificationFailures >= maxVerificationCycles) {
+        semanticVerificationCycles = advanceSemanticVerificationCycle(
+          semanticVerificationCycles,
+          semanticReviewCompleted,
+        );
+        incompleteVerifierRuns = advanceIncompleteSemanticVerificationRuns(
+          incompleteVerifierRuns,
+          semanticReviewAttempted,
+          semanticReviewCompleted,
+        );
+        if (incompleteVerifierRuns >= maxIncompleteVerifierRuns) {
+          const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
+          writeFileSync(
+            sentinel,
+            JSON.stringify(
+              {
+                summary,
+                verification: 'failed',
+                incompleteVerifierRuns,
+                failures,
+                warnings,
+                timestamp: Date.now(),
+              },
+              null,
+              2,
+            ),
+            'utf8',
+          );
+          return {
+            isError: true,
+            content: [
+              {
+                type: 'text',
+                text: `Independent semantic verifier failed to complete after ${maxIncompleteVerifierRuns} bounded runs. Final failures:\n${failures.map((failure) => `- ${failure}`).join('\n')}`,
+              },
+            ],
+          };
+        }
+        const failurePhase = semanticReviewCompleted
+          ? `semantic verification failed (cycle ${semanticVerificationCycles}/${maxVerificationCycles})`
+          : semanticReviewAttempted
+            ? 'semantic verifier did not complete a review (semantic cycle unchanged)'
+            : 'deterministic verification failed (semantic cycle unchanged)';
+        log(failurePhase);
+        const awaitingFinalInconclusiveDecision =
+          semanticVerificationCycles >= maxVerificationCycles && pendingInconclusive !== undefined;
+        if (
+          semanticVerificationCycles >= maxVerificationCycles &&
+          !awaitingFinalInconclusiveDecision
+        ) {
           const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
           writeFileSync(
             sentinel,
@@ -691,7 +793,7 @@ Fix the issues in workflow.json, re-test with run_verification, and call done ag
               {
                 summary,
                 verification: 'failed',
-                cycles: verificationFailures,
+                cycles: semanticVerificationCycles,
                 failures,
                 warnings,
                 timestamp: Date.now(),
@@ -706,20 +808,23 @@ Fix the issues in workflow.json, re-test with run_verification, and call done ag
             content: [
               {
                 type: 'text',
-                text: `Verification failed after ${maxVerificationCycles} cycles. Giving up. Final failures:\n${failures.map((f) => `- ${f}`).join('\n')}`,
+                text: `Semantic verification failed after ${maxVerificationCycles} cycles. Giving up. Final failures:\n${failures.map((f) => `- ${f}`).join('\n')}`,
               },
             ],
           };
         }
 
-        const continuationMessage = `You called done but verification failed (cycle ${verificationFailures}/${maxVerificationCycles}):
+        const continuationMessage = `You called done but ${failurePhase}:
 
 ${failures.map((f) => `- ${f}`).join('\n')}
 
 Resume your work. Read the files you wrote (workflow.json, parser.ts, parser.test.ts), fix the issues, re-run tests, and call done again when fixed.`;
-        const compilerDecisionGuidance = `\n\nUse the verifier's semantic evidence, not a requirement for 100% of the original candidate inputs. If the core intent works but a secondary parameter cannot be supported from the recording and live evidence without guessing, remove that parameter and add workflow.limitations with omittedParameters and a specific reason. Close that omission over its dependencies: also remove dependent public inputs and narrow parameter/intent descriptions so callers cannot still enter the unsupported branch indirectly. Do not use a limitation to hide a broken core tool, and do not keep a known broken or ignored public input.`;
+        const compilerDecisionGuidance = `\n\nUse the verifier's semantic evidence, not a requirement for 100% of the original candidate inputs. If the core intent works but a secondary parameter cannot be supported from the recording and live evidence without guessing, remove that parameter and add workflow.limitations with omittedParameters and a specific reason. Treat emitsTokens as downstream compatibility targets, not automatic definitions of producer success: when useful core records lack an optional consumer token, preserve the records and supported input classes, document the missing output and affected consumers, and leave those consumers limited/unverified. Narrow an input class only when its core results are unusable or misleading. Remove claims that directly depend on an omitted feature, but do not erase valid producer results solely to make a downstream chain total. Do not use a limitation to hide a broken core tool, and do not keep a known broken or ignored public input.`;
         const inconclusiveDecisionGuidance = pendingInconclusive
-          ? '\n\nThe live verifier was infrastructure-only inconclusive. Review its evidence and log. If they expose a tool defect, revise the artifacts and call done normally so verification reruns. If they expose no tool-level defect and the deterministic artifact should ship explicitly unverified, call done again without changing compile artifacts, set accept_inconclusive=true, and provide your concrete reasoning in inconclusive_reason. This compiler decision is persisted and does not mint liveVerified.'
+          ? semanticVerificationCycles >= maxVerificationCycles &&
+            pendingInconclusive.report.completedReview
+            ? '\n\nThe final allowed live semantic review was infrastructure-only inconclusive. Review its evidence and log. If they expose a tool defect, do not attempt to change the artifact after the review cap. If they expose no tool-level defect and the unchanged deterministic artifact should ship explicitly unverified, call done again without changing compile artifacts, set accept_inconclusive=true, and provide your concrete reasoning in inconclusive_reason. This compiler decision is persisted and does not mint liveVerified.'
+            : '\n\nThe live verifier was infrastructure-only inconclusive. Review its evidence and log. Fix any exposed tool defect, or call done normally to request another independent review. Explicit unverified acceptance is available only after the semantic review limit is reached.'
           : '';
         return {
           isError: true,