imprint-mcp 0.2.0 → 0.3.0

package/src/imprint/llm.ts

@@ -6,6 +6,7 @@ import {
   llmSpanAttributes,
   resolveTraceTokenCount,
   setSpanAttributes,
+  totalPromptTokens,
   traceLlmIoEnabled,
   traceLlmMessages,
   traced,
@@ -17,6 +18,16 @@ interface AnalyzeResult {
   text: string;
   inputTokens: number | null;
   outputTokens: number | null;
+  /**
+   * Prompt-cache token counts, when the provider reports them. `inputTokens` is
+   * the *uncached* input only (the Anthropic/CLI `usage.input_tokens`); the bulk
+   * of a cache-hit call lives here. Threaded through so `llm.analyze` cost is
+   * cache-aware (cache reads bill at 0.1×, writes at 1.25×) instead of charging
+   * the whole prompt at the full input rate. Null/undefined for providers that
+   * don't expose usage (codex-cli, cursor-cli).
+   */
+  cacheReadInputTokens?: number | null;
+  cacheCreationInputTokens?: number | null;
   durationMs: number;
   stopReason: string | null;
 }
@@ -129,6 +140,8 @@ class AnthropicApiProvider implements LLMProvider {
           text,
           inputTokens: response.usage.input_tokens,
           outputTokens: response.usage.output_tokens,
+          cacheReadInputTokens: response.usage.cache_read_input_tokens ?? null,
+          cacheCreationInputTokens: response.usage.cache_creation_input_tokens ?? null,
           durationMs: Date.now() - t0,
           stopReason: response.stop_reason ?? null,
         };
@@ -256,7 +269,15 @@ class ClaudeCliProvider implements LLMProvider {
           );
         }
 
-        let parsed: { result?: string; usage?: { input_tokens?: number; output_tokens?: number } };
+        let parsed: {
+          result?: string;
+          usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_read_input_tokens?: number;
+            cache_creation_input_tokens?: number;
+          };
+        };
         try {
           parsed = JSON.parse(stdout);
         } catch (parseErr) {
@@ -273,6 +294,8 @@ class ClaudeCliProvider implements LLMProvider {
           text: parsed.result,
           inputTokens: parsed.usage?.input_tokens ?? null,
           outputTokens: parsed.usage?.output_tokens ?? null,
+          cacheReadInputTokens: parsed.usage?.cache_read_input_tokens ?? null,
+          cacheCreationInputTokens: parsed.usage?.cache_creation_input_tokens ?? null,
           durationMs: Date.now() - t0,
           stopReason: null,
         };
@@ -437,7 +460,20 @@ async function traceAnalyze(
     },
     async (span) => {
       const result = await fn();
-      const inputTokens = resolveTraceTokenCount(result.inputTokens, details?.inputText);
+      // Providers report `inputTokens` as the *uncached* input only; the cached
+      // portion lives in the cache fields. `llmCostAttributes` expects the TOTAL
+      // prompt tokens (it derives uncached = total − cacheRead − cacheWrite), so
+      // sum them here. A real total is also large enough to clear the
+      // resolveTraceTokenCount sanity check, so cache-hit calls stop falling back
+      // to the chars/4 estimate.
+      const cacheReadTokens = result.cacheReadInputTokens ?? undefined;
+      const cacheWriteTokens = result.cacheCreationInputTokens ?? undefined;
+      const totalInputTokens = totalPromptTokens(
+        result.inputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+      );
+      const inputTokens = resolveTraceTokenCount(totalInputTokens, details?.inputText);
       const outputTokens = resolveTraceTokenCount(result.outputTokens, result.text);
       setSpanAttributes(span, {
         ...llmSpanAttributes({
@@ -445,6 +481,8 @@ async function traceAnalyze(
           model,
           inputTokens: inputTokens.tokens,
           outputTokens: outputTokens.tokens,
+          cacheReadTokens,
+          cacheWriteTokens,
           tokenCountsEstimated:
             inputTokens.source === 'estimated' || outputTokens.source === 'estimated',
           inputTokenSource: inputTokens.source,
@@ -512,12 +550,20 @@ async function traceMessageWithTools(
           return `[${b.type}]`;
         })
         .join('\n');
+      const cacheReadTokens = response.usage.cache_read_input_tokens ?? undefined;
+      const cacheWriteTokens = response.usage.cache_creation_input_tokens ?? undefined;
       setSpanAttributes(span, {
         ...llmSpanAttributes({
           provider,
           model,
-          inputTokens: response.usage.input_tokens,
+          inputTokens: totalPromptTokens(
+            response.usage.input_tokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+          ),
           outputTokens: response.usage.output_tokens,
+          cacheReadTokens,
+          cacheWriteTokens,
           stopReason: response.stop_reason,
           outputMessages: captureIo
             ? traceLlmMessages([{ role: 'assistant', content: outputText }])
@@ -824,7 +870,7 @@ export function detectTeachProvider(): ProviderName {
 }
 
 function createProvider(name: ProviderName, opts: LLMOptions = {}): LLMProvider {
-  const model = opts.model ?? process.env.ANTHROPIC_MODEL ?? 'claude-opus-4-7';
+  const model = opts.model ?? process.env.ANTHROPIC_MODEL ?? 'claude-opus-4-8';
   const temperature = opts.temperature ?? 0;
   const maxTokens = opts.maxTokens ?? 8192;
 
@@ -865,11 +911,11 @@ export function preferredAgentModel(provider: ProviderName): string {
   switch (provider) {
     case 'anthropic-api':
     case 'claude-cli':
-      return 'claude-opus-4-7';
+      return 'claude-opus-4-8';
     case 'codex-cli':
       return 'gpt-5.5';
     case 'cursor-cli':
-      return 'claude-opus-4-7'; // best-effort; cursor passes through
+      return 'claude-opus-4-8'; // best-effort; cursor passes through
   }
 }
 
@@ -883,7 +929,8 @@ export function availableModelsForProvider(provider: ProviderName): ModelOption[
     case 'anthropic-api':
     case 'claude-cli':
       return [
-        { model: 'claude-opus-4-7', isDefault: true },
+        { model: 'claude-opus-4-8', isDefault: true },
+        { model: 'claude-opus-4-7', isDefault: false },
         { model: 'claude-sonnet-4-6', isDefault: false },
         { model: 'claude-haiku-4-5', isDefault: false },
         { model: 'claude-opus-4-6', isDefault: false },
@@ -908,7 +955,8 @@ export function availableModelsForProvider(provider: ProviderName): ModelOption[
       ];
     case 'cursor-cli':
       return [
-        { model: 'claude-opus-4-7', isDefault: true },
+        { model: 'claude-opus-4-8', isDefault: true },
+        { model: 'claude-opus-4-7', isDefault: false },
         { model: 'claude-sonnet-4-6', isDefault: false },
         { model: 'claude-haiku-4-5', isDefault: false },
         { model: 'gpt-5.5', isDefault: false },

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

@@ -24,7 +24,13 @@ import {
   ListToolsRequestSchema,
   type Tool,
 } from '@modelcontextprotocol/sdk/types.js';
-import { buildCompileTools, externalVerification } from './compile-tools.ts';
+import { type SharedModuleManifestEntry, resolvePlanSliceFromFile } from './build-plan.ts';
+import {
+  applyLiveVerification,
+  applyParamVerification,
+  buildCompileTools,
+  externalVerification,
+} from './compile-tools.ts';
 import { loadJsonFile } from './load-json.ts';
 import { createLog } from './log.ts';
 import { redactSession } from './redact.ts';
@@ -43,6 +49,10 @@ interface RunCompileMcpServerOptions {
   maxVerificationCycles?: number;
   candidate?: ToolCandidate;
   sharedContext?: SharedCompileContext;
+  /** Absolute path to the multi-tool build plan sidecar (.build-plan.json). */
+  buildPlanPath?: string;
+  /** Shared-module build manifest for this site (verified flags). */
+  sharedModules?: SharedModuleManifestEntry[];
 }
 
 const DONE_SENTINEL = '.compile-done.json';
@@ -67,12 +77,24 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
     session = redactSession(session).session;
   }
 
-  // Build the 8 read/write tools (same as the in-process loop).
+  // Build the read/write tools (same as the in-process loop). When a build
+  // plan is present, buildCompileTools also exposes read_build_plan.
   const compileTools = buildCompileTools(session, opts.toolDir, opts.sessionPath, {
     candidate: opts.candidate,
     sharedContext: opts.sharedContext,
+    buildPlanPath: opts.buildPlanPath,
+    sharedModules: opts.sharedModules,
   });
 
+  // Resolve the shared modules + producer→consumer token contracts the plan
+  // assigned this tool, so verification can assert modules are imported and
+  // require a chained test for each producer-sourced token param.
+  const { assignedSharedModules, tokenParams, emittedTokens } = resolvePlanSliceFromFile(
+    opts.buildPlanPath,
+    opts.candidate?.toolName,
+    opts.sharedModules,
+  );
+
   // The custom done/give_up tools live alongside in MCP space.
   const doneTool: Tool = {
     name: 'done',
@@ -136,25 +158,36 @@ export async function runCompileMcpServer(opts: RunCompileMcpServerOptions): Pro
     if (name === 'done') {
       const summary = (args as { summary?: string }).summary ?? 'Task completed';
       log(`done() called: ${summary}`);
-      const { failures, warnings } = await externalVerification(
-        opts.toolDir,
-        session,
-        opts.sessionPath,
-        {
+      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,
+          emittedTokens,
+        });
       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, timestamp: Date.now() },
+            { summary, verification: 'passed', warnings: allWarnings, timestamp: Date.now() },
             null,
             2,
           ),

package/src/imprint/mcp-maintenance.ts

@@ -28,7 +28,6 @@ import * as p from '@clack/prompts';
 import YAML from 'yaml';
 import { imprintHomeDir, localSiteDir } from './paths.ts';
 import {
-  type TeachState,
   type WorkflowState,
   loadTeachState,
   resolveTeachStatePath,
@@ -38,7 +37,7 @@ import {
 
 type McpClient = 'claude-code' | 'codex' | 'claude-desktop' | 'openclaw' | 'hermes';
 type LocalDeleteMode = 'none' | 'tool' | 'site';
-type IssueKind = 'incomplete' | 'missing-session' | 'orphan-session' | 'stale-registration';
+type IssueKind = 'incomplete' | 'missing-session' | 'stale-registration';
 
 const CLIENTS: McpClient[] = ['claude-code', 'codex', 'claude-desktop', 'openclaw', 'hermes'];
 const DISABLED_STORE_VERSION = 1;
@@ -100,7 +99,6 @@ interface LocalSiteStatus {
   dir: string;
   tools: LocalToolStatus[];
   workflows: LocalWorkflowStatus[];
-  orphanSessions: string[];
 }
 
 interface McpIssue {
@@ -393,22 +391,6 @@ async function runInteractiveIssueFix(status: McpStatus, ctx: MaintenanceContext
     return;
   }
 
-  const orphanIssues = indices
-    .map((i) => status.issues[i])
-    .filter(
-      (issue): issue is McpIssue => !!issue && issue.kind === 'orphan-session' && !!issue.path,
-    );
-
-  let deleteOrphans = true;
-  if (orphanIssues.length > 0) {
-    const confirm = await p.confirm({
-      message: `Delete ${orphanIssues.length} orphan session file${orphanIssues.length === 1 ? '' : 's'}?`,
-      initialValue: false,
-    });
-    if (p.isCancel(confirm)) return;
-    deleteOrphans = confirm === true;
-  }
-
   const aggregate: MutationResult = { changed: [], skipped: [] };
   for (const index of indices) {
     const issue = status.issues[index];
@@ -416,17 +398,12 @@ async function runInteractiveIssueFix(status: McpStatus, ctx: MaintenanceContext
       appendMutation(aggregate, { changed: [], skipped: ['selection disappeared'] });
       continue;
     }
-    appendMutation(aggregate, fixIssue(issue, status, ctx, { deleteOrphans }));
+    appendMutation(aggregate, fixIssue(issue, status, ctx));
   }
   reportMutation(aggregate);
 }
 
-function fixIssue(
-  issue: McpIssue,
-  status: McpStatus,
-  ctx: MaintenanceContext,
-  opts: { deleteOrphans: boolean },
-): MutationResult {
+function fixIssue(issue: McpIssue, status: McpStatus, ctx: MaintenanceContext): MutationResult {
   if (issue.kind === 'stale-registration') {
     const reg = status.registrations.find(
       (r) =>
@@ -446,13 +423,6 @@ function fixIssue(
     return pruneSingleTeachWorkflow(issue.site, issue.workflow);
   }
 
-  if (issue.kind === 'orphan-session' && issue.path) {
-    if (!opts.deleteOrphans) {
-      return { changed: [], skipped: [`kept orphan session ${issue.path}`] };
-    }
-    return deleteOrphanSessionFile(issue.path);
-  }
-
   return { changed: [], skipped: [`no automatic fix for ${issue.kind}`] };
 }
 
@@ -463,7 +433,7 @@ async function runInteractiveLocalDelete(status: McpStatus): Promise<void> {
       const complete = s.tools.filter((t) => t.complete).length;
       return {
         value: s.site,
-        label: `${s.site} (${complete} complete tool${complete === 1 ? '' : 's'}, ${s.orphanSessions.length} orphan session${s.orphanSessions.length === 1 ? '' : 's'})`,
+        label: `${s.site} (${complete} complete tool${complete === 1 ? '' : 's'})`,
       };
     }),
   });
@@ -686,7 +656,7 @@ function formatMcpStatus(status: McpStatus): string {
       const incomplete = s.workflows.filter((w) => w.incomplete).length;
       const missing = s.workflows.filter((w) => w.missingSession).length;
       lines.push(
-        `  ${s.site}: ${complete} complete tool${complete === 1 ? '' : 's'}, ${incomplete} incomplete workflow${incomplete === 1 ? '' : 's'}, ${missing} missing-session issue${missing === 1 ? '' : 's'}, ${s.orphanSessions.length} orphan session${s.orphanSessions.length === 1 ? '' : 's'}`,
+        `  ${s.site}: ${complete} complete tool${complete === 1 ? '' : 's'}, ${incomplete} incomplete workflow${incomplete === 1 ? '' : 's'}, ${missing} missing-session issue${missing === 1 ? '' : 's'}`,
       );
     }
   }
@@ -714,8 +684,6 @@ function issueFixHint(issue: McpIssue): string | null {
       return `choose "Fix an issue" or run: imprint mcp prune-state --site ${issue.site} --incomplete --yes`;
     case 'missing-session':
       return `choose "Fix an issue" or run: imprint mcp prune-state --site ${issue.site} --missing-session --yes`;
-    case 'orphan-session':
-      return 'choose "Fix an issue" to delete this recording, or keep it if you still need it';
   }
   return null;
 }
@@ -737,12 +705,12 @@ function scanLocalSites(ctx: MaintenanceContext): LocalSiteStatus[] {
     if (entry === 'node_modules' || entry.startsWith('.')) continue;
     const dir = pathJoin(ctx.imprintHome, entry);
     if (!safeIsDir(dir)) continue;
-    sites.push(scanLocalSite(ctx, entry, dir));
+    sites.push(scanLocalSite(entry, dir));
   }
   return sites;
 }
 
-function scanLocalSite(ctx: MaintenanceContext, site: string, dir: string): LocalSiteStatus {
+function scanLocalSite(site: string, dir: string): LocalSiteStatus {
   const tools: LocalToolStatus[] = [];
   for (const entry of readdirSync(dir).sort()) {
     if (entry === 'sessions' || entry === '_shared' || entry.startsWith('.')) continue;
@@ -764,12 +732,8 @@ function scanLocalSite(ctx: MaintenanceContext, site: string, dir: string): Loca
   const workflows = Object.entries(state.workflows)
     .map(([name, ws]) => workflowStatus(site, name, ws, tools))
     .sort((a, b) => a.name.localeCompare(b.name));
-  const referenced = referencedSessionPaths(site, state);
-  const orphanSessions = discoverSessionFiles(pathJoin(dir, 'sessions')).filter(
-    (session) => !isReferencedSessionFile(site, session, ctx, referenced),
-  );
 
-  return { site, dir, tools, workflows, orphanSessions };
+  return { site, dir, tools, workflows };
 }
 
 function workflowStatus(
@@ -813,47 +777,6 @@ function workflowJsonToolName(toolDir: string): string | null {
   }
 }
 
-function referencedSessionPaths(site: string, state: TeachState): Set<string> {
-  const out = new Set<string>();
-  for (const ws of Object.values(state.workflows)) {
-    for (const stored of [ws.sessionPath, ws.redactedPath, ws.triagedPath]) {
-      if (!stored) continue;
-      out.add(stored);
-      const resolved = resolveTeachStatePath(site, stored);
-      if (resolved) out.add(resolved);
-    }
-  }
-  return out;
-}
-
-function discoverSessionFiles(sessionDir: string): string[] {
-  if (!existsSync(sessionDir)) return [];
-  return readdirSync(sessionDir)
-    .filter((f) => (f.endsWith('.json') || f.endsWith('.jsonl')) && !f.includes('.triaged'))
-    .map((f) => pathJoin(sessionDir, f))
-    .sort();
-}
-
-function isReferencedSessionFile(
-  site: string,
-  absolutePath: string,
-  ctx: MaintenanceContext,
-  referenced: Set<string>,
-): boolean {
-  const candidates = [absolutePath, relativeToSite(site, absolutePath, ctx)];
-  if (absolutePath.endsWith('.jsonl')) {
-    const jsonPath = absolutePath.replace(/\.jsonl$/, '.json');
-    candidates.push(jsonPath, relativeToSite(site, jsonPath, ctx));
-  }
-  return candidates.some((candidate) => referenced.has(candidate));
-}
-
-function relativeToSite(site: string, absolutePath: string, ctx: MaintenanceContext): string {
-  const siteDir = pathJoin(ctx.imprintHome, site);
-  const prefix = `${siteDir}/`;
-  return absolutePath.startsWith(prefix) ? absolutePath.slice(prefix.length) : absolutePath;
-}
-
 function collectIssues(opts: {
   registrations: McpRegistration[];
   sites: LocalSiteStatus[];
@@ -881,14 +804,6 @@ function collectIssues(opts: {
         });
       }
     }
-    for (const session of site.orphanSessions) {
-      issues.push({
-        kind: 'orphan-session',
-        site: site.site,
-        message: `${site.site} has an untracked session ${session}`,
-        path: session,
-      });
-    }
   }
 
   for (const r of opts.registrations) {
@@ -1174,7 +1089,7 @@ function pruneTeachState(
   for (const site of sites) {
     const statePath = teachStatePath(site);
     if (!existsSync(statePath)) continue;
-    const status = scanLocalSite(ctx, site, localSiteDir(site));
+    const status = scanLocalSite(site, localSiteDir(site));
     const remove = new Set(
       status.workflows
         .filter(
@@ -1208,13 +1123,6 @@ function pruneSingleTeachWorkflow(site: string, workflow: string): MutationResul
   return { changed: [`pruned teach-state entry ${site}/${workflow}`], skipped: [] };
 }
 
-function deleteOrphanSessionFile(path: string): MutationResult {
-  if (!existsSync(path))
-    return { changed: [], skipped: [`orphan session ${path} no longer exists`] };
-  rmSync(path, { force: true });
-  return { changed: [`deleted orphan session ${path}`], skipped: [] };
-}
-
 function matchesTarget(
   reg: McpRegistration,
   target: string,

package/src/imprint/mcp-server.ts

@@ -17,6 +17,7 @@ import {
   type Tool,
 } from '@modelcontextprotocol/sdk/types.js';
 import { resolveLadder, runWithLadder } from './backend-ladder.ts';
+import type { CdpBrowserFetch } from './cdp-browser-fetch.ts';
 import { createLog } from './log.ts';
 import { imprintHomeDir } from './paths.ts';
 import { loadBackendsCache } from './probe-backends.ts';
@@ -66,11 +67,17 @@ function buildToolDescription(w: ResolvedTool['workflow']): string {
 
 /** MCP advertises tool input as JSON Schema; build it directly from
  *  workflow parameters rather than going through Zod. */
-function buildJsonSchema(parameters: WorkflowParameter[]): Tool['inputSchema'] {
+export function buildJsonSchema(parameters: WorkflowParameter[]): Tool['inputSchema'] {
   const properties: Record<string, { type: string; description: string }> = {};
   const required: string[] = [];
   for (const p of parameters) {
-    properties[p.name] = { type: p.type, description: p.description };
+    // Producer-sourced token params: tell the orchestrating LLM where to mint the
+    // value so it calls the producer once and reuses it, rather than fabricating
+    // an opaque token (which the tool would reject).
+    const description = p.sourcedFrom
+      ? `${p.description} Obtain this value from the \`${p.sourcedFrom.tool}\` tool's \`${p.sourcedFrom.field}\` output — call \`${p.sourcedFrom.tool}\` first and reuse the value across calls (no need to re-fetch each time).`
+      : p.description;
+    properties[p.name] = { type: p.type, description };
     if (p.default === undefined) required.push(p.name);
   }
   return {
@@ -88,13 +95,13 @@ function buildServer(
   version: string,
   tools: ResolvedTool[],
   assetRoot: string,
-): Server {
+): { server: Server; closeCdpPool: () => Promise<void> } {
   const server = new Server(
     { name, version },
     {
       capabilities: { tools: {} },
       instructions:
-        'Imprint runs deterministic workflows captured from real browser sessions. Tools prefer fetch API replay, may use gated fetch-bootstrap only for declared browser-minted state, then stealth-fetch for bot-defense state, and playbook only for full DOM interaction. Error codes: AUTH_EXPIRED (401, run `imprint login <site>`); STATE_MISSING (required cookie/state was unavailable or ambiguous); FORBIDDEN (403); RATE_LIMITED (429, back off); BAD_RESPONSE (other 4xx/5xx); NETWORK (fetch failed); UNKNOWN (everything else).',
+        'Imprint runs deterministic workflows captured from real browser sessions. Tools prefer fetch API replay, may use gated fetch-bootstrap only for declared browser-minted state, then cdp-replay (API requests run inside a live trusted Chrome so a protected POST refreshes its anti-bot token between calls) for multi-step state-changing flows, then stealth-fetch for bot-defense state, and playbook only for full DOM interaction. Error codes: AUTH_EXPIRED (401, run `imprint login <site>`); STATE_MISSING (required cookie/state was unavailable or ambiguous); FORBIDDEN (403); RATE_LIMITED (429, back off); BAD_RESPONSE (other 4xx/5xx); NETWORK (fetch failed); UNKNOWN (everything else).',
     },
   );
 
@@ -105,6 +112,21 @@ function buildServer(
   // Per-site stealth-fetch cache so the ~12s bootstrap runs once per site.
   const stealthCache = new Map<string, StealthFetch>();
 
+  // Per-site CDP browser pool: cdp-replay stores its live Chrome here after
+  // the first successful call so subsequent calls reuse it (~2-5s vs ~33s).
+  const cdpPool = new Map<string, CdpBrowserFetch>();
+  const cdpIdleTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  const CDP_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
+  // Per-tool memo of the winning backend for THIS server session. After the
+  // first call discovers the right rung, later calls skip the doomed early ones
+  // (e.g. southwest's ~80s fetch-bootstrap FORBIDDEN before cdp-replay wins). Its
+  // lifetime is tied to `cdpPool`: the memoized cdp-replay is only cheap while
+  // its Chrome is pooled, so a site's memo is evicted when that pool entry is
+  // idle-closed (below) — otherwise the next call would start at a now-cold
+  // cdp-replay and re-pay the ~33s relaunch.
+  const winnerCache = new Map<string, ConcreteBackend>();
+
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: tools.map((t) => ({
       name: t.workflow.toolName,
@@ -140,6 +162,15 @@ function buildServer(
       string | number | boolean
     >;
 
+    // Audit-only pacing: when the audit harness sets IMPRINT_AUDIT_PACING_MS,
+    // sleep before each tool call so the auditor's per-parameter differential
+    // probing of bot-defended idempotent reads stays steady enough not to trip
+    // the per-IP anti-bot defense. Unset in production → no delay.
+    const pacingMs = Number(process.env.IMPRINT_AUDIT_PACING_MS);
+    if (Number.isFinite(pacingMs) && pacingMs > 0) {
+      await new Promise((r) => setTimeout(r, pacingMs));
+    }
+
     try {
       const ladder = resolveLadder('auto', tool.preferredOrder);
       const { result, usedBackend } = await runWithLadder(
@@ -148,7 +179,29 @@ function buildServer(
         args,
         assetRoot,
         stealthCache,
+        { cdpPool, winnerCache },
       );
+      // Reset the idle timer for this site's pooled Chrome.
+      if (result.ok && usedBackend === 'cdp-replay' && cdpPool.has(tool.site)) {
+        const prev = cdpIdleTimers.get(tool.site);
+        if (prev) clearTimeout(prev);
+        const timer = setTimeout(() => {
+          const cf = cdpPool.get(tool.site);
+          if (cf) {
+            log(`closing idle CDP session for ${tool.site}`);
+            cf.close().catch(() => {});
+            cdpPool.delete(tool.site);
+            cdpIdleTimers.delete(tool.site);
+            // Drop this site's winner memo too: a memoized cdp-replay would now
+            // point at a closed Chrome and re-pay the cold relaunch.
+            for (const key of winnerCache.keys()) {
+              if (key.startsWith(`${tool.site}:`)) winnerCache.delete(key);
+            }
+          }
+        }, CDP_IDLE_TIMEOUT_MS);
+        timer.unref();
+        cdpIdleTimers.set(tool.site, timer);
+      }
       if (!result.ok) {
         const text = formatToolError(result);
         return {
@@ -165,7 +218,18 @@ function buildServer(
     }
   });
 
-  return server;
+  async function closeCdpPool(): Promise<void> {
+    for (const [site, cf] of cdpPool) {
+      log(`shutdown: closing CDP session for ${site}`);
+      await cf.close().catch(() => {});
+    }
+    cdpPool.clear();
+    for (const timer of cdpIdleTimers.values()) clearTimeout(timer);
+    cdpIdleTimers.clear();
+    winnerCache.clear();
+  }
+
+  return { server, closeCdpPool };
 }
 
 function formatToolError(result: Extract<ToolResult, { ok: false }>): string {
@@ -263,7 +327,7 @@ async function runStdio(
   tools: ResolvedTool[],
   assetRoot: string,
 ): Promise<void> {
-  const server = buildServer(name, version, tools, assetRoot);
+  const { server, closeCdpPool } = buildServer(name, version, tools, assetRoot);
   const transport = new StdioServerTransport();
   await server.connect(transport);
   log(`stdio transport ready (${tools.length} tool${tools.length === 1 ? '' : 's'})`);
@@ -277,6 +341,7 @@ async function runStdio(
     process.once('SIGINT', () => done('SIGINT'));
     process.once('SIGTERM', () => done('SIGTERM'));
   });
+  await closeCdpPool();
 }
 
 /**
@@ -296,7 +361,7 @@ async function runHttp(
   port: number,
   assetRoot: string,
 ): Promise<void> {
-  const server = buildServer(name, version, tools, assetRoot);
+  const { server, closeCdpPool } = buildServer(name, version, tools, assetRoot);
   const transport = new StreamableHTTPServerTransport({
     sessionIdGenerator: () => crypto.randomUUID(),
   });
@@ -347,4 +412,5 @@ async function runHttp(
     process.once('SIGINT', () => shutdown('SIGINT'));
     process.once('SIGTERM', () => shutdown('SIGTERM'));
   });
+  await closeCdpPool();
 }

package/src/imprint/multi-progress.ts

@@ -55,15 +55,20 @@ export class MultiProgress {
   }
 
   private redraw(): void {
+    const cols = process.stderr.columns || 80;
     let buf = '';
     if (this.renderedCount > 0) {
       buf += `\x1b[${this.renderedCount}F`;
     }
     buf += '\x1b[J';
+    let physicalLines = 0;
     for (const [, msg] of this.lines) {
-      buf += `│  ${msg}\n`;
+      const line = `│  ${msg}`;
+      const truncated = line.length >= cols ? line.slice(0, cols - 1) : line;
+      buf += `${truncated}\n`;
+      physicalLines += 1;
     }
     process.stderr.write(buf);
-    this.renderedCount = this.lines.size;
+    this.renderedCount = physicalLines;
   }
 }