prism-mcp-server 20.21.21 → 20.21.23

package/dist/darkfactory/runner.js

@@ -18,11 +18,13 @@
  *   Using console.log() (stdout) will corrupt the MCP JSON-RPC stream.
  */
 import { getStorage } from '../storage/index.js';
+import { SqliteStorage } from '../storage/sqlite.js';
 import { VALID_ACTION_TYPES } from './schema.js';
 import { SafetyController } from './safetyController.js';
 import { invokeClawAgent } from './clawInvocation.js';
 import { PRISM_DARK_FACTORY_POLL_MS, PRISM_DARK_FACTORY_MAX_RUNTIME_MS, PRISM_USER_ID, PRISM_VERIFICATION_LAYERS, PRISM_VERIFICATION_DEFAULT_SEVERITY } from '../config.js';
 import { debugLog } from '../utils/logger.js';
+import { executeActions } from './actionExecutor.js';
 import path from 'path';
 import fs from 'fs';
 import * as crypto from 'crypto';
@@ -30,6 +32,19 @@ import { Gatekeeper } from '../verification/gatekeeper.js';
 import { VerificationRunner } from '../verification/runner.js';
 import { computeRubricHash } from '../verification/schema.js';
 import { VerificationGateError } from '../errors.js';
+import { registerPipelineAuthority, isPipelineAuthorized, claimPipelineLease, FACTORY_LEASE_RENEW_MS } from './executionAuthority.js';
+const LEASED_STORAGE_WRITES = new Set(['savePipeline', 'saveVerificationHarness', 'saveVerificationRun']);
+async function locallyAuthorized(pipeline, backend) {
+    if (await isPipelineAuthorized(pipeline))
+        return true;
+    // Existing local SQLite queues already belong to this machine. Remote
+    // rows require a receipt created by the local start handler.
+    if (backend instanceof SqliteStorage && pipeline.status === 'PENDING') {
+        await registerPipelineAuthority(pipeline);
+        return true;
+    }
+    return false;
+}
 /** Interval handle for graceful shutdown */
 let runnerInterval = null;
 /** Tracks whether the runner is currently processing a tick (prevents overlap) */
@@ -48,15 +63,28 @@ async function recoverStalePipelines() {
             debugLog('[DarkFactory] No stale pipelines found on startup.');
             return;
         }
-        debugLog(`[DarkFactory] Found ${runningPipelines.length} stale RUNNING pipeline(s) — marking as FAILED.`);
+        debugLog(`[DarkFactory] Checking ${runningPipelines.length} RUNNING pipeline(s) for locally authorized recovery.`);
         for (const pipeline of runningPipelines) {
+            if (!(await locallyAuthorized(pipeline, storage)))
+                continue;
+            const lease = await claimPipelineLease(pipeline);
+            if (!lease)
+                continue;
             try {
+                const live = await storage.getPipeline(pipeline.id, pipeline.user_id);
+                if (!live || live.status !== 'RUNNING' || !(await isPipelineAuthorized(live)))
+                    continue;
+                if (!lease.reclaimed && !SafetyController.isHeartbeatLapsed(live))
+                    continue;
+                if (!(await lease.isHeld()))
+                    continue;
                 await storage.savePipeline({
-                    ...pipeline,
+                    ...live,
                     status: 'FAILED',
                     error: 'Unexpected Server Termination: pipeline was RUNNING when server restarted.',
                     current_step: pipeline.current_step,
                 });
+                await lease.acknowledgeRecovery();
                 debugLog(`[DarkFactory] Pipeline ${pipeline.id} marked FAILED (was RUNNING on restart).`);
             }
             catch (err) {
@@ -64,6 +92,9 @@ async function recoverStalePipelines() {
                 // by a concurrent process — safe to ignore.
                 console.error(`[DarkFactory] Failed to recover pipeline ${pipeline.id}: ${err instanceof Error ? err.message : String(err)}`);
             }
+            finally {
+                await lease.release();
+            }
         }
     }
     catch (err) {
@@ -76,8 +107,10 @@ async function recoverStalePipelines() {
  * Called periodically during LLM execution to prove liveness.
  * This is intentionally cheap — just a timestamp update.
  */
-async function pulseHeartbeat(pipelineId, userId) {
+async function pulseHeartbeat(pipelineId, userId, lease) {
     try {
+        if (!(await lease.isHeld()))
+            return;
         const storage = await getStorage();
         const pipeline = await storage.getPipeline(pipelineId, userId);
         if (!pipeline || pipeline.status !== 'RUNNING')
@@ -95,9 +128,9 @@ async function pulseHeartbeat(pipelineId, userId) {
  * Creates a heartbeat interval that pulses every 15 seconds during execution.
  * Returns a cleanup function to stop the interval.
  */
-function startHeartbeatInterval(pipelineId, userId) {
+function startHeartbeatInterval(pipelineId, userId, lease) {
     const interval = setInterval(() => {
-        pulseHeartbeat(pipelineId, userId).catch(() => { });
+        pulseHeartbeat(pipelineId, userId, lease).catch(() => { });
     }, 15_000);
     return () => clearInterval(interval);
 }
@@ -113,17 +146,29 @@ async function sweepZombies() {
         const running = await storage.listPipelines(undefined, 'RUNNING', PRISM_USER_ID);
         for (const pipeline of running) {
             if (SafetyController.isHeartbeatLapsed(pipeline)) {
+                if (!(await locallyAuthorized(pipeline, storage)))
+                    continue;
+                const lease = await claimPipelineLease(pipeline);
+                if (!lease)
+                    continue;
                 debugLog(`[DarkFactory] Zombie detected: pipeline ${pipeline.id} heartbeat lapsed.`);
                 try {
+                    const live = await storage.getPipeline(pipeline.id, pipeline.user_id);
+                    if (!live || live.status !== 'RUNNING' || !SafetyController.isHeartbeatLapsed(live) || !(await lease.isHeld()))
+                        continue;
                     await storage.savePipeline({
-                        ...pipeline,
+                        ...live,
                         status: 'FAILED',
                         error: `Zombie pipeline: no heartbeat for ${SafetyController.HEARTBEAT_TIMEOUT_MS / 1000}s.`,
                     });
+                    await lease.acknowledgeRecovery();
                 }
                 catch {
                     // Status guard may fire — pipeline was already terminated
                 }
+                finally {
+                    await lease.release();
+                }
                 // Emit failure experience event
                 await emitExperienceEvent(pipeline, 'failure', 'Pipeline zombie-swept due to heartbeat lapse.');
             }
@@ -316,12 +361,12 @@ export function parseEvaluationOutput(raw) {
  * The `scopeViolation` field on the result signals the runner to
  * terminate the entire pipeline (not just the step).
  */
-async function executeStep(pipeline, spec) {
+async function executeStep(pipeline, spec, lease) {
     const stepStart = new Date().toISOString();
     const step = pipeline.current_step;
     debugLog(`[DarkFactory] Executing step=${step} iter=${pipeline.iteration} pipeline=${pipeline.id}`);
     // Start heartbeat pulse during LLM execution
-    const stopHeartbeat = startHeartbeatInterval(pipeline.id, pipeline.user_id);
+    const stopHeartbeat = startHeartbeatInterval(pipeline.id, pipeline.user_id, lease);
     try {
         // All steps use the Claw invocation wrapper which applies:
         // - SafetyController boundary prompt
@@ -440,14 +485,25 @@ async function executeStep(pipeline, spec) {
                 scopeViolation: scopeError,
             };
         }
-        // All actions validated — return success with structured notes
+        let observations;
+        try {
+            observations = await executeActions(parsed.actions, spec, async () => {
+                if (!runnerInterval || !(await lease.isHeld()))
+                    return false;
+                const live = await (await getStorage()).getPipeline(pipeline.id, pipeline.user_id);
+                return !!runnerInterval && await lease.isHeld() && live?.status === 'RUNNING' && live.current_step === pipeline.current_step;
+            }, async () => !!runnerInterval && await lease.isHeld());
+        }
+        catch (error) {
+            return { iteration: pipeline.iteration, step, started_at: stepStart, completed_at: new Date().toISOString(), success: false, notes: String(error instanceof Error ? error.message : error) };
+        }
         return {
             iteration: pipeline.iteration,
             step,
             started_at: stepStart,
             completed_at: new Date().toISOString(),
             success: true,
-            notes: parsed.notes || `Executed ${parsed.actions.length} action(s) successfully`,
+            notes: `${parsed.notes || `Executed ${parsed.actions.length} action(s) successfully`}\n${observations.join('\n')}`,
         };
     }
     finally {
@@ -469,25 +525,72 @@ async function runnerTick() {
         return;
     }
     tickInProgress = true;
+    let lease = null;
+    let renewalInterval;
     try {
         // Phase 1: Zombie sweep (cheap — just DB reads)
         await sweepZombies();
         // Phase 2: Promote PENDING → RUNNING, then find a RUNNING pipeline to advance
-        const storage = await getStorage();
-        // Pick up PENDING pipelines and promote to RUNNING (queue → active)
-        const pending = await storage.listPipelines(undefined, 'PENDING', PRISM_USER_ID);
-        if (pending.length > 0) {
-            // Promote oldest PENDING pipeline (FIFO)
-            const toPromote = pending.sort((a, b) => new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime())[0];
-            debugLog(`[DarkFactory] Promoting PENDING pipeline ${toPromote.id} → RUNNING`);
-            await storage.savePipeline({ ...toPromote, status: 'RUNNING' });
+        const backend = await getStorage();
+        const candidates = [
+            ...await backend.listPipelines(undefined, 'PENDING', PRISM_USER_ID),
+            ...await backend.listPipelines(undefined, 'RUNNING', PRISM_USER_ID),
+        ].sort((a, b) => Date.parse(a.updated_at) - Date.parse(b.updated_at));
+        let selected;
+        for (const candidate of candidates) {
+            if (!(await locallyAuthorized(candidate, backend)))
+                continue;
+            lease = await claimPipelineLease(candidate);
+            if (lease) {
+                selected = candidate;
+                break;
+            }
         }
-        const running = await storage.listPipelines(undefined, 'RUNNING', PRISM_USER_ID);
-        if (running.length === 0) {
-            return; // Nothing to do
+        if (!selected || !lease)
+            return;
+        const heldLease = lease;
+        renewalInterval = setInterval(() => {
+            void heldLease.renew().catch(error => {
+                console.error(`[DarkFactory] Execution lease renewal failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, FACTORY_LEASE_RENEW_MS);
+        renewalInterval.unref();
+        const pipeline = await backend.getPipeline(selected.id, selected.user_id);
+        if (!pipeline || !(await isPipelineAuthorized(pipeline)))
+            return;
+        if (!['PENDING', 'RUNNING'].includes(pipeline.status)) {
+            if (['FAILED', 'ABORTED', 'COMPLETED'].includes(pipeline.status))
+                await heldLease.acknowledgeRecovery();
+            return;
+        }
+        // Every persisted lifecycle/verification write must retain this process's
+        // authority. File actions and the test command check the same lease below.
+        const storage = new Proxy(backend, { get(target, key) {
+                const value = Reflect.get(target, key);
+                if (typeof value !== 'function')
+                    return value;
+                if (!LEASED_STORAGE_WRITES.has(String(key)))
+                    return value.bind(target);
+                return async (...args) => {
+                    if (!(await heldLease.isHeld()) || !(await isPipelineAuthorized(pipeline)))
+                        throw new Error('Factory execution lease lost');
+                    return Reflect.apply(value, target, args);
+                };
+            } });
+        if (heldLease.reclaimed && pipeline.status === 'RUNNING') {
+            await storage.savePipeline({ ...pipeline, status: 'FAILED', error: 'Execution owner was lost; refusing to replay an unfinished step.' });
+            await heldLease.acknowledgeRecovery();
+            return;
+        }
+        if (pipeline.status === 'PENDING') {
+            await storage.savePipeline({ ...pipeline, status: 'RUNNING' });
+            const promoted = await backend.getPipeline(pipeline.id, pipeline.user_id);
+            if (!promoted || promoted.status !== 'RUNNING')
+                return;
+            Object.assign(pipeline, promoted);
+            if (heldLease.reclaimed)
+                await heldLease.acknowledgeRecovery();
         }
-        // Pick the oldest updated pipeline (FIFO fairness)
-        const pipeline = running.sort((a, b) => new Date(a.updated_at).getTime() - new Date(b.updated_at).getTime())[0];
         // Poison Pill Guard: Parse spec with localized error handling.
         // If a pipeline has corrupt/invalid JSON in its spec column,
         // we MUST mark it FAILED immediately. Otherwise the runner will
@@ -578,7 +681,25 @@ async function runnerTick() {
             return;
         }
         // Execute the current step
-        const result = await executeStep(pipeline, spec);
+        const result = await executeStep(pipeline, spec, heldLease);
+        if (!(await heldLease.isHeld()))
+            return;
+        // Heartbeat pulses persist their own optimistic version while the model runs.
+        // Re-read after stopping the pulse and rebase only onto the same live step;
+        // never carry a step result across an abort or another runner's advance.
+        const afterStep = await storage.getPipeline(pipeline.id, pipeline.user_id);
+        if (!afterStep || afterStep.status !== 'RUNNING') {
+            debugLog(`[DarkFactory] Step result discarded for ${pipeline.id}: pipeline is no longer RUNNING.`);
+            return;
+        }
+        if (afterStep.current_step !== pipeline.current_step ||
+            afterStep.iteration !== pipeline.iteration ||
+            (afterStep.eval_revisions ?? 0) !== (pipeline.eval_revisions ?? 0)) {
+            debugLog(`[DarkFactory] Step result discarded for ${pipeline.id}: pipeline advanced concurrently.`);
+            return;
+        }
+        pipeline.updated_at = afterStep.updated_at;
+        pipeline.last_heartbeat = afterStep.last_heartbeat;
         // v7.3.1: Scope violation in EXECUTE step → immediate pipeline termination
         if ('scopeViolation' in result && result.scopeViolation) {
             debugLog(`[DarkFactory] Pipeline ${pipeline.id} terminated: scope violation in EXECUTE step.`);
@@ -594,6 +715,27 @@ async function runnerTick() {
             return;
         }
         const currentStep = pipeline.current_step;
+        if (currentStep === 'VERIFY') {
+            if (!spec.testCommand) {
+                result.success = false;
+                result.notes = 'Deterministic verification requires spec.testCommand.';
+            }
+            else
+                try {
+                    const verificationNotes = await executeActions([{ type: 'RUN_TEST', targetPath: '.', command: spec.testCommand }], spec, async () => {
+                        if (!runnerInterval || !(await heldLease.isHeld()))
+                            return false;
+                        const live = await (await getStorage()).getPipeline(pipeline.id, pipeline.user_id);
+                        return !!runnerInterval && await heldLease.isHeld() && live?.status === 'RUNNING' && live.current_step === pipeline.current_step;
+                    }, async () => !!runnerInterval && await heldLease.isHeld());
+                    result.notes = `${result.notes || ''}\n${verificationNotes.join('\n')}`;
+                    result.success = true;
+                }
+                catch (error) {
+                    result.success = false;
+                    result.notes = `Deterministic verification failed: ${error instanceof Error ? error.message : String(error)}`;
+                }
+        }
         // ── Phase 4: Verification Pipeline Orchestrator ──
         if (currentStep === 'VERIFY' && spec.workingDirectory) {
             const harnessPath = path.join(path.resolve(spec.workingDirectory), 'verification_harness.json');
@@ -602,13 +744,15 @@ async function runnerTick() {
                     const rawHarness = fs.readFileSync(harnessPath, 'utf8');
                     const harnessData = JSON.parse(rawHarness);
                     // GAP-5 fix: Persist the harness so CLI drift detection works for DarkFactory runs
-                    const rubricHash = computeRubricHash(harnessData.tests);
+                    const minPassRate = harnessData.min_pass_rate ?? 1;
+                    const rubricHash = computeRubricHash(harnessData.tests, minPassRate);
                     const harness = {
                         ...harnessData,
                         project: pipeline.project,
                         conversation_id: `dark-factory-${pipeline.id}`,
-                        created_at: new Date().toISOString(),
+                        created_at: pipeline.started_at,
                         rubric_hash: rubricHash,
+                        min_pass_rate: minPassRate,
                     };
                     await storage.saveVerificationHarness(harness, pipeline.user_id);
                     // GAP-2 fix: Build VerificationConfig from env vars so PRISM_VERIFICATION_LAYERS
@@ -633,7 +777,7 @@ async function runnerTick() {
                         project: pipeline.project,
                         conversation_id: `dark-factory-${pipeline.id}`,
                         run_at: new Date().toISOString(),
-                        passed: passRate >= harnessData.min_pass_rate && verificationResult.severity_gate.action !== "abort",
+                        passed: passRate >= minPassRate && verificationResult.severity_gate.action !== "abort",
                         pass_rate: passRate,
                         critical_failures: verificationResult.severity_gate.failed_assertions.length,
                         coverage_score: coverageScore,
@@ -641,8 +785,8 @@ async function runnerTick() {
                         gate_action: verificationResult.severity_gate.action,
                         gate_override: false,
                     };
+                    await storage.saveVerificationRun(valResult, pipeline.user_id);
                     const { canContinue, validatedResult } = Gatekeeper.executeGate(valResult);
-                    await storage.saveVerificationRun(validatedResult, pipeline.user_id);
                     // GAP-3 fix: Emit verification experience event for ML routing feedback
                     try {
                         const confidenceScore = Math.round(passRate * 100);
@@ -774,9 +918,7 @@ async function runnerTick() {
                 // EXECUTE notes = what the generator did
                 // EVALUATE notes = what the evaluator found
                 // Other steps: preserve existing notes
-                const updatedNotes = (currentStep === 'EXECUTE' || currentStep === 'EVALUATE') && result.notes
-                    ? result.notes
-                    : pipeline.notes;
+                const updatedNotes = result.notes || pipeline.notes;
                 await storage.savePipeline({
                     ...pipeline,
                     current_step: nextStepInfo.step,
@@ -803,6 +945,12 @@ async function runnerTick() {
         console.error(`[DarkFactory] Runner tick error (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
     }
     finally {
+        if (renewalInterval)
+            clearInterval(renewalInterval);
+        if (lease)
+            await lease.release().catch(error => {
+                console.error(`[DarkFactory] Execution lease release failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
         tickInProgress = false;
     }
 }

package/dist/darkfactory/safetyController.js

@@ -25,7 +25,8 @@ export class SafetyController {
      */
     static LEGAL_TRANSITIONS = {
         'PENDING': ['RUNNING', 'ABORTED'], // Queued → Runner promotes or user aborts
-        'RUNNING': ['PAUSED', 'ABORTED', 'COMPLETED', 'FAILED'],
+        // Step progress and heartbeats retain RUNNING throughout the pipeline.
+        'RUNNING': ['RUNNING', 'PAUSED', 'ABORTED', 'COMPLETED', 'FAILED'],
         'PAUSED': ['RUNNING', 'ABORTED'],
         'ABORTED': [], // Terminal — no exits
         'COMPLETED': [], // Terminal — no exits
@@ -168,6 +169,14 @@ export class SafetyController {
         if (spec.contextFiles && spec.contextFiles.length > 0) {
             lines.push(`Context Files: ${spec.contextFiles.join(', ')}`);
         }
+        if (spec.allowedWritePaths) {
+            lines.push(`Allowed WRITE_FILE/PATCH_FILE targetPath values (relative, exactly as listed): ${JSON.stringify(spec.allowedWritePaths)}`);
+        }
+        if (spec.testCommand) {
+            lines.push(`Caller-authorized test command (exact string): ${spec.testCommand}`);
+            lines.push(`The VERIFY phase runs this command independently. In EXECUTE, return file changes only; do not add a RUN_TEST action.`);
+        }
+        lines.push(`All targetPath values must be relative. The executor supplies the working directory; never prefix targetPath with the working directory.`);
         lines.push(``, `── Objective ──`, spec.objective, ``, `── Safety Rules ──`, `1. Do NOT modify files outside the Restricted Workspace.`, `2. Do NOT make network requests unless the objective explicitly requires it.`, `3. Do NOT execute destructive operations (rm -rf, DROP TABLE, etc.).`, `4. Respond ONLY with actions relevant to the current step.`, `5. If you cannot complete the step, explain why and stop.`);
         return lines.join('\n');
     }

package/dist/dashboard/server.js

@@ -40,6 +40,7 @@ import { createDashboardStorageAccessor } from "./storageAccessor.js";
 import { DASHBOARD_READ_MESSAGES } from "./readMessages.js";
 import { isDashboardSettingKeyAllowed, isDashboardSettingValueAllowed } from "./settingsPolicy.js";
 import { isTrustedRequest, isRebindGuardedPath } from "./hostGuard.js";
+import { darkFactoryEnablementState, DARK_FACTORY_SETTINGS_UNAVAILABLE } from "../darkfactory/enablement.js";
 import { resolveDashboardToken, requestHasToken, buildTokenCookie, dashboardTokenCookieName, isDashboardTokenProtectedPath, } from "./dashboardToken.js";
 import { safeCompare, generateToken, isAuthenticated, createRateLimiter, initJWKS, } from "./authUtils.js";
 const PORT = parseInt(process.env.PRISM_DASHBOARD_PORT || "3000", 10);
@@ -392,7 +393,7 @@ return false;}
                                 type: "boolean",
                                 title: "Enable Dark Factory",
                                 description: "Set to true to enable autonomous evaluation pipelines.",
-                                default: false
+                                default: true
                             },
                             prismTaskRouterEnabled: {
                                 type: "boolean",
@@ -732,11 +733,11 @@ return false;}
                     const { getAllSettings } = await import("../storage/configStorage.js");
                     const settings = await getAllSettings();
                     res.writeHead(200, { "Content-Type": "application/json" });
-                    return res.end(JSON.stringify({ settings }));
+                    return res.end(JSON.stringify({ settings, darkFactory: darkFactoryEnablementState() }));
                 }
                 catch {
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    return res.end(JSON.stringify({ settings: {} }));
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    return res.end(JSON.stringify({ error: DARK_FACTORY_SETTINGS_UNAVAILABLE }));
                 }
             }
             // ─── API: Settings — POST (v3.0 Dashboard Settings) ───

package/dist/dashboard/settingsPolicy.js

@@ -29,6 +29,8 @@ export function isDashboardSettingValueAllowed(key, value) {
     if (["auto_capture", "hivemind_enabled", "task_router_enabled"].includes(key)) {
         return value === "true" || value === "false";
     }
+    if (key === "PRISM_DARK_FACTORY_ENABLED")
+        return value === "true" || value === "false";
     if (key === "agent_name")
         return value.length <= 80 && !/[<>]/.test(value);
     if (key === "default_role")

package/dist/dashboard/ui.js

@@ -14,6 +14,7 @@
  * ═══════════════════════════════════════════════════════════════════
  */
 import { ANALYTICS_DATE_PATTERN, ANALYTICS_METRIC_IDS, DASHBOARD_READ_MESSAGES } from './readMessages.js';
+import { DARK_FACTORY_SETTINGS_UNAVAILABLE } from '../darkfactory/enablement.js';
 export function renderDashboardLocalOpenHTML() {
     return `<!DOCTYPE html>
 <html lang="en">
@@ -505,8 +506,10 @@ export function renderDashboardHTML(version) {
     .modal-close:hover { color: var(--text-primary); }
     .setting-row {
       display: flex; justify-content: space-between; align-items: center;
+      gap: 1rem;
       padding: 0.75rem 0; border-bottom: 1px solid rgba(255,255,255,0.05);
     }
+    .setting-row > div { min-width: 0; }
     .setting-row:last-child { border-bottom: none; }
     .setting-label { font-size: 0.85rem; color: var(--text-secondary); }
     .setting-desc { font-size: 0.7rem; color: var(--text-muted); margin-top: 0.2rem; }
@@ -1313,6 +1316,14 @@ export function renderDashboardHTML(version) {
           </div>
           <div class="toggle" id="toggle-task-router" onclick="toggleBootSetting('task_router_enabled', this)"></div>
         </div>
+        <div class="setting-row">
+          <div>
+            <div class="setting-label">Dark Factory</div>
+            <div class="setting-desc">Enable pipeline execution tools and the background runner. Restart required; an environment override wins.</div>
+            <div id="dark-factory-state" style="color:var(--text-muted);font-size:0.78rem;margin-top:0.25rem">Loading startup state…</div>
+          </div>
+          <button class="toggle" id="toggle-dark-factory" type="button" role="switch" aria-label="Dark Factory enablement" aria-checked="false" disabled onclick="toggleBootSetting('PRISM_DARK_FACTORY_ENABLED', this)"></button>
+        </div>
         <div class="setting-row">
           <div>
             <div class="setting-label">Storage Backend</div>
@@ -3993,9 +4004,11 @@ function loadSettings() {
                     return [4 /*yield*/, fetch('/api/settings?t=' + Date.now())];
                 case 1:
                     res = _a.sent();
+                    if (!res.ok) throw new Error(DARK_FACTORY_SETTINGS_UNAVAILABLE_MESSAGE);
                     return [4 /*yield*/, res.json()];
                 case 2:
                     data = _a.sent();
+                    if (!data.darkFactory) throw new Error(DARK_FACTORY_SETTINGS_UNAVAILABLE_MESSAGE);
                     s = data.settings || {};
                     // Runtime toggles
                     if (s.auto_capture === 'true')
@@ -4019,6 +4032,21 @@ function loadSettings() {
                         document.getElementById('toggle-task-router').classList.add('active');
                     else
                         document.getElementById('toggle-task-router').classList.remove('active');
+                    if ((s.PRISM_DARK_FACTORY_ENABLED || (data.darkFactory && data.darkFactory.saved ? 'true' : 'false')) === 'true')
+                        document.getElementById('toggle-dark-factory').classList.add('active');
+                    else
+                        document.getElementById('toggle-dark-factory').classList.remove('active');
+                    document.getElementById('toggle-dark-factory').setAttribute('aria-checked', document.getElementById('toggle-dark-factory').classList.contains('active') ? 'true' : 'false');
+                    if (data.darkFactory) {
+                        var df = data.darkFactory;
+                        var effective = df.envOverride === null ? df.saved : df.envOverride;
+                        var state = df.envOverride === null ? 'Saved: ' + (df.saved ? 'on' : 'off') + ' · Active: ' + (df.active ? 'on' : 'off') + (df.pendingRestart ? ' · restart required' : '') : 'Saved: ' + (df.saved ? 'on' : 'off') + ' · Active override: ' + (df.envOverride ? 'on' : 'off');
+                        document.getElementById('dark-factory-state').textContent = state;
+                        document.getElementById('toggle-dark-factory').disabled = df.envOverride !== null;
+                        document.getElementById('toggle-dark-factory').setAttribute('aria-disabled', df.envOverride !== null ? 'true' : 'false');
+                        document.getElementById('toggle-dark-factory').classList.toggle('active', effective);
+                        document.getElementById('toggle-dark-factory').setAttribute('aria-checked', effective ? 'true' : 'false');
+                    }
                     // Storage Backend
                     if (s.PRISM_STORAGE) {
                         document.getElementById('storageBackendSelect').value = s.PRISM_STORAGE;
@@ -4041,6 +4069,9 @@ function loadSettings() {
                 case 3:
                     e_19 = _a.sent();
                     console.warn('Settings load failed:', e_19);
+                    document.getElementById('dark-factory-state').textContent = DARK_FACTORY_SETTINGS_UNAVAILABLE_MESSAGE;
+                    document.getElementById('toggle-dark-factory').disabled = true;
+                    document.getElementById('toggle-dark-factory').setAttribute('aria-disabled', 'true');
                     return [3 /*break*/, 4];
                 case 4: return [2 /*return*/];
             }
@@ -4093,15 +4124,20 @@ function toggleSetting(key, el) {
 }
 function toggleBootSetting(key, el) {
     var isActive = el.classList.toggle('active');
+    el.setAttribute('aria-checked', isActive ? 'true' : 'false');
     saveSetting(key, isActive ? 'true' : 'false').then(function (ok) {
         if (!ok) {
             el.classList.toggle('active'); // rollback on failure
+            el.setAttribute('aria-checked', isActive ? 'false' : 'true');
         }
         else {
-            showToast('Saved. Restart your AI client for this to take effect.');
+            showToast(DARK_FACTORY_RESTART_MESSAGE);
+            loadSettings();
         }
     });
 }
+var DARK_FACTORY_SETTINGS_UNAVAILABLE_MESSAGE = ${JSON.stringify(DARK_FACTORY_SETTINGS_UNAVAILABLE)};
+var DARK_FACTORY_RESTART_MESSAGE = 'Saved. Restart your AI client for this to take effect.';
 function saveBootSetting(key, value) {
     saveSetting(key, value).then(function (ok) {
         if (ok)

package/dist/onboarding/wizard.js

@@ -158,7 +158,7 @@ function getAdvancedTourContent() {
         title: "🚀 Advanced Features",
         description: "Prism has much more to offer. Here's a quick tour of advanced capabilities:",
         instructions: [
-            "**Dark Factory** — Autonomous AI pipelines that run in the background (set PRISM_DARK_FACTORY_ENABLED=true)",
+            "**Dark Factory** — Autonomous AI pipelines that run in the background (enabled by default; use the dashboard or PRISM_DARK_FACTORY_ENABLED=false to disable)",
             "**Hivemind** — Multi-agent coordination with role-based access (set PRISM_ENABLE_HIVEMIND=true)",
             "**Auto-Scholar** — Autonomous research agent that discovers and synthesizes papers",
             "**Mind Palace Dashboard** — Web UI at localhost:3080 for managing projects, viewing analytics, and configuring settings",

package/dist/server.js

@@ -60,7 +60,8 @@ 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_HDC_ENABLED, PRISM_TASK_ROUTER_ENABLED_ENV, PRISM_DARK_FACTORY_ENABLED, YDC_API_KEY, } 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_HDC_ENABLED, PRISM_TASK_ROUTER_ENABLED_ENV, YDC_API_KEY, } from "./config.js";
+import { initializeDarkFactoryEnabled, isDarkFactoryEnabled } from "./darkfactory/enablement.js";
 import { startWatchdog, drainAlerts } from "./hivemindWatchdog.js";
 import { startScheduler } from "./backgroundScheduler.js";
 import { startDarkFactoryRunner } from "./darkfactory/runner.js";
@@ -345,7 +346,7 @@ export function getAvailableTools() {
         ...SESSION_MEMORY_TOOLS,
         ...(PRISM_ENABLE_HIVEMIND ? AGENT_REGISTRY_TOOLS : []),
         ...(getSettingSync("task_router_enabled", String(PRISM_TASK_ROUTER_ENABLED_ENV)) === "true" ? [SESSION_TASK_ROUTE_TOOL] : []),
-        ...(PRISM_DARK_FACTORY_ENABLED ? [SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL] : []),
+        ...(isDarkFactoryEnabled() ? [SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_TOOL] : []),
     ];
 }
 export const PRISM_SERVER_INSTRUCTIONS = `Prism MCP — The Mind Palace for AI Agents. On the first user turn of every conversation, ` +
@@ -357,7 +358,7 @@ export const PRISM_SERVER_INSTRUCTIONS = `Prism MCP — The Mind Palace for AI A
     `trigger rules — read each before proposing any change. Surfacing a name is not loading it: hosts that ` +
     `do not auto-load skill files must fetch each body with knowledge_search, passing the skill name ` +
     `exactly as listed. ` +
-    `AFTER that first turn, routing does not stop: call session_route_prompt at the start of any turn where the user states a new task, changes the kind of work, or reports a defect, passing their verbatim message as {prompt} and the skills you already hold as {loaded}. session_bootstrap routes only turn one, so without this a long session keeps working with whatever it happened to load hours earlier. The call is cheap — a single line when nothing new matches, and never the same skill twice. When it returns skills, read and follow them before doing the work. ` +
+    `AFTER turn one, call session_route_prompt at the start of any turn with a new task, changed work, or reported defect. Pass the verbatim message as {prompt} and held skills as {loaded}; supply current project, working_directory, files_involved and test_command when known. Read and follow returned skills. When prism_factory_route has target factory, automatically call recommended_tool with recommended_args, then monitor status. Routing itself never executes code. ` +
     `Emit no preamble. Print the complete tool result verbatim as the entire first-turn startup display, before any optional ` +
     `answer. Do not summarize, paraphrase, rename headings, reformat, or omit any returned section. Preserve its order and ` +
     `line content. For a greeting-only prompt, stop after the verbatim startup display. ` +
@@ -981,22 +982,22 @@ export function createServer() {
                     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.");
+                        if (!isDarkFactoryEnabled())
+                            throw new Error("Dark Factory not enabled. Enable it in the dashboard or 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.");
+                        if (!isDarkFactoryEnabled())
+                            throw new Error("Dark Factory not enabled. Enable it in the dashboard or 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.");
+                        if (!isDarkFactoryEnabled())
+                            throw new Error("Dark Factory not enabled. Enable it in the dashboard or set PRISM_DARK_FACTORY_ENABLED=true.");
                         result = await sessionAbortPipelineHandler(args);
                         break;
                     // ─── v12.1: Developer Onboarding & Framework Bridge ───
@@ -1288,6 +1289,7 @@ export async function startServer() {
     // during the Initialize handshake — zero extra latency for resource reads.
     // initConfigStorage() is local SQLite only (~5ms), safe to await.
     await initConfigStorage();
+    initializeDarkFactoryEnabled();
     // v4.6.0: Initialize OTel AFTER the settings cache is warm so that
     // initTelemetry() can read otel_enabled/otel_endpoint from getSettingSync()
     // synchronously. This is a synchronous call — no await needed.
@@ -1597,7 +1599,7 @@ async function resumeServerStartup(server) {
     // 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) {
+    if (isDarkFactoryEnabled() && SESSION_MEMORY_ENABLED) {
         storageReady?.then(() => {
             startDarkFactoryRunner();
         }).catch(err => {