@tangle-network/agent-runtime 0.317.0 → 0.319.3

package/dist/workspace-store/index.js

@@ -1,4 +1,215 @@
 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 {
@@ -34,6 +245,21 @@ function checkWorkspacePut(input) {
 	if (!input.actor) throw new TypeError("actor is required");
 	if (input.content === void 0 === (input.bytes === void 0)) throw new TypeError(`${input.path}: exactly one of content and bytes is required`);
 	if (input.ifRevision !== null && !Number.isSafeInteger(input.ifRevision)) throw new TypeError(`${input.path}: ifRevision must be an integer or null`);
+	checkOperationId(input.path, input.operationId);
+}
+const MAX_OPERATION_ID = 256;
+/** Refuse an `operationId` that is present but empty, not a string, or over 256 chars. */
+function checkOperationId(path, operationId) {
+	if (operationId === void 0) return;
+	if (typeof operationId !== "string" || !operationId || operationId.length > MAX_OPERATION_ID) throw new TypeError(`${path}: operationId must be a non-empty string of at most ${MAX_OPERATION_ID} chars`);
+}
+function sameBytes(left, right) {
+	if (!left || !right) return left === right;
+	return left.key === right.key && left.size === right.size && left.contentType === right.contentType && left.sha256 === right.sha256;
+}
+/** Whether `entry` is exactly what `input` would write: same kind, content and bytes. */
+function isSameWorkspaceWrite(entry, input) {
+	return entry.kind === input.kind && entry.content === input.content && sameBytes(entry.bytes, input.bytes);
 }
 /** Process-local adapter for tests, previews, and single-instance hosts. */
 function createInMemoryWorkspaceStore(options = {}) {
@@ -42,6 +268,9 @@ function createInMemoryWorkspaceStore(options = {}) {
 	const live = /* @__PURE__ */ new Map();
 	const lastRevision = /* @__PURE__ */ new Map();
 	const erased = [];
+	const wroteLive = /* @__PURE__ */ new Map();
+	const erasedBy = /* @__PURE__ */ new Map();
+	const pathKey = (workspaceId, path) => `${workspaceId}\u0000${path}`;
 	const tenant = (workspaceId) => {
 		let entries = live.get(workspaceId);
 		if (!entries) {
@@ -51,6 +280,7 @@ function createInMemoryWorkspaceStore(options = {}) {
 		return entries;
 	};
 	return {
+		idempotentOperations: true,
 		async get(workspaceId, path) {
 			const entry = live.get(workspaceId)?.get(path);
 			return entry ? structuredClone(entry) : null;
@@ -62,8 +292,9 @@ function createInMemoryWorkspaceStore(options = {}) {
 			checkWorkspacePut(input);
 			const entries = tenant(input.workspaceId);
 			const current = entries.get(input.path);
+			const key = pathKey(input.workspaceId, input.path);
+			if (current && input.operationId !== void 0 && wroteLive.get(key) === input.operationId && isSameWorkspaceWrite(current, input)) return structuredClone(current);
 			if ((current?.revision ?? null) !== input.ifRevision) throw new WorkspaceConflictError(input.path, input.ifRevision, current?.revision ?? null);
-			const key = `${input.workspaceId}\u0000${input.path}`;
 			const revision = (lastRevision.get(key) ?? 0) + 1;
 			const at = now();
 			const entry = {
@@ -82,12 +313,18 @@ function createInMemoryWorkspaceStore(options = {}) {
 			};
 			entries.set(input.path, entry);
 			lastRevision.set(key, revision);
+			if (input.operationId === void 0) wroteLive.delete(key);
+			else wroteLive.set(key, input.operationId);
 			return structuredClone(entry);
 		},
 		async delete(input) {
 			assertWorkspacePath(input.path);
+			checkOperationId(input.path, input.operationId);
 			const entries = tenant(input.workspaceId);
 			const current = entries.get(input.path);
+			const key = pathKey(input.workspaceId, input.path);
+			const previous = erasedBy.get(key);
+			if (!current && input.operationId !== void 0 && previous?.operationId === input.operationId) return { ...previous.tombstone };
 			if (input.ifRevision !== void 0 && current?.revision !== input.ifRevision) throw new WorkspaceConflictError(input.path, input.ifRevision, current?.revision ?? null);
 			if (!current) return null;
 			const revision = current.revision + 1;
@@ -100,7 +337,13 @@ function createInMemoryWorkspaceStore(options = {}) {
 				deletedAt: now()
 			};
 			entries.delete(input.path);
-			lastRevision.set(`${input.workspaceId}\u0000${input.path}`, revision);
+			lastRevision.set(key, revision);
+			wroteLive.delete(key);
+			if (input.operationId === void 0) erasedBy.delete(key);
+			else erasedBy.set(key, {
+				operationId: input.operationId,
+				tombstone
+			});
 			erased.push(tombstone);
 			return { ...tombstone };
 		},
@@ -156,6 +399,7 @@ function defaultMemoryPolicy(options = {}) {
 		...options.admit ? { admit: options.admit } : {}
 	};
 }
+/** Policy check shared by the memory tools and harness ingest; not part of the public entry. */
 async function guard(context, turn, access, text) {
 	const policy = context.policy ?? defaultMemoryPolicy();
 	const refusal = policy.authorize(turn, access);
@@ -556,9 +800,81 @@ function toolsFor(store, turn, policy) {
 		return tool.run(args);
 	};
 }
+const idempotentOperationCase = ["operationId: a repeated put or delete returns its result instead of a conflict", async (store) => {
+	check(store.idempotentOperations === true, "the store declares idempotentOperations");
+	const base = {
+		workspaceId: W,
+		path: "/files/op.md",
+		kind: "file",
+		actor: "alice"
+	};
+	const first = await store.put({
+		...base,
+		content: "one",
+		ifRevision: null,
+		operationId: "op-1"
+	});
+	const replay = await store.put({
+		...base,
+		content: "one",
+		ifRevision: null,
+		operationId: "op-1"
+	});
+	check(replay.revision === first.revision && replay.id === first.id && replay.content === "one", "a repeated put returns the entry it wrote");
+	await rejects(() => store.put({
+		...base,
+		content: "other",
+		ifRevision: null,
+		operationId: "op-1"
+	}), WorkspaceConflictError, "the same operation with different content");
+	await rejects(() => store.put({
+		...base,
+		content: "one",
+		ifRevision: null,
+		operationId: "op-other"
+	}), WorkspaceConflictError, "another operation with the same content");
+	const second = await store.put({
+		...base,
+		content: "two",
+		ifRevision: first.revision,
+		operationId: "op-2"
+	});
+	await rejects(() => store.put({
+		...base,
+		content: "one",
+		ifRevision: null,
+		operationId: "op-1"
+	}), WorkspaceConflictError, "an operation a later write superseded");
+	const erase = {
+		workspaceId: W,
+		path: base.path,
+		ifRevision: second.revision,
+		actor: "bob"
+	};
+	const tombstone = await store.delete({
+		...erase,
+		operationId: "op-3"
+	});
+	const again = await store.delete({
+		...erase,
+		operationId: "op-3"
+	});
+	check(tombstone !== null && again?.revision === tombstone.revision, "a repeated delete returns its tombstone");
+	await rejects(() => store.delete({
+		...erase,
+		operationId: "op-4"
+	}), WorkspaceConflictError, "another operation deleting the erased path");
+	check((await store.tombstones(W, base.path)).length === 1, "a repeated delete erases once");
+	await rejects(() => store.put({
+		...base,
+		content: "x",
+		ifRevision: null,
+		operationId: ""
+	}), TypeError, "an empty operationId");
+}];
 /** The contract as named cases; each case builds its own store. */
-function workspaceStoreContractCases(makeStore) {
-	return [
+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,
@@ -824,7 +1140,9 @@ function workspaceStoreContractCases(makeStore) {
 			const small = renderPinnedMemory(entries, { maxTokens: 120 });
 			check(small.length <= 480 && /\d+ more not shown\./.test(small), "a small budget truncates and counts");
 		}]
-	].map(([name, body]) => ({
+	];
+	if (options.idempotentOperations) cases.push(idempotentOperationCase);
+	return cases.map(([name, body]) => ({
 		name,
 		async run() {
 			await body(await makeStore());
@@ -832,9 +1150,9 @@ function workspaceStoreContractCases(makeStore) {
 	}));
 }
 /** Run every contract case against fresh stores; never throws for a failing case. */
-async function runWorkspaceStoreContract(makeStore) {
+async function runWorkspaceStoreContract(makeStore, options = {}) {
 	const results = [];
-	for (const contractCase of workspaceStoreContractCases(makeStore)) try {
+	for (const contractCase of workspaceStoreContractCases(makeStore, options)) try {
 		await contractCase.run();
 		results.push({
 			name: contractCase.name,
@@ -850,6 +1168,209 @@ async function runWorkspaceStoreContract(makeStore) {
 	return results;
 }
 //#endregion
-export { WorkspaceConflictError, WorkspacePolicyError, assertWorkspacePath, checkWorkspacePut, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, memberIdFromPath, rankEntries, readTurnMemories, renderPinnedMemory, runWorkspaceStoreContract, workspaceStoreContractCases };
+//#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 {@link 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, HARNESS_MEMORY_END, SEALED_CONTENT_PREFIX, WorkspaceCodecError, WorkspaceConflictError, WorkspacePolicyError, aesGcmContentCodecFromEnv, assertWorkspacePath, captureHarnessMemory, checkOperationId, checkWorkspacePut, createAesGcmContentCodec, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, harnessActor, ingestHarnessMemories, isSameWorkspaceWrite, memberIdFromPath, memoryDivergence, normalizeMemoryText, openWorkspaceBytes, parseHarnessActor, projectHarnessMemory, rankEntries, readTurnMemories, renderHarnessMemory, renderPinnedMemory, runWorkspaceStoreContract, sealWorkspaceBytes, withContentCodec, workspaceStoreContractCases };
 
 //# sourceMappingURL=index.js.map