@sanity/ailf 2.0.0 → 2.0.2

package/dist/pipeline/compiler/mode-handlers/mcp-tool-provider.js

@@ -0,0 +1,368 @@
+/**
+ * mcp-tool-provider.ts — Custom Promptfoo provider for MCP tool-use evaluation.
+ *
+ * Implements a multi-turn tool execution loop: the LLM receives a prompt,
+ * discovers MCP tools, calls them, gets results, and continues until it
+ * produces a final text answer or exhausts maxToolRounds.
+ *
+ * Promptfoo's built-in Anthropic/OpenAI providers with config.mcp only do
+ * single-turn tool calls. This provider fills that gap by managing the
+ * full conversation loop, similar to the agentic-provider.ts pattern.
+ *
+ * Promptfoo config usage:
+ *
+ *   providers:
+ *     - id: file://dist/pipeline/compiler/mode-handlers/mcp-tool-provider.js
+ *       label: "Claude Opus 4.6 + MCP"
+ *       config:
+ *         model: anthropic:messages:claude-opus-4-6
+ *         maxToolRounds: 5
+ *         temperature: 0.2
+ *         max_tokens: 4096
+ *         mcpServer:
+ *           url: https://mcp.sanity.io
+ *           auth: { type: bearer, token: "{{env.SANITY_API_TOKEN}}" }
+ *           name: mcp-live-query-documents
+ *         mcpTools: [query_documents, get_schema]
+ */
+import { config as loadDotenv } from "dotenv";
+loadDotenv({
+    override: true,
+    path: new URL("../../../../.env", import.meta.url).pathname,
+});
+// ---------------------------------------------------------------------------
+// Provider
+// ---------------------------------------------------------------------------
+export default class MCPToolProvider {
+    config;
+    providerId;
+    constructor(options = {}) {
+        this.config = options.config || {};
+        this.providerId = options.id || "mcp-tool-provider";
+    }
+    id() {
+        return this.providerId;
+    }
+    async callApi(prompt, _context) {
+        const mcpServerConfig = this.config.mcpServer;
+        if (!mcpServerConfig) {
+            return { error: "mcpServer config is required", output: undefined };
+        }
+        // Resolve model provider
+        const modelId = this.config.model ||
+            "anthropic:messages:claude-sonnet-4-20250514";
+        if (modelId.startsWith("anthropic:")) {
+            return this.runAnthropicLoop(prompt, mcpServerConfig, modelId);
+        }
+        // For now, only Anthropic is supported. OpenAI support can be added later.
+        return {
+            error: `MCP tool provider only supports Anthropic models for now. Got: ${modelId}`,
+            output: undefined,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Anthropic multi-turn MCP tool loop
+    // -------------------------------------------------------------------------
+    async runAnthropicLoop(prompt, mcpServerConfig, modelId) {
+        // Parse model name from provider ID (e.g., "anthropic:messages:claude-opus-4-6" → "claude-opus-4-6")
+        const modelParts = modelId.split(":");
+        const model = modelParts.length > 2
+            ? modelParts.slice(2).join(":")
+            : modelParts[modelParts.length - 1];
+        const temperature = this.config.temperature ?? 0.2;
+        const maxTokens = this.config.max_tokens || 4096;
+        const maxToolRounds = this.config.maxToolRounds || 5;
+        const apiKey = this.config.apiKey || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return {
+                error: "ANTHROPIC_API_KEY not set. Configure it in env or provider config.",
+                output: undefined,
+            };
+        }
+        // Connect to MCP server and discover tools
+        let mcpClient;
+        try {
+            mcpClient = await this.connectMCP(mcpServerConfig);
+        }
+        catch (err) {
+            return {
+                error: `Failed to connect to MCP server: ${err instanceof Error ? err.message : String(err)}`,
+                output: undefined,
+            };
+        }
+        try {
+            // Get available tools and convert to Anthropic format
+            const mcpTools = mcpClient.getAllTools();
+            const toolFilter = this.config.mcpTools;
+            const filteredTools = toolFilter
+                ? mcpTools.filter((t) => toolFilter.includes(t.name))
+                : mcpTools;
+            const tools = filteredTools.map((t) => ({
+                name: t.name,
+                description: t.description || `MCP tool: ${t.name}`,
+                input_schema: t.inputSchema || { type: "object", properties: {} },
+            }));
+            if (tools.length === 0) {
+                return {
+                    error: "No MCP tools available after filtering. Check mcpTools config and server capabilities.",
+                    output: undefined,
+                };
+            }
+            /** Append a machine-readable tool call summary to output for assertion detection */
+            function appendToolSummary(text, log) {
+                if (log.length === 0)
+                    return text;
+                const names = JSON.stringify(log.map((tc) => tc.name));
+                return `${text}\n\n<!-- MCP_TOOLS_CALLED: ${names} -->`;
+            }
+            const systemPrompt = "You are an AI assistant with access to tools provided by an MCP server. " +
+                "Use the available tools to complete the task. Call tools with correct parameters, " +
+                "interpret responses, and provide a complete answer.";
+            const messages = [{ content: prompt, role: "user" }];
+            let inputTokens = 0;
+            let outputTokens = 0;
+            const startTime = Date.now();
+            const toolCallLog = [];
+            for (let round = 0; round <= maxToolRounds; round++) {
+                const isLastRound = round === maxToolRounds;
+                // On last round, omit tools to force a final text response
+                if (isLastRound) {
+                    const lastMsg = messages[messages.length - 1];
+                    const synthesisText = "You've used the tools available. Based on the information gathered, " +
+                        "provide your complete, final answer now.";
+                    if (lastMsg?.role === "user" && Array.isArray(lastMsg.content)) {
+                        ;
+                        lastMsg.content.push({
+                            type: "text",
+                            text: synthesisText,
+                        });
+                    }
+                    else {
+                        messages.push({ content: synthesisText, role: "user" });
+                    }
+                }
+                const body = {
+                    max_tokens: maxTokens,
+                    messages,
+                    model,
+                    system: systemPrompt,
+                    temperature,
+                };
+                if (!isLastRound) {
+                    body.tools = tools;
+                }
+                const response = await fetch("https://api.anthropic.com/v1/messages", {
+                    body: JSON.stringify(body),
+                    headers: {
+                        "anthropic-version": "2023-06-01",
+                        "Content-Type": "application/json",
+                        "x-api-key": apiKey,
+                    },
+                    method: "POST",
+                });
+                const data = (await response.json());
+                if (data.error) {
+                    return {
+                        error: data.error.message ??
+                            `Anthropic API error: ${JSON.stringify(data.error)}`,
+                        output: undefined,
+                    };
+                }
+                inputTokens += data.usage?.input_tokens ?? 0;
+                outputTokens += data.usage?.output_tokens ?? 0;
+                if (!data.content?.length) {
+                    return {
+                        cost: 0,
+                        metadata: { toolRounds: round, toolCallLog },
+                        output: "",
+                        tokenUsage: {
+                            completion: outputTokens,
+                            prompt: inputTokens,
+                            total: inputTokens + outputTokens,
+                        },
+                    };
+                }
+                // Add assistant response to history
+                messages.push({ content: data.content, role: "assistant" });
+                // Check if model wants to use tools
+                const toolUseBlocks = data.content.filter((b) => b.type === "tool_use");
+                if (data.stop_reason !== "tool_use" || toolUseBlocks.length === 0) {
+                    // Model is done — extract text
+                    const textBlocks = data.content.filter((b) => b.type === "text");
+                    const rawOutput = textBlocks.map((b) => b.text || "").join("\n") || "";
+                    return {
+                        cost: 0,
+                        metadata: {
+                            toolRounds: round,
+                            toolCallLog,
+                            latencyMs: Date.now() - startTime,
+                        },
+                        output: appendToolSummary(rawOutput, toolCallLog),
+                        tokenUsage: {
+                            completion: outputTokens,
+                            prompt: inputTokens,
+                            total: inputTokens + outputTokens,
+                        },
+                    };
+                }
+                // Execute each tool call via MCP
+                const toolResults = [];
+                for (const toolUse of toolUseBlocks) {
+                    const toolName = toolUse.name;
+                    const toolInput = (toolUse.input || {});
+                    try {
+                        const result = await mcpClient.callTool(toolName, toolInput);
+                        const content = result.error
+                            ? JSON.stringify({ error: result.error })
+                            : result.content;
+                        toolCallLog.push({
+                            name: toolName,
+                            input: toolInput,
+                            output: content,
+                        });
+                        toolResults.push({
+                            content,
+                            tool_use_id: toolUse.id,
+                            type: "tool_result",
+                        });
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        toolCallLog.push({
+                            name: toolName,
+                            input: toolInput,
+                            output: `Error: ${errMsg}`,
+                        });
+                        toolResults.push({
+                            content: JSON.stringify({ error: errMsg }),
+                            tool_use_id: toolUse.id,
+                            type: "tool_result",
+                        });
+                    }
+                }
+                // Add tool results to conversation
+                messages.push({ content: toolResults, role: "user" });
+            }
+            // Exhausted rounds
+            const lastAssistant = [...messages]
+                .reverse()
+                .find((m) => m.role === "assistant");
+            let lastText = "";
+            if (lastAssistant && Array.isArray(lastAssistant.content)) {
+                lastText = lastAssistant.content
+                    .filter((b) => b.type === "text")
+                    .map((b) => b.text || "")
+                    .join("\n");
+            }
+            return {
+                cost: 0,
+                metadata: {
+                    toolRounds: maxToolRounds,
+                    exhaustedRounds: true,
+                    toolCallLog,
+                    latencyMs: Date.now() - startTime,
+                },
+                output: appendToolSummary(lastText || "[Exhausted tool rounds without final answer]", toolCallLog),
+                tokenUsage: {
+                    completion: outputTokens,
+                    prompt: inputTokens,
+                    total: inputTokens + outputTokens,
+                },
+            };
+        }
+        finally {
+            await mcpClient.cleanup().catch(() => { });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // MCP client management
+    // -------------------------------------------------------------------------
+    async connectMCP(serverConfig) {
+        // Dynamically import Promptfoo's MCPClient — reuse its MCP SDK integration
+        // rather than adding a direct dependency on @modelcontextprotocol/sdk
+        const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+        const client = new Client({
+            name: "ailf-mcp-eval",
+            version: "1.0.0",
+        });
+        // Resolve auth — render {{env.VAR}} templates
+        const resolvedConfig = this.resolveEnvTemplates(serverConfig);
+        // Determine transport type and connect
+        let closeTransport;
+        if (resolvedConfig.command) {
+            // stdio transport
+            const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
+            const parts = String(resolvedConfig.command).split(/\s+/);
+            const transport = new StdioClientTransport({
+                command: parts[0],
+                args: parts.slice(1),
+                env: process.env,
+            });
+            await client.connect(transport);
+            closeTransport = () => transport.close();
+        }
+        else if (resolvedConfig.url) {
+            // streamable-http transport
+            const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+            const headers = {};
+            const auth = resolvedConfig.auth;
+            if (auth?.type === "bearer" && auth.token) {
+                headers["Authorization"] = `Bearer ${auth.token}`;
+            }
+            const transport = new StreamableHTTPClientTransport(new URL(String(resolvedConfig.url)), { requestInit: { headers } });
+            await client.connect(transport);
+            closeTransport = () => transport.close();
+        }
+        else {
+            throw new Error("MCP server config must have either 'command' (stdio) or 'url' (http)");
+        }
+        // Discover tools
+        const { tools: toolsList } = await client.listTools();
+        const allTools = toolsList.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        }));
+        return {
+            getAllTools: () => allTools,
+            callTool: async (name, args) => {
+                const result = await client.callTool({ name, arguments: args });
+                let content = "";
+                if (result?.content) {
+                    if (Array.isArray(result.content)) {
+                        content = result.content
+                            .map((c) => c.text || JSON.stringify(c))
+                            .join("\n");
+                    }
+                    else {
+                        content = String(result.content);
+                    }
+                }
+                return { content, error: result.isError ? content : undefined };
+            },
+            cleanup: async () => {
+                await closeTransport().catch(() => { });
+            },
+        };
+    }
+    /**
+     * Resolve {{env.VAR}} templates in config values.
+     */
+    resolveEnvTemplates(config) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(config)) {
+            if (typeof value === "string") {
+                resolved[key] = value.replace(/\{\{env\.(\w+)\}\}/g, (_, varName) => {
+                    return process.env[varName] || "";
+                });
+            }
+            else if (value && typeof value === "object" && !Array.isArray(value)) {
+                resolved[key] = this.resolveEnvTemplates(value);
+            }
+            else {
+                resolved[key] = value;
+            }
+        }
+        return resolved;
+    }
+}

package/dist/pipeline/compiler/presets/sanity-literacy.d.ts

@@ -11,7 +11,7 @@
  * Evaluation methodology (rubrics, scoring, prompts) is inherited from the
  * `literacy` mode base — see mode-bases/literacy.ts.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-8-scoring-storage-presets.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-8-scoring-storage-presets.md
  */
 import { type PresetDefinition } from "../../../_vendor/ailf-core/index.d.ts";
 export interface SanityLiteracyPresetOptions {

package/dist/pipeline/compiler/presets/sanity-literacy.js

@@ -11,7 +11,7 @@
  * Evaluation methodology (rubrics, scoring, prompts) is inherited from the
  * `literacy` mode base — see mode-bases/literacy.ts.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-8-scoring-storage-presets.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-8-scoring-storage-presets.md
  */
 import { env } from "../../../_vendor/ailf-core/index.js";
 import { SanityDocFetcher } from "../../../adapters/doc-fetchers/index.js";

package/dist/pipeline/compiler/promptfoo-compiler.d.ts

@@ -9,10 +9,7 @@
  *   TaskGraph → resolve fixtures → resolve variables → map assertions
  *             → assemble prompts → assemble providers → emit YAML
  *
- * This module exists alongside `generate-configs.ts` — it does NOT replace
- * the existing codegen path. Phase 7 will swap callers over to the compiler.
- *
- * @see docs/exec-plans/architecture-overhaul/phase-2-config-compiler.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-2-config-compiler.md
  */
 import type { ModeHandler, ModelsConfig, TaskGraph } from "../../_vendor/ailf-core/index.d.ts";
 import type { EvalMode } from "../../_vendor/ailf-shared/index.d.ts";

package/dist/pipeline/compiler/promptfoo-compiler.js

@@ -9,10 +9,7 @@
  *   TaskGraph → resolve fixtures → resolve variables → map assertions
  *             → assemble prompts → assemble providers → emit YAML
  *
- * This module exists alongside `generate-configs.ts` — it does NOT replace
- * the existing codegen path. Phase 7 will swap callers over to the compiler.
- *
- * @see docs/exec-plans/architecture-overhaul/phase-2-config-compiler.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-2-config-compiler.md
  */
 import { mapAssertions } from "./assertion-mapper.js";
 import { resolveTaskFixtures } from "./fixture-resolver.js";
@@ -151,20 +148,14 @@ function buildProviders(models, mode) {
 /**
  * Check if a model entry matches the current evaluation mode.
  *
- * Literacy mode defaults to baseline model matching. Variant-specific
+ * Uses the typed EvalMode values on model.modes. Variant-specific
  * provider filtering is handled by the provider-assembler and
  * generate-configs-step, not here.
  */
 function modelMatchesMode(model, mode) {
     if (!model.modes || model.modes.length === 0)
         return true;
-    switch (mode) {
-        case "literacy":
-            return model.modes.includes(LiteracyVariant.STANDARD);
-        default:
-            // Non-literacy modes accept all models by default
-            return true;
-    }
+    return model.modes.includes(mode);
 }
 // ---------------------------------------------------------------------------
 // Prompt resolution

package/dist/pipeline/compiler/provider-assembler.js

@@ -7,9 +7,9 @@
  * Separated into its own module so GenerateConfigsStep can import it
  * without pulling in the full legacy generate-configs machinery.
  */
-import { extractModelName, extractProvider, mergeConfig, modelMatchesMode, } from "../../_vendor/ailf-core/index.js";
-import { LiteracyVariant } from "../normalize-mode.js";
+import { extractModelName, extractProvider, mergeConfig, } from "../../_vendor/ailf-core/index.js";
 import { loadConfigFile } from "./config-loader.js";
+import { modelMatchesLiteracyVariant } from "./mode-bases/literacy.js";
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -36,9 +36,12 @@ export function loadModelsAndProviders(rootDir, source, searchMode, allowedOrigi
 // ---------------------------------------------------------------------------
 function buildBaselineProviders(models) {
     return models.models
-        .filter((m) => modelMatchesMode(m, LiteracyVariant.STANDARD))
+        .filter((m) => modelMatchesLiteracyVariant(m, "baseline"))
         .map((model) => ({
-        config: mergeConfig(models.defaults, model.config),
+        config: {
+            ...mergeConfig(models.defaults, model.config),
+            ...(model.timeoutMs ? { timeoutMs: model.timeoutMs } : {}),
+        },
         id: model.id,
         label: model.label,
     }));
@@ -48,12 +51,13 @@ function buildBaselineProviders(models) {
 // ---------------------------------------------------------------------------
 function buildObservedProviders(models) {
     return models.models
-        .filter((m) => modelMatchesMode(m, LiteracyVariant.OBSERVED))
+        .filter((m) => modelMatchesLiteracyVariant(m, "observed"))
         .map((model) => {
         const modelName = extractModelName(model.id);
         return {
             config: {
                 ...mergeConfig(models.defaults, model.config),
+                ...(model.timeoutMs ? { timeoutMs: model.timeoutMs } : {}),
                 modelName,
                 observe: true,
                 recordOptions: models.defaults.observerOptions ?? {},
@@ -67,8 +71,8 @@ function buildObservedProviders(models) {
 // Agentic providers
 // ---------------------------------------------------------------------------
 function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
-    const naiveModels = models.models.filter((m) => modelMatchesMode(m, "agentic-naive"));
-    const optimizedModels = models.models.filter((m) => modelMatchesMode(m, "agentic-optimized"));
+    const naiveModels = models.models.filter((m) => modelMatchesLiteracyVariant(m, "agentic-naive"));
+    const optimizedModels = models.models.filter((m) => modelMatchesLiteracyVariant(m, "agentic-optimized"));
     const resolvedSearchMode = searchMode ?? "open";
     const sourceConfig = source
         ? {
@@ -100,6 +104,7 @@ function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
                     model: modelName,
                     provider,
                 }),
+                ...(model.timeoutMs ? { timeoutMs: model.timeoutMs } : {}),
                 ...sourceConfig,
                 observe: true,
                 observerOptions: models.defaults.observerOptions ?? {},
@@ -119,6 +124,7 @@ function buildAgenticProviders(models, source, searchMode, _allowedOrigins) {
                     model: modelName,
                     provider,
                 }),
+                ...(model.timeoutMs ? { timeoutMs: model.timeoutMs } : {}),
                 ...sourceConfig,
                 observe: true,
                 observerOptions: models.defaults.observerOptions ?? {},

package/dist/pipeline/compiler/sandbox/docker-sandbox.d.ts

@@ -8,7 +8,7 @@
  * no shell) to prevent shell injection from task-supplied values like
  * image names or task IDs.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import type { SandboxArtifacts, SandboxInfo, SandboxProvisionOptions, SandboxStrategy } from "./sandbox-strategy.js";
 export declare class DockerSandboxStrategy implements SandboxStrategy {

package/dist/pipeline/compiler/sandbox/docker-sandbox.js

@@ -8,7 +8,7 @@
  * no shell) to prevent shell injection from task-supplied values like
  * image names or task IDs.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import { randomUUID } from "crypto";
 import { execFileSync } from "child_process";

package/dist/pipeline/compiler/sandbox/fixture-provisioner.d.ts

@@ -10,7 +10,7 @@
  * - sanity:// — Content Lake document by ID or query
  *
  * @see docs/design-docs/architecture-overhaul/fixtures-artifacts.md
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import type { SandboxInfo } from "./sandbox-strategy.js";
 /** A fixture reference from a task definition */

package/dist/pipeline/compiler/sandbox/fixture-provisioner.js

@@ -10,7 +10,7 @@
  * - sanity:// — Content Lake document by ID or query
  *
  * @see docs/design-docs/architecture-overhaul/fixtures-artifacts.md
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { createHash } from "crypto";

package/dist/pipeline/compiler/sandbox/git-worktree-sandbox.d.ts

@@ -7,7 +7,7 @@
  * All git CLI calls use `execFileSync` (array form, no shell) to prevent
  * injection from task-supplied values like git refs or repo paths.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import type { SandboxArtifacts, SandboxInfo, SandboxProvisionOptions, SandboxStrategy } from "./sandbox-strategy.js";
 export declare class GitWorktreeSandboxStrategy implements SandboxStrategy {

package/dist/pipeline/compiler/sandbox/git-worktree-sandbox.js

@@ -7,7 +7,7 @@
  * All git CLI calls use `execFileSync` (array form, no shell) to prevent
  * injection from task-supplied values like git refs or repo paths.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import { randomUUID } from "crypto";
 import { execFileSync } from "child_process";

package/dist/pipeline/compiler/sandbox/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Sandbox infrastructure — isolated execution environments for agent harness mode.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 export type { SandboxArtifacts, SandboxInfo, SandboxProvisionOptions, SandboxStrategy, SandboxType, } from "./sandbox-strategy.js";
 export { DockerSandboxStrategy } from "./docker-sandbox.js";

package/dist/pipeline/compiler/sandbox/index.js

@@ -1,7 +1,7 @@
 /**
  * Sandbox infrastructure — isolated execution environments for agent harness mode.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 // Implementations
 export { DockerSandboxStrategy } from "./docker-sandbox.js";

package/dist/pipeline/compiler/sandbox/sandbox-selector.d.ts

@@ -8,7 +8,7 @@
  *
  * CI environments (detected via CI env var) always prefer Docker.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import type { SandboxStrategy, SandboxType } from "./sandbox-strategy.js";
 /** Result of sandbox selection */

package/dist/pipeline/compiler/sandbox/sandbox-selector.js

@@ -8,7 +8,7 @@
  *
  * CI environments (detected via CI env var) always prefer Docker.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import { DockerSandboxStrategy } from "./docker-sandbox.js";
 import { GitWorktreeSandboxStrategy } from "./git-worktree-sandbox.js";

package/dist/pipeline/compiler/sandbox/sandbox-strategy.d.ts

@@ -10,7 +10,7 @@
  * Selection: task config specifies preferred strategy; runtime falls back
  * Docker → TempDir if Docker is unavailable. CI environments prefer Docker.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 /** Metadata describing a provisioned sandbox */
 export interface SandboxInfo {

package/dist/pipeline/compiler/sandbox/sandbox-strategy.js

@@ -10,6 +10,6 @@
  * Selection: task config specifies preferred strategy; runtime falls back
  * Docker → TempDir if Docker is unavailable. CI environments prefer Docker.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 export {};

package/dist/pipeline/compiler/sandbox/tempdir-sandbox.d.ts

@@ -7,7 +7,7 @@
  *
  * This is the universal fallback when Docker is unavailable.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import type { SandboxArtifacts, SandboxInfo, SandboxProvisionOptions, SandboxStrategy } from "./sandbox-strategy.js";
 export declare class TempDirSandboxStrategy implements SandboxStrategy {

package/dist/pipeline/compiler/sandbox/tempdir-sandbox.js

@@ -7,7 +7,7 @@
  *
  * This is the universal fallback when Docker is unavailable.
  *
- * @see docs/exec-plans/architecture-overhaul/phase-4-agent-harness.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-4-agent-harness.md
  */
 import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, readdirSync, rmSync } from "fs";

package/dist/pipeline/compiler/scoring-bridge.d.ts

@@ -18,7 +18,7 @@
  *
  * @see packages/core/src/services/scoring-engine.ts — the 4-tier engine
  * @see packages/eval/src/pipeline/calculate-scores.ts — the consumer
- * @see docs/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
+ * @see docs/archive/exec-plans/architecture-overhaul/phase-7-migrate-literacy.md
  */
 import { type DimensionScore } from "../../_vendor/ailf-core/index.d.ts";
 import type { TestResult } from "../../_vendor/ailf-core/index.d.ts";