@tangle-network/agent-runtime 0.339.0 → 0.342.0

package/dist/workspace-store/index.js

@@ -1,215 +1,4 @@
 import { z } from "zod";
-//#region src/workspace-store/codec.ts
-/** A value did not open: unknown key, wrong tenant or path, tampering, or plaintext where a seal was required. */
-var WorkspaceCodecError = class extends Error {
-	code = "codec";
-	constructor(message) {
-		super(message);
-		this.name = "WorkspaceCodecError";
-	}
-};
-const VERSION = 1;
-const IV_BYTES = 12;
-const KEY_ID = /^[A-Za-z0-9_-]{1,64}$/;
-const encoder = new TextEncoder();
-const decoder = new TextDecoder("utf-8", { fatal: true });
-function bytesOf(value) {
-	if (typeof value !== "string") return value;
-	const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
-	return Uint8Array.from(binary, (char) => char.charCodeAt(0));
-}
-function base64(bytes) {
-	let binary = "";
-	for (let offset = 0; offset < bytes.length; offset += 32768) binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
-	return btoa(binary);
-}
-/** A copy in a plain ArrayBuffer, which every Web Crypto typing accepts (this package has no DOM lib). */
-function arrayBuffer(bytes) {
-	return bytes.slice().buffer;
-}
-function concat(...parts) {
-	const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
-	let offset = 0;
-	for (const part of parts) {
-		out.set(part, offset);
-		offset += part.length;
-	}
-	return out;
-}
-/** Strings joined with a 4-byte length before each, so no two lists encode alike. */
-function framed(...values) {
-	return concat(...values.flatMap((value) => {
-		const bytes = encoder.encode(value);
-		const length = /* @__PURE__ */ new Uint8Array(4);
-		new DataView(length.buffer).setUint32(0, bytes.length);
-		return [length, bytes];
-	}));
-}
-/** The authenticated data: the tenant and path a value belongs to. */
-const associated = ({ tenant, path }) => framed(tenant, path);
-/**
-* AES-256-GCM with a key id per value. `keys` maps key id to 32 raw bytes
-* (base64 or base64url when a string). The encryption key and the key that
-* derives replay-stable IVs are both derived from the raw key with HKDF, so the
-* raw key is never used for two algorithms.
-*
-* Without an `operationId` every seal uses a random 96-bit IV. With one, the IV
-* is an HMAC of the tenant, path, operation and plaintext, as in SIV: only an
-* identical write repeats it, and that repeat reveals only that the write was
-* repeated.
-*/
-function createAesGcmContentCodec(options) {
-	const raw = /* @__PURE__ */ new Map();
-	for (const [id, value] of Object.entries(options.keys)) {
-		if (!KEY_ID.test(id)) throw new TypeError(`workspace store key id is not [A-Za-z0-9_-]{1,64}: ${id}`);
-		const bytes = bytesOf(value);
-		if (bytes.length !== 32) throw new TypeError(`workspace store key ${id} must be 32 bytes, got ${bytes.length}`);
-		raw.set(id, bytes);
-	}
-	if (!raw.has(options.activeKeyId)) throw new TypeError(`the active workspace store key ${options.activeKeyId} is not among the keys`);
-	const derived = /* @__PURE__ */ new Map();
-	const keyFor = (id) => {
-		const bytes = raw.get(id);
-		if (!bytes) return Promise.reject(new WorkspaceCodecError(`unknown workspace store key id: ${id}`));
-		let key = derived.get(id);
-		if (!key) {
-			key = (async () => {
-				const base = await crypto.subtle.importKey("raw", arrayBuffer(bytes), "HKDF", false, ["deriveKey"]);
-				const hkdf = (info) => ({
-					name: "HKDF",
-					hash: "SHA-256",
-					salt: /* @__PURE__ */ new Uint8Array(32),
-					info: encoder.encode(`workspace-store/${info}`)
-				});
-				return {
-					seal: await crypto.subtle.deriveKey(hkdf("aes-256-gcm"), base, {
-						name: "AES-GCM",
-						length: 256
-					}, false, ["encrypt", "decrypt"]),
-					iv: await crypto.subtle.deriveKey(hkdf("siv"), base, {
-						name: "HMAC",
-						hash: "SHA-256",
-						length: 256
-					}, false, ["sign"])
-				};
-			})();
-			derived.set(id, key);
-		}
-		return key;
-	};
-	return {
-		async seal(plain, context) {
-			const id = options.activeKeyId;
-			const key = await keyFor(id);
-			const aad = associated(context);
-			const iv = context.operationId === void 0 ? crypto.getRandomValues(new Uint8Array(IV_BYTES)) : new Uint8Array(await crypto.subtle.sign("HMAC", key.iv, arrayBuffer(concat(framed(context.tenant, context.path, context.operationId), plain)))).slice(0, IV_BYTES);
-			const sealed = new Uint8Array(await crypto.subtle.encrypt({
-				name: "AES-GCM",
-				iv: arrayBuffer(iv),
-				additionalData: arrayBuffer(aad)
-			}, key.seal, arrayBuffer(plain)));
-			const keyId = encoder.encode(id);
-			return concat(Uint8Array.of(VERSION, keyId.length), keyId, iv, sealed);
-		},
-		async open(sealed, context) {
-			if (sealed.length < 2 || sealed[0] !== VERSION) throw new WorkspaceCodecError("not a sealed workspace value");
-			const start = 2 + sealed[1];
-			if (sealed.length < start + IV_BYTES + 16) throw new WorkspaceCodecError("a sealed workspace value is truncated");
-			const key = await keyFor(new TextDecoder().decode(sealed.subarray(2, start)));
-			try {
-				return new Uint8Array(await crypto.subtle.decrypt({
-					name: "AES-GCM",
-					iv: arrayBuffer(sealed.subarray(start, start + IV_BYTES)),
-					additionalData: arrayBuffer(associated(context))
-				}, key.seal, arrayBuffer(sealed.subarray(start + IV_BYTES))));
-			} catch {
-				throw new WorkspaceCodecError(`${context.path}: the sealed value does not open for this tenant and path`);
-			}
-		}
-	};
-}
-/**
-* The AES-256-GCM codec from an app's env, or `null` when neither variable is
-* set. `WORKSPACE_STORE_KEYS` is `id:base64,id:base64`; `WORKSPACE_STORE_KEY_ID`
-* names the key new writes use. Setting one without the other is refused.
-*/
-function aesGcmContentCodecFromEnv(env) {
-	const list = env.WORKSPACE_STORE_KEYS?.trim();
-	const active = env.WORKSPACE_STORE_KEY_ID?.trim();
-	if (!list && !active) return null;
-	if (!list || !active) throw new TypeError("set both WORKSPACE_STORE_KEYS and WORKSPACE_STORE_KEY_ID");
-	const keys = {};
-	for (const pair of list.split(",")) {
-		const at = pair.indexOf(":");
-		if (at <= 0) throw new TypeError("WORKSPACE_STORE_KEYS is id:base64,id:base64");
-		keys[pair.slice(0, at).trim()] = pair.slice(at + 1).trim();
-	}
-	return createAesGcmContentCodec({
-		keys,
-		activeKeyId: active
-	});
-}
-/** Stored text of a sealed `content`: a prefix, then the sealed bytes in base64. */
-const SEALED_CONTENT_PREFIX = "wsc1:";
-/** Seal bytes a host is about to upload (an R2 object) under the entry's tenant and path. */
-function sealWorkspaceBytes(codec, context, bytes) {
-	return codec.seal(bytes, context);
-}
-/** Open bytes a host downloaded for an entry's `bytes` reference. */
-function openWorkspaceBytes(codec, context, sealed) {
-	return codec.open(sealed, context);
-}
-/**
-* `store` with every entry's `content` sealed at rest. Index fields, `bytes`
-* references and tombstones pass through untouched; the host seals the bytes
-* themselves. `idempotentOperations` is the inner store's: a replayed put with
-* an `operationId` seals to the same bytes, so the inner replay check holds.
-*/
-function withContentCodec(store, codec, options = {}) {
-	const open = async (entry) => {
-		if (entry.content === void 0) return entry;
-		if (!entry.content.startsWith("wsc1:")) {
-			if (options.readPlaintext) return entry;
-			throw new WorkspaceCodecError(`${entry.path}: stored content is not sealed`);
-		}
-		const plain = await codec.open(bytesOf(entry.content.slice(5)), {
-			tenant: entry.workspaceId,
-			path: entry.path
-		});
-		return {
-			...entry,
-			content: decoder.decode(plain)
-		};
-	};
-	return {
-		...store.idempotentOperations !== void 0 ? { idempotentOperations: store.idempotentOperations } : {},
-		async get(workspaceId, path) {
-			const entry = await store.get(workspaceId, path);
-			return entry ? open(entry) : null;
-		},
-		async list(workspaceId, prefix) {
-			return Promise.all((await store.list(workspaceId, prefix)).map(open));
-		},
-		async put(input) {
-			if (input.content === void 0) return store.put(input);
-			const sealed = await codec.seal(encoder.encode(input.content), {
-				tenant: input.workspaceId,
-				path: input.path,
-				...input.operationId !== void 0 ? { operationId: input.operationId } : {}
-			});
-			return {
-				...await store.put({
-					...input,
-					content: `${SEALED_CONTENT_PREFIX}${base64(sealed)}`
-				}),
-				content: input.content
-			};
-		},
-		delete: (input) => store.delete(input),
-		tombstones: (workspaceId, prefix) => store.tombstones(workspaceId, prefix)
-	};
-}
-//#endregion
 //#region src/workspace-store/store.ts
 /** A write lost a compare-and-set race or targeted the wrong revision. Re-read and retry. */
 var WorkspaceConflictError = class extends Error {
@@ -872,274 +661,282 @@ const idempotentOperationCase = ["operationId: a repeated put or delete returns
 		operationId: ""
 	}), TypeError, "an empty operationId");
 }];
+const compareAndSetCase = ["compare-and-set: create, stale update, and re-create conflict with a typed error", async (store) => {
+	const base = {
+		workspaceId: W,
+		path: "/files/a.md",
+		kind: "file",
+		actor: "alice"
+	};
+	const first = await store.put({
+		...base,
+		content: "one",
+		ifRevision: null
+	});
+	check(first.revision >= 1 && first.content === "one", "create returns revision and content");
+	check(first.createdBy === "alice" && first.createdAt && first.updatedAt, "create stamps author and times");
+	check((await rejects(() => store.put({
+		...base,
+		content: "dup",
+		ifRevision: null
+	}), WorkspaceConflictError, "create over a live path")).actual === first.revision, "conflict reports the live revision");
+	const second = await store.put({
+		...base,
+		content: "two",
+		ifRevision: first.revision,
+		actor: "bob"
+	});
+	check(second.revision > first.revision && second.id === first.id, "update bumps revision, keeps id");
+	check(second.createdBy === "alice" && second.updatedBy === "bob", "update keeps creator, records updater");
+	await rejects(() => store.put({
+		...base,
+		content: "stale",
+		ifRevision: first.revision
+	}), WorkspaceConflictError, "update at a stale revision");
+	check((await store.get(W, base.path))?.content === "two", "a refused write changes nothing");
+	check((await Promise.allSettled(["x", "y"].map((content) => store.put({
+		...base,
+		content,
+		ifRevision: second.revision
+	})))).filter((r) => r.status === "fulfilled").length === 1, "exactly one racing write wins");
+}];
+const entriesCase = ["entries: exactly one of content or bytes, normalized paths, tenant isolation, sorted list", async (store) => {
+	const bytes = {
+		key: "r2/obj-1",
+		size: 42,
+		contentType: "application/pdf"
+	};
+	const file = await store.put({
+		workspaceId: W,
+		path: "/files/b.pdf",
+		kind: "file",
+		actor: "alice",
+		bytes,
+		ifRevision: null
+	});
+	check(file.bytes?.key === bytes.key && file.content === void 0, "bytes reference round-trips");
+	await rejects(() => store.put({
+		workspaceId: W,
+		path: "/files/c",
+		kind: "file",
+		actor: "a",
+		ifRevision: null
+	}), TypeError, "neither content nor bytes");
+	for (const path of [
+		"files/x",
+		"/files/../x",
+		"/files//x",
+		"/files/x/"
+	]) await rejects(() => store.put({
+		workspaceId: W,
+		path,
+		kind: "file",
+		actor: "a",
+		content: "x",
+		ifRevision: null
+	}), TypeError, `path ${path}`);
+	await store.put({
+		workspaceId: W,
+		path: "/files/a.md",
+		kind: "file",
+		actor: "a",
+		content: "a",
+		ifRevision: null
+	});
+	await store.put({
+		workspaceId: "other",
+		path: "/files/z.md",
+		kind: "file",
+		actor: "a",
+		content: "z",
+		ifRevision: null
+	});
+	check((await store.list(W, "/files/")).map((e) => e.path).join() === "/files/a.md,/files/b.pdf", "list is sorted and tenant-scoped");
+	check(await store.get("other", "/files/a.md") === null, "another tenant cannot read the path");
+	check((await store.put({
+		workspaceId: W,
+		path: "/memories/members/alice/m1",
+		kind: "fact",
+		actor: "alice",
+		content: "x",
+		ifRevision: null
+	})).scope === "member" && file.scope === "workspace", "scope follows the path");
+}];
+const deleteTombstoneCase = ["delete erases content and keeps a tombstone; revisions stay monotonic", async (store) => {
+	const base = {
+		workspaceId: W,
+		path: "/files/secret.md",
+		kind: "file",
+		actor: "alice"
+	};
+	const entry = await store.put({
+		...base,
+		content: "card 4111",
+		ifRevision: null
+	});
+	await rejects(() => store.delete({
+		workspaceId: W,
+		path: base.path,
+		ifRevision: entry.revision + 5,
+		actor: "alice"
+	}), WorkspaceConflictError, "delete at a stale revision");
+	const tombstone = await store.delete({
+		workspaceId: W,
+		path: base.path,
+		ifRevision: entry.revision,
+		actor: "bob"
+	});
+	check(tombstone !== null, "delete returns a tombstone");
+	check(tombstone.id === entry.id && tombstone.revision > entry.revision, "tombstone keeps id, bumps revision");
+	check(tombstone.deletedBy === "bob" && Boolean(tombstone.deletedAt), "tombstone records who and when");
+	check(!JSON.stringify(tombstone).includes("4111"), "tombstone holds no content");
+	check(await store.get(W, base.path) === null, "deleted entry is gone");
+	check((await store.list(W, "/files/")).length === 0, "deleted entry is not listed");
+	const audit = await store.tombstones(W, "/files/");
+	check(audit.length === 1 && !JSON.stringify(audit).includes("4111"), "audit rows hold no content");
+	check(await store.delete({
+		workspaceId: W,
+		path: "/files/none",
+		actor: "a"
+	}) === null, "unconditional delete of a missing path is a no-op");
+	check((await store.put({
+		...base,
+		content: "new",
+		ifRevision: null
+	})).revision > tombstone.revision, "re-created path continues the revision sequence");
+}];
+const rememberRecallCase = ["tools: remember then recall round-trips, and forget erases", async (store) => {
+	const call = toolsFor(store, alice);
+	const saved = await call("memory.remember", {
+		text: "The walk-in freezer code is   on the clipboard",
+		kind: "fact",
+		scope: "workspace"
+	});
+	check(saved.saved && saved.path === `/memories/workspace/${saved.id}`, "remember saves under workspace");
+	const found = await toolsFor(store, bob)("memory.recall", { query: "freezer code" });
+	check(found.memories[0]?.id === saved.id, "another member recalls a workspace fact");
+	check(found.memories[0]?.text === "The walk-in freezer code is on the clipboard", "whitespace is collapsed");
+	const updated = await call("memory.remember", {
+		text: "The freezer code is in the office",
+		kind: "fact",
+		scope: "workspace",
+		replaces: saved.id
+	});
+	check(updated.id === saved.id && updated.revision > saved.revision, "replaces updates in place");
+	await call("memory.forget", { id: saved.id });
+	check((await call("memory.recall", { query: "freezer" })).memories.length === 0, "forgotten memory is not recalled");
+	check((await store.tombstones(W)).some((row) => row.id === saved.id), "forget leaves a tombstone");
+}];
+const memberScopeCase = ["tools: a member cannot see or touch another member’s scope", async (store) => {
+	const mine = await toolsFor(store, alice)("memory.remember", {
+		text: "Alice prefers replies in Spanish",
+		kind: "preference",
+		scope: "me"
+	});
+	check(mine.path === `/memories/members/alice/${mine.id}`, "scope me writes under the member");
+	const asBob = toolsFor(store, bob);
+	check((await asBob("memory.recall", { query: "Spanish replies" })).memories.length === 0, "recall is member-isolated");
+	await rejects(() => asBob("memory.forget", { id: mine.id }), Error, "forget of another member’s memory");
+	check(await store.get(W, mine.path) !== null, "the other member’s memory survives");
+	await rejects(() => asBob("files.read", { path: mine.path }), Error, "files.read outside /files and /knowledge");
+	check(!renderPinnedMemory(await readTurnMemories(store, bob)).includes("Spanish"), "pinned memory is member-isolated");
+	check(renderPinnedMemory(await readTurnMemories(store, alice)).includes("Spanish"), "the owner sees it pinned");
+}];
+const policyCase = ["tools: default policy and admit hook refuse by name", async (store) => {
+	await rejects(() => toolsFor(store, alice)("memory.remember", {
+		text: "Never discount",
+		kind: "instruction",
+		scope: "workspace"
+	}), WorkspacePolicyError, "member instruction");
+	await rejects(() => toolsFor(store, alice)("memory.remember", {
+		text: "Use metric",
+		kind: "preference",
+		scope: "workspace"
+	}), WorkspacePolicyError, "member workspace preference");
+	await rejects(() => toolsFor(store, guest)("memory.remember", {
+		text: "I am Gus",
+		kind: "fact",
+		scope: "me"
+	}), WorkspacePolicyError, "guest write");
+	await rejects(() => toolsFor(store, alice)("files.write", {
+		path: "/knowledge/menu.md",
+		content: "x",
+		ifRevision: null
+	}), WorkspacePolicyError, "member knowledge write");
+	check((await toolsFor(store, owner)("memory.remember", {
+		text: "Never offer discounts",
+		kind: "instruction",
+		scope: "workspace"
+	})).saved, "owner saves an instruction");
+	const noPhones = defaultMemoryPolicy({ admit: (_turn, { text }) => /\d{3}-\d{4}/.test(text) ? "Phone numbers are not saved" : null });
+	check((await rejects(() => toolsFor(store, alice, noPhones)("memory.remember", {
+		text: "Call 555-0100",
+		kind: "fact",
+		scope: "me"
+	}), WorkspacePolicyError, "admit hook")).message === "Phone numbers are not saved", "refusal carries the product reason");
+	check((await store.list(W, "/memories/members/alice/")).length === 0, "refused writes store nothing");
+}];
+const fileToolsCase = ["tools: files write, read, CAS conflict, search, delete", async (store) => {
+	const call = toolsFor(store, alice);
+	const created = await call("files.write", {
+		path: "/files/notes/menu.md",
+		content: "Tuesday special: lamb",
+		ifRevision: null
+	});
+	await rejects(() => call("files.write", {
+		path: "/files/notes/menu.md",
+		content: "x",
+		ifRevision: null
+	}), WorkspaceConflictError, "files.write create over a live file");
+	const read = await toolsFor(store, bob)("files.read", { path: "/files/notes/menu.md" });
+	check(read.content === "Tuesday special: lamb" && read.revision === created.revision, "files.read returns content and revision");
+	const hits = await call("files.search", { query: "lamb special" });
+	check(hits.files[0]?.path === "/files/notes/menu.md" && hits.files[0].snippet.includes("lamb"), "files.search finds text");
+	check((await call("files.list", {})).files.length === 1, "files.list lists it");
+	await call("files.delete", {
+		path: "/files/notes/menu.md",
+		ifRevision: created.revision
+	});
+	await rejects(() => call("files.read", { path: "/files/notes/menu.md" }), Error, "read after delete");
+}];
+const pinnedMemoryCase = ["renderPinnedMemory: stable, ordered, budgeted, ends with the recall index", async (store) => {
+	await toolsFor(store, alice)("memory.remember", {
+		text: "Alice works weekends",
+		kind: "fact",
+		scope: "me"
+	});
+	await toolsFor(store, owner)("memory.remember", {
+		text: "Always greet by name",
+		kind: "instruction",
+		scope: "workspace"
+	});
+	for (let i = 0; i < 40; i += 1) await toolsFor(store, alice)("memory.remember", {
+		text: `Supplier ${i} delivers on day ${i % 7}`,
+		kind: "fact",
+		scope: "workspace"
+	});
+	const entries = await readTurnMemories(store, alice);
+	const block = renderPinnedMemory(entries);
+	check(block === renderPinnedMemory([...entries].reverse()), "input order does not change the output");
+	check(block === renderPinnedMemory(await readTurnMemories(store, alice)), "identical input renders identically");
+	const lines = block.split("\n");
+	check(lines.findIndex((l) => l.includes("Always greet")) < lines.findIndex((l) => l.includes("Supplier")), "instructions first");
+	check(lines.at(-1) === "</saved-memory>" && lines.at(-2)?.startsWith("Recall more:"), "ends with the recall index");
+	check(entries.every((e) => block.includes(`[${e.id}]`)), "every memory is shown with its id under the default budget");
+	const small = renderPinnedMemory(entries, { maxTokens: 120 });
+	check(small.length <= 480 && /\d+ more not shown\./.test(small), "a small budget truncates and counts");
+}];
 /** The contract as named cases; each case builds its own store. */
 function workspaceStoreContractCases(makeStore, options = {}) {
 	const cases = [
-		["compare-and-set: create, stale update, and re-create conflict with a typed error", async (store) => {
-			const base = {
-				workspaceId: W,
-				path: "/files/a.md",
-				kind: "file",
-				actor: "alice"
-			};
-			const first = await store.put({
-				...base,
-				content: "one",
-				ifRevision: null
-			});
-			check(first.revision >= 1 && first.content === "one", "create returns revision and content");
-			check(first.createdBy === "alice" && first.createdAt && first.updatedAt, "create stamps author and times");
-			check((await rejects(() => store.put({
-				...base,
-				content: "dup",
-				ifRevision: null
-			}), WorkspaceConflictError, "create over a live path")).actual === first.revision, "conflict reports the live revision");
-			const second = await store.put({
-				...base,
-				content: "two",
-				ifRevision: first.revision,
-				actor: "bob"
-			});
-			check(second.revision > first.revision && second.id === first.id, "update bumps revision, keeps id");
-			check(second.createdBy === "alice" && second.updatedBy === "bob", "update keeps creator, records updater");
-			await rejects(() => store.put({
-				...base,
-				content: "stale",
-				ifRevision: first.revision
-			}), WorkspaceConflictError, "update at a stale revision");
-			check((await store.get(W, base.path))?.content === "two", "a refused write changes nothing");
-			check((await Promise.allSettled(["x", "y"].map((content) => store.put({
-				...base,
-				content,
-				ifRevision: second.revision
-			})))).filter((r) => r.status === "fulfilled").length === 1, "exactly one racing write wins");
-		}],
-		["entries: exactly one of content or bytes, normalized paths, tenant isolation, sorted list", async (store) => {
-			const bytes = {
-				key: "r2/obj-1",
-				size: 42,
-				contentType: "application/pdf"
-			};
-			const file = await store.put({
-				workspaceId: W,
-				path: "/files/b.pdf",
-				kind: "file",
-				actor: "alice",
-				bytes,
-				ifRevision: null
-			});
-			check(file.bytes?.key === bytes.key && file.content === void 0, "bytes reference round-trips");
-			await rejects(() => store.put({
-				workspaceId: W,
-				path: "/files/c",
-				kind: "file",
-				actor: "a",
-				ifRevision: null
-			}), TypeError, "neither content nor bytes");
-			for (const path of [
-				"files/x",
-				"/files/../x",
-				"/files//x",
-				"/files/x/"
-			]) await rejects(() => store.put({
-				workspaceId: W,
-				path,
-				kind: "file",
-				actor: "a",
-				content: "x",
-				ifRevision: null
-			}), TypeError, `path ${path}`);
-			await store.put({
-				workspaceId: W,
-				path: "/files/a.md",
-				kind: "file",
-				actor: "a",
-				content: "a",
-				ifRevision: null
-			});
-			await store.put({
-				workspaceId: "other",
-				path: "/files/z.md",
-				kind: "file",
-				actor: "a",
-				content: "z",
-				ifRevision: null
-			});
-			check((await store.list(W, "/files/")).map((e) => e.path).join() === "/files/a.md,/files/b.pdf", "list is sorted and tenant-scoped");
-			check(await store.get("other", "/files/a.md") === null, "another tenant cannot read the path");
-			check((await store.put({
-				workspaceId: W,
-				path: "/memories/members/alice/m1",
-				kind: "fact",
-				actor: "alice",
-				content: "x",
-				ifRevision: null
-			})).scope === "member" && file.scope === "workspace", "scope follows the path");
-		}],
-		["delete erases content and keeps a tombstone; revisions stay monotonic", async (store) => {
-			const base = {
-				workspaceId: W,
-				path: "/files/secret.md",
-				kind: "file",
-				actor: "alice"
-			};
-			const entry = await store.put({
-				...base,
-				content: "card 4111",
-				ifRevision: null
-			});
-			await rejects(() => store.delete({
-				workspaceId: W,
-				path: base.path,
-				ifRevision: entry.revision + 5,
-				actor: "alice"
-			}), WorkspaceConflictError, "delete at a stale revision");
-			const tombstone = await store.delete({
-				workspaceId: W,
-				path: base.path,
-				ifRevision: entry.revision,
-				actor: "bob"
-			});
-			check(tombstone !== null, "delete returns a tombstone");
-			check(tombstone.id === entry.id && tombstone.revision > entry.revision, "tombstone keeps id, bumps revision");
-			check(tombstone.deletedBy === "bob" && Boolean(tombstone.deletedAt), "tombstone records who and when");
-			check(!JSON.stringify(tombstone).includes("4111"), "tombstone holds no content");
-			check(await store.get(W, base.path) === null, "deleted entry is gone");
-			check((await store.list(W, "/files/")).length === 0, "deleted entry is not listed");
-			const audit = await store.tombstones(W, "/files/");
-			check(audit.length === 1 && !JSON.stringify(audit).includes("4111"), "audit rows hold no content");
-			check(await store.delete({
-				workspaceId: W,
-				path: "/files/none",
-				actor: "a"
-			}) === null, "unconditional delete of a missing path is a no-op");
-			check((await store.put({
-				...base,
-				content: "new",
-				ifRevision: null
-			})).revision > tombstone.revision, "re-created path continues the revision sequence");
-		}],
-		["tools: remember then recall round-trips, and forget erases", async (store) => {
-			const call = toolsFor(store, alice);
-			const saved = await call("memory.remember", {
-				text: "The walk-in freezer code is   on the clipboard",
-				kind: "fact",
-				scope: "workspace"
-			});
-			check(saved.saved && saved.path === `/memories/workspace/${saved.id}`, "remember saves under workspace");
-			const found = await toolsFor(store, bob)("memory.recall", { query: "freezer code" });
-			check(found.memories[0]?.id === saved.id, "another member recalls a workspace fact");
-			check(found.memories[0]?.text === "The walk-in freezer code is on the clipboard", "whitespace is collapsed");
-			const updated = await call("memory.remember", {
-				text: "The freezer code is in the office",
-				kind: "fact",
-				scope: "workspace",
-				replaces: saved.id
-			});
-			check(updated.id === saved.id && updated.revision > saved.revision, "replaces updates in place");
-			await call("memory.forget", { id: saved.id });
-			check((await call("memory.recall", { query: "freezer" })).memories.length === 0, "forgotten memory is not recalled");
-			check((await store.tombstones(W)).some((row) => row.id === saved.id), "forget leaves a tombstone");
-		}],
-		["tools: a member cannot see or touch another member’s scope", async (store) => {
-			const mine = await toolsFor(store, alice)("memory.remember", {
-				text: "Alice prefers replies in Spanish",
-				kind: "preference",
-				scope: "me"
-			});
-			check(mine.path === `/memories/members/alice/${mine.id}`, "scope me writes under the member");
-			const asBob = toolsFor(store, bob);
-			check((await asBob("memory.recall", { query: "Spanish replies" })).memories.length === 0, "recall is member-isolated");
-			await rejects(() => asBob("memory.forget", { id: mine.id }), Error, "forget of another member’s memory");
-			check(await store.get(W, mine.path) !== null, "the other member’s memory survives");
-			await rejects(() => asBob("files.read", { path: mine.path }), Error, "files.read outside /files and /knowledge");
-			check(!renderPinnedMemory(await readTurnMemories(store, bob)).includes("Spanish"), "pinned memory is member-isolated");
-			check(renderPinnedMemory(await readTurnMemories(store, alice)).includes("Spanish"), "the owner sees it pinned");
-		}],
-		["tools: default policy and admit hook refuse by name", async (store) => {
-			await rejects(() => toolsFor(store, alice)("memory.remember", {
-				text: "Never discount",
-				kind: "instruction",
-				scope: "workspace"
-			}), WorkspacePolicyError, "member instruction");
-			await rejects(() => toolsFor(store, alice)("memory.remember", {
-				text: "Use metric",
-				kind: "preference",
-				scope: "workspace"
-			}), WorkspacePolicyError, "member workspace preference");
-			await rejects(() => toolsFor(store, guest)("memory.remember", {
-				text: "I am Gus",
-				kind: "fact",
-				scope: "me"
-			}), WorkspacePolicyError, "guest write");
-			await rejects(() => toolsFor(store, alice)("files.write", {
-				path: "/knowledge/menu.md",
-				content: "x",
-				ifRevision: null
-			}), WorkspacePolicyError, "member knowledge write");
-			check((await toolsFor(store, owner)("memory.remember", {
-				text: "Never offer discounts",
-				kind: "instruction",
-				scope: "workspace"
-			})).saved, "owner saves an instruction");
-			const noPhones = defaultMemoryPolicy({ admit: (_turn, { text }) => /\d{3}-\d{4}/.test(text) ? "Phone numbers are not saved" : null });
-			check((await rejects(() => toolsFor(store, alice, noPhones)("memory.remember", {
-				text: "Call 555-0100",
-				kind: "fact",
-				scope: "me"
-			}), WorkspacePolicyError, "admit hook")).message === "Phone numbers are not saved", "refusal carries the product reason");
-			check((await store.list(W, "/memories/members/alice/")).length === 0, "refused writes store nothing");
-		}],
-		["tools: files write, read, CAS conflict, search, delete", async (store) => {
-			const call = toolsFor(store, alice);
-			const created = await call("files.write", {
-				path: "/files/notes/menu.md",
-				content: "Tuesday special: lamb",
-				ifRevision: null
-			});
-			await rejects(() => call("files.write", {
-				path: "/files/notes/menu.md",
-				content: "x",
-				ifRevision: null
-			}), WorkspaceConflictError, "files.write create over a live file");
-			const read = await toolsFor(store, bob)("files.read", { path: "/files/notes/menu.md" });
-			check(read.content === "Tuesday special: lamb" && read.revision === created.revision, "files.read returns content and revision");
-			const hits = await call("files.search", { query: "lamb special" });
-			check(hits.files[0]?.path === "/files/notes/menu.md" && hits.files[0].snippet.includes("lamb"), "files.search finds text");
-			check((await call("files.list", {})).files.length === 1, "files.list lists it");
-			await call("files.delete", {
-				path: "/files/notes/menu.md",
-				ifRevision: created.revision
-			});
-			await rejects(() => call("files.read", { path: "/files/notes/menu.md" }), Error, "read after delete");
-		}],
-		["renderPinnedMemory: stable, ordered, budgeted, ends with the recall index", async (store) => {
-			await toolsFor(store, alice)("memory.remember", {
-				text: "Alice works weekends",
-				kind: "fact",
-				scope: "me"
-			});
-			await toolsFor(store, owner)("memory.remember", {
-				text: "Always greet by name",
-				kind: "instruction",
-				scope: "workspace"
-			});
-			for (let i = 0; i < 40; i += 1) await toolsFor(store, alice)("memory.remember", {
-				text: `Supplier ${i} delivers on day ${i % 7}`,
-				kind: "fact",
-				scope: "workspace"
-			});
-			const entries = await readTurnMemories(store, alice);
-			const block = renderPinnedMemory(entries);
-			check(block === renderPinnedMemory([...entries].reverse()), "input order does not change the output");
-			check(block === renderPinnedMemory(await readTurnMemories(store, alice)), "identical input renders identically");
-			const lines = block.split("\n");
-			check(lines.findIndex((l) => l.includes("Always greet")) < lines.findIndex((l) => l.includes("Supplier")), "instructions first");
-			check(lines.at(-1) === "</saved-memory>" && lines.at(-2)?.startsWith("Recall more:"), "ends with the recall index");
-			check(entries.every((e) => block.includes(`[${e.id}]`)), "every memory is shown with its id under the default budget");
-			const small = renderPinnedMemory(entries, { maxTokens: 120 });
-			check(small.length <= 480 && /\d+ more not shown\./.test(small), "a small budget truncates and counts");
-		}]
+		compareAndSetCase,
+		entriesCase,
+		deleteTombstoneCase,
+		rememberRecallCase,
+		memberScopeCase,
+		policyCase,
+		fileToolsCase,
+		pinnedMemoryCase
 	];
 	if (options.idempotentOperations) cases.push(idempotentOperationCase);
 	return cases.map(([name, body]) => ({
@@ -1168,209 +965,6 @@ async function runWorkspaceStoreContract(makeStore, options = {}) {
 	return results;
 }
 //#endregion
-//#region src/workspace-store/harness.ts
-/** Opening marker for the generated block in a harness's native memory file. */
-const HARNESS_MEMORY_BEGIN = "<!-- workspace-store:memory begin. Generated from the workspace store; save memories with memory.remember. -->";
-/** Closing marker for the generated block in a harness's native memory file. */
-const HARNESS_MEMORY_END = "<!-- workspace-store:memory end -->";
-/** The generated block a host writes into a harness's native memory location. */
-function renderHarnessMemory(entries, options = {}) {
-	return [
-		HARNESS_MEMORY_BEGIN,
-		renderPinnedMemory(entries, options),
-		HARNESS_MEMORY_END
-	].join("\n");
-}
-/** Replace the generated block in `native`, or append one; text outside it is kept byte for byte. */
-function projectHarnessMemory(native, block) {
-	const { before, after, found } = splitGenerated(native);
-	if (found) return `${before}${block}${after}`;
-	return native.length === 0 ? `${block}\n` : `${native}${native.endsWith("\n") ? "\n" : "\n\n"}${block}\n`;
-}
-function splitGenerated(native) {
-	const start = native.indexOf(HARNESS_MEMORY_BEGIN);
-	const end = start < 0 ? -1 : native.indexOf(HARNESS_MEMORY_END, start);
-	if (start < 0 || end < 0) return {
-		before: native,
-		block: "",
-		after: "",
-		found: false
-	};
-	const stop = end + 35;
-	return {
-		before: native.slice(0, start),
-		block: native.slice(start, stop),
-		after: native.slice(stop),
-		found: true
-	};
-}
-/** Ids listed in a generated block (`- [id] kind, scope: text`). */
-function projectedIds(block) {
-	const ids = /* @__PURE__ */ new Map();
-	for (const match of block.matchAll(/^- \[([A-Za-z0-9_-]{1,64})\] [a-z]+, (?:me|workspace): (.*)$/gm)) ids.set(match[1], match[2]);
-	return ids;
-}
-/** Lowercase, collapse spaces, drop a leading "Remember:" and trailing punctuation: the duplicate key. */
-function normalizeMemoryText(text) {
-	return text.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)?/, "").replace(/^(?:remember|note)\b\s*(?:that\b)?\s*:?\s*/i, "").replace(/\s+/g, " ").trim().replace(/[.!;,\s]+$/, "").toLowerCase();
-}
-function stripFrontmatter(text) {
-	return text.startsWith("---\n") ? text.slice(text.indexOf("\n---", 4) + 4).replace(/^\n+/, "") : text;
-}
-/** Lines that read as one memory: bullets and plain sentences, not headings, markers or fences. */
-function memoryLines(text) {
-	const lines = [];
-	let fenced = false;
-	for (const raw of stripFrontmatter(text).split("\n")) {
-		const line = raw.trim();
-		if (line.startsWith("```")) {
-			fenced = !fenced;
-			continue;
-		}
-		if (fenced || !line || line.startsWith("#") || line.startsWith("<!--") || line.startsWith("@")) continue;
-		const fact = line.replace(/^(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
-		if (fact.length >= 3 && fact.length <= 1e3) lines.push(fact);
-	}
-	return lines;
-}
-/**
-* What the harness added during the turn, outside the generated block: new
-* lines in files that existed, and the body of new files (a Claude Code memory
-* directory entry). Lines removed or present before are ignored; a removal is
-* not a forget, which only `memory.forget` performs.
-*/
-function captureHarnessMemory(before, after) {
-	const seen = /* @__PURE__ */ new Set();
-	const facts = [];
-	for (const [path, next] of Object.entries(after)) {
-		if (next === void 0) continue;
-		const old = new Set(memoryLines(outside(before[path] ?? "")).map(normalizeMemoryText));
-		for (const fact of memoryLines(outside(next))) {
-			const key = normalizeMemoryText(fact);
-			if (!key || old.has(key) || seen.has(key)) continue;
-			seen.add(key);
-			facts.push(fact);
-		}
-	}
-	return facts;
-}
-function outside(native) {
-	const { before, after, found } = splitGenerated(native);
-	return found ? `${before}\n${after}` : native;
-}
-const ACTOR = /^harness:([a-z0-9][a-z0-9._-]{0,40})\/turn:([^/\s]{1,128})\/member:([^/\s]{1,128})$/;
-/** The entry `actor` for a captured memory, so `createdBy` carries its provenance. */
-function harnessActor({ harness, turnId, memberId }) {
-	const actor = `harness:${harness}/turn:${turnId}/member:${memberId}`;
-	if (!ACTOR.test(actor)) throw new TypeError(`invalid harness provenance: ${actor}`);
-	return actor;
-}
-/** Read the harness, turn, and member provenance encoded by `harnessActor`. */
-function parseHarnessActor(actor) {
-	const match = ACTOR.exec(actor);
-	return match ? {
-		harness: match[1],
-		turnId: match[2],
-		memberId: match[3]
-	} : null;
-}
-/**
-* Save captured facts as workspace memories through the same policy as
-* `memory.remember`, with the harness and turn as the actor. Duplicates of a
-* memory the turn can see, or of an earlier fact in the batch, are skipped.
-*/
-async function ingestHarnessMemories(context, input) {
-	const turn = await context.activeTurn();
-	const actor = harnessActor({
-		harness: input.harness,
-		turnId: input.turnId,
-		memberId: turn.memberId
-	});
-	const newId = context.newId ?? (() => crypto.randomUUID());
-	const known = new Set((await readTurnMemories(context.store, turn)).map((entry) => normalizeMemoryText(entry.content ?? "")));
-	const saved = [];
-	const duplicates = [];
-	const refused = [];
-	for (const raw of input.facts) {
-		const text = raw.replace(/\s+/g, " ").trim();
-		const key = normalizeMemoryText(text);
-		if (!key) continue;
-		if (known.has(key)) {
-			duplicates.push(text);
-			continue;
-		}
-		const id = newId();
-		const path = `/memories/workspace/${id}`;
-		try {
-			await guard(context, turn, {
-				op: "write",
-				path,
-				kind: "fact"
-			}, text);
-		} catch (error) {
-			refused.push({
-				text,
-				reason: error instanceof Error ? error.message : String(error)
-			});
-			continue;
-		}
-		known.add(key);
-		saved.push(await context.store.put({
-			workspaceId: turn.workspaceId,
-			path,
-			kind: "fact",
-			ifRevision: null,
-			actor,
-			content: text,
-			id
-		}));
-	}
-	return {
-		saved,
-		duplicates,
-		refused
-	};
-}
-/**
-* Compare each native file with the store as `turn` sees it, after ingest ran.
-* `before` is the files as projected at session start, `after` as they are now:
-* only what the harness added since then can be uncaptured, so the profile's own
-* generated text in the same file never counts. Files that held a generated
-* block at session start are projection targets: losing the block counts every
-* visible memory as missing. Other files (a new memory-directory entry) can
-* only hold uncaptured facts.
-*/
-async function memoryDivergence(store, turn, before, after) {
-	const entries = (await readTurnMemories(store, turn)).filter((entry) => entry.content !== void 0);
-	const byId = new Map(entries.map((entry) => [entry.id, entry.content.replace(/\s+/g, " ").trim()]));
-	const stored = new Set(entries.map((entry) => normalizeMemoryText(entry.content)));
-	const files = {};
-	let missing = 0;
-	let stale = 0;
-	let uncaptured = 0;
-	for (const [path, native] of Object.entries(after)) {
-		if (native === void 0) continue;
-		const target = splitGenerated(before[path] ?? "").found || splitGenerated(native).found;
-		const listed = projectedIds(splitGenerated(native).block);
-		const report = {
-			missing: target ? [...byId.keys()].filter((id) => !listed.has(id)) : [],
-			stale: [...listed].filter(([id, text]) => byId.get(id) !== text).map(([id]) => id),
-			uncaptured: captureHarnessMemory({ [path]: before[path] }, { [path]: native }).filter((fact) => !stored.has(normalizeMemoryText(fact)))
-		};
-		missing += report.missing.length;
-		stale += report.stale.length;
-		uncaptured += report.uncaptured.length;
-		files[path] = report;
-	}
-	return {
-		total: missing + stale + uncaptured,
-		missing,
-		stale,
-		uncaptured,
-		files
-	};
-}
-//#endregion
-export { HARNESS_MEMORY_BEGIN, SEALED_CONTENT_PREFIX, WorkspaceCodecError, WorkspaceConflictError, aesGcmContentCodecFromEnv, assertWorkspacePath, captureHarnessMemory, checkWorkspacePut, createAesGcmContentCodec, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, ingestHarnessMemories, memoryDivergence, openWorkspaceBytes, parseHarnessActor, projectHarnessMemory, readTurnMemories, renderHarnessMemory, renderPinnedMemory, runWorkspaceStoreContract, sealWorkspaceBytes, withContentCodec, workspaceStoreContractCases };
+export { WorkspaceConflictError, assertWorkspacePath, checkWorkspacePut, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, readTurnMemories, renderPinnedMemory, runWorkspaceStoreContract, workspaceStoreContractCases };
 
 //# sourceMappingURL=index.js.map