prism-mcp-server 20.2.0 → 20.2.2

package/README.md

@@ -18,6 +18,87 @@ A paid subscription adds cloud sync, higher model tiers, and team features throu
 
 ---
 
+## What's New in v20.2.2
+
+### One Local-First Workflow Across Every Agent
+`prism connect` now installs one orchestration contract for Claude Code,
+Claude Desktop, Cursor, Gemini CLI, and Codex. Bounded delegated work goes to
+`session_task_route` and the local `prism_infer` worker first; routine work must
+not create background host agents. Local workers can receive the active
+project's dashboard-configured quick, standard, or deep memory and select a
+RAM-safe 2B/4B/9B/27B model at call time. The router forwards complexity but
+does not choose the model; `prism_infer` owns the final decision using memory
+and context fit, installed models, live RAM, entitlements, and explicit caller
+overrides.
+
+Codex and Gemini native agent fan-out are disabled during connect. Codex keeps
+a two-thread, one-level Terra/low fallback profile if the developer explicitly
+re-enables native agents later. Claude Code keeps native agents as a last-resort
+path but pins their model to Sonnet. Cursor and Claude Desktop do not expose a
+supported global subagent-policy file, so they receive the identical workflow
+through Prism's MCP server instructions. `prism_infer` safety boundaries and
+the host's final verification responsibility are unchanged.
+
+### Subscription-Tier Skills Arrive Before the First Host Launch
+`prism connect` now downloads the authoritative Synalux skill manifest and
+materializes entitled packages in the native `~/.agents/skills` directory
+before the command exits. Codex therefore sees the current skillset on its
+first launch instead of requiring a second restart. Prism rechecks the same
+snapshot at MCP startup, session load, and every five minutes—without host
+lifecycle hooks.
+
+On the first user turn, Prism's native skill, MCP metadata, and managed host
+instructions request one `session_bootstrap({})` call. Prism then uses the
+dashboard's developer name, Auto-Load Projects, and quick, standard, or deep
+setting. The response stays focused on greeting and session state because tier
+skills are already present in the host's native skill directory.
+
+Hook-free MCP can provide and prioritize that ready-to-display block, but the
+host model still owns the final assistant message and may summarize it. Prism
+does not claim a deterministic verbatim greeting on third-party chat surfaces;
+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 12-skill foundation. 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.
+
+When upgrading an older Claude Code installation, `prism connect` removes only
+the exact Prism-owned startup, skill-sync, handoff, and drift hook actions from
+the legacy bootstrap. It also removes the recognized legacy Prism startup
+sections from `~/CLAUDE.md`, preserves every other instruction, and installs a
+small ownership-marked native block that selects `session_bootstrap({})` on the
+first turn. User hooks, custom instruction sections, and near matches remain
+untouched; native skills and server-side reminders preserve those Prism
+features without host lifecycle hooks. Because hosts expose no native
+session-end callback, handoff at shutdown is instruction-driven rather than a
+guaranteed lifecycle event.
+
+After Claude Code's native user registration succeeds, the same default or
+`--refresh` command checks the nearest `.mcp.json` from the current directory
+through the home directory. It removes only the exact legacy
+`prism-mcp` entry `{ "command": "npx", "args": ["-y", "prism-mcp-server"] }`
+that would otherwise shadow the user registration. Custom Prism entries and
+their additional fields, plus unrelated servers, are preserved; malformed
+files fail loud without changes. `--dry-run` reports the recognized migration
+without changing the file.
+
+---
+
+## What's New in v20.2.1
+
+### Subscription-Aware Memory Storage
+`prism connect` now carries an explicit `PRISM_STORAGE=auto|local|synalux|supabase`
+into every managed host registration and rejects invalid values before changing a
+config file. In `auto`, a portal-confirmed free tier uses local SQLite, while
+Standard, Advanced, and Enterprise use Synalux cloud memory. If entitlement
+resolution is unavailable, Prism fails closed instead of splitting history across
+backends. Storage remains independent of local-first model routing.
+
+---
+
 ## What's New in v20.2.0
 
 ### One Command Connects Every Supported Host
@@ -121,11 +202,37 @@ Use `prism connect --all` to target all five, `--host <name>` for one host, or
 `--dry-run` to preview the files that would change. Existing `prism` and
 `prism-mcp` entries are never overwritten by default. `--refresh` updates only
 an entry previously created by Prism; custom entries remain untouched.
+For Claude Code, both the default command and `--refresh` also remove the exact
+legacy project-scoped `npx -y prism-mcp-server` entry from the effective
+ancestor `.mcp.json` after the native user registration succeeds. No custom or
+near-match project entry is changed.
 Close the target MCP hosts before a non-dry-run registration so they cannot
 edit their configuration at the same time.
 
-Codex registration preserves `~/.codex/config.toml` and appends only a marked
-Prism-managed block. `CODEX_HOME` is respected when set and must already exist,
+The same connection installs the local-first orchestration contract:
+
+| Host | Managed containment |
+|---|---|
+| Codex | `features.multi_agent=false`; a 2-thread, depth-1 Terra/low fallback profile is retained for explicit re-enable |
+| Gemini CLI | `experimental.enableAgents=false` |
+| Claude Code | `CLAUDE_CODE_SUBAGENT_MODEL=sonnet`; managed instructions reserve it for last-resort fallback |
+| Cursor | Canonical policy delivered through MCP initialize instructions |
+| Claude Desktop | Canonical policy delivered through MCP initialize instructions |
+
+All five receive `PRISM_AGENT_POLICY=local-first` in their managed Prism MCP
+entry. Routine tasks use the RAM-aware local worker; native/background fan-out
+is not the default workflow. `session_task_route` supplies a complexity hint;
+`prism_infer` remains the single owner of model and thinking selection and can
+choose 27B when its viability gates support it.
+
+Set `PRISM_STORAGE` before running `prism connect` to preserve an explicit
+storage choice in the generated host entries. This does not change local-model
+routing; Synalux cloud storage separately requires an active cloud-memory
+entitlement.
+
+Codex registration preserves unrelated `~/.codex/config.toml` content, appends
+only the marked Prism MCP block, and updates only the documented local-first
+feature/agent keys. `CODEX_HOME` is respected when set and must already exist,
 matching Codex's own contract. Restart Codex CLI, the
 IDE extension, or the ChatGPT desktop app after connecting.
 
@@ -482,7 +589,8 @@ Prism exposes 40+ MCP tools. The core memory loop:
 
 | Tool | What it does |
 |---|---|
-| `session_load_context` | Recover the prior session's state on boot |
+| `session_bootstrap` | Hook-free first-turn greeting and dashboard-configured context |
+| `session_load_context` | Explicit project reload or older-server startup fallback |
 | `session_save_ledger` | Append an immutable session log entry |
 | `session_save_handoff` | Save live state for the next session |
 | `knowledge_search` | Semantic + keyword search over all memories |
@@ -491,7 +599,7 @@ Prism exposes 40+ MCP tools. The core memory loop:
 | `verify_behavior` | Pre-edit scenario challenge — catch bad changes before they happen |
 | `knowledge_ingest` | Teach Prism a codebase or document |
 | `prism_infer` | Local-first inference (route/chat/code modes, thinking, cloud escalation) |
-| `inference_metrics` | Session delegation stats on demand (call count, tokens, local/cloud split) |
+| `inference_metrics` | Session delegation or persisted MCP + VS Code panel local/cloud stats |
 
 ### `prism_infer` — local-first inference with cloud escalation
 
@@ -516,7 +624,7 @@ Full TypeScript signatures live in [`src/tools/`](src/tools/); architecture in [
 
 ### `inference_metrics` — see your local-model usage on demand
 
-Call `inference_metrics` anytime mid-session to see how many `prism_infer` calls ran locally vs cloud, with actual token counts:
+Call `inference_metrics` anytime mid-session to see how many `prism_infer` calls ran locally vs cloud. Use `period: "all"` to atomically import the Synalux VS Code panel spool and include its local-serve rate in the persisted totals:
 
 ```
 📊 Inference Metrics — local-model delegation (this session):
@@ -530,28 +638,42 @@ Call `inference_metrics` anytime mid-session to see how many `prism_infer` calls
 
 The same block also appears automatically in `session_save_ledger` and `session_save_handoff` responses at session end.
 
-**Note:** This tracks `prism_infer` delegation only — not your host model's (Claude's) own token spend. For that, use Claude Code's `/cost` command.
+**Note:** The default session view tracks this MCP process's `prism_infer` delegation. The all-time view combines persisted MCP calls with Synalux VS Code panel inference. Neither view includes your host model's (Claude's) own token spend; use Claude Code's `/cost` command for that.
 
-### Local-model delegation (opt-in)
+### Local-model delegation (default)
 
-By default, your AI agent (Claude, Cursor, etc.) handles everything itself. You can optionally enable delegation so the agent offloads cheap, verifiable sub-tasks to local Ollama models at $0:
+Prism routes qualifying bounded work—bulk classification, field extraction,
+mechanical formatting, test generation, and similar tasks—to local Ollama
+models before any host-native subagent. The agent checks `gate_outcome`,
+verifies the result, and continues in the current host thread when the local
+worker is unavailable, refused, or degraded.
 
-```bash
-# Enable via Prism config
-prism config set delegation_enabled true
+Pass project memory when the subtask depends on prior work:
+
+```json
+{
+  "prompt": "Generate the bounded regression-test cases.",
+  "project": "prism-mcp",
+  "context_depth": "standard",
+  "conversation_id": "<from session_bootstrap>",
+  "mode": "code",
+  "cloud_fallback": false,
+  "escalation": "report"
+}
 ```
 
-When enabled, the agent's task router may delegate qualifying work — bulk classification, field extraction, mechanical formatting — to `prism_infer` instead of using cloud tokens. The agent always verifies the result and redoes it itself if quality is degraded.
+Omit `context_depth` to use the dashboard setting. Turn off the dashboard Task
+Router toggle or set `PRISM_TASK_ROUTER_ENABLED=false` for an explicit opt-out.
 
 **Guardrails:**
-- **Off by default** — enforced in code, not just convention
+- **Local by default** — an explicit operator opt-out is preserved
 - **Never delegates:** code/text that ships to the user, security/safety logic, planning/reasoning, anything where a silent quality drop isn't obvious
 - **Always verifies:** checks `quality_gate_failed` and `used_cloud` before trusting local output
 
 <details>
 <summary>How Prism survives context compaction</summary>
 
-The LLM context window is treated as ephemeral scratch space; durable state lives in the persistent store (SQLite locally, the portal in the cloud). Every session begins with a mandatory `session_load_context` call, so the agent is oriented before it writes a response. When a project exceeds a threshold (default 50 entries), `session_compact_ledger` summarizes old entries into a rollup, soft-archives the originals, and links them in the graph. See [`docs/COMPACTION.md`](docs/COMPACTION.md)
+The LLM context window is treated as ephemeral scratch space; durable state lives in the persistent store (SQLite locally, the portal in the cloud). Every session begins with a mandatory no-argument `session_bootstrap` call, so Prism applies the dashboard's project and quick/standard/deep setting before the agent writes a response. When a project exceeds a threshold (default 50 entries), `session_compact_ledger` summarizes old entries into a rollup, soft-archives the originals, and links them in the graph. See [`docs/COMPACTION.md`](docs/COMPACTION.md)
 </details>
 
 ---
@@ -692,7 +814,7 @@ Routing is automatic: `9b → 4b → cloud fallback` on desktop/server, `2b →
 | `PRISM_FORCE_LOCAL` | Force local SQLite regardless of credentials | `false` |
 | `TELEMETRY_WRITE_TOKEN` | Portal analytics token (optional — metrics display works without it) | -- |
 
-With no variables set, Prism runs fully local. Set `PRISM_SYNALUX_API_KEY` (and leave `PRISM_STORAGE=auto`) to use the cloud backend.
+With no variables set, Prism runs fully local. With an active cloud-memory subscription, set `PRISM_SYNALUX_API_KEY` (and leave `PRISM_STORAGE=auto`) to use the Synalux backend; a portal-confirmed free tier remains on local SQLite.
 
 ---
 

package/dist/cli.js

@@ -7,13 +7,81 @@ import { getStorage, closeStorage } from './storage/index.js';
 import { getSetting } from './storage/configStorage.js';
 import { PRISM_USER_ID, SERVER_CONFIG } from './config.js';
 import { getCurrentGitState } from './utils/git.js';
-import { sessionLoadContextHandler, sessionSaveLedgerHandler, sessionSaveHandoffHandler } from './tools/ledgerHandlers.js';
-import { connectHosts, normalizeHostName } from './connect.js';
+import { sessionBootstrapHandler, sessionLoadContextHandler, sessionSaveLedgerHandler, sessionSaveHandoffHandler, } from './tools/ledgerHandlers.js';
+import { configureClaudeAgentPolicy, configureClaudeNativeStartup, configureCodexAgentPolicy, configureCodexNativeStartup, configureGeminiAgentPolicy, configureGeminiNativeStartup, connectHosts, migrateLegacyClaudeHooks, migrateLegacyClaudeInstructions, migrateLegacyClaudeManagedStartup, migrateLegacyClaudeProjectMcp, normalizeHostName, } from './connect.js';
 const program = new Command();
+/** Build the stable `prism load --json` envelope from depth-specific context. */
+export function buildLoadJsonOutput(project, data, level, metadata) {
+    let history = [];
+    let historyLimit = 0;
+    if (level === 'standard') {
+        history = Array.isArray(data.recent_sessions) ? data.recent_sessions : [];
+        historyLimit = 5;
+    }
+    else if (level === 'deep') {
+        // Canonical deep context uses session_history. Fall back only when that
+        // field is absent so older portal responses remain consumable.
+        history = Array.isArray(data.session_history)
+            ? data.session_history
+            : Array.isArray(data.recent_sessions)
+                ? data.recent_sessions
+                : [];
+        historyLimit = 50;
+    }
+    return {
+        agent_name: metadata.agentName || null,
+        handoff: [{
+                project,
+                role: metadata.effectiveRole || data.role || 'global',
+                last_summary: data.last_summary || null,
+                pending_todo: data.pending_todo || null,
+                active_decisions: data.active_decisions || null,
+                keywords: data.keywords || null,
+                key_context: data.key_context || null,
+                active_branch: data.active_branch || null,
+                version: data.version ?? null,
+                updated_at: data.updated_at || null,
+            }],
+        // Keep the established key for callers while sourcing the canonical field
+        // for the requested depth.
+        recent_ledger: history.slice(0, historyLimit).map((entry) => ({
+            summary: entry?.summary || null,
+            decisions: entry?.decisions || null,
+            keywords: entry?.keywords || null,
+            created_at: entry?.session_date || entry?.created_at || null,
+        })),
+        git_hash: metadata.gitHash,
+        git_branch: metadata.gitBranch,
+        pkg_version: metadata.packageVersion,
+    };
+}
 program
     .name('prism')
     .description('Prism — The Mind Palace for AI Agents')
     .version(SERVER_CONFIG.version);
+/** Print the canonical hook-free first-turn display used by the MCP tool. */
+export async function runBootstrapCommand() {
+    try {
+        const result = await sessionBootstrapHandler({});
+        const output = result.content?.map((part) => part?.text).filter(Boolean).join('\n') || '';
+        if (!output)
+            throw new Error('session_bootstrap returned no display content');
+        console.log(output);
+        if (result.isError)
+            process.exitCode = 1;
+    }
+    catch (err) {
+        console.error(`Bootstrap failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+    finally {
+        await closeStorage().catch(() => { });
+    }
+}
+program
+    .command('bootstrap')
+    .description('Print the canonical dashboard-configured first-turn Prism greeting')
+    .action(runBootstrapCommand);
 // ─── prism connect ────────────────────────────────────────────
 // Registers this installed package with supported MCP hosts. The
 // merge is additive: an existing `prism` or `prism-mcp` entry is
@@ -25,7 +93,7 @@ program
     .option('--all', 'Target all supported hosts instead of auto-detecting installed hosts')
     .option('--dry-run', 'Preview configuration changes without writing files')
     .option('--refresh', 'Refresh only entries previously created by Prism; custom entries stay untouched')
-    .action((options) => {
+    .action(async (options) => {
     try {
         if (!options.dryRun) {
             console.log('Close target MCP hosts before registration so they cannot edit configuration concurrently.');
@@ -63,11 +131,146 @@ program
                 process.exitCode = 1;
             }
         }
+        const connectedClaude = summary.results.some((result) => result.host === 'claude-code' && result.status !== 'error' && result.startupCompatible);
+        const connectedGemini = summary.results.some((result) => result.host === 'gemini' && result.status !== 'error' && result.startupCompatible);
+        const connectedCodex = summary.results.some((result) => result.host === 'codex' && result.status !== 'error' && result.startupCompatible);
         if (options.dryRun) {
+            if (connectedClaude) {
+                const projectMcpMigration = migrateLegacyClaudeProjectMcp(undefined, undefined, true);
+                const hookMigration = migrateLegacyClaudeHooks(undefined, true);
+                const instructionMigration = migrateLegacyClaudeInstructions(undefined, true);
+                const managedMigration = migrateLegacyClaudeManagedStartup(undefined, true);
+                const nativeStartup = configureClaudeNativeStartup(undefined, true);
+                const agentPolicy = configureClaudeAgentPolicy(undefined, true);
+                if (projectMcpMigration.status === 'would-remove') {
+                    console.log(`• Claude Code: would remove exact legacy project Prism registration (${projectMcpMigration.path})`);
+                }
+                if (hookMigration.status === 'would-remove') {
+                    console.log(`• Claude Code: would remove ${hookMigration.removed} legacy Prism hook action(s) (${hookMigration.path})`);
+                }
+                if (instructionMigration.status === 'would-remove') {
+                    console.log(`• Claude Code: would remove ${instructionMigration.removed} legacy Prism startup section(s) (${instructionMigration.path})`);
+                }
+                if (managedMigration.status === 'would-remove') {
+                    console.log(`• Claude Code: would remove legacy managed startup block (${managedMigration.path})`);
+                }
+                if (nativeStartup.status === 'would-install' || nativeStartup.status === 'would-refresh') {
+                    console.log(`• Claude Code: would ${nativeStartup.status === 'would-install' ? 'install' : 'refresh'} native startup instructions (${nativeStartup.path})`);
+                }
+                if (agentPolicy.status === 'would-install' || agentPolicy.status === 'would-refresh') {
+                    console.log(`• Claude Code: would ${agentPolicy.status === 'would-install' ? 'install' : 'refresh'} local-first fallback policy (${agentPolicy.path})`);
+                }
+            }
+            if (connectedGemini) {
+                const nativeStartup = configureGeminiNativeStartup(undefined, true);
+                const agentPolicy = configureGeminiAgentPolicy(undefined, true);
+                if (nativeStartup.status === 'would-install' || nativeStartup.status === 'would-refresh') {
+                    console.log(`• Gemini CLI: would ${nativeStartup.status === 'would-install' ? 'install' : 'refresh'} native startup instructions (${nativeStartup.path})`);
+                }
+                if (agentPolicy.status === 'would-install' || agentPolicy.status === 'would-refresh') {
+                    console.log(`• Gemini CLI: would ${agentPolicy.status === 'would-install' ? 'disable native agents for' : 'refresh'} local-first policy (${agentPolicy.path})`);
+                }
+            }
+            if (connectedCodex) {
+                const nativeStartup = configureCodexNativeStartup(undefined, true);
+                const agentPolicy = configureCodexAgentPolicy(undefined, true);
+                if (nativeStartup.status === 'would-install' || nativeStartup.status === 'would-refresh') {
+                    console.log(`• Codex: would ${nativeStartup.status === 'would-install' ? 'install' : 'refresh'} native startup instructions (${nativeStartup.path})`);
+                }
+                if (agentPolicy.status === 'would-install' || agentPolicy.status === 'would-refresh') {
+                    console.log(`• Codex: would ${agentPolicy.status === 'would-install' ? 'install' : 'refresh'} hard local-first agent limits (${agentPolicy.path})`);
+                }
+            }
             console.log('\nDry run complete — no files changed.');
         }
+        else if (summary.results.some((result) => result.status !== 'error' && result.startupCompatible)) {
+            // Codex discovers native skills before it starts MCP servers. Syncing
+            // only from server startup therefore makes a fresh install require a
+            // second host restart. Materialize the entitlement snapshot before
+            // this registration command exits so the first launch sees it.
+            const { triggerSkillManifestSync } = await import('./skillManifestSync.js');
+            const skillSync = await triggerSkillManifestSync();
+            if (skillSync.status === 'failed' || skillSync.status === 'partial') {
+                throw new Error(`Synalux skill synchronization failed: ${skillSync.error || skillSync.status}`);
+            }
+            if (skillSync.status !== 'disabled') {
+                const changed = skillSync.installed.length + skillSync.updated.length + skillSync.pruned.length;
+                console.log(`✓ Synalux skills: ${skillSync.tier || 'free'} tier (${changed} changed)`);
+                if (skillSync.conflicts.length > 0) {
+                    console.error(`⚠ Preserved locally modified skill conflicts: ${skillSync.conflicts.join(', ')}`);
+                }
+                if (connectedClaude) {
+                    // Validate every affected surface before mutating any file.
+                    migrateLegacyClaudeHooks(undefined, true);
+                    migrateLegacyClaudeInstructions(undefined, true);
+                    migrateLegacyClaudeManagedStartup(undefined, true);
+                    configureClaudeNativeStartup(undefined, true);
+                    configureClaudeAgentPolicy(undefined, true);
+                    // Install the canonical block first. Never remove the legacy block
+                    // unless the canonical path is already current or commits safely.
+                    const nativeStartup = configureClaudeNativeStartup();
+                    const agentPolicy = configureClaudeAgentPolicy();
+                    const projectMcpMigration = migrateLegacyClaudeProjectMcp();
+                    const hookMigration = migrateLegacyClaudeHooks();
+                    const instructionMigration = migrateLegacyClaudeInstructions();
+                    const managedMigration = migrateLegacyClaudeManagedStartup();
+                    if (projectMcpMigration.status === 'removed') {
+                        console.log(`✓ Claude Code: removed exact legacy project Prism registration (${projectMcpMigration.path}); user-scope registration now owns Prism`);
+                    }
+                    if (hookMigration.status === 'removed') {
+                        console.log(`✓ Claude Code: removed ${hookMigration.removed} legacy Prism hook action(s); native skills now own startup and sync`);
+                    }
+                    if (instructionMigration.status === 'removed') {
+                        console.log(`✓ Claude Code: removed ${instructionMigration.removed} legacy Prism startup section(s); MCP bootstrap now owns first-turn context`);
+                    }
+                    if (managedMigration.status === 'removed') {
+                        console.log('✓ Claude Code: removed legacy managed startup block from ~/CLAUDE.md');
+                    }
+                    if (nativeStartup.status === 'installed' || nativeStartup.status === 'refreshed') {
+                        console.log(`✓ Claude Code: ${nativeStartup.status} hook-free native startup instructions`);
+                    }
+                    if (agentPolicy.status === 'installed' || agentPolicy.status === 'refreshed') {
+                        console.log(`✓ Claude Code: ${agentPolicy.status} local-first policy with Sonnet fallback`);
+                    }
+                }
+                if (connectedGemini) {
+                    configureGeminiNativeStartup(undefined, true);
+                    configureGeminiAgentPolicy(undefined, true);
+                    const nativeStartup = configureGeminiNativeStartup();
+                    const agentPolicy = configureGeminiAgentPolicy();
+                    if (nativeStartup.status === 'installed' || nativeStartup.status === 'refreshed') {
+                        console.log(`✓ Gemini CLI: ${nativeStartup.status} hook-free native startup instructions`);
+                    }
+                    if (agentPolicy.status === 'installed' || agentPolicy.status === 'refreshed') {
+                        console.log(`✓ Gemini CLI: ${agentPolicy.status} local-first policy; native agents disabled`);
+                    }
+                }
+                if (connectedCodex) {
+                    configureCodexNativeStartup(undefined, true);
+                    configureCodexAgentPolicy(undefined, true);
+                    const nativeStartup = configureCodexNativeStartup();
+                    const agentPolicy = configureCodexAgentPolicy();
+                    if (nativeStartup.status === 'installed' || nativeStartup.status === 'refreshed') {
+                        console.log(`✓ Codex: ${nativeStartup.status} hook-free native startup instructions`);
+                    }
+                    if (agentPolicy.status === 'installed' || agentPolicy.status === 'refreshed') {
+                        console.log(`✓ Codex: ${agentPolicy.status} hard local-first agent limits`);
+                    }
+                }
+            }
+            else if (connectedClaude) {
+                // The project-level npx registration is redundant once the
+                // user-level installed-server entry succeeds. Removing that exact
+                // legacy tuple is independent of native skill delivery; leave hooks
+                // and startup instructions untouched while synchronization is off.
+                const projectMcpMigration = migrateLegacyClaudeProjectMcp();
+                if (projectMcpMigration.status === 'removed') {
+                    console.log(`✓ Claude Code: removed exact legacy project Prism registration (${projectMcpMigration.path}); user-scope registration now owns Prism`);
+                }
+            }
+        }
         if (!summary.usedApiKey) {
-            console.log('PRISM_SYNALUX_API_KEY is not set; new registrations use local/free mode.');
+            console.log('PRISM_SYNALUX_API_KEY is not set; no Synalux subscription key was copied into new registrations.');
         }
     }
     catch (err) {
@@ -101,13 +304,13 @@ program
 program
     .command('load <project>')
     .description('Load session context for a project (same output as session_load_context MCP tool)')
-    .option('-l, --level <level>', 'Context depth: quick, standard, deep', 'standard')
+    .option('-l, --level <level>', 'Context depth: quick, standard, deep (defaults to dashboard setting)')
     .option('-r, --role <role>', 'Role scope for context loading')
     .option('-s, --storage <backend>', 'Storage backend: auto (default, prefers cloud), local (SQLite), or supabase. Overrides PRISM_STORAGE env var.')
     .option('--json', 'Emit machine-readable JSON instead of formatted text')
     .action(async (project, options) => {
     try {
-        const { level, role, storage, json: jsonOutput } = options;
+        const { level: requestedLevel, role, storage, json: jsonOutput } = options;
         // v9.2.2: --storage flag overrides PRISM_STORAGE env var to prevent
         // split-brain when CLI environment differs from MCP server config.
         if (storage) {
@@ -119,10 +322,12 @@ program
             process.env.PRISM_STORAGE = storage;
         }
         const validLevels = ['quick', 'standard', 'deep'];
-        if (!validLevels.includes(level)) {
-            console.error(`Error: Invalid level "${level}". Must be one of: ${validLevels.join(', ')}`);
+        if (requestedLevel && !validLevels.includes(requestedLevel)) {
+            console.error(`Error: Invalid level "${requestedLevel}". Must be one of: ${validLevels.join(', ')}`);
             process.exit(1);
         }
+        const configuredLevel = requestedLevel ?? await getSetting('default_context_depth', 'standard');
+        const level = validLevels.includes(configuredLevel) ? configuredLevel : 'standard';
         if (jsonOutput) {
             // ── JSON mode: structured output for programmatic consumption ──
             const storageBackend = await getStorage();
@@ -136,30 +341,13 @@ program
             }
             const d = data;
             const gitState = getCurrentGitState();
-            const output = {
-                agent_name: agentName || null,
-                handoff: [{
-                        project,
-                        role: effectiveRole || d.role || 'global',
-                        last_summary: d.last_summary || null,
-                        pending_todo: d.pending_todo || null,
-                        active_decisions: d.active_decisions || null,
-                        keywords: d.keywords || null,
-                        key_context: d.key_context || null,
-                        active_branch: d.active_branch || null,
-                        version: d.version ?? null,
-                        updated_at: d.updated_at || null,
-                    }],
-                recent_ledger: (d.recent_sessions || []).map((s) => ({
-                    summary: s.summary || null,
-                    decisions: s.decisions || null,
-                    keywords: s.keywords || null,
-                    created_at: s.session_date || s.created_at || null,
-                })),
-                git_hash: gitState.commitSha ? gitState.commitSha.substring(0, 7) : null,
-                git_branch: gitState.branch || null,
-                pkg_version: SERVER_CONFIG.version,
-            };
+            const output = buildLoadJsonOutput(project, d, level, {
+                agentName,
+                effectiveRole,
+                gitHash: gitState.commitSha ? gitState.commitSha.substring(0, 7) : null,
+                gitBranch: gitState.branch || null,
+                packageVersion: SERVER_CONFIG.version,
+            });
             console.log(JSON.stringify(output, null, 2));
         }
         else {
@@ -167,7 +355,7 @@ program
             // Delegates to the real handler so all enrichments (morning briefing,
             // reality drift, SDM recall, visual memory, skill injection,
             // behavioral warnings, etc.) are included automatically.
-            const result = await sessionLoadContextHandler({ project, level, role });
+            const result = await sessionLoadContextHandler({ project, ...(requestedLevel ? { level: requestedLevel } : {}), role });
             // Surface handler-level errors (e.g. invalid args, storage failures)
             if (result.isError) {
                 console.error(result.content[0]?.text || 'Unknown error loading context');
@@ -646,4 +834,4 @@ program
     if (fail > 0)
         process.exit(1);
 });
-program.parse(process.argv);
+await program.parseAsync(process.argv);

package/dist/config.js

@@ -81,7 +81,8 @@ export const GOOGLE_SEARCH_CX = process.env.GOOGLE_SEARCH_CX;
 //
 // Auto-resolution (PRISM_STORAGE=auto, the default) picks in this order:
 //   1. PRISM_FORCE_LOCAL=true → "local" (override everything)
-//   2. SYNALUX_API_KEY + PRISM_SYNALUX_BASE_URL set → "synalux"
+//   2. Synalux credentials + portal-confirmed cloud-memory entitlement → "synalux"
+//      (portal-confirmed free → "local"; unverifiable entitlement → fail closed)
 //   3. SUPABASE_URL + SUPABASE_KEY set → "supabase" (legacy)
 //   4. else → "local"
 export const PRISM_STORAGE = process.env.PRISM_STORAGE || "auto";
@@ -124,7 +125,9 @@ export const SUPABASE_CONFIGURED = !!SUPABASE_URL &&
 // becomes a thin HTTP client of the synalux portal. This is the paid-tier
 // default. Synalux portal owns project validation, tier gating, audit logs,
 // and hivemind agent coordination.
-export const PRISM_SYNALUX_BASE_URL = sanitizeEnv(process.env.PRISM_SYNALUX_BASE_URL);
+// PRISM_SYNALUX_BASE_URL is canonical. SYNALUX_BASE_URL remains a legacy
+// compatibility alias so every portal client resolves the same origin.
+export const PRISM_SYNALUX_BASE_URL = sanitizeEnv(process.env.PRISM_SYNALUX_BASE_URL || process.env.SYNALUX_BASE_URL);
 export const PRISM_SYNALUX_API_KEY = sanitizeEnv(process.env.PRISM_SYNALUX_API_KEY);
 export const SYNALUX_CONFIGURED = !!PRISM_SYNALUX_BASE_URL &&
     !!PRISM_SYNALUX_API_KEY &&
@@ -263,14 +266,18 @@ export const PRISM_ACTR_BUFFER_FLUSH_MS = parseInt(process.env.PRISM_ACTR_BUFFER
 export const PRISM_ACTR_ACCESS_LOG_RETENTION_DAYS = parseInt(process.env.PRISM_ACTR_ACCESS_LOG_RETENTION_DAYS || "90", 10);
 // ─── v7.1: Task Router Configuration ─────────────────────────
 // Deterministic heuristic-based routing for delegating coding tasks
-// between the host cloud model and the local claw-code-agent.
-// Set PRISM_TASK_ROUTER_ENABLED=true to unlock the session_task_route tool.
+// between the host cloud model and Prism's local worker. Local-first is the
+// default; set PRISM_TASK_ROUTER_ENABLED=false for an explicit operator opt-out.
 /** Master switch for the task router tool. */
-export const PRISM_TASK_ROUTER_ENABLED_ENV = process.env.PRISM_TASK_ROUTER_ENABLED === "true";
+export const PRISM_TASK_ROUTER_ENABLED_ENV = process.env.PRISM_TASK_ROUTER_ENABLED !== "false";
 /** Confidence threshold below which routing defaults to the host model. (Default: 0.6) */
 export const PRISM_TASK_ROUTER_CONFIDENCE_THRESHOLD = parseFloat(process.env.PRISM_TASK_ROUTER_CONFIDENCE_THRESHOLD || "0.6");
-/** Maximum complexity score (1-10) that Claw can handle. Tasks above this → host. (Default: 4) */
-export const PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY = parseInt(process.env.PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY || "4", 10);
+/**
+ * Operator ceiling for bounded local work (1-10). The router independently
+ * rejects architecture, security, tool-heavy, and other host-only work.
+ * Default 10 lets prism_infer select every entitled/RAM-safe local tier.
+ */
+export const PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY = parseInt(process.env.PRISM_TASK_ROUTER_MAX_CLAW_COMPLEXITY || "10", 10);
 // ─── v7.2: Verification Harness ──────────────────────────────
 /** Master switch for the v7.2.0 enhanced verification harness. */
 export const PRISM_VERIFICATION_HARNESS_ENABLED = process.env.PRISM_VERIFICATION_HARNESS_ENABLED === "true";