prism-mcp-server 7.2.0 → 7.3.3

package/dist/storage/supabase.js

@@ -18,6 +18,7 @@ import { debugLog } from "../utils/logger.js";
 import { PRISM_USER_ID } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { runAutoMigrations } from "./supabaseMigrations.js";
+import { SafetyController } from "../darkfactory/safetyController.js";
 export class SupabaseStorage {
     // ─── Lifecycle ─────────────────────────────────────────────
     async initialize() {
@@ -1182,9 +1183,6 @@ export class SupabaseStorage {
                     return Number(first.prism_prune_access_log) || 0;
                 }
             }
-            if (rpcResult && typeof rpcResult.deleted_count !== "undefined") {
-                return Number(rpcResult.deleted_count) || 0;
-            }
             if (rpcResult && typeof rpcResult.prism_prune_access_log !== "undefined") {
                 return Number(rpcResult.prism_prune_access_log) || 0;
             }
@@ -1195,4 +1193,198 @@ export class SupabaseStorage {
             return 0;
         }
     }
+    // ─── Dark Factory (v7.3) ───────────────────────────────────
+    async savePipeline(state) {
+        const now = new Date().toISOString();
+        const updatedState = { ...state, updated_at: now };
+        // Status Guard: prevent overwriting a terminated pipeline
+        const existing = await this.getPipeline(state.id, state.user_id);
+        if (existing) {
+            if (existing.status === 'ABORTED' || existing.status === 'COMPLETED') {
+                throw new Error(`Cannot update pipeline ${state.id} because it is already ${existing.status}.`);
+            }
+            // Validate state machine transition
+            if (!SafetyController.validateTransition(existing.status, updatedState.status)) {
+                throw new Error(`Illegal pipeline transition: ${existing.status} → ${updatedState.status} ` +
+                    `for pipeline ${state.id}. Legal transitions from ${existing.status}: ` +
+                    `${SafetyController.getLegalTransitions(existing.status).join(', ') || 'NONE (terminal)'}.`);
+            }
+        }
+        try {
+            await supabasePost("dark_factory_pipelines", {
+                id: updatedState.id,
+                project: updatedState.project,
+                user_id: updatedState.user_id,
+                status: updatedState.status,
+                current_step: updatedState.current_step,
+                iteration: updatedState.iteration,
+                started_at: updatedState.started_at,
+                updated_at: updatedState.updated_at,
+                spec: updatedState.spec,
+                error: updatedState.error || null,
+                last_heartbeat: updatedState.last_heartbeat || null
+            }, { on_conflict: "id" }, { Prefer: "return=minimal,resolution=merge-duplicates" });
+        }
+        catch (e) {
+            // PGRST202 fallback if the table doesn't exist yet
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation")) {
+                debugLog("[SupabaseStorage] dark_factory_pipelines missing — please run migration 038");
+                return;
+            }
+            throw e;
+        }
+    }
+    async getPipeline(id, userId) {
+        try {
+            const result = await supabaseGet("dark_factory_pipelines", {
+                id: `eq.${id}`,
+                user_id: `eq.${userId}`,
+                limit: "1"
+            });
+            const rows = Array.isArray(result) ? result : [];
+            if (rows.length === 0)
+                return null;
+            return rows[0];
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation"))
+                return null;
+            throw e;
+        }
+    }
+    async listPipelines(project, status, userId) {
+        try {
+            const query = {
+                user_id: `eq.${userId}`,
+                order: "updated_at.desc"
+            };
+            if (project)
+                query.project = `eq.${project}`;
+            if (status)
+                query.status = `eq.${status}`;
+            const result = await supabaseGet("dark_factory_pipelines", query);
+            return (Array.isArray(result) ? result : []);
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation"))
+                return [];
+            throw e;
+        }
+    }
+    // ─── Verification Harness (v7.2.0) ───────────────────────────
+    async saveVerificationHarness(harness, userId) {
+        try {
+            await supabasePost("verification_harnesses", {
+                rubric_hash: harness.rubric_hash,
+                project: harness.project,
+                conversation_id: harness.conversation_id,
+                created_at: harness.created_at,
+                min_pass_rate: harness.min_pass_rate,
+                tests: JSON.stringify(harness.tests),
+                metadata: harness.metadata ? JSON.stringify(harness.metadata) : null,
+                user_id: userId
+            }, { on_conflict: "rubric_hash" }, { Prefer: "return=representation,resolution=merge-duplicates" });
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST116") || e.message?.includes("duplicate key")) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async getVerificationHarness(rubric_hash, userId) {
+        try {
+            const rows = await supabaseGet("verification_harnesses", {
+                "rubric_hash": `eq.${rubric_hash}`,
+                "user_id": `eq.${userId}`
+            });
+            if (!Array.isArray(rows) || rows.length === 0)
+                return null;
+            const row = rows[0];
+            return {
+                ...row,
+                tests: JSON.parse(row.tests),
+                metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+            };
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation"))
+                return null;
+            throw e;
+        }
+    }
+    async saveVerificationRun(result, userId) {
+        try {
+            await supabasePost("verification_runs", {
+                id: result.id,
+                rubric_hash: result.rubric_hash,
+                project: result.project,
+                conversation_id: result.conversation_id,
+                run_at: result.run_at,
+                // H2 fix: Use native booleans for Supabase/PostgreSQL (not 0/1 integers)
+                passed: result.passed,
+                pass_rate: result.pass_rate,
+                critical_failures: result.critical_failures,
+                coverage_score: result.coverage_score,
+                result_json: result.result_json,
+                gate_action: result.gate_action,
+                gate_override: result.gate_override ?? false,
+                override_reason: result.override_reason || null,
+                user_id: userId
+            }, { on_conflict: "id" }, { Prefer: "return=representation,resolution=ignore-duplicates" });
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST116") || e.message?.includes("duplicate key")) {
+                return;
+            }
+            throw e;
+        }
+    }
+    async listVerificationRuns(project, userId) {
+        try {
+            const query = {
+                project: `eq.${project}`,
+                user_id: `eq.${userId}`,
+                order: "run_at.desc"
+            };
+            const rows = await supabaseGet("verification_runs", query);
+            if (!Array.isArray(rows))
+                return [];
+            return rows.map((row) => ({
+                ...row,
+                passed: Boolean(row.passed),
+                // H2 fix: Use Boolean() consistently (native booleans from Supabase)
+                gate_override: Boolean(row.gate_override),
+                override_reason: row.override_reason || undefined
+            }));
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation"))
+                return [];
+            throw e;
+        }
+    }
+    async getVerificationRun(id, userId) {
+        try {
+            const rows = await supabaseGet("verification_runs", {
+                id: `eq.${id}`,
+                user_id: `eq.${userId}`
+            });
+            if (!Array.isArray(rows) || rows.length === 0)
+                return null;
+            const row = rows[0];
+            return {
+                ...row,
+                passed: Boolean(row.passed),
+                // H2 fix: Use Boolean() consistently (native booleans from Supabase)
+                gate_override: Boolean(row.gate_override),
+                override_reason: row.override_reason || undefined
+            };
+        }
+        catch (e) {
+            if (e.message?.includes("PGRST202") || e.message?.includes("Could not find the relation"))
+                return null;
+            throw e;
+        }
+    }
 }

package/dist/storage/supabaseMigrations.js

@@ -721,6 +721,58 @@ export const MIGRATIONS = [
       GRANT EXECUTE ON FUNCTION public.prism_seed_access_log_on_ledger_insert() TO service_role, authenticated;
     `
     },
+    {
+        // ─── v7.3: Dark Factory Pipelines ─────────────────────────────
+        //
+        // Creates the dark_factory_pipelines table for autonomous Plan-Execute-Verify
+        // pipeline orchestration. Includes status CHECK constraint for the canonical set.
+        //
+        // EXISTING DEPLOYMENT GUARD: If the table already exists (e.g., from running
+        // 038_dark_factory_pipelines.sql directly), CREATE TABLE IF NOT EXISTS is a no-op.
+        // We then ALTER TABLE to add the CHECK constraint for existing deployments.
+        version: 38,
+        name: "dark_factory_pipelines",
+        sql: `
+      -- Create the table if fresh install
+      CREATE TABLE IF NOT EXISTS public.dark_factory_pipelines (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL,
+        user_id TEXT NOT NULL DEFAULT 'default',
+        status TEXT NOT NULL,
+        current_step TEXT NOT NULL,
+        iteration INTEGER NOT NULL,
+        started_at TIMESTAMPTZ NOT NULL,
+        updated_at TIMESTAMPTZ NOT NULL,
+        spec TEXT NOT NULL,
+        error TEXT,
+        last_heartbeat TIMESTAMPTZ
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_pipelines_status
+        ON public.dark_factory_pipelines(user_id, project, status);
+
+      ALTER TABLE public.dark_factory_pipelines ENABLE ROW LEVEL SECURITY;
+
+      -- Idempotent policy creation
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_policies WHERE tablename = 'dark_factory_pipelines' AND policyname = 'allow_all_dark_factory'
+        ) THEN
+          CREATE POLICY allow_all_dark_factory
+            ON public.dark_factory_pipelines AS PERMISSIVE FOR ALL USING (true);
+        END IF;
+      END $$;
+
+      -- Retrofit CHECK constraint for existing deployments.
+      -- DROP first (idempotent) then ADD — covers both fresh and upgraded tables.
+      ALTER TABLE public.dark_factory_pipelines
+        DROP CONSTRAINT IF EXISTS chk_pipeline_status;
+      ALTER TABLE public.dark_factory_pipelines
+        ADD CONSTRAINT chk_pipeline_status
+        CHECK (status IN ('PENDING', 'RUNNING', 'PAUSED', 'ABORTED', 'COMPLETED', 'FAILED'));
+    `
+    },
 ];
 /**
  * Current schema version — derived from the MIGRATIONS array.

package/dist/tools/index.js

@@ -47,3 +47,8 @@ export { agentRegisterHandler, agentHeartbeatHandler, agentListTeamHandler } fro
 // Registered when PRISM_TASK_ROUTER_ENABLED=true.
 // server.ts handles the conditional registration.
 export { sessionTaskRouteHandler } from "./taskRouterHandler.js";
+// ── Dark Factory Pipeline Tools (v7.3 — Autonomous Execution, Optional) ──
+// Registered when PRISM_DARK_FACTORY_ENABLED=true.
+// server.ts handles the conditional registration.
+export { SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL, isStartPipelineArgs, isCheckPipelineStatusArgs, isAbortPipelineArgs, } from "./pipelineDefinitions.js";
+export { sessionStartPipelineHandler, sessionCheckPipelineStatusHandler, sessionAbortPipelineHandler, } from "./pipelineHandlers.js";

package/dist/tools/pipelineDefinitions.js

@@ -0,0 +1,131 @@
+// ─── session_start_pipeline ─────────────────────────────────
+export const SESSION_START_PIPELINE_TOOL = {
+    name: "session_start_pipeline",
+    description: "Start an autonomous Dark Factory pipeline. The pipeline runs in the background " +
+        "and executes a PLAN → EXECUTE → VERIFY cycle up to `max_iterations` times.\n\n" +
+        "**Requires:** `PRISM_DARK_FACTORY_ENABLED=true` in the environment.\n\n" +
+        "**How it works:**\n" +
+        "1. Call this tool with an objective (what to accomplish)\n" +
+        "2. The pipeline is queued and executes autonomously in the background\n" +
+        "3. Use `session_check_pipeline_status` to poll for results\n\n" +
+        "**Safety:**\n" +
+        "- Pipelines are scoped to a `working_directory` — no filesystem escape\n" +
+        "- Strict iteration cap (default: 3) prevents infinite loops\n" +
+        "- Wall-clock timeout (default: 15min) prevents runaway execution\n" +
+        "- All operations are logged to the session ledger for audit",
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project identifier. Required for scoping and audit.",
+            },
+            objective: {
+                type: "string",
+                description: "What the pipeline should accomplish. Be specific — this becomes the LLM's system prompt objective.",
+            },
+            working_directory: {
+                type: "string",
+                description: "Absolute path to the working directory. The pipeline can only modify " +
+                    "files within this directory. Defaults to the project's repo_path if configured.",
+            },
+            max_iterations: {
+                type: "number",
+                description: "Maximum PLAN→EXECUTE→VERIFY loop iterations (default: 3, max: 10). " +
+                    "Each iteration is one complete cycle. Most tasks complete in 1-2 iterations.",
+            },
+            context_files: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional list of specific files to focus on. Paths are relative " +
+                    "to the working directory.",
+            },
+            model_override: {
+                type: "string",
+                description: "Optional model name to use instead of the default LLM. " +
+                    "Useful for routing to a local model (e.g., 'qwen3') via Claw.",
+            },
+        },
+        required: ["project", "objective"],
+    },
+};
+// ─── session_check_pipeline_status ──────────────────────────
+export const SESSION_CHECK_PIPELINE_STATUS_TOOL = {
+    name: "session_check_pipeline_status",
+    description: "Check the status of a Dark Factory pipeline. Returns the current step, " +
+        "iteration count, and any error messages.\n\n" +
+        "**Statuses:**\n" +
+        "- `PENDING` — Queued, waiting for runner pickup\n" +
+        "- `RUNNING` — Currently executing a step\n" +
+        "- `COMPLETED` — Successfully finished all steps\n" +
+        "- `FAILED` — Encountered an error or exceeded limits\n" +
+        "- `ABORTED` — Manually cancelled",
+    inputSchema: {
+        type: "object",
+        properties: {
+            pipeline_id: {
+                type: "string",
+                description: "The pipeline ID returned by `session_start_pipeline`.",
+            },
+            project: {
+                type: "string",
+                description: "Optional project filter. If omitted, searches across all projects.",
+            },
+        },
+        required: ["pipeline_id"],
+    },
+};
+// ─── session_abort_pipeline ─────────────────────────────────
+export const SESSION_ABORT_PIPELINE_TOOL = {
+    name: "session_abort_pipeline",
+    description: "Abort a running Dark Factory pipeline. The pipeline will be marked as ABORTED " +
+        "and the background runner will stop processing it on the next tick.\n\n" +
+        "**Note:** This is a 'kill switch' — the runner detects the status change via " +
+        "the storage status guard and gracefully stops execution.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            pipeline_id: {
+                type: "string",
+                description: "The pipeline ID to abort.",
+            },
+        },
+        required: ["pipeline_id"],
+    },
+};
+export function isStartPipelineArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    if (typeof a.project !== "string" || !a.project.trim())
+        return false;
+    if (typeof a.objective !== "string" || !a.objective.trim())
+        return false;
+    if (a.working_directory !== undefined && typeof a.working_directory !== "string")
+        return false;
+    if (a.max_iterations !== undefined && (typeof a.max_iterations !== "number" || a.max_iterations < 1 || a.max_iterations > 10))
+        return false;
+    if (a.context_files !== undefined && (!Array.isArray(a.context_files) || !a.context_files.every((f) => typeof f === "string")))
+        return false;
+    if (a.model_override !== undefined && typeof a.model_override !== "string")
+        return false;
+    return true;
+}
+export function isCheckPipelineStatusArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    if (typeof a.pipeline_id !== "string" || !a.pipeline_id.trim())
+        return false;
+    if (a.project !== undefined && typeof a.project !== "string")
+        return false;
+    return true;
+}
+export function isAbortPipelineArgs(args) {
+    if (typeof args !== "object" || args === null)
+        return false;
+    const a = args;
+    if (typeof a.pipeline_id !== "string" || !a.pipeline_id.trim())
+        return false;
+    return true;
+}

package/dist/tools/pipelineHandlers.js

@@ -0,0 +1,214 @@
+/**
+ * Pipeline Handlers (v7.3 — Dark Factory)
+ *
+ * MCP tool handlers for managing autonomous pipeline lifecycle:
+ *   - session_start_pipeline: Create and enqueue a new pipeline
+ *   - session_check_pipeline_status: Poll pipeline progress
+ *   - session_abort_pipeline: Kill a running pipeline
+ *
+ * These handlers follow the exact same CallToolResult pattern as
+ * all other tools in /tools/*.ts.
+ */
+import { randomUUID } from 'crypto';
+import { getStorage } from '../storage/index.js';
+import { PRISM_USER_ID } from '../config.js';
+import { getSettingSync } from '../storage/configStorage.js';
+import { isStartPipelineArgs, isCheckPipelineStatusArgs, isAbortPipelineArgs, } from './pipelineDefinitions.js';
+import { debugLog } from '../utils/logger.js';
+// ─── Start Pipeline Handler ─────────────────────────────────
+export async function sessionStartPipelineHandler(args) {
+    if (!isStartPipelineArgs(args)) {
+        return {
+            content: [{ type: "text", text: "❌ Invalid arguments. Required: project (string), objective (string). Optional: working_directory, max_iterations (1-10), context_files, model_override." }],
+            isError: true,
+        };
+    }
+    const { project, objective, working_directory, max_iterations, context_files, model_override } = args;
+    // Resolve working directory: explicit arg > dashboard repo_path > reject
+    let resolvedWorkDir = working_directory;
+    if (!resolvedWorkDir) {
+        // Project-scoped key first (dashboard stores "repo_path:<project>"),
+        // then fall back to global "repo_path"
+        resolvedWorkDir = getSettingSync(`repo_path:${project}`, "") || getSettingSync("repo_path", "");
+        if (!resolvedWorkDir) {
+            return {
+                content: [{ type: "text", text: "❌ No working_directory provided and no repo_path configured for this project. Either pass working_directory or configure repo_path in the dashboard." }],
+                isError: true,
+            };
+        }
+    }
+    const pipelineId = randomUUID();
+    const now = new Date().toISOString();
+    const spec = {
+        objective,
+        maxIterations: Math.min(max_iterations ?? 3, 10),
+        workingDirectory: resolvedWorkDir,
+        contextFiles: context_files,
+        modelOverride: model_override,
+    };
+    const pipelineState = {
+        id: pipelineId,
+        project,
+        user_id: PRISM_USER_ID,
+        status: 'PENDING',
+        current_step: 'INIT',
+        iteration: 0,
+        spec: JSON.stringify(spec),
+        error: null,
+        started_at: now,
+        updated_at: now,
+        last_heartbeat: now,
+    };
+    try {
+        const storage = await getStorage();
+        await storage.savePipeline(pipelineState);
+        debugLog(`[PipelineHandler] Pipeline ${pipelineId} created for project=${project} objective="${objective.slice(0, 80)}"`);
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `✅ Dark Factory pipeline started.`,
+                        ``,
+                        `**Pipeline ID:** \`${pipelineId}\``,
+                        `**Project:** ${project}`,
+                        `**Objective:** ${objective.slice(0, 200)}`,
+                        `**Working Directory:** ${resolvedWorkDir}`,
+                        `**Max Iterations:** ${spec.maxIterations}`,
+                        `**Status:** PENDING (queued for runner pickup)`,
+                        ``,
+                        `The pipeline is now executing autonomously in the background.`,
+                        `Use \`session_check_pipeline_status\` with the pipeline ID to poll for results.`,
+                        `Use \`session_abort_pipeline\` to cancel the pipeline.`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        debugLog(`[PipelineHandler] Failed to create pipeline: ${msg}`);
+        return {
+            content: [{ type: "text", text: `❌ Failed to create pipeline: ${msg}` }],
+            isError: true,
+        };
+    }
+}
+// ─── Check Pipeline Status Handler ──────────────────────────
+export async function sessionCheckPipelineStatusHandler(args) {
+    if (!isCheckPipelineStatusArgs(args)) {
+        return {
+            content: [{ type: "text", text: "❌ Invalid arguments. Required: pipeline_id (string). Optional: project." }],
+            isError: true,
+        };
+    }
+    const { pipeline_id, project } = args;
+    try {
+        const storage = await getStorage();
+        const pipeline = await storage.getPipeline(pipeline_id, PRISM_USER_ID);
+        if (!pipeline) {
+            return {
+                content: [{ type: "text", text: `❌ Pipeline \`${pipeline_id}\` not found.` }],
+                isError: true,
+            };
+        }
+        // Project filter — if specified, ensure pipeline belongs to the project
+        if (project && pipeline.project !== project) {
+            return {
+                content: [{ type: "text", text: `❌ Pipeline \`${pipeline_id}\` does not belong to project "${project}".` }],
+                isError: true,
+            };
+        }
+        // Parse spec for display (safe — we handle parse failures)
+        let objective = 'Unknown';
+        let maxIter = '?';
+        try {
+            const spec = JSON.parse(pipeline.spec);
+            objective = spec.objective.slice(0, 200);
+            maxIter = String(spec.maxIterations);
+        }
+        catch {
+            objective = '(spec corrupted)';
+        }
+        const isTerminal = ['COMPLETED', 'FAILED', 'ABORTED'].includes(pipeline.status);
+        const emoji = pipeline.status === 'COMPLETED' ? '✅' :
+            pipeline.status === 'FAILED' ? '❌' :
+                pipeline.status === 'ABORTED' ? '🛑' :
+                    pipeline.status === 'RUNNING' ? '⏳' :
+                        pipeline.status === 'PENDING' ? '⏸' : '📋';
+        const lines = [
+            `${emoji} **Pipeline Status: ${pipeline.status}**`,
+            ``,
+            `| Field | Value |`,
+            `|-------|-------|`,
+            `| **ID** | \`${pipeline.id}\` |`,
+            `| **Project** | ${pipeline.project} |`,
+            `| **Objective** | ${objective} |`,
+            `| **Current Step** | ${pipeline.current_step} |`,
+            `| **Iteration** | ${pipeline.iteration} / ${maxIter} |`,
+            `| **Started** | ${pipeline.started_at} |`,
+            `| **Last Updated** | ${pipeline.updated_at} |`,
+            `| **Last Heartbeat** | ${pipeline.last_heartbeat || 'N/A'} |`,
+        ];
+        if (pipeline.error) {
+            lines.push(`| **Error** | ${pipeline.error.slice(0, 500)} |`);
+        }
+        if (!isTerminal) {
+            lines.push(``, `*Pipeline is still running. Poll again in 30-60 seconds.*`);
+        }
+        return {
+            content: [{ type: "text", text: lines.join('\n') }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `❌ Failed to check pipeline status: ${msg}` }],
+            isError: true,
+        };
+    }
+}
+// ─── Abort Pipeline Handler ─────────────────────────────────
+export async function sessionAbortPipelineHandler(args) {
+    if (!isAbortPipelineArgs(args)) {
+        return {
+            content: [{ type: "text", text: "❌ Invalid arguments. Required: pipeline_id (string)." }],
+            isError: true,
+        };
+    }
+    const { pipeline_id } = args;
+    try {
+        const storage = await getStorage();
+        const pipeline = await storage.getPipeline(pipeline_id, PRISM_USER_ID);
+        if (!pipeline) {
+            return {
+                content: [{ type: "text", text: `❌ Pipeline \`${pipeline_id}\` not found.` }],
+                isError: true,
+            };
+        }
+        // Already terminal?
+        if (['COMPLETED', 'FAILED', 'ABORTED'].includes(pipeline.status)) {
+            return {
+                content: [{ type: "text", text: `ℹ️ Pipeline \`${pipeline_id}\` is already in terminal state: **${pipeline.status}**. No action needed.` }],
+            };
+        }
+        // Abort — the status guard + kill switch in runner.ts will handle the rest
+        await storage.savePipeline({
+            ...pipeline,
+            status: 'ABORTED',
+            error: 'Manually aborted by user via session_abort_pipeline.',
+        });
+        debugLog(`[PipelineHandler] Pipeline ${pipeline_id} aborted by user.`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `🛑 Pipeline \`${pipeline_id}\` has been **ABORTED**.\n\nThe background runner will stop processing this pipeline on the next tick.`,
+                }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `❌ Failed to abort pipeline: ${msg}` }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/routerExperience.js

@@ -54,6 +54,20 @@ export async function getExperienceBias(project, taskKeywords, storageBackend) {
                     relevantCount++;
                 }
             }
+            // GAP-1 fix: Ingest validation_result events into ML routing bias.
+            // The v7.2 spec requires that "Router learning ingests raw verification
+            // signals (pass_rate, critical_failures, coverage_score, rubric_hash)."
+            // confidence_score >= 80 indicates a passing verification suite.
+            if (eventType === "validation_result") {
+                const confidence = raw.confidence_score || 50;
+                if (confidence >= 80) {
+                    successCount++;
+                }
+                else {
+                    failureCount++;
+                }
+                relevantCount++;
+            }
         }
         if (relevantCount < MIN_SAMPLES) {
             return {

package/dist/tools/sessionMemoryDefinitions.js

@@ -899,7 +899,8 @@ export const SESSION_SAVE_EXPERIENCE_TOOL = {
         "- **correction**: Agent was corrected by user\n" +
         "- **success**: Task completed successfully\n" +
         "- **failure**: Task failed\n" +
-        "- **learning**: New knowledge acquired",
+        "- **learning**: New knowledge acquired\n" +
+        "- **validation_result**: Verification sandbox passed or failed",
     inputSchema: {
         type: "object",
         properties: {
@@ -909,7 +910,7 @@ export const SESSION_SAVE_EXPERIENCE_TOOL = {
             },
             event_type: {
                 type: "string",
-                enum: ["correction", "success", "failure", "learning"],
+                enum: ["correction", "success", "failure", "learning", "validation_result"],
                 description: "Type of behavioral event.",
             },
             context: {
@@ -952,7 +953,8 @@ export function isSessionSaveExperienceArgs(args) {
         (a.event_type !== "correction" &&
             a.event_type !== "success" &&
             a.event_type !== "failure" &&
-            a.event_type !== "learning"))
+            a.event_type !== "learning" &&
+            a.event_type !== "validation_result"))
         return false;
     if (typeof a.context !== "string")
         return false;