prism-mcp-server 20.21.11 → 20.21.13

package/README.md

@@ -70,6 +70,13 @@ Prism works locally without an account, API key, or cloud subscription. Add a
 Synalux subscription when you want cloud memory, paid-tier skills, or team
 features.
 
+To check your plan, open **⚙ Account & Settings → Account** in the dashboard.
+Free users see **Start 14-day trial**; paid users see **Manage subscription**.
+During a trial, the same panel shows the paid tier and exact end date. No card
+is required to start. Add payment details before the end date to continue; if
+you do not, the subscription cancels and local Prism Free remains available.
+You can also compare plans directly at [synalux.ai/pricing#prism-plans](https://synalux.ai/pricing#prism-plans).
+
 After a few sessions, ask what it's been worth:
 
 ```bash
@@ -151,6 +158,27 @@ or by re-enabling after each run.
 <details>
 <summary>Release history (optional)</summary>
 
+## What's New in v20.21.13
+
+### Paid plans and trials are clear in Account & Settings
+
+- Free users can open the Prism plan comparison and start a 14-day trial.
+- Trial users see their paid tier, exact end date, and the action to add payment
+  details before automatic cancellation.
+- Active and payment-recovery states lead to the correct hosted billing action;
+  an unavailable verification is labeled instead of being presented as paid.
+- Local Prism Free remains available without an account or subscription.
+
+## What's New in v20.21.12
+
+### Multiple MCP hosts keep a working dashboard link
+
+- Each running Prism host now registers its local dashboard independently.
+- `prism dashboard` and the startup message verify the newest candidates and
+  fall back to an older live dashboard when a newer host stops.
+- Instance cleanup cannot remove another host's registration, and the open
+  message preserves the linked account and plan description.
+
 ## What's New in v20.21.11
 
 ### Linked accounts persist across dashboard refreshes
@@ -1301,7 +1329,11 @@ All on-device models are free to run locally via Ollama on every tier. A subscri
 | Analytics dashboard | -- | ✅ | ✅ | ✅ |
 | HIPAA BAA | -- | -- | -- | ✅ |
 
-14-day free trial on paid plans. 25+ seats: [contact sales](https://synalux.ai/support)
+Paid plans start with a 14-day trial. No card is required to start; add payment
+details before the trial ends to continue, or the subscription cancels
+automatically and local Prism Free remains available. View the exact deadline
+under **⚙ Account & Settings → Account** in `prism dashboard`. 25+ seats:
+[contact sales](https://synalux.ai/support)
 
 ---
 

package/dist/cli.js

@@ -15,7 +15,7 @@ import { runBrowserCli } from './browserCli.js';
 import { filterPrismMemoryContext } from './utils/memoryQuality.js';
 import { isRecoverableStartupStorageError } from './utils/startupRecovery.js';
 import { verifyBehaviorHandler } from './tools/behavioralVerifierHandler.js';
-import { isLocalDashboardRunning, openDashboardUrl, readDashboardAccessState, } from './dashboard/dashboardAccess.js';
+import { dashboardOpenSuccessMessage, findRunningDashboardAccessState, openDashboardUrl, } from './dashboard/dashboardAccess.js';
 const program = new Command();
 /** Build the stable `prism load --json` envelope from depth-specific context. */
 export function buildLoadJsonOutput(project, data, level, metadata) {
@@ -121,16 +121,13 @@ program
     .option('--print', 'Print the current local dashboard link instead of opening a browser')
     .action(async (options) => {
     try {
-        const { url, probeKey } = readDashboardAccessState();
-        if (!(await isLocalDashboardRunning(url, probeKey))) {
-            throw new Error('The recorded Prism dashboard is not running. Restart your connected MCP host first.');
-        }
+        const { url } = await findRunningDashboardAccessState();
         if (options.print) {
             console.log(url);
             return;
         }
         openDashboardUrl(url);
-        console.log('Opened the local Prism Free dashboard. No Synalux account is required.');
+        console.log(dashboardOpenSuccessMessage());
     }
     catch (error) {
         console.error(`Dashboard unavailable: ${error instanceof Error ? error.message : String(error)}`);

package/dist/dashboard/accountRouter.js

@@ -6,6 +6,11 @@ import { upgradeInsecureCloudUrl } from "../utils/secureUrl.js";
 const DEFAULT_PORTAL_URL = "https://synalux.ai";
 const MAX_BODY_BYTES = 16 * 1024;
 const VALID_PLANS = new Set(["free", "standard", "advanced", "enterprise"]);
+const VALID_BILLING_STATUSES = new Set([
+    "free", "trialing", "active", "past_due", "unpaid", "canceled",
+    "incomplete", "incomplete_expired", "paused", "managed", "unknown", "sync_pending",
+]);
+const VALID_PAID_PLANS = new Set(["standard", "advanced", "enterprise"]);
 let accountMutationQueue = Promise.resolve();
 async function serializeAccountMutation(operation) {
     const previous = accountMutationQueue;
@@ -94,7 +99,10 @@ function signedOutAccount(origin) {
         name: null,
         role_key: null,
         plan: "free",
-        billing: { action: "upgrade", url: `${origin}/pricing` },
+        subscription_plan: null,
+        billing_status: "free",
+        trial_ends_at: null,
+        billing: { action: "upgrade", url: `${origin}/pricing#prism-plans` },
         auth_url: authUrl(origin),
     };
 }
@@ -112,13 +120,28 @@ function normalizeAccount(value, origin) {
     const url = typeof billingRaw.url === "string" && isAllowedBillingUrl(billingRaw.url, origin)
         ? billingRaw.url
         : null;
+    const rawBillingStatus = typeof raw.billing_status === "string" && VALID_BILLING_STATUSES.has(raw.billing_status)
+        ? raw.billing_status
+        : plan === "free" ? "free" : "unknown";
+    const subscriptionPlan = typeof raw.subscription_plan === "string" && VALID_PAID_PLANS.has(raw.subscription_plan)
+        ? raw.subscription_plan
+        : null;
+    const billingStatus = rawBillingStatus === "sync_pending" && subscriptionPlan === null
+        ? "unknown"
+        : rawBillingStatus;
+    const trialEndsAt = typeof raw.trial_ends_at === "string" && Number.isFinite(Date.parse(raw.trial_ends_at))
+        ? new Date(raw.trial_ends_at).toISOString()
+        : null;
     return {
         signed_in: raw.signed_in === true,
         configured: true,
         name: typeof raw.name === "string" ? raw.name.slice(0, 160) : null,
         role_key: typeof raw.role_key === "string" ? raw.role_key.slice(0, 80) : null,
         plan: plan,
+        subscription_plan: subscriptionPlan,
         plan_source: raw.plan_source === "managed" ? "managed" : "stripe",
+        billing_status: billingStatus,
+        trial_ends_at: billingStatus === "trialing" || billingStatus === "sync_pending" ? trialEndsAt : null,
         billing: { action, url },
         auth_url: authUrl(origin),
     };
@@ -230,7 +253,7 @@ export async function openDashboardBilling(overrides = {}) {
     const deps = { ...defaultDeps, ...overrides };
     const origin = await portalOrigin(deps);
     if (await applyStoredSignOut(deps) || !deps.usablePortalKey()) {
-        return { url: `${origin}/pricing`, action: "upgrade" };
+        return { url: `${origin}/pricing#prism-plans`, action: "upgrade" };
     }
     let jwt = await deps.getJwt();
     if (!jwt || isSynaluxSignedOut())

package/dist/dashboard/dashboardAccess.js

@@ -1,14 +1,19 @@
 import { spawnSync } from "node:child_process";
-import { chmodSync, closeSync, constants as fsConstants, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, constants as fsConstants, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { createDashboardProbeRequest, DASHBOARD_PROBE_PATH, generateDashboardProbeKey, validateDashboardProbeKey, verifyDashboardProbeResponse, } from "./dashboardProbe.js";
 const DASHBOARD_URL_FILE = "dashboard.url";
+const DASHBOARD_REGISTRY_DIRECTORY = "dashboard-instances";
 const MAX_DASHBOARD_URL_BYTES = 4096;
+const DASHBOARD_INSTANCE_ID = /^[a-f0-9]{32}$/;
 export function dashboardAccessUrlPath(home = homedir()) {
     return join(home, ".prism-mcp", DASHBOARD_URL_FILE);
 }
+export function dashboardAccessRegistryPath(home = homedir()) {
+    return join(home, ".prism-mcp", DASHBOARD_REGISTRY_DIRECTORY);
+}
 function dashboardAccessDirectory(home) {
     const directory = join(home, ".prism-mcp");
     mkdirSync(directory, { recursive: true, mode: 0o700 });
@@ -20,6 +25,18 @@ function dashboardAccessDirectory(home) {
         chmodSync(directory, 0o700);
     return directory;
 }
+function dashboardRegistryDirectory(home) {
+    dashboardAccessDirectory(home);
+    const directory = dashboardAccessRegistryPath(home);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const stat = lstatSync(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new Error("Local dashboard registry is not a regular directory");
+    }
+    if (process.platform !== "win32")
+        chmodSync(directory, 0o700);
+    return directory;
+}
 function validateDashboardUrl(raw) {
     const value = raw.trim();
     if (!value || Buffer.byteLength(value, "utf8") > MAX_DASHBOARD_URL_BYTES) {
@@ -49,22 +66,11 @@ function validateDashboardUrl(raw) {
     }
     return parsed.toString();
 }
-/**
- * Persist the current local dashboard link for the `prism dashboard` command.
- * The token is a localhost capability, so the file is owner-only and symlinks
- * present at validation time are rejected rather than followed. This is not a
- * boundary against another process running as the same OS user: that process
- * can already read or replace owner-only Prism state.
- */
-export function writeDashboardAccessUrl(url, home = homedir(), probeKey = generateDashboardProbeKey()) {
-    const validated = validateDashboardUrl(url);
-    const validatedProbeKey = validateDashboardProbeKey(probeKey);
-    const directory = dashboardAccessDirectory(home);
-    const filePath = dashboardAccessUrlPath(home);
+function writeOwnerOnlyJson(filePath, directory, value, label) {
     try {
         const existing = lstatSync(filePath);
         if (!existing.isFile() || existing.isSymbolicLink()) {
-            throw new Error("Local dashboard link path is not a regular file");
+            throw new Error(`${label} path is not a regular file`);
         }
     }
     catch (error) {
@@ -77,14 +83,14 @@ export function writeDashboardAccessUrl(url, home = homedir(), probeKey = genera
     // symlink cannot redirect the token write even on platforms without
     // O_NOFOLLOW. The containing directory follows the same-OS-user trust model
     // documented above.
-    const tempPath = join(directory, `.${DASHBOARD_URL_FILE}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+    const tempPath = join(directory, `.${basename(filePath)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
     const noFollow = process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW;
     const fd = openSync(tempPath, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | noFollow, 0o600);
     let tempExists = true;
     try {
         if (process.platform !== "win32")
             fchmodSync(fd, 0o600);
-        writeFileSync(fd, `${JSON.stringify({ version: 1, url: validated, probe_key: validatedProbeKey })}\n`, "utf8");
+        writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
     }
     finally {
         closeSync(fd);
@@ -105,9 +111,7 @@ export function writeDashboardAccessUrl(url, home = homedir(), probeKey = genera
     }
     return filePath;
 }
-export function readDashboardAccessState(home = homedir()) {
-    dashboardAccessDirectory(home);
-    const filePath = dashboardAccessUrlPath(home);
+function readOwnerOnlyJson(filePath, label, missingMessage) {
     const noFollow = process.platform === "win32" ? 0 : fsConstants.O_NOFOLLOW;
     let fd;
     try {
@@ -115,11 +119,10 @@ export function readDashboardAccessState(home = homedir()) {
     }
     catch (error) {
         const code = error.code;
-        if (code === "ENOENT") {
-            throw new Error("No current local dashboard link. Restart your connected MCP host first.");
-        }
+        if (code === "ENOENT" && missingMessage)
+            throw new Error(missingMessage);
         if (code === "ELOOP")
-            throw new Error("Local dashboard link path is not a regular file");
+            throw new Error(`${label} path is not a regular file`);
         throw error;
     }
     try {
@@ -129,40 +132,215 @@ export function readDashboardAccessState(home = homedir()) {
         // race on POSIX without broadening the same-OS-user trust boundary.
         const stat = fstatSync(fd);
         if (!stat.isFile())
-            throw new Error("Local dashboard link path is not a regular file");
+            throw new Error(`${label} path is not a regular file`);
         if (process.platform !== "win32" && (stat.mode & 0o077) !== 0) {
-            throw new Error("Local dashboard link file permissions are unsafe");
+            throw new Error(`${label} file permissions are unsafe`);
         }
         const raw = readFileSync(fd, "utf8");
         if (!raw || Buffer.byteLength(raw, "utf8") > MAX_DASHBOARD_URL_BYTES) {
-            throw new Error("Local dashboard link is missing or invalid");
+            throw new Error(`${label} is missing or invalid`);
         }
-        let parsed;
         try {
-            parsed = JSON.parse(raw);
+            return JSON.parse(raw);
         }
         catch {
-            throw new Error("Local dashboard link is invalid");
-        }
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            throw new Error("Local dashboard link is invalid");
-        }
-        const state = parsed;
-        if (state.version !== 1 || typeof state.url !== "string" || typeof state.probe_key !== "string") {
-            throw new Error("Local dashboard link is invalid");
+            throw new Error(`${label} is invalid`);
         }
-        return {
-            url: validateDashboardUrl(state.url),
-            probeKey: validateDashboardProbeKey(state.probe_key),
-        };
     }
     finally {
         closeSync(fd);
     }
 }
+function parseDashboardAccessState(parsed, label) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${label} is invalid`);
+    }
+    const state = parsed;
+    if (state.version !== 1 || typeof state.url !== "string" || typeof state.probe_key !== "string") {
+        throw new Error(`${label} is invalid`);
+    }
+    return {
+        url: validateDashboardUrl(state.url),
+        probeKey: validateDashboardProbeKey(state.probe_key),
+    };
+}
+/**
+ * Persist the latest local dashboard link for older Prism clients. Current
+ * clients discover live dashboards from the per-instance registry below.
+ * The token is a localhost capability, so the file is owner-only and symlinks
+ * present at validation time are rejected rather than followed. This is not a
+ * boundary against another process running as the same OS user: that process
+ * can already read or replace owner-only Prism state.
+ */
+export function writeDashboardAccessUrl(url, home = homedir(), probeKey = generateDashboardProbeKey()) {
+    const validated = validateDashboardUrl(url);
+    const validatedProbeKey = validateDashboardProbeKey(probeKey);
+    const directory = dashboardAccessDirectory(home);
+    return writeOwnerOnlyJson(dashboardAccessUrlPath(home), directory, { version: 1, url: validated, probe_key: validatedProbeKey }, "Local dashboard link");
+}
+export function readDashboardAccessState(home = homedir()) {
+    dashboardAccessDirectory(home);
+    return parseDashboardAccessState(readOwnerOnlyJson(dashboardAccessUrlPath(home), "Local dashboard link", "No current local dashboard link. Restart your connected MCP host first."), "Local dashboard link");
+}
 export function readDashboardAccessUrl(home = homedir()) {
     return readDashboardAccessState(home).url;
 }
+function validateDashboardInstanceId(value) {
+    if (!DASHBOARD_INSTANCE_ID.test(value)) {
+        throw new Error("Local dashboard instance ID is invalid");
+    }
+    return value;
+}
+function validateRegistrationInteger(value, label, allowZero = false) {
+    if (!Number.isSafeInteger(value) || (allowZero ? value < 0 : value < 1)) {
+        throw new Error(`Local dashboard ${label} is invalid`);
+    }
+    return value;
+}
+function parseDashboardAccessRecord(parsed, recordPath, expectedInstanceId) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Local dashboard registry record is invalid");
+    }
+    const record = parsed;
+    if (record.version !== 1 ||
+        typeof record.instance_id !== "string" ||
+        typeof record.pid !== "number" ||
+        typeof record.registered_at_ms !== "number" ||
+        typeof record.url !== "string" ||
+        typeof record.probe_key !== "string") {
+        throw new Error("Local dashboard registry record is invalid");
+    }
+    const instanceId = validateDashboardInstanceId(record.instance_id);
+    if (instanceId !== expectedInstanceId) {
+        throw new Error("Local dashboard registry record is invalid");
+    }
+    return {
+        instanceId,
+        pid: validateRegistrationInteger(record.pid, "process ID"),
+        registeredAtMs: validateRegistrationInteger(record.registered_at_ms, "registration time", true),
+        url: validateDashboardUrl(record.url),
+        probeKey: validateDashboardProbeKey(record.probe_key),
+        recordPath,
+    };
+}
+function readDashboardAccessRecord(recordPath, instanceId) {
+    return parseDashboardAccessRecord(readOwnerOnlyJson(recordPath, "Local dashboard registry record"), recordPath, instanceId);
+}
+function unregisterDashboardAccessRecord(record) {
+    let current;
+    try {
+        current = readDashboardAccessRecord(record.recordPath, record.instanceId);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        return;
+    }
+    if (current.pid !== record.pid ||
+        current.registeredAtMs !== record.registeredAtMs ||
+        current.url !== record.url ||
+        current.probeKey !== record.probeKey) {
+        return;
+    }
+    try {
+        unlinkSync(record.recordPath);
+    }
+    catch {
+        // Best effort: an unreadable registry must not block another live instance.
+    }
+}
+function isDashboardProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM proves the process exists but is owned by a different principal.
+        return error.code === "EPERM";
+    }
+}
+/** Register one running dashboard without replacing records for other hosts. */
+export function registerDashboardAccessUrl(url, home = homedir(), probeKey = generateDashboardProbeKey(), options = {}) {
+    const validatedUrl = validateDashboardUrl(url);
+    const validatedProbeKey = validateDashboardProbeKey(probeKey);
+    const instanceId = validateDashboardInstanceId(options.instanceId ?? randomBytes(16).toString("hex"));
+    const pid = validateRegistrationInteger(options.pid ?? process.pid, "process ID");
+    const registeredAtMs = validateRegistrationInteger(options.registeredAtMs ?? Date.now(), "registration time", true);
+    // Preserve the singleton file for clients released before the registry.
+    writeDashboardAccessUrl(validatedUrl, home, validatedProbeKey);
+    const directory = dashboardRegistryDirectory(home);
+    const recordPath = join(directory, `${instanceId}.json`);
+    const record = {
+        instanceId,
+        pid,
+        registeredAtMs,
+        url: validatedUrl,
+        probeKey: validatedProbeKey,
+        recordPath,
+    };
+    writeOwnerOnlyJson(recordPath, directory, {
+        version: 1,
+        instance_id: instanceId,
+        pid,
+        registered_at_ms: registeredAtMs,
+        url: validatedUrl,
+        probe_key: validatedProbeKey,
+    }, "Local dashboard registry record");
+    return {
+        recordPath,
+        state: { url: validatedUrl, probeKey: validatedProbeKey },
+        unregister: () => unregisterDashboardAccessRecord(record),
+    };
+}
+function readDashboardAccessRecords(home) {
+    const directory = dashboardRegistryDirectory(home);
+    const records = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const match = /^([a-f0-9]{32})\.json$/.exec(entry.name);
+        if (!match || !entry.isFile() || entry.isSymbolicLink())
+            continue;
+        try {
+            records.push(readDashboardAccessRecord(join(directory, entry.name), match[1]));
+        }
+        catch {
+            // A malformed or unsafe record can never become a dashboard capability.
+        }
+    }
+    return records.sort((left, right) => right.registeredAtMs - left.registeredAtMs || right.instanceId.localeCompare(left.instanceId));
+}
+/**
+ * Return the newest cryptographically verified dashboard that is still alive.
+ * Dead registry entries are removed one at a time; a surviving instance is
+ * never deleted just because a newer process stopped.
+ */
+export async function findRunningDashboardAccessState(home = homedir(), fetcher = fetch) {
+    const records = readDashboardAccessRecords(home);
+    const probed = new Set();
+    for (const record of records) {
+        const key = `${record.url}\n${record.probeKey}`;
+        probed.add(key);
+        if (await isLocalDashboardRunning(record.url, record.probeKey, fetcher)) {
+            return { url: record.url, probeKey: record.probeKey };
+        }
+        // One timeout is not proof that a live host is dead. Remove the record only
+        // when the owning PID is also gone; otherwise preserve it for a later retry.
+        if (!isDashboardProcessAlive(record.pid))
+            unregisterDashboardAccessRecord(record);
+    }
+    // A singleton-only record was written by Prism versions before this registry.
+    try {
+        const legacy = readDashboardAccessState(home);
+        const key = `${legacy.url}\n${legacy.probeKey}`;
+        if (!probed.has(key) && await isLocalDashboardRunning(legacy.url, legacy.probeKey, fetcher)) {
+            return legacy;
+        }
+    }
+    catch (error) {
+        if (records.length === 0)
+            throw error;
+    }
+    throw new Error("No registered Prism dashboard is running. Restart your connected MCP host first.");
+}
 export async function isLocalDashboardRunning(dashboardUrl, probeKey, fetcher = fetch) {
     const validated = validateDashboardUrl(dashboardUrl);
     const challenge = createDashboardProbeRequest(probeKey);
@@ -190,6 +368,9 @@ export async function isLocalDashboardRunning(dashboardUrl, probeKey, fetcher =
         return false;
     }
 }
+export function dashboardOpenSuccessMessage() {
+    return "Opened the current local Prism dashboard in your default browser. Your Synalux account and plan are unchanged.";
+}
 export function dashboardOpenCommand(url, platform = process.platform) {
     const validated = validateDashboardUrl(url);
     if (platform === "darwin")

package/dist/dashboard/server.js

@@ -26,7 +26,7 @@ import { activeStorageBackend } from "../storage/index.js";
 import { readDashboardLedger } from "./ledgerReader.js";
 import { PRISM_USER_ID, SERVER_CONFIG } from "../config.js";
 import { renderDashboardHTML, renderDashboardLocalOpenHTML } from "./ui.js";
-import { writeDashboardAccessUrl } from "./dashboardAccess.js";
+import { registerDashboardAccessUrl } from "./dashboardAccess.js";
 import { createDashboardProbeResponse, DASHBOARD_PROBE_PATH, generateDashboardProbeKey, verifyDashboardProbeRequest, } from "./dashboardProbe.js";
 import { computeIntentHealth } from "./intentHealth.js";
 import { getAllSettings, setSetting, getSetting, getSettingSync } from "../storage/configStorage.js";
@@ -1488,7 +1488,13 @@ self.addEventListener('message', (e) => {
         // Non-fatal — just means the user has to know the port
     }
     try {
-        writeDashboardAccessUrl(dashboardUrl, os.homedir(), DASHBOARD_PROBE_KEY);
+        const registration = registerDashboardAccessUrl(dashboardUrl, os.homedir(), DASHBOARD_PROBE_KEY);
+        const unregister = registration.unregister;
+        httpServer.once("close", () => {
+            unregister();
+            process.removeListener("exit", unregister);
+        });
+        process.once("exit", unregister);
     }
     catch (error) {
         console.error(`[Dashboard] Could not save local opener link: ${error instanceof Error ? error.message : String(error)}`);

package/dist/dashboard/ui.js

@@ -449,6 +449,8 @@ export function renderDashboardHTML(version) {
     .identity-chip .role-icon { font-size: 0.9rem; }
     .identity-chip .identity-label { max-width: 120px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
     .identity-chip .plan-mini { font-size: 0.58rem; letter-spacing: 0.06em; text-transform: uppercase; color: var(--accent-green); }
+    .identity-chip .plan-mini.trial { color: var(--accent-amber); }
+    .identity-chip .plan-mini.attention { color: #fb7185; }
     .main-tabs { overflow-x: auto; scrollbar-width: thin; }
     .main-tabs .s-tab { flex: 0 0 auto; }
     /* Settings modal tab bar */
@@ -549,6 +551,8 @@ export function renderDashboardHTML(version) {
     }
     .account-badge.role { color: var(--accent-cyan); background: rgba(6,182,212,0.1); border-color: rgba(6,182,212,0.22); }
     .account-badge.managed { color: var(--accent-amber); background: rgba(245,158,11,0.1); border-color: rgba(245,158,11,0.22); }
+    .account-badge.trial { color: var(--accent-green); background: rgba(34,197,94,0.1); border-color: rgba(34,197,94,0.3); }
+    .account-badge.attention { color: #fb7185; background: rgba(244,63,94,0.1); border-color: rgba(244,63,94,0.3); }
     .account-name { font-size: 1.35rem; line-height: 1.2; font-weight: 700; color: var(--text-primary); }
     .account-summary { margin-top: 0.45rem; color: var(--text-secondary); font-size: 0.82rem; line-height: 1.55; max-width: 540px; }
     .account-actions { display: flex; flex-wrap: wrap; gap: 0.65rem; margin-top: 1rem; }
@@ -2118,6 +2122,49 @@ function accountPlanSummary(plan) {
     };
     return summaries[plan] || summaries.free;
 }
+function accountTrialEndLabel(value) {
+    if (!value) return '';
+    var date = new Date(value);
+    if (isNaN(date.getTime())) return '';
+    return date.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+}
+function accountBillingBadge(account) {
+    if (account.billing_status === 'trialing') return '<span class="account-badge trial">Trial active</span>';
+    if (account.billing_status === 'sync_pending') return '<span class="account-badge attention">Access update pending</span>';
+    if (['past_due', 'unpaid', 'incomplete', 'paused'].indexOf(account.billing_status) >= 0) {
+        return '<span class="account-badge attention">Payment needs attention</span>';
+    }
+    if (account.billing_status === 'unknown') return '<span class="account-badge attention">Billing status unavailable</span>';
+    if (account.billing_status === 'active') return '<span class="account-badge trial">Paid</span>';
+    return '';
+}
+function accountSubscriptionSummary(account) {
+    if (account.billing_status === 'trialing') {
+        var end = accountTrialEndLabel(account.trial_ends_at);
+        return accountPlanLabel(account.plan) + ' trial is active' + (end ? ' through ' + end : '') +
+            '. Add payment details before the trial ends to continue; otherwise it cancels automatically.';
+    }
+    if (['past_due', 'unpaid', 'incomplete', 'paused'].indexOf(account.billing_status) >= 0) {
+        var billedPlan = account.subscription_plan
+            ? accountPlanLabel(account.subscription_plan) + ' plan'
+            : account.plan === 'free' ? 'paid subscription' : accountPlanLabel(account.plan) + ' plan';
+        return 'Your ' + billedPlan + ' needs billing attention. Update payment details to restore or keep cloud features active.';
+    }
+    if (account.billing_status === 'sync_pending') {
+        var syncingPlan = accountPlanLabel(account.subscription_plan || account.plan);
+        var syncTrialEnd = accountTrialEndLabel(account.trial_ends_at);
+        return 'Stripe confirms your ' + syncingPlan + ' subscription' +
+            (syncTrialEnd ? ' with a trial through ' + syncTrialEnd : '') +
+            '. Synalux is updating access; current access remains ' + accountPlanLabel(account.plan) + '. Retry shortly or manage the subscription.';
+    }
+    if (account.billing_status === 'canceled' || account.billing_status === 'incomplete_expired') {
+        return 'This paid subscription is no longer active. Local Prism Free remains available.';
+    }
+    if (account.billing_status === 'unknown') {
+        return 'Prism could not verify the current trial or payment status. Open billing to review the subscription; local features remain available.';
+    }
+    return accountPlanSummary(account.plan);
+}
 function renderPlanLadder(plan) {
     var tiers = [
         ['free', 'Free', 'Local'],
@@ -2132,14 +2179,29 @@ function renderPlanLadder(plan) {
 }
 function renderAccountChip(account, error) {
     var chip = document.getElementById('identityChip');
+    var planStatus;
+    var planStatusClass;
     if (!chip)
         return;
     if (error) {
         chip.innerHTML = '<span class="role-icon">⚠️</span><span class="identity-label">Account</span>';
     }
     else if (account && account.signed_in) {
+        planStatus = account.billing_status === 'sync_pending'
+            ? accountPlanLabel(account.subscription_plan || account.plan) + ' syncing'
+            : account.billing_status === 'trialing' ? ' trial' :
+            ['past_due', 'unpaid', 'incomplete', 'paused'].indexOf(account.billing_status) >= 0
+                ? (account.plan === 'free' ? 'Payment due' : ' payment due') :
+                account.billing_status === 'unknown' ? ' status unavailable' : '';
+        planStatusClass = account.billing_status === 'trialing' ? ' trial' :
+            ['past_due', 'unpaid', 'incomplete', 'paused', 'unknown', 'sync_pending'].indexOf(account.billing_status) >= 0 ? ' attention' : '';
+        var chipPlanLabel = account.billing_status === 'sync_pending'
+            ? planStatus
+            : account.plan === 'free' && planStatus === 'Payment due'
+                ? planStatus
+                : accountPlanLabel(account.plan) + planStatus;
         chip.innerHTML = '<span class="role-icon">🤖</span><span class="identity-label">' + escapeHtml(account.name || 'Synalux user') + '</span>' +
-            '<span class="plan-mini">' + escapeHtml(accountPlanLabel(account.plan)) + '</span>';
+            '<span class="plan-mini' + planStatusClass + '">' + escapeHtml(chipPlanLabel) + '</span>';
     }
     else {
         chip.innerHTML = '<span class="role-icon">🆓</span><span class="identity-label">Free</span>';
@@ -2180,14 +2242,17 @@ function renderAccountPanel(account, error) {
         return;
     }
     role = account.role_key || 'user';
-    billingLabel = account.billing && account.billing.action === 'manage' ? 'Manage subscription' :
-        account.billing && account.billing.action === 'included' ? 'View plans' : 'Upgrade plan';
+    billingLabel = account.billing_status === 'trialing' ? 'Add payment details' :
+        account.billing_status === 'sync_pending' ? 'Manage subscription' :
+        ['past_due', 'unpaid', 'incomplete', 'paused'].indexOf(account.billing_status) >= 0 ? 'Update payment details' :
+        account.billing && account.billing.action === 'manage' ? 'Manage subscription' :
+        account.billing && account.billing.action === 'included' ? 'View plans' : 'Start 14-day trial';
     managedBadge = account.plan_source === 'managed' ? '<span class="account-badge managed">Managed</span>' : '';
     panel.innerHTML = '<div class="account-card"><div class="account-card-head"><div>' +
         '<div class="account-badges"><span class="account-badge">' + escapeHtml(accountPlanLabel(account.plan)) + '</span>' +
-        '<span class="account-badge role">' + escapeHtml(role) + '</span>' + managedBadge + '</div>' +
+        '<span class="account-badge role">' + escapeHtml(role) + '</span>' + managedBadge + accountBillingBadge(account) + '</div>' +
         '<div class="account-name">' + escapeHtml(account.name || 'Synalux user') + '</div>' +
-        '<div class="account-summary">' + accountPlanSummary(account.plan) + '</div></div></div>' +
+        '<div class="account-summary">' + escapeHtml(accountSubscriptionSummary(account)) + '</div></div></div>' +
         '<div class="account-actions"><button class="account-action" id="accountBillingButton" onclick="openAccountBilling()">' + billingLabel + '</button>' +
         '<button class="account-action danger" id="accountSignOutButton" onclick="signOutAccount()">Sign out</button></div>' +
         '<div class="account-status" id="accountStatus"></div></div>' + renderPlanLadder(account.plan);

package/dist/tools/ledgerHandlers.js

@@ -36,6 +36,7 @@ import { renderFloorDigestBlock, skillDigestFromSource, splitSkillFrontmatter }
 import { mergeHandoff, dbToHandoffSchema, sanitizeForMerge } from "../utils/crdtMerge.js";
 import { resolveProject } from "../utils/projectResolver.js";
 import { getUpdateNotice } from "../updateNotice.js";
+import { findRunningDashboardAccessState } from "../dashboard/dashboardAccess.js";
 // The running server's own version, for the update-available notice. A read
 // failure must never affect startup: an empty string fails the notice's
 // semver gate, so no notice renders rather than a bogus "running 0.0.0".
@@ -610,14 +611,29 @@ function freeTierUpgradeLine(tier) {
  * a private localhost capability, so startup advertises the local CLI opener
  * rather than copying that link into agent context.
  */
-async function readDashboardUrl() {
+export async function readDashboardUrlForStartup(home = os.homedir()) {
+    const explicitPort = (process.env.PRISM_DASHBOARD_PORT || "").trim();
+    // Current Prism versions keep one signed record per dashboard instance. The
+    // newest record may belong to a host that just stopped, so use the same
+    // verified fallback selection as `prism dashboard` before consulting legacy
+    // singleton state. An explicit port remains authoritative for this process.
+    if (!explicitPort) {
+        try {
+            const state = await findRunningDashboardAccessState(home);
+            return new URL(state.url).origin;
+        }
+        catch {
+            // Continue into the legacy port probe for older installations and the
+            // startup instant before this process has written its registry record.
+        }
+    }
     // Precedence: explicit env override > recorded port file > default. The
     // file is written by whatever dashboard ran last and persists across boots,
     // so it must never outrank configuration the operator set for THIS process.
-    let port = (process.env.PRISM_DASHBOARD_PORT || "").trim();
+    let port = explicitPort;
     if (!port) {
         try {
-            const recorded = fs.readFileSync(nodePath.join(os.homedir(), ".prism-mcp", "dashboard.port"), "utf8").trim();
+            const recorded = fs.readFileSync(nodePath.join(home, ".prism-mcp", "dashboard.port"), "utf8").trim();
             if (/^\d{2,5}$/.test(recorded))
                 port = recorded;
         }
@@ -2338,7 +2354,7 @@ export async function sessionBootstrapHandler(args = {}, options = {}) {
         ? greeting
         : `${greeting}\n\n${identityBlock}${updateNotice ? `\n${updateNotice}` : ""}`;
     if (projects.length === 0) {
-        const dashboardUrl = await readDashboardUrl();
+        const dashboardUrl = await readDashboardUrlForStartup();
         const dashboardLine = dashboardUrl
             ? `- 🎛️ **Dashboard:** run \`prism dashboard\` — opens locally with no Synalux account required`
             : `- 🎛️ **Dashboard:** not running — start Prism's dashboard to configure projects, identity, and context depth`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.21.11",
+  "version": "20.21.13",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Persistent session memory for AI coding agents that never leaves your machine — including the on-device model that reasons over it. Restores your prior decisions, open TODOs, and changed files across sessions; adds associative recall of related past work, semantic drift detection, and local inference. Local-first by default. Works with Claude Code, Cursor, and Codex.",
   "module": "index.ts",