ai-space/opencode-working-memory
3
0
Fork 0
mirror of https://github.com/sdwolf4103/opencode-working-memory.git synced 2026-07-17 12:56:42 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
041115c1737c97d3837ef08459cbdeffefcd3743
opencode-working-memory/tests/plugin.test.ts
T
Ralph Chang 041115c173 chore(code-health): prepare v1.6.5
2026-05-19 15:05:48 +08:00

3349 lines
124 KiB
TypeScript
Raw Blame History

import test from "node:test";
import assert from "node:assert/strict";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { dirname, join } from "node:path";
import { MemoryV2Plugin } from "../src/plugin.ts";
import { loadSessionState, saveSessionState } from "../src/session-state.ts";
import { parseWorkspaceMemoryCandidates } from "../src/extractors.ts";
import type { CompactionMemoryRef, LongTermMemoryEntry, OpenError } from "../src/types.ts";
import { PROMOTION_RETRY_LIMITS, WORKSPACE_MEMORY_CACHE_LIMITS } from "../src/types.ts";
import { sessionStatePath, workspaceMemoryPath, workspacePendingJournalPath } from "../src/paths.ts";
import { loadPendingJournal, savePendingJournal, memoryKey } from "../src/pending-journal.ts";
import { loadWorkspaceMemory, updateWorkspaceMemory, workspaceMemoryExactKey, workspaceMemoryIdentityKey } from "../src/workspace-memory.ts";
import { queryEvidenceEvents } from "../src/evidence-log.ts";
// Mock client for root session (not a sub-agent)
function mockRootClient() {
return {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({ data: [] }),
todo: async () => ({ data: [] }),
},
};
}
function mockClientWithLatestUser(text: string, messageID: string) {
return {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({
data: [
{
info: { role: "user", id: messageID },
parts: [{ type: "text", text }],
},
],
}),
todo: async () => ({ data: [] }),
},
};
}
function mockClientWithCompactionSummary(summary: string) {
return {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({
data: [
{
info: { role: "assistant", summary: true },
parts: [{ type: "text", text: summary }],
},
],
}),
todo: async () => ({ data: [] }),
},
};
}
function mockClientWithMutableCompactionSummary(summary: () => string) {
return {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({
data: summary()
? [{ info: { role: "assistant", summary: true }, parts: [{ type: "text", text: summary() }] }]
: [],
}),
todo: async () => ({ data: [] }),
},
};
}
function compactionRefFor(memory: LongTermMemoryEntry, ref = "M1", overrides: Partial<CompactionMemoryRef> = {}): CompactionMemoryRef {
return {
ref,
memoryId: memory.id,
type: memory.type,
source: memory.source,
exactKey: workspaceMemoryExactKey(memory),
identityKey: workspaceMemoryIdentityKey(memory),
textPreview: memory.text,
capturedAt: Date.now(),
...overrides,
};
}
// Helper: create session state with pre-populated open error
function createSessionWithError(sessionID: string, error: OpenError) {
return {
version: 1 as const,
sessionID,
turn: 0,
updatedAt: new Date().toISOString(),
activeFiles: [],
openErrors: [error],
recentDecisions: [],
pendingMemories: [],
};
}
async function withMockedDateNow<T>(now: number, fn: () => Promise<T>): Promise<T> {
const originalDateNow = Date.now;
Date.now = () => now;
try {
return await fn();
} finally {
Date.now = originalDateNow;
}
}
async function withNumberedReinforceScenario(
options: { sessionID: string; nowMs: number; existing: LongTermMemoryEntry; summary?: string },
assertions: (context: {
workspace: Awaited<ReturnType<typeof loadWorkspaceMemory>>;
events: Awaited<ReturnType<typeof queryEvidenceEvents>>;
}) => Promise<void> | void,
): Promise<void> {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(options.existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: options.sessionID,
turn: 0,
updatedAt: new Date(options.nowMs).toISOString(),
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(options.existing)],
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(options.summary ?? "Memory candidates:\nREINFORCE [M1]"),
});
await withMockedDateNow(options.nowMs, async () => {
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: options.sessionID } },
});
});
await assertions({
workspace: await loadWorkspaceMemory(tmpDir),
events: await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] }),
});
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
}
test("tool.execute.after: undefined exitCode does NOT create open error", async () => {
// 1. Temp directory for isolated file I/O
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
// 2. Mock client — root session, no user messages
const client = mockRootClient();
// 3. Instantiate plugin
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
// 4. Simulate bash output with NO exitCode, but output contains TS error
// This would create an open error if exitCode was non-zero
// Using STRONG error signal (TS2345) to catch the bug where undefined !== 0
await (plugin as Record<string, Function>)["tool.execute.after"](
{
tool: "bash",
sessionID: "test-session-1",
args: { command: "npm run typecheck" },
},
{
// exitCode deliberately absent (undefined !== 0 is the bug we're testing)
output: "src/index.ts(10,3): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'",
}
);
// 5. Assert: session state has ZERO open errors
const state = await loadSessionState(tmpDir, "test-session-1");
assert.equal(state.openErrors.length, 0,
"exitCode === undefined must not create open errors even with strong error signal");
} finally {
// Cleanup
await rm(tmpDir, { recursive: true, force: true });
}
});
test("tool.execute.after: undefined exitCode does NOT clear existing open error", async () => {
// 1. Temp directory
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
// 2. Pre-populate session state with a real open error
const preExistingError: OpenError = {
id: "err_critical_abc",
category: "typecheck",
summary: "TS2345: Argument of type 'string' is not assignable to parameter of type 'number'",
command: "npm run typecheck",
fingerprint: "ee7b3f9a1c2d",
status: "open",
firstSeen: Date.now() - 3600000,
lastSeen: Date.now() - 3600000,
seenCount: 3,
};
await saveSessionState(tmpDir, createSessionWithError("test-session-2", preExistingError));
// 3. Mock client
const client = mockRootClient();
// 4. Instantiate plugin
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
// 5. Simulate bash output with NO exitCode (inspection command)
// Using STRONG error signal (TS error) to verify undefined exitCode doesn't clear
await (plugin as Record<string, Function>)["tool.execute.after"](
{
tool: "bash",
sessionID: "test-session-2",
args: { command: "rtk cat ~/.local/share/opencode-working-memory/session.json" },
},
{
// exitCode deliberately absent (undefined)
// Even with TS error in output, should NOT clear existing error
output: "src/other.ts(5,10): error TS2794: Expected 0 arguments, but got 1",
}
);
// 6. Assert: pre-existing open error is PRESERVED
const state = await loadSessionState(tmpDir, "test-session-2");
assert.equal(state.openErrors.length, 1,
"exitCode === undefined must not clear pre-existing open errors");
assert.equal(state.openErrors[0].fingerprint, "ee7b3f9a1c2d",
"The original open error must remain intact");
} finally {
// Cleanup
await rm(tmpDir, { recursive: true, force: true });
}
});
test("tool.execute.after: exitCode 0 clears errors for same category", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
// Pre-populate session with a typecheck error
const preExistingError: OpenError = {
id: "err_test",
category: "typecheck",
summary: "TS2345: some error",
command: "npm run typecheck",
fingerprint: "abc123",
status: "open",
firstSeen: Date.now() - 3600000,
lastSeen: Date.now() - 3600000,
seenCount: 1,
};
await saveSessionState(tmpDir, createSessionWithError("test-session-3", preExistingError));
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
// Simulate successful typecheck (exitCode 0)
await (plugin as Record<string, Function>)["tool.execute.after"](
{
tool: "bash",
sessionID: "test-session-3",
args: { command: "npm run typecheck" },
},
{
exitCode: 0,
output: "",
}
);
const state = await loadSessionState(tmpDir, "test-session-3");
assert.equal(state.openErrors.length, 0,
"exitCode 0 should clear typecheck errors");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("tool.execute.after: exitCode non-zero creates open error", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
// Simulate failed typecheck (exitCode 1)
await (plugin as Record<string, Function>)["tool.execute.after"](
{
tool: "bash",
sessionID: "test-session-4",
args: { command: "npm run typecheck" },
},
{
exitCode: 1,
output: "src/index.ts(10,3): error TS2345: Argument of type 'string' is not assignable",
}
);
const state = await loadSessionState(tmpDir, "test-session-4");
assert.equal(state.openErrors.length, 1,
"exitCode non-zero should create open error");
assert.equal(state.openErrors[0].category, "typecheck");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction hook sets output.prompt with ---free template", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
await updateWorkspaceMemory(tmpDir, store => {
const now = new Date().toISOString();
store.entries.push({
id: "compaction-numbered-memory",
type: "decision",
text: "Decision dedupe stays exact-only.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
});
return store;
});
// Create a session state with some data
await saveSessionState(tmpDir, {
version: 1,
sessionID: "test-session-compaction",
turn: 1,
updatedAt: new Date().toISOString(),
activeFiles: [{ path: "/src/index.ts", action: "edit", count: 5, lastSeen: Date.now() }],
openErrors: [],
recentDecisions: [{ text: "Test decision", rationale: "Testing", source: "user", createdAt: Date.now() }],
});
// Call the compaction hook
const output = { context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "test-session-compaction" },
output
);
// Should set output.prompt and clear output.context
const prompt = (output as Record<string, unknown>).prompt as string | undefined;
assert.ok(prompt, "output.prompt should be set");
assert.equal(typeof prompt, "string", "output.prompt should be a string");
assert.equal(output.context.length, 0, "output.context should be cleared after setting prompt");
// Should NOT contain YAML frontmatter separators (--- at start)
assert.equal(prompt!.includes("\n---"), false,
"Prompt should not contain --- separators on their own line");
// Should NOT contain XML-like tags
assert.equal(prompt!.includes("<workspace_memory>"), false);
assert.equal(prompt!.includes("</workspace_memory>"), false);
assert.equal(prompt!.includes("<hot_session_state>"), false);
assert.equal(prompt!.includes("<pending_todos>"), false);
// Should NOT contain HTML comments
assert.equal(prompt!.includes("<!--"), false);
// Should contain the ---free template heading
assert.equal(prompt!.includes("## Goal"), true,
"Prompt should use ## Goal heading, not --- separators");
// Should contain formatting rules that explicitly forbid ---
assert.equal(prompt!.includes("Do not output YAML frontmatter"), true,
"Prompt should explicitly forbid YAML frontmatter");
assert.equal(prompt!.includes("horizontal rules"), true,
"Prompt should explicitly forbid horizontal rules");
// Should contain Memory candidates format
assert.equal(prompt!.includes("Memory candidates:"), true,
"Prompt should include Memory candidates: label");
assert.equal(prompt!.includes("Good memory examples:"), true,
"Prompt should include concrete positive memory examples");
assert.equal(prompt!.includes("Bad memory examples to skip:"), true,
"Prompt should include concrete negative memory examples");
assert.equal(prompt!.includes("180 tests passed"), true,
"Prompt should explicitly reject test-count snapshots");
assert.equal(prompt!.includes("Commit a762e86"), true,
"Prompt should explicitly reject commit-hash snapshots");
// Should contain numbered workspace memory refs but not normal hot state or unnumbered workspace memory.
assert.equal(prompt!.includes("Existing workspace memories available for consolidation:"), true,
"Prompt should include numbered compaction memory context");
assert.equal(prompt!.includes("[M1] Decision dedupe stays exact-only."), true,
"Prompt should include numbered workspace memory line");
assert.equal(prompt!.includes("Workspace memory (cross-session"), false,
"Prompt should not include normal unnumbered workspace memory context");
assert.equal(prompt!.includes("- Decision dedupe stays exact-only."), false,
"Prompt should not duplicate numbered memory as unnumbered memory");
assert.equal(prompt!.includes("Hot session state"), false,
"Prompt should not include hot session state context");
assert.equal(prompt!.includes("active_files:"), false,
"Prompt should not include active_files in compaction context");
assert.equal(prompt!.includes("Test decision"), false,
"Prompt should not include recent_decisions in compaction context");
const state = await loadSessionState(tmpDir, "test-session-compaction");
assert.deepEqual(state.compactionMemoryRefs.map(ref => ref.ref), ["M1"]);
assert.equal(state.compactionMemoryRefs[0]?.memoryId, "compaction-numbered-memory");
// Verify: prompt starts with plain text, not a markup delimiter
assert.equal(prompt!.startsWith("---"), false,
"Prompt should not start with --- (YAML frontmatter)");
assert.equal(prompt!.startsWith("##"), false,
"Prompt should start with plain instructions, not a heading");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction prompt forbids progress and session-internal memory candidates", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-prompt-"));
try {
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { prompt: "", context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "prompt-session", model: {} },
output,
);
assert.match(output.prompt, /CRITICAL MEMORY RULES/);
assert.match(output.prompt, /NO completion or progress statements/i);
assert.match(output.prompt, /NO session-internal implementation notes/i);
assert.match(output.prompt, /decision = future rule\/architecture choice/i);
assert.match(output.prompt, /Do not use decision for service names, IDs, URLs, file paths/i);
assert.match(output.prompt, /Most compactions should produce ZERO memories/i);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction prompt includes numbered reinforce and replace guidance", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-prompt-"));
try {
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { prompt: "", context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "prompt-wording-reuse-session", model: {} },
output,
);
assert.match(output.prompt, /Existing memories are numbered \[M#\]/);
assert.match(output.prompt, /emit at most 3 lines like `REINFORCE \[M#\]`/);
assert.match(output.prompt, /Use `REPLACE \[M#\] \[type\] text` only for eligible unreinforced compaction-sourced memories/);
assert.match(output.prompt, /REINFORCE the existing \[M#\].*also emit a new complete \[type\] candidate/s);
assert.doesNotMatch(output.prompt, /reuse the existing memory wording exactly whenever possible/);
assert.doesNotMatch(output.prompt, /feedback ONLY means/);
assert.doesNotMatch(output.prompt, /decision ONLY means/);
assert.doesNotMatch(output.prompt, /project\/reference ONLY when/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction prompt includes only supported command directives", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-prompt-"));
try {
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { prompt: "", context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "prompt-no-crud-session", model: {} },
output,
);
assert.doesNotMatch(output.prompt, /\bDROP\b/);
assert.doesNotMatch(output.prompt, /fuzzy merge/i);
assert.doesNotMatch(output.prompt, /semantic merge/i);
assert.doesNotMatch(output.prompt, /embedding/i);
assert.match(output.prompt, /\bREPLACE \[M#\]/);
assert.match(output.prompt, /\bREINFORCE\s+\[M#\]/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction prompt preserves Memory candidates output format", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-prompt-"));
try {
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { prompt: "", context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "prompt-format-session", model: {} },
output,
);
assert.match(
output.prompt,
/Format when there ARE REINFORCE\/REPLACE commands or durable new candidates:\nMemory candidates:\nREINFORCE \[M#\]\nREPLACE \[M#\] \[feedback\|decision\|project\|reference\] corrected durable fact\n- \[feedback\|decision\|project\|reference\] new future-facing durable fact/,
);
assert.match(
output.prompt,
/Format when there are NO REINFORCE\/REPLACE commands or durable candidates:\nMemory candidates:\n\(none\)/,
);
assert.match(output.prompt, /Good memory examples:[\s\S]*REINFORCE \[M\d+\]/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction hook merges existing output.context from other plugins", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
// Simulate another plugin having pushed context first
const output = { context: ["Other plugin context data"] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "test-merge-context" },
output
);
const prompt = (output as Record<string, unknown>).prompt as string | undefined;
assert.ok(prompt, "output.prompt should be set");
assert.equal(output.context.length, 0, "output.context should be cleared");
// Should contain the other plugin's context
assert.equal(prompt!.includes("Other plugin context data"), true,
"Prompt should preserve context from other plugins");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("parseWorkspaceMemoryCandidates accepts Markdown section format", async () => {
const summary = `
## Summary
Progress made on testing.
## Memory Candidates
- [decision] Use Markdown sections for candidates
- [project] This repo uses Markdown for docs
Next steps: continue development.
`;
const candidates = parseWorkspaceMemoryCandidates(summary);
assert.equal(candidates.length, 2, "Should parse Markdown section format");
assert.equal(candidates[0].type, "decision");
assert.equal(candidates[1].type, "project");
});
// Compatibility-contract characterization: legacy compaction parser formats are
// still supported intentionally and should not be removed as brittle fixtures.
test("parseWorkspaceMemoryCandidates accepts legacy Workspace Memory Candidates section", async () => {
const summary = `
## Summary
Progress made on testing.
## Workspace Memory Candidates
- [reference] Check docs at README.md
## Next Steps
Continue development.
`;
const candidates = parseWorkspaceMemoryCandidates(summary);
assert.equal(candidates.length, 1, "Should parse legacy section format");
assert.equal(candidates[0].type, "reference");
});
test("parseWorkspaceMemoryCandidates still accepts legacy XML format", async () => {
const summary = `
## Summary
Progress made on testing.
<workspace_memory_candidates>
- [feedback] Users prefer darker themes
</workspace_memory_candidates>
Next steps: continue development.
`;
const candidates = parseWorkspaceMemoryCandidates(summary);
assert.equal(candidates.length, 1, "Should parse legacy XML format");
assert.equal(candidates[0].type, "feedback");
});
test("chat system transform reuses frozen rendered workspace snapshot", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
const output1 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "snapshot-session", model: {} },
output1,
);
const firstWorkspacePrompt = output1.system.find((part: string) =>
part.startsWith("Workspace memory")
);
assert.equal(firstWorkspacePrompt, undefined,
"empty workspace memory should not render a prompt before any memories exist");
const output2 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "snapshot-session", model: {} },
output2,
);
assert.deepEqual(output2.system, ["base header"],
"no compaction summary means no workspace memory prompt is added");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("chat system transform degrades gracefully when workspace memory JSON is corrupt", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const path = await workspaceMemoryPath(tmpDir);
await mkdir(dirname(path), { recursive: true });
await writeFile(path, "{ invalid json", "utf8");
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockRootClient(),
});
const output = { system: ["base header"] };
await assert.doesNotReject(async () => {
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "corrupt-json-session", model: {} },
output,
);
});
assert.deepEqual(output.system, ["base header"]);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("hook failure emits hook_failed evidence without raw tool output", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const statePath = await sessionStatePath(tmpDir, "hook-failure-session");
await mkdir(dirname(statePath), { recursive: true });
await mkdir(statePath, { recursive: true });
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["tool.execute.after"](
{
tool: "bash",
sessionID: "hook-failure-session",
args: { command: "cat secret-output.txt" },
},
{ output: "raw tool output password: sushi should not be in evidence", exitCode: 1 },
);
const events = await queryEvidenceEvents(tmpDir, { types: ["hook_failed"] });
const raw = JSON.stringify(events);
assert.equal(events.length, 1);
assert.equal(events[0].reasonCodes.includes("tool.execute.after"), true);
assert.equal(raw.includes("raw tool output"), false);
assert.equal(raw.includes("sushi"), false);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("no compaction: owned explicit memory is not promoted by unrelated next session start", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const firstClient = mockClientWithLatestUser("remember this: Prefer boring cache boundaries.", "msg-remember-1");
const firstPlugin = await MemoryV2Plugin({ directory: tmpDir, client: firstClient });
await (firstPlugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "session-without-compaction", model: {} },
{ system: ["base header"] },
);
const secondPlugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { system: ["base header"] };
await (secondPlugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "new-session", model: {} },
output,
);
const workspacePrompt = output.system.find((part: string) => part.startsWith("Workspace memory"));
assert.doesNotMatch(workspacePrompt ?? "", /Prefer boring cache boundaries/);
const pending = await loadPendingJournal(tmpDir);
assert.equal(pending.entries.length, 1);
assert.equal(pending.entries[0].pendingOwnerSessionID, "session-without-compaction");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("explicit memory appended from user message is owned by session and not promoted before current snapshot", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser("remember this: Prefer Traditional Chinese.", "msg-a"),
});
const output = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "session-a", model: {} },
output,
);
const pending = await loadPendingJournal(tmpDir);
assert.equal(pending.entries.length, 1);
assert.equal(pending.entries[0].pendingOwnerSessionID, "session-a");
assert.equal(pending.entries[0].pendingMessageID, "msg-a");
const workspace = await loadWorkspaceMemory(tmpDir);
assert.equal(
workspace.entries.some(entry => /Prefer Traditional Chinese/.test(entry.text)),
false,
"current-turn explicit memory should remain pending until compaction/promotion",
);
assert.match(output.system.join("\n"), /Prefer Traditional Chinese/,
"current-turn explicit memory should still appear in hot session state");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session promotion does not clear another session's same-key pending journal entry", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const pendingA = {
id: "mem_same_key_a",
type: "feedback" as const,
text: "Prefer owner-scoped pending cleanup.",
source: "explicit" as const,
confidence: 1,
status: "active" as const,
createdAt: now,
updatedAt: now,
pendingOwnerSessionID: "session-a",
pendingMessageID: "msg-a",
};
const pendingB = {
...pendingA,
id: "mem_same_key_b",
pendingOwnerSessionID: "session-b",
pendingMessageID: "msg-b",
};
await saveSessionState(tmpDir, {
version: 1,
sessionID: "session-a",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [pendingA],
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "session-b",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [pendingB],
});
await savePendingJournal(tmpDir, {
version: 1,
workspace: { root: tmpDir, key: "test" },
updatedAt: now,
entries: [pendingA, pendingB],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "session-a" } },
});
const journal = await loadPendingJournal(tmpDir);
assert.equal(journal.entries.length, 1);
assert.equal(journal.entries[0].pendingOwnerSessionID, "session-b",
"session-a promotion must not clear session-b's same-key journal entry");
const stateB = await loadSessionState(tmpDir, "session-b");
assert.equal(stateB.pendingMemories.length, 1);
assert.equal(memoryKey(stateB.pendingMemories[0]), memoryKey(pendingB));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.deleted promotes pending memories before deleting session state", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockClientWithLatestUser("remember this: Promote pending memories before delete.", "msg-delete-1");
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "delete-session", model: {} },
{ system: ["base header"] },
);
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.deleted",
properties: { info: { id: "delete-session" } },
},
});
const nextPlugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { system: ["base header"] };
await (nextPlugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "after-delete-session", model: {} },
output,
);
const workspacePrompt = output.system.find((part: string) => part.startsWith("Workspace memory"));
assert.match(workspacePrompt ?? "", /Promote pending memories before delete/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.deleted clears caches even when session state file is already gone", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_before_delete_cache",
type: "project",
text: "Workspace memory before delete cleanup.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
});
return store;
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const beforeOutput = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "deleted-missing-state-session", model: {} },
beforeOutput,
);
assert.match(beforeOutput.system.join("\n"), /Workspace memory before delete cleanup/);
const ownedPending = {
id: "mem_delete_owned_journal",
type: "decision" as const,
text: "Owned journal memory promotes during delete cleanup.",
source: "explicit" as const,
confidence: 1,
status: "active" as const,
createdAt: now,
updatedAt: now,
pendingOwnerSessionID: "deleted-missing-state-session",
pendingMessageID: "msg-delete-owned",
};
await savePendingJournal(tmpDir, {
version: 1,
workspace: { root: tmpDir, key: "test" },
updatedAt: now,
entries: [ownedPending],
});
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.deleted",
properties: { sessionID: "deleted-missing-state-session" },
},
});
const pendingAfter = await loadPendingJournal(tmpDir);
assert.equal(pendingAfter.entries.length, 0,
"clearable owned journal entry should be removed even when session state file is absent");
const afterOutput = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "deleted-missing-state-session", model: {} },
afterOutput,
);
const workspacePrompt = afterOutput.system.find((part: string) => part.startsWith("Workspace memory"));
assert.match(workspacePrompt ?? "", /Owned journal memory promotes during delete cleanup/,
"session.deleted should clear frozen cache after successful promotion");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("duplicate explicit memories dedupe by normalized type and text, not generated id", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const pluginA = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser("remember this: Prefer stable cache boundaries.", "msg-a"),
});
await (pluginA as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "dedupe-session", model: {} },
{ system: ["base header"] },
);
const pluginB = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser("remember this: prefer stable cache boundaries.", "msg-b"),
});
await (pluginB as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "dedupe-session", model: {} },
{ system: ["base header"] },
);
await (pluginB as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "dedupe-session" } },
});
const output = { system: ["base header"] };
const pluginC = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (pluginC as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "dedupe-next", model: {} },
output,
);
const joined = output.system.join("\n");
assert.equal((joined.match(/stable cache boundaries/gi) ?? []).length, 1);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted promotes pending memories to workspace memory and clears pending list", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
await saveSessionState(tmpDir, {
version: 1,
sessionID: "promote-session",
turn: 1,
updatedAt: new Date().toISOString(),
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_pending_1",
type: "decision",
text: "Use frozen rendered snapshots for cache stability.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
}],
});
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.compacted",
properties: { sessionID: "promote-session" },
},
});
const state = await loadSessionState(tmpDir, "promote-session");
assert.equal(state.pendingMemories.length, 0,
"pending memories should be cleared after promotion");
const after = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "new-session-after-promotion", model: {} },
after,
);
const workspacePrompt = after.system.find((part: string) => part.startsWith("Workspace memory"));
assert.match(workspacePrompt ?? "", /Use frozen rendered snapshots for cache stability/);
const workspace = await loadWorkspaceMemory(tmpDir);
const promoted = workspace.entries.find(entry => entry.id === "mem_pending_1");
assert.ok(typeof promoted?.retentionClock === "number",
"legacy pending memory should receive a retention clock when promoted");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted reinforces existing exact workspace memory", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const oldRetentionClock = Date.now() - 10 * 24 * 60 * 60 * 1000;
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "existing-memory",
type: "decision",
text: "Use frozen rendered snapshots for cache stability.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: oldRetentionClock,
});
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "reinforce-existing-session",
turn: 1,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "pending-duplicate",
type: "decision",
text: "Use frozen rendered snapshots for cache stability.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "reinforce-existing-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const existing = workspace.entries.find(entry => entry.id === "existing-memory");
assert.equal(workspace.entries.filter(entry => /frozen rendered/.test(entry.text)).length, 1);
assert.equal(existing?.reinforcementCount, 1);
assert.equal(existing?.lastReinforcedSessionID, "reinforce-existing-session");
assert.ok((existing?.retentionClock ?? 0) > oldRetentionClock);
assert.equal((await loadSessionState(tmpDir, "reinforce-existing-session")).pendingMemories.length, 0);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted applies numbered REINFORCE command to referenced memory", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const now = new Date(nowMs).toISOString();
const lastReinforcedAt = nowMs - 8 * 24 * 60 * 60 * 1000;
const existing: LongTermMemoryEntry = {
id: "numbered-reinforce-memory",
type: "decision",
text: "Use numbered refs for explicit memory reinforcement.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: lastReinforcedAt,
reinforcementCount: 1,
lastReinforcedAt,
lastReinforcedSessionID: "numbered-reinforce-session",
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "numbered-reinforce-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary("Memory candidates:\nREINFORCE [M1]"),
});
await withMockedDateNow(nowMs, async () => {
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "numbered-reinforce-session" } },
});
});
const workspace = await loadWorkspaceMemory(tmpDir);
const reinforced = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(reinforced?.reinforcementCount, 2);
assert.equal(reinforced?.lastReinforcedSessionID, "numbered-reinforce-session");
assert.equal(reinforced?.lastReinforcedAt, nowMs);
assert.equal(reinforced?.retentionClock, nowMs);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] });
const event = events.find(event =>
event.outcome === "reinforced" &&
event.reasonCodes.includes("numbered_ref_reinforce") &&
event.reasonCodes.includes("reinforcement_window_allowed") &&
event.memory?.memoryId === existing.id
);
assert.ok(event, "numbered REINFORCE should emit allowed evidence");
assert.equal(event.instrumentationVersion, 3);
assert.equal(event.details?.reinforcementOutcome, "reinforced");
assert.equal(event.details?.reinforcementMode, "increment");
assert.equal(event.details?.sameSession, true);
assert.equal(event.details?.elapsedMs, 8 * 24 * 60 * 60 * 1000);
assert.equal(event.details?.requiredElapsedMs, 7 * 24 * 60 * 60 * 1000);
assert.equal(event.details?.attemptedAtMs, nowMs);
assert.equal(event.details?.lastReinforcedAtMs, lastReinforcedAt);
assert.equal(event.details?.previousReinforcementCount, 1);
assert.equal(event.details?.newReinforcementCount, 2);
assert.equal(JSON.stringify(event.details).includes("numbered-reinforce-session"), false);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted allows numbered REINFORCE at exact 7-day boundary", async () => {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const lastReinforcedAt = nowMs - 7 * 24 * 60 * 60 * 1000;
const existing: LongTermMemoryEntry = {
id: "numbered-reinforce-exact-window",
type: "decision",
text: "Use exact rolling windows for memory reinforcement.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: new Date(nowMs).toISOString(),
updatedAt: new Date(nowMs).toISOString(),
retentionClock: lastReinforcedAt,
reinforcementCount: 5,
lastReinforcedAt,
lastReinforcedSessionID: "previous-session",
};
await withNumberedReinforceScenario({ sessionID: "exact-window-session", nowMs, existing }, ({ workspace, events }) => {
const reinforced = workspace.entries.find(entry => entry.id === existing.id);
const event = events.find(event => event.outcome === "reinforced" && event.memory?.memoryId === existing.id);
assert.equal(reinforced?.reinforcementCount, 6);
assert.equal(reinforced?.retentionClock, nowMs);
assert.ok(event, "exact 7-day boundary should emit reinforced evidence");
assert.equal(event.details?.reinforcementMode, "increment");
assert.equal(event.details?.elapsedMs, 7 * 24 * 60 * 60 * 1000);
assert.equal(event.details?.requiredElapsedMs, 7 * 24 * 60 * 60 * 1000);
assert.equal(event.instrumentationVersion, 3);
});
});
test("session.compacted blocks different-session numbered REINFORCE below 7-day window", async () => {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const lastReinforcedAt = nowMs - (7 * 24 * 60 * 60 * 1000 - 1);
const existing: LongTermMemoryEntry = {
id: "numbered-reinforce-below-window",
type: "feedback",
text: "User prefers below-window reinforcement blocks.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: new Date(nowMs).toISOString(),
updatedAt: new Date(nowMs).toISOString(),
retentionClock: nowMs - 10 * 24 * 60 * 60 * 1000,
reinforcementCount: 1,
lastReinforcedAt,
lastReinforcedSessionID: "previous-session",
};
await withNumberedReinforceScenario({ sessionID: "different-session", nowMs, existing }, ({ workspace, events }) => {
const blocked = workspace.entries.find(entry => entry.id === existing.id);
const event = events.find(event => event.outcome === "rejected" && event.memory?.memoryId === existing.id);
assert.equal(blocked?.reinforcementCount, 1);
assert.ok(event, "below-window different-session attempt should emit rejected evidence");
assert.ok(event.reasonCodes.includes("reinforcement_block_min_elapsed_window"));
assert.equal(event.details?.blockReason, "min_elapsed_window");
assert.equal(event.details?.sameSession, false);
assert.equal(event.details?.elapsedMs, 7 * 24 * 60 * 60 * 1000 - 1);
assert.equal(event.details?.requiredElapsedMs, 7 * 24 * 60 * 60 * 1000);
assert.equal(event.instrumentationVersion, 3);
});
});
test("session.compacted refreshes saturated numbered REINFORCE after rolling window", async () => {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const lastReinforcedAt = nowMs - 7 * 24 * 60 * 60 * 1000;
const existing: LongTermMemoryEntry = {
id: "numbered-reinforce-refresh-only",
type: "decision",
text: "Use refresh-only mode for saturated reinforcement.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: new Date(nowMs).toISOString(),
updatedAt: new Date(nowMs).toISOString(),
retentionClock: nowMs - 30 * 24 * 60 * 60 * 1000,
reinforcementCount: 6,
lastReinforcedAt,
lastReinforcedSessionID: "previous-session",
};
await withNumberedReinforceScenario({ sessionID: "refresh-only-session", nowMs, existing }, ({ workspace, events }) => {
const refreshed = workspace.entries.find(entry => entry.id === existing.id);
const event = events.find(event => event.outcome === "reinforced" && event.memory?.memoryId === existing.id);
assert.equal(refreshed?.reinforcementCount, 6);
assert.equal(refreshed?.retentionClock, nowMs);
assert.equal(refreshed?.lastReinforcedAt, nowMs);
assert.equal(refreshed?.lastReinforcedSessionID, "refresh-only-session");
assert.ok(event, "saturated after-window attempt should emit refreshed evidence");
assert.equal(event.details?.reinforcementOutcome, "refreshed");
assert.equal(event.details?.reinforcementMode, "refresh_only");
assert.equal(event.details?.previousReinforcementCount, 6);
assert.equal(event.details?.newReinforcementCount, 6);
assert.ok(event.reasonCodes.includes("reinforcement_saturation_refresh"));
assert.equal(event.reasonCodes.includes("reinforcement_block_max_count"), false);
assert.equal(event.instrumentationVersion, 3);
});
});
test("session.compacted emits legacy missing timestamp details for numbered REINFORCE", async () => {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const existing: LongTermMemoryEntry = {
id: "numbered-reinforce-legacy-missing",
type: "feedback",
text: "User prefers legacy timestamp anomalies to be visible.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: new Date(nowMs).toISOString(),
updatedAt: new Date(nowMs).toISOString(),
retentionClock: nowMs - 30 * 24 * 60 * 60 * 1000,
reinforcementCount: 2,
lastReinforcedSessionID: "previous-session",
};
await withNumberedReinforceScenario({ sessionID: "legacy-missing-session", nowMs, existing }, ({ workspace, events }) => {
const reinforced = workspace.entries.find(entry => entry.id === existing.id);
const event = events.find(event => event.outcome === "reinforced" && event.memory?.memoryId === existing.id);
assert.equal(reinforced?.reinforcementCount, 3);
assert.equal(reinforced?.lastReinforcedAt, nowMs);
assert.equal(reinforced?.retentionClock, nowMs);
assert.equal(event?.details?.legacyMissingTimestamp, true);
assert.equal(event?.details?.reinforcementMode, "increment");
assert.equal(event?.instrumentationVersion, 3);
});
});
test("session.compacted rejects invalid unavailable and stale REINFORCE refs without mutation", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const current: LongTermMemoryEntry = {
id: "stale-numbered-target",
type: "decision",
text: "Current durable memory text should not reinforce from a stale snapshot.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: Date.now() - 5 * 24 * 60 * 60 * 1000,
};
const oldSnapshot = {
...current,
text: "Old durable memory text from the compaction snapshot.",
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(current);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "numbered-reinforce-reject-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [
compactionRefFor(current, "M1", {
exactKey: workspaceMemoryExactKey(oldSnapshot),
identityKey: workspaceMemoryIdentityKey(oldSnapshot),
textPreview: oldSnapshot.text,
}),
compactionRefFor({ ...current, id: "missing-numbered-target" }, "M2"),
],
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary([
"Memory candidates:",
"REINFORCE [M1]",
"REINFORCE [M2]",
"REINFORCE [M9]",
].join("\n")),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "numbered-reinforce-reject-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const target = workspace.entries.find(entry => entry.id === current.id);
assert.equal(target?.reinforcementCount ?? 0, 0);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] });
const rejectedReasons = events
.filter(event => event.outcome === "rejected")
.flatMap(event => event.reasonCodes);
assert.ok(rejectedReasons.includes("memory_ref_target_changed"));
assert.ok(rejectedReasons.includes("memory_ref_target_unavailable"));
assert.ok(rejectedReasons.includes("invalid_memory_ref"));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted emits rejected evidence when numbered REINFORCE is blocked by retention gates", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const nowMs = Date.UTC(2026, 4, 15, 12, 0, 0);
const now = new Date(nowMs).toISOString();
const lastReinforcedAt = nowMs - (7 * 24 * 60 * 60 * 1000 - 60 * 60 * 1000);
const existing: LongTermMemoryEntry = {
id: "blocked-numbered-reinforce",
type: "feedback",
text: "User prefers deterministic numbered-ref reinforcement evidence.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: nowMs - 10 * 24 * 60 * 60 * 1000,
reinforcementCount: 1,
lastReinforcedAt,
lastReinforcedSessionID: "blocked-reinforce-session",
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "blocked-reinforce-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary("Memory candidates:\nREINFORCE [M1]"),
});
await withMockedDateNow(nowMs, async () => {
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "blocked-reinforce-session" } },
});
});
const workspace = await loadWorkspaceMemory(tmpDir);
assert.equal(workspace.entries.filter(entry => entry.id === existing.id).length, 1);
const blocked = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(blocked?.reinforcementCount, 1);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] });
const event = events.find(event =>
event.outcome === "rejected" &&
event.reasonCodes.includes("reinforcement_window_blocked") &&
event.reasonCodes.includes("reinforcement_block_min_elapsed_window") &&
event.memory?.memoryId === existing.id &&
event.relations?.some(relation => relation.role === "target" && relation.memory?.memoryId === existing.id) &&
!event.relations?.some(relation => relation.role === "reinforced")
);
assert.ok(event, "blocked numbered REINFORCE should emit elapsed-window evidence");
assert.equal(event.instrumentationVersion, 3);
assert.equal(event.reasonCodes.includes("reinforcement_block_same_session"), false);
assert.equal(event.reasonCodes.includes("reinforcement_block_same_utc_day"), false);
assert.equal(event.reasonCodes.includes("reinforcement_block_min_interval"), false);
assert.equal(event.reasonCodes.includes("reinforcement_block_max_count"), false);
assert.equal(event.details?.blockReason, "min_elapsed_window");
assert.equal(event.details?.elapsedMs, 7 * 24 * 60 * 60 * 1000 - 60 * 60 * 1000);
assert.equal(event.details?.requiredElapsedMs, 7 * 24 * 60 * 60 * 1000);
assert.equal(event.details?.sameSession, true);
assert.equal(event.details?.attemptedAtMs, nowMs);
assert.equal(event.details?.lastReinforcedAtMs, lastReinforcedAt);
assert.equal(event.details?.reinforcementCount, 1);
assert.equal(event.details?.maxReinforcementCount, 6);
assert.equal("minIntervalMs" in (event.details ?? {}), false);
assert.equal("reinforcementMode" in (event.details ?? {}), false);
assert.equal(JSON.stringify(event.details).includes("blocked-reinforce-session"), false);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted applies REINFORCE plus new candidate append through normal promotion", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "reinforce-plus-append-existing",
type: "decision",
text: "Use numbered refs for durable memory consolidation.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "reinforce-plus-append-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const newCandidateText = "Use numbered refs plus audit evidence for durable consolidation.";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary([
"Memory candidates:",
"REINFORCE [M1]",
`- [decision] ${newCandidateText}`,
].join("\n")),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "reinforce-plus-append-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const reinforced = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(reinforced?.reinforcementCount, 1);
assert.ok(workspace.entries.some(entry => entry.text === newCandidateText && entry.status === "active"));
const events = await queryEvidenceEvents(tmpDir, { newestFirst: false });
assert.ok(events.some(event => event.type === "memory_reinforced" && event.outcome === "reinforced"));
assert.ok(events.some(event => event.type === "promotion_promoted" && event.textPreview === newCandidateText));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted replaces unreinforced compaction memory with same-type numbered command", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "replace-same-type-target",
type: "decision",
text: "Use old replacement wording for numbered ref consolidation.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "replace-same-type-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const replacementText = "Use corrected replacement wording for numbered ref consolidation.";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(`Memory candidates:\nREPLACE [M1] [decision] ${replacementText}`),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "replace-same-type-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const oldTarget = workspace.entries.find(entry => entry.id === existing.id);
const replacement = workspace.entries.find(entry => entry.text === replacementText);
assert.equal(oldTarget?.status, "superseded");
assert.equal(replacement?.status, "active");
assert.equal(replacement?.type, "decision");
assert.equal(replacement?.source, "compaction");
assert.deepEqual(replacement?.supersedes, [existing.id]);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "superseded" &&
event.reasonCodes.includes("numbered_ref_replace") &&
event.reasonCodes.includes("same_type_replace") &&
event.relations?.some(relation => relation.role === "superseded" && relation.memory?.memoryId === existing.id) &&
event.relations?.some(relation => relation.role === "superseded_by" && relation.memory?.memoryId === replacement?.id)
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted applies cross-type numbered REPLACE for eligible compaction target", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "replace-cross-type-target",
type: "project",
text: "This repository uses an old replacement categorization.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "replace-cross-type-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const replacementText = "Use numbered REPLACE only for correcting eligible compaction memory records.";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(`Memory candidates:\nREPLACE [M1] [decision] ${replacementText}`),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "replace-cross-type-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const oldTarget = workspace.entries.find(entry => entry.id === existing.id);
const replacement = workspace.entries.find(entry => entry.text === replacementText);
assert.equal(oldTarget?.status, "superseded");
assert.equal(replacement?.type, "decision");
assert.deepEqual(replacement?.supersedes, [existing.id]);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "superseded" &&
event.reasonCodes.includes("numbered_ref_replace") &&
event.reasonCodes.includes("cross_type_replace")
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted rejects numbered REPLACE for reinforced compaction target", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "replace-reinforced-target",
type: "decision",
text: "Keep protected replacement targets when they have reinforcement history.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
reinforcementCount: 1,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "replace-reinforced-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const replacementText = "Use replacement text that should not be applied to reinforced memory.";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(`Memory candidates:\nREPLACE [M1] [decision] ${replacementText}`),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "replace-reinforced-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
assert.equal(workspace.entries.find(entry => entry.id === existing.id)?.status, "active");
assert.equal(workspace.entries.some(entry => entry.text === replacementText), false);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "rejected" &&
event.reasonCodes.includes("protected_reinforced_target") &&
event.memory?.memoryId === existing.id &&
event.relations?.some(relation => relation.role === "target" && relation.memory?.memoryId === existing.id) &&
!event.relations?.some(relation => relation.role === "superseded" || relation.role === "superseded_by")
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted rejects numbered REPLACE for explicit or manual targets", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const explicitTarget: LongTermMemoryEntry = {
id: "replace-explicit-target",
type: "feedback",
text: "User prefers protected explicit memory records.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
};
const manualTarget: LongTermMemoryEntry = {
id: "replace-manual-target",
type: "project",
text: "This workspace has protected manual memory records.",
source: "manual",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(explicitTarget, manualTarget);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "replace-protected-source-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(explicitTarget), compactionRefFor(manualTarget, "M2")],
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary([
"Memory candidates:",
"REPLACE [M1] [feedback] User prefers unprotected explicit replacement records.",
"REPLACE [M2] [project] This workspace has unprotected manual replacement records.",
].join("\n")),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "replace-protected-source-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
assert.equal(workspace.entries.find(entry => entry.id === explicitTarget.id)?.status, "active");
assert.equal(workspace.entries.find(entry => entry.id === manualTarget.id)?.status, "active");
assert.equal(workspace.entries.length, 2);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
const protectedEvents = events.filter(event => event.reasonCodes.includes("protected_memory_source"));
assert.equal(protectedEvents.length, 2);
assert.ok(protectedEvents.some(event => event.memory?.memoryId === explicitTarget.id));
assert.ok(protectedEvents.some(event => event.memory?.memoryId === manualTarget.id));
assert.ok(protectedEvents.every(event => event.relations?.some(relation => relation.role === "target")));
assert.ok(protectedEvents.every(event => !event.relations?.some(relation => relation.role === "superseded" || relation.role === "superseded_by")));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted rejects low-quality numbered REPLACE and leaves target active", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "replace-quality-target",
type: "decision",
text: "Use quality gates before applying numbered replacement commands.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "replace-quality-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [],
compactionMemoryRefs: [compactionRefFor(existing)],
});
const badReplacement = "Task A.5 completed successfully.";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(`Memory candidates:\nREPLACE [M1] [decision] ${badReplacement}`),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "replace-quality-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
assert.equal(workspace.entries.find(entry => entry.id === existing.id)?.status, "active");
assert.equal(workspace.entries.some(entry => entry.text === badReplacement), false);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "rejected" &&
event.reasonCodes.includes("progress_snapshot") &&
event.memory?.memoryId === existing.id &&
event.relations?.some(relation => relation.role === "target" && relation.memory?.memoryId === existing.id) &&
!event.relations?.some(relation => relation.role === "superseded" || relation.role === "superseded_by")
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("e2e compaction numbered refs reinforce and promote appended candidate then clear refs", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-e2e-"));
try {
const now = new Date().toISOString();
const oldRetentionClock = Date.now() - 9 * 24 * 60 * 60 * 1000;
const existing: LongTermMemoryEntry = {
id: "e2e-reinforce-existing",
type: "decision",
text: "Use numbered refs for compaction consolidation decisions.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: oldRetentionClock,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
const additionText = "Use audit-safe addition memory when numbered refs reinforce existing consolidation facts.";
let summary = "";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithMutableCompactionSummary(() => summary),
});
const compactingOutput = { context: [], prompt: "" };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "e2e-reinforce-append-session" },
compactingOutput,
);
assert.match(compactingOutput.prompt, /Existing workspace memories available for consolidation:/);
assert.match(compactingOutput.prompt, /\[M1\] Use numbered refs for compaction consolidation decisions\./);
assert.deepEqual(
(await loadSessionState(tmpDir, "e2e-reinforce-append-session")).compactionMemoryRefs.map(ref => ref.memoryId),
[existing.id],
);
const compactionId = (await loadSessionState(tmpDir, "e2e-reinforce-append-session")).compactionMemoryRefs[0]?.compactionId;
assert.ok(compactionId);
summary = [
"## Goal",
"Continue the task.",
"",
"Memory candidates:",
`Memory ref snapshot id: ${compactionId}`,
"REINFORCE [M1]",
`- [decision] ${additionText}`,
].join("\n");
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "e2e-reinforce-append-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const reinforced = workspace.entries.find(entry => entry.id === existing.id);
const addition = workspace.entries.find(entry => entry.text === additionText);
assert.equal(reinforced?.reinforcementCount, 1);
assert.equal(reinforced?.lastReinforcedSessionID, "e2e-reinforce-append-session");
assert.ok((reinforced?.retentionClock ?? 0) > oldRetentionClock);
assert.equal(addition?.status, "active");
assert.equal(addition?.source, "compaction");
const stateAfter = await loadSessionState(tmpDir, "e2e-reinforce-append-session");
assert.deepEqual(stateAfter.compactionMemoryRefs, []);
assert.equal(stateAfter.pendingMemories.length, 0);
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 0);
const events = await queryEvidenceEvents(tmpDir, { newestFirst: false });
assert.ok(events.some(event => event.type === "render_selected" && event.memory?.memoryId === existing.id));
assert.ok(events.some(event => event.type === "memory_reinforced" && event.outcome === "reinforced" && event.memory?.memoryId === existing.id));
assert.ok(events.some(event => event.type === "promotion_promoted" && event.textPreview === additionText));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("e2e compaction numbered refs apply cross-type REPLACE and clear refs", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-e2e-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "e2e-replace-existing",
type: "project",
text: "This repository stores replacement policy as a project fact.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
const replacementText = "Use numbered REPLACE only for eligible unreinforced compaction memory corrections.";
let summary = "";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithMutableCompactionSummary(() => summary),
});
const compactingOutput = { context: [], prompt: "" };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "e2e-replace-session" },
compactingOutput,
);
assert.match(compactingOutput.prompt, /\[M1\] This repository stores replacement policy as a project fact\./);
const persistedRef = (await loadSessionState(tmpDir, "e2e-replace-session")).compactionMemoryRefs[0];
assert.equal(persistedRef?.memoryId, existing.id);
assert.ok(persistedRef?.compactionId);
summary = [
"Memory candidates:",
`Memory ref snapshot id: ${persistedRef.compactionId}`,
`REPLACE [M1] [decision] ${replacementText}`,
].join("\n");
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "e2e-replace-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const oldTarget = workspace.entries.find(entry => entry.id === existing.id);
const replacement = workspace.entries.find(entry => entry.text === replacementText);
assert.equal(oldTarget?.status, "superseded");
assert.equal(replacement?.status, "active");
assert.equal(replacement?.type, "decision");
assert.deepEqual(replacement?.supersedes, [existing.id]);
assert.deepEqual((await loadSessionState(tmpDir, "e2e-replace-session")).compactionMemoryRefs, []);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "superseded" &&
event.reasonCodes.includes("numbered_ref_replace") &&
event.reasonCodes.includes("cross_type_replace") &&
event.relations?.some(relation => relation.role === "superseded" && relation.memory?.memoryId === existing.id) &&
event.relations?.some(relation => relation.role === "superseded_by" && relation.memory?.memoryId === replacement?.id)
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("e2e compaction stale numbered ref rejects after concurrent workspace mutation and clears refs", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-e2e-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "e2e-stale-existing",
type: "decision",
text: "Use original stale ref text before concurrent mutation.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
const replacementText = "Use replacement text that must not apply to stale refs.";
let summary = "";
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithMutableCompactionSummary(() => summary),
});
const compactingOutput = { context: [], prompt: "" };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "e2e-stale-session" },
compactingOutput,
);
assert.match(compactingOutput.prompt, /\[M1\] Use original stale ref text before concurrent mutation\./);
const persistedRef = (await loadSessionState(tmpDir, "e2e-stale-session")).compactionMemoryRefs[0];
assert.equal(persistedRef?.exactKey, workspaceMemoryExactKey(existing));
assert.ok(persistedRef?.compactionId);
summary = [
"Memory candidates:",
`Memory ref snapshot id: ${persistedRef.compactionId}`,
`REPLACE [M1] [decision] ${replacementText}`,
].join("\n");
await updateWorkspaceMemory(tmpDir, store => {
const target = store.entries.find(entry => entry.id === existing.id);
assert.ok(target);
target.text = "Use concurrently changed stale ref text before compacted handling.";
target.updatedAt = new Date().toISOString();
return store;
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "e2e-stale-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const targetAfter = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(targetAfter?.status, "active");
assert.equal(targetAfter?.text, "Use concurrently changed stale ref text before compacted handling.");
assert.equal(workspace.entries.some(entry => entry.text === replacementText), false);
assert.deepEqual((await loadSessionState(tmpDir, "e2e-stale-session")).compactionMemoryRefs, []);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_replaced_numbered_ref"] });
assert.ok(events.some(event =>
event.outcome === "rejected" &&
event.reasonCodes.includes("memory_ref_target_changed") &&
event.memory?.memoryId === existing.id
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("overlapping compactions reject numbered commands from stale ref snapshot", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-e2e-overlap-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "overlap-numbered-target",
type: "decision",
text: "Use compaction snapshot ids to guard numbered memory refs.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: Date.now() - 9 * 24 * 60 * 60 * 1000,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
let summary = "";
const client = {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({
data: summary
? [{ info: { role: "assistant", summary: true }, parts: [{ type: "text", text: summary }] }]
: [],
}),
todo: async () => ({ data: [] }),
},
};
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
const firstOutput = { prompt: "", context: [] as string[] };
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "overlap-compaction-session" },
firstOutput,
);
const firstId = (await loadSessionState(tmpDir, "overlap-compaction-session")).compactionMemoryRefs[0]?.compactionId;
assert.ok(firstId);
assert.match(firstOutput.prompt, new RegExp(`Memory ref snapshot id: ${firstId}`));
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "overlap-compaction-session" },
{ prompt: "", context: [] as string[] },
);
const secondId = (await loadSessionState(tmpDir, "overlap-compaction-session")).compactionMemoryRefs[0]?.compactionId;
assert.ok(secondId);
assert.notEqual(secondId, firstId);
summary = [
"Memory candidates:",
`Memory ref snapshot id: ${firstId}`,
"REINFORCE [M1]",
].join("\n");
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "overlap-compaction-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const target = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(target?.reinforcementCount ?? 0, 0);
assert.deepEqual((await loadSessionState(tmpDir, "overlap-compaction-session")).compactionMemoryRefs, []);
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] });
assert.ok(events.some(event =>
event.outcome === "rejected" &&
event.reasonCodes.includes("missing_memory_ref_snapshot") &&
event.details?.compactionId === firstId &&
event.details?.storedCompactionId === secondId
));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction id omission falls back to exact ref validation", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-e2e-compaction-id-fallback-"));
try {
const now = new Date().toISOString();
const existing: LongTermMemoryEntry = {
id: "fallback-numbered-target",
type: "decision",
text: "Use exact ref validation when compaction summaries omit snapshot ids.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
retentionClock: Date.now() - 9 * 24 * 60 * 60 * 1000,
};
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push(existing);
return store;
});
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary([
"Memory candidates:",
"REINFORCE [M1]",
].join("\n")),
});
await (plugin as Record<string, Function>)["experimental.session.compacting"](
{ sessionID: "compaction-id-fallback-session" },
{ prompt: "", context: [] as string[] },
);
const persistedRef = (await loadSessionState(tmpDir, "compaction-id-fallback-session")).compactionMemoryRefs[0];
assert.equal(persistedRef?.memoryId, existing.id);
assert.ok(persistedRef?.compactionId);
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "compaction-id-fallback-session" } },
});
const workspace = await loadWorkspaceMemory(tmpDir);
const target = workspace.entries.find(entry => entry.id === existing.id);
assert.equal(target?.reinforcementCount, 1);
assert.equal(target?.lastReinforcedSessionID, "compaction-id-fallback-session");
const events = await queryEvidenceEvents(tmpDir, { types: ["memory_reinforced"] });
assert.ok(events.some(event =>
event.outcome === "reinforced" &&
event.memory?.memoryId === existing.id
));
assert.equal(events.some(event => event.reasonCodes.includes("missing_memory_ref_snapshot")), false);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("integration: explicit memory flows from user message through pending journal into workspace", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser("remember this: Prefer deterministic consolidation accounting.", "msg-explicit-flow"),
});
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "explicit-flow-session", model: {} },
{ system: ["base header"] },
);
assert.equal((await loadSessionState(tmpDir, "explicit-flow-session")).pendingMemories.length, 1);
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 1);
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "explicit-flow-session" } },
});
assert.equal((await loadSessionState(tmpDir, "explicit-flow-session")).pendingMemories.length, 0);
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 0);
const output = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "explicit-flow-session", model: {} },
output,
);
assert.match(output.system.join("\n"), /Prefer deterministic consolidation accounting/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("explicit memory lifecycle emits detected appended and promoted evidence", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser("remember this: Prefer evidence-backed lifecycle tests.", "msg-evidence-life"),
});
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "evidence-life-session", model: {} },
{ system: ["base header"] },
);
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "evidence-life-session" } },
});
const events = await queryEvidenceEvents(tmpDir, { newestFirst: false });
const eventTypes = events.map(event => event.type);
assert.ok(eventTypes.includes("explicit_memory_detected"));
assert.ok(eventTypes.includes("pending_memory_appended"));
assert.ok(eventTypes.includes("promotion_promoted"));
const output = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "evidence-life-session", model: {} },
output,
);
const finalEvents = await queryEvidenceEvents(tmpDir, { newestFirst: false });
assert.ok(finalEvents.map(event => event.type).includes("render_selected"));
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted promotes first-time explicit memory without self-reinforcement", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithLatestUser(
"remember this: Prefer no self reinforcement during first promotion.",
"msg-no-self-reinforce",
),
});
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "no-self-reinforce-session", model: {} },
{ system: ["base header"] },
);
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.compacted",
properties: { sessionID: "no-self-reinforce-session" },
},
});
const workspace = await loadWorkspaceMemory(tmpDir);
const promoted = workspace.entries.find(entry =>
/Prefer no self reinforcement/.test(entry.text)
);
assert.ok(promoted, "explicit memory should be promoted");
assert.equal(promoted.reinforcementCount ?? 0, 0);
assert.equal(promoted.lastReinforcedSessionID, undefined);
const state = await loadSessionState(tmpDir, "no-self-reinforce-session");
assert.equal(state.pendingMemories.length, 0);
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 0);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("integration: compaction candidate flows through journal promotion and clears pending journal", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const summary = `
## Goal
Continue durable memory work.
## Memory Candidates
- [decision] Use accounting events to classify promoted absorbed superseded and rejected memories.
`;
const plugin = await MemoryV2Plugin({
directory: tmpDir,
client: mockClientWithCompactionSummary(summary),
});
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "compaction-flow-session" } },
});
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 0,
"compaction candidate should be promoted and then cleared from pending journal");
const output = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "after-compaction-flow", model: {} },
output,
);
assert.match(output.system.join("\n"), /accounting events to classify promoted absorbed superseded and rejected memories/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("integration: next session promotes prior unowned journal and leaves journal clean", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await savePendingJournal(tmpDir, {
version: 1,
workspace: { root: tmpDir, key: "test" },
updatedAt: now,
entries: [{
id: "mem_unowned_cross_session",
type: "feedback",
text: "Cross-session unowned promotion keeps the journal clean.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 1);
const secondPlugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output = { system: ["base header"] };
await (secondPlugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "second-cross-session", model: {} },
output,
);
assert.equal((await loadPendingJournal(tmpDir)).entries.length, 0);
assert.match(output.system.join("\n"), /Cross-session unowned promotion keeps the journal clean/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("same-session explicit memory does not mutate frozen system[1]", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
// 1. Seed workspace memory so system[1] exists before explicit memory is added.
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_existing_stable",
type: "project",
text: "Existing stable workspace memory.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
});
return store;
});
// 2. Use one plugin instance with a mutable mock client so the in-memory
// frozen cache is preserved across turns while the latest user message changes.
let latestMessages: Array<Record<string, unknown>> = [];
const client = {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({ data: latestMessages }),
todo: async () => ({ data: [] }),
},
};
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
const output1 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "frozen-cache-session", model: {} },
output1,
);
const firstSystem1 = output1.system.find((part: string) => part.startsWith("Workspace memory"));
assert.match(firstSystem1 ?? "", /Existing stable workspace memory/,
"first transform should create a frozen workspace memory system[1]");
// 3. User says "remember X" in the same session.
latestMessages = [{
info: { role: "user", id: "msg-explicit-1" },
parts: [{ type: "text", text: "remember this: Same-session memory stays ephemeral." }],
}];
const output2 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "frozen-cache-session", model: {} },
output2,
);
// 4. Assert: workspace system[1] unchanged (frozen snapshot).
const secondSystem1 = output2.system.find((part: string) => part.startsWith("Workspace memory"));
assert.equal(secondSystem1, firstSystem1,
"frozen system[1] must not change after explicit memory in same session");
// 5. Assert: hot state (system[2+]) contains the pending memory.
const hotState = output2.system.find((part: string) => part.includes("Hot session state"));
assert.ok(hotState, "hot session state should be rendered");
assert.match(hotState, /pending_memories:/,
"hot state should contain pending_memories section");
assert.match(hotState, /Same-session memory stays ephemeral/,
"hot state should contain the explicit memory text");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("chat system transform reloads frozen workspace snapshot after cache TTL expires", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
const originalNow = Date.now;
let now = originalNow();
Date.now = () => now;
try {
const timestamp = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_cache_ttl_old",
type: "project",
text: "Workspace memory before TTL expiry.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: timestamp,
updatedAt: timestamp,
});
return store;
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
const output1 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "ttl-session", model: {} },
output1,
);
assert.match(output1.system.join("\n"), /Workspace memory before TTL expiry/);
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_cache_ttl_new",
type: "project",
text: "Workspace memory after TTL expiry.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: timestamp,
updatedAt: timestamp,
});
return store;
});
now += WORKSPACE_MEMORY_CACHE_LIMITS.frozenTtlMs + 1;
const output2 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "ttl-session", model: {} },
output2,
);
assert.match(output2.system.join("\n"), /Workspace memory after TTL expiry/);
} finally {
Date.now = originalNow;
await rm(tmpDir, { recursive: true, force: true });
}
});
test("chat system transform evicts oldest frozen snapshots when cache exceeds session limit", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const timestamp = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_cache_size_old",
type: "project",
text: "Workspace memory before cache pressure.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: timestamp,
updatedAt: timestamp,
});
return store;
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
for (let i = 0; i <= WORKSPACE_MEMORY_CACHE_LIMITS.maxFrozenSessions; i += 1) {
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: `cache-size-session-${i}`, model: {} },
{ system: ["base header"] },
);
}
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_cache_size_new",
type: "project",
text: "Workspace memory after cache pressure.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: timestamp,
updatedAt: timestamp,
});
return store;
});
const output = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "cache-size-session-0", model: {} },
output,
);
assert.match(output.system.join("\n"), /Workspace memory after cache pressure/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("processed user message cache keeps only the latest message IDs per session", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
let latestMessages: Array<Record<string, unknown>> = [];
const client = {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async () => ({ data: latestMessages }),
todo: async () => ({ data: [] }),
},
};
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
for (let i = 0; i <= WORKSPACE_MEMORY_CACHE_LIMITS.maxProcessedMessagesPerSession; i += 1) {
latestMessages = [{
info: { role: "user", id: `msg-${i}` },
parts: [{ type: "text", text: `remember this: Processed cache filler memory ${i}.` }],
}];
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "processed-cache-session", model: {} },
{ system: ["base header"] },
);
}
latestMessages = [{
info: { role: "user", id: "msg-0" },
parts: [{ type: "text", text: "remember this: Evicted processed message id can be reused." }],
}];
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "processed-cache-session", model: {} },
{ system: ["base header"] },
);
const state = await loadSessionState(tmpDir, "processed-cache-session");
assert.ok(
state.pendingMemories.some(memory => /Evicted processed message id can be reused/.test(memory.text)),
"oldest processed message id should be evicted and accepted again",
);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("processed user message cache evicts oldest session ID sets", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const latestBySession = new Map<string, Array<Record<string, unknown>>>();
const client = {
session: {
get: async () => ({ data: { parentID: null } }),
messages: async ({ path }: { path?: { id?: string } } = {}) => ({
data: latestBySession.get(path?.id ?? "") ?? [],
}),
todo: async () => ({ data: [] }),
},
};
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
for (let i = 0; i <= WORKSPACE_MEMORY_CACHE_LIMITS.maxProcessedSessionIDs; i += 1) {
const sessionID = `processed-session-${i}`;
latestBySession.set(sessionID, [{
info: { role: "user", id: `msg-${i}` },
parts: [{ type: "text", text: `remember this: Session cache filler memory ${i}.` }],
}]);
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID, model: {} },
{ system: ["base header"] },
);
}
latestBySession.set("processed-session-0", [{
info: { role: "user", id: "msg-0" },
parts: [{ type: "text", text: "remember this: Evicted processed session set can process again." }],
}]);
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "processed-session-0", model: {} },
{ system: ["base header"] },
);
const state = await loadSessionState(tmpDir, "processed-session-0");
assert.ok(
state.pendingMemories.some(memory => /Evicted processed session set can process again/.test(memory.text)),
"oldest processed session set should be evicted and accept the same message id again",
);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("compaction intentionally refreshes frozen system[1] with promoted memories", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
// 1. Seed workspace memory, then first transform creates non-empty frozen system[1].
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_old_stable",
type: "project",
text: "Old stable memory.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: now,
updatedAt: now,
});
return store;
});
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
const output1 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "compaction-refresh-session", model: {} },
output1,
);
const firstSystem1 = output1.system.find((part: string) => part.startsWith("Workspace memory"));
assert.match(firstSystem1 ?? "", /Old stable memory/,
"first transform should create a non-empty frozen system[1]");
// 2. Add pending memory to session state
await saveSessionState(tmpDir, {
version: 1,
sessionID: "compaction-refresh-session",
turn: 1,
updatedAt: new Date().toISOString(),
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_compaction_test",
type: "decision",
text: "Compaction refreshes frozen snapshot.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
}],
});
// 3. Fire session.compacted event
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.compacted",
properties: { sessionID: "compaction-refresh-session" },
},
});
// 4. Next transform same session - system[1] should be refreshed
const output2 = { system: ["base header"] };
await (plugin as Record<string, Function>)["experimental.chat.system.transform"](
{ sessionID: "compaction-refresh-session", model: {} },
output2,
);
const secondSystem1 = output2.system.find((part: string) => part.startsWith("Workspace memory"));
// 5. Assert: system[1] changed (compaction started new cache epoch)
assert.notEqual(secondSystem1, firstSystem1,
"frozen system[1] should change after compaction (new cache epoch)");
// 6. Assert: old stable memory is preserved and promoted memory is now in system[1]
assert.match(secondSystem1 ?? "", /Old stable memory/,
"refreshed system[1] should preserve existing workspace memory");
assert.match(secondSystem1 ?? "", /Compaction refreshes frozen snapshot/,
"promoted memory should appear in refreshed system[1]");
// 7. Assert: pending memory cleared from hot state
const hotState = output2.system.find((part: string) => part.includes("Hot session state"));
if (hotState) {
assert.equal(hotState.includes("pending_memories:"), false,
"pending_memories should be cleared after promotion");
}
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted clears pending memory absorbed by existing workspace duplicate", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_existing_duplicate",
type: "decision",
text: "Prefer stable cache boundaries.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "absorbed-duplicate-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_pending_duplicate",
type: "decision",
text: "prefer stable cache boundaries.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "absorbed-duplicate-session" } },
});
const state = await loadSessionState(tmpDir, "absorbed-duplicate-session");
assert.equal(state.pendingMemories.length, 0,
"duplicate pending memory should be cleared after it is absorbed by existing workspace memory");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted promotes pending memory when exact existing entry is only superseded", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_superseded_duplicate",
type: "decision",
text: "Revive superseded exact memories when remembered again.",
source: "explicit",
confidence: 1,
status: "superseded",
createdAt: now,
updatedAt: now,
});
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "superseded-boundary-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_pending_revive",
type: "decision",
text: "Revive superseded exact memories when remembered again.",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "superseded-boundary-session" } },
});
const state = await loadSessionState(tmpDir, "superseded-boundary-session");
assert.equal(state.pendingMemories.length, 0,
"revived pending memory should be cleared after successful promotion");
const workspace = await loadWorkspaceMemory(tmpDir);
const activeMatches = workspace.entries.filter(entry =>
entry.status === "active" && /Revive superseded exact memories/.test(entry.text)
);
assert.equal(activeMatches.length, 1,
"pending memory should become active even when only matching prior entry is superseded");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted clears pending memory absorbed by existing workspace identity", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
store.entries.push({
id: "mem_existing_parser_formats",
type: "decision",
text: "Parser supports 2 candidate formats.",
source: "compaction",
confidence: 0.9,
status: "active",
createdAt: "2026-04-27T10:00:00.000Z",
updatedAt: "2026-04-27T10:00:00.000Z",
});
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "absorbed-identity-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_pending_parser_formats",
type: "decision",
text: "Parser supports 3 candidate formats.",
source: "compaction",
confidence: 0.75,
status: "active",
createdAt: "2026-04-27T09:00:00.000Z",
updatedAt: "2026-04-27T09:00:00.000Z",
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "absorbed-identity-session" } },
});
const state = await loadSessionState(tmpDir, "absorbed-identity-session");
assert.equal(state.pendingMemories.length, 0,
"same-identity pending memory should be cleared after workspace normalization keeps an equivalent entry");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted clears compaction pending memory rejected by workspace entry cap", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_feedback_${i}`,
type: "feedback",
text: `High priority user feedback memory ${i} that should outrank low priority references.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_decision_${i}`,
type: "decision",
text: `High priority decision memory ${i} that should outrank low priority references.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 8; i += 1) {
store.entries.push({
id: `mem_high_project_${i}`,
type: "project",
text: `High priority project memory ${i} that should outrank low priority references.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "rejected-cap-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_low_priority_reference",
type: "reference",
text: "Low priority reference memory that should not fit when the workspace cap is full.",
source: "compaction",
confidence: 0.1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "rejected-cap-session" } },
});
const state = await loadSessionState(tmpDir, "rejected-cap-session");
assert.equal(state.pendingMemories.length, 0,
"compaction pending memory rejected by workspace cap should be terminal and clearable");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted keeps explicit pending memory rejected by workspace entry cap", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_explicit_reject_feedback_${i}`,
type: "feedback",
text: `Pinned high priority feedback for explicit reject ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_explicit_reject_decision_${i}`,
type: "decision",
text: `Pinned high priority decision for explicit reject ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 8; i += 1) {
store.entries.push({
id: `mem_high_explicit_reject_project_${i}`,
type: "project",
text: `Pinned high priority project for explicit reject ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "explicit-rejected-cap-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_explicit_low_priority_reference",
type: "reference",
text: "Explicit reference should remain pending when capacity rejected.",
source: "explicit",
confidence: 0.1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "explicit-rejected-cap-session" } },
});
const state = await loadSessionState(tmpDir, "explicit-rejected-cap-session");
assert.equal(state.pendingMemories.length, 1,
"explicit pending memory rejected by workspace cap should remain pending for retry");
assert.match(state.pendingMemories[0].text, /Explicit reference/);
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("explicit capacity rejection records bounded retry metadata", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_bounded_reject_feedback_${i}`,
type: "feedback",
text: `Pinned high priority feedback for bounded rejection ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_bounded_reject_decision_${i}`,
type: "decision",
text: `Pinned high priority decision for bounded rejection ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 8; i += 1) {
store.entries.push({
id: `mem_high_bounded_reject_project_${i}`,
type: "project",
text: `Pinned high priority project for bounded rejection ${i}.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
return store;
});
const rejectedMemory = {
id: "mem_explicit_bounded_reject",
type: "reference" as const,
text: "Explicit reference should retry only a bounded number of times.",
source: "explicit" as const,
confidence: 0.1,
status: "active" as const,
createdAt: now,
updatedAt: now,
pendingOwnerSessionID: "bounded-reject-session",
pendingMessageID: "msg-bounded-reject",
};
await saveSessionState(tmpDir, {
version: 1,
sessionID: "bounded-reject-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [rejectedMemory],
});
await savePendingJournal(tmpDir, {
version: 1,
workspace: { root: tmpDir, key: "test" },
updatedAt: now,
entries: [rejectedMemory],
});
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
for (let attempt = 1; attempt < PROMOTION_RETRY_LIMITS.maxExplicitAttempts; attempt += 1) {
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "bounded-reject-session" } },
});
const journal = await loadPendingJournal(tmpDir);
assert.equal(journal.entries.length, 1,
"explicit rejection should not silently clear before retry exhaustion");
assert.equal(journal.entries[0].promotionAttempts, attempt);
assert.equal(journal.entries[0].lastPromotionFailureReason, "rejected_capacity");
const state = await loadSessionState(tmpDir, "bounded-reject-session");
assert.equal(state.pendingMemories.length, 1,
"hot session state should keep retryable explicit memory visible before exhaustion");
}
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "bounded-reject-session" } },
});
const journal = await loadPendingJournal(tmpDir);
assert.equal(journal.entries.length, 0,
"explicit pending journal entry should clear after max retry attempts");
const state = await loadSessionState(tmpDir, "bounded-reject-session");
assert.equal(state.pendingMemories.length, 0,
"explicit hot session state should clear after retry exhaustion");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted clears compaction pending memories when all rejected by workspace cap", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const now = new Date().toISOString();
await updateWorkspaceMemory(tmpDir, store => {
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_all_rejected_feedback_${i}`,
type: "feedback",
text: `Pinned high priority feedback ${i} that keeps the workspace entry cap full.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 10; i += 1) {
store.entries.push({
id: `mem_high_all_rejected_decision_${i}`,
type: "decision",
text: `Pinned high priority decision ${i} that keeps the workspace entry cap full.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
for (let i = 0; i < 8; i += 1) {
store.entries.push({
id: `mem_high_all_rejected_project_${i}`,
type: "project",
text: `Pinned high priority project ${i} that keeps the workspace entry cap full.`,
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
});
}
return store;
});
await saveSessionState(tmpDir, {
version: 1,
sessionID: "all-rejected-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_session_rejected",
type: "reference",
text: "Session pending reference should remain when every pending memory is rejected by cap.",
source: "compaction",
confidence: 0.1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const journal = await loadPendingJournal(tmpDir);
journal.entries = [{
id: "mem_journal_rejected_other_session",
type: "reference",
text: "Journal pending reference from another session should not be cleared by an empty clearable set.",
source: "compaction",
confidence: 0.1,
status: "active",
createdAt: now,
updatedAt: now,
}];
await savePendingJournal(tmpDir, journal);
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "all-rejected-session" } },
});
const state = await loadSessionState(tmpDir, "all-rejected-session");
assert.equal(state.pendingMemories.length, 0,
"compaction session pending memory should clear when rejected by capacity accounting");
const pendingAfter = await loadPendingJournal(tmpDir);
assert.equal(pendingAfter.entries.length, 0,
"compaction journal pending memories should clear when rejected by capacity accounting");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("session.compacted clears stale rejected compaction journal memories", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const old = new Date(Date.now() - 90 * 86400000).toISOString();
const journal = await loadPendingJournal(tmpDir);
journal.entries = [{
id: "mem_stale_journal_rejected",
type: "reference",
text: "Stale journal pending reference should remain pending after pruning rejects it.",
source: "compaction",
confidence: 0.75,
status: "active",
createdAt: old,
updatedAt: old,
staleAfterDays: 1,
}];
await savePendingJournal(tmpDir, journal);
const plugin = await MemoryV2Plugin({ directory: tmpDir, client: mockRootClient() });
await (plugin as Record<string, Function>)["event"]({
event: { type: "session.compacted", properties: { sessionID: "stale-journal-rejected-session" } },
});
const pendingAfter = await loadPendingJournal(tmpDir);
assert.equal(pendingAfter.entries.length, 0,
"stale rejected compaction journal memory should be terminal and clearable");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
test("promotion failure does not clear pending memories in session or journal", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "memory-plugin-test-"));
try {
const client = mockRootClient();
const plugin = await MemoryV2Plugin({ directory: tmpDir, client });
const now = new Date().toISOString();
await saveSessionState(tmpDir, {
version: 1,
sessionID: "failure-session",
turn: 0,
updatedAt: now,
activeFiles: [],
openErrors: [],
recentDecisions: [],
pendingMemories: [{
id: "mem_pending_failure",
type: "decision",
text: "Keep pending when promotion fails",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}],
});
const journalPath = await workspacePendingJournalPath(tmpDir);
await mkdir(dirname(journalPath), { recursive: true });
const journal = await loadPendingJournal(tmpDir);
journal.entries = [{
id: "mem_pending_failure_journal",
type: "decision",
text: "Keep pending when promotion fails",
source: "explicit",
confidence: 1,
status: "active",
createdAt: now,
updatedAt: now,
}];
await savePendingJournal(tmpDir, journal);
const wmPath = await workspaceMemoryPath(tmpDir);
await rm(wmPath, { force: true }).catch(() => undefined);
await mkdir(wmPath, { recursive: true });
let didThrow = false;
try {
await (plugin as Record<string, Function>)["event"]({
event: {
type: "session.compacted",
properties: { sessionID: "failure-session" },
},
});
} catch {
didThrow = true;
}
assert.equal(didThrow, false,
"promotion failure should not throw from session.compacted handler");
const state = await loadSessionState(tmpDir, "failure-session");
assert.equal(state.pendingMemories.length, 1,
"session pending memories should remain when promotion fails");
const pendingAfter = await loadPendingJournal(tmpDir);
assert.equal(pendingAfter.entries.length, 1,
"journal pending memories should remain when promotion fails");
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
Reference in New Issue View Git Blame Copy Permalink