@provos/ironcurtain 0.11.0 → 0.13.0

package/dist/pipeline/pipeline-runner.d.ts

@@ -13,6 +13,7 @@
 import type { LanguageModelV3 } from '@ai-sdk/provider';
 import type { LanguageModel } from 'ai';
 import type { MCPServerConfig } from '../config/types.js';
+import { type ServerProgressReporter } from './pipeline-shared.js';
 import type { PromptCacheStrategy } from '../session/prompt-cache.js';
 import type { CompiledPolicyFile, CompiledRule, DynamicListsFile, ListDefinition, StoredToolAnnotationsFile, TestScenario, ToolAnnotation } from './types.js';
 /**
@@ -67,6 +68,41 @@ export interface PipelineRunConfig {
      * When undefined, the pre-filter is skipped.
      */
     readonly prefilterText?: string;
+    /**
+     * Factory for per-server progress reporters. When provided, both the
+     * sequential and parallel paths use this instead of the built-in ora/spinner
+     * (sequential) or multi-line (parallel) reporters. Non-TTY callers (e.g. the
+     * daemon driving a compile over the WS surface) inject an event-bus reporter
+     * here. Absent => the built-in reporters are used (CLI behavior).
+     */
+    readonly reporterFactory?: (serverName: string) => ServerProgressReporter;
+    /**
+     * Cooperative cancellation. Threaded into every LLM call (`abortSignal`) and
+     * checked at each per-phase boundary so a long compile aborts promptly.
+     */
+    readonly signal?: AbortSignal;
+    /**
+     * Suppress narrative stderr output. The daemon path sets this so progress is
+     * routed through `onProgress`/`reporterFactory` instead of polluting stderr.
+     * When `quiet` is true, a `reporterFactory` MUST be supplied — there is no
+     * silent fallback to the ora/spinner reporter (it would write to stderr).
+     */
+    readonly quiet?: boolean;
+    /**
+     * Whether the list resolver may connect to live MCP servers to resolve
+     * data-backed (`requiresMcp: true`) lists. Defaults to true (CLI). The WS
+     * compile path sets this to false: there is no live MCP available, so any
+     * list definition that requires MCP fails fast with a typed error rather than
+     * silently resolving to empty.
+     */
+    readonly allowMcpLists?: boolean;
+    /**
+     * Optional validation hook invoked on the in-memory merged policy BEFORE any
+     * artifact is written. Throwing rejects the compile and leaves all prior
+     * artifacts intact (no partial write). Used by the WS surface to enforce
+     * additional invariants (e.g. server scoping) atomically.
+     */
+    readonly validateCompiled?: (policy: CompiledPolicyFile, dynamicLists?: DynamicListsFile) => void;
 }
 /**
  * LLM model references shared across pipeline runs.
@@ -80,8 +116,14 @@ export interface PipelineModels {
     /** Cheap model for pre-filter classification (Haiku). */
     readonly prefilterModel: LanguageModel;
 }
-/** Creates PipelineModels from user config. Delegates to shared createPipelineLlm. */
-export declare function createPipelineModels(logDir?: string): Promise<PipelineModels>;
+/**
+ * Creates PipelineModels from user config. Delegates to shared createPipelineLlm.
+ *
+ * `logFileName` overrides the default `llm-interactions.jsonl` filename so a
+ * caller can scope the log to a single operation (e.g. the persona compile
+ * orchestrator passes `<operationId>.jsonl`).
+ */
+export declare function createPipelineModels(logDir?: string, logFileName?: string): Promise<PipelineModels>;
 /** Output from a single server's compilation cycle. */
 interface ServerCompilationResult {
     readonly serverName: string;
@@ -92,6 +134,23 @@ interface ServerCompilationResult {
     readonly constitutionHash: string;
     readonly resolvedLists?: DynamicListsFile;
 }
+/**
+ * A narrative logger for non-progress output (summaries, warnings, gaps).
+ * In quiet mode the message is routed to `onProgress` (so the daemon can
+ * surface it) instead of stderr; otherwise it goes to stderr as before.
+ */
+type NarrativeLogger = (message: string) => void;
+/**
+ * Thrown when a list definition requires live MCP access (`requiresMcp: true`)
+ * but the run was configured with `allowMcpLists: false` (e.g. the WS compile
+ * path, which has no live MCP). Carries a discriminant `code` so callers can
+ * detect it without importing this module (`error.code === 'MCP_LISTS_DISALLOWED'`).
+ */
+export declare class McpListsDisallowedError extends Error {
+    readonly listNames: string[];
+    readonly code = "MCP_LISTS_DISALLOWED";
+    constructor(listNames: string[]);
+}
 /**
  * Computes a content hash for a single server's policy compilation inputs.
  * The hash includes the server name, constitution, annotations, and prompt
@@ -114,7 +173,7 @@ export declare function validateServerScoping(serverName: string, rules: Compile
  * generationPrompt values for the same named list, uses first-wins
  * (alphabetical server order) and logs a warning.
  */
-export declare function deduplicateListDefinitions(defs: ListDefinition[]): ListDefinition[];
+export declare function deduplicateListDefinitions(defs: ListDefinition[], log?: NarrativeLogger): ListDefinition[];
 /**
  * Merges per-server compilation results into a single CompiledPolicyFile.
  * Rules are concatenated in alphabetical server order for determinism.
@@ -123,7 +182,7 @@ export declare function deduplicateListDefinitions(defs: ListDefinition[]): List
 export declare function mergeServerResults(results: ServerCompilationResult[], constitutionHash: string, skippedServers?: Array<{
     serverName: string;
     reason: string;
-}>): CompiledPolicyFile;
+}>, log?: NarrativeLogger): CompiledPolicyFile;
 /**
  * Encapsulates the full policy compilation pipeline:
  * compile rules -> generate scenarios -> verify -> repair loop.

package/dist/pipeline/pipeline-runner.js

@@ -20,17 +20,23 @@ import { PolicyEngine } from '../trusted-process/policy-engine.js';
 import { buildCompilerSystemPrompt, ConstitutionCompilerSession, formatAnnotationsSummary, validateCompiledRules, } from './constitution-compiler.js';
 import { getHandwrittenScenarios } from './handwritten-scenarios.js';
 import { resolveAllLists } from './list-resolver.js';
-import { computeHash, loadExistingArtifact, loadStoredToolAnnotationsFile, resolveRulePaths, writeArtifact, createPipelineLlm, createPerServerModel, createThrottledModel, SpinnerProgressReporter, } from './pipeline-shared.js';
+import { computeHash, loadExistingArtifact, loadStoredToolAnnotationsFile, resolveRulePaths, writeArtifact, removeArtifactIfExists, createPipelineLlm, createPerServerModel, createThrottledModel, SpinnerProgressReporter, } from './pipeline-shared.js';
 import { resolveStoredAnnotationsFile } from '../types/argument-roles.js';
 import { applyScenarioCorrections, buildJudgeSystemPrompt, detectAllDefaultRoleFallbacks, extractScenarioCorrections, filterStructuralConflicts, PolicyVerifierSession, verifyPolicy, } from './policy-verifier.js';
 import { filterInvalidSchemaScenarios } from './scenario-schema-validator.js';
 import { buildGeneratorSystemPrompt, generateScenarios, repairScenarios } from './scenario-generator.js';
 import { prefilterServers } from './server-prefilter.js';
 import { connectViaProxy } from './proxy-mcp-connections.js';
-/** Creates PipelineModels from user config. Delegates to shared createPipelineLlm. */
-export async function createPipelineModels(logDir) {
+/**
+ * Creates PipelineModels from user config. Delegates to shared createPipelineLlm.
+ *
+ * `logFileName` overrides the default `llm-interactions.jsonl` filename so a
+ * caller can scope the log to a single operation (e.g. the persona compile
+ * orchestrator passes `<operationId>.jsonl`).
+ */
+export async function createPipelineModels(logDir, logFileName) {
     const effectiveLogDir = logDir ?? resolve(process.cwd(), 'generated');
-    const llm = await createPipelineLlm(effectiveLogDir, 'unknown');
+    const llm = await createPipelineLlm(effectiveLogDir, 'unknown', logFileName);
     const userConfig = loadUserConfig();
     const haikuBaseLlm = await createLanguageModel(userConfig.prefilterModelId, userConfig);
     const { model: prefilterModel } = createPerServerModel(haikuBaseLlm, llm.logPath, 'prefilter');
@@ -57,18 +63,20 @@ function computeScenariosHash(systemPrompt, handwrittenScenarios) {
  * `mcpServers` may be undefined when compile-policy is run with `--no-mcp`,
  * in which case the check is skipped.
  */
-function warnOnCompileAnnotationGaps(mcpServers, storedAnnotationsFile) {
+function warnOnCompileAnnotationGaps(mcpServers, storedAnnotationsFile, log = (msg) => {
+    console.error(msg);
+}) {
     if (!mcpServers)
         return;
     const { missing } = findAnnotationServerDrift(storedAnnotationsFile, mcpServers);
     if (missing.length === 0)
         return;
-    console.error(chalk.yellow(`Warning: ${missing.length} configured MCP server(s) have no tool annotations: ${missing.map(safeForDisplay).join(', ')}.`));
-    console.error(chalk.yellow('  The compiled policy will have no rules for these servers and their tools will be denied.'));
+    log(chalk.yellow(`Warning: ${missing.length} configured MCP server(s) have no tool annotations: ${missing.map(safeForDisplay).join(', ')}.`));
+    log(chalk.yellow('  The compiled policy will have no rules for these servers and their tools will be denied.'));
     for (const name of missing) {
-        console.error(chalk.yellow(`  Run \`ironcurtain annotate-tools --server ${safeForDisplay(name)}\` to annotate this server.`));
+        log(chalk.yellow(`  Run \`ironcurtain annotate-tools --server ${safeForDisplay(name)}\` to annotate this server.`));
     }
-    console.error('');
+    log('');
 }
 function extractPermittedDirectories(rules) {
     const dirs = new Set();
@@ -131,6 +139,31 @@ function filterAndLogStructuralConflicts(engine, scenarios, label = 'Discarded s
 function toError(err) {
     return err instanceof Error ? err : new Error(String(err));
 }
+function makeNarrativeLogger(config) {
+    if (config.quiet) {
+        const onProgress = config.onProgress;
+        return (msg) => {
+            onProgress?.(msg);
+        };
+    }
+    return (msg) => {
+        console.error(msg);
+    };
+}
+/**
+ * Resolves the reporter for a server. A caller-supplied `reporterFactory`
+ * always wins. When absent: quiet mode has NO fallback (the built-in reporters
+ * write to stderr), so it is a configuration error; non-quiet mode uses the
+ * built-in concrete reporter via `makeDefault`.
+ */
+function resolveReporter(config, serverName, makeDefault) {
+    if (config.reporterFactory)
+        return config.reporterFactory(serverName);
+    if (config.quiet) {
+        throw new Error(`quiet:true requires a reporterFactory; no stderr-free reporter is available for server "${serverName}".`);
+    }
+    return makeDefault();
+}
 class RuleValidationError extends Error {
     errors;
     constructor(errors) {
@@ -139,6 +172,23 @@ class RuleValidationError extends Error {
         this.name = 'RuleValidationError';
     }
 }
+/**
+ * Thrown when a list definition requires live MCP access (`requiresMcp: true`)
+ * but the run was configured with `allowMcpLists: false` (e.g. the WS compile
+ * path, which has no live MCP). Carries a discriminant `code` so callers can
+ * detect it without importing this module (`error.code === 'MCP_LISTS_DISALLOWED'`).
+ */
+export class McpListsDisallowedError extends Error {
+    listNames;
+    code = 'MCP_LISTS_DISALLOWED';
+    constructor(listNames) {
+        super(`Dynamic list(s) require live MCP access but it is disabled (allowMcpLists: false): ` +
+            `${listNames.join(', ')}. Resolve these lists in an environment with MCP available, ` +
+            `or remove the MCP-backed list definitions.`);
+        this.listNames = listNames;
+        this.name = 'McpListsDisallowedError';
+    }
+}
 function validateRulesOrThrow(rules, listDefinitions = [], reporter) {
     const warn = (msg) => (reporter ? reporter.warn(msg) : console.error(msg));
     const ruleValidation = validateCompiledRules(rules, listDefinitions);
@@ -279,7 +329,9 @@ export function validateServerScoping(serverName, rules) {
  * generationPrompt values for the same named list, uses first-wins
  * (alphabetical server order) and logs a warning.
  */
-export function deduplicateListDefinitions(defs) {
+export function deduplicateListDefinitions(defs, log = (msg) => {
+    console.error(msg);
+}) {
     const seen = new Map();
     for (const def of defs) {
         const existing = seen.get(def.name);
@@ -287,7 +339,7 @@ export function deduplicateListDefinitions(defs) {
             seen.set(def.name, def);
         }
         else if (existing.generationPrompt !== def.generationPrompt) {
-            console.error(`  Warning: list "${def.name}" has divergent generation prompts ` +
+            log(`  Warning: list "${def.name}" has divergent generation prompts ` +
                 `across servers. Using first definition (alphabetical server order).`);
         }
     }
@@ -298,11 +350,11 @@ export function deduplicateListDefinitions(defs) {
  * Rules are concatenated in alphabetical server order for determinism.
  * List definitions are deduplicated by name.
  */
-export function mergeServerResults(results, constitutionHash, skippedServers) {
+export function mergeServerResults(results, constitutionHash, skippedServers, log) {
     const sortedResults = [...results].sort((a, b) => a.serverName.localeCompare(b.serverName));
     const allRules = sortedResults.flatMap((r) => r.rules);
     const allListDefs = sortedResults.flatMap((r) => r.listDefinitions);
-    const uniqueListDefs = deduplicateListDefinitions(allListDefs);
+    const uniqueListDefs = deduplicateListDefinitions(allListDefs, log);
     const mergedInputHash = computeHash(...sortedResults.map((r) => r.inputHash));
     const artifact = {
         generatedAt: new Date().toISOString(),
@@ -366,21 +418,22 @@ export class PipelineRunner {
      * to select the appropriate compiler prompt.
      */
     async runPerServer(config) {
+        const log = makeNarrativeLogger(config);
+        config.signal?.throwIfAborted();
         const storedAnnotationsFile = config.preloadedStoredAnnotations ??
             loadStoredToolAnnotationsFile(config.toolAnnotationsDir, config.toolAnnotationsFallbackDir);
         if (!storedAnnotationsFile) {
             throw new Error("tool-annotations.json not found. Run 'ironcurtain annotate-tools' first.");
         }
-        warnOnCompileAnnotationGaps(config.mcpServers, storedAnnotationsFile);
+        warnOnCompileAnnotationGaps(config.mcpServers, storedAnnotationsFile, log);
         // Resolve conditional role specs to flat annotations for compiler prompts
         const toolAnnotationsFile = resolveStoredAnnotationsFile(storedAnnotationsFile);
         const constitutionHash = computeHash(config.constitutionInput);
         // Phase 1: Per-server compilation (with optional Haiku pre-filter)
         const { results: serverResults, skippedServers } = await this.compileAllServers(config, toolAnnotationsFile, constitutionHash, storedAnnotationsFile);
-        // Phase 2: Merge
-        const mergedPolicy = mergeServerResults(serverResults, constitutionHash, skippedServers);
-        writeArtifact(config.outputDir, 'compiled-policy.json', mergedPolicy);
-        // Merge scenarios for the global artifact
+        config.signal?.throwIfAborted();
+        // Phase 2: Merge (all three artifacts assembled in memory before any write)
+        const mergedPolicy = mergeServerResults(serverResults, constitutionHash, skippedServers, log);
         const allScenarios = serverResults.flatMap((r) => r.scenarios);
         const mergedScenariosFile = {
             generatedAt: new Date().toISOString(),
@@ -388,10 +441,10 @@ export class PipelineRunner {
             inputHash: mergedPolicy.inputHash,
             scenarios: allScenarios,
         };
-        writeArtifact(config.outputDir, 'test-scenarios.json', mergedScenariosFile);
-        // Phase 3: Merge per-server resolved lists into global dynamic-lists.json
+        // Phase 3: Merge per-server resolved lists into the global dynamic-lists.json.
         // Each server resolved its own lists during compileServer(); merge them here.
         const listDefinitions = mergedPolicy.listDefinitions ?? [];
+        let mergedDynamicLists;
         if (listDefinitions.length > 0) {
             const keptListNames = new Set(listDefinitions.map((d) => d.name));
             const mergedListEntries = {};
@@ -406,12 +459,34 @@ export class PipelineRunner {
                     }
                 }
             }
-            const mergedDynamicLists = {
+            mergedDynamicLists = {
                 generatedAt: new Date().toISOString(),
                 lists: mergedListEntries,
             };
+        }
+        // Optional caller validation runs on the in-memory policy BEFORE any artifact
+        // is written, so a rejection leaves the prior generation's files intact.
+        config.validateCompiled?.(mergedPolicy, mergedDynamicLists);
+        // Write order is the REVERSE of the runtime read order in
+        // loadPersonaPolicyArtifacts (compiled-policy first, then dynamic-lists):
+        //   1. dynamic-lists.json (or atomically REMOVE the stale file when there
+        //      are no list definitions — fixing the previous skip-leaves-stale bug)
+        //   2. test-scenarios.json
+        //   3. compiled-policy.json LAST
+        // Each write is per-file atomic (tmp + rename). The dependency ordering
+        // guarantees a concurrent reader that observes the NEW compiled-policy.json
+        // already sees the matching dynamic-lists.json; the reverse interleaving
+        // (new lists + old compiled) is fail-safe because an unknown @list-id
+        // resolves to the empty allowlist => deny (PolicyEngine.getEffectiveListValues
+        // returns [] for a missing list rather than throwing).
+        if (mergedDynamicLists) {
             writeArtifact(config.outputDir, 'dynamic-lists.json', mergedDynamicLists);
         }
+        else {
+            removeArtifactIfExists(config.outputDir, 'dynamic-lists.json');
+        }
+        writeArtifact(config.outputDir, 'test-scenarios.json', mergedScenariosFile);
+        writeArtifact(config.outputDir, 'compiled-policy.json', mergedPolicy);
         // Cross-server verification is intentionally omitted. Per-server rules compose
         // correctly by construction: every rule has server: [serverName] (enforced by
         // Zod schema), the engine checks cond.server.includes(request.serverName) so
@@ -423,16 +498,16 @@ export class PipelineRunner {
         const totalRules = mergedPolicy.rules.length;
         const totalScenarios = allScenarios.length;
         const serverCount = serverResults.length;
-        console.error('');
-        console.error(`  Servers compiled: ${serverCount}`);
-        console.error(`  Rules: ${totalRules}`);
-        console.error(`  Scenarios tested: ${totalScenarios}`);
-        console.error(`  Artifacts written to: ${chalk.dim(config.outputDir + '/')}`);
+        log('');
+        log(`  Servers compiled: ${serverCount}`);
+        log(`  Rules: ${totalRules}`);
+        log(`  Scenarios tested: ${totalScenarios}`);
+        log(`  Artifacts written to: ${chalk.dim(config.outputDir + '/')}`);
         if (config.llmLogPath) {
-            console.error(`  LLM interaction log: ${chalk.dim(config.llmLogPath)}`);
+            log(`  LLM interaction log: ${chalk.dim(config.llmLogPath)}`);
         }
-        console.error('');
-        console.error(chalk.green.bold('Policy compilation successful!'));
+        log('');
+        log(chalk.green.bold('Policy compilation successful!'));
         return mergedPolicy;
     }
     /**
@@ -441,6 +516,7 @@ export class PipelineRunner {
      * Multi-server compilation uses parallel execution with a multi-line progress display.
      */
     async compileAllServers(config, toolAnnotationsFile, constitutionHash, storedAnnotationsFile) {
+        const log = makeNarrativeLogger(config);
         const serverEntries = Object.entries(toolAnnotationsFile.servers);
         // Apply server filter if provided
         const { serverFilter } = config;
@@ -457,7 +533,7 @@ export class PipelineRunner {
         if (config.prefilterText !== undefined && !config.serverFilter) {
             const prefilterText = config.prefilterText;
             if (prefilterText.trim() === '') {
-                console.error(chalk.yellow('Pre-filter input is empty. All servers skipped (default-deny applies).'));
+                log(chalk.yellow('Pre-filter input is empty. All servers skipped (default-deny applies).'));
                 const allSkipped = filteredEntries.map(([name]) => ({
                     serverName: name,
                     reason: 'No input text provided — all servers skipped by default',
@@ -470,7 +546,7 @@ export class PipelineRunner {
             entriesToCompile = filteredEntries.filter(([name]) => {
                 const decision = decisionMap.get(name);
                 if (decision?.skip) {
-                    console.error(`  ${chalk.dim(name)}: ${chalk.yellow('skipped')} — ${decision.reason}`);
+                    log(`  ${chalk.dim(name)}: ${chalk.yellow('skipped')} — ${decision.reason}`);
                     skippedServers.push({ serverName: name, reason: decision.reason });
                     return false;
                 }
@@ -478,11 +554,11 @@ export class PipelineRunner {
             });
             const skippedCount = filteredEntries.length - entriesToCompile.length;
             if (skippedCount > 0) {
-                console.error(`  Pre-filter: ${skippedCount} server(s) skipped, ${entriesToCompile.length} proceeding`);
+                log(`  Pre-filter: ${skippedCount} server(s) skipped, ${entriesToCompile.length} proceeding`);
             }
         }
         if (entriesToCompile.length === 0) {
-            console.error(chalk.yellow('All servers skipped by pre-filter. Policy will use default-deny only.'));
+            log(chalk.yellow('All servers skipped by pre-filter. Policy will use default-deny only.'));
             return { results: [], skippedServers };
         }
         // Load handwritten scenarios once, then filter per server (avoids N redundant loads)
@@ -513,20 +589,22 @@ export class PipelineRunner {
         return { results, skippedServers };
     }
     /** Creates a per-server model wrapped with LLM call throttling. */
-    createServerModel(serverName, llmSemaphore) {
+    createServerModel(serverName, llmSemaphore, signal) {
         const { model, logContext } = createPerServerModel(this.baseLlm, this.logPath, serverName);
-        return { model: createThrottledModel(model, llmSemaphore), logContext };
+        return { model: createThrottledModel(model, llmSemaphore, signal), logContext };
     }
     async compileServersSequential(filteredEntries, config, constitutionHash, buildUnit, llmSemaphore) {
+        const log = makeNarrativeLogger(config);
         const results = [];
         const totalServers = filteredEntries.length;
         const failedServers = [];
         for (let i = 0; i < filteredEntries.length; i++) {
+            config.signal?.throwIfAborted();
             const [serverName] = filteredEntries[i];
-            console.error('');
-            console.error(chalk.bold(`[${i + 1}/${totalServers}] Compiling server: ${serverName}`));
-            const { model, logContext } = this.createServerModel(serverName, llmSemaphore);
-            const reporter = new SpinnerProgressReporter(serverName);
+            log('');
+            log(chalk.bold(`[${i + 1}/${totalServers}] Compiling server: ${serverName}`));
+            const { model, logContext } = this.createServerModel(serverName, llmSemaphore, config.signal);
+            const reporter = resolveReporter(config, serverName, () => new SpinnerProgressReporter(serverName));
             try {
                 const result = await this.compileServer(buildUnit(serverName), config, constitutionHash, model, logContext, reporter);
                 results.push(result);
@@ -534,20 +612,36 @@ export class PipelineRunner {
             catch (err) {
                 const coerced = toError(err);
                 reporter.fail('compiling', coerced);
-                console.error(`  ${chalk.red(`Server "${serverName}" failed:`)} ${coerced.message}`);
+                // A disabled-MCP-list error is a run-level configuration failure, not a
+                // per-server verification failure. Surface it past the failedServers
+                // aggregation so the orchestrator can map it to LIST_REQUIRES_MCP
+                // instead of the generic "all servers failed compilation" error.
+                if (err instanceof McpListsDisallowedError)
+                    throw err;
+                log(`  ${chalk.red(`Server "${serverName}" failed:`)} ${coerced.message}`);
                 failedServers.push(serverName);
             }
         }
-        return this.handleCompilationResults(results, failedServers);
+        return this.handleCompilationResults(results, failedServers, log);
     }
     async compileServersParallel(filteredEntries, config, constitutionHash, buildUnit, llmSemaphore, serverLimit) {
+        const log = makeNarrativeLogger(config);
         // Lazy import to avoid loading parallel-progress.ts when not needed
         const { ParallelProgressDisplay, ParallelProgressReporter } = await import('./parallel-progress.js');
         const serverNames = filteredEntries.map(([name]) => name);
-        const display = new ParallelProgressDisplay(serverNames);
+        // When a reporterFactory is injected the caller drives its own display; the
+        // built-in multi-line ParallelProgressDisplay would write to stderr, so it
+        // is only constructed for the built-in reporter path.
+        const display = config.reporterFactory ? undefined : new ParallelProgressDisplay(serverNames);
         const settled = await Promise.allSettled(filteredEntries.map(([serverName]) => serverLimit(async () => {
-            const { model, logContext } = this.createServerModel(serverName, llmSemaphore);
-            const reporter = new ParallelProgressReporter(display, serverName);
+            config.signal?.throwIfAborted();
+            const { model, logContext } = this.createServerModel(serverName, llmSemaphore, config.signal);
+            const reporter = resolveReporter(config, serverName, () => {
+                // `display` is defined whenever reporterFactory is absent (built-in path).
+                if (!display)
+                    throw new Error('internal: built-in parallel display missing');
+                return new ParallelProgressReporter(display, serverName);
+            });
             try {
                 return await this.compileServer(buildUnit(serverName), config, constitutionHash, model, logContext, reporter);
             }
@@ -556,7 +650,7 @@ export class PipelineRunner {
                 throw err;
             }
         })));
-        display.finish();
+        display?.finish();
         const results = [];
         const failedServers = [];
         for (const [i, outcome] of settled.entries()) {
@@ -564,16 +658,21 @@ export class PipelineRunner {
                 results.push(outcome.value);
             }
             else {
+                // A disabled-MCP-list error is a run-level configuration failure, not a
+                // per-server verification failure. Surface it past the failedServers
+                // aggregation so the orchestrator can map it to LIST_REQUIRES_MCP.
+                if (outcome.reason instanceof McpListsDisallowedError)
+                    throw outcome.reason;
                 const serverName = filteredEntries[i][0];
                 failedServers.push(serverName);
             }
         }
-        return this.handleCompilationResults(results, failedServers);
+        return this.handleCompilationResults(results, failedServers, log);
     }
-    handleCompilationResults(results, failedServers) {
+    handleCompilationResults(results, failedServers, log) {
         if (failedServers.length > 0) {
-            console.error(`\n${chalk.yellow(`Warning: ${failedServers.length} server(s) failed verification: ${failedServers.join(', ')}`)}`);
-            console.error(chalk.yellow('Continuing with successfully compiled servers.'));
+            log(`\n${chalk.yellow(`Warning: ${failedServers.length} server(s) failed verification: ${failedServers.join(', ')}`)}`);
+            log(chalk.yellow('Continuing with successfully compiled servers.'));
         }
         if (results.length === 0) {
             throw new Error(`All ${failedServers.length} server(s) failed compilation: ${failedServers.join(', ')}. ` +
@@ -619,6 +718,7 @@ export class PipelineRunner {
         }
         const compilerSystem = this.cacheStrategy.wrapSystemPrompt(compilerPrompt);
         // Step 1: Compile rules for this server
+        config.signal?.throwIfAborted();
         logContext.stepName = `compile-${unit.serverName}`;
         const compileResult = await this.compileServerPolicyRules(unit, compilerSystem, inputHash, model, reporter);
         let { rules } = compileResult;
@@ -626,6 +726,7 @@ export class PipelineRunner {
         // Validate server scoping (debug assertion)
         validateServerScoping(unit.serverName, rules);
         // Resolve dynamic lists for this server (before scenario generation so lists are available)
+        config.signal?.throwIfAborted();
         let dynamicLists;
         if (listDefinitions.length > 0) {
             dynamicLists = await this.resolveServerLists(listDefinitions, serverOutputDir, config, `  ${unit.serverName}`, model, logContext, reporter);
@@ -652,12 +753,14 @@ export class PipelineRunner {
             ? extractServerDomainAllowlists({ [unit.serverName]: unit.mcpServerConfig })
             : undefined;
         // Step 2: Generate test scenarios for this server
+        config.signal?.throwIfAborted();
         logContext.stepName = `scenarios-${unit.serverName}`;
         const permittedDirectories = extractPermittedDirectories(rules);
         const scenarioPrompt = buildGeneratorSystemPrompt(unit.constitutionText, unit.storedAnnotations, unit.allowedDirectory, permittedDirectories, dynamicLists);
         const scenarioHash = computeScenariosHash(scenarioPrompt, unit.handwrittenScenarios);
         const scenarioResult = await this.generateTestScenarios(unit.constitutionText, unit.storedAnnotations, unit.allowedDirectory, unit.handwrittenScenarios, scenarioHash, existingServerScenarios, `  ${unit.serverName}`, permittedDirectories, dynamicLists, model, reporter);
         // Step 3: Verify and repair
+        config.signal?.throwIfAborted();
         const state = await this.verifyAndRepairServer(unit, config, constitutionHash, inputHash, serverPolicyFile, serverAnnotationsFile, serverDomainAllowlists, dynamicLists, rules, listDefinitions, compileResult.session, scenarioResult, permittedDirectories, compilerSystem, model, logContext, reporter, serverOutputDir, writeServerPolicy);
         // Sync repaired state back so the writeServerPolicy closure sees updated values
         rules = state.rules;
@@ -943,7 +1046,13 @@ export class PipelineRunner {
     async resolveServerLists(listDefinitions, serverOutputDir, config, labelPrefix, model, logContext, reporter) {
         logContext.stepName = `resolve-lists-${labelPrefix.trim()}`;
         const existingLists = loadExistingArtifact(serverOutputDir, 'dynamic-lists.json');
-        const needsMcp = listDefinitions.some((d) => d.requiresMcp);
+        const mcpListNames = listDefinitions.filter((d) => d.requiresMcp).map((d) => d.name);
+        const needsMcp = mcpListNames.length > 0;
+        // The WS compile path disables live MCP. Fail fast with a typed error rather
+        // than silently resolving MCP-backed lists to empty (which would deny).
+        if (needsMcp && config.allowMcpLists === false) {
+            throw new McpListsDisallowedError(mcpListNames);
+        }
         let proxy;
         if (needsMcp && config.mcpServers) {
             proxy = await connectViaProxy(listDefinitions, config.mcpServers, config.toolAnnotationsDir);