imprint-mcp 0.6.0 → 0.6.2

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

@@ -14,7 +14,8 @@
  * loss.
  */
 
-import { writeFileSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join as pathJoin } from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -24,7 +25,11 @@ import {
   ListToolsRequestSchema,
   type Tool,
 } from '@modelcontextprotocol/sdk/types.js';
-import { authExternalVerification, buildAuthCompileTools } from './auth-compile-tools.ts';
+import {
+  authExternalVerification,
+  authWorkflowPreflightFailures,
+  buildAuthCompileTools,
+} from './auth-compile-tools.ts';
 import {
   type AuthToolPlan,
   type SharedModuleManifestEntry,
@@ -36,8 +41,15 @@ import {
   buildCompileTools,
   externalVerification,
 } from './compile-tools.ts';
+import {
+  mergeSemanticParamVerification,
+  runLiveSemanticVerification,
+  semanticVerificationFailures,
+} from './live-verifier.ts';
+import type { ProviderName } from './llm.ts';
 import { loadJsonFile } from './load-json.ts';
 import { createLog } from './log.ts';
+import { rebindExistingBackendsCacheToWorkflow } from './probe-backends.ts';
 import { redactSession } from './redact.ts';
 import { loadCredentialStore } from './runtime.ts';
 import type { SharedCompileContext, ToolCandidate } from './tool-candidates.ts';
@@ -50,8 +62,7 @@ interface RunCompileMcpServerOptions {
   sessionPath: string;
   /** Absolute path to the generated tool directory where artifacts go. */
   toolDir: string;
-  /** Hard cap on done() verification failures before we permanently fail.
-   *  Mirrors compile-agent.ts MAX_VERIFICATION_CYCLES. */
+  /** Data-tool cap on done() verification failures. Auth is deadline-bounded. */
   maxVerificationCycles?: number;
   candidate?: ToolCandidate;
   sharedContext?: SharedCompileContext;
@@ -59,26 +70,162 @@ interface RunCompileMcpServerOptions {
   buildPlanPath?: string;
   /** Shared-module build manifest for this site (verified flags). */
   sharedModules?: SharedModuleManifestEntry[];
-  /** Present → run in AUTH mode: register the auth toolset (run_verification)
+  /** Present → run in AUTH mode: register the auth checkpoint toolset
    *  and run authExternalVerification in done() instead of the data-tool
    *  verification. */
   authToolPlan?: NonNullable<AuthToolPlan>;
   /** Site slug (required in auth mode) — used to load credentials for the live
    *  auth-test tools. */
   site?: string;
+  /** Compile provider. The independent verifier uses the same provider family
+   * with its dedicated review model (Terra for Codex, latest Sonnet for Claude). */
+  provider?: ProviderName;
+  /** Bounded resume of an already-generated data tool. */
+  revisionMode?: boolean;
 }
 
 const DONE_SENTINEL = '.compile-done.json';
 const GIVE_UP_SENTINEL = '.compile-give-up.json';
-/** Auth mode only: a mid-loop checkpoint the agent reaches (run_verification /
- *  prompt_user / wait_for_cooldown). The tool records the request here and the
+const VERIFICATION_STATE_SENTINEL = '.compile-verification-state.json';
+// Keep the compile watchdog from charging live verification against the model's
+// reasoning budget, while retaining a hard bound if the MCP server dies during
+// done(). This matches the longest supported MCP tool call.
+const MAX_VERIFICATION_WALL_TIME_MS = 30 * 60_000;
+/** Auth mode only: a mid-loop checkpoint the agent reaches. The tool records
+ *  the request here and the
  *  agent STOPS; the orchestrator (teach) performs the action and resumes the
  *  agent (`claude --resume`) with the result. One pending checkpoint per segment. */
 const CHECKPOINT_SENTINEL = '.compile-checkpoint.json';
 
+const COMPILE_ARTIFACT_FILES = [
+  'workflow.json',
+  'parser.ts',
+  'parser.test.ts',
+  'integration.test.ts',
+  'request-transform.ts',
+  'playbook.yaml',
+] as const;
+
+interface PendingInconclusiveDecision {
+  artifactFingerprint: string;
+  report: Awaited<ReturnType<typeof runLiveSemanticVerification>>;
+}
+
+interface CompileVerificationState {
+  excludedMs: number;
+  activeSinceMs?: number;
+  activeUntilMs?: number;
+}
+
+function readCompileVerificationState(toolDir: string): CompileVerificationState {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(pathJoin(toolDir, VERIFICATION_STATE_SENTINEL), 'utf8'),
+    ) as Partial<CompileVerificationState>;
+    return {
+      excludedMs:
+        typeof parsed.excludedMs === 'number' && Number.isFinite(parsed.excludedMs)
+          ? Math.max(0, parsed.excludedMs)
+          : 0,
+      activeSinceMs:
+        typeof parsed.activeSinceMs === 'number' && Number.isFinite(parsed.activeSinceMs)
+          ? parsed.activeSinceMs
+          : undefined,
+      activeUntilMs:
+        typeof parsed.activeUntilMs === 'number' && Number.isFinite(parsed.activeUntilMs)
+          ? parsed.activeUntilMs
+          : undefined,
+    };
+  } catch {
+    return { excludedMs: 0 };
+  }
+}
+
+function writeCompileVerificationState(toolDir: string, state: CompileVerificationState): void {
+  const destination = pathJoin(toolDir, VERIFICATION_STATE_SENTINEL);
+  const temporary = pathJoin(
+    toolDir,
+    `${VERIFICATION_STATE_SENTINEL}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  try {
+    writeFileSync(temporary, `${JSON.stringify(state)}\n`, {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o600,
+    });
+    renameSync(temporary, destination);
+  } finally {
+    // rename removes the source on success; clean up a partial temp file if a
+    // write or rename fails without disturbing the last complete state.
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+function beginCompileVerification(toolDir: string): () => void {
+  const previous = readCompileVerificationState(toolDir);
+  const startedAt = Date.now();
+  writeCompileVerificationState(toolDir, {
+    excludedMs: previous.excludedMs,
+    activeSinceMs: startedAt,
+    activeUntilMs: startedAt + MAX_VERIFICATION_WALL_TIME_MS,
+  });
+  return () => {
+    const finishedAt = Date.now();
+    writeCompileVerificationState(toolDir, {
+      excludedMs:
+        previous.excludedMs +
+        Math.min(MAX_VERIFICATION_WALL_TIME_MS, Math.max(0, finishedAt - startedAt)),
+    });
+  };
+}
+
+/** Effective compiler deadline after excluding bounded time spent inside done()
+ * verification. Exported for the CLI watchdogs and focused lifecycle tests. */
+export function compileDeadlineAfterVerification(
+  toolDir: string,
+  compilerDeadlineMs: number,
+  now = Date.now(),
+): number {
+  const state = readCompileVerificationState(toolDir);
+  const activeElapsedMs =
+    state.activeSinceMs === undefined
+      ? 0
+      : Math.max(
+          0,
+          Math.min(now, state.activeUntilMs ?? state.activeSinceMs) - state.activeSinceMs,
+        );
+  return compilerDeadlineMs + state.excludedMs + activeElapsedMs;
+}
+
+export function compileArtifactFingerprint(toolDir: string): string {
+  const hash = createHash('sha256');
+  for (const relativePath of COMPILE_ARTIFACT_FILES) {
+    const absolutePath = pathJoin(toolDir, relativePath);
+    hash.update(relativePath);
+    hash.update('\0');
+    if (existsSync(absolutePath)) hash.update(readFileSync(absolutePath));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+export function canAcceptInconclusiveDecision(opts: {
+  pendingFingerprint?: string;
+  currentFingerprint: string;
+  acceptInconclusive?: boolean;
+  inconclusiveReason?: string;
+}): boolean {
+  return (
+    opts.acceptInconclusive === true &&
+    Boolean(opts.inconclusiveReason?.trim()) &&
+    opts.pendingFingerprint === opts.currentFingerprint
+  );
+}
+
 export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Promise<void> {
   const isAuthMode = !!opts.authToolPlan;
-  const maxVerificationCycles = opts.maxVerificationCycles ?? (isAuthMode ? 3 : 5);
+  const maxVerificationCycles = opts.maxVerificationCycles ?? 5;
+  let pendingInconclusive: PendingInconclusiveDecision | undefined;
 
   // Load + auto-redact the session, exactly as compile-agent.ts does.
   let session: Session = loadJsonFile(
@@ -110,9 +257,8 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
 
   if (isAuthMode) {
     const site = opts.site ?? session.site;
-    // Credentials power the live run_verification tool (and any login playbook
-    // it drives). Loaded here (not passed on the command line) to keep secrets
-    // out of argv.
+    // Credentials power the orchestrator-owned live verifier. Load them here
+    // rather than passing secrets on the command line.
     const creds = await loadCredentialStore(site);
     const teachCredentials = { site, values: creds?.values ?? {} };
     compileTools = buildAuthCompileTools(session, opts.toolDir, opts.sessionPath, teachCredentials);
@@ -123,6 +269,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
       sharedContext: opts.sharedContext,
       buildPlanPath: opts.buildPlanPath,
       sharedModules: opts.sharedModules,
+      revisionMode: opts.revisionMode,
     });
 
     // Resolve the shared modules + producer→consumer token contracts + the general
@@ -146,6 +293,16 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
       type: 'object',
       properties: {
         summary: { type: 'string', description: 'Brief summary of what was accomplished' },
+        accept_inconclusive: {
+          type: 'boolean',
+          description:
+            'After an infrastructure-only inconclusive verifier result, explicitly ship the unchanged deterministic artifact without a liveVerified stamp.',
+        },
+        inconclusive_reason: {
+          type: 'string',
+          description:
+            'Compiler reasoning for accepting the unchanged artifact after reviewing the inconclusive verifier evidence.',
+        },
       },
       required: ['summary'],
     },
@@ -176,20 +333,53 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
         {
           name: 'run_verification',
           description:
-            'Hand the current workflow.json to the verification stage to run LIVE (the only thing that fires a real login). phase="initiate" sends the OTP/push (reaches AWAITING_2FA); phase="submit_otp" submits an otp_code; phase="complete" polls a push. After calling this you MUST stop — the orchestrator runs it and resumes you with the result as a new message. Do NOT call any other tool in the same turn.',
+            'Run one action from the current workflow.json live in the verification browser. Supply the action name and only its declared parameters. Set freshSession only when observed evidence means the prior browser and continuation state must be discarded. Set cleanSession only when evidence requires also withholding stored cookies and browser storage. After calling this, stop; the orchestrator resumes you with the observed result.',
           inputSchema: {
             type: 'object',
             properties: {
-              phase: { type: 'string', enum: ['initiate', 'submit_otp', 'complete'] },
-              otp_code: { type: 'string', description: 'For submit_otp only.' },
+              action: { type: 'string', description: 'An action declared in authConfig.actions.' },
+              parameters: {
+                type: 'object',
+                description:
+                  'Scalar values required by this action, keyed by workflow parameter name.',
+              },
+              freshSession: {
+                type: 'boolean',
+                description:
+                  'Close and discard the prior verification browser and continuation state before running this action. Defaults to false.',
+              },
+              cleanSession: {
+                type: 'boolean',
+                description:
+                  'Also withhold stored cookies and browser storage for this fresh run. Credential values remain available.',
+              },
+            },
+            required: ['action'],
+          },
+        },
+        {
+          name: 'inspect_verification_page',
+          description:
+            'Inspect the currently rendered page in the existing verification browser without navigating, resetting state, or running another auth action. Returns rendered body text, final URL, title, and optional cookie metadata (never cookie values). Use when observed verification evidence warrants inspecting the page. After calling this, stop; the orchestrator resumes you with the snapshot.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              maxChars: {
+                type: 'number',
+                description: 'Maximum rendered body-text characters to return (256–20000).',
+              },
+              includeCookies: {
+                type: 'boolean',
+                description:
+                  'Include cookie names, domains, paths, expirations, and flags. Cookie values are never returned. Defaults to true.',
+              },
             },
-            required: ['phase'],
           },
         },
         {
           name: 'prompt_user',
           description:
-            'Ask the human (in the teach TUI) to supply the live second factor — e.g. enter the code they received, click the emailed link then confirm, or approve the push then confirm. Provide a clear message and optional choice options. After calling this you MUST stop; the orchestrator collects the answer and resumes you with it.',
+            'Ask the human for input or an external action required by the compiled auth program. After calling this, stop; the orchestrator collects the answer and resumes you with it.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -206,7 +396,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
         {
           name: 'wait_for_cooldown',
           description:
-            'When a verification failed only because the site rate-flagged repeated logins (not a defect in your workflow), wait out a cool-off WITHOUT firing any login. After calling this you MUST stop; the orchestrator waits (informing the user) and resumes you so you can run_verification once more.',
+            'Request a delay without running any live action. Use only when the observed site response justifies waiting. After calling this, stop.',
           inputSchema: {
             type: 'object',
             properties: {
@@ -233,7 +423,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
     {
       capabilities: { tools: {} },
       instructions: isAuthMode
-        ? 'These tools let you turn the captured login + 2FA flow into an auth workflow.json. Read the recording, write workflow.json, test it live with run_verification (AWAITING_2FA = success), and call done() when login works. The done tool verifies the workflow structure and will tell you what to fix.'
+        ? 'Compile the recorded login into an auth action program in workflow.json. Define the actions, evidence, state carry, retries, and success criteria from the recording; run those actions live with run_verification, then call done after a declared success action passes.'
         : 'These tools let you reverse-engineer the captured session into workflow.json + parser.ts + parser.test.ts. Read the recording, write the artifacts, run tests, and call done() when verified. The done tool runs external verification and will tell you what to fix if anything is wrong.',
     },
   );
@@ -259,7 +449,12 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
 
     // Custom done — runs verification inline.
     if (name === 'done') {
-      const summary = (args as { summary?: string }).summary ?? 'Task completed';
+      const doneArgs = args as {
+        summary?: string;
+        accept_inconclusive?: boolean;
+        inconclusive_reason?: string;
+      };
+      const summary = doneArgs.summary ?? 'Task completed';
       log(`done() called: ${summary}`);
 
       // Auth mode: lightweight structural verification (the agent already proved
@@ -268,6 +463,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
         const failures = authExternalVerification(
           opts.toolDir,
           (opts.authToolPlan?.captures ?? []).map((c) => ({ name: c.name, usedAs: c.usedAs })),
+          { requireLiveAttempt: true },
         );
         if (failures.length === 0) {
           const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
@@ -292,7 +488,201 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
         }
 
         verificationFailures++;
-        log(`auth verification failed (cycle ${verificationFailures}/${maxVerificationCycles})`);
+        log(`auth verification failed (cycle ${verificationFailures})`);
+
+        return {
+          isError: true,
+          content: [
+            {
+              type: 'text',
+              text: `You called done but verification failed (cycle ${verificationFailures}):
+
+${failures.map((f) => `- ${f}`).join('\n')}
+
+Fix the issues in workflow.json, re-test with run_verification, and call done again when fixed.`,
+            },
+          ],
+        };
+      }
+
+      const finishVerification = beginCompileVerification(opts.toolDir);
+      try {
+        const { failures, warnings, paramVerification, integrationEvidence } =
+          await externalVerification(opts.toolDir, session, opts.sessionPath, {
+            expectedToolName: opts.candidate?.toolName,
+            likelyParams: opts.candidate?.likelyParams,
+            candidateRequestSeqs: opts.candidate?.requestSeqs,
+            // Widen Fix B's variation pool to dependency requests so a token that
+            // varies only across them and is frozen as a literal in the tool's
+            // request is caught (the cross-request session-token leak case).
+            dependencyRequestSeqs: opts.candidate?.dependencySeqs,
+            assignedSharedModules,
+            tokenParams,
+            tokenParamShapes,
+            emittedTokens,
+            requiredInputs,
+            credentialValues,
+            credentialNames: opts.sharedContext?.credentialNames,
+            deferLiveIntegrationToSemanticAgent: true,
+          });
+        if (warnings.length > 0) {
+          log(`verification warnings (non-blocking):\n${warnings.join('\n')}`);
+        }
+        if (failures.length === 0) {
+          if (!opts.provider) {
+            failures.push('compile provider was not supplied to the independent semantic verifier');
+          } else {
+            const currentFingerprint = compileArtifactFingerprint(opts.toolDir);
+            if (
+              pendingInconclusive &&
+              canAcceptInconclusiveDecision({
+                pendingFingerprint: pendingInconclusive.artifactFingerprint,
+                currentFingerprint,
+                acceptInconclusive: doneArgs.accept_inconclusive,
+                inconclusiveReason: doneArgs.inconclusive_reason,
+              })
+            ) {
+              const semantic = pendingInconclusive.report;
+              const semanticParams = mergeSemanticParamVerification(
+                paramVerification,
+                semantic.report,
+              );
+              const inconclusiveReason = doneArgs.inconclusive_reason?.trim() ?? '';
+              applyLiveVerification(opts.toolDir, {
+                kind: 'waived-infra',
+                firstError: inconclusiveReason,
+                exhaustedBackends: [],
+              });
+              const paramWarnings = applyParamVerification(opts.toolDir, semanticParams);
+              // The unverified stamp and parameter annotations are metadata-only,
+              // so carry the already-proven preference to the final workflow hash.
+              rebindExistingBackendsCacheToWorkflow(opts.toolDir);
+              const allWarnings = [
+                ...warnings,
+                `independent semantic verification was inconclusive: ${semantic.report.summary}`,
+                ...paramWarnings,
+              ];
+              const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
+              writeFileSync(
+                sentinel,
+                JSON.stringify(
+                  {
+                    summary,
+                    verification: 'passed',
+                    liveVerified: false,
+                    semanticVerification: {
+                      status: semantic.report.status,
+                      provider: semantic.provider,
+                      model: semantic.model,
+                      attempts: semantic.attempts,
+                      evidenceArtifact: semantic.report.evidenceArtifact,
+                      logArtifact: semantic.report.logArtifact,
+                    },
+                    compilerDecision: {
+                      decision: 'ship_unverified',
+                      reason: inconclusiveReason,
+                    },
+                    warnings: allWarnings,
+                    timestamp: Date.now(),
+                  },
+                  null,
+                  2,
+                ),
+                'utf8',
+              );
+              log(`compiler accepted unchanged inconclusive artifact; wrote ${sentinel}`);
+              return {
+                content: [
+                  {
+                    type: 'text',
+                    text: `DONE_UNVERIFIED — deterministic verification passed and the compiler explicitly accepted the unchanged artifact after an infrastructure-only inconclusive live review. 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.`,
+                  },
+                ],
+              };
+            }
+
+            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,
+            });
+            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(),
+                  },
+                  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) {
           const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
           writeFileSync(
@@ -303,6 +693,7 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
                 verification: 'failed',
                 cycles: verificationFailures,
                 failures,
+                warnings,
                 timestamp: Date.now(),
               },
               null,
@@ -321,116 +712,57 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
           };
         }
 
-        return {
-          isError: true,
-          content: [
-            {
-              type: 'text',
-              text: `You called done but verification failed (cycle ${verificationFailures}/${maxVerificationCycles}):
+        const continuationMessage = `You called done but verification failed (cycle ${verificationFailures}/${maxVerificationCycles}):
 
 ${failures.map((f) => `- ${f}`).join('\n')}
 
-Fix the issues in workflow.json, re-test with run_verification, and call done again when fixed.`,
-            },
-          ],
-        };
-      }
-
-      const { failures, warnings, paramVerification, liveVerification } =
-        await externalVerification(opts.toolDir, session, opts.sessionPath, {
-          expectedToolName: opts.candidate?.toolName,
-          likelyParams: opts.candidate?.likelyParams,
-          candidateRequestSeqs: opts.candidate?.requestSeqs,
-          // Widen Fix B's variation pool to dependency requests so a token that
-          // varies only across them and is frozen as a literal in the tool's
-          // request is caught (the cross-request session-token leak case).
-          dependencyRequestSeqs: opts.candidate?.dependencySeqs,
-          assignedSharedModules,
-          tokenParams,
-          tokenParamShapes,
-          emittedTokens,
-          requiredInputs,
-          credentialValues,
-          credentialNames: opts.sharedContext?.credentialNames,
-        });
-      if (warnings.length > 0) {
-        log(`verification warnings (non-blocking):\n${warnings.join('\n')}`);
-      }
-      if (failures.length === 0) {
-        // Persist per-parameter verified flags + the live-verification stamp
-        // onto workflow.json. Audit and teach read the stamp.
-        applyLiveVerification(opts.toolDir, liveVerification);
-        const paramWarnings = applyParamVerification(opts.toolDir, paramVerification);
-        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', warnings: allWarnings, timestamp: Date.now() },
-            null,
-            2,
-          ),
-          'utf8',
-        );
-        log(`verification passed; wrote ${sentinel}`);
-        return {
-          content: [
-            {
-              type: 'text',
-              text: 'DONE_VERIFIED — verification passed. The orchestrator will exit shortly. Do not call any more tools.',
-            },
-          ],
-        };
-      }
-
-      verificationFailures++;
-      log(`verification failed (cycle ${verificationFailures}/${maxVerificationCycles})`);
-      if (verificationFailures >= maxVerificationCycles) {
-        const sentinel = pathJoin(opts.toolDir, DONE_SENTINEL);
-        writeFileSync(
-          sentinel,
-          JSON.stringify(
-            {
-              summary,
-              verification: 'failed',
-              cycles: verificationFailures,
-              failures,
-              warnings,
-              timestamp: Date.now(),
-            },
-            null,
-            2,
-          ),
-          'utf8',
-        );
+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 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.'
+          : '';
         return {
           isError: true,
           content: [
             {
               type: 'text',
-              text: `Verification failed after ${maxVerificationCycles} cycles. Giving up. Final failures:\n${failures.map((f) => `- ${f}`).join('\n')}`,
+              text: continuationMessage + compilerDecisionGuidance + inconclusiveDecisionGuidance,
             },
           ],
         };
+      } finally {
+        finishVerification();
       }
-
-      const continuationMessage = `You called done but verification failed (cycle ${verificationFailures}/${maxVerificationCycles}):
-
-${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.`;
-      return {
-        isError: true,
-        content: [{ type: 'text', text: continuationMessage }],
-      };
     }
 
     // Auth-mode checkpoint tools — record the request and end the segment. The
     // orchestrator performs the action live and resumes the agent with the result.
-    if (name === 'run_verification' || name === 'prompt_user' || name === 'wait_for_cooldown') {
+    if (
+      name === 'run_verification' ||
+      name === 'inspect_verification_page' ||
+      name === 'prompt_user' ||
+      name === 'wait_for_cooldown'
+    ) {
+      if (name === 'run_verification') {
+        const failures = authWorkflowPreflightFailures(
+          opts.toolDir,
+          session,
+          opts.authToolPlan?.credentialNames,
+        );
+        if (failures.length > 0) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: 'text',
+                text: `run_verification blocked by auth workflow preflight. Fix workflow.json before requesting live verification:\n${failures
+                  .map((failure) => `- ${failure}`)
+                  .join('\n')}`,
+              },
+            ],
+          };
+        }
+      }
       if (checkpointWritten) {
         return {
           isError: true,
@@ -524,4 +856,5 @@ export const COMPILE_SENTINELS = {
   done: DONE_SENTINEL,
   giveUp: GIVE_UP_SENTINEL,
   checkpoint: CHECKPOINT_SENTINEL,
+  verificationState: VERIFICATION_STATE_SENTINEL,
 } as const;