myagentmemory 0.4.16 → 0.4.17

package/dist/plugin-service.js

@@ -18,29 +18,27 @@ const MISSING_ENTITLEMENT = {
     state: "missing",
     features: [],
     capabilities: {},
-    reason: "Enter an email address to activate the free daily session allowance",
+    reason: "Install the no-account Pro preview to activate local recall and learning",
 };
 function cloneEntitlement(value) {
     return structuredClone(value);
 }
-function freeEntitlement(dailySessionLimit) {
+function freeEntitlement() {
     return {
         plan: "free",
         state: "active",
         features: ["session-intelligence", "web-console"],
         capabilities: {
             "session-index": { enabled: true },
-            "session-worker": {
-                enabled: true,
-                quota: { limit: dailySessionLimit, window: "day", scope: "account" },
-            },
-            learning: { enabled: true },
+            recall: { enabled: true, quota: { limit: 10, window: "day", scope: "device" } },
+            "session-worker": { enabled: false },
+            learning: { enabled: true, quota: { limit: 1, window: "day", scope: "device" } },
             "retrieval-evaluation": { enabled: true },
             "operational-metrics": { enabled: true },
             "web-console": { enabled: true },
             "memory-explorer": { enabled: true },
         },
-        reason: `${dailySessionLimit} free agent sessions per UTC day`,
+        reason: "Free preview: 10 recalls and 1 learning scan per local day; indexing and dashboard access remain available",
     };
 }
 function isEmail(value) {
@@ -346,41 +344,27 @@ export class TemporaryPluginBackend {
         this.artifactOrigin = options.artifactOrigin ?? ARTIFACT_ORIGIN;
         this.fetchImplementation = options.fetch ?? globalThis.fetch;
         this.openUrl = options.openUrl ?? openLoopbackUrl;
-        this.activate = options.activate ?? (() => collectTemporaryActivation(this.openUrl));
+        this.activate = options.activate ?? (async () => `am_install_${randomBytes(24).toString("base64url")}`);
     }
     async getLocalEntitlement() {
         const activation = this.readActivation();
-        return activation ? freeEntitlement(activation.dailySessionLimit) : cloneEntitlement(MISSING_ENTITLEMENT);
+        return activation ? freeEntitlement() : cloneEntitlement(MISSING_ENTITLEMENT);
     }
     async resolveAccess(request) {
         const activation = this.readActivation();
-        let email = activation?.email;
-        if (!email) {
-            if (!request.allowAuthentication)
-                return {
-                    kind: "auth_required",
-                    entitlement: cloneEntitlement(MISSING_ENTITLEMENT),
-                    nextAction: {
-                        kind: "authenticate",
-                        url: "https://jayzeng.github.io/agentmemory/",
-                        message: "Run plugin install in an interactive terminal to enter an email address",
-                    },
-                };
-            email = await this.activate();
-        }
+        const installationId = activation?.installationId ?? (await this.activate());
         const response = await this.request(`${this.apiOrigin}/v1/plugin/access`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
-                schemaVersion: 1,
-                email,
+                schemaVersion: 2,
+                installationId,
                 bundleId: request.bundleId,
                 installedVersion: request.installedVersion ?? null,
                 coreVersion: this.coreVersion,
                 channel: request.channel,
                 platform: process.platform,
                 architecture: process.arch,
-                consentVersion: "activation-v2",
             }),
         });
         const value = (await readJson(response));
@@ -389,14 +373,20 @@ export class TemporaryPluginBackend {
             throw new PluginBootstrapFailure("service_response_invalid", "The access response omitted its artifact grant");
         if (typeof value.usageCredential !== "string" || !ACTIVATION_CREDENTIAL.test(value.usageCredential))
             throw new PluginBootstrapFailure("service_response_invalid", "The access response omitted its usage credential");
-        const freeQuota = value.entitlement.capabilities["session-worker"]?.quota;
+        const recallQuota = value.entitlement.capabilities.recall?.quota;
+        const learningQuota = value.entitlement.capabilities.learning?.quota;
         if (value.entitlement.plan !== "free" ||
             value.entitlement.state !== "active" ||
-            !freeQuota ||
-            freeQuota.scope !== "account" ||
-            freeQuota.window !== "day")
-            throw new PluginBootstrapFailure("service_response_invalid", "The free session policy is invalid");
-        this.writeActivation(email, value.usageCredential, freeQuota.limit);
+            !recallQuota ||
+            recallQuota.scope !== "device" ||
+            recallQuota.window !== "day" ||
+            !learningQuota ||
+            learningQuota.scope !== "device" ||
+            learningQuota.window !== "day" ||
+            value.entitlement.capabilities["session-index"]?.enabled !== true ||
+            value.entitlement.capabilities["web-console"]?.enabled !== true)
+            throw new PluginBootstrapFailure("service_response_invalid", "The free preview policy is invalid");
+        this.writeActivation(installationId, value.usageCredential, 1);
         return { kind: "granted", entitlement: value.entitlement, artifactGrant: value.artifactGrant };
     }
     async reserveSession(operationId) {
@@ -451,8 +441,9 @@ export class TemporaryPluginBackend {
             if (!stat.isFile() || stat.isSymbolicLink() || (process.platform !== "win32" && (stat.mode & 0o077) !== 0))
                 return null;
             const value = JSON.parse(fs.readFileSync(activationPath, "utf-8"));
-            if (value.schemaVersion !== 2 ||
-                !isEmail(value.email) ||
+            if (value.schemaVersion !== 3 ||
+                typeof value.installationId !== "string" ||
+                !/^am_install_[A-Za-z0-9_-]{32}$/.test(value.installationId) ||
                 !Number.isFinite(Date.parse(value.activatedAt)) ||
                 !ACTIVATION_CREDENTIAL.test(value.usageCredential) ||
                 !Number.isSafeInteger(value.dailySessionLimit) ||
@@ -465,9 +456,9 @@ export class TemporaryPluginBackend {
             return null;
         }
     }
-    writeActivation(email, usageCredential, dailySessionLimit) {
-        if (!isEmail(email))
-            throw new PluginBootstrapFailure("email_invalid", "Enter a valid email address");
+    writeActivation(installationId, usageCredential, dailySessionLimit) {
+        if (!/^am_install_[A-Za-z0-9_-]{32}$/.test(installationId))
+            throw new PluginBootstrapFailure("activation_failed", "The installation identifier is invalid");
         if (!ACTIVATION_CREDENTIAL.test(usageCredential))
             throw new PluginBootstrapFailure("activation_failed", "The activation credential is invalid");
         if (!Number.isSafeInteger(dailySessionLimit) || dailySessionLimit <= 0 || dailySessionLimit > 10_000)
@@ -484,7 +475,13 @@ export class TemporaryPluginBackend {
         if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink())
             throw new PluginBootstrapFailure("activation_path_invalid", "The plugin activation directory is unsafe");
         const temporary = `${target}.tmp-${process.pid}-${randomUUID()}`;
-        fs.writeFileSync(temporary, `${JSON.stringify({ schemaVersion: 2, email, activatedAt: new Date().toISOString(), usageCredential, dailySessionLimit }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        fs.writeFileSync(temporary, `${JSON.stringify({
+            schemaVersion: 3,
+            installationId,
+            activatedAt: new Date().toISOString(),
+            usageCredential,
+            dailySessionLimit,
+        }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
         fs.renameSync(temporary, target);
     }
     async sessionUsage(action, operationId) {

package/docs/official-plugin-bootstrap.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Accepted design on 2026-08-16 and revised on 2026-08-17. The public core implements host types, loopback email activation, live catalog and artifact retrieval, Ed25519 release verification, bounded package validation, transactional install, bundle health checks, paid-command dispatch, and SessionStart hook dispatch. The free plan grants a configurable number of agent sessions per normalized email and UTC day; durable account authentication, payment, renewal, and account management remain deferred.
+Accepted design on 2026-08-16 and revised on 2026-08-17. The public core implements host types, anonymous preview activation, live catalog and artifact retrieval, Ed25519 release verification, bounded package validation, transactional install, bundle health checks, paid-command dispatch, and SessionStart hook dispatch. The free preview grants 10 device-local recalls and one device-local learning scan per local day while keeping indexing and Memory Dashboard visibility available. Account authentication, payment, renewal, and account management remain deferred.
 
 The public `agentmemory` repository and `myagentmemory` npm package remain the free, MIT-licensed core. The public bootstrap client and host contracts are also MIT-licensed. Official commercial implementations and browser assets are built and distributed separately from the private `agent-memory-plugin` workspace under their own terms. Pricing, the billing provider, device limits, offline-grace duration, and Enterprise contract terms are intentionally not decided here. The temporary beta currently uses allowlisted `*.agentmemory.paperpilot.me` service origins; changing those origins is a public-client release change.
 
@@ -10,10 +10,10 @@ The public `agentmemory` repository and `myagentmemory` npm package remain the f
 
 The public core will provide a small bootstrap and host surface for signed first-party plugins. It will not contain paid implementations, browser assets, commercial entitlement logic, or a general third-party marketplace.
 
-The primary user command is:
+The primary product-facing command is:
 
 ```bash
-agent-memory plugin install
+agent-memory pro install
 ```
 
 `plugin install` is an idempotent reconcile operation:
@@ -23,11 +23,11 @@ agent-memory plugin install
 | Plugin absent | Active or grace | Install the compatible signed bundle |
 | Plugin older than the selected release | Active or grace | Upgrade atomically |
 | Plugin current | Active or grace | Report that it is current |
-| Any | Missing | Start loopback email activation in an interactive terminal |
+| Any | Missing | Request an anonymous free-preview entitlement and signed artifact grant |
 | Any | Expired | Direct the user to renewal; leave core available |
 | Incompatible bundle | Any | Leave the current version untouched and explain the required core version |
 
-An absent plugin cannot activate itself. The public bootstrap collects an email locally, obtains a server-issued usage credential and short-lived artifact grant, and verifies the release and artifact. The credential is persisted only after the service accepts activation. After installation, the public host reconstructs the free account-metered capability policy in core code and checks required capabilities before commands and hooks. Signed long-lived entitlements can extend this credential when authentication and payment ship.
+An absent plugin cannot activate itself. The public bootstrap creates a random installation identifier, obtains a server-issued free-preview policy and short-lived artifact grant, and verifies the release and artifact. A mode-0600 activation record is persisted only after the service accepts the request. After installation, the public host reconstructs the free capability policy in core code and checks required capabilities before commands and hooks. Signed long-lived paid entitlements can extend this record when authentication and payment ship.
 
 ## Ownership boundary
 
@@ -67,6 +67,12 @@ Core memory operations must continue to work when the service is unreachable, a
 ### Bootstrap commands
 
 ```text
+agent-memory pro
+agent-memory pro install
+agent-memory pro status
+agent-memory pro upgrade
+agent-memory pro manage
+
 agent-memory plugin
 agent-memory plugin list
 agent-memory plugin status
@@ -76,6 +82,8 @@ agent-memory plugin uninstall [--yes]
 agent-memory plugin manage [--no-browser]
 ```
 
+The `pro` namespace is the user-facing surface. The `plugin` namespace remains supported for low-level administration and compatibility.
+
 - `plugin` with no subcommand prints a discovery summary and the next relevant command.
 - `list` reports known official plugins and whether each is installed and available. It does not download artifacts or inspect memory.
 - `status` is read-only. It reports the installed bundle, selected channel, compatibility, entitlement state, and update availability.
@@ -84,7 +92,7 @@ agent-memory plugin manage [--no-browser]
 - `uninstall` removes executable plugin material and the active receipt. It preserves core memory, plugin state, and the permission-restricted activation credential.
 - `manage` remains unavailable until authenticated account and billing management exists.
 
-Installed plugins contribute top-level commands such as `recall`, `learn`, `worker`, and `web`. Bootstrap command names are reserved by the core and cannot be replaced by a plugin.
+Installed plugins contribute top-level commands including `recall` and `learn`; `dashboard` is a product-facing alias for the lower-level `web` command. Bootstrap command names are reserved by the core and cannot be replaced by a plugin.
 
 The current private compatibility CLI uses `plugin install` and `plugin uninstall` for skill files only. During migration, those meanings move to `install-skills --plugin-only` and `uninstall-skills --plugin-only`; the bootstrap command names above become authoritative.
 
@@ -93,13 +101,13 @@ The current private compatibility CLI uses `plugin install` and `plugin uninstal
 After a successful interactive `agent-memory init`, the core may print one informational line:
 
 ```text
-Optional: AgentMemory Pro adds session recall and a local Web Console.
-Run: agent-memory plugin install
+Core remembers what you save. Pro learns from what you do.
+Run: agent-memory pro install
 ```
 
-Top-level help includes an `Optional official plugins` section. Human-readable `status` may include the same recommendation while no official plugin is installed. Routine `context`, `read`, `write`, `search`, and scratchpad commands never show commercial prompts.
+Top-level help includes a Pro section. Human-readable `status` may include the same recommendation while Pro is not installed. Routine `context`, `read`, `write`, `search`, and scratchpad commands never show commercial prompts.
 
-The core must not open a browser during package installation, `init`, `help`, `status`, or any normal memory operation. A browser may open only after an explicit interactive `plugin install`. `--no-browser`, non-interactive execution, and `--json` fail closed with `auth_required` when no activation record exists.
+The free preview does not open a browser or request identity. Browsers remain restricted to explicit `dashboard`, future `pro manage`, and future paid upgrade/authentication flows. Non-interactive and `--json` installs use the same anonymous access request and still fail closed when the commercial service is unavailable.
 
 ### Machine-readable output
 
@@ -133,17 +141,17 @@ Every bootstrap command supports `--json` and emits one JSON document with a ver
 
 `result` is one of `not_installed`, `installed`, `upgraded`, `current`, `update_available`, `uninstalled`, `auth_required`, `renewal_required`, or `unavailable`. Failures use `ok: false` plus a stable `error.code` and redacted `error.message`. Output must never contain access tokens, download credentials, signed entitlement contents, local memory paths, or URLs containing bearer credentials.
 
-## Free activation flow
+## Anonymous free-preview flow
 
-1. `agent-memory plugin install` starts an HTTP server bound to `127.0.0.1` on an ephemeral port.
-2. The CLI prints and opens a nonce-bearing local URL. The page accepts one email address with bounded input, an exact Host and nonce path, same-origin browser request validation, restrictive response headers, and a five-minute deadline.
-3. Submission returns a completion page but does not create a local credential yet.
-4. The waiting CLI sends the email plus core, installed-bundle, platform, architecture, release-channel, and consent-version fields to the private control plane. Its activation database stores none of the user's memory, session content, queries, repository paths, raw agent session identifiers, IP address, or user-agent string.
-5. The service normalizes the email, stores only a hash of a random usage credential, and returns the credential, a free account-metered entitlement, and a short-lived object-bound artifact grant. Only then does the CLI atomically write a mode-0600 activation record.
+1. `agent-memory pro install` creates a random installation identifier locally when no activation record exists.
+2. The CLI sends that identifier plus core, installed-bundle, platform, architecture, and release-channel fields to the private control plane. It sends no email, memory, session content, query, repository path, raw agent session identifier, IP address, or user-agent string.
+3. The service stores the pseudonymous identifier and only the hash of a random compatibility credential, then returns a free-preview capability policy and short-lived object-bound artifact grant.
+4. The CLI validates the explicit free policy: local indexing and Memory Dashboard access, 10 device-local recalls per day, one device-local learning scan per day, and no free automatic background worker.
+5. Only then does the CLI atomically write a mode-0600 activation record.
 6. The CLI verifies the Ed25519-signed release plus package digest and limits, imports it for health checks, and atomically activates the receipt.
-7. Each paid SessionStart hook reserves one opaque operation against the email's UTC-day allowance, commits after useful hook work, and releases on failure. Exhaustion skips paid hook work without affecting public-core context.
+7. Device-local quota operations reserve before work, commit after useful work, and release on abstention or failure. A zero-result recall does not consume allowance.
 
-Email ownership is not verified in this free flow. Authentication, payment, renewal, account management, and signed paid entitlements are not implemented yet.
+Authentication, payment, renewal, account management, and signed paid entitlements are not implemented yet.
 
 ## Future authentication and purchase flow
 
@@ -163,12 +171,12 @@ An Enterprise administrator may pre-provision an organization entitlement or man
 
 The service exposes:
 
-- `POST /v1/plugin/access` for a free account-metered entitlement, a usage credential, and a short-lived artifact grant;
-- `POST /v1/plugin/sessions/reserve|commit|release` for atomic daily allowance enforcement;
+- `POST /v1/plugin/access` for an anonymous free-preview policy, compatibility credential, and short-lived artifact grant;
+- `POST /v1/plugin/sessions/reserve|commit|release` for migration compatibility with activation-v2 clients;
 - `GET /v1/plugin/releases` for an Ed25519-signed release selected from the private R2 catalog;
 - `GET|HEAD /v1/artifacts/download` for the exact content-addressed object authorized by the bearer grant.
 
-The access request contains the submitted email plus the bounded core, bundle, platform, architecture, release-channel, and consent-version fields described above. Session metering sends only a random operation ID and bearer credential; D1 associates those values with a normalized email and UTC-day counter. Application payloads contain no memory content, search query, session content, path, repository name, raw agent session identifier, qmd data, IP address, or user-agent string. The activation database stores neither IP addresses nor user-agent strings. Future authenticated service responsibilities include:
+The access request contains a random installation identifier plus the bounded core, bundle, platform, architecture, and release-channel fields described above. Application payloads contain no email, memory content, search query, session content, path, repository name, raw agent session identifier, qmd data, IP address, or user-agent string. The activation database stores neither IP addresses nor user-agent strings. Future authenticated service responsibilities include:
 
 - create and poll a device authorization;
 - read the authenticated principal's effective entitlement;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "myagentmemory",
-	"version": "0.4.16",
+	"version": "0.4.17",
 	"description": "agentmemory (agent-memory) is persistent memory for coding agents (Claude Code, OpenAI Codex, Cursor, Agent) with qmd-powered semantic search across daily logs, long-term memory, and scratchpad",
 	"main": "./dist/core.js",
 	"types": "./dist/core.d.ts",

package/src/cli-spec.ts

@@ -23,6 +23,10 @@ export const COMMANDS = [
 	"install-hooks",
 	"uninstall-hooks",
 	"completion",
+	"pro",
+	"recall",
+	"learn",
+	"dashboard",
 	"plugin",
 	"version",
 	"help",
@@ -48,9 +52,13 @@ export const COMMAND_DESCRIPTIONS: Record<(typeof COMMANDS)[number], string> = {
 	"install-hooks": "install automatic SessionStart indexing and context hooks",
 	"uninstall-hooks": "remove only SessionStart hooks managed by agent-memory",
 	completion: "install or print Bash, Zsh, Fish, or PowerShell completion",
-	plugin: "index, recall, learn from, and evaluate prior agent sessions",
+	pro: "install, inspect, or upgrade AgentMemory Pro",
+	recall: "recall decisions and context from prior coding sessions with Pro",
+	learn: "find repeated corrections worth remembering with Pro",
+	dashboard: "open the private local Memory Dashboard",
+	plugin: "discover, install, update, or remove optional official plugins",
 	version: "print the installed agent-memory version",
-	help: "show top-level, command, or nested plugin help",
+	help: "show this command overview",
 };
 
 export const PLUGIN_COMMAND_DESCRIPTIONS: Record<(typeof PLUGIN_COMMANDS)[number], string> = {
@@ -89,6 +97,10 @@ export const COMMAND_OPTIONS: Record<string, readonly string[]> = {
 	"install-hooks": ["--yes", "--all", "--only"],
 	"uninstall-hooks": ["--only"],
 	completion: ["--stdout"],
+	pro: [],
+	recall: ["--scope", "--cwd", "--limit", "--context"],
+	learn: [],
+	dashboard: ["--no-browser"],
 	version: [],
 	help: [],
 };

package/src/cli.ts

@@ -25,6 +25,7 @@
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 
+import { COMMAND_DESCRIPTIONS, COMMANDS } from "./cli-spec.js";
 import { type CompletionShell, detectCompletionShell, generateCompletion, installCompletion } from "./completions.js";
 
 import {
@@ -73,6 +74,7 @@ import {
 	PluginBootstrapFailure,
 	type PluginBootstrapResultV1,
 } from "./plugin-bootstrap.js";
+import type { PluginContextSectionV1 } from "./plugin-host.js";
 import { InstalledPluginRuntimeV1 } from "./plugin-runtime.js";
 
 declare const __VERSION__: string;
@@ -186,21 +188,23 @@ function openExternalUrl(url: string): boolean {
 
 function printProOverview(installed: boolean): void {
 	console.log("");
-	console.log("AgentMemory Pro includes:");
-	console.log("  Session Intelligence  Recall decisions and context across Pi, Codex, and Claude Code sessions.");
-	console.log("  Guided Learning       Turn repeated corrections into reviewable, reversible memory.");
-	console.log("  Local Web Console     Inspect memories, activity, health, and settings in your browser.");
+	console.log("Core remembers what you save. Pro learns from what you do.");
 	console.log("");
-	console.log("Your session content stays on this device.");
+	console.log("AgentMemory Pro:");
+	console.log("  Recall coding history       Find decisions and context across Pi, Codex, and Claude Code sessions.");
+	console.log("  Learn from corrections      Turn repeated fixes into reviewable, reversible memory.");
+	console.log("  See and control learning    Inspect what AgentMemory remembers and why in the Memory Dashboard.");
+	console.log("");
+	console.log("No account is required for the free preview. Your coding history stays on this device.");
 	console.log("");
 	if (installed) {
 		console.log("Try it:");
 		console.log('  agent-memory recall "what did we decide about authentication?"');
 		console.log("  agent-memory learn");
-		console.log("  agent-memory web");
+		console.log("  agent-memory dashboard");
 	} else {
-		console.log("Start your Pro beta:");
-		console.log("  agent-memory plugin install");
+		console.log("Start your free Pro preview:");
+		console.log("  agent-memory pro install");
 	}
 }
 
@@ -241,12 +245,10 @@ function printPluginResult(result: PluginBootstrapResultV1, json: boolean, allow
 				break;
 			case "not_installed":
 				console.log("AgentMemory Pro is not installed.");
-				console.log("Run: agent-memory plugin install");
+				console.log("Run: agent-memory pro install");
 				break;
 			case "auth_required":
-				console.log(
-					"Run this command in an interactive terminal to enter an email and activate free daily access.",
-				);
+				console.log("Run agent-memory pro install to activate the free preview.");
 				break;
 			case "renewal_required":
 				console.log("Renew AgentMemory Pro to continue using paid capabilities.");
@@ -280,10 +282,23 @@ async function cmdContext(flags: Record<string, string | boolean>) {
 	ensureDirs();
 	if (!noSearch && query) await ensureQmdAvailableForSync();
 	const searchResults = noSearch ? "" : await searchRelevantMemories(query);
-	const context = buildMemoryContext(searchResults);
+	const coreContext = buildMemoryContext(searchResults);
+	let pluginSections: PluginContextSectionV1[] = [];
+	try {
+		pluginSections = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).provideContext({
+			host: "agent-memory-cli",
+			cwd: process.cwd(),
+			query: query || undefined,
+			signal: new AbortController().signal,
+		});
+	} catch {
+		// Optional Pro context must never make public-core context unavailable.
+	}
+	const pluginContext = pluginSections.map((section) => `${section.label}\n\n${section.content}`).join("\n\n");
+	const context = [coreContext, pluginContext].filter(Boolean).join("\n\n");
 
 	if (json) {
-		output({ context, directory: getMemoryDir() }, true);
+		output({ context, directory: getMemoryDir(), ...(pluginSections.length ? { pluginSections } : {}) }, true);
 	} else {
 		if (context) {
 			process.stdout.write(context);
@@ -811,8 +826,8 @@ async function cmdInit(flags: Record<string, string | boolean>) {
 				const plugin = await createDefaultPluginBootstrap(VERSION).list();
 				if (plugin.result === "not_installed") {
 					console.log("");
-					console.log("Optional: AgentMemory Pro adds session recall and a local Web Console.");
-					console.log("Run: agent-memory plugin install");
+					console.log("Optional: Pro recalls coding history and learns from repeated corrections.");
+					console.log("Try it without an account: agent-memory pro install");
 				}
 			} catch {
 				// Commercial discovery must never make core initialization fail.
@@ -957,8 +972,8 @@ async function cmdStatus(flags: Record<string, string | boolean>) {
 		}
 		if (!officialPlugin.installed) {
 			console.log("");
-			console.log("Optional official plugins: not installed");
-			console.log("  run: agent-memory plugin install");
+			console.log("AgentMemory Pro: not installed");
+			console.log("  try without an account: agent-memory pro install");
 		}
 	}
 }
@@ -1001,9 +1016,10 @@ Usage:
   agent-memory plugin uninstall --yes
   agent-memory plugin manage [--no-browser]
 
-The public core remains fully usable without AgentMemory Pro. Interactive install
-opens a loopback website for email activation and a configurable free daily
-agent-session allowance. Memory and session content stay on this device.`);
+The public core remains fully usable without AgentMemory Pro. Install uses a random
+installation identifier and requires no account or email. The free preview includes
+10 recalls and one learning scan per local day; indexing and the Memory Dashboard
+remain available. Memory and session content stay on this device.`);
 }
 
 function pluginCommandFailure(command: string, error: unknown): PluginBootstrapResultV1 {
@@ -1028,24 +1044,24 @@ function pluginCommandFailure(command: string, error: unknown): PluginBootstrapR
 	};
 }
 
-async function cmdPlugin(flags: Record<string, string | boolean>, positional: string[]): Promise<void> {
+async function cmdPlugin(
+	flags: Record<string, string | boolean>,
+	positional: string[],
+): Promise<PluginBootstrapResultV1 | null> {
 	const json = hasFlag(flags, "json");
 	const subcommand = positional[0] ?? "list";
 	if (subcommand === "help" || hasFlag(flags, "help")) {
 		printPluginUsage();
-		return;
+		return null;
 	}
 	const channel = getFlag(flags, "channel") ?? "stable";
 	if (channel !== "stable") {
-		printPluginResult(
-			pluginCommandFailure(
-				subcommand,
-				new PluginBootstrapFailure("channel_invalid", "--channel supports only 'stable'"),
-			),
-			json,
-			false,
+		const failure = pluginCommandFailure(
+			subcommand,
+			new PluginBootstrapFailure("channel_invalid", "--channel supports only 'stable'"),
 		);
-		return;
+		printPluginResult(failure, json, false);
+		return failure;
 	}
 	const allowBrowser = !json && !hasFlag(flags, "no-browser") && Boolean(process.stdin.isTTY && process.stdout.isTTY);
 	const manager = createDefaultPluginBootstrap(VERSION);
@@ -1098,6 +1114,55 @@ async function cmdPlugin(flags: Record<string, string | boolean>, positional: st
 		result = pluginCommandFailure(subcommand, error);
 	}
 	printPluginResult(result, json, allowBrowser && (subcommand === "install" || subcommand === "manage"));
+	return result;
+}
+
+async function printFirstRunProof(): Promise<void> {
+	try {
+		const result = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).run("index", {
+			args: [],
+			flags: {},
+			signal: new AbortController().signal,
+		});
+		if (!result?.ok || !result.data || typeof result.data !== "object") return;
+		const stats = (result.data as { stats?: { discovered?: Record<string, number>; selected?: number } }).stats;
+		if (!stats?.discovered) return;
+		const hosts = [
+			["Claude Code", stats.discovered.claude ?? 0],
+			["Codex", stats.discovered.codex ?? 0],
+			["Pi", stats.discovered.pi ?? 0],
+		] as const;
+		console.log("");
+		console.log("Found local coding history:");
+		for (const [label, count] of hosts) console.log(`  ${label.padEnd(13)} ${count} sessions`);
+		console.log("");
+		console.log(`${stats.selected ?? 0} sessions available for local recall. Nothing was uploaded.`);
+		console.log("");
+		console.log('Try: agent-memory recall "what did we decide about authentication?"');
+		console.log("Open: agent-memory dashboard");
+	} catch {
+		// Personalized proof is helpful but must never turn a successful install into a failure.
+	}
+}
+
+async function cmdPro(flags: Record<string, string | boolean>, positional: string[]): Promise<void> {
+	const subcommand = positional[0];
+	if (!subcommand) {
+		await cmdPlugin(flags, ["list"]);
+		return;
+	}
+	const mapped = subcommand === "upgrade" ? "update" : subcommand;
+	if (!["install", "status", "update", "manage"].includes(mapped)) {
+		const json = hasFlag(flags, "json");
+		const message = `Unknown Pro command: ${subcommand}. Available commands: install, status, upgrade, manage.`;
+		if (json) console.log(JSON.stringify({ error: message }));
+		else console.error(`Error: ${message}`);
+		process.exitCode = 1;
+		return;
+	}
+	const result = await cmdPlugin(flags, [mapped]);
+	if (!hasFlag(flags, "json") && mapped === "install" && ["installed", "upgraded"].includes(result?.result ?? ""))
+		await printFirstRunProof();
 }
 
 // ---------------------------------------------------------------------------
@@ -1105,28 +1170,18 @@ async function cmdPlugin(flags: Record<string, string | boolean>, positional: st
 // ---------------------------------------------------------------------------
 
 function printUsage() {
+	const commandWidth = Math.max(...COMMANDS.map((command) => command.length));
+	const commandList = COMMANDS.map(
+		(command) => `  ${command.padEnd(commandWidth)}  ${COMMAND_DESCRIPTIONS[command]}`,
+	).join("\n");
+
 	console.log(`agent-memory — persistent memory for coding agents
 
 Usage:
   agent-memory <command> [options]
 
 Commands:
-  version     Show binary version
-  install-skills  Install (or --uninstall) bundled skills
-  uninstall-skills  Uninstall bundled skills
-  context     Build context; optionally retrieve memories with --query
-  write       Write to memory files (default: daily; optional --source-uri)
-  read        Read memory files
-  scratchpad  Manage checklist items
-  search      Search across memory files (requires qmd)
-  distil      Generate compact MEMORY.md index from daily logs + topics
-  sync        Re-index and embed all files (requires qmd)
-  init        Initialize memory directory and qmd collection
-  status      Show configuration and status (--probe for a live embeddings check)
-  completion  Install or print shell completion
-  install-hooks  Install managed SessionStart hooks
-  uninstall-hooks  Remove only managed SessionStart hooks
-  plugin      Discover, install, update, or remove optional official plugins
+${commandList}
 
 Global flags:
   --dir <path>   Override memory directory
@@ -1152,8 +1207,10 @@ Examples:
   agent-memory status --json
   agent-memory completion zsh
   agent-memory install-hooks --yes
-  agent-memory plugin status
-  agent-memory plugin install`);
+  agent-memory pro status
+  agent-memory pro install
+  agent-memory recall "what did we decide about authentication?"
+  agent-memory dashboard`);
 }
 
 // ---------------------------------------------------------------------------
@@ -1245,18 +1302,22 @@ async function main() {
 		case "plugin":
 			await cmdPlugin(flags, positional);
 			break;
+		case "pro":
+			await cmdPro(flags, positional);
+			break;
 		default: {
 			const controller = new AbortController();
 			const abort = () => controller.abort();
 			process.once("SIGINT", abort);
 			try {
-				const result = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).run(command, {
+				const pluginCommand = command === "dashboard" ? "web" : command;
+				const result = await new InstalledPluginRuntimeV1({ coreVersion: VERSION }).run(pluginCommand, {
 					args: positional,
 					flags,
 					signal: controller.signal,
 				});
 				if (!result) exitError(`Unknown command: ${command}. Run 'agent-memory help' for usage.`, json);
-				if (!result.ok) exitError(result.error?.message ?? `Plugin command ${command} failed`, json);
+				if (!result.ok) exitError(result.error?.message ?? `Plugin command ${pluginCommand} failed`, json);
 				output(result.data ?? { ok: true }, json);
 			} finally {
 				process.removeListener("SIGINT", abort);

package/src/plugin-bootstrap.ts

@@ -195,8 +195,8 @@ const MISSING_ENTITLEMENT: PluginEntitlementStatusV1 = {
 };
 
 const OFFICIAL_PLUGINS = [
-	{ id: OFFICIAL_PLUGIN_IDS[0], name: "Session Intelligence" },
-	{ id: OFFICIAL_PLUGIN_IDS[1], name: "Web Console" },
+	{ id: OFFICIAL_PLUGIN_IDS[0], name: "Coding History Recall" },
+	{ id: OFFICIAL_PLUGIN_IDS[1], name: "Memory Dashboard" },
 ] as const;
 
 const PACKAGE_MAX_BYTES = 64 * 1024 * 1024;