prism-mcp-server 20.2.8 → 20.2.9

package/README.md

@@ -148,13 +148,16 @@ that would require a host lifecycle hook, launcher, extension, or Prism-owned
 panel. Context loading itself remains complete even when a host shortens the
 visible reply.
 
-Free accounts receive the protected 13-skill foundation. It includes
-`current-staging-acceptance`, the strict completion extension of
-`evidence-first-protocol`: agents must use the exact current staging artifact
-and inspect every case and screenshot before reporting acceptance. Paid
-accounts receive the current subscribed routing set. Upgrades install newly
-entitled packages; downgrades remove only Prism-owned packages while preserving
-local skills and locally modified conflicts.
+Free accounts receive only the public hook-free `prism-startup` package; the MCP
+server still supplies a compact, non-proprietary safety and evidence contract.
+Authenticated paid accounts receive the protected behavioral and engineering
+packages plus the current subscribed routing set. The paid
+`evidence-first-protocol` keeps ordinary coding lightweight: one correlated
+reproduction is enough to begin an edit, while strict acceptance starts only
+before a completion claim, push, or release and inspects only the exact artifacts
+used as proof. Upgrades install newly entitled packages; verified downgrades
+remove only Prism-owned packages while preserving local skills and locally
+modified conflicts.
 
 When upgrading an older Claude Code installation, `prism connect` removes only
 the exact Prism-owned startup, skill-sync, handoff, and drift hook actions from

package/dist/cli.js

@@ -12,6 +12,7 @@ import { configureClaudeAgentPolicy, configureClaudeNativeStartup, configureCode
 import { runBrowserCli } from './browserCli.js';
 import { filterPrismMemoryContext } from './utils/memoryQuality.js';
 import { isRecoverableStartupStorageError } from './utils/startupRecovery.js';
+import { verifyBehaviorHandler } from './tools/behavioralVerifierHandler.js';
 const program = new Command();
 /** Build the stable `prism load --json` envelope from depth-specific context. */
 export function buildLoadJsonOutput(project, data, level, metadata) {
@@ -111,6 +112,50 @@ program
     .command('bootstrap')
     .description('Print the canonical dashboard-configured first-turn Prism greeting')
     .action(runBootstrapCommand);
+/**
+ * One-shot fallback for hosts whose long-lived MCP transport has closed.
+ * This calls the canonical handler, including its authenticated portal path
+ * and fail-closed offline scenario; it never asks the host to invent one.
+ */
+export async function runVerifyBehaviorCommand(options) {
+    try {
+        const baseUrl = process.env.PRISM_SYNALUX_BASE_URL?.trim() ||
+            process.env.SYNALUX_BASE_URL?.trim() ||
+            (await getSetting('PRISM_SYNALUX_BASE_URL', '')).trim() ||
+            (await getSetting('SYNALUX_BASE_URL', '')).trim() ||
+            'https://synalux.ai';
+        const apiKey = process.env.PRISM_SYNALUX_API_KEY?.trim() ||
+            (await getSetting('PRISM_SYNALUX_API_KEY', '')).trim();
+        process.env.PRISM_SYNALUX_BASE_URL = baseUrl.replace(/\/+$/, '');
+        if (apiKey)
+            process.env.PRISM_SYNALUX_API_KEY = apiKey;
+        const result = await verifyBehaviorHandler({
+            file_path: options.file,
+            change_summary: options.summary,
+            ...(options.project ? { project: options.project } : {}),
+            ...(options.workspaceId ? { workspace_id: options.workspaceId } : {}),
+        });
+        const output = result.content
+            ?.map((part) => part?.text)
+            .filter(Boolean)
+            .join('\n') || '';
+        if (!output)
+            throw new Error('verify_behavior returned no scenario');
+        console.log(output);
+    }
+    catch (err) {
+        console.error(`Behavioral verification failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+}
+program
+    .command('verify-behavior')
+    .description('Get the behavioral edit scenario when an MCP transport is unavailable')
+    .requiredOption('--file <path>', 'Path of the file about to be edited')
+    .requiredOption('--summary <text>', 'Brief description of the intended change')
+    .option('--project <project>', 'Project identifier for workspace-scoped scenarios')
+    .option('--workspace-id <id>', 'Workspace ID for custom scenarios')
+    .action(runVerifyBehaviorCommand);
 // Parsed by the direct dispatch at the bottom so all Python CLI flags pass
 // through unchanged. Registering it here keeps the command visible in help.
 program

package/dist/connect.js

@@ -4,6 +4,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 as w
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { EVIDENCE_WORKFLOW_POLICY_LINES } from "./evidenceWorkflowPolicy.js";
 import { LOCAL_FIRST_POLICY_ID, LOCAL_FIRST_POLICY_LINES } from "./localFirstPolicy.js";
 export const CONNECT_HOSTS = [
     "claude-code",
@@ -46,6 +47,8 @@ const CODEX_STARTUP_BODY = [
     "block is managed by `prism connect`; do not edit it manually.",
     "",
     ...LOCAL_FIRST_POLICY_LINES,
+    "",
+    ...EVIDENCE_WORKFLOW_POLICY_LINES,
 ];
 const CONNECT_STORAGE_BACKENDS = ["auto", "local", "synalux", "supabase"];
 const LEGACY_CLAUDE_PROJECT_PRISM_ENTRY = {
@@ -542,6 +545,8 @@ function serializeClaudeStartupBlock(newline) {
         "managed by `prism connect`; do not edit it manually.",
         "",
         ...LOCAL_FIRST_POLICY_LINES,
+        "",
+        ...EVIDENCE_WORKFLOW_POLICY_LINES,
         CLAUDE_STARTUP_MANAGED_END,
         "",
     ].join(newline);
@@ -617,6 +622,8 @@ function serializeGeminiStartupBlock(newline) {
         "session_detect_drift calls. This block is managed by `prism connect`; do not edit it manually.",
         "",
         ...LOCAL_FIRST_POLICY_LINES,
+        "",
+        ...EVIDENCE_WORKFLOW_POLICY_LINES,
         GEMINI_STARTUP_MANAGED_END,
         "",
     ].join(newline);

package/dist/evidenceWorkflowPolicy.js

@@ -0,0 +1,19 @@
+/**
+ * Minimum evidence contract shared by every MCP host.
+ *
+ * Native-skill hosts also receive the full evidence-first protocol. Keep this
+ * compact copy in MCP initialize instructions so hosts without a filesystem
+ * skill surface, including Claude Desktop, still follow the same workflow.
+ */
+export const EVIDENCE_WORKFLOW_POLICY_LINES = [
+    "## Prism evidence workflow",
+    "During diagnosis and editing, one trustworthy correlated reproduction is enough; do not block coding on",
+    "inspecting unrelated diagnostic screenshots, trace frames, or abandoned attempts.",
+    "Before a completion claim, push, or release, exercise the corrected path with fresh evidence from the current",
+    "build and bind stateful proof to the exact run and entity. Inspect every artifact used to support the claim.",
+    "When a screenshot is requested or used as proof, the active agent must open it and compare its visible state",
+    "with the issue's expected and forbidden states. Complete that review yourself; do not ask the user to verify it.",
+    "A screenshot is an observation, not absolute truth. Reject stale, wrong-run, wrong-entity, or visibly failing",
+    "evidence even when its metadata says passed.",
+];
+export const EVIDENCE_WORKFLOW_POLICY_TEXT = EVIDENCE_WORKFLOW_POLICY_LINES.join(" ");

package/dist/mcpTransportHealth.js

@@ -28,8 +28,16 @@ export function monitorMcpTransport(server, options) {
         options.onFailure(reason, error);
     };
     const handleClose = () => {
-        previousOnClose?.();
-        fail("MCP_TRANSPORT_CLOSED");
+        let closeError;
+        try {
+            previousOnClose?.();
+        }
+        catch (error) {
+            closeError = error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            fail("MCP_TRANSPORT_CLOSED", closeError);
+        }
     };
     server.onclose = handleClose;
     const check = async () => {

package/dist/server.js

@@ -85,6 +85,7 @@ import { inferenceMetricsHandler } from "./utils/inferenceMetrics.js";
 import { recordInvocation } from "./utils/analytics.js";
 import { BOUNDARIES_TEXT } from "./boundaries/boundaries.js";
 import { triggerSkillManifestSync } from "./skillManifestSync.js";
+import { EVIDENCE_WORKFLOW_POLICY_TEXT } from "./evidenceWorkflowPolicy.js";
 import { LOCAL_FIRST_POLICY_TEXT } from "./localFirstPolicy.js";
 // ─── Import Tool Definitions (schemas) and Handlers (implementations) ─────
 import { WEB_SEARCH_TOOL, BRAVE_WEB_SEARCH_CODE_MODE_TOOL, LOCAL_SEARCH_TOOL, BRAVE_LOCAL_SEARCH_CODE_MODE_TOOL, CODE_MODE_TRANSFORM_TOOL, BRAVE_ANSWERS_TOOL, RESEARCH_PAPER_ANALYSIS_TOOL, webSearchHandler, braveWebSearchCodeModeHandler, localSearchHandler, braveLocalSearchCodeModeHandler, codeModeTransformHandler, braveAnswersHandler, researchPaperAnalysisHandler, } from "./tools/index.js";
@@ -328,6 +329,7 @@ export const PRISM_SERVER_INSTRUCTIONS = `Prism MCP — The Mind Palace for AI A
     `Reuse the conversation_id returned by session_bootstrap in structuredContent for those saves and for ` +
     `session_detect_drift, the 60-minute goal-alignment drift check. Do not add the id to the visible greeting.\n\n` +
     `${LOCAL_FIRST_POLICY_TEXT}\n\n` +
+    `${EVIDENCE_WORKFLOW_POLICY_TEXT}\n\n` +
     `Architecture: session_save_ledger and session_save_handoff require context loaded by session_bootstrap ` +
     `or session_load_context when a conversation_id is supplied. ${BOUNDARIES_TEXT} ` +
     `All cloud inference routes through the Synalux portal for billing, tier-gating, and audit.`;

package/dist/skillManifestSync.js

@@ -4,7 +4,7 @@ import { access, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realp
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { applyManagedSkillManifest, getSetting, refreshConfigStorageCache, } from "./storage/configStorage.js";
-import { REQUIRED_NATIVE_SKILL_NAMES } from "./tools/skillRouting.js";
+import { FREE_NATIVE_SKILL_NAMES, REQUIRED_NATIVE_SKILL_NAMES } from "./tools/skillRouting.js";
 import { getSynaluxJwt, invalidateSynaluxJwt } from "./utils/synaluxJwt.js";
 const OWNER = "prism-skill-sync-v1";
 const MARKER = ".prism-managed.json";
@@ -181,17 +181,20 @@ export function validateSkillManifest(payload) {
             }
         }
     }
-    const requiredNames = new Set(REQUIRED_NATIVE_SKILL_NAMES);
-    for (const required of REQUIRED_NATIVE_SKILL_NAMES) {
+    const requiredForTier = value.tier === "free"
+        ? FREE_NATIVE_SKILL_NAMES
+        : REQUIRED_NATIVE_SKILL_NAMES;
+    const requiredNames = new Set(requiredForTier);
+    for (const required of requiredForTier) {
         const requiredSkill = skills.find((skill) => skill.name === required);
         if (!requiredSkill)
-            throw new Error(`manifest is missing required protected skill: ${required}`);
+            throw new Error(`manifest is missing required native skill: ${required}`);
         if (!requiredSkill.metadata.protected || !requiredSkill.metadata.categories.includes("universal")) {
-            throw new Error(`required skill is not protected universal: ${required}`);
+            throw new Error(`required native skill is not protected universal: ${required}`);
         }
     }
     if (value.tier === "free" && (skills.length !== requiredNames.size || skills.some((skill) => !requiredNames.has(skill.name)))) {
-        throw new Error("free manifest must contain exactly the protected skill floor");
+        throw new Error("free manifest must contain exactly the public startup package");
     }
     const normalized = {
         schema_version: 1,

package/dist/storage/synalux.js

@@ -20,6 +20,7 @@
  *   Methods migrated to portal:
  *     - saveLedger        → POST /api/v1/prism/memory  action=save_ledger
  *     - saveHandoff       → POST /api/v1/prism/memory  action=save_handoff
+ *     - saveHistorySnapshot → POST /api/v1/prism/memory  action=save_history_snapshot
  *     - loadContext       → POST /api/v1/prism/memory  action=load_context
  *     - searchKnowledge   → POST /api/v1/prism/memory  action=search
  *     - softDeleteLedger  → POST /api/v1/prism/memory  action=forget_memory (Phase 3 Tier A)
@@ -203,7 +204,46 @@ export class SynaluxStorage extends SupabaseStorage {
             role: handoff.role,
             expected_version: expectedVersion ?? undefined,
         });
-        return (result.handoff ?? result);
+        const candidate = Object.prototype.hasOwnProperty.call(result, "result")
+            ? result.result
+            : Object.prototype.hasOwnProperty.call(result, "handoff")
+                ? result.handoff
+                : result;
+        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+            throw new Error("[SynaluxStorage] Invalid save_handoff response: missing result");
+        }
+        const value = candidate;
+        if (value.status === "conflict" && Number.isSafeInteger(value.current_version)) {
+            return {
+                status: "conflict",
+                current_version: value.current_version,
+            };
+        }
+        if ((value.status === "created" || value.status === "updated")
+            && Number.isSafeInteger(value.version)) {
+            return {
+                status: value.status,
+                version: value.version,
+            };
+        }
+        // Older portal RPC wrappers returned only the new version. Preserve that
+        // rolling-upgrade contract without accepting an unversioned success.
+        if (value.status === undefined && Number.isSafeInteger(value.version)) {
+            return {
+                status: "updated",
+                version: value.version,
+            };
+        }
+        throw new Error("[SynaluxStorage] Invalid save_handoff response: malformed OCC result");
+    }
+    async saveHistorySnapshot(handoff, branch = "main") {
+        await this.portalPost("/api/v1/prism/memory", {
+            action: "save_history_snapshot",
+            project: handoff.project,
+            version: handoff.version,
+            snapshot: handoff,
+            branch,
+        });
     }
     // ─── Context ─────────────────────────────────────────────────
     async loadContext(project, level, userId, role) {

package/dist/tools/behavioralVerifierHandler.js

@@ -8,7 +8,7 @@
  * FAIL-CLOSED: if the portal is unreachable, returns a generic
  * verification challenge rather than skipping verification.
  */
-import { PRISM_SYNALUX_BASE_URL, SYNALUX_CONFIGURED } from "../config.js";
+import { PRISM_SYNALUX_BASE_URL } from "../config.js";
 import { getSynaluxJwt } from "../utils/synaluxJwt.js";
 const FALLBACK_SCENARIO = [
     "⚠️ BEHAVIORAL VERIFICATION (OFFLINE MODE)",
@@ -33,7 +33,13 @@ export async function verifyBehaviorHandler(args) {
     return { content: [{ type: "text", text: await buildScenarioText(args) }] };
 }
 async function buildScenarioText(args) {
-    if (!SYNALUX_CONFIGURED || !PRISM_SYNALUX_BASE_URL) {
+    const baseUrl = process.env.PRISM_SYNALUX_BASE_URL?.trim() ||
+        process.env.SYNALUX_BASE_URL?.trim() ||
+        PRISM_SYNALUX_BASE_URL;
+    // OAuth/JWT-backed installs intentionally do not copy a long-lived API key
+    // into host configuration. A valid portal URL is enough to attempt the
+    // short-lived JWT flow; getSynaluxJwt() remains the fail-closed auth gate.
+    if (!baseUrl) {
         return FALLBACK_SCENARIO;
     }
     const jwt = await getSynaluxJwt();
@@ -42,7 +48,7 @@ async function buildScenarioText(args) {
         return FALLBACK_SCENARIO;
     }
     try {
-        const url = `${PRISM_SYNALUX_BASE_URL}/api/v1/prism/verify-behavior`;
+        const url = `${baseUrl.replace(/\/+$/, "")}/api/v1/prism/verify-behavior`;
         const res = await fetch(url, {
             method: "POST",
             headers: {
@@ -60,7 +66,11 @@ async function buildScenarioText(args) {
             console.error(`[verify-behavior] ⚠️ portal returned ${res.status} — fail-closed. URL: ${url}`);
             return FALLBACK_SCENARIO;
         }
-        const data = (await res.json());
+        const data = await res.json();
+        if (!isVerifyBehaviorResult(data)) {
+            console.error("[verify-behavior] ⚠️ portal returned a malformed response — fail-closed");
+            return FALLBACK_SCENARIO;
+        }
         return formatResult(data);
     }
     catch (err) {
@@ -68,6 +78,12 @@ async function buildScenarioText(args) {
         return FALLBACK_SCENARIO;
     }
 }
+function isVerifyBehaviorResult(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        typeof value.requires_verification === "boolean";
+}
 function formatResult(data) {
     if (!data.requires_verification) {
         return JSON.stringify({ requires_verification: false, reason: data.reason || "non-behavioral file" });

package/dist/tools/ledgerHandlers.js

@@ -142,29 +142,42 @@ function parseNativeSkillNames(value) {
     }
 }
 async function resolveNativeSkillManifestSnapshot(syncResult) {
-    const { REQUIRED_NATIVE_SKILL_NAMES } = await import("./skillRouting.js");
+    const { FREE_NATIVE_SKILL_NAMES, REQUIRED_NATIVE_SKILL_NAMES } = await import("./skillRouting.js");
     const [storedNamesValue, storedTierValue] = await Promise.all([
         getSetting("skill_manifest:names", "[]"),
         getSetting("skill_manifest:tier", ""),
     ]);
-    const partialNames = syncResult.status === "partial" && Array.isArray(syncResult.entitledNames)
-        ? syncResult.entitledNames.filter((name) => typeof name === "string" && NATIVE_SKILL_NAME.test(name))
+    const partialNamesInput = syncResult.status === "partial" && Array.isArray(syncResult.entitledNames)
+        ? syncResult.entitledNames
+        : null;
+    const partialProvided = partialNamesInput !== null;
+    const partialNames = partialNamesInput
+        ? partialNamesInput.filter((name) => typeof name === "string" && NATIVE_SKILL_NAME.test(name))
         : [];
     const storedNames = parseNativeSkillNames(storedNamesValue);
-    const names = partialNames.length > 0
-        ? [...new Set(partialNames)]
-        : storedNames.length > 0
-            ? storedNames
-            : [...REQUIRED_NATIVE_SKILL_NAMES];
-    const source = partialNames.length > 0
-        ? "validated-partial"
-        : storedNames.length > 0
-            ? "committed"
-            : "protected-fallback";
     const candidateTier = syncResult.status === "partial" ? syncResult.tier : storedTierValue || syncResult.tier;
     const tier = typeof candidateTier === "string" && SYNALUX_TIERS.has(candidateTier)
         ? candidateTier
         : "free";
+    const tierFallbackNames = tier === "free"
+        ? FREE_NATIVE_SKILL_NAMES
+        : REQUIRED_NATIVE_SKILL_NAMES;
+    const freeNames = new Set(FREE_NATIVE_SKILL_NAMES);
+    const namesForTier = (names) => tier === "free"
+        ? names.filter((name) => freeNames.has(name))
+        : names;
+    const entitledPartialNames = namesForTier([...new Set(partialNames)]);
+    const entitledStoredNames = namesForTier(storedNames);
+    const names = partialProvided
+        ? entitledPartialNames.length > 0 ? entitledPartialNames : [...tierFallbackNames]
+        : entitledStoredNames.length > 0
+            ? entitledStoredNames
+            : [...tierFallbackNames];
+    const source = partialProvided
+        ? "validated-partial"
+        : entitledStoredNames.length > 0
+            ? "committed"
+            : "tier-fallback";
     return {
         names,
         tier,
@@ -216,10 +229,10 @@ async function buildNativeSystemReadyBlock(snapshot, depth) {
             `> - 🧠 **Context depth:** ${depth}\n` +
             `> - 🔄 **Skill sync:** ${SKILL_SYNC_STATUS_LABELS[snapshot.syncStatus]} · native materialization incomplete${conflictSuffix}`;
     }
-    if (snapshot.source === "protected-fallback") {
+    if (snapshot.source === "tier-fallback") {
         return `> **Prism System Ready**\n>\n` +
             `> - 🪪 **Subscription tier:** ${snapshot.tier}\n` +
-            `> - 🛡️ **Protected fallback names:** ${formatBoundedSkillNames(coreSkills, "fallback")}\n` +
+            `> - 🛡️ **Fallback skill names:** ${formatBoundedSkillNames(snapshot.names, "fallback")}\n` +
             `> - 🧠 **Context depth:** ${depth}\n` +
             `> - 🔄 **Skill sync:** ${SKILL_SYNC_STATUS_LABELS[snapshot.syncStatus]} · no committed manifest${conflictSuffix}`;
     }
@@ -341,38 +354,46 @@ export async function sessionSaveLedgerHandler(args) {
         role: effectiveRole, // v3.0: Hivemind role scoping (dashboard fallback)
     });
     // ─── Fire-and-forget embedding generation ───
+    let embeddingQueued = false;
     if (result) {
         const embeddingText = [summary, ...(decisions || [])].join("\n");
         const savedEntry = Array.isArray(result) ? result[0] : result;
         const entryId = savedEntry?.id;
         if (entryId) {
-            getLLMProvider().generateEmbedding(embeddingText)
-                .then(async (embedding) => {
-                // Build atomic patch — float32 + TurboQuant in ONE DB update
-                const patchData = {
-                    embedding: JSON.stringify(embedding),
-                };
-                // TurboQuant: compress alongside float32 (non-fatal)
-                try {
-                    const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
-                    const compressor = getDefaultCompressor();
-                    const compressed = compressor.compress(embedding);
-                    const buf = serialize(compressed);
-                    patchData.embedding_compressed = buf.toString("base64");
-                    patchData.embedding_format = `turbo${compressor.bits}`;
-                    patchData.embedding_turbo_radius = compressed.radius;
-                    debugLog(`[session_save_ledger] TurboQuant compressed: ${buf.length} bytes (${(3072 / buf.length).toFixed(1)}× ratio)`);
-                }
-                catch (turboErr) {
-                    console.error(`[session_save_ledger] TurboQuant compression failed (non-fatal): ${turboErr.message}`);
-                }
-                // Single atomic DB update for all embedding data
-                await storage.patchLedger(entryId, patchData);
-                debugLog(`[session_save_ledger] Embedding saved for entry ${entryId}`);
-            })
-                .catch((err) => {
-                console.error(`[session_save_ledger] Embedding generation failed (non-fatal): ${err.message}`);
-            });
+            try {
+                const embeddingPromise = getLLMProvider().generateEmbedding(embeddingText);
+                embeddingQueued = true;
+                embeddingPromise
+                    .then(async (embedding) => {
+                    // Build atomic patch — float32 + TurboQuant in ONE DB update
+                    const patchData = {
+                        embedding: JSON.stringify(embedding),
+                    };
+                    // TurboQuant: compress alongside float32 (non-fatal)
+                    try {
+                        const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
+                        const compressor = getDefaultCompressor();
+                        const compressed = compressor.compress(embedding);
+                        const buf = serialize(compressed);
+                        patchData.embedding_compressed = buf.toString("base64");
+                        patchData.embedding_format = `turbo${compressor.bits}`;
+                        patchData.embedding_turbo_radius = compressed.radius;
+                        debugLog(`[session_save_ledger] TurboQuant compressed: ${buf.length} bytes (${(3072 / buf.length).toFixed(1)}× ratio)`);
+                    }
+                    catch (turboErr) {
+                        console.error(`[session_save_ledger] TurboQuant compression failed (non-fatal): ${turboErr.message}`);
+                    }
+                    // Single atomic DB update for all embedding data
+                    await storage.patchLedger(entryId, patchData);
+                    debugLog(`[session_save_ledger] Embedding saved for entry ${entryId}`);
+                })
+                    .catch((err) => {
+                    console.error(`[session_save_ledger] Embedding generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+            catch (err) {
+                console.error(`[session_save_ledger] Embedding provider initialization failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // ─── v6.0 Phase 3: Fire-and-forget auto-linking ────────────
@@ -439,7 +460,9 @@ export async function sessionSaveLedgerHandler(args) {
                     (todos?.length ? `TODOs: ${todos.length} items\n` : "") +
                     (files_changed?.length ? `Files changed: ${files_changed.length}\n` : "") +
                     (decisions?.length ? `Decisions: ${decisions.length}\n` : "") +
-                    `📊 Embedding generation queued for semantic search.` +
+                    (embeddingQueued
+                        ? `📊 Embedding generation queued for semantic search.`
+                        : `📊 Primary history saved; optional semantic indexing was not queued.`) +
                     metricsBlock +
                     resolverNote,
             }],
@@ -599,9 +622,11 @@ export async function sessionSaveHandoffHandler(args, server) {
     }
     // ─── Success: handoff created or updated ───
     const newVersion = data.version;
-    // ─── TIME MACHINE: Auto-snapshot for time travel (fire-and-forget) ───
+    // ─── TIME MACHINE: Auto-snapshot for time travel ───
     // Every successful save creates a snapshot so the user can revert later.
-    // We don't await — this should never block the success response.
+    // Await the attempt so short-lived CLI/MCP transports cannot exit before the
+    // snapshot reaches storage. Failure stays non-fatal because the primary
+    // handoff has already been durably saved.
     if (data.status === "created" || data.status === "updated") {
         const snapshotEntry = {
             project,
@@ -614,9 +639,15 @@ export async function sessionSaveHandoffHandler(args, server) {
             active_branch: active_branch ?? null,
             version: newVersion,
         };
-        storage.saveHistorySnapshot(snapshotEntry).catch(err => console.error(`[session_save_handoff] History snapshot failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`));
+        try {
+            await storage.saveHistorySnapshot(snapshotEntry);
+        }
+        catch (err) {
+            console.error(`[session_save_handoff] History snapshot failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        }
     }
     // ─── Fire-and-forget embedding generation (enables semantic search on handoffs) ───
+    let embeddingQueued = false;
     if (data.status === "created" || data.status === "updated") {
         const embeddingText = [
             last_summary || "",
@@ -624,30 +655,37 @@ export async function sessionSaveHandoffHandler(args, server) {
             ...(open_todos || []),
         ].filter(Boolean).join("\n");
         if (embeddingText.trim()) {
-            getLLMProvider().generateEmbedding(embeddingText)
-                .then(async (embedding) => {
-                const patchData = {
-                    embedding: JSON.stringify(embedding),
-                };
-                try {
-                    const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
-                    const compressor = getDefaultCompressor();
-                    const compressed = compressor.compress(embedding);
-                    const buf = serialize(compressed);
-                    patchData.embedding_compressed = buf.toString("base64");
-                    patchData.embedding_format = `turbo${compressor.bits}`;
-                    patchData.embedding_turbo_radius = compressed.radius;
-                    debugLog(`[session_save_handoff] TurboQuant compressed: ${buf.length} bytes`);
-                }
-                catch (turboErr) {
-                    console.error(`[session_save_handoff] TurboQuant compression failed (non-fatal): ${turboErr.message}`);
-                }
-                await storage.patchHandoff(project, PRISM_USER_ID, patchData);
-                debugLog(`[session_save_handoff] Embedding saved for project "${project}"`);
-            })
-                .catch((err) => {
-                console.error(`[session_save_handoff] Embedding generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
-            });
+            try {
+                const embeddingPromise = getLLMProvider().generateEmbedding(embeddingText);
+                embeddingQueued = true;
+                embeddingPromise
+                    .then(async (embedding) => {
+                    const patchData = {
+                        embedding: JSON.stringify(embedding),
+                    };
+                    try {
+                        const { getDefaultCompressor, serialize } = await import("../utils/turboquant.js");
+                        const compressor = getDefaultCompressor();
+                        const compressed = compressor.compress(embedding);
+                        const buf = serialize(compressed);
+                        patchData.embedding_compressed = buf.toString("base64");
+                        patchData.embedding_format = `turbo${compressor.bits}`;
+                        patchData.embedding_turbo_radius = compressed.radius;
+                        debugLog(`[session_save_handoff] TurboQuant compressed: ${buf.length} bytes`);
+                    }
+                    catch (turboErr) {
+                        console.error(`[session_save_handoff] TurboQuant compression failed (non-fatal): ${turboErr.message}`);
+                    }
+                    await storage.patchHandoff(project, PRISM_USER_ID, patchData);
+                    debugLog(`[session_save_handoff] Embedding saved for project "${project}"`);
+                })
+                    .catch((err) => {
+                    console.error(`[session_save_handoff] Embedding generation failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+            catch (err) {
+                console.error(`[session_save_handoff] Embedding provider initialization failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // ─── Trigger resource subscription notification ───
@@ -776,7 +814,9 @@ export async function sessionSaveHandoffHandler(args, server) {
                 (last_summary ? `Last summary: ${last_summary}\n` : "") +
                 (open_todos?.length ? `Open TODOs: ${open_todos.length} items\n` : "") +
                 (active_branch ? `Active branch: ${active_branch}\n` : "") +
-                `📊 Embedding generation queued for semantic search.\n` +
+                (embeddingQueued
+                    ? `📊 Embedding generation queued for semantic search.\n`
+                    : `📊 Primary history saved; optional semantic indexing was not queued.\n`) +
                 metricsBlock +
                 `\n🔑 Remember: pass expected_version: ${newVersion} on your next save ` +
                 `to maintain concurrency control.`);
@@ -1961,16 +2001,21 @@ export async function sessionSaveExperienceHandler(args) {
         const savedEntry = Array.isArray(result) ? result[0] : result;
         const entryId = savedEntry?.id;
         if (entryId) {
-            getLLMProvider().generateEmbedding(embeddingText)
-                .then(async (embedding) => {
-                await storage.patchLedger(entryId, {
-                    embedding: JSON.stringify(embedding),
+            try {
+                getLLMProvider().generateEmbedding(embeddingText)
+                    .then(async (embedding) => {
+                    await storage.patchLedger(entryId, {
+                        embedding: JSON.stringify(embedding),
+                    });
+                    debugLog(`[session_save_experience] Embedding saved for entry ${entryId}`);
+                })
+                    .catch((err) => {
+                    console.error(`[session_save_experience] Embedding failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
                 });
-                debugLog(`[session_save_experience] Embedding saved for entry ${entryId}`);
-            })
-                .catch((err) => {
-                console.error(`[session_save_experience] Embedding failed (non-fatal): ${err.message}`);
-            });
+            }
+            catch (err) {
+                console.error(`[session_save_experience] Embedding provider initialization failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     return {

package/dist/tools/sessionMemoryDefinitions.js

@@ -1839,7 +1839,8 @@ export const VERIFY_BEHAVIOR_TOOL = {
     description: "Call BEFORE editing behavioral source files (API routes, ordering logic, billing, auth, migrations). " +
         "Returns a domain-specific scenario you must answer to demonstrate understanding of the end-user impact. " +
         "Example: editing a KDS route returns 'A cook has a 3-item ticket. One item is voided. What should the cook see?' " +
-        "Answer the scenario concretely before proceeding with the edit.",
+        "Answer the scenario concretely before proceeding with the edit. If the MCP transport is unavailable, use the " +
+        "packaged `prism verify-behavior` CLI fallback; never fabricate a replacement scenario.",
     inputSchema: {
         type: "object",
         properties: {

package/dist/tools/skillRouting.js

@@ -22,11 +22,10 @@ export const REQUIRED_PROTECTED_SKILL_NAMES = [
     'pre-commit-protocol',
     'pre-push-audit',
     'implementation-integrity-audit',
-    'current-staging-acceptance',
     'local-inference-first',
 ];
 /**
- * Native skills that every subscription tier receives through `prism connect`.
+ * Native skills that paid subscription tiers receive through `prism connect`.
  *
  * `prism-startup` is deliberately not part of OFFLINE_FALLBACK: it tells the
  * host to call session_load_context, so injecting it back into that tool's
@@ -37,6 +36,8 @@ export const REQUIRED_NATIVE_SKILL_NAMES = [
     ...REQUIRED_PROTECTED_SKILL_NAMES,
     'prism-startup',
 ];
+/** Public hook-free bootstrap package available without a paid entitlement. */
+export const FREE_NATIVE_SKILL_NAMES = ['prism-startup'];
 export const OFFLINE_FALLBACK = {
     version: 1,
     universal: REQUIRED_PROTECTED_SKILL_NAMES.map((name, priority) => ({ name, priority, protected: true })),

package/dist/utils/codingQualityPolicy.js

@@ -41,7 +41,9 @@ const UNFENCED_PYTHON_START_RE = /^\s*(?:from\s+\S+\s+import|import\s+\S+|(?:asy
 const TRAILING_PROSE_LINE_RE = /^(?!(?:async\s+def|def|class|from|import|return|raise|yield|assert|del|global|nonlocal|if|elif|else|for|while|try|except|finally|with|match|case)\b)(?![A-Za-z_]\w*\s*=)[A-Za-z][A-Za-z'’-]*:?(?:\s+(?:[A-Za-z][A-Za-z'’+/-]*|`[^`\r\n]+`|https?:\/\/\S+|\d[\w.,%()+\-]*|[+*=<>-])){2,}[.!?]$/;
 const TRAILING_URL_LINE_RE = /^https?:\/\/\S+$/i;
 const PYTHON_INVALID_DEF_RE = /(?:^|\n)\s*(?:async\s+)?def\s+[A-Za-z_]\w*\s*:/m;
-const PYTHON_AST_SCRIPT = "import ast,sys; tree=ast.parse(sys.stdin.read()); compile(tree, '<prism-coding-gate>', 'exec')";
+const PYTHON_READY_SENTINEL = "PRISM_PYTHON_READY";
+const PYTHON_AST_SCRIPT = `import ast,sys; print('${PYTHON_READY_SENTINEL}', flush=True); ` +
+    "tree=ast.parse(sys.stdin.read()); compile(tree, '<prism-coding-gate>', 'exec')";
 const PYTHON_COMMANDS = ["python3", "python"];
 const PYTHON_CHILDREN_KEYS_UNPACK_RE = /\bfor\s+[A-Za-z_]\w*\s*,\s*child(?:_node)?\s+in\s+(?:sorted\(\s*)?[A-Za-z_][\w.]*\.children\.keys\(\)\s*\)?\s*:/;
 function extractUnfencedPythonCode(output) {
@@ -279,6 +281,12 @@ function pythonSyntaxFailure(code) {
         if (parsed.error && parsed.error.code === "ENOENT") {
             continue;
         }
+        const parserStarted = parsed.stdout
+            ?.split(/\r?\n/)
+            .includes(PYTHON_READY_SENTINEL) === true;
+        if (!parserStarted) {
+            continue;
+        }
         return parsed.status === 0 ? undefined : "python_syntax_error";
     }
     return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.8",
+  "version": "20.2.9",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -22,7 +22,7 @@
     "prebuild": "npm run clean",
     "build": "tsc && npm run chmod-bins",
     "chmod-bins": "node -e \"['dist/cli.js','dist/server.js','dist/utils/universalImporter.js'].forEach(f => { try { require('fs').chmodSync(f, 0o755); } catch (e) { console.warn('chmod skipped', f, e.message); } })\"",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "node scripts/check-publish-clean.mjs && npm run build",
     "lint:dashboard": "node scripts/lint-dashboard-es5.cjs",
     "start": "node dist/server.js",
     "test": "vitest run",