Something went wrong. Try again.
A local-first event pipeline for independent agents, built on Jazz.
Something went wrong. Try again.
30 kB · 756 lines
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757import fs from "node:fs/promises";import path from "node:path";import type { LettaCodeClientSessionOptions, LettaCodeSession, LettaConversation, AnyAgentTool, ListMessagesResult, SDKMessage, SendMessage,} from "@letta-ai/letta-agent-sdk";import { afterEach, describe, expect, test } from "vitest";import { FilesystemConnector } from "../src/connectors/filesystem.js";import { LettaAgentSdkRunner, lettaDocumentConversationBindingId, lettaDocumentConversationRemoteMarker, lettaTurnKey, type LettaAgentSdkClient,} from "../src/agents/letta-agent-sdk.js";import { PUBLIC_KNOWLEDGE_PROPOSED_DIFF_OUTPUT_CONTRACT, publicKnowledgeProposedDiffOutputSchema, type PublicKnowledgeProposedDiffOutput,} from "../src/agents/output-contracts.js";import { ThoughtAgentRuntime } from "../src/agents/runtime.js";import type { AgentOutput, AgentRunInput, AgentRunner, RunnerTrace, ThoughtAgentDeclaration,} from "../src/agents/types.js";import { buildPublicKnowledgeContextPacket, PublicKnowledgeEligibilitySkip, validatePublicKnowledgeProposedDiffAgainstContext,} from "../src/public-knowledge/context.js";import { PUBLIC_KNOWLEDGE_PROPOSED_DIFF_EVENT_TYPE } from "../src/public-knowledge/types.js";import { PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME } from "../src/public-knowledge/proposal-tool.js";import type { ThoughtEvent } from "../src/events/types.js";import type { JazzThoughtStore } from "../src/jazz/store.js";import { temporaryProject, testStore } from "./helpers.js";
const stores: JazzThoughtStore[] = [];const roots: string[] = [];
afterEach(async () => { await Promise.all(stores.splice(0).map((store) => store.close())); await Promise.all(roots.splice(0).map((root) => fs.rm(root, { recursive: true, force: true })));});
describe("Coil Public Knowledge consumer", () => { test("loads one exact eligible document and a bounded relevant public target while blocking journal content before inference", async () => { const fixture = await fixtureWorkspace(); const declaration = publicKnowledgeDeclaration(); const scan = await fixture.connector.scan(fixture.store); const lesson = scan.events.find((event) => event.payload.path === "lessons/eligible.md")!; const journal = scan.events.find((event) => event.payload.path === "journal/private.md")!;
const packet = await buildPublicKnowledgeContextPacket(fixture.store, declaration, lesson, fixture.contextOptions);
expect(packet.text).toContain("# Eligible source"); expect(packet.text).toContain("agent-memory"); expect(packet.text).toContain("PUBLIC ADMITTED TARGET BODY"); expect(packet.text).not.toContain("UNRELATED PUBLIC BODY MUST STAY OUT"); expect(packet.manifest).toMatchObject({ truncated: false, publicKnowledge: { documentId: lesson.payload.documentId, versionId: lesson.payload.versionId, sourceSha256: lesson.payload.sha256, catalogSlugs: ["agent-memory", "unrelated-entry"], catalogTargets: [{ slug: "agent-memory", sha256: expect.stringMatching(/^[a-f0-9]{64}$/) }], }, }); await expect(buildPublicKnowledgeContextPacket( fixture.store, declaration, journal, fixture.contextOptions, )).rejects.toMatchObject({ code: "blocked-path" } satisfies Partial<PublicKnowledgeEligibilitySkip>); let blockedContentReads = 0; const contentTrap = { getDocumentVersion: async () => { blockedContentReads += 1; throw new Error("blocked content must not be read"); }, } as unknown as JazzThoughtStore; await expect(buildPublicKnowledgeContextPacket( contentTrap, declaration, journal, fixture.contextOptions, )).rejects.toMatchObject({ code: "blocked-path" }); expect(blockedContentReads).toBe(0); });
test("settles blocked files as skipped before runner calls or inference accounting", async () => { const fixture = await fixtureWorkspace(); const scan = await fixture.connector.scan(fixture.store); const declaration = publicKnowledgeDeclaration(); const runner = new ProposedDiffProbe(); const runtime = new ThoughtAgentRuntime(fixture.store, [runner], { publicKnowledgeContext: fixture.contextOptions, });
const results = await runtime.consumeBacklog([declaration]);
expect(results).toHaveLength(scan.events.length); expect(runner.calls).toBe(1); const runs = await fixture.store.listRuns(); expect(runs.map((run) => run.status).sort()).toEqual(["completed", "skipped"]); const skipped = runs.find((run) => run.status === "skipped")!; expect(skipped.contextManifest).toMatchObject({ skip: { code: "blocked-path" } }); expect((await fixture.store.listInferenceAccounting({ agentId: declaration.id }))).toHaveLength(1); expect((await fixture.store.listEvents({ types: ["stream.thought.agent.run.skipped"] }))).toHaveLength(1); expect((await fixture.store.listEvents({ types: [PUBLIC_KNOWLEDGE_PROPOSED_DIFF_EVENT_TYPE], }))).toEqual([expect.objectContaining({ privacy: "sensitive", payload: expect.objectContaining({ structuredOutput: expect.objectContaining({ proposalState: "agent-proposed", publicationEligible: false, }), }), })]); });
test("binds one output-only local confined Co conversation to a stable document across path changes", async () => { const fixture = await fixtureWorkspace(); const [event] = (await fixture.connector.scan(fixture.store)).events.filter((candidate) => ( candidate.payload.path === "lessons/eligible.md" )); const declaration = publicKnowledgeDeclaration(); const context = await buildPublicKnowledgeContextPacket(fixture.store, declaration, event!, fixture.contextOptions); const client = new FakeConversationClient(validProposedDiff(context)); const runner = new LettaAgentSdkRunner({ client, conversationStore: fixture.store, environment: { THOUGHTSTREAM_LETTA_CO_MEMORY_DIR: "/tmp/co-memory" }, reconciliationDelayMs: 0, });
const traces: RunnerTrace[] = []; const first = await runner.run( { runId: "thought-run-first", declaration, event: event!, context }, async (trace) => { traces.push(trace); }, ); const renamed: ThoughtEvent = { ...event!, id: "event-renamed-fixture", sourceSequence: event!.sourceSequence + 1, type: "stream.thought.source.file.renamed", payload: { ...event!.payload, path: "lessons/renamed.md", previousPath: "lessons/eligible.md" }, }; await runner.run({ runId: "thought-run-second", declaration, event: renamed, context }, async () => {}); const upgradedDeclaration: ThoughtAgentDeclaration = { ...declaration, version: declaration.version + 1 }; const upgradedEvent: ThoughtEvent = { ...renamed, id: "event-upgraded-declaration-fixture", sourceSequence: renamed.sourceSequence + 1, }; await runner.run({ runId: "thought-run-third", declaration: upgradedDeclaration, event: upgradedEvent, context, }, async () => {});
expect(first).toMatchObject({ decision: "revise-existing", proposal: { target: { kind: "replacement", slug: "agent-memory" } }, publicationEligible: false, }); expect(client.created).toHaveLength(1); expect(client.resumedIds).toEqual([client.created[0]!.id, client.created[0]!.id, client.created[0]!.id]); expect(client.sessionOptions[0]).toMatchObject({ permissionMode: "strict", skillSources: [], allowedTools: [PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME], tools: [expect.objectContaining({ name: PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME })], cwd: "/tmp/co-memory", env: { MEMORY_DIR: "/tmp/co-memory" }, filesystemConfinement: "memory", model: "chatgpt-plus-pro/gpt-5.6-luna", }); const canUseTool = client.sessionOptions[0]?.canUseTool; expect(canUseTool).toBeTypeOf("function"); await expect(canUseTool!(PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME, {}, undefined)).resolves.toMatchObject({ behavior: "allow", }); await expect(canUseTool!("Patch", {}, undefined)).resolves.toMatchObject({ behavior: "deny", interrupt: false, }); expect(traces.filter((trace) => trace.kind === "letta.tool_call")).toEqual([ expect.objectContaining({ data: expect.objectContaining({ toolName: PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME }) }), ]); expect(traces.filter((trace) => trace.kind === "letta.tool_result")).toHaveLength(1); expect(JSON.stringify(traces)).not.toContain("/tmp/co-memory"); expect(JSON.stringify(traces)).not.toContain("Durable memory depends on explicit context custody"); expect(client.sessions.flatMap((session) => session.sent).join("\n")).not.toContain("/tmp/co-memory"); const [binding] = await fixture.store.listLettaConversationBindings(); expect(binding).toMatchObject({ agentId: "agent-co-fixture", source: "filesystem:coil", scopeType: "document", scopeKey: event!.payload.documentId, conversationId: client.created[0]!.id, currentPath: "lessons/renamed.md", declarationVersion: upgradedDeclaration.version, }); expect(binding!.remoteMarker).toBe(lettaDocumentConversationRemoteMarker( lettaDocumentConversationBindingId(declaration, event!), )); });
test("recovers a summary-marked remote conversation and fails closed on duplicate markers", async () => { const fixture = await fixtureWorkspace(); const event = (await fixture.connector.scan(fixture.store)).events.find((candidate) => ( candidate.payload.path === "lessons/eligible.md" ))!; const declaration = publicKnowledgeDeclaration(); const context = await buildPublicKnowledgeContextPacket(fixture.store, declaration, event, fixture.contextOptions); const marker = lettaDocumentConversationRemoteMarker(lettaDocumentConversationBindingId(declaration, event)); const existing = conversation("conv-recovered", marker); const client = new FakeConversationClient(validProposedDiff(context), [existing]); const runner = new LettaAgentSdkRunner({ client, conversationStore: fixture.store, environment: { THOUGHTSTREAM_LETTA_CO_MEMORY_DIR: "/tmp/co-memory" }, reconciliationDelayMs: 0, });
await runner.run({ runId: "thought-run-recover", declaration, event, context }, async () => {});
expect(client.created).toHaveLength(0); expect(client.resumedIds).toEqual([existing.id]); expect((await fixture.store.listLettaConversationBindings())[0]?.conversationId).toBe(existing.id);
const duplicateRoot = await temporaryProject("thoughtstream-pk-duplicate-"); roots.push(duplicateRoot); const duplicateStore = await testStore(duplicateRoot); stores.push(duplicateStore); const duplicateClient = new FakeConversationClient(validProposedDiff(context), [ conversation("conv-duplicate-a", marker), conversation("conv-duplicate-b", marker), ]); const duplicateRunner = new LettaAgentSdkRunner({ client: duplicateClient, conversationStore: duplicateStore, environment: { THOUGHTSTREAM_LETTA_CO_MEMORY_DIR: "/tmp/co-memory" }, reconciliationDelayMs: 0, }); await expect(duplicateRunner.run({ runId: "thought-run-duplicate", declaration, event, context, }, async () => {})).rejects.toMatchObject({ diagnostic: { code: "letta-conversation-marker-ambiguous" }, }); expect(duplicateClient.resumedIds).toHaveLength(0); });
test("recovers one validated proposal tool call from durable conversation history without resending", async () => { const fixture = await fixtureWorkspace(); const event = (await fixture.connector.scan(fixture.store)).events.find((candidate) => ( candidate.payload.path === "lessons/eligible.md" ))!; const declaration = publicKnowledgeDeclaration(); const context = await buildPublicKnowledgeContextPacket(fixture.store, declaration, event, fixture.contextOptions); const proposal = validProposedDiff(context); const marker = lettaDocumentConversationRemoteMarker(lettaDocumentConversationBindingId(declaration, event)); const existing = conversation("conv-history-recovery", marker); const turnKey = lettaTurnKey(declaration, event.id); const history = [ { id: "assistant", message_type: "assistant_message", content: "PROPOSAL_CAPTURED" }, { id: "tool-return", message_type: "tool_return_message", tool_call_id: "proposal-call", status: "success", tool_return: "{\"accepted\":true}", }, { id: "tool-call", message_type: "tool_call_message", tool_call: { tool_call_id: "proposal-call", name: PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME, arguments: JSON.stringify({ raw: JSON.stringify(proposal) }), }, }, { id: "user", message_type: "user_message", content: `trusted marker ${turnKey}` }, ]; const client = new FakeConversationClient(proposal, [existing], "none", history); const runner = new LettaAgentSdkRunner({ client, conversationStore: fixture.store, environment: { THOUGHTSTREAM_LETTA_CO_MEMORY_DIR: "/tmp/co-memory" }, reconciliationDelayMs: 0, });
const output = await runner.run({ runId: "thought-run-history-recovery", declaration, event, context }, async () => {});
expect(output).toMatchObject({ decision: "revise-existing", proposal: { target: { slug: "agent-memory" } }, publicationEligible: false, }); expect(client.sessions[0]?.sent).toHaveLength(0); expect(client.sessions[0]?.streamCalls).toBe(0); });
test("rejects context-invalid targets, hashes, links, and privacy claims after schema validation", async () => { const fixture = await fixtureWorkspace("# Eligible source\n\nA memory architecture note.\n\n[[journal/private]]\n"); const event = (await fixture.connector.scan(fixture.store)).events.find((candidate) => ( candidate.payload.path === "lessons/eligible.md" ))!; const context = await buildPublicKnowledgeContextPacket( fixture.store, publicKnowledgeDeclaration(), event, fixture.contextOptions, ); const valid = validProposedDiff(context); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...valid, proposal: { ...valid.proposal!, target: { kind: "replacement", slug: "missing-entry", baseSha256: "a".repeat(64) }, }, }, context)).toThrow("not admitted"); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...valid, proposal: { ...valid.proposal!, target: { ...valid.proposal!.target, baseSha256: "b".repeat(64) }, }, }, context)).toThrow("base hash"); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...valid, proposal: { ...valid.proposal!, draft: { ...valid.proposal!.draft, relatedSlugs: ["missing-entry"] }, }, }, context)).toThrow("unknown related slugs"); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...valid, privacy: { status: "clear", findings: [] }, }, context)).toThrow("blocked wikilinks"); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...valid, privateDependencies: ["private evidence"], privacy: { status: "clear", findings: [] }, }, { ...context, manifest: { ...context.manifest, publicKnowledge: { ...(context.manifest.publicKnowledge as object), blockedWikilinkCount: 0 }, }, })).toThrow("private dependencies"); const colliding = validNewProposedDiff(); expect(() => validatePublicKnowledgeProposedDiffAgainstContext({ ...colliding, proposal: { ...colliding.proposal!, target: { kind: "new", slug: "agent-memory", baseSha256: null }, }, }, context)).toThrow("collides"); });
test("requires inert new, replacement, and blocked-skip shapes", () => { expect(() => publicKnowledgeProposedDiffOutputSchema.parse({ ...validNewProposedDiff(), publicationEligible: true, })).toThrow(); expect(() => publicKnowledgeProposedDiffOutputSchema.parse({ ...validNewProposedDiff(), proposal: { ...validNewProposedDiff().proposal!, target: { kind: "new", slug: "new-entry", baseSha256: "a".repeat(64) }, }, })).toThrow(); expect(() => publicKnowledgeProposedDiffOutputSchema.parse({ ...validNewProposedDiff(), privacy: { status: "blocked", findings: ["private"] }, })).toThrow(); expect(publicKnowledgeProposedDiffOutputSchema.parse({ proposalState: "agent-proposed", decision: "skip", summary: "No public-safe draft.", rationale: ["The source is private."], proposal: null, publicSourcesToVerify: [], privateDependencies: [], privacy: { status: "blocked", findings: ["private"] }, confidence: "high", publicationEligible: false, })).toMatchObject({ decision: "skip", proposal: null, publicationEligible: false }); });
test.each([ ["none", "missing-tool-call"], ["unknown", "unexpected-tool-call"], ["duplicate", "duplicate-call"], ["malformed", "invalid-schema"], ["context-invalid", "invalid-context"], ["missing-result", "missing-tool-result"], ["error-result", "invalid-tool-result"], ] as const)("fails closed for %s proposal-tool behavior", async (toolBehavior, reason) => { const fixture = await fixtureWorkspace(); const event = (await fixture.connector.scan(fixture.store)).events.find((candidate) => ( candidate.payload.path === "lessons/eligible.md" ))!; const declaration = publicKnowledgeDeclaration(); const context = await buildPublicKnowledgeContextPacket(fixture.store, declaration, event, fixture.contextOptions); const client = new FakeConversationClient(validProposedDiff(context), [], toolBehavior); const runner = new LettaAgentSdkRunner({ client, conversationStore: fixture.store, environment: { THOUGHTSTREAM_LETTA_CO_MEMORY_DIR: "/tmp/co-memory" }, reconciliationDelayMs: 0, });
const error = await runner.run({ runId: `thought-run-tool-${toolBehavior}`, declaration, event, context, }, async () => {}).catch((caught) => caught); expect(error).toMatchObject({ diagnostic: { code: "invalid-proposal-tool-output", reason }, advanceProgress: true, }); expect(JSON.stringify(error.diagnostic)).not.toContain("PRIVATE-MALFORMED-RATIONALE"); });});
class ProposedDiffProbe implements AgentRunner { readonly mode = "letta-agent-sdk" as const; calls = 0; async run(_input: AgentRunInput, _onTrace: (trace: RunnerTrace) => Promise<void>): Promise<AgentOutput> { this.calls += 1; return validNewProposedDiff(); }}
type ToolBehavior = "valid" | "none" | "unknown" | "duplicate" | "malformed" | "context-invalid" | "missing-result" | "error-result";
class FakeConversationClient implements LettaAgentSdkClient { readonly created: LettaConversation[] = []; readonly resumedIds: string[] = []; readonly sessionOptions: Array<LettaCodeClientSessionOptions | undefined> = []; readonly sessions: FakeSession[] = []; private readonly remote = new Map<string, LettaConversation>(); private sequence = 0;
readonly conversations: NonNullable<LettaAgentSdkClient["conversations"]>;
constructor( private readonly output: PublicKnowledgeProposedDiffOutput, conversations: LettaConversation[] = [], private readonly toolBehavior: ToolBehavior = "valid", private readonly history: unknown[] = [], ) { for (const item of conversations) this.remote.set(item.id, item); this.conversations = { list: async (options) => [...this.remote.values()].filter((item) => ( (!options?.agentId || item.agent_id === options.agentId) && (!options?.summarySearch || item.summary?.includes(options.summarySearch)) )), create: async (options) => { const item = conversation(`conv-created-${++this.sequence}`, options.summary ?? ""); this.remote.set(item.id, item); this.created.push(item); return item; }, retrieve: async (conversationId) => { const item = this.remote.get(conversationId); if (!item) throw new Error("conversation missing"); return item; }, }; }
resumeSession(id: string, options?: LettaCodeClientSessionOptions): LettaCodeSession { this.resumedIds.push(id); this.sessionOptions.push(options); const session = new FakeSession(id, this.output, options?.tools ?? [], this.toolBehavior, this.history); this.sessions.push(session); return session as unknown as LettaCodeSession; }}
class FakeSession { readonly agentId = "agent-co-fixture"; readonly sessionId = "session-pk-fixture"; readonly sent: string[] = []; streamCalls = 0; closed = false;
constructor( readonly conversationId: string, private readonly output: PublicKnowledgeProposedDiffOutput, private readonly tools: AnyAgentTool[], private readonly toolBehavior: ToolBehavior, private readonly history: unknown[], ) {}
async send(message: SendMessage): Promise<void> { if (typeof message !== "string") throw new Error("Fixture accepts text only"); this.sent.push(message); }
async *stream(): AsyncGenerator<SDKMessage> { this.streamCalls += 1; if (this.toolBehavior === "unknown") { yield { type: "tool_call", toolCallId: "tool-call-unknown", toolName: "Bash", toolInput: { command: "redacted" }, uuid: "tool-call-message-unknown", runId: "run-pk-fixture", } as SDKMessage; } else if (this.toolBehavior !== "none") { const tool = this.tools.find((candidate) => candidate.name === PUBLIC_KNOWLEDGE_PROPOSAL_TOOL_NAME); if (!tool) throw new Error("Fixture proposal tool is missing"); const calls = this.toolBehavior === "duplicate" ? 2 : 1; for (let index = 0; index < calls; index += 1) { const toolCallId = `tool-call-fixture-${index + 1}`; const input = this.toolBehavior === "malformed" ? { ...this.output, rationale: "PRIVATE-MALFORMED-RATIONALE" } : this.toolBehavior === "context-invalid" && this.output.proposal ? { ...this.output, proposal: { ...this.output.proposal, target: { ...this.output.proposal.target, baseSha256: "b".repeat(64) }, }, } : this.output; const toolInput = { raw: JSON.stringify(input) }; const result = await tool.execute(toolCallId, toolInput); yield { type: "tool_call", toolCallId, toolName: tool.name, toolInput, uuid: `tool-call-message-fixture-${index + 1}`, runId: "run-pk-fixture", } as SDKMessage; if (this.toolBehavior !== "missing-result") { yield { type: "tool_result", toolCallId, content: result.content.map((part) => part.text ?? "").join(""), isError: this.toolBehavior === "error-result" ? true : result.isError ?? false, uuid: `tool-result-message-fixture-${index + 1}`, runId: "run-pk-fixture", } as SDKMessage; } } } yield { type: "result", success: true, result: "PROPOSAL_CAPTURED", durationMs: 20, conversationId: this.conversationId, runIds: ["run-pk-fixture"], }; }
async abort(): Promise<void> {} async listMessages(): Promise<ListMessagesResult> { return { messages: this.history as ListMessagesResult["messages"], nextBefore: null, hasMore: false }; } close(): void { this.closed = true; }}
async function fixtureWorkspace(source = "# Eligible source\n\nA durable memory architecture note.\n") { const project = await temporaryProject("thoughtstream-pk-"); roots.push(project); const vault = path.join(project, "vault"); const catalog = path.join(project, "published"); const policyPath = path.join(project, "policy.json"); await fs.mkdir(path.join(vault, "lessons"), { recursive: true }); await fs.mkdir(path.join(vault, "journal"), { recursive: true }); await fs.mkdir(catalog, { recursive: true }); await fs.writeFile(path.join(vault, "lessons", "eligible.md"), source); await fs.writeFile(path.join(vault, "journal", "private.md"), "PRIVATE JOURNAL SENTINEL\n"); await fs.writeFile(path.join(catalog, "agent-memory.md"), [ "---", "slug: agent-memory", "title: Agent memory", "summary: Public metadata only", "---", "PUBLIC ADMITTED TARGET BODY", "", ].join("\n")); await fs.writeFile(path.join(catalog, "unrelated-entry.md"), [ "---", "slug: unrelated-entry", "title: Maritime fertilizer logistics", "summary: Public shipping metadata", "---", "UNRELATED PUBLIC BODY MUST STAY OUT", "", ].join("\n")); await fs.writeFile(policyPath, JSON.stringify({ version: 1, defaultDecision: "deny", sourceMappings: [{ pattern: "lessons/*.md", decision: "stage" }], blockedPrefixes: ["journal/"], blockedWikilinkPrefixes: ["journal/"], })); const store = await testStore(project); stores.push(store); return { project, store, connector: new FilesystemConnector({ id: "filesystem:coil", root: vault, privacy: "sensitive" }), contextOptions: { policyPath, catalogRoot: catalog }, };}
function publicKnowledgeDeclaration(): ThoughtAgentDeclaration { return { id: "coil-public-knowledge", version: 3, name: "Coil Public Knowledge", description: "Fixture", mode: "letta-agent-sdk", provider: "letta-local", model: "chatgpt-plus-pro/gpt-5.6-luna", outputContract: { ...PUBLIC_KNOWLEDGE_PROPOSED_DIFF_OUTPUT_CONTRACT.identity }, lettaAgent: { backend: "local", agentIdEnv: "THOUGHTSTREAM_LETTA_CO_AGENT_ID", agentId: "agent-co-fixture", conversation: "per-document", responseMode: "strict-json", outputOnly: true, proposalTool: "public-knowledge-diff", permissionMode: "strict", skillSources: [], memoryDirEnv: "THOUGHTSTREAM_LETTA_CO_MEMORY_DIR", dreaming: { trigger: "off" }, sandbox: { ttlMinutes: 5, terminateOnClose: false }, }, eventTypes: [ "stream.thought.source.file.added", "stream.thought.source.file.changed", "stream.thought.source.file.renamed", "stream.thought.source.file.deleted", ], compiledEventTypes: [ "stream.thought.source.file.added", "stream.thought.source.file.changed", "stream.thought.source.file.renamed", "stream.thought.source.file.deleted", ], sourcePatterns: ["filesystem:coil"], acceptedPrivacy: ["sensitive"], initialReplay: "beginning", outputEventType: PUBLIC_KNOWLEDGE_PROPOSED_DIFF_EVENT_TYPE, emit: [PUBLIC_KNOWLEDGE_PROPOSED_DIFF_EVENT_TYPE], promptRef: "prompts/coil-public-knowledge.md", systemPrompt: "Recommend Public Knowledge content.", enabled: true, maxEvents: 1, maxInputChars: 100_000, contextStrategy: "coil-public-knowledge", payloadFields: ["documentId", "path", "versionId", "sha256"], maxOutputTokens: 4_000, timeoutMs: 180_000, accounting: { leaseMs: 240_000, reservation: { inputTokens: 60_000, outputTokens: 4_000 }, limits: [{ window: "hour", maxCalls: 20, maxInputTokens: 1_200_000, maxOutputTokens: 40_000, }], }, tools: [], externalActions: false, };}
function validProposedDiff(context: { manifest: { publicKnowledge?: unknown } }): PublicKnowledgeProposedDiffOutput { const evidence = context.manifest.publicKnowledge as { catalogTargets?: Array<{ slug: string; sha256: string }> }; const target = evidence.catalogTargets?.[0]; if (!target) throw new Error("Fixture context has no admitted target"); return { proposalState: "agent-proposed", decision: "revise-existing", summary: "Revise the existing agent-memory entry.", rationale: ["The source adds a useful architectural distinction."], proposal: { target: { kind: "replacement", slug: target.slug, baseSha256: target.sha256 }, draft: { title: "Agent memory", summary: "A public explanation of durable agent memory.", kind: "concept", topics: ["agents", "memory"], relatedSlugs: [], bodyMarkdown: "# Agent memory\n\nDurable memory depends on explicit context custody.", }, }, publicSourcesToVerify: ["Primary source"], privateDependencies: [], privacy: { status: "clear", findings: [] }, confidence: "high", publicationEligible: false, };}
function validNewProposedDiff(): PublicKnowledgeProposedDiffOutput { return { proposalState: "agent-proposed", decision: "propose-new", summary: "Propose a new durable entry.", rationale: ["The source contains a distinct public concept."], proposal: { target: { kind: "new", slug: "new-entry", baseSha256: null }, draft: { title: "New entry", summary: "A concise public concept.", kind: "concept", topics: ["agents"], relatedSlugs: [], bodyMarkdown: "# New entry\n\nA proposed body.", }, }, publicSourcesToVerify: [], privateDependencies: [], privacy: { status: "clear", findings: [] }, confidence: "medium", publicationEligible: false, };}
function conversation(id: string, summary: string): LettaConversation { return { id, agent_id: "agent-co-fixture", summary, } as LettaConversation;}