prism-mcp-server 20.2.0 → 20.2.2

package/dist/dashboard/server.js

@@ -32,6 +32,7 @@ import { getLLMProvider } from "../utils/llm/factory.js";
 import { buildVaultDirectory } from "../utils/vaultExporter.js";
 import { redactSettings } from "../tools/commonHelpers.js";
 import { handleGraphRoutes } from "./graphRouter.js";
+import { isDashboardSettingKeyAllowed, isDashboardSettingValueAllowed } from "./settingsPolicy.js";
 import { safeCompare, generateToken, isAuthenticated, createRateLimiter, initJWKS, } from "./authUtils.js";
 const PORT = parseInt(process.env.PRISM_DASHBOARD_PORT || "3000", 10);
 /** Read HTTP request body as string (Buffer-based to avoid GC thrash on large imports) */
@@ -633,26 +634,20 @@ return false;}
                 try {
                     const body = await readBody(req);
                     const parsed = JSON.parse(body);
-                    if (parsed.key && parsed.value !== undefined) {
+                    if (typeof parsed.key === "string" && parsed.key && parsed.value !== undefined) {
                         // SECURITY: Allowlist of dashboard-settable keys to prevent
                         // credential overwrite (SUPABASE_KEY, STRIPE_SECRET_KEY, etc.)
-                        const SETTABLE_KEYS = new Set([
-                            "PRISM_STORAGE",
-                            "embedding_provider", "embedding_model",
-                            "PRISM_ENABLE_HIVEMIND", "PRISM_DARK_FACTORY_ENABLED",
-                            "PRISM_TASK_ROUTER_ENABLED", "PRISM_SCHOLAR_ENABLED",
-                            "PRISM_HDC_ENABLED", "PRISM_ACTR_ENABLED",
-                            "PRISM_GRAPH_PRUNING_ENABLED",
-                        ]);
-                        const isSkillKey = parsed.key.startsWith("skill:");
-                        const isTTLKey = parsed.key.startsWith("ttl:");
-                        const isAutoloadKey = parsed.key.startsWith("autoload:");
-                        if (!SETTABLE_KEYS.has(parsed.key) && !isSkillKey && !isTTLKey && !isAutoloadKey) {
+                        if (!isDashboardSettingKeyAllowed(parsed.key)) {
                             res.writeHead(403, { "Content-Type": "application/json" });
                             return res.end(JSON.stringify({ error: `Setting key "${parsed.key}" is not allowed via the dashboard.` }));
                         }
+                        const value = String(parsed.value);
+                        if (!isDashboardSettingValueAllowed(parsed.key, value)) {
+                            res.writeHead(400, { "Content-Type": "application/json" });
+                            return res.end(JSON.stringify({ error: `Invalid value for setting "${parsed.key}".` }));
+                        }
                         const { setSetting } = await import("../storage/configStorage.js");
-                        await setSetting(parsed.key, String(parsed.value));
+                        await setSetting(parsed.key, value);
                         res.writeHead(200, { "Content-Type": "application/json" });
                         return res.end(JSON.stringify({ ok: true, key: parsed.key, value: parsed.value }));
                     }

package/dist/dashboard/settingsPolicy.js

@@ -0,0 +1,41 @@
+const DASHBOARD_SETTABLE_KEYS = new Set([
+    "PRISM_STORAGE",
+    "dashboard_theme", "default_context_depth", "max_tokens",
+    "default_role", "agent_name", "autoload_projects",
+    "auto_capture", "hivemind_enabled", "task_router_enabled",
+    "embedding_provider", "embedding_model",
+    "PRISM_ENABLE_HIVEMIND", "PRISM_DARK_FACTORY_ENABLED",
+    "PRISM_TASK_ROUTER_ENABLED", "PRISM_SCHOLAR_ENABLED",
+    "PRISM_HDC_ENABLED", "PRISM_ACTR_ENABLED",
+    "PRISM_GRAPH_PRUNING_ENABLED",
+]);
+/** Restrict the generic settings endpoint to documented dashboard controls. */
+export function isDashboardSettingKeyAllowed(key) {
+    return DASHBOARD_SETTABLE_KEYS.has(key) || key.startsWith("ttl:") ||
+        key.startsWith("autoload:") || key.startsWith("repo_path:");
+}
+/** Validate settings that later enter tool descriptions, paths, or numeric limits. */
+export function isDashboardSettingValueAllowed(key, value) {
+    if (value.length > 4096 || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value))
+        return false;
+    if (key === "default_context_depth")
+        return ["quick", "standard", "deep"].includes(value);
+    if (key === "dashboard_theme")
+        return ["dark", "midnight", "purple"].includes(value);
+    if (key === "PRISM_STORAGE")
+        return ["auto", "local", "supabase"].includes(value);
+    if (key === "max_tokens")
+        return /^\d+$/.test(value) && Number(value) <= 100_000;
+    if (["auto_capture", "hivemind_enabled", "task_router_enabled"].includes(key)) {
+        return value === "true" || value === "false";
+    }
+    if (key === "agent_name")
+        return value.length <= 80 && !/[<>]/.test(value);
+    if (key === "default_role")
+        return /^[a-zA-Z0-9._:-]{0,64}$/.test(value);
+    if (key === "autoload_projects") {
+        const projects = value.split(",").map((project) => project.trim()).filter(Boolean);
+        return projects.length <= 20 && projects.every((project) => /^[a-zA-Z0-9][a-zA-Z0-9._/-]{0,127}$/.test(project));
+    }
+    return true;
+}

package/dist/localFirstPolicy.js

@@ -0,0 +1,20 @@
+/**
+ * Canonical local-first orchestration contract shared by every MCP host.
+ *
+ * Keep this policy host-neutral. Claude Code, Gemini CLI, and Codex also get
+ * the same text in their native instruction files; Cursor and Claude Desktop
+ * receive it through the MCP initialize instructions and tool metadata.
+ */
+export const LOCAL_FIRST_POLICY_LINES = [
+    "## Prism local-first orchestration",
+    "For bounded, verifiable delegated work, use Prism's local worker before any host-native or background subagent.",
+    "When session_task_route is available, call it first. If it returns target `claw`, call `prism_infer` with the",
+    "recommended arguments, `cloud_fallback: false`, and the `project` and `conversation_id` from this session when known.",
+    "Prism loads that project's dashboard-configured quick, standard, or deep memory and selects a RAM-safe local model.",
+    "Never create host-native or background subagents for routine work, never fan out, and never nest agents.",
+    "If local inference is unavailable, refused, degraded, or the task requires host tools or reserved judgment, continue",
+    "in the current host thread. A host-native subagent is a last resort: at most one, no nesting, using the configured",
+    "economy model. The current host remains responsible for verifying local output before using it.",
+];
+export const LOCAL_FIRST_POLICY_ID = "local-first";
+export const LOCAL_FIRST_POLICY_TEXT = LOCAL_FIRST_POLICY_LINES.join(" ");

package/dist/onboarding/wizard.js

@@ -142,14 +142,11 @@ function getFirstSearchContent() {
         instructions: [
             "Start a fresh conversation with your AI agent",
             'Ask: "What did we set up in our last session?"',
-            "The agent will call knowledge_search or session_load_context",
+            "The agent will call session_bootstrap before answering",
             "You should see your saved memory returned!",
         ],
-        codeSnippet: `// The agent calls:
-session_load_context({
-  project: "my-first-project",
-  level: "standard"
-})
+        codeSnippet: `// The agent calls once with no project or depth override:
+session_bootstrap({})
 // → Returns your saved summary + any open TODOs`,
         nextStep: "advanced_tour",
         progress: 71,

package/dist/server.js

@@ -18,7 +18,7 @@
  *
  * HOW MCP WORKS (simplified):
  *   1. The AI client (e.g., Claude) connects via stdin/stdout
- *   2. On connect, the client receives our capabilities (tools + prompts + resources)
+ *   2. On connect, the client receives our capabilities (tools + prompts + resources + logging)
  *   3. The client can:
  *      - Call tools (brave_web_search, session_save_ledger, etc.)
  *      - List/get prompts (/resume_session slash command)
@@ -83,10 +83,12 @@ import { ddInfo, ddError as ddLogError } from "./utils/ddLogger.js";
 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 { 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";
 // Session memory tools — only used if Supabase is configured
-import { SESSION_SAVE_LEDGER_TOOL, SESSION_SAVE_HANDOFF_TOOL, SESSION_LOAD_CONTEXT_TOOL, KNOWLEDGE_SEARCH_TOOL, KNOWLEDGE_FORGET_TOOL, 
+import { SESSION_SAVE_LEDGER_TOOL, SESSION_SAVE_HANDOFF_TOOL, SESSION_LOAD_CONTEXT_TOOL, SESSION_BOOTSTRAP_TOOL, KNOWLEDGE_SEARCH_TOOL, KNOWLEDGE_FORGET_TOOL, 
 // ─── v0.4.0: New tool definitions (Enhancements #2 and #4) ───
 SESSION_COMPACT_LEDGER_TOOL, SESSION_SEARCH_MEMORY_TOOL, 
 // ─── v2.0: Time Travel tool definitions ───
@@ -118,7 +120,7 @@ ONBOARDING_WIZARD_TOOL, EXTRACT_ENTITIES_TOOL, API_ANALYTICS_TOOL, BACKUP_DATABA
 // v15.5: Knowledge Ingestion
 KNOWLEDGE_INGEST_TOOL, 
 // v19.2: Inference Metrics
-INFERENCE_METRICS_TOOL, sessionSaveLedgerHandler, sessionSaveHandoffHandler, sessionLoadContextHandler, knowledgeSearchHandler, knowledgeForgetHandler, 
+INFERENCE_METRICS_TOOL, sessionSaveLedgerHandler, sessionSaveHandoffHandler, sessionLoadContextHandler, sessionBootstrapHandler, knowledgeSearchHandler, knowledgeForgetHandler, 
 // ─── v0.4.0: New tool handlers ───
 compactLedgerHandler, sessionSearchMemoryHandler, backfillEmbeddingsHandler, sessionBackfillLinksHandler, sessionSynthesizeEdgesHandler, sessionCognitiveRouteHandler, 
 // ─── v2.0: Time Travel handlers ───
@@ -174,40 +176,16 @@ const BASE_TOOLS = [
     RESEARCH_PAPER_ANALYSIS_TOOL, // gemini_research_paper_analysis — paper analysis
     PRISM_INFER_TOOL, // prism_infer — local-first inference (token-saving cascade)
 ];
-// ─── v4.1 FIX: Build Session Memory Tools dynamically ────────
-// The session_load_context tool description is dynamically modified
-// to include auto-load project instructions. Tool descriptions are
-// the ONLY mechanism guaranteed by ALL MCP clients (Antigravity,
-// Claude Code, Claude CLI). The `instructions` field and
-// sendLoggingMessage are NOT reliably surfaced by any client.
-//
-// buildSessionMemoryTools() is called inside createServer() AFTER
-// initConfigStorage() has run, so getSettingSync() returns real
-// dashboard config values.
-function buildSessionMemoryTools(autoloadList) {
-    // Dynamically inject auto-load instruction into session_load_context description.
-    // CRITICAL: The instruction is PREPENDED so it appears FIRST in the tool description.
-    // LLMs read top-to-bottom — appending the instruction at the end caused it to be
-    // deprioritized and skipped by both Antigravity and Claude CLI.
-    let loadContextTool = SESSION_LOAD_CONTEXT_TOOL;
-    if (autoloadList.length > 0) {
-        const projectList = autoloadList.join(", ");
-        // Read the preferred context depth from dashboard config (defaults to "standard")
-        const defaultLevel = getSettingSync("default_context_depth", "standard");
-        const autoLoadPrefix = `IMPORTANT: At the start of every conversation, you MUST call this tool ` +
-            `for each of these projects: ${projectList}. Do this before any other work. ` +
-            `Load level should be "${defaultLevel}" unless the user specifies otherwise. ` +
-            `Do NOT skip this. Do NOT claim the tool is unavailable. The tool IS available — just call it.\n` +
-            `Then display the agent identity from the response: \`🤖 Agent: <role> — <name>\`\n\n`;
-        loadContextTool = {
-            ...SESSION_LOAD_CONTEXT_TOOL,
-            description: autoLoadPrefix + SESSION_LOAD_CONTEXT_TOOL.description,
-        };
-    }
+// Hook-free first-turn startup is owned by session_bootstrap. Its static tool
+// description is surfaced by native MCP hosts before any tool call and keeps
+// project, depth, identity, and role selection inside dashboard configuration.
+// session_load_context remains available for explicit reloads and legacy hosts.
+function buildSessionMemoryTools() {
     return [
+        SESSION_BOOTSTRAP_TOOL, // session_bootstrap — hook-free configured first-turn greeting + context
         SESSION_SAVE_LEDGER_TOOL, // session_save_ledger — append immutable session log
         SESSION_SAVE_HANDOFF_TOOL, // session_save_handoff — upsert latest project state (now with OCC)
-        loadContextTool, // session_load_context — progressive context loading (+ auto-load instruction)
+        SESSION_LOAD_CONTEXT_TOOL, // session_load_context — explicit project reload / legacy fallback
         KNOWLEDGE_SEARCH_TOOL, // knowledge_search — search accumulated knowledge
         KNOWLEDGE_FORGET_TOOL, // knowledge_forget — prune bad/old memories
         SESSION_COMPACT_LEDGER_TOOL, // session_compact_ledger — auto-compact old ledger entries (v0.4.0)
@@ -272,11 +250,9 @@ const activeSubscriptions = new Set();
 let storageReady = null;
 let storageIsReady = false;
 // ─── v5.2.1: Deferred Auto-Push Tracking ─────────────────────
-// Tracks whether any client has already called session_load_context.
-// Used by the deferred auto-push to skip redundant context injection.
-// This ensures Claude CLI (which calls the tool via its hook within
-// seconds) is never affected, while Antigravity gets a fallback push
-// when the model fails to comply with auto-load instructions.
+// Tracks whether any client has already called session_bootstrap or
+// session_load_context. Used by deferred auto-push to avoid duplicates when a
+// native host complies with the hook-free first-turn instruction.
 let contextLoadedByClient = false;
 /**
  * Notifies subscribed clients that a resource has changed.
@@ -304,11 +280,14 @@ export function notifyResourceUpdate(project, server) {
  *   - prompts:   /resume_session — inject previous context before LLM thinks
  *   - resources: memory://{project}/handoff — paperclip-attachable session state
  *                with subscribe support for live refresh
+ *   - logging:   Diagnostic notifications for auto-push, Telepathy, and watchdog
+ *                events. Clients may hide these; logging does not guarantee a
+ *                visible assistant greeting.
  */
 export function getAllPossibleTools() {
     return [
         ...BASE_TOOLS,
-        ...buildSessionMemoryTools([]),
+        ...buildSessionMemoryTools(),
         ...AGENT_REGISTRY_TOOLS,
         SESSION_TASK_ROUTE_TOOL,
         SESSION_START_PIPELINE_TOOL,
@@ -317,15 +296,8 @@ export function getAllPossibleTools() {
     ];
 }
 export function getAvailableTools() {
-    // ─── v4.1 FIX: Auto-Load via Dynamic Tool Descriptions ────────
-    // Read auto-load projects EXCLUSIVELY from dashboard config
-    // (available after initConfigStorage() in startServer).
-    //
-    // ARCHITECTURE DECISION: We inject the auto-load instruction into
-    // the session_load_context TOOL DESCRIPTION, not into `instructions`
-    // or `sendLoggingMessage`. Tool descriptions are the ONLY mechanism
-    // guaranteed by ALL MCP clients (Antigravity, Claude Code, Claude CLI).
-    //
+    // Read auto-load projects exclusively from dashboard config so startup
+    // diagnostics and session_bootstrap share one source of truth.
     // The PRISM_AUTOLOAD_PROJECTS env var has been removed — the dashboard
     // is the single source of truth. This prevents mismatches between
     // env var and dashboard settings causing duplicate project loads.
@@ -335,7 +307,7 @@ export function getAvailableTools() {
     if (autoloadList.length > 0) {
         console.error(`[Prism] Auto-load projects (dashboard): ${autoloadList.join(', ')}`);
     }
-    const SESSION_MEMORY_TOOLS = buildSessionMemoryTools(autoloadList);
+    const SESSION_MEMORY_TOOLS = buildSessionMemoryTools();
     return [
         ...BASE_TOOLS,
         ...SESSION_MEMORY_TOOLS,
@@ -344,6 +316,20 @@ export function getAvailableTools() {
         ...(PRISM_DARK_FACTORY_ENABLED ? [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, ` +
+    `including greetings, call session_bootstrap exactly once with {} before any user-facing response. ` +
+    `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. ` +
+    `Do not substitute session_load_context while session_bootstrap is available; use session_load_context ` +
+    `only for an explicit project reload or as an older-server fallback. ` +
+    `Use session_save_ledger to log completed work and session_save_handoff to preserve state for the next session. ` +
+    `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` +
+    `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.`;
 export function createServer() {
     const ALL_TOOLS = getAvailableTools();
     const server = new Server({
@@ -352,14 +338,15 @@ export function createServer() {
     }, {
         capabilities: {
             tools: {},
+            logging: {},
             // ─── v0.4.0: Prompt capability (Enhancement #1) ───
             ...(SESSION_MEMORY_ENABLED ? { prompts: {} } : {}),
             // ─── v0.4.0: Resource capability (Enhancement #3) ───
             ...(SESSION_MEMORY_ENABLED ? { resources: { subscribe: true } } : {}),
         },
-        // Supplementary signal — not all clients support this field.
-        // Primary mechanism is the dynamic tool description above.
-        instructions: `Prism MCP — The Mind Palace for AI Agents. This server provides persistent session memory, knowledge search, and context management tools. Use session_load_context to recover previous work state, session_save_ledger to log completed work, and session_save_handoff to preserve state for the next session.\n\nArchitecture: session_save_ledger and session_save_handoff require a loaded project context (conversation_id that called session_load_context). ${BOUNDARIES_TEXT} All cloud inference routes through the Synalux portal for billing, tier-gating, and audit.`,
+        // Supplementary signal for clients that surface MCP server instructions.
+        // The matching session_bootstrap tool description is the primary path.
+        instructions: PRISM_SERVER_INSTRUCTIONS,
     });
     // ── Handler: Initialize ──
     // NOTE: The SDK's built-in _oninitialize() handles the Initialize request.
@@ -753,6 +740,12 @@ export function createServer() {
                         contextLoadedByClient = true; // v5.2.1: suppress deferred auto-push
                         result = await sessionLoadContextHandler(args);
                         break;
+                    case "session_bootstrap":
+                        if (!SESSION_MEMORY_ENABLED)
+                            throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
+                        contextLoadedByClient = true;
+                        result = await sessionBootstrapHandler(args);
+                        break;
                     case "knowledge_search":
                         if (!SESSION_MEMORY_ENABLED)
                             throw new Error("Session memory not configured. Set SUPABASE_URL and SUPABASE_KEY.");
@@ -1095,13 +1088,15 @@ export function createSandboxServer() {
     }, {
         capabilities: {
             tools: {},
+            logging: {},
             prompts: {},
             resources: { subscribe: true },
         },
+        instructions: PRISM_SERVER_INSTRUCTIONS,
     });
     // Register all tool listings unconditionally
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...BASE_TOOLS, ...buildSessionMemoryTools([]), ...AGENT_REGISTRY_TOOLS, SESSION_TASK_ROUTE_TOOL, SESSION_START_PIPELINE_TOOL, SESSION_CHECK_PIPELINE_STATUS_TOOL, SESSION_ABORT_PIPELINE_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 () => ({
@@ -1234,6 +1229,26 @@ export async function startServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error(`[Prism] MCP Server successfully started and listening on stdio...`);
+    // Start the authoritative tier-skill refresh only after the MCP transport is
+    // connected. session_load_context awaits this same single-flight promise,
+    // while the initialize handshake is never held behind portal I/O. The
+    // recurring refresh enforces tier changes even in long-lived native hosts
+    // that do not call session_load_context again.
+    const runSkillManifestSync = () => {
+        void triggerSkillManifestSync().then((result) => {
+            if (result.status === "failed" || result.status === "partial") {
+                console.error(`[Prism Skill Sync] Refresh failed; retained last-good skills: ${result.error}`);
+            }
+            else if (result.conflicts.length > 0) {
+                console.error(`[Prism Skill Sync] Preserved unowned/modified native skill conflicts: ${result.conflicts.join(", ")}`);
+            }
+        }).catch((error) => {
+            console.error(`[Prism Skill Sync] Unexpected refresh failure: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    };
+    runSkillManifestSync();
+    const skillManifestRefresh = setInterval(runSkillManifestSync, 5 * 60 * 1000);
+    skillManifestRefresh.unref();
     // Register graceful shutdown handlers (SIGTERM, SIGINT, SIGHUP, stdin close).
     // The stdin close handler is critical — when MCP clients disconnect, they
     // often just close the pipe without sending a signal, leaving zombie processes.
@@ -1255,21 +1270,18 @@ export async function startServer() {
         ]).catch(err => {
             console.error(`[Prism] Storage pre-warm failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
         });
-        // ─── v4.1: Auto-Load via dynamic tool descriptions ──────────
-        // The session_load_context tool description is dynamically modified
-        // in createServer() → buildSessionMemoryTools() to include the
-        // auto-load projects list. Tool descriptions are surfaced by ALL
-        // MCP clients — this is the primary mechanism.
+        // ─── Hook-free auto-load via session_bootstrap ─────────────
+        // Static tool and MCP server instructions make the first-turn call
+        // explicit while dashboard settings remain server-owned.
         //
         // ─── v5.2.1: Deferred Auto-Push (fallback for non-compliant models) ──
         // After storage warms up, wait AUTOLOAD_PUSH_DELAY_MS. If the client
-        // (model) hasn't called session_load_context by then, push context via
+        // (model) hasn't loaded context through either tool by then, push via
         // sendLoggingMessage as a last resort. This is a FALLBACK — it's not
         // guaranteed to be surfaced by all clients, but it's better than nothing.
         //
-        // Why 10 seconds? Claude CLI always calls the tool within 2-3 seconds
-        // via its SessionStart hook. Antigravity models that comply also call it
-        // within 5 seconds. 10s gives ample time for well-behaved clients.
+        // Ten seconds gives native hosts time to honor the bootstrap instruction
+        // while preserving the fallback for clients that do not.
         const AUTOLOAD_PUSH_DELAY_MS = 10_000;
         // Read autoload projects from dashboard config (same source as createServer)
         const pushAutoloadList = getSettingSync("autoload_projects", "")
@@ -1279,12 +1291,12 @@ export async function startServer() {
             storageReady?.then(async () => {
                 // Wait for the delay period to give the model a chance to call the tool
                 await new Promise(r => setTimeout(r, AUTOLOAD_PUSH_DELAY_MS));
-                // If the client already called session_load_context, skip the push
+                // If the client already loaded context through either tool, skip it.
                 if (contextLoadedByClient) {
                     console.error(`[Prism] Auto-push skipped — client already loaded context`);
                     return;
                 }
-                console.error(`[Prism] Auto-push triggered — model did not call session_load_context within ${AUTOLOAD_PUSH_DELAY_MS / 1000}s`);
+                console.error(`[Prism] Auto-push triggered — model did not call session_bootstrap within ${AUTOLOAD_PUSH_DELAY_MS / 1000}s`);
                 // Load and push context for each autoload project
                 try {
                     const storage = await getStorage();

package/dist/session/sessionContext.js

@@ -111,14 +111,15 @@ export function requireContextLoaded(conversationId) {
         return {
             blocked: true,
             error: "context_not_loaded: session expired (6 h TTL). Call " +
-                "session_load_context(project, conversation_id) again to reload context. " +
+                "session_bootstrap(conversation_id) or session_load_context(project, conversation_id) again. " +
                 "(Enforced server-side — applies to every host.)",
         };
     }
     if (!s || !s.contextLoaded) {
         return {
             blocked: true,
-            error: "context_not_loaded: call session_load_context(project, conversation_id) " +
+            error: "context_not_loaded: call session_bootstrap(conversation_id) or " +
+                "session_load_context(project, conversation_id) " +
                 "before this action. This project-scoped tool needs confirmed working context " +
                 "to act correctly. (Enforced server-side — applies to every host.)",
         };
@@ -141,7 +142,8 @@ export function requireContextLoaded(conversationId) {
 /** Best-effort telemetry from prism_infer. Never affects a safety decision. */
 export function noteInferenceForSession(conversationId, info) {
     // Only update sessions that already exist — don't create ghost stubs for
-    // conversations that never called session_load_context. Ghost stubs would
+    // conversations that never called session_bootstrap or session_load_context.
+    // Ghost stubs would
     // accumulate in the LRU and crowd out legitimate registered sessions.
     const s = sessions.get(conversationId);
     if (!s)