@tangle-network/agent-runtime 0.339.0 → 0.340.0

package/dist/workspace-store/index.d.ts

@@ -128,41 +128,6 @@ interface WorkspaceContentCodec {
   seal(plain: Uint8Array, context: WorkspaceCodecContext): Promise<Uint8Array>;
   open(sealed: Uint8Array, context: WorkspaceCodecContext): Promise<Uint8Array>;
 }
-/** A value did not open: unknown key, wrong tenant or path, tampering, or plaintext where a seal was required. */
-declare class WorkspaceCodecError extends Error {
-  readonly code: "codec";
-  constructor(message: string);
-}
-/**
- * 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.
- */
-declare function createAesGcmContentCodec(options: {
-  keys: Readonly<Record<string, string | Uint8Array>>;
-  activeKeyId: string;
-}): WorkspaceContentCodec;
-/**
- * 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.
- */
-declare function aesGcmContentCodecFromEnv(env: {
-  WORKSPACE_STORE_KEYS?: string;
-  WORKSPACE_STORE_KEY_ID?: string;
-}): WorkspaceContentCodec | null;
-/** Stored text of a sealed `content`: a prefix, then the sealed bytes in base64. */
-declare const SEALED_CONTENT_PREFIX = "wsc1:";
-/** Seal bytes a host is about to upload (an R2 object) under the entry's tenant and path. */
-declare function sealWorkspaceBytes(codec: WorkspaceContentCodec, context: WorkspaceCodecContext, bytes: Uint8Array): Promise<Uint8Array>;
-/** Open bytes a host downloaded for an entry's `bytes` reference. */
-declare function openWorkspaceBytes(codec: WorkspaceContentCodec, context: WorkspaceCodecContext, sealed: Uint8Array): Promise<Uint8Array>;
 interface ContentCodecOptions {
   /**
    * Return stored content that is not sealed as is, for a store being moved
@@ -170,13 +135,6 @@ interface ContentCodecOptions {
    */
   readonly readPlaintext?: boolean;
 }
-/**
- * `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.
- */
-declare function withContentCodec(store: WorkspaceStore, codec: WorkspaceContentCodec, options?: ContentCodecOptions): WorkspaceStore;
 //#endregion
 //#region src/workspace-store/contract.d.ts
 interface WorkspaceStoreContractCase {
@@ -274,31 +232,12 @@ declare function renderPinnedMemory(entries: readonly WorkspaceEntry[], options?
 }): string;
 //#endregion
 //#region src/workspace-store/harness.d.ts
-/** Opening marker for the generated block in a harness's native memory file. */
-declare const HARNESS_MEMORY_BEGIN = "<!-- workspace-store:memory begin. Generated from the workspace store; save memories with memory.remember. -->";
-/** The generated block a host writes into a harness's native memory location. */
-declare function renderHarnessMemory(entries: readonly WorkspaceEntry[], options?: {
-  maxTokens?: number;
-}): string;
-/** Replace the generated block in `native`, or append one; text outside it is kept byte for byte. */
-declare function projectHarnessMemory(native: string, block: string): string;
-/** Native files keyed by path, as the host read them. A missing file is absent or `undefined`. */
-type HarnessNativeFiles = Readonly<Record<string, string | undefined>>;
-/**
- * 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.
- */
-declare function captureHarnessMemory(before: HarnessNativeFiles, after: HarnessNativeFiles): string[];
 /** Where a captured memory came from. */
 interface HarnessProvenance {
   readonly harness: string;
   readonly turnId: string;
   readonly memberId: string;
 }
-/** Read the harness, turn, and member provenance encoded by `harnessActor`. */
-declare function parseHarnessActor(actor: string): HarnessProvenance | null;
 interface HarnessIngestResult {
   readonly saved: WorkspaceEntry[];
   /** Facts already in the store, by normalized text. */
@@ -309,16 +248,6 @@ interface HarnessIngestResult {
     reason: string;
   }[];
 }
-/**
- * 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.
- */
-declare function ingestHarnessMemories(context: WorkspaceToolContext, input: {
-  harness: string;
-  turnId: string;
-  facts: readonly string[];
-}): Promise<HarnessIngestResult>;
 interface MemoryDivergence {
   /** Sum of the counts below; 0 means every native copy agrees with the store. */
   readonly total: number;
@@ -334,16 +263,6 @@ interface MemoryDivergence {
     uncaptured: string[];
   }>;
 }
-/**
- * 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.
- */
-declare function memoryDivergence(store: WorkspaceStore, turn: WorkspaceTurn, before: HarnessNativeFiles, after: HarnessNativeFiles): Promise<MemoryDivergence>;
 //#endregion
-export { type ContentCodecOptions, HARNESS_MEMORY_BEGIN, type HarnessIngestResult, type HarnessNativeFiles, type HarnessProvenance, type MakeWorkspaceStore, type MemoryDivergence, type MemoryPolicy, SEALED_CONTENT_PREFIX, type WorkspaceAccess, type WorkspaceBytesRef, type WorkspaceCodecContext, WorkspaceCodecError, WorkspaceConflictError, type WorkspaceContentCodec, type WorkspaceDeleteInput, type WorkspaceEntry, type WorkspaceEntryKind, type WorkspaceEntryScope, type WorkspacePolicyDecision, type WorkspacePutInput, type WorkspaceRole, type WorkspaceStore, type WorkspaceStoreContractCase, type WorkspaceStoreContractOptions, type WorkspaceStoreContractResult, type WorkspaceTombstone, type WorkspaceToolContext, type WorkspaceToolDefinition, type WorkspaceTurn, aesGcmContentCodecFromEnv, assertWorkspacePath, captureHarnessMemory, checkWorkspacePut, createAesGcmContentCodec, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, ingestHarnessMemories, memoryDivergence, openWorkspaceBytes, parseHarnessActor, projectHarnessMemory, readTurnMemories, renderHarnessMemory, renderPinnedMemory, runWorkspaceStoreContract, sealWorkspaceBytes, withContentCodec, workspaceStoreContractCases };
+export { type ContentCodecOptions, type HarnessIngestResult, type HarnessProvenance, type MakeWorkspaceStore, type MemoryDivergence, type MemoryPolicy, type WorkspaceAccess, type WorkspaceBytesRef, type WorkspaceCodecContext, WorkspaceConflictError, type WorkspaceContentCodec, type WorkspaceDeleteInput, type WorkspaceEntry, type WorkspaceEntryKind, type WorkspaceEntryScope, type WorkspacePolicyDecision, type WorkspacePutInput, type WorkspaceRole, type WorkspaceStore, type WorkspaceStoreContractCase, type WorkspaceStoreContractOptions, type WorkspaceStoreContractResult, type WorkspaceTombstone, type WorkspaceToolContext, type WorkspaceToolDefinition, type WorkspaceTurn, assertWorkspacePath, checkWorkspacePut, createFileTools, createInMemoryWorkspaceStore, createMemoryTools, defaultMemoryPolicy, readTurnMemories, renderPinnedMemory, runWorkspaceStoreContract, workspaceStoreContractCases };
 //# sourceMappingURL=index.d.ts.map

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 {
@@ -1168,209 +957,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