myagentmemory 0.5.1 → 0.5.2

package/dist/cli.js

@@ -617,8 +617,11 @@ async function cmdUserPromptSubmit(_flags) {
 }
 // How many Stop events must elapse (per session_id) before the periodic
 // memory-write nudge fires again. Balances "long sessions get checked
-// repeatedly" against "don't block every single turn".
-const STOP_NAG_INTERVAL = 12;
+// repeatedly" against "don't block every single turn". Deliberately short —
+// most real sessions are well under a dozen turns, so a wider interval meant
+// the nudge rarely fired in practice (see stop-hook.json in the wild: sessions
+// topping out around 7 turns, zero nags ever recorded).
+const STOP_NAG_INTERVAL = 6;
 // Bound state/stop-hook.json so it can't grow unboundedly across many sessions.
 const STOP_HOOK_MAX_SESSIONS = 50;
 function stopHookStatePath() {
@@ -2691,7 +2694,8 @@ async function cmdServe(flags) {
     }, async () => {
         const memFile = getMemoryFile();
         const scratchFile = getScratchpadFile();
-        const memory = redactSecrets(readFileSafe(memFile) ?? "").content || "(empty)";
+        const memory = redactSecrets(readFileSafe(memFile) ?? "").content ||
+            '(empty — this only covers what was explicitly saved. For things said in prior chat sessions, try `agent-memory recall "<query>"` or the `session_recall`/`session_search` MCP tools, if AgentMemory Pro is installed.)';
         const scratchRaw = readFileSafe(scratchFile) ?? "";
         const scratchItems = parseScratchpad(scratchRaw)
             .filter((item) => !item.done)
@@ -2732,7 +2736,7 @@ async function cmdServe(flags) {
     try {
         await runtime.load();
         for (const tool of runtime.getMcpTools()) {
-            server.addTool({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema }, (input) => tool.run(input));
+            server.addTool({ name: tool.name, description: tool.description, inputSchema: tool.inputSchema }, (input) => runtime.runMcpTool(tool.name, input));
         }
         server.addStartupHook(() => runtime.runMcpStartup());
     }

package/dist/plugin-host.d.ts

@@ -147,6 +147,7 @@ export interface PluginMcpToolInputSchema {
 export interface PluginMcpToolV1 {
     name: string;
     description: string;
+    requiredCapability: string;
     inputSchema: PluginMcpToolInputSchema;
     run(input: Record<string, unknown>): unknown | Promise<unknown>;
 }

package/dist/plugin-runtime.d.ts

@@ -34,6 +34,15 @@ export declare class InstalledPluginRuntimeV1 {
         signal: AbortSignal;
     }): Promise<PluginContextSectionV1[]>;
     getMcpTools(): PluginMcpToolV1[];
+    /**
+     * Invoke a registered MCP tool by name, re-checking entitlement on every
+     * call — matching `run()`'s behavior for commands. MCP tools are
+     * registered once at `serve --mcp` startup and the server process can
+     * live for a long session, so a tool's entitlement must be re-verified
+     * per-call rather than trusted from registration time (e.g. a trial
+     * expiring mid-session must actually stop the tool from working).
+     */
+    runMcpTool(name: string, input: Record<string, unknown>): Promise<unknown>;
     runMcpStartup(): Promise<void>;
     private createHost;
     private refreshEntitlement;

package/dist/plugin-runtime.js

@@ -186,6 +186,25 @@ export class InstalledPluginRuntimeV1 {
     getMcpTools() {
         return [...this.mcpTools];
     }
+    /**
+     * Invoke a registered MCP tool by name, re-checking entitlement on every
+     * call — matching `run()`'s behavior for commands. MCP tools are
+     * registered once at `serve --mcp` startup and the server process can
+     * live for a long session, so a tool's entitlement must be re-verified
+     * per-call rather than trusted from registration time (e.g. a trial
+     * expiring mid-session must actually stop the tool from working).
+     */
+    async runMcpTool(name, input) {
+        if (!(await this.load()))
+            return { error: `Unknown MCP tool: ${name}` };
+        const tool = this.mcpTools.find((candidate) => candidate.name === name);
+        if (!tool)
+            return { error: `Unknown MCP tool: ${name}` };
+        const entitlement = await this.refreshEntitlement();
+        if (!isPluginCapabilityEnabled(entitlement, tool.requiredCapability))
+            return { error: `Capability ${tool.requiredCapability} is not enabled for the ${name} tool` };
+        return tool.run(input);
+    }
     async runMcpStartup() {
         for (const hook of this.mcpStartupHooks)
             await hook();
@@ -238,6 +257,8 @@ export class InstalledPluginRuntimeV1 {
                 this.contextProviders.push({ provider, pluginId: manifest.id });
             },
             registerMcpTool: (tool) => {
+                if (!(manifest.capabilities ?? []).includes(tool.requiredCapability))
+                    throw new PluginBootstrapFailure("plugin_mcp_tool_invalid", `Plugin ${manifest.id} registered an MCP tool with an undeclared capability`);
                 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);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "myagentmemory",
-	"version": "0.5.1",
+	"version": "0.5.2",
 	"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/plugin-host.ts

@@ -176,6 +176,7 @@ export interface PluginMcpToolInputSchema {
 export interface PluginMcpToolV1 {
 	name: string;
 	description: string;
+	requiredCapability: string;
 	inputSchema: PluginMcpToolInputSchema;
 	run(input: Record<string, unknown>): unknown | Promise<unknown>;
 }