From c8223cd5213d163517f704e60e923866f2db3d64 Mon Sep 17 00:00:00 2001 From: Joyjit Nath <96009+joyjit@users.noreply.github.com> Date: Mon, 29 Jun 2026 16:50:11 -0700 Subject: [PATCH 1/6] fix(hooks): skip capturing memory_* MCP tools and add capture config env vars Closes #993. post-tool-use and post-tool-failure now filter agentmemory's own MCP tools (memory_*, ToolSearch, etc.) so recall/search calls are not written back into the observation store. Adds AGENTMEMORY_CAPTURE_DENY/ALLOW, AGENTMEMORY_CAPTURE_OUTPUT_MAX, and AGENTMEMORY_PRE_COMPACT_BUDGET. --- plugin/scripts/post-tool-failure.mjs | 41 ++++++++++ plugin/scripts/post-tool-use.mjs | 50 +++++++++++- plugin/scripts/pre-compact.mjs | 13 ++- src/hooks/_capture-filter.ts | 68 ++++++++++++++++ src/hooks/post-tool-failure.ts | 3 + src/hooks/post-tool-use.ts | 6 +- src/hooks/pre-compact.ts | 6 +- test/capture-filter.test.ts | 113 +++++++++++++++++++++++++++ test/post-tool-use-capture.test.ts | 90 +++++++++++++++++++++ 9 files changed, 386 insertions(+), 4 deletions(-) create mode 100644 src/hooks/_capture-filter.ts create mode 100644 test/capture-filter.test.ts create mode 100644 test/post-tool-use-capture.test.ts diff --git a/plugin/scripts/post-tool-failure.mjs b/plugin/scripts/post-tool-failure.mjs index 0af94e7cda..d326b294f3 100755 --- a/plugin/scripts/post-tool-failure.mjs +++ b/plugin/scripts/post-tool-failure.mjs @@ -1,6 +1,46 @@ #!/usr/bin/env node import { execSync } from "node:child_process"; import { basename } from "node:path"; +//#region src/hooks/_capture-filter.ts +const DEFAULT_DENY_PATTERNS = [ + "memory_*", + "toolsearch", + "listmcpresources", + "fetchmcpresource" +]; +function parseEnvList(raw) { + if (!raw?.trim()) return void 0; + return raw.split(/[,\s]+/).map((part) => part.trim()).filter(Boolean); +} +function bareToolName(toolName) { + const trimmed = toolName.trim(); + if (/^mcp__/i.test(trimmed)) { + const parts = trimmed.split("__"); + if (parts.length >= 3) return parts[parts.length - 1]; + } + return trimmed; +} +function normalizePattern(pattern) { + return pattern.trim().toLowerCase(); +} +function matchesPattern(toolName, pattern) { + const bare = bareToolName(toolName).toLowerCase(); + const pat = normalizePattern(pattern); + if (!pat.includes("*")) return bare === pat; + const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); + const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); + return re.test(bare) || re.test(toolName.toLowerCase()); +} +function matchesAny(toolName, patterns) { + return patterns.some((pattern) => matchesPattern(toolName, pattern)); +} +function shouldCaptureTool(toolName) { + if (typeof toolName !== "string" || !toolName.trim()) return true; + const allow = parseEnvList(process.env["AGENTMEMORY_CAPTURE_ALLOW"]); + if (allow) return matchesAny(toolName, allow); + return !matchesAny(toolName, [...DEFAULT_DENY_PATTERNS, ...parseEnvList(process.env["AGENTMEMORY_CAPTURE_DENY"]) ?? []]); +} +//#endregion //#region src/hooks/_project.ts function resolveProject(cwd) { const explicit = process.env["AGENTMEMORY_PROJECT_NAME"]; @@ -58,6 +98,7 @@ async function main() { if (data.is_interrupt || data.isInterrupt) return; const sessionId = data.session_id || data.sessionId || data.conversation_id || "unknown"; const toolName = data.tool_name ?? data.toolName; + if (!shouldCaptureTool(toolName)) return; const toolInput = data.tool_input ?? data.toolArgs; const error = data.error ?? data.errorMessage; const cwd = hookCwd(data) || process.cwd(); diff --git a/plugin/scripts/post-tool-use.mjs b/plugin/scripts/post-tool-use.mjs index 1189e35fe1..7136f4b18d 100755 --- a/plugin/scripts/post-tool-use.mjs +++ b/plugin/scripts/post-tool-use.mjs @@ -1,6 +1,52 @@ #!/usr/bin/env node import { execSync } from "node:child_process"; import { basename } from "node:path"; +//#region src/hooks/_capture-filter.ts +const DEFAULT_DENY_PATTERNS = [ + "memory_*", + "toolsearch", + "listmcpresources", + "fetchmcpresource" +]; +function parseEnvList(raw) { + if (!raw?.trim()) return void 0; + return raw.split(/[,\s]+/).map((part) => part.trim()).filter(Boolean); +} +function bareToolName(toolName) { + const trimmed = toolName.trim(); + if (/^mcp__/i.test(trimmed)) { + const parts = trimmed.split("__"); + if (parts.length >= 3) return parts[parts.length - 1]; + } + return trimmed; +} +function normalizePattern(pattern) { + return pattern.trim().toLowerCase(); +} +function matchesPattern(toolName, pattern) { + const bare = bareToolName(toolName).toLowerCase(); + const pat = normalizePattern(pattern); + if (!pat.includes("*")) return bare === pat; + const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); + const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); + return re.test(bare) || re.test(toolName.toLowerCase()); +} +function matchesAny(toolName, patterns) { + return patterns.some((pattern) => matchesPattern(toolName, pattern)); +} +function shouldCaptureTool(toolName) { + if (typeof toolName !== "string" || !toolName.trim()) return true; + const allow = parseEnvList(process.env["AGENTMEMORY_CAPTURE_ALLOW"]); + if (allow) return matchesAny(toolName, allow); + return !matchesAny(toolName, [...DEFAULT_DENY_PATTERNS, ...parseEnvList(process.env["AGENTMEMORY_CAPTURE_DENY"]) ?? []]); +} +function captureOutputMax() { + const raw = process.env["AGENTMEMORY_CAPTURE_OUTPUT_MAX"]; + if (!raw?.trim()) return 8e3; + const parsed = Number.parseInt(raw, 10); + return Number.isFinite(parsed) && parsed > 0 ? parsed : 8e3; +} +//#endregion //#region src/hooks/_project.ts function resolveProject(cwd) { const explicit = process.env["AGENTMEMORY_PROJECT_NAME"]; @@ -57,9 +103,11 @@ async function main() { if (isSdkChildContext(data)) return; const sessionId = data.session_id || data.sessionId || data.conversation_id || "unknown"; const toolName = data.tool_name ?? data.toolName; + if (!shouldCaptureTool(toolName)) return; const toolInput = data.tool_input ?? data.toolArgs; const { imageData, cleanOutput } = extractImageData(toolOutput(data)); const cwd = hookCwd(data) || process.cwd(); + const outputMax = captureOutputMax(); fetch(`${REST_URL}/agentmemory/observe`, { method: "POST", headers: authHeaders(), @@ -72,7 +120,7 @@ async function main() { data: { tool_name: toolName, tool_input: toolInput, - tool_output: truncate(cleanOutput, 8e3), + tool_output: truncate(cleanOutput, outputMax), ...imageData ? { image_data: imageData } : {} } }), diff --git a/plugin/scripts/pre-compact.mjs b/plugin/scripts/pre-compact.mjs index 7530943593..4af7781024 100755 --- a/plugin/scripts/pre-compact.mjs +++ b/plugin/scripts/pre-compact.mjs @@ -1,6 +1,15 @@ #!/usr/bin/env node import { execSync } from "node:child_process"; import { basename } from "node:path"; +//#region src/hooks/_capture-filter.ts +function preCompactBudget() { + const raw = process.env["AGENTMEMORY_PRE_COMPACT_BUDGET"]; + if (raw?.trim() === "0") return 0; + if (!raw?.trim()) return 1500; + const parsed = Number.parseInt(raw, 10); + return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1500; +} +//#endregion //#region src/hooks/_project.ts function resolveProject(cwd) { const explicit = process.env["AGENTMEMORY_PROJECT_NAME"]; @@ -65,6 +74,8 @@ async function main() { signal: AbortSignal.timeout(5e3) }); } catch {} + const budget = preCompactBudget(); + if (budget === 0) return; try { const res = await fetch(`${REST_URL}/agentmemory/context`, { method: "POST", @@ -72,7 +83,7 @@ async function main() { body: JSON.stringify({ sessionId, project, - budget: 1500 + budget }), signal: AbortSignal.timeout(5e3) }); diff --git a/src/hooks/_capture-filter.ts b/src/hooks/_capture-filter.ts new file mode 100644 index 0000000000..ba7493ee93 --- /dev/null +++ b/src/hooks/_capture-filter.ts @@ -0,0 +1,68 @@ +const DEFAULT_DENY_PATTERNS = [ + "memory_*", + "toolsearch", + "listmcpresources", + "fetchmcpresource", +]; + +function parseEnvList(raw: string | undefined): string[] | undefined { + if (!raw?.trim()) return undefined; + return raw + .split(/[,\s]+/) + .map((part) => part.trim()) + .filter(Boolean); +} + +export function bareToolName(toolName: string): string { + const trimmed = toolName.trim(); + if (/^mcp__/i.test(trimmed)) { + const parts = trimmed.split("__"); + if (parts.length >= 3) return parts[parts.length - 1]!; + } + return trimmed; +} + +function normalizePattern(pattern: string): string { + return pattern.trim().toLowerCase(); +} + +function matchesPattern(toolName: string, pattern: string): boolean { + const bare = bareToolName(toolName).toLowerCase(); + const pat = normalizePattern(pattern); + if (!pat.includes("*")) return bare === pat; + const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); + const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); + return re.test(bare) || re.test(toolName.toLowerCase()); +} + +function matchesAny(toolName: string, patterns: string[]): boolean { + return patterns.some((pattern) => matchesPattern(toolName, pattern)); +} + +export function shouldCaptureTool(toolName: unknown): boolean { + if (typeof toolName !== "string" || !toolName.trim()) return true; + + const allow = parseEnvList(process.env["AGENTMEMORY_CAPTURE_ALLOW"]); + if (allow) return matchesAny(toolName, allow); + + const deny = [ + ...DEFAULT_DENY_PATTERNS, + ...(parseEnvList(process.env["AGENTMEMORY_CAPTURE_DENY"]) ?? []), + ]; + return !matchesAny(toolName, deny); +} + +export function captureOutputMax(): number { + const raw = process.env["AGENTMEMORY_CAPTURE_OUTPUT_MAX"]; + if (!raw?.trim()) return 8000; + const parsed = Number.parseInt(raw, 10); + return Number.isFinite(parsed) && parsed > 0 ? parsed : 8000; +} + +export function preCompactBudget(): number { + const raw = process.env["AGENTMEMORY_PRE_COMPACT_BUDGET"]; + if (raw?.trim() === "0") return 0; + if (!raw?.trim()) return 1500; + const parsed = Number.parseInt(raw, 10); + return Number.isFinite(parsed) && parsed >= 0 ? parsed : 1500; +} diff --git a/src/hooks/post-tool-failure.ts b/src/hooks/post-tool-failure.ts index 69ec145df3..427e32cd1c 100644 --- a/src/hooks/post-tool-failure.ts +++ b/src/hooks/post-tool-failure.ts @@ -1,4 +1,5 @@ #!/usr/bin/env node +import { shouldCaptureTool } from "./_capture-filter.js"; import { resolveProject, hookCwd } from "./_project.js"; function isSdkChildContext(payload: unknown): boolean { @@ -35,6 +36,8 @@ async function main() { const sessionId = ((data.session_id || data.sessionId || data.conversation_id) as string) || "unknown"; const toolName = data.tool_name ?? data.toolName; + if (!shouldCaptureTool(toolName)) return; + const toolInput = data.tool_input ?? data.toolArgs; const error = data.error ?? data.errorMessage; diff --git a/src/hooks/post-tool-use.ts b/src/hooks/post-tool-use.ts index e8fe3483c7..3561f2ed9e 100644 --- a/src/hooks/post-tool-use.ts +++ b/src/hooks/post-tool-use.ts @@ -1,4 +1,5 @@ #!/usr/bin/env node +import { captureOutputMax, shouldCaptureTool } from "./_capture-filter.js"; import { resolveProject, hookCwd } from "./_project.js"; function isSdkChildContext(payload: unknown): boolean { @@ -34,10 +35,13 @@ async function main() { const sessionId = ((data.session_id || data.sessionId || data.conversation_id) as string) || "unknown"; const toolName = data.tool_name ?? data.toolName; + if (!shouldCaptureTool(toolName)) return; + const toolInput = data.tool_input ?? data.toolArgs; const { imageData, cleanOutput } = extractImageData(toolOutput(data)); const cwd = hookCwd(data) || process.cwd(); + const outputMax = captureOutputMax(); fetch(`${REST_URL}/agentmemory/observe`, { method: "POST", @@ -51,7 +55,7 @@ async function main() { data: { tool_name: toolName, tool_input: toolInput, - tool_output: truncate(cleanOutput, 8000), + tool_output: truncate(cleanOutput, outputMax), ...(imageData ? { image_data: imageData } : {}), }, }), diff --git a/src/hooks/pre-compact.ts b/src/hooks/pre-compact.ts index 71d7c5cbd1..07a8b9f83a 100644 --- a/src/hooks/pre-compact.ts +++ b/src/hooks/pre-compact.ts @@ -1,4 +1,5 @@ #!/usr/bin/env node +import { preCompactBudget } from "./_capture-filter.js"; import { resolveProject, hookCwd } from "./_project.js"; function isSdkChildContext(payload: unknown): boolean { @@ -48,11 +49,14 @@ async function main() { } } + const budget = preCompactBudget(); + if (budget === 0) return; + try { const res = await fetch(`${REST_URL}/agentmemory/context`, { method: "POST", headers: authHeaders(), - body: JSON.stringify({ sessionId, project, budget: 1500 }), + body: JSON.stringify({ sessionId, project, budget }), signal: AbortSignal.timeout(5000), }); diff --git a/test/capture-filter.test.ts b/test/capture-filter.test.ts new file mode 100644 index 0000000000..98bcba48f8 --- /dev/null +++ b/test/capture-filter.test.ts @@ -0,0 +1,113 @@ +import { describe, it, expect, beforeEach, afterEach } from "vitest"; +import { + bareToolName, + captureOutputMax, + preCompactBudget, + shouldCaptureTool, +} from "../src/hooks/_capture-filter.js"; + +describe("bareToolName", () => { + it("returns plain tool names unchanged", () => { + expect(bareToolName("Bash")).toBe("Bash"); + expect(bareToolName("memory_recall")).toBe("memory_recall"); + }); + + it("strips Claude Code MCP prefixes", () => { + expect(bareToolName("mcp__agentmemory__memory_smart_search")).toBe( + "memory_smart_search", + ); + }); +}); + +describe("shouldCaptureTool (#993)", () => { + const envKeys = [ + "AGENTMEMORY_CAPTURE_ALLOW", + "AGENTMEMORY_CAPTURE_DENY", + ] as const; + const original: Record = {}; + + beforeEach(() => { + for (const key of envKeys) { + original[key] = process.env[key]; + delete process.env[key]; + } + }); + + afterEach(() => { + for (const key of envKeys) { + if (original[key] === undefined) delete process.env[key]; + else process.env[key] = original[key]; + } + }); + + it("captures normal agent tools by default", () => { + expect(shouldCaptureTool("Bash")).toBe(true); + expect(shouldCaptureTool("Edit")).toBe(true); + expect(shouldCaptureTool("Agent")).toBe(true); + }); + + it("skips agentmemory memory_* MCP tools by default", () => { + expect(shouldCaptureTool("memory_recall")).toBe(false); + expect(shouldCaptureTool("memory_smart_search")).toBe(false); + expect(shouldCaptureTool("mcp__agentmemory__memory_recall")).toBe(false); + }); + + it("skips plumbing tools by default", () => { + expect(shouldCaptureTool("ToolSearch")).toBe(false); + expect(shouldCaptureTool("ListMcpResources")).toBe(false); + }); + + it("honors AGENTMEMORY_CAPTURE_DENY", () => { + process.env.AGENTMEMORY_CAPTURE_DENY = "Grep, Glob"; + expect(shouldCaptureTool("Grep")).toBe(false); + expect(shouldCaptureTool("Bash")).toBe(true); + }); + + it("honors AGENTMEMORY_CAPTURE_ALLOW over defaults", () => { + process.env.AGENTMEMORY_CAPTURE_ALLOW = "memory_recall, Bash"; + expect(shouldCaptureTool("memory_recall")).toBe(true); + expect(shouldCaptureTool("memory_smart_search")).toBe(false); + expect(shouldCaptureTool("Bash")).toBe(true); + expect(shouldCaptureTool("Edit")).toBe(false); + }); +}); + +describe("captureOutputMax", () => { + const key = "AGENTMEMORY_CAPTURE_OUTPUT_MAX"; + const original = process.env[key]; + + afterEach(() => { + if (original === undefined) delete process.env[key]; + else process.env[key] = original; + }); + + it("defaults to 8000", () => { + delete process.env[key]; + expect(captureOutputMax()).toBe(8000); + }); + + it("reads a positive override", () => { + process.env[key] = "4096"; + expect(captureOutputMax()).toBe(4096); + }); +}); + +describe("preCompactBudget", () => { + const key = "AGENTMEMORY_PRE_COMPACT_BUDGET"; + const original = process.env[key]; + + afterEach(() => { + if (original === undefined) delete process.env[key]; + else process.env[key] = original; + }); + + it("defaults to 1500", () => { + delete process.env[key]; + expect(preCompactBudget()).toBe(1500); + }); + + it("allows disabling injection with 0", () => { + process.env[key] = "0"; + expect(preCompactBudget()).toBe(0); + }); +}); diff --git a/test/post-tool-use-capture.test.ts b/test/post-tool-use-capture.test.ts new file mode 100644 index 0000000000..4e057a3fb9 --- /dev/null +++ b/test/post-tool-use-capture.test.ts @@ -0,0 +1,90 @@ +import { describe, it, expect, afterEach } from "vitest"; +import { spawn } from "node:child_process"; +import { createServer, type Server } from "node:http"; +import { join } from "node:path"; + +const HOOKS_DIR = join(import.meta.dirname, "..", "plugin", "scripts"); + +function runHook( + scriptName: string, + stdin: string, + env: Record, +): Promise<{ exitCode: number | null }> { + return new Promise((resolve, reject) => { + const child = spawn(process.execPath, [join(HOOKS_DIR, scriptName)], { + env: { + PATH: process.env["PATH"] ?? "", + ...env, + }, + stdio: ["pipe", "ignore", "ignore"], + }); + child.on("error", reject); + child.on("close", (exitCode) => resolve({ exitCode })); + child.stdin.write(stdin); + child.stdin.end(); + }); +} + +describe("post-tool-use hook — capture filter (#993)", () => { + let server: Server; + let observeCalls = 0; + let port = 0; + + afterEach(async () => { + observeCalls = 0; + if (server) { + await new Promise((resolve, reject) => { + server.close((err) => (err ? reject(err) : resolve())); + }); + } + }); + + async function startServer() { + server = createServer((req, res) => { + if (req.method === "POST" && req.url === "/agentmemory/observe") { + observeCalls += 1; + } + res.writeHead(200, { "Content-Type": "application/json" }); + res.end("{}"); + }); + await new Promise((resolve) => { + server.listen(0, "127.0.0.1", () => { + const addr = server.address(); + if (addr && typeof addr === "object") port = addr.port; + resolve(); + }); + }); + } + + it("does not observe memory_* MCP tools", async () => { + await startServer(); + const payload = JSON.stringify({ + session_id: "ses_test", + tool_name: "mcp__agentmemory__memory_smart_search", + tool_input: { query: "hooks" }, + tool_output: "results", + }); + const result = await runHook("post-tool-use.mjs", payload, { + AGENTMEMORY_URL: `http://127.0.0.1:${port}`, + }); + await new Promise((r) => setTimeout(r, 600)); + expect(result.exitCode).toBe(0); + expect(observeCalls).toBe(0); + }); + + it("still observes normal tools", async () => { + await startServer(); + const payload = JSON.stringify({ + session_id: "ses_test", + tool_name: "Bash", + tool_input: { command: "ls" }, + tool_output: "ok", + }); + const result = await runHook("post-tool-use.mjs", payload, { + AGENTMEMORY_URL: `http://127.0.0.1:${port}`, + }); + await new Promise((r) => setTimeout(r, 600)); + expect(result.exitCode).toBe(0); + expect(observeCalls).toBe(1); + }); +}); From 1a042223f8e822658da4628c5dc3be61325ac045 Mon Sep 17 00:00:00 2001 From: Joyjit Nath <96009+joyjit@users.noreply.github.com> Date: Mon, 29 Jun 2026 18:08:42 -0700 Subject: [PATCH 2/6] test(hooks): wait on observe signal instead of fixed sleep MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Address CodeRabbit review on #994 — integration test now resolves when the mock server receives /observe (or confirms none arrive after hook exit). --- test/post-tool-use-capture.test.ts | 39 ++++++++++++++++++++++++++---- 1 file changed, 34 insertions(+), 5 deletions(-) diff --git a/test/post-tool-use-capture.test.ts b/test/post-tool-use-capture.test.ts index 4e057a3fb9..a4e48302fd 100644 --- a/test/post-tool-use-capture.test.ts +++ b/test/post-tool-use-capture.test.ts @@ -29,9 +29,11 @@ describe("post-tool-use hook — capture filter (#993)", () => { let server: Server; let observeCalls = 0; let port = 0; + let onObserve: (() => void) | undefined; afterEach(async () => { observeCalls = 0; + onObserve = undefined; if (server) { await new Promise((resolve, reject) => { server.close((err) => (err ? reject(err) : resolve())); @@ -39,10 +41,26 @@ describe("post-tool-use hook — capture filter (#993)", () => { } }); + async function assertNoObserveAfterHook( + hook: Promise<{ exitCode: number | null }>, + { settleMs = 300 } = {}, + ): Promise<{ exitCode: number | null }> { + const result = await hook; + const deadline = Date.now() + settleMs; + while (Date.now() < deadline) { + if (observeCalls !== 0) { + throw new Error(`unexpected observe call(s): ${observeCalls}`); + } + await new Promise((r) => setTimeout(r, 25)); + } + return result; + } + async function startServer() { server = createServer((req, res) => { if (req.method === "POST" && req.url === "/agentmemory/observe") { observeCalls += 1; + onObserve?.(); } res.writeHead(200, { "Content-Type": "application/json" }); res.end("{}"); @@ -64,10 +82,11 @@ describe("post-tool-use hook — capture filter (#993)", () => { tool_input: { query: "hooks" }, tool_output: "results", }); - const result = await runHook("post-tool-use.mjs", payload, { - AGENTMEMORY_URL: `http://127.0.0.1:${port}`, - }); - await new Promise((r) => setTimeout(r, 600)); + const result = await assertNoObserveAfterHook( + runHook("post-tool-use.mjs", payload, { + AGENTMEMORY_URL: `http://127.0.0.1:${port}`, + }), + ); expect(result.exitCode).toBe(0); expect(observeCalls).toBe(0); }); @@ -80,10 +99,20 @@ describe("post-tool-use hook — capture filter (#993)", () => { tool_input: { command: "ls" }, tool_output: "ok", }); + const observeSeen = new Promise((resolve, reject) => { + const timer = setTimeout( + () => reject(new Error("observe request never arrived")), + 2000, + ); + onObserve = () => { + clearTimeout(timer); + resolve(); + }; + }); const result = await runHook("post-tool-use.mjs", payload, { AGENTMEMORY_URL: `http://127.0.0.1:${port}`, }); - await new Promise((r) => setTimeout(r, 600)); + await observeSeen; expect(result.exitCode).toBe(0); expect(observeCalls).toBe(1); }); From 9f375fa9db0c10cb6d4549c3055970bbc4f2fc48 Mon Sep 17 00:00:00 2001 From: Joyjit Nath <96009+joyjit@users.noreply.github.com> Date: Mon, 7 Sep 2026 17:18:35 -0700 Subject: [PATCH 3/6] fix(hooks): keep capture truncation within OUTPUT_MAX Reserve space for the truncation marker so AGENTMEMORY_CAPTURE_OUTPUT_MAX is a hard length cap, not max-plus-marker. --- plugin/scripts/post-tool-use.mjs | 29 +++++++++++++++++------------ src/hooks/_capture-filter.ts | 21 +++++++++++++++++++++ src/hooks/post-tool-use.ts | 20 ++++++-------------- test/capture-filter.test.ts | 27 +++++++++++++++++++++++++++ 4 files changed, 71 insertions(+), 26 deletions(-) diff --git a/plugin/scripts/post-tool-use.mjs b/plugin/scripts/post-tool-use.mjs index 7136f4b18d..a690bfde12 100755 --- a/plugin/scripts/post-tool-use.mjs +++ b/plugin/scripts/post-tool-use.mjs @@ -46,6 +46,22 @@ function captureOutputMax() { const parsed = Number.parseInt(raw, 10); return Number.isFinite(parsed) && parsed > 0 ? parsed : 8e3; } +/** Truncate so the result length is at most `max` (marker included). */ +function truncateCaptureOutput(value, max) { + if (typeof value === "string" && value.length > max) { + const suffix = "\n[...truncated]"; + return max <= 15 ? suffix.slice(0, max) : value.slice(0, max - 15) + suffix; + } + if (typeof value === "object" && value !== null) { + const str = JSON.stringify(value); + if (str.length > max) { + const suffix = "...[truncated]"; + return max <= 14 ? suffix.slice(0, max) : str.slice(0, max - 14) + suffix; + } + return value; + } + return value; +} //#endregion //#region src/hooks/_project.ts function resolveProject(cwd) { @@ -120,7 +136,7 @@ async function main() { data: { tool_name: toolName, tool_input: toolInput, - tool_output: truncate(cleanOutput, outputMax), + tool_output: truncateCaptureOutput(cleanOutput, outputMax), ...imageData ? { image_data: imageData } : {} } }), @@ -164,17 +180,6 @@ function extractImageData(output) { cleanOutput: output }; } -function truncate(value, max) { - if (typeof value === "string" && value.length > max) return value.slice(0, max) + "\n[...truncated]"; - if (typeof value === "object" && value !== null) { - const str = JSON.stringify(value); - if (str.length > max) return str.slice(0, max) + "...[truncated]"; - return value; - } - return value; -} main().catch(() => process.exit(0)); //#endregion export {}; - -//# sourceMappingURL=post-tool-use.mjs.map \ No newline at end of file diff --git a/src/hooks/_capture-filter.ts b/src/hooks/_capture-filter.ts index ba7493ee93..907837f915 100644 --- a/src/hooks/_capture-filter.ts +++ b/src/hooks/_capture-filter.ts @@ -59,6 +59,27 @@ export function captureOutputMax(): number { return Number.isFinite(parsed) && parsed > 0 ? parsed : 8000; } +/** Truncate so the result length is at most `max` (marker included). */ +export function truncateCaptureOutput(value: unknown, max: number): unknown { + if (typeof value === "string" && value.length > max) { + const suffix = "\n[...truncated]"; + return max <= suffix.length + ? suffix.slice(0, max) + : value.slice(0, max - suffix.length) + suffix; + } + if (typeof value === "object" && value !== null) { + const str = JSON.stringify(value); + if (str.length > max) { + const suffix = "...[truncated]"; + return max <= suffix.length + ? suffix.slice(0, max) + : str.slice(0, max - suffix.length) + suffix; + } + return value; + } + return value; +} + export function preCompactBudget(): number { const raw = process.env["AGENTMEMORY_PRE_COMPACT_BUDGET"]; if (raw?.trim() === "0") return 0; diff --git a/src/hooks/post-tool-use.ts b/src/hooks/post-tool-use.ts index 3561f2ed9e..05aed99375 100644 --- a/src/hooks/post-tool-use.ts +++ b/src/hooks/post-tool-use.ts @@ -1,5 +1,9 @@ #!/usr/bin/env node -import { captureOutputMax, shouldCaptureTool } from "./_capture-filter.js"; +import { + captureOutputMax, + shouldCaptureTool, + truncateCaptureOutput, +} from "./_capture-filter.js"; import { resolveProject, hookCwd } from "./_project.js"; function isSdkChildContext(payload: unknown): boolean { @@ -55,7 +59,7 @@ async function main() { data: { tool_name: toolName, tool_input: toolInput, - tool_output: truncate(cleanOutput, outputMax), + tool_output: truncateCaptureOutput(cleanOutput, outputMax), ...(imageData ? { image_data: imageData } : {}), }, }), @@ -108,16 +112,4 @@ function extractImageData(output: unknown): { imageData: string | undefined; cle return { imageData: undefined, cleanOutput: output }; } -function truncate(value: unknown, max: number): unknown { - if (typeof value === "string" && value.length > max) { - return value.slice(0, max) + "\n[...truncated]"; - } - if (typeof value === "object" && value !== null) { - const str = JSON.stringify(value); - if (str.length > max) return str.slice(0, max) + "...[truncated]"; - return value; - } - return value; -} - main().catch(() => process.exit(0)); diff --git a/test/capture-filter.test.ts b/test/capture-filter.test.ts index 98bcba48f8..79a3c792a7 100644 --- a/test/capture-filter.test.ts +++ b/test/capture-filter.test.ts @@ -4,6 +4,7 @@ import { captureOutputMax, preCompactBudget, shouldCaptureTool, + truncateCaptureOutput, } from "../src/hooks/_capture-filter.js"; describe("bareToolName", () => { @@ -92,6 +93,32 @@ describe("captureOutputMax", () => { }); }); +describe("truncateCaptureOutput", () => { + it("leaves short strings alone", () => { + expect(truncateCaptureOutput("hello", 20)).toBe("hello"); + }); + + it("keeps truncated string length within max", () => { + const out = truncateCaptureOutput("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 20); + expect(typeof out).toBe("string"); + expect((out as string).length).toBe(20); + expect(out).toBe("ABCDE\n[...truncated]"); + }); + + it("handles max smaller than the marker", () => { + expect(truncateCaptureOutput("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 5)).toBe( + "\n[...", + ); + }); + + it("keeps truncated JSON length within max", () => { + const out = truncateCaptureOutput({ a: "x".repeat(50) }, 30); + expect(typeof out).toBe("string"); + expect((out as string).length).toBe(30); + expect(out).toMatch(/\.\.\.\[truncated\]$/); + }); +}); + describe("preCompactBudget", () => { const key = "AGENTMEMORY_PRE_COMPACT_BUDGET"; const original = process.env[key]; From f7a573e83118ee7388c52284a113c15fb668f95a Mon Sep 17 00:00:00 2001 From: Rohit Ghumare Date: Thu, 1 Oct 2026 13:26:49 +0530 Subject: [PATCH 4/6] chore(hooks): regenerate skills reference for capture env vars Run npm run skills:gen so the agentmemory-config reference lists AGENTMEMORY_CAPTURE_ALLOW, AGENTMEMORY_CAPTURE_DENY, AGENTMEMORY_CAPTURE_OUTPUT_MAX and AGENTMEMORY_PRE_COMPACT_BUDGET, drop the doc comment in the capture filter, and rebuild the hook scripts. --- plugin/scripts/post-tool-use.mjs | 3 ++- plugin/skills/agentmemory-config/REFERENCE.md | 6 +++++- src/hooks/_capture-filter.ts | 1 - 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/plugin/scripts/post-tool-use.mjs b/plugin/scripts/post-tool-use.mjs index a690bfde12..0674d1d3e1 100755 --- a/plugin/scripts/post-tool-use.mjs +++ b/plugin/scripts/post-tool-use.mjs @@ -46,7 +46,6 @@ function captureOutputMax() { const parsed = Number.parseInt(raw, 10); return Number.isFinite(parsed) && parsed > 0 ? parsed : 8e3; } -/** Truncate so the result length is at most `max` (marker included). */ function truncateCaptureOutput(value, max) { if (typeof value === "string" && value.length > max) { const suffix = "\n[...truncated]"; @@ -183,3 +182,5 @@ function extractImageData(output) { main().catch(() => process.exit(0)); //#endregion export {}; + +//# sourceMappingURL=post-tool-use.mjs.map \ No newline at end of file diff --git a/plugin/skills/agentmemory-config/REFERENCE.md b/plugin/skills/agentmemory-config/REFERENCE.md index f7e3b60f22..d6dbf6a508 100644 --- a/plugin/skills/agentmemory-config/REFERENCE.md +++ b/plugin/skills/agentmemory-config/REFERENCE.md @@ -3,7 +3,7 @@ Generated by scanning `src/` for `AGENTMEMORY_*` usage. Do not edit the block below by hand; run `npm run skills:gen` after adding or removing a variable. Internal markers ending in two underscores are excluded. -Configuration is read from the environment and from `~/.agentmemory/.env` (no `export` prefix). 52 recognized variables: +Configuration is read from the environment and from `~/.agentmemory/.env` (no `export` prefix). 56 recognized variables: - `AGENTMEMORY_AGENT_SCOPE` - `AGENTMEMORY_ALLOW_AGENT_SDK` @@ -11,6 +11,9 @@ Configuration is read from the environment and from `~/.agentmemory/.env` (no `e - `AGENTMEMORY_AUDIT_MIGRATE_MAX_BYTES` - `AGENTMEMORY_AUDIT_RETENTION_MONTHS` - `AGENTMEMORY_AUTO_COMPRESS` +- `AGENTMEMORY_CAPTURE_ALLOW` +- `AGENTMEMORY_CAPTURE_DENY` +- `AGENTMEMORY_CAPTURE_OUTPUT_MAX` - `AGENTMEMORY_COMMIT_SHA` - `AGENTMEMORY_CONSOLIDATION_COOLDOWN_MS` - `AGENTMEMORY_COPILOT_MCP_BLOCK` @@ -35,6 +38,7 @@ Configuration is read from the environment and from `~/.agentmemory/.env` (no `e - `AGENTMEMORY_LLM_TIMEOUT_MS` - `AGENTMEMORY_MCP_BLOCK` - `AGENTMEMORY_METRICS_PORT` +- `AGENTMEMORY_PRE_COMPACT_BUDGET` - `AGENTMEMORY_PROBE_TIMEOUT_MS` - `AGENTMEMORY_PROJECT_NAME` - `AGENTMEMORY_PROVIDER` diff --git a/src/hooks/_capture-filter.ts b/src/hooks/_capture-filter.ts index 907837f915..b0576f803f 100644 --- a/src/hooks/_capture-filter.ts +++ b/src/hooks/_capture-filter.ts @@ -59,7 +59,6 @@ export function captureOutputMax(): number { return Number.isFinite(parsed) && parsed > 0 ? parsed : 8000; } -/** Truncate so the result length is at most `max` (marker included). */ export function truncateCaptureOutput(value: unknown, max: number): unknown { if (typeof value === "string" && value.length > max) { const suffix = "\n[...truncated]"; From a8a004cf9502d550a3b14d6737d2a0ee3871529a Mon Sep 17 00:00:00 2001 From: Rohit Ghumare Date: Thu, 1 Oct 2026 13:57:41 +0530 Subject: [PATCH 5/6] docs(env): list the hook capture settings in .env.example --- .env.example | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.env.example b/.env.example index 7a3289d714..592ee991f4 100644 --- a/.env.example +++ b/.env.example @@ -25,6 +25,10 @@ # but LLM-backed summarisation / reflection / consolidation are disabled. # A provider key alone does not enable LLM-written observation compression; # that path also requires AGENTMEMORY_AUTO_COMPRESS=true. +# AGENTMEMORY_CAPTURE_ALLOW= # Comma/space list of tool names or globs to capture; when set, only these are captured +# AGENTMEMORY_CAPTURE_DENY= # Extra tool names or globs to skip, added to the defaults (memory_*, toolsearch, listmcpresources, fetchmcpresource) +# AGENTMEMORY_CAPTURE_OUTPUT_MAX=8000 # Max characters of tool output stored per captured observation +# AGENTMEMORY_PRE_COMPACT_BUDGET=1500 # Token budget for context injected by the PreCompact hook; 0 disables it # The detection order is OPENAI_API_KEY → MINIMAX_API_KEY → ANTHROPIC_API_KEY # → GEMINI_API_KEY → OPENROUTER_API_KEY → noop. From 1256c7664dde8f75322582a419ac46212dfd62ae Mon Sep 17 00:00:00 2001 From: Rohit Ghumare Date: Thu, 1 Oct 2026 14:09:47 +0530 Subject: [PATCH 6/6] fix(hooks): match exact capture patterns against the full tool name An exact pattern in AGENTMEMORY_CAPTURE_ALLOW or AGENTMEMORY_CAPTURE_DENY was only compared with the bare tool name, so a full MCP name such as mcp__github__create_issue never matched, while wildcard patterns already checked both forms. Exact patterns now match either the bare or the full name. --- plugin/scripts/post-tool-failure.mjs | 5 +++-- plugin/scripts/post-tool-use.mjs | 5 +++-- src/hooks/_capture-filter.ts | 5 +++-- test/capture-filter.test.ts | 8 ++++++++ 4 files changed, 17 insertions(+), 6 deletions(-) diff --git a/plugin/scripts/post-tool-failure.mjs b/plugin/scripts/post-tool-failure.mjs index d326b294f3..a33f5c1b00 100755 --- a/plugin/scripts/post-tool-failure.mjs +++ b/plugin/scripts/post-tool-failure.mjs @@ -25,11 +25,12 @@ function normalizePattern(pattern) { } function matchesPattern(toolName, pattern) { const bare = bareToolName(toolName).toLowerCase(); + const full = toolName.trim().toLowerCase(); const pat = normalizePattern(pattern); - if (!pat.includes("*")) return bare === pat; + if (!pat.includes("*")) return bare === pat || full === pat; const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); - return re.test(bare) || re.test(toolName.toLowerCase()); + return re.test(bare) || re.test(full); } function matchesAny(toolName, patterns) { return patterns.some((pattern) => matchesPattern(toolName, pattern)); diff --git a/plugin/scripts/post-tool-use.mjs b/plugin/scripts/post-tool-use.mjs index 0674d1d3e1..8345354cf2 100755 --- a/plugin/scripts/post-tool-use.mjs +++ b/plugin/scripts/post-tool-use.mjs @@ -25,11 +25,12 @@ function normalizePattern(pattern) { } function matchesPattern(toolName, pattern) { const bare = bareToolName(toolName).toLowerCase(); + const full = toolName.trim().toLowerCase(); const pat = normalizePattern(pattern); - if (!pat.includes("*")) return bare === pat; + if (!pat.includes("*")) return bare === pat || full === pat; const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); - return re.test(bare) || re.test(toolName.toLowerCase()); + return re.test(bare) || re.test(full); } function matchesAny(toolName, patterns) { return patterns.some((pattern) => matchesPattern(toolName, pattern)); diff --git a/src/hooks/_capture-filter.ts b/src/hooks/_capture-filter.ts index b0576f803f..4c57a70908 100644 --- a/src/hooks/_capture-filter.ts +++ b/src/hooks/_capture-filter.ts @@ -28,11 +28,12 @@ function normalizePattern(pattern: string): string { function matchesPattern(toolName: string, pattern: string): boolean { const bare = bareToolName(toolName).toLowerCase(); + const full = toolName.trim().toLowerCase(); const pat = normalizePattern(pattern); - if (!pat.includes("*")) return bare === pat; + if (!pat.includes("*")) return bare === pat || full === pat; const escaped = pat.replace(/[.+?^${}()|[\]\\]/g, "\\$&"); const re = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`); - return re.test(bare) || re.test(toolName.toLowerCase()); + return re.test(bare) || re.test(full); } function matchesAny(toolName: string, patterns: string[]): boolean { diff --git a/test/capture-filter.test.ts b/test/capture-filter.test.ts index 79a3c792a7..6767c1a0bc 100644 --- a/test/capture-filter.test.ts +++ b/test/capture-filter.test.ts @@ -64,6 +64,14 @@ describe("shouldCaptureTool (#993)", () => { expect(shouldCaptureTool("Bash")).toBe(true); }); + it("matches an exact pattern against the full MCP tool name", () => { + process.env.AGENTMEMORY_CAPTURE_DENY = "mcp__github__create_issue"; + expect(shouldCaptureTool("mcp__github__create_issue")).toBe(false); + expect(shouldCaptureTool("mcp__gitlab__create_issue")).toBe(true); + process.env.AGENTMEMORY_CAPTURE_DENY = "create_issue"; + expect(shouldCaptureTool("mcp__gitlab__create_issue")).toBe(false); + }); + it("honors AGENTMEMORY_CAPTURE_ALLOW over defaults", () => { process.env.AGENTMEMORY_CAPTURE_ALLOW = "memory_recall, Bash"; expect(shouldCaptureTool("memory_recall")).toBe(true);