prism-mcp-server 7.2.0 → 7.3.1

package/dist/hivemindWatchdog.js

@@ -1,5 +1,5 @@
 /**
- * Hivemind Watchdog (v5.3) — Active Agent Health Monitoring
+ * Hivemind Watchdog (v7.2) — Active Agent Health Monitoring
  *
  * Server-side health monitor for multi-agent coordination.
  * Runs every WATCHDOG_INTERVAL_MS when PRISM_ENABLE_HIVEMIND=true.
@@ -22,7 +22,13 @@
  *   - Sweep is non-blocking: errors are caught and logged, never crash
  */
 import { getStorage } from "./storage/index.js";
-import { PRISM_USER_ID } from "./config.js";
+import { PRISM_USER_ID, PRISM_VERIFICATION_HARNESS_ENABLED, PRISM_VERIFICATION_LAYERS, PRISM_VERIFICATION_DEFAULT_SEVERITY } from "./config.js";
+import * as fs from "fs";
+import * as path from "path";
+import { VerificationRunner } from "./verification/runner.js";
+import { TestSuiteSchema } from "./verification/schema.js";
+import { validateWithClaw } from "./verification/clawValidator.js";
+import { sessionSaveExperienceHandler } from "./tools/ledgerHandlers.js";
 export const DEFAULT_WATCHDOG_CONFIG = {
     intervalMs: 60_000,
     staleThresholdMin: 5,
@@ -35,6 +41,11 @@ export const DEFAULT_WATCHDOG_CONFIG = {
  * Only one alert per agent per status is kept until drained.
  */
 const pendingAlerts = new Map();
+/**
+ * Deduplicates concurrent verification jobs per agent.
+ * Key format: project:user_id:role
+ */
+const inFlightVerifications = new Map();
 /**
  * Drain all pending alerts for a project.
  * Called by server.ts in the CallToolRequestSchema handler
@@ -118,7 +129,8 @@ export async function runWatchdogSweep(cfg = DEFAULT_WATCHDOG_CONFIG) {
         // ── State Transition: Heartbeat-based ──────────────────
         let newStatus = null;
         if (minutesSinceHeartbeat >= cfg.offlineThresholdMin) {
-            // OFFLINE → prune the agent
+            // OFFLINE → prune the agent and clean up assertion files
+            cleanupAssertionFiles(agent);
             try {
                 await storage.deregisterAgent(agent.project, agent.user_id, agent.role);
                 queueAlert(agent, "OFFLINE", `No heartbeat for ${Math.floor(minutesSinceHeartbeat)}m — auto-pruned from registry.`);
@@ -161,6 +173,166 @@ export async function runWatchdogSweep(cfg = DEFAULT_WATCHDOG_CONFIG) {
                 }
             }
         }
+        // ── State Transition: Verification Phase (v7.2.0 Enhanced) ──
+        // ARCHITECTURE: Verification is fire-and-forget. The sweep transitions the agent
+        // to 'verifying' synchronously and spawns a detached async closure. This prevents
+        // long-running Claw/Runner calls (10-70s) from blocking heartbeat checks for
+        // other agents.
+        if (!newStatus && (currentStatus === "active" || currentStatus === "failed_validation")) {
+            // v7.2.0 FIX: Scope assertion file per project+role to prevent multi-agent collision
+            const scopedFile = path.join(".prism-mcp", `test_assertions_${agent.project}_${agent.role}.json`);
+            // Also check the legacy global path for backward compat
+            const legacyFile = "test_assertions.json";
+            const activeFile = fs.existsSync(scopedFile) ? scopedFile
+                : fs.existsSync(legacyFile) ? legacyFile
+                    : null;
+            if (activeFile) {
+                const flightKey = `${agent.project}:${agent.user_id}:${agent.role}`;
+                // Skip if a verification is already in-flight for this agent
+                if (!inFlightVerifications.has(flightKey)) {
+                    // Set verifying state synchronously (non-blocking for the sweep)
+                    console.error(`[Watchdog] 🔬 Verifying agent "${agent.role}" on "${agent.project}"`);
+                    newStatus = "verifying";
+                    // Capture values for the async closure
+                    const capturedAgent = { ...agent };
+                    const capturedFile = activeFile;
+                    const capturedFailCount = agent.loop_count || 0;
+                    // Spawn detached verification — does NOT block the sweep
+                    const verificationJob = (async () => {
+                        try {
+                            const assertionsContent = fs.readFileSync(capturedFile, "utf8");
+                            const innerStorage = await getStorage();
+                            // v7.2.0: Build verification config from env vars
+                            const vConfig = {
+                                enabled: PRISM_VERIFICATION_HARNESS_ENABLED,
+                                layers: PRISM_VERIFICATION_LAYERS,
+                                default_severity: PRISM_VERIFICATION_DEFAULT_SEVERITY,
+                            };
+                            // v7.2.0: Claw-as-Validator adversarial pre-check (fail-open)
+                            if (PRISM_VERIFICATION_HARNESS_ENABLED) {
+                                try {
+                                    const suite = TestSuiteSchema.parse(JSON.parse(assertionsContent));
+                                    const clawResult = await validateWithClaw({
+                                        suite,
+                                        project: capturedAgent.project,
+                                        files_changed: [],
+                                        change_summary: `Automated verification for ${capturedAgent.role}`,
+                                    }, async (prompt, cwd) => {
+                                        // @ts-ignore: Optional runtime dependency; handled by .catch()
+                                        const mod = await import("./tools/clawHandlers.js").catch(() => null);
+                                        if (!mod?.clawRunTaskHandler)
+                                            throw new Error("claw-agent not available");
+                                        return mod.clawRunTaskHandler({ prompt, cwd });
+                                    });
+                                    if (!clawResult.accepted) {
+                                        console.error(`[Watchdog] ⚠️ Claw validator flagged ${clawResult.issues.length} issues`);
+                                    }
+                                }
+                                catch (clawErr) {
+                                    console.error(`[Watchdog] Claw validator skipped: ${clawErr instanceof Error ? clawErr.message : String(clawErr)}`);
+                                }
+                            }
+                            // v7.2.0: Use enhanced runner with layer filtering
+                            const result = await VerificationRunner.runSuite(assertionsContent, PRISM_VERIFICATION_HARNESS_ENABLED
+                                ? { layers: PRISM_VERIFICATION_LAYERS, config: vConfig }
+                                : undefined);
+                            let resolvedStatus;
+                            let resolvedLoopCount = capturedFailCount;
+                            if (!result.passed) {
+                                // Emit structured experience event
+                                try {
+                                    await sessionSaveExperienceHandler({
+                                        project: capturedAgent.project,
+                                        event_type: "validation_result",
+                                        context: `Verification run for ${capturedAgent.role}`,
+                                        action: "automated_verification",
+                                        outcome: `${result.failed_count}/${result.total} failed — gate: ${result.severity_gate.action}`,
+                                        role: capturedAgent.role,
+                                        confidence_score: Math.round((result.passed_count / Math.max(result.total, 1)) * 100)
+                                    });
+                                }
+                                catch (err) {
+                                    console.error(`[Watchdog] Error saving failure experience: ${err}`);
+                                }
+                                // Severity gate enforcement
+                                if (PRISM_VERIFICATION_HARNESS_ENABLED && result.severity_gate.action === "abort") {
+                                    resolvedStatus = "failed_validation";
+                                    resolvedLoopCount = capturedFailCount + 1;
+                                    queueAlert(capturedAgent, "FAILED_VALIDATION", `[ABORT] ${result.severity_gate.summary}`);
+                                    console.error(`[Watchdog] 🛑 ABORT gate triggered for "${capturedAgent.role}" — ${result.severity_gate.summary}`);
+                                }
+                                else if (PRISM_VERIFICATION_HARNESS_ENABLED && result.severity_gate.action === "block") {
+                                    resolvedStatus = "failed_validation";
+                                    resolvedLoopCount = capturedFailCount + 1;
+                                    queueAlert(capturedAgent, "FAILED_VALIDATION", `[BLOCKED] ${result.severity_gate.summary}`);
+                                    console.error(`[Watchdog] 🚫 Gate BLOCKED for "${capturedAgent.role}" — ${result.severity_gate.summary}`);
+                                }
+                                else if (capturedFailCount >= 3) {
+                                    resolvedStatus = "looping";
+                                    // FIX: Clean up orphaned assertion file on LOOPING
+                                    cleanupAssertionFiles(capturedAgent);
+                                    queueAlert(capturedAgent, "LOOPING", `Validation failed ${capturedFailCount} times. Bailing out.`);
+                                }
+                                else {
+                                    resolvedStatus = "failed_validation";
+                                    resolvedLoopCount = capturedFailCount + 1;
+                                    const failSummary = result.assertion_results
+                                        .filter(a => !a.passed && !a.skipped)
+                                        .map(a => `[${a.layer}] ${a.description}: ${a.error}`)
+                                        .join(" | ");
+                                    queueAlert(capturedAgent, "FAILED_VALIDATION", `[Verification Failed] ${failSummary}`);
+                                }
+                            }
+                            else {
+                                // Passed! Clean up assertion file
+                                cleanupAssertionFiles(capturedAgent);
+                                resolvedStatus = "active";
+                                resolvedLoopCount = 0;
+                                queueAlert(capturedAgent, "SUCCESS", "All test assertions passed successfully.");
+                                console.error(`[Watchdog] ✅ Verification PASSED for "${capturedAgent.role}" on "${capturedAgent.project}"`);
+                                try {
+                                    await sessionSaveExperienceHandler({
+                                        project: capturedAgent.project,
+                                        event_type: "validation_result",
+                                        context: `Verification run for ${capturedAgent.role}`,
+                                        action: "automated_verification",
+                                        outcome: `Passed all ${result.total} assertions (${result.duration_ms}ms)`,
+                                        role: capturedAgent.role,
+                                        confidence_score: 100
+                                    });
+                                }
+                                catch (err) {
+                                    console.error(`[Watchdog] Error saving success experience: ${err}`);
+                                }
+                            }
+                            // Persist final status
+                            try {
+                                await innerStorage.updateAgentStatus(capturedAgent.project, capturedAgent.user_id, capturedAgent.role, resolvedStatus, { loop_count: resolvedLoopCount });
+                            }
+                            catch (err) {
+                                console.error(`[Watchdog] Failed to update status after verification: ${err}`);
+                            }
+                        }
+                        catch (e) {
+                            // Verification script error — mark as failed_validation
+                            try {
+                                const innerStorage = await getStorage();
+                                await innerStorage.updateAgentStatus(capturedAgent.project, capturedAgent.user_id, capturedAgent.role, "failed_validation", { loop_count: capturedFailCount + 1 });
+                            }
+                            catch { /* best-effort */ }
+                            queueAlert(capturedAgent, "FAILED_VALIDATION", `[Verification Script Error] ${e.message}`);
+                        }
+                        finally {
+                            inFlightVerifications.delete(flightKey);
+                        }
+                    })();
+                    inFlightVerifications.set(flightKey, verificationJob);
+                }
+            }
+        }
+        else if (!newStatus && currentStatus === "verifying") {
+            // Agent is already verifying — don't re-trigger, just skip
+        }
         // ── State Transition: LOOPING confirmation ─────────────
         // Loop detection is primarily done in heartbeatAgent().
         // The watchdog just confirms and queues alerts for it.
@@ -169,6 +341,8 @@ export async function runWatchdogSweep(cfg = DEFAULT_WATCHDOG_CONFIG) {
             agent.loop_count >= cfg.loopThreshold &&
             currentStatus !== "looping") {
             newStatus = "looping";
+            // FIX: Clean up orphaned assertion files on LOOPING
+            cleanupAssertionFiles(agent);
             queueAlert(agent, "LOOPING", `Same task repeated ${agent.loop_count} times — possible infinite loop.`);
             console.error(`[Watchdog] 🔄 Agent "${agent.role}" on "${agent.project}" detected LOOPING ` +
                 `(task repeated ${agent.loop_count}x)`);
@@ -176,7 +350,7 @@ export async function runWatchdogSweep(cfg = DEFAULT_WATCHDOG_CONFIG) {
         // ── Apply status update ────────────────────────────────
         if (newStatus && newStatus !== currentStatus) {
             try {
-                await storage.updateAgentStatus(agent.project, agent.user_id, agent.role, newStatus);
+                await storage.updateAgentStatus(agent.project, agent.user_id, agent.role, newStatus, { loop_count: agent.loop_count });
             }
             catch (err) {
                 console.error(`[Watchdog] Status update failed for ${agent.project}/${agent.role}: ${err instanceof Error ? err.message : String(err)}`);
@@ -204,3 +378,22 @@ function truncate(str, maxLen) {
         return str;
     return str.slice(0, maxLen - 3) + "...";
 }
+/**
+ * Clean up assertion files for an agent (scoped + legacy).
+ * Prevents orphaned files from triggering phantom verifications on restart.
+ */
+function cleanupAssertionFiles(agent) {
+    const scopedFile = path.join(".prism-mcp", `test_assertions_${agent.project}_${agent.role}.json`);
+    const legacyFile = "test_assertions.json";
+    for (const filePath of [scopedFile, legacyFile]) {
+        try {
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                console.error(`[Watchdog] 🧹 Cleaned up assertion file: ${filePath}`);
+            }
+        }
+        catch (err) {
+            console.error(`[Watchdog] Failed to clean up ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/lifecycle.js

@@ -157,7 +157,15 @@ export function registerShutdownHandlers() {
         shuttingDown = true;
         log(`Shutting down gracefully (${reason})...`);
         try {
-            // 0. Await pending background tasks FIRST (max 5s timeout)
+            // 0. Stop the Dark Factory background runner first (prevents new DB writes)
+            try {
+                const { stopDarkFactoryRunner } = await import("./darkfactory/runner.js");
+                stopDarkFactoryRunner();
+            }
+            catch {
+                // Runner may not be initialized — safe to ignore
+            }
+            // 0.5 Await pending background tasks (max 5s timeout)
             await BackgroundTaskRegistry.awaitAll(5000);
             // 0.5. Flush OTel span buffer FIRST — before any DBs are closed.
             //    BatchSpanProcessor holds spans in memory (up to 5s). If we close

package/dist/server.js

@@ -58,9 +58,10 @@ ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequ
 // Claude Desktop that the attached resource has changed.
 // Without this, the paperclipped context becomes stale.
 SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { SERVER_CONFIG, SESSION_MEMORY_ENABLED, PRISM_USER_ID, PRISM_ENABLE_HIVEMIND, WATCHDOG_INTERVAL_MS, WATCHDOG_STALE_MIN, WATCHDOG_FROZEN_MIN, WATCHDOG_OFFLINE_MIN, WATCHDOG_LOOP_THRESHOLD, PRISM_SCHEDULER_ENABLED, PRISM_SCHEDULER_INTERVAL_MS, PRISM_SCHOLAR_ENABLED, PRISM_HDC_ENABLED, PRISM_TASK_ROUTER_ENABLED_ENV, } from "./config.js";
+import { SERVER_CONFIG, SESSION_MEMORY_ENABLED, PRISM_USER_ID, PRISM_ENABLE_HIVEMIND, WATCHDOG_INTERVAL_MS, WATCHDOG_STALE_MIN, WATCHDOG_FROZEN_MIN, WATCHDOG_OFFLINE_MIN, WATCHDOG_LOOP_THRESHOLD, PRISM_SCHEDULER_ENABLED, PRISM_SCHEDULER_INTERVAL_MS, PRISM_SCHOLAR_ENABLED, PRISM_HDC_ENABLED, PRISM_TASK_ROUTER_ENABLED_ENV, PRISM_DARK_FACTORY_ENABLED, } from "./config.js";
 import { startWatchdog, drainAlerts } from "./hivemindWatchdog.js";
 import { startScheduler, startScholarScheduler } from "./backgroundScheduler.js";
+import { startDarkFactoryRunner } from "./darkfactory/runner.js";
 import { getSyncBus } from "./sync/factory.js";
 import { startDashboardServer } from "./dashboard/server.js";
 import { acquireLock, registerShutdownHandlers } from "./lifecycle.js";
@@ -123,7 +124,9 @@ MAINTENANCE_VACUUM_TOOL, maintenanceVacuumHandler,
 // ─── v3.0: Agent Hivemind tools ───
 AGENT_REGISTRY_TOOLS, agentRegisterHandler, agentHeartbeatHandler, agentListTeamHandler, 
 // v7.1: Task Router
-sessionTaskRouteHandler, } from "./tools/index.js";
+sessionTaskRouteHandler, 
+// v7.3: Dark Factory Pipeline tools
+SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL, sessionStartPipelineHandler, sessionCheckPipelineStatusHandler, sessionAbortPipelineHandler, } from "./tools/index.js";
 // ─── Dynamic Tool Registration ───────────────────────────────────
 // Base tools: always available regardless of configuration
 const BASE_TOOLS = [
@@ -282,6 +285,8 @@ export function createServer() {
         ...(PRISM_ENABLE_HIVEMIND ? AGENT_REGISTRY_TOOLS : []),
         // v7.1: Task Router tool — only when PRISM_TASK_ROUTER_ENABLED=true
         ...(getSettingSync("task_router_enabled", String(PRISM_TASK_ROUTER_ENABLED_ENV)) === "true" ? [SESSION_TASK_ROUTE_TOOL] : []),
+        // v7.3: Dark Factory pipeline tools — only when PRISM_DARK_FACTORY_ENABLED=true
+        ...(PRISM_DARK_FACTORY_ENABLED ? [SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL] : []),
     ];
     const server = new Server({
         name: SERVER_CONFIG.name,
@@ -811,6 +816,28 @@ export function createServer() {
                             throw new Error("Task router not enabled. Enable it in the dashboard or set PRISM_TASK_ROUTER_ENABLED=true.");
                         result = await sessionTaskRouteHandler(args);
                         break;
+                    // ─── v7.3: Dark Factory Pipeline Tools ───
+                    case "session_start_pipeline":
+                        if (!SESSION_MEMORY_ENABLED)
+                            throw new Error("Session memory not configured.");
+                        if (!PRISM_DARK_FACTORY_ENABLED)
+                            throw new Error("Dark Factory not enabled. Set PRISM_DARK_FACTORY_ENABLED=true.");
+                        result = await sessionStartPipelineHandler(args);
+                        break;
+                    case "session_check_pipeline_status":
+                        if (!SESSION_MEMORY_ENABLED)
+                            throw new Error("Session memory not configured.");
+                        if (!PRISM_DARK_FACTORY_ENABLED)
+                            throw new Error("Dark Factory not enabled. Set PRISM_DARK_FACTORY_ENABLED=true.");
+                        result = await sessionCheckPipelineStatusHandler(args);
+                        break;
+                    case "session_abort_pipeline":
+                        if (!SESSION_MEMORY_ENABLED)
+                            throw new Error("Session memory not configured.");
+                        if (!PRISM_DARK_FACTORY_ENABLED)
+                            throw new Error("Dark Factory not enabled. Set PRISM_DARK_FACTORY_ENABLED=true.");
+                        result = await sessionAbortPipelineHandler(args);
+                        break;
                     default:
                         result = {
                             content: [{ type: "text", text: `Unknown tool: ${name}` }],
@@ -892,7 +919,7 @@ export function createSandboxServer() {
     });
     // Register all tool listings unconditionally
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...BASE_TOOLS, ...buildSessionMemoryTools([]), ...AGENT_REGISTRY_TOOLS, SESSION_TASK_ROUTE_TOOL],
+        tools: [...BASE_TOOLS, ...buildSessionMemoryTools([]), ...AGENT_REGISTRY_TOOLS, SESSION_TASK_ROUTE_TOOL, SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL],
     }));
     // Register prompts listing so scanners see resume_session
     server.setRequestHandler(ListPromptsRequestSchema, async () => ({
@@ -1146,6 +1173,17 @@ export async function startServer() {
             console.error(`[WebScholar] Startup failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         });
     }
+    // ─── v7.3: Dark Factory Background Runner ────────────────
+    // Autonomous pipeline orchestration engine. Picks up RUNNING
+    // pipelines and advances them through PLAN → EXECUTE → VERIFY
+    // cycles. Non-blocking — uses setInterval to yield between ticks.
+    if (PRISM_DARK_FACTORY_ENABLED && SESSION_MEMORY_ENABLED) {
+        storageReady?.then(() => {
+            startDarkFactoryRunner();
+        }).catch(err => {
+            console.error(`[DarkFactory] Startup failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
     // Keep the process alive — without this, Node.js would exit
     // because there are no active event loop handles after the
     // synchronous setup completes.

package/dist/storage/sqlite.js

@@ -24,6 +24,7 @@ import { AccessLogBuffer } from "../utils/accessLogBuffer.js";
 import { PRISM_ACTR_BUFFER_FLUSH_MS } from "../config.js";
 import { getSetting as cfgGet, setSetting as cfgSet, getAllSettings as cfgGetAll } from "./configStorage.js";
 import { debugLog } from "../utils/logger.js";
+import { SafetyController } from "../darkfactory/safetyController.js";
 export class SqliteStorage {
     db;
     dbPath;
@@ -556,6 +557,23 @@ export class SqliteStorage {
        ON memory_access_log(entry_id, accessed_at DESC)`);
         await this.db.execute(`CREATE INDEX IF NOT EXISTS idx_access_log_time
        ON memory_access_log(accessed_at)`);
+        // ─── v7.3 Migration: Dark Factory Pipelines ───────────────
+        await this.db.execute(`
+      CREATE TABLE IF NOT EXISTS 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 TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        spec TEXT NOT NULL,
+        error TEXT,
+        last_heartbeat TEXT
+      )
+    `);
+        await this.db.execute(`CREATE INDEX IF NOT EXISTS idx_pipelines_status ON dark_factory_pipelines(user_id, project, status)`);
         // ─── v6.1 Migration: Integrity Check ──────────────────────
         //
         // REVIEWER NOTE: PRAGMA integrity_check scans the B-tree structure of
@@ -2786,4 +2804,74 @@ export class SqliteStorage {
         debugLog(`[SqliteStorage] pruneAccessLog: removed ${pruned} entries older than ${olderThanDays} days`);
         return pruned;
     }
+    // ─── 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)'}.`);
+            }
+        }
+        await this.db.execute({
+            sql: `
+        INSERT INTO dark_factory_pipelines (id, project, user_id, status, current_step, iteration, started_at, updated_at, spec, error, last_heartbeat)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          status = excluded.status,
+          current_step = excluded.current_step,
+          iteration = excluded.iteration,
+          updated_at = excluded.updated_at,
+          spec = excluded.spec,
+          error = excluded.error,
+          last_heartbeat = excluded.last_heartbeat
+      `,
+            args: [
+                updatedState.id,
+                updatedState.project,
+                updatedState.user_id,
+                updatedState.status,
+                updatedState.current_step,
+                updatedState.iteration,
+                updatedState.started_at,
+                updatedState.updated_at,
+                updatedState.spec,
+                updatedState.error || null,
+                updatedState.last_heartbeat || null
+            ]
+        });
+    }
+    async getPipeline(id, userId) {
+        const result = await this.db.execute({
+            sql: `SELECT * FROM dark_factory_pipelines WHERE id = ? AND user_id = ?`,
+            args: [id, userId]
+        });
+        if (result.rows.length === 0)
+            return null;
+        return result.rows[0];
+    }
+    async listPipelines(project, status, userId) {
+        const conditions = ['user_id = ?'];
+        const args = [userId];
+        if (project) {
+            conditions.push('project = ?');
+            args.push(project);
+        }
+        if (status) {
+            conditions.push('status = ?');
+            args.push(status);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const sql = `SELECT * FROM dark_factory_pipelines ${where} ORDER BY updated_at DESC`;
+        const result = await this.db.execute({ sql, args });
+        return result.rows;
+    }
 }

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,82 @@ 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;
+        }
+    }
 }

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