prism-mcp-server 7.2.0 → 7.3.1

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/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;

package/dist/verification/clawValidator.js

@@ -0,0 +1,228 @@
+/**
+ * Claw-as-Validator (v7.2.0)
+ *
+ * Adversarial validation layer that delegates assertion generation
+ * to the local Claw agent. When the host model produces a plan with
+ * test_assertions.json, the clawValidator can:
+ *
+ *  1. Review the assertions for completeness (are all layers covered?)
+ *  2. Generate adversarial counter-assertions to stress-test the plan
+ *  3. Validate the test suite against the codebase before execution
+ *
+ * This creates a host ↔ Claw dialectic: the host plans and writes code,
+ * Claw validates and challenges, creating a feedback loop that catches
+ * issues before the automated verification runner executes.
+ *
+ * Prerequisites:
+ *  - claw-code-agent MCP server must be available
+ *  - PRISM_VERIFICATION_HARNESS_ENABLED=true
+ */
+import { TestSuiteSchema } from "./schema.js";
+/**
+ * Build the prompt for Claw validation.
+ * The prompt instructs the Claw agent to analyze the test suite
+ * and report any missing coverage, logical errors, or improvements.
+ */
+function buildValidationPrompt(request) {
+    const assertionSummary = request.suite.tests
+        .map(t => `  - [${t.layer}/${t.severity}] ${t.id}: ${t.description}`)
+        .join("\n");
+    const filesContext = request.files_changed.length > 0
+        ? `\nFiles changed:\n${request.files_changed.map(f => `  - ${f}`).join("\n")}`
+        : "";
+    return `You are a code review validator. Analyze the following test assertion suite for completeness, correctness, and coverage.
+
+Project: ${request.project}
+${request.change_summary ? `Change: ${request.change_summary}` : ""}
+${filesContext}
+
+Test Assertions:
+${assertionSummary}
+
+Full JSON:
+${JSON.stringify(request.suite, null, 2)}
+
+Tasks:
+1. Check if all layers (data, agent, pipeline) have appropriate coverage
+2. Identify any assertions that could produce false positives/negatives
+3. Suggest any missing assertions that should be added
+4. Flag any assertions with incorrect severity levels
+
+Respond in JSON format:
+{
+  "accepted": true/false,
+  "issues": [{"severity": "info|warning|error", "message": "...", "assertion_id": "optional"}],
+  "suggested_assertions": []
+}`;
+}
+function tryParseObject(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Ignore parse errors — caller will continue searching
+    }
+    return null;
+}
+function extractCodeFenceBlocks(output) {
+    const blocks = [];
+    let cursor = 0;
+    while (cursor < output.length) {
+        const start = output.indexOf("```", cursor);
+        if (start === -1)
+            break;
+        const end = output.indexOf("```", start + 3);
+        if (end === -1)
+            break;
+        const block = output.slice(start + 3, end);
+        const firstNewline = block.indexOf("\n");
+        if (firstNewline === -1) {
+            blocks.push(block.trim());
+        }
+        else {
+            const body = block.slice(firstNewline + 1).trim();
+            if (body.length > 0)
+                blocks.push(body);
+        }
+        cursor = end + 3;
+    }
+    return blocks;
+}
+function extractBalancedAcceptedObject(output) {
+    const source = output.length > 200_000 ? output.slice(0, 200_000) : output;
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== "{")
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let j = i; j < source.length; j++) {
+            const ch = source[j];
+            if (inString) {
+                if (escaped)
+                    escaped = false;
+                else if (ch === "\\")
+                    escaped = true;
+                else if (ch === '"')
+                    inString = false;
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                continue;
+            }
+            if (ch === "{") {
+                depth++;
+                continue;
+            }
+            if (ch === "}") {
+                depth--;
+                if (depth === 0) {
+                    const candidate = source.slice(i, j + 1);
+                    const parsed = tryParseObject(candidate);
+                    if (parsed && Object.prototype.hasOwnProperty.call(parsed, "accepted")) {
+                        return parsed;
+                    }
+                    break;
+                }
+                if (depth < 0)
+                    break;
+            }
+        }
+    }
+    return null;
+}
+function parseClawJsonOutput(output) {
+    const direct = tryParseObject(output.trim());
+    if (direct && Object.prototype.hasOwnProperty.call(direct, "accepted")) {
+        return direct;
+    }
+    for (const block of extractCodeFenceBlocks(output)) {
+        const parsed = tryParseObject(block);
+        if (parsed && Object.prototype.hasOwnProperty.call(parsed, "accepted")) {
+            return parsed;
+        }
+    }
+    return extractBalancedAcceptedObject(output);
+}
+function normalizeIssues(rawIssues) {
+    if (!Array.isArray(rawIssues))
+        return [];
+    return rawIssues
+        .filter((issue) => Boolean(issue) && typeof issue === "object")
+        .map((issue) => ({
+        severity: issue.severity === "error" || issue.severity === "warning" || issue.severity === "info"
+            ? issue.severity
+            : "info",
+        message: typeof issue.message === "string"
+            ? issue.message
+            : "Claw issue payload was not a valid object message.",
+        assertion_id: typeof issue.assertion_id === "string" ? issue.assertion_id : undefined,
+    }));
+}
+/**
+ * Validate a test suite using the Claw agent.
+ *
+ * This is a non-blocking call — if the Claw agent is unavailable,
+ * validation is skipped with a warning (fail-open for v7.2.0).
+ */
+export async function validateWithClaw(request, clawRunTask) {
+    const prompt = buildValidationPrompt(request);
+    try {
+        const result = await clawRunTask(prompt, process.cwd());
+        const parsed = parseClawJsonOutput(result.output);
+        if (parsed) {
+            return {
+                accepted: typeof parsed.accepted === "boolean" ? parsed.accepted : true,
+                issues: normalizeIssues(parsed.issues),
+                suggested_assertions: Array.isArray(parsed.suggested_assertions) ? parsed.suggested_assertions : [],
+                raw_output: result.output,
+            };
+        }
+        return {
+            accepted: true,
+            issues: [{ severity: "info", message: "Claw response was unstructured; treating as accepted." }],
+            suggested_assertions: [],
+            raw_output: result.output,
+        };
+    }
+    catch (e) {
+        // Fail-open: Claw unavailable should not block verification
+        console.error(`[ClawValidator] Claw agent unavailable: ${e.message}`);
+        return {
+            accepted: true,
+            issues: [{ severity: "warning", message: `Claw agent unavailable: ${e.message}` }],
+            suggested_assertions: [],
+            raw_output: "",
+        };
+    }
+}
+/**
+ * Merge Claw-suggested assertions into an existing test suite.
+ * Re-validates the merged suite through the Zod schema.
+ */
+export function mergeSuggestedAssertions(suite, suggestions) {
+    if (!suggestions || suggestions.length === 0)
+        return suite;
+    try {
+        const merged = {
+            tests: [
+                ...suite.tests,
+                ...suggestions.map((s) => ({
+                    ...s,
+                    id: s.id || `claw-suggestion-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+                    severity: s.severity || "warn",
+                })),
+            ],
+        };
+        // Validate through schema — rejects malformed suggestions
+        return TestSuiteSchema.parse(merged);
+    }
+    catch (e) {
+        console.error(`[ClawValidator] Failed to merge suggestions: ${e.message}`);
+        return null;
+    }
+}