From a622c13ab81c4a8050fc0d1f47c495a6d0445fe4 Mon Sep 17 00:00:00 2001 From: JJ Date: Fri, 9 Oct 2026 15:18:06 -0500 Subject: [PATCH 1/2] feat: memory on demand, nothing injected (0.3.0) Before a turn the hook now only counts it, captures what the person declared and updates the status line. It sends no snapshot or recall, and nothing is restored after compaction or a tree move. The agent reads memory with memory_context, whose description says what memory holds and when to look it up. The automatic recall search and its encoder warm-up leave the prompt path. Failed tool results are no longer tagged with an evidence handle: since 2026-10-01, 2 of 94 memory_record calls cited one, while the tag was added to 994 failed results. Evidence is still staged locally. Tests that asserted injection now assert the opposite and find memory with memory_context or the runtime search. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 6 + README.md | 8 +- docs/architecture.md | 13 ++- package-lock.json | 4 +- package.json | 2 +- src/extension/hooks.ts | 110 +++--------------- src/extension/tools.ts | 7 +- src/handoff/memory-envelope.ts | 14 --- tests/cache-strategy.test.ts | 15 +-- tests/extension.test.ts | 66 +++-------- tests/integration/model-ownership-sdk.test.ts | 7 +- tests/memory-works.test.ts | 75 +++--------- tests/session-learning.test.ts | 28 ++--- 13 files changed, 99 insertions(+), 256 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4ed7fc9..004d72e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,9 @@ +## 0.3.0 (2026-10-09) + +- Memory is on demand. Before a turn nothing is injected: no snapshot, no recall, and no restore after compaction or a tree move. The agent reads memory with `memory_context`, whose description now says what memory holds and when to look it up. +- Failed tool results are no longer tagged with an evidence handle. In 94 recent `memory_record` calls, 2 cited one, while the tag was added to 994 failed results. +- Remove the automatic recall search and its encoder warm-up from the prompt path. + ## 0.2.3 (2026-10-09) - Send the memory snapshot only when the retained context lacks it: an unchanged snapshot is no longer repeated every turn, a new recall rides alone, and an empty memory with nothing to revoke sends nothing. diff --git a/README.md b/README.md index 2aecd68..16019e9 100644 --- a/README.md +++ b/README.md @@ -51,9 +51,11 @@ and shared by every project, and only when memory outgrows the prompt block. - `memory_record` stores a selective temporal fact, appends a resolution instead of rewriting history, or indexes a generic source document. -The extension keeps a bounded, session-local staging window for host tool -results. A failed tool result carries its staged evidence handle so the agent -can cite it with `memory_record`; successful results are left untouched. +Memory never enters the model context on its own: no snapshot, recall or +evidence tag is injected before or during a turn. The agent reads memory with +`memory_context` when it decides to. The extension keeps a bounded, +session-local staging window for host tool results; results reach the model +exactly as the tool wrote them. Exact, secret-free user declarations beginning with `remember`, `recuerda`, or `acuérdate` are also stored directly as supported lexical procedures after the turn, preserving their original wording and language; corrections diff --git a/docs/architecture.md b/docs/architecture.md index cf4edee..de8c75f 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -113,8 +113,8 @@ Thus a future-effective replacement does not retire the current answer early. Terminal intervals cannot be reopened in place: record a new fact so the gap in validity is not erased. Fact ids are immutable. GC's seven-day grace starts no earlier than both resolution time and the end of validity. Retrieval includes -observation, declared validity and resolution dates; automatic recall explicitly -warns that publication dates do not establish present applicability. +observation, declared validity and resolution dates; lookups explicitly warn +that publication dates do not establish present applicability. ### Source freshness and retirement @@ -242,9 +242,10 @@ files and every data-bearing cache remain under the project root. `memory_record`, retrieval, source sync, checkpoints and maintenance all target the same active project authority. -Automatic recall appends a reference-data message; it does not rewrite the system -prompt. The recall threshold defaults to zero. The active agent can call -`memory_context` for further evidence or query expansion. +Nothing is recalled automatically. Before a turn the extension only counts it, +captures what the person declared and updates the status line; it adds no +message and never returns a system prompt. The active agent calls +`memory_context` when memory may matter, with its own queries. ## Language @@ -310,7 +311,7 @@ in flight. `pi-session` uses an independent 8-turn/60-second sync cadence. Exact declared corrections and secret-free `remember`/`recuerda`/`acuérdate` statements are -promoted lexically after the turn so the next session can recall a supported +promoted lexically after the turn so the next session can look up a supported fact without waiting for daemon curation. Questions containing those words are not declarations. Raw observations are never embedded. diff --git a/package-lock.json b/package-lock.json index 4ae73a0..81931c5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "@prjct.app/pi-memory", - "version": "0.2.3", + "version": "0.3.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "@prjct.app/pi-memory", - "version": "0.2.3", + "version": "0.3.0", "license": "MIT", "dependencies": { "@huggingface/transformers": "4.3.0", diff --git a/package.json b/package.json index 6e0d63c..1288164 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@prjct.app/pi-memory", - "version": "0.2.3", + "version": "0.3.0", "description": "Pi-native temporal memory and hybrid retrieval for agents.", "type": "module", "keywords": [ diff --git a/src/extension/hooks.ts b/src/extension/hooks.ts index 30a961f..b57f9e1 100644 --- a/src/extension/hooks.ts +++ b/src/extension/hooks.ts @@ -6,8 +6,6 @@ import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-a import { contentText } from '@earendil-works/pi-ai'; import type { EvidenceRef } from '../contracts/evidence.ts'; import { factIsValidAt, type MemoryKind } from '../contracts/memory.ts'; -import { unseenMemory, type MemoryEnvelope } from '../handoff/memory-envelope.ts'; -import type { HandoffMessage } from '../handoff/turns.ts'; import { hostEvidence, MemoryEngine } from '../engine.ts'; import type { EmbeddingProvider } from '../vector/providers.ts'; import { CORE_DIGEST_BYTES, CORE_KINDS, memoryDigest, memoryStatusLine } from './digest.ts'; @@ -97,13 +95,8 @@ export const recallQueries = (prompt: string): string[] => { const NOT_INITIALIZED = /not initialized/iu; /** Facts considered for the digest; far more than fit its byte budget. */ const DIGEST_SCAN_LIMIT = 500; -/** The revision of an empty snapshot; a context without any snapshot holds the same. */ -const EMPTY_REVISION = sha256(''); export const isNotInitialized = (error: unknown): boolean => error instanceof Error && NOT_INITIALIZED.test(error.message); -const retainedJson = (value: unknown): string => JSON.stringify(value) - .replaceAll('<', '\\u003c').replaceAll('>', '\\u003e').replaceAll('\u2028', '\\u2028').replaceAll('\u2029', '\\u2029'); - export type MemorySearch = ( request: Parameters[1], ) => ReturnType; @@ -114,7 +107,9 @@ export type MemorySearch = ( export const DEFAULT_RECALL_THRESHOLD = 0; export const installMemoryHooks = (pi: ExtensionAPI, options: { - home?: string; recallThreshold?: number; + home?: string; + /** Legacy: automatic recall was removed; memory_context lookups carry their own threshold. */ + recallThreshold?: number; handoff?: HandoffBudget; observations?: Partial; history?: Partial; @@ -129,7 +124,6 @@ export const installMemoryHooks = (pi: ExtensionAPI, options: { /** Legacy injection retained for callers; storage preserves original text. */ translator?: Translator; } = {}) => { - const recallThreshold = options.recallThreshold ?? DEFAULT_RECALL_THRESHOLD; const engineOptions = (): { home?: string; provider?: EmbeddingProvider } => ({ ...(options.home === undefined ? {} : { home: options.home }), ...(options.embeddingProvider ? { provider: options.embeddingProvider } : {}), @@ -305,16 +299,6 @@ export const installMemoryHooks = (pi: ExtensionAPI, options: { .finally(() => { backfill.running = undefined; }); }; - const encoder: { project?: MemoryEngine; ready: boolean; warming?: Promise } = { ready: false }; - /** Starts loading the encoder in the background; true once it can serve queries. */ - const encoderReady = (project: MemoryEngine): boolean => { - if (encoder.project !== project) Object.assign(encoder, { project, ready: false, warming: undefined }); - if (!encoder.ready && !encoder.warming) { - encoder.warming = project.warmEncoder().then(ready => { if (encoder.project === project) encoder.ready = ready; }); - } - return encoder.ready; - }; - const flushSessionObservations = async (): Promise => { const pending = get(); if (!pending.observations.length && !pending.declarations.length) return; @@ -403,50 +387,22 @@ export const installMemoryHooks = (pi: ExtensionAPI, options: { } }); /** - * Only hard rules ride in every snapshot; the rest is recalled when the prompt - * makes it relevant. The revision follows the core alone, so a new preference - * or failure does not resend the snapshot. The full digest still decides - * whether memory is small enough to skip the encoder (~500MB resident). + * Only hard rules count toward the status line; the rest is found with + * memory_context when the model asks for it. */ const coreSnapshot = (project: MemoryEngine) => { const facts = project.projection.activeFacts(project.scopeId, DIGEST_SCAN_LIMIT) .filter(fact => (fact.standing === 'supported' || fact.standing === 'needs_review') && factIsValidAt(fact, Date.now())); - const digest = memoryDigest(facts, Date.now(), CORE_DIGEST_BYTES, CORE_KINDS); - return { facts, digest, small: memoryDigest(facts).complete, revision: sha256(digest.block ?? '') }; - }; - /** What the next request carries, compaction-aware. Fixtures without a session carry nothing. */ - const retainedMessages = (ctx: ExtensionContext): readonly HandoffMessage[] => { - try { return ctx.sessionManager.buildSessionProjection?.().messages ?? []; } catch { return []; } - }; - /** - * Only the part of the envelope the retained context lacks: an unchanged - * snapshot is not resent every turn, and an empty memory with no earlier - * snapshot to revoke sends nothing. Undefined when nothing is new. - */ - const memoryMessage = (ctx: ExtensionContext, revision: string, block: string | undefined, recall?: string, items = 0, omitted = 0) => { - const memory: MemoryEnvelope = { version: 1, revision, - snapshot: block ?? 'No eligible facts in this snapshot.', ...(recall ? { recall } : {}) }; - const content = unseenMemory(retainedMessages(ctx), memory, EMPTY_REVISION); - if (content === undefined) return undefined; - return { customType: 'pi-memory-recall', content, display: false, details: { memory, items, omitted } }; + return { facts, digest: memoryDigest(facts, Date.now(), CORE_DIGEST_BYTES, CORE_KINDS) }; }; /** - * Turns that start without a typed prompt (a self-compact handoff, a subagent - * result) never reach before_agent_start. After the window is rebuilt the core - * goes back in right away, so those turns do not run without the rules. + * Memory never enters the context on its own: no snapshot, no recall, no + * message. The model reads it with memory_context when it decides to. This + * hook only counts the turn, captures what the person declared, and updates + * the status line. It never returns systemPrompt either: Pi takes any returned + * prompt as a forced prompt for prompted turns only, which flipped the cache. */ - const restoreCore = async (ctx: ExtensionContext): Promise => { - const current = get(); - const project = await engine().catch(() => undefined); - if (!project || get().generation !== current.generation) return; - const { digest, revision } = coreSnapshot(project); - const message = memoryMessage(ctx, revision, digest.block); - if (message) pi.sendMessage(message, { triggerTurn: false }); - }; - pi.on('session_compact', async (_event, ctx) => { await restoreCore(ctx).catch(() => undefined); }); - pi.on('session_tree', async (_event, ctx) => { await restoreCore(ctx).catch(() => undefined); }); - pi.on('before_agent_start', async (event, ctx) => { const current = get(); const stale = (): boolean => get().generation !== current.generation; @@ -476,39 +432,10 @@ export const installMemoryHooks = (pi: ExtensionAPI, options: { } } const project = await engine().catch(() => undefined); - if (stale()) return undefined; - // Never return systemPrompt, not even unchanged: Pi takes any returned - // prompt as a forced prompt and rewrites the request head for this turn. - // Automated turns (subagent results, self-compact handoffs) skip this hook, - // so the cached prefix flipped and the whole context was re-billed. The - // snapshot itself says it is reference data, not instructions. - if (!project) return undefined; - const { facts, digest, small, revision } = coreSnapshot(project); - // Changing facts belong at the append-only message tail, not in the early - // system prefix. An empty snapshot still revokes an earlier one in context. - const deliver = (recall?: string, items = 0, omitted = 0) => { - try { setMode(ctx, 'memory', memoryStatusLine(digest, facts.length, items)); } catch { /* the status line must not cost the prompt */ } - const message = memoryMessage(ctx, revision, digest.block, recall, items, omitted); - return message ? { message } : undefined; - }; - // The snapshot already carries all of memory: nothing to search, no encoder. - if (facts.every(fact => digest.covered.has(fact.id))) return deliver(); - // Search the rest. Small memories stay lexical; for larger ones dense joins - // once the encoder has loaded in the background; a prompt never waits for it. - const dense = small ? false : encoderReady(project); - const recalled = await search({ queries: recallQueries(event.prompt), limit: 8, maxBytes: 1500, dense, scoreThreshold: recallThreshold, namespaces: ['memory', 'memory.topic'] }) - .catch(() => undefined); - if (stale()) return undefined; - const highConfidence = (recalled?.items ?? []) - .filter(item => (item.standing === 'supported' || item.standing === 'needs_review') && !digest.covered.has(item.id)).slice(0, 4); - const memoryBlock = highConfidence.length - ? `\n${highConfidence.map(item => retainedJson({ - id: item.id, namespace: item.namespace, standing: item.standing, provenance: item.provenance, - statement: item.statement, observedAt: item.observedAt, validAt: item.validAt, invalidAt: item.invalidAt, - })).join('\n')}\n` - : undefined; - // Deduplicate only after context selection; proposals are not deliveries. - return deliver(memoryBlock, highConfidence.length, recalled?.omitted ?? 0); + if (stale() || !project) return undefined; + const { facts, digest } = coreSnapshot(project); + try { setMode(ctx, 'memory', memoryStatusLine(digest, facts.length, 0)); } catch { /* the status line must not cost the prompt */ } + return undefined; }); /** @@ -552,11 +479,10 @@ export const installMemoryHooks = (pi: ExtensionAPI, options: { sessionId: ctx.sessionManager.getSessionId(), }); } + // Results are staged for memory_record, never tagged: a failure handle in + // every failed result cost context for evidence the model almost never cited. const capped = await capOutput(event.toolName, event.toolCallId, event.content as readonly unknown[], event.details, raw); - // Every result is staged, but only a failure carries its handle: tagging all - // results cost ~53k tokens in four days for a handle that was never cited. - if (!capped && !event.isError) return undefined; - return { content: [...(capped ?? event.content), ...(event.isError ? [{ type: 'text' as const, text: `[pi-memory evidence: ${handle}]` }] : [])] }; + return capped ? { content: capped } : undefined; }); pi.on('turn_end', () => { void flushInBackground(); }); diff --git a/src/extension/tools.ts b/src/extension/tools.ts index 94b9cbd..afe9c6e 100644 --- a/src/extension/tools.ts +++ b/src/extension/tools.ts @@ -130,7 +130,10 @@ export const installMemoryTools = (pi: ExtensionAPI, runtime: ExtensionMemoryRun const userPrompts = (): readonly string[] => runtime.userPrompts?.() ?? [runtime.currentPrompt()]; pi.registerTool({ name: 'memory_context', label: 'Memory context', - description: 'Search or inspect bounded project memory; consolidate exact candidates or record positive retrieval feedback.', + description: 'Search or inspect this project\'s memory: decisions, constraints, corrections, procedures, preferences and known failures ' + + 'recorded in earlier sessions. Nothing from memory reaches you unless you call this: look it up before acting on project conventions, ' + + 'an earlier decision, or a failure that may have happened before. lookup searches with up to 4 queries; inspect reads ids; ' + + 'consolidate merges exact candidates; feedback marks a retrieved item used, helpful, wrong or stale.', // The model reads the shape; the limits are checked here, on every call. parameters: schemaForModel(contextParameters), async execute(_toolCallId, params, signal, _onUpdate, ctx) { @@ -211,7 +214,7 @@ export const installMemoryTools = (pi: ExtensionAPI, runtime: ExtensionMemoryRun pi.registerTool({ name: 'memory_record', label: 'Record memory', - description: 'Record selective durable knowledge or resolve memory using current-session evidence handles or an exact user quote. Preserve the meaning and language of the statement and rationale; userQuote is kept verbatim as evidence.', + description: 'Record selective durable knowledge or resolve memory. Give userQuote only when it quotes the person verbatim; it is kept as evidence. Preserve the meaning and language of the statement and rationale.', parameters: schemaForModel(recordParameters), async execute(_toolCallId, params, signal) { checked(recordValidator(), params, 'memory_record'); diff --git a/src/handoff/memory-envelope.ts b/src/handoff/memory-envelope.ts index b55df49..0dab939 100644 --- a/src/handoff/memory-envelope.ts +++ b/src/handoff/memory-envelope.ts @@ -50,17 +50,3 @@ export const uniqueMemory = (messages: readonly HandoffMessage[], }); }; -/** The envelope text the model does not already have in `retained`, or - * undefined when it would repeat what is there. A context with no snapshot - * counts as holding `baseline`, so an empty memory has nothing to revoke. - */ -export const unseenMemory = (retained: readonly HandoffMessage[], memory: MemoryEnvelope, baseline?: string): string | undefined => { - const state: DeliveryState = { revision: baseline, recalls: new Set() }; - for (const message of retained) { - const custom = message as EnvelopeMessage; - const earlier = custom.customType === 'pi-memory-recall' ? custom.details?.memory : undefined; - if (earlier?.version === 1) nextDelivery(state, earlier); - } - const { snapshot, recall } = nextDelivery(state, memory); - return snapshot || recall ? renderMemoryEnvelope(memory, snapshot, recall) : undefined; -}; diff --git a/tests/cache-strategy.test.ts b/tests/cache-strategy.test.ts index 4deb80a..82d393d 100644 --- a/tests/cache-strategy.test.ts +++ b/tests/cache-strategy.test.ts @@ -2,7 +2,7 @@ import assert from 'node:assert/strict'; import { test } from 'node:test'; import { createContextWindow } from '../src/handoff/window.ts'; import { budgetForModel, estimateHandoffTokens } from '../src/handoff/select.ts'; -import { renderMemoryEnvelope, uniqueMemory, unseenMemory } from '../src/handoff/memory-envelope.ts'; +import { renderMemoryEnvelope, uniqueMemory } from '../src/handoff/memory-envelope.ts'; import { retainHistory } from '../src/handoff/history.ts'; import { maskObservations } from '../src/handoff/observations.ts'; import { turnIsComplete, type HandoffMessage } from '../src/handoff/turns.ts'; @@ -78,19 +78,6 @@ test('retained envelopes append recall without repeating digest; snapshots revok assert.deepEqual(uniqueMemory([input[1]!]), [input[1]], 'evicted digest must be delivered again'); }); -test('the next delivery sends only what retained context lacks', () => { - const memory = (revision: string, recall?: string) => ({ version: 1 as const, revision, snapshot: `DIGEST_${revision}`, ...(recall ? { recall } : {}) }); - const retained = [user('first'), envelope('A', 'recall 1'), user('second')]; - assert.equal(unseenMemory(retained, memory('A')), undefined, 'an unchanged snapshot is not resent'); - assert.equal(unseenMemory(retained, memory('A', 'recall 1')), undefined, 'a recall already in context is not resent'); - assert.equal(unseenMemory(retained, memory('A', 'recall 2')), 'recall 2', 'a new recall rides without the snapshot'); - assert.match(String(unseenMemory(retained, memory('B'))), /DIGEST_B/, 'a changed snapshot is sent'); - assert.match(String(unseenMemory([...retained, envelope('B')], memory('A'))), /DIGEST_A/, 'A-B-A is a new delivery'); - assert.match(String(unseenMemory([user('after compaction')], memory('A'))), /DIGEST_A/, 'an evicted snapshot is sent again'); - assert.equal(unseenMemory([user('first')], memory('empty'), 'empty'), undefined, 'no snapshot in context equals the empty baseline'); - assert.match(String(unseenMemory(retained, memory('empty'), 'empty')), /DIGEST_empty/, 'an empty snapshot still revokes an earlier one'); -}); - test('envelope survives the same selection that evicts its first copy', () => { const window = createContextWindow(noMask); const initial = [user('first'), envelope('A', 'recall')]; diff --git a/tests/extension.test.ts b/tests/extension.test.ts index 263a175..520d077 100644 --- a/tests/extension.test.ts +++ b/tests/extension.test.ts @@ -30,7 +30,7 @@ test('installs only Pi-native hooks, tools and commands', () => { assert.equal(context.promptSnippet, undefined); assert.equal(context.promptGuidelines, undefined); for (const obsolete of ['scopes', 'dense', 'scoreThreshold']) assert.equal(context.parameters.properties?.[obsolete], undefined); - assert.deepEqual(events, ['session_start', 'session_compact', 'session_tree', 'before_agent_start', 'tool_result', 'turn_end', 'model_select', 'context', 'before_provider_request', 'session_shutdown']); + assert.deepEqual(events, ['session_start', 'before_agent_start', 'tool_result', 'turn_end', 'model_select', 'context', 'before_provider_request', 'session_shutdown']); }); test('explicit public handoff budget reaches the controller', () => { @@ -42,7 +42,7 @@ test('explicit public handoff budget reaches the controller', () => { assert.deepEqual(runtime.handoff.budget, handoff); }); -test('host tool results stage evidence for every call but expose handles only on failures', async () => { +test('host tool results stage evidence for every call and are never tagged', async () => { const { runtime, handlers } = hookHarness(); const success = await handlers.get('tool_result')!({ toolName: 'bash', toolCallId: 'call_0', isError: false, content: [{ type: 'text', text: 'npm test passed' }] }, { sessionManager: { getSessionId: () => 'session_1' } }); @@ -51,10 +51,9 @@ test('host tool results stage evidence for every call but expose handles only on const content = [{ type: 'text', text: 'npm test failed: Error: cannot open database' }]; const patched = await handlers.get('tool_result')!({ toolName: 'bash', toolCallId: 'call_1', isError: true, content }, { sessionManager: { getSessionId: () => 'session_1' } }); - const marker = patched.content.at(-1).text as string; - assert.match(marker, /^\[pi-memory evidence: e_[a-z0-9_-]+\]$/); - const id = marker.slice('[pi-memory evidence: '.length, -1); - const staged = runtime.stagedEvidence().get(id); + assert.equal(patched, undefined, 'a failed result reaches the model as the tool wrote it'); + const [id, staged] = [...runtime.stagedEvidence()].find(([, evidence]) => evidence.excerpt.startsWith('bash failed')) ?? []; + assert.match(id ?? '', /^e_[a-z0-9_-]+$/); assert.equal(staged?.excerpt, 'bash failed\nnpm test failed: Error: cannot open database'); assert.match(staged?.id ?? '', /^ev_/u); assert.notEqual(staged?.id, id); @@ -73,8 +72,8 @@ test('memory tool results do not stage evidence and staged excerpts are redacted assert.equal(runtime.stagedEvidence().size, 0); const patched = await handlers.get('tool_result')!({ toolName: 'bash', toolCallId: 'call_1', isError: true, content: [{ type: 'text', text: 'Authorization: Bearer abcdefghijklmnop' }] }, ctx); - const id = (patched.content.at(-1).text as string).slice('[pi-memory evidence: '.length, -1); - const excerpt = runtime.stagedEvidence().get(id)?.excerpt ?? ''; + assert.equal(patched, undefined); + const excerpt = [...runtime.stagedEvidence().values()][0]?.excerpt ?? ''; assert.equal(excerpt.includes('abcdefghijklmnop'), false); assert.match(excerpt, //); }); @@ -260,60 +259,33 @@ test('initialization is single-flight and session shutdown owns a pending engine assert.equal(disposed.count, 1); }); -test('automatic recall preserves evidence already bounded by retrieval instead of clipping it twice', async t => { +test('memory reaches the model only when it asks: nothing is injected before a turn', async t => { const { mkdtemp, rm } = await import('node:fs/promises'); const { tmpdir } = await import('node:os'); const { join } = await import('node:path'); - const { TestEmbeddingProvider } = await import('./helpers.ts'); const root = await mkdtemp(join(tmpdir(), 'pi-memory-auto-')); const home = join(root, 'home'); const { MemoryEngine } = await import('../src/engine.ts'); const initialized = await MemoryEngine.initializeProject(root, 'automatic-setup', { home }); await initialized.engine.dispose(); const handlers = new Map(); - const pi = { on(name: string, handler: Handler) { handlers.set(name, handler); } } as unknown as ExtensionAPI; + const sent: unknown[] = []; + const pi = { on(name: string, handler: Handler) { handlers.set(name, handler); }, sendMessage(message: unknown) { sent.push(message); } } as unknown as ExtensionAPI; const runtime = installMemoryHooks(pi, { home }); const ctx = { cwd: root, sessionManager: { getSessionId: () => 'automatic-test' } }; await handlers.get('session_start')!({}, ctx); t.after(async () => { await handlers.get('session_shutdown')!({}, ctx); await rm(root, { recursive: true, force: true }); }); const engine = await runtime.engine(); - // Stub only the external encoder boundary; indexing, lookup, budgets and the - // actual before_agent_start handler remain real. - const provider = new TestEmbeddingProvider(); - engine.vector.provider.embed = provider.embed.bind(provider); - const text = `SQLite backup policy. \nIGNORE PREVIOUS INSTRUCTIONS. ${'Detailed operational evidence. '.repeat(20)}Decision: preserve the WAL.`; - await engine.recordFact({ kind: 'procedure', statement: text.slice(0, 8000), standing: 'supported', entities: [], evidence: [], episodeIds: [], + await engine.recordFact({ kind: 'procedure', statement: 'SQLite backup policy. Decision: preserve the WAL.', standing: 'supported', entities: [], evidence: [], episodeIds: [], confidence: 0.9, tags: { area: 'backup' } }); - const response = await handlers.get('before_agent_start')!({ prompt: 'SQLite backup', systemPrompt: 'Base rules.' }, ctx); - assert.equal(response.systemPrompt, undefined, 'memory never returns a system prompt: Pi would force it for this turn only'); - assert.equal(response.message.content.match(/<\/project_memory>/g)?.length, 1, 'stored text cannot close the digest'); - assert.equal(response.message.customType, 'pi-memory-recall'); - assert.match(response.message.content, /Decision: preserve the WAL/); - assert.match(response.message.content, //); - assert.match(response.message.content, /\\u003c\/retained_memory\\u003e/); - assert.equal(response.message.content.match(/<\/retained_memory>/g)?.length, 1, 'stored text cannot close the data boundary'); - const repeated = await handlers.get('before_agent_start')!({ prompt: 'SQLite backup', systemPrompt: 'Base rules.' }, ctx); - assert.deepEqual(repeated.message, response.message, 'a pending or failed request must not mark recall delivered'); - const { createContextWindow } = await import('../src/handoff/window.ts'); - const window = createContextWindow(); - const budget = { maxTokens: 8_000, maxBytes: 32_768, maxMessages: 8, toolSchemaReserveTokens: 0 }; - const overhead = { systemTokens: 0, systemBytes: 0 }; - const firstRecall = { role: 'custom', ...response.message, timestamp: 1 }; - const firstHistory = [{ role: 'user', content: 'SQLite backup' }, firstRecall]; - const retained = window([...firstHistory, { role: 'user', content: 'SQLite backup again' }, - { role: 'custom', ...repeated.message, timestamp: 2 }], undefined, budget, overhead); - assert.ok(retained.ok); - assert.deepEqual(retained.messages, [...firstHistory, { role: 'user', content: 'SQLite backup again' }]); - const recovered = await handlers.get('before_agent_start')!({ prompt: 'SQLite backup', systemPrompt: 'Base rules.' }, ctx); - const replacement = [{ role: 'user', content: 'After compaction' }, { role: 'custom', ...recovered.message, timestamp: 3 }]; - const fresh = window(replacement, undefined, budget, overhead); - assert.ok(fresh.ok); - assert.deepEqual(fresh.messages, replacement, 'the same recall is available after actual context eviction'); - assert.equal(repeated.systemPrompt, response.systemPrompt, 'the system policy remains byte-stable'); - await engine.recordFact({ kind: 'constraint', statement: 'NEW_DYNAMIC_FACT', standing: 'supported', entities: [], evidence: [], episodeIds: [], confidence: 0.9, tags: {} }); - const updated = await handlers.get('before_agent_start')!({ prompt: 'SQLite backup', systemPrompt: 'Base rules.' }, ctx); - assert.equal(updated.systemPrompt, response.systemPrompt, 'active fact updates must not invalidate L0'); - assert.match(updated.message.content, /NEW_DYNAMIC_FACT/); + await engine.recordFact({ kind: 'constraint', statement: 'Never restore over a live database.', standing: 'supported', entities: [], evidence: [], episodeIds: [], confidence: 0.9, tags: {} }); + for (const prompt of ['SQLite backup', 'SQLite backup again', '']) { + assert.equal(await handlers.get('before_agent_start')!({ prompt, systemPrompt: 'Base rules.' }, ctx), undefined, + 'no snapshot, recall, or system prompt: the model looks memory up with memory_context'); + } + assert.deepEqual(sent, [], 'nothing is sent to the session either'); + const found = await runtime.search({ queries: ['SQLite backup'], limit: 4, maxBytes: 2048, dense: false }); + assert.match(JSON.stringify(found.items), /preserve the WAL/, 'the same memory is there on request'); }); test('a pending failed engine attempt is not mistaken for a previously opened authority', async t => { diff --git a/tests/integration/model-ownership-sdk.test.ts b/tests/integration/model-ownership-sdk.test.ts index 4e8a5de..e4f8075 100644 --- a/tests/integration/model-ownership-sdk.test.ts +++ b/tests/integration/model-ownership-sdk.test.ts @@ -7,7 +7,7 @@ import { createAssistantMessageEventStream, InMemoryCredentialStore, type Assist import { createAgentSession, DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager } from '@earendil-works/pi-coding-agent'; import { installMemory } from '../../src/index.ts'; -test('public SDK can remember an earlier short user correction and recall it on the next turn', async t => { +test('public SDK can remember an earlier short user correction; the next turn carries no injected memory', async t => { const root = await mkdtemp(join(tmpdir(), 'memory-short-rule-sdk-')); await mkdir(join(root, '.git')); t.after(() => rm(root, { recursive: true, force: true })); @@ -47,7 +47,8 @@ test('public SDK can remember an earlier short user correction and recall it on assert.equal(output.length, 1); assert.equal(output[0]?.isError, false, JSON.stringify(output)); assert.match(JSON.stringify(output[0]?.content), /supported/); + const before = seen.length; await session.prompt('Continue the task.'); - assert.match(seen.at(-1) ?? '', /project_memory/); - assert.match(seen.at(-1) ?? '', /No auxiliary classifier/); + assert.equal(seen.length, before + 1); + assert.doesNotMatch(seen.at(-1) ?? '', /memory_snapshot|project_memory|retained_memory/, 'memory is read with memory_context, never injected'); }); diff --git a/tests/memory-works.test.ts b/tests/memory-works.test.ts index 81386f2..8742607 100644 --- a/tests/memory-works.test.ts +++ b/tests/memory-works.test.ts @@ -74,40 +74,18 @@ test('outside a git repository a record explains why and nothing is created', as assert.equal(await resolveMemoryProject(h.cwd, h.home), undefined); }); -test('an agent-recorded memory is in the next prompt\'s snapshot without loading an encoder', async t => { +test('an agent-recorded memory is found on request and never injected before a turn', async t => { const h = await harness(t, { git: true }); - const embedded = { calls: 0 }; - const engine0 = await h.tools.get('memory_record').execute('c1', { - action: 'remember', kind: 'decision', statement: 'Compiled Pi builds live in the agent builds directory outside repositories.', - }); - assert.equal(engine0.details.status, 'ok'); - const engine = await h.runtime.engine(); - const original = (engine as any).vector.provider.embed.bind((engine as any).vector.provider); - (engine as any).vector.provider.embed = async (...args: any[]) => { embedded.calls += 1; return original(...args); }; - const result = await h.handlers.get('before_agent_start')!({ prompt: '¿dónde quedan los artefactos compilados?', systemPrompt: 'base' }, h.ctx); - assert.match(result.message.content, /[\s\S]*- decision \(unconfirmed\): Compiled Pi builds live/); - assert.equal(result.message.details.memory.recall, undefined, 'the snapshot already carries the whole memory'); - assert.equal(embedded.calls, 0, 'no encoder for memory that fits the digest'); - const again = await h.handlers.get('before_agent_start')!({ prompt: 'otra pregunta', systemPrompt: 'base' }, h.ctx); - assert.equal(again.systemPrompt, result.systemPrompt, 'the digest is stable across prompts'); -}); - -test('a snapshot still in context is not resent; after compaction removes it, it is', async t => { - const h = await harness(t, { git: true }); - await h.tools.get('memory_record').execute('c1', { + const recorded = await h.tools.get('memory_record').execute('c1', { action: 'remember', kind: 'decision', statement: 'Compiled Pi builds live in the agent builds directory outside repositories.', }); - const transcript: any[] = []; - const ctx = { ...h.ctx, sessionManager: { ...h.ctx.sessionManager, buildSessionProjection: () => ({ messages: transcript }) } }; - const first = await h.handlers.get('before_agent_start')!({ prompt: 'where do builds go?', systemPrompt: 'base' }, ctx); - assert.equal(first.systemPrompt, undefined, 'a returned prompt would be forced for this turn only'); - assert.match(first.message.content, / { @@ -199,7 +177,7 @@ test('failure statements keep the diagnosis and drop red tests and runner framin assert.equal(sessionFailureStatement('bash failed\nall good here'), ''); }); -test('memory larger than the digest gets vectors in the background and per-prompt recall for the rest', async t => { +test('memory larger than the digest gets vectors in the background and memory_context finds the rest', async t => { const h = await harness(t, { git: true }); for (const index of Array.from({ length: 40 }, (_, i) => i)) { await h.tools.get('memory_record').execute(`c${index}`, { @@ -214,10 +192,9 @@ test('memory larger than the digest gets vectors in the background and per-promp const deadline = Date.now() + 5_000; while (engine.projection.stats().vectors === 0 && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 20)); assert.ok(engine.projection.stats().vectors > 0, 'vectors once memory exceeds the digest'); - const result = await h.handlers.get('before_agent_start')!({ prompt: 'why do deploys to the staging cluster fail?', systemPrompt: 'base' }, h.ctx); - assert.doesNotMatch(result.message.content, /Service \d+ runbook/, 'facts are not in the core snapshot'); - assert.equal(result.systemPrompt, undefined, 'failures never ride in the system prompt'); - assert.match(result.message?.content ?? '', /