myagentmemory 0.4.16 → 0.5.1

package/dist/mcp-server.js

@@ -0,0 +1,106 @@
+import * as readline from "node:readline";
+// ---------------------------------------------------------------------------
+// Bare stdio MCP server — no external dependencies
+//
+// MCP uses newline-delimited JSON-RPC 2.0 over stdin/stdout (NOT Content-Length
+// framing). Each message is one JSON object followed by \n.
+// ---------------------------------------------------------------------------
+export class StdioMcpServer {
+    version;
+    tools = new Map();
+    startupHooks = [];
+    constructor(version = "0.0.0") {
+        this.version = version;
+    }
+    addTool(definition, handler) {
+        this.tools.set(definition.name, { definition, handler });
+    }
+    addStartupHook(fn) {
+        this.startupHooks.push(fn);
+    }
+    async start() {
+        // Run all startup hooks before entering the message loop.
+        for (const hook of this.startupHooks)
+            await hook();
+        const rl = readline.createInterface({ input: process.stdin, terminal: false });
+        rl.on("line", (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                return;
+            }
+            this.handleMessage(message);
+        });
+        await new Promise((resolve) => {
+            rl.on("close", resolve);
+            process.stdin.on("end", resolve);
+        });
+    }
+    handleMessage(msg) {
+        const id = msg.id;
+        const method = typeof msg.method === "string" ? msg.method : "";
+        // Notifications (no id) — no response needed.
+        if (id === undefined || id === null) {
+            // notifications/initialized is the only one we care about; ignore the rest.
+            return;
+        }
+        if (method === "initialize") {
+            this.respond(id, {
+                protocolVersion: "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "agent-memory", version: this.version },
+            });
+            return;
+        }
+        if (method === "ping") {
+            this.respond(id, {});
+            return;
+        }
+        if (method === "tools/list") {
+            this.respond(id, {
+                tools: [...this.tools.values()].map(({ definition }) => definition),
+            });
+            return;
+        }
+        if (method === "tools/call") {
+            const params = (msg.params ?? {});
+            const toolName = typeof params.name === "string" ? params.name : "";
+            const toolInput = (params.arguments ?? {});
+            const entry = this.tools.get(toolName);
+            if (!entry) {
+                this.respondError(id, -32601, `Unknown tool: ${toolName}`);
+                return;
+            }
+            // Execute handler — handle both sync and async.
+            Promise.resolve()
+                .then(() => entry.handler(toolInput))
+                .then((result) => {
+                this.respond(id, {
+                    content: [
+                        { type: "text", text: typeof result === "string" ? result : JSON.stringify(result, null, 2) },
+                    ],
+                });
+            })
+                .catch((error) => {
+                this.respond(id, {
+                    content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+                    isError: true,
+                });
+            });
+            return;
+        }
+        // Unknown method — JSON-RPC method not found.
+        this.respondError(id, -32601, `Method not found: ${method}`);
+    }
+    respond(id, result) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, result })}\n`);
+    }
+    respondError(id, code, message) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } })}\n`);
+    }
+}

package/dist/plugin-bootstrap.js

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { AGENT_MEMORY_PLUGIN_API_VERSION, isSafeBundlePath, validateBundleManifestV1, } from "./plugin-host.js";
-import { TemporaryPluginBackend } from "./plugin-service.js";
+import { AgentMemoryServiceBackend } from "./plugin-service.js";
 export const OFFICIAL_BUNDLE_ID = "agentmemory.pro";
 export const OFFICIAL_PLUGIN_IDS = ["agentmemory.session-intelligence", "agentmemory.web-console"];
 const MISSING_ENTITLEMENT = {
@@ -14,13 +14,13 @@ const MISSING_ENTITLEMENT = {
     reason: "No signed AgentMemory commercial entitlement is installed",
 };
 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" },
 ];
 const PACKAGE_MAX_BYTES = 64 * 1024 * 1024;
 const PACKAGE_MAX_EXPANDED_BYTES = 128 * 1024 * 1024;
 const PACKAGE_MAX_FILES = 10_000;
-const TEMPORARY_RELEASE_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+const RELEASE_SIGNING_KEY_2026_08 = `-----BEGIN PUBLIC KEY-----
 MCowBQYDK2VwAyEASefZFUVFy1EmvGbd0ckHZThmPgqQ3u9HCwZRReAZQW8=
 -----END PUBLIC KEY-----`;
 export class PluginBootstrapFailure extends Error {
@@ -423,11 +423,11 @@ export class PluginBootstrapV1 {
 }
 export function createDefaultPluginBootstrap(coreVersion) {
     const store = new FilePluginInstallStore();
-    const backend = new TemporaryPluginBackend({ root: store.root, coreVersion });
+    const backend = new AgentMemoryServiceBackend({ root: store.root, coreVersion });
     return new PluginBootstrapV1({
         coreVersion,
         backend,
-        verifier: new Ed25519ReleaseVerifier({ "agentmemory-temporary-2026-08": TEMPORARY_RELEASE_PUBLIC_KEY }),
+        verifier: new Ed25519ReleaseVerifier({ "agentmemory-temporary-2026-08": RELEASE_SIGNING_KEY_2026_08 }),
         store,
         healthCheck: async (directory, release) => {
             const { createInstalledBundleHealthCheck } = await import("./plugin-runtime.js");

package/dist/plugin-host.d.ts

@@ -73,6 +73,21 @@ export interface PluginSessionStartHookV1 {
     requiredCapability: string;
     run(context: PluginSessionStartContextV1): Promise<void>;
 }
+export interface PluginBackgroundRefreshContextV1 {
+    host: string;
+    cwd?: string;
+    signal: AbortSignal;
+}
+/**
+ * Un-metered per-turn refresh callback. Fired on every UserPromptSubmit so
+ * plugins can keep background workers alive across `/clear` and long idle.
+ * MUST be idempotent and cheap — no quota is charged.
+ */
+export interface PluginBackgroundRefreshHookV1 {
+    name: string;
+    requiredCapability: string;
+    run(context: PluginBackgroundRefreshContextV1): Promise<void>;
+}
 export interface PluginMemoryWriteV1 {
     target: "long_term" | "daily" | "topic";
     content: string;
@@ -103,11 +118,47 @@ export interface PluginStructuredErrorV1 {
     message: string;
     retryable?: boolean;
 }
+export interface PluginContextSectionV1 {
+    id: string;
+    label: string;
+    content: string;
+    artifactPath?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface PluginContextProviderV1 {
+    name: string;
+    requiredCapability: string;
+    provide(context: {
+        host: string;
+        cwd?: string;
+        query?: string;
+        signal: AbortSignal;
+    }): Promise<PluginContextSectionV1[]>;
+}
+export interface PluginMcpToolInputSchema {
+    type: "object";
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+    }>;
+    required?: string[];
+}
+export interface PluginMcpToolV1 {
+    name: string;
+    description: string;
+    inputSchema: PluginMcpToolInputSchema;
+    run(input: Record<string, unknown>): unknown | Promise<unknown>;
+}
 export interface AgentMemoryPluginHostV1 {
     apiVersion: 1;
     coreVersion: string;
     registerCommand(command: PluginCommandV1): void;
     registerSessionStartHook(hook: PluginSessionStartHookV1): void;
+    registerBackgroundRefresh?(hook: PluginBackgroundRefreshHookV1): void;
+    registerContextProvider?(provider: PluginContextProviderV1): void;
+    registerMcpTool?(tool: PluginMcpToolV1): void;
+    registerMcpStartup?(fn: () => void | Promise<void>): void;
     getStateDirectory(): string;
     getMemoryDirectory(): string;
     getEntitlement(): Promise<PluginEntitlementStatusV1>;

package/dist/plugin-runtime.d.ts

@@ -1,5 +1,5 @@
 import { type PluginBootstrapBackendV1, type PluginInstallStoreV1, type PluginSessionUsageDecisionV1, type SignedPluginReleaseV1 } from "./plugin-bootstrap.js";
-import { type PluginCommandContextV1, type PluginCommandResultV1, type PluginSessionStartHookV1 } from "./plugin-host.js";
+import { type PluginBackgroundRefreshContextV1, type PluginCommandContextV1, type PluginCommandResultV1, type PluginContextSectionV1, type PluginMcpToolV1, type PluginSessionStartHookV1 } from "./plugin-host.js";
 export interface PluginRuntimeOptionsV1 {
     coreVersion: string;
     store?: PluginInstallStoreV1;
@@ -11,11 +11,30 @@ export declare class InstalledPluginRuntimeV1 {
     private readonly backend;
     private readonly commands;
     private readonly hooks;
+    private readonly backgroundRefreshHooks;
+    private readonly contextProviders;
+    private readonly mcpTools;
+    private readonly mcpStartupHooks;
     private loaded;
     constructor(options: PluginRuntimeOptionsV1);
     load(): Promise<boolean>;
     run(name: string, context: PluginCommandContextV1): Promise<PluginCommandResultV1 | null>;
     runSessionStart(context: Parameters<PluginSessionStartHookV1["run"]>[0]): Promise<PluginSessionUsageDecisionV1 | null>;
+    /**
+     * Fire all registered background-refresh hooks. Un-metered — intended for
+     * per-turn UserPromptSubmit invocation, keeping workers alive across
+     * `/clear` and idle without charging session quota. Failures propagate to
+     * the caller (which is expected to swallow them silently).
+     */
+    refreshBackgroundWorkers(context: PluginBackgroundRefreshContextV1): Promise<void>;
+    provideContext(context: {
+        host: string;
+        cwd?: string;
+        query?: string;
+        signal: AbortSignal;
+    }): Promise<PluginContextSectionV1[]>;
+    getMcpTools(): PluginMcpToolV1[];
+    runMcpStartup(): Promise<void>;
     private createHost;
     private refreshEntitlement;
 }

package/dist/plugin-runtime.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
 import { getMemoryDir, memoryWrite, redactSecrets, scheduleQmdUpdate } from "./core.js";
 import { FilePluginInstallStore, OFFICIAL_BUNDLE_ID, PluginBootstrapFailure, } from "./plugin-bootstrap.js";
 import { AGENT_MEMORY_PLUGIN_API_VERSION, isPluginCapabilityEnabled, validateBundleManifestV1, validatePluginEntitlementStatusV1, validatePluginManifestV1, } from "./plugin-host.js";
-import { TemporaryPluginBackend } from "./plugin-service.js";
+import { AgentMemoryServiceBackend } from "./plugin-service.js";
 function assertPermission(manifest, permission) {
     if (!manifest.permissions.includes(permission))
         throw new PluginBootstrapFailure("plugin_permission_denied", `Plugin ${manifest.id} did not declare permission ${permission}`);
@@ -61,11 +61,15 @@ export class InstalledPluginRuntimeV1 {
     backend;
     commands = new Map();
     hooks = [];
+    backgroundRefreshHooks = [];
+    contextProviders = [];
+    mcpTools = [];
+    mcpStartupHooks = [];
     loaded = false;
     constructor(options) {
         this.options = options;
         this.store = options.store ?? new FilePluginInstallStore();
-        this.backend = options.backend ?? new TemporaryPluginBackend({ root: this.store.root });
+        this.backend = options.backend ?? new AgentMemoryServiceBackend({ root: this.store.root });
     }
     async load() {
         if (this.loaded)
@@ -132,6 +136,60 @@ export class InstalledPluginRuntimeV1 {
             throw error;
         }
     }
+    /**
+     * Fire all registered background-refresh hooks. Un-metered — intended for
+     * per-turn UserPromptSubmit invocation, keeping workers alive across
+     * `/clear` and idle without charging session quota. Failures propagate to
+     * the caller (which is expected to swallow them silently).
+     */
+    async refreshBackgroundWorkers(context) {
+        if (!(await this.load()) || this.backgroundRefreshHooks.length === 0)
+            return;
+        const entitlement = await this.refreshEntitlement();
+        for (const hook of this.backgroundRefreshHooks) {
+            if (!isPluginCapabilityEnabled(entitlement, hook.requiredCapability))
+                continue;
+            await hook.run(context);
+        }
+    }
+    async provideContext(context) {
+        if (!(await this.load()) || this.contextProviders.length === 0)
+            return [];
+        const entitlement = await this.refreshEntitlement();
+        const sections = [];
+        for (const registered of this.contextProviders) {
+            if (!isPluginCapabilityEnabled(entitlement, registered.provider.requiredCapability))
+                continue;
+            const provided = await registered.provider.provide(context);
+            if (!Array.isArray(provided) || provided.length > 16)
+                throw new PluginBootstrapFailure("plugin_context_invalid", `Plugin ${registered.pluginId} returned invalid context sections`);
+            for (const section of provided) {
+                if (!section ||
+                    typeof section.id !== "string" ||
+                    section.id.length === 0 ||
+                    section.id.length > 256 ||
+                    typeof section.label !== "string" ||
+                    section.label.length === 0 ||
+                    section.label.length > 256 ||
+                    typeof section.content !== "string" ||
+                    Buffer.byteLength(section.content, "utf-8") > 64 * 1024 ||
+                    (section.artifactPath !== undefined &&
+                        (typeof section.artifactPath !== "string" || section.artifactPath.length > 4_096)) ||
+                    (section.metadata !== undefined &&
+                        (!section.metadata || typeof section.metadata !== "object" || Array.isArray(section.metadata))))
+                    throw new PluginBootstrapFailure("plugin_context_invalid", `Plugin ${registered.pluginId} returned an invalid context section`);
+                sections.push(structuredClone(section));
+            }
+        }
+        return sections;
+    }
+    getMcpTools() {
+        return [...this.mcpTools];
+    }
+    async runMcpStartup() {
+        for (const hook of this.mcpStartupHooks)
+            await hook();
+    }
     createHost(manifest) {
         const descriptors = new Map(manifest.commands.map((command) => [command.name, command]));
         const stateRoot = path.join(this.store.root, "state");
@@ -165,6 +223,28 @@ export class InstalledPluginRuntimeV1 {
                     throw new PluginBootstrapFailure("plugin_hook_invalid", `Plugin ${manifest.id} registered a hook with an undeclared capability`);
                 this.hooks.push(hook);
             },
+            registerBackgroundRefresh: (hook) => {
+                if (!(manifest.capabilities ?? []).includes(hook.requiredCapability))
+                    throw new PluginBootstrapFailure("plugin_hook_invalid", `Plugin ${manifest.id} registered a background refresh hook with an undeclared capability`);
+                if (!hook.name || this.backgroundRefreshHooks.some((existing) => existing.name === hook.name))
+                    throw new PluginBootstrapFailure("plugin_hook_invalid", `Plugin background refresh hook ${hook.name || "(unnamed)"} is invalid or already registered`);
+                this.backgroundRefreshHooks.push(hook);
+            },
+            registerContextProvider: (provider) => {
+                if (!(manifest.capabilities ?? []).includes(provider.requiredCapability))
+                    throw new PluginBootstrapFailure("plugin_context_invalid", `Plugin ${manifest.id} registered a context provider with an undeclared capability`);
+                if (!provider.name || this.contextProviders.some((item) => item.provider.name === provider.name))
+                    throw new PluginBootstrapFailure("plugin_context_invalid", `Plugin context provider ${provider.name || "(unnamed)"} is invalid or already registered`);
+                this.contextProviders.push({ provider, pluginId: manifest.id });
+            },
+            registerMcpTool: (tool) => {
+                if (!tool.name || this.mcpTools.some((existing) => existing.name === tool.name))
+                    throw new PluginBootstrapFailure("plugin_mcp_tool_invalid", `Plugin MCP tool ${tool.name || "(unnamed)"} is invalid or already registered`);
+                this.mcpTools.push(tool);
+            },
+            registerMcpStartup: (fn) => {
+                this.mcpStartupHooks.push(fn);
+            },
             getStateDirectory: () => stateDirectory,
             getMemoryDirectory: () => {
                 assertPermission(manifest, "memory:read");
@@ -215,6 +295,7 @@ export function createInstalledBundleHealthCheck(coreVersion, backend, storeRoot
                 coreVersion,
                 registerCommand() { },
                 registerSessionStartHook() { },
+                registerBackgroundRefresh() { },
                 getStateDirectory: () => stateDirectory,
                 getMemoryDirectory: () => {
                     assertPermission(plugin.manifest, "memory:read");

package/dist/plugin-service.d.ts

@@ -1,6 +1,6 @@
 import { type PluginAccessDecisionV1, type PluginBootstrapBackendV1, type PluginNextActionV1, type PluginSessionUsageDecisionV1, type SignedPluginReleaseV1 } from "./plugin-bootstrap.js";
 import { type PluginEntitlementStatusV1 } from "./plugin-host.js";
-interface TemporaryPluginBackendOptions {
+interface AgentMemoryServiceBackendOptions {
     root?: string;
     coreVersion?: string;
     apiOrigin?: string;
@@ -10,8 +10,8 @@ interface TemporaryPluginBackendOptions {
     activate?: () => Promise<string>;
 }
 export declare function openLoopbackUrl(url: string): boolean;
-export declare function collectTemporaryActivation(openUrl?: (url: string) => boolean): Promise<string>;
-export declare class TemporaryPluginBackend implements PluginBootstrapBackendV1 {
+export declare function collectActivation(openUrl?: (url: string) => boolean): Promise<string>;
+export declare class AgentMemoryServiceBackend implements PluginBootstrapBackendV1 {
     private readonly root;
     private readonly coreVersion;
     private readonly apiOrigin;
@@ -19,7 +19,7 @@ export declare class TemporaryPluginBackend implements PluginBootstrapBackendV1
     private readonly fetchImplementation;
     private readonly openUrl;
     private readonly activate;
-    constructor(options?: TemporaryPluginBackendOptions);
+    constructor(options?: AgentMemoryServiceBackendOptions);
     getLocalEntitlement(): Promise<PluginEntitlementStatusV1>;
     resolveAccess(request: {
         bundleId: string;
@@ -46,4 +46,10 @@ export declare class TemporaryPluginBackend implements PluginBootstrapBackendV1
     private sessionUsage;
     private request;
 }
+export declare class TemporaryPluginBackend extends AgentMemoryServiceBackend {
+    constructor(options: {
+        root: string;
+        coreVersion: string;
+    });
+}
 export {};

package/dist/plugin-service.js

@@ -7,7 +7,8 @@ import { getDefaultPluginInstallRoot, PluginBootstrapFailure, } from "./plugin-b
 import { validatePluginEntitlementStatusV1 } from "./plugin-host.js";
 const API_ORIGIN = "https://api.agentmemory.paperpilot.me";
 const ARTIFACT_ORIGIN = "https://plugins.agentmemory.paperpilot.me";
-const ACTIVATION_FILE = "credentials/temporary-access.json";
+const ACTIVATION_FILE = "credentials/activation.json";
+const ACTIVATION_FILE_LEGACY = "credentials/temporary-access.json";
 const REQUEST_TIMEOUT_MS = 30_000;
 const EMAIL_MAX_BYTES = 254;
 const FORM_MAX_BYTES = 2_048;
@@ -18,29 +19,45 @@ 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" },
-            },
+            recall: { enabled: true, quota: { limit: 20, window: "day", scope: "device" } },
+            "session-worker": { enabled: false },
+            learning: { enabled: true, quota: { limit: 5, window: "day", scope: "device" } },
+            "retrieval-evaluation": { enabled: true },
+            "operational-metrics": { enabled: true },
+            "web-console": { enabled: true },
+            "memory-explorer": { enabled: true },
+        },
+        reason: "Included at no cost: 20 recalls and 5 learning scans per local day; local indexing and dashboard access remain available",
+    };
+}
+function devEntitlement() {
+    return {
+        plan: "pro",
+        state: "active",
+        features: ["session-intelligence", "web-console"],
+        capabilities: {
+            "session-index": { enabled: true },
+            recall: { enabled: true },
+            "session-worker": { enabled: true },
             learning: { enabled: true },
             "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: "Dev entitlement: all capabilities enabled, no quotas (AGENT_MEMORY_DEV_ENTITLEMENT=1)",
     };
 }
 function isEmail(value) {
@@ -255,7 +272,7 @@ export function openLoopbackUrl(url) {
         return false;
     }
 }
-export async function collectTemporaryActivation(openUrl = openLoopbackUrl) {
+export async function collectActivation(openUrl = openLoopbackUrl) {
     const nonce = randomBytes(24).toString("hex");
     const activationPath = `/activate/${nonce}`;
     let expectedHost = "";
@@ -319,7 +336,7 @@ export async function collectTemporaryActivation(openUrl = openLoopbackUrl) {
         throw new PluginBootstrapFailure("browser_unavailable", `Open this URL in a browser: ${url}`);
     }
     const timer = setTimeout(() => {
-        fail?.(new PluginBootstrapFailure("activation_timeout", "Temporary activation timed out", true));
+        fail?.(new PluginBootstrapFailure("activation_timeout", "Browser activation timed out", true));
         server.close();
     }, 5 * 60_000);
     timer.unref();
@@ -331,7 +348,7 @@ export async function collectTemporaryActivation(openUrl = openLoopbackUrl) {
         server.close();
     }
 }
-export class TemporaryPluginBackend {
+export class AgentMemoryServiceBackend {
     root;
     coreVersion;
     apiOrigin;
@@ -346,41 +363,31 @@ 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);
+        if (!activation)
+            return cloneEntitlement(MISSING_ENTITLEMENT);
+        if (process.env.AGENT_MEMORY_DEV_ENTITLEMENT === "1")
+            return devEntitlement();
+        return freeEntitlement();
     }
     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 +396,25 @@ 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);
+            value.entitlement.capabilities.recall?.enabled !== true ||
+            !recallQuota ||
+            recallQuota.limit !== 20 ||
+            recallQuota.scope !== "device" ||
+            recallQuota.window !== "day" ||
+            value.entitlement.capabilities.learning?.enabled !== true ||
+            !learningQuota ||
+            learningQuota.limit !== 5 ||
+            learningQuota.scope !== "device" ||
+            learningQuota.window !== "day" ||
+            value.entitlement.capabilities["session-index"]?.enabled !== true ||
+            value.entitlement.capabilities["session-worker"]?.enabled !== false ||
+            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) {
@@ -437,6 +455,17 @@ export class TemporaryPluginBackend {
     }
     readActivation() {
         const activationPath = this.activationPath();
+        if (!fs.existsSync(activationPath)) {
+            const legacyPath = path.join(this.root, ...ACTIVATION_FILE_LEGACY.split("/"));
+            if (fs.existsSync(legacyPath)) {
+                try {
+                    fs.renameSync(legacyPath, activationPath);
+                }
+                catch {
+                    /* best-effort migration */
+                }
+            }
+        }
         if (!fs.existsSync(activationPath))
             return null;
         try {
@@ -451,8 +480,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 +495,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 +514,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) {
@@ -545,3 +581,8 @@ export class TemporaryPluginBackend {
         return response;
     }
 }
+export class TemporaryPluginBackend extends AgentMemoryServiceBackend {
+    constructor(options) {
+        super({ ...options, openUrl: () => false });
+    }
+}