@orkestrel/agent 0.0.11 → 0.0.13

package/dist/src/core/index.js

@@ -1,10 +1,12 @@
-import { isArray, isNumber, isRecord, isString, rawShape, stringShape } from "@orkestrel/contract";
+import { attempt, isArray, isBoolean, isFiniteNumber, isObject, isRecord, isString, parseJSONValue, rawShape, stringShape } from "@orkestrel/contract";
 import { createDatabase, createMemoryDriver } from "@orkestrel/database";
 import { createQueue } from "@orkestrel/queue";
 import { createDeferred, createRunner } from "@orkestrel/workflow";
 import { createAbort } from "@orkestrel/abort";
 import { createTimeout } from "@orkestrel/timeout";
 import { Emitter } from "@orkestrel/emitter";
+import { ToolManager, isToolCall } from "@orkestrel/tool";
+import { WorkspaceManager, isBinary, isText } from "@orkestrel/workspace";
 import { createTokenBudget } from "@orkestrel/budget";
 //#region src/core/constants.ts
 /**
@@ -90,53 +92,6 @@ var MESSAGE_TOKEN_OVERHEAD = 4;
 * exact count.
 */
 var IMAGE_TOKEN_ESTIMATE = 512;
-/**
-* The extension→language table {@link import('./helpers.js').inferLanguage} reads to
-* map a file path's extension to a fenced-code language tag. Covers the common source /
-* markup / data extensions; an unlisted extension falls back to `'text'`.
-*/
-var EXTENSION_TO_LANGUAGE = Object.freeze({
-	ts: "typescript",
-	tsx: "typescript",
-	js: "javascript",
-	jsx: "javascript",
-	mjs: "javascript",
-	cjs: "javascript",
-	json: "json",
-	md: "markdown",
-	html: "html",
-	htm: "html",
-	css: "css",
-	scss: "scss",
-	sass: "sass",
-	less: "less",
-	vue: "vue",
-	svelte: "svelte",
-	py: "python",
-	rb: "ruby",
-	rs: "rust",
-	go: "go",
-	java: "java",
-	kt: "kotlin",
-	swift: "swift",
-	c: "c",
-	cpp: "cpp",
-	h: "c",
-	hpp: "cpp",
-	cs: "csharp",
-	php: "php",
-	sql: "sql",
-	sh: "bash",
-	bash: "bash",
-	zsh: "bash",
-	ps1: "powershell",
-	yaml: "yaml",
-	yml: "yaml",
-	toml: "toml",
-	xml: "xml",
-	svg: "xml",
-	txt: "text"
-});
 //#endregion
 //#region src/core/errors.ts
 /**
@@ -260,45 +215,6 @@ function isConversationError(value) {
 	return value instanceof ConversationError;
 }
 /**
-* An error thrown by the in-memory {@link import('./workspaces/Workspace.js').Workspace} edit
-* surface.
-*
-* @remarks
-* Carries a {@link WorkspaceErrorCode} and an optional `context` bag naming the offending
-* path / range. Thrown for a text-only operation aimed at an image file (`MODALITY` — a
-* ranged read / write, `prepend`, or `append`), an invalid `search` / `replace` regular
-* expression (`PATTERN`), and a structurally invalid ranged-write {@link import('./types.js').Range}
-* (`RANGE` — inverted, or a sub-1 line / column).
-*/
-var WorkspaceError = class extends Error {
-	code;
-	context;
-	constructor(code, message, context) {
-		super(message);
-		this.name = "WorkspaceError";
-		this.code = code;
-		if (context !== void 0) this.context = context;
-	}
-};
-/**
-* Narrow an unknown caught value to a {@link WorkspaceError}.
-*
-* @param value - The value to test (typically a `catch` binding)
-* @returns `true` when `value` is a {@link WorkspaceError}
-*
-* @example
-* ```ts
-* try {
-* 	workspace.prepend('icon.png', '// header')
-* } catch (error) {
-* 	if (isWorkspaceError(error) && error.code === 'MODALITY') skipBinary()
-* }
-* ```
-*/
-function isWorkspaceError(value) {
-	return value instanceof WorkspaceError;
-}
-/**
 * Thrown synchronously by an {@link AgentInterface}'s `stream()` when a concurrent run would
 * corrupt SHARED per-agent accounting — carries a machine-readable `code`.
 *
@@ -551,7 +467,7 @@ var Conversation = class {
 * The registry of {@link Conversation}s keyed by `id`, in insertion order, WITH an active pointer
 * — the §9 store over the conversation layer PLUS the `active` / `switch` seam the
 * {@link import('../AgentContext.js').AgentContext} renders. Event-free (a registry, like
-* {@link import('../workspaces/WorkspaceManager.js').WorkspaceManager}); the observability lives
+* {@link import('@orkestrel/workspace').WorkspaceManager}); the observability lives
 * on each {@link Conversation}.
 *
 * @remarks
@@ -666,28 +582,59 @@ var ConversationManager = class {
 //#endregion
 //#region src/core/helpers.ts
 /**
-* Infer a fenced-code language tag from a file path's extension — what a workspace text file
-* (or the {@link fencedFile} renderer) renders its content block as.
-*
-* @remarks
-* Reads the extension after the last `.` (case-insensitive) and maps it through a
-* fixed extension→language table. An unknown extension, or a path with no extension,
-* falls back to `'text'` (a safe, language-agnostic fence). Total — never throws.
-*
-* @param path - The document's file path (e.g. `'src/main.ts'`)
-* @returns The inferred language tag (e.g. `'typescript'`), or `'text'` when unknown
-*
-* @example
-* ```ts
-* inferLanguage('src/main.ts') // 'typescript'
-* inferLanguage('README.md') // 'markdown'
-* inferLanguage('LICENSE') // 'text'
-* ```
-*/
-function inferLanguage(path) {
-	const dot = path.lastIndexOf(".");
-	if (dot === -1) return "text";
-	return EXTENSION_TO_LANGUAGE[path.slice(dot + 1).toLowerCase()] ?? "text";
+* Project an unknown value onto the canonical JSON representation of an
+* {@link AgentResult}.
+*
+* @remarks
+* This is a total hostile-boundary projection. Each structural field is captured once
+* through Contract's sanctioned exception boundary, so conforming accessors and inherited
+* properties are supported while a throwing getter or revoked proxy returns `undefined`.
+* Present usage counts must be finite numbers; negative and fractional values are preserved,
+* not normalized. Extra input properties are dropped while a fresh exact plain object is rebuilt
+* and deep-gated through
+* {@link import('@orkestrel/contract').parseJSONValue}.
+*
+* @param value - The unknown value to project
+* @returns A fresh JSON value containing only AgentResult fields, or `undefined` when invalid
+*
+* @example
+* ```ts
+* import { agentResultToJSON } from '@orkestrel/agent'
+*
+* agentResultToJSON({ content: 'done', usage: { prompt: 2, completion: 1, total: 3 }, partial: false })
+* // { content: 'done', usage: { prompt: 2, completion: 1, total: 3 }, partial: false }
+* ```
+*/
+function agentResultToJSON(value) {
+	const captured = attempt(() => {
+		if (!isObject(value)) return void 0;
+		const content = Reflect.get(value, "content");
+		const thinking = Reflect.get(value, "thinking");
+		const usage = Reflect.get(value, "usage");
+		const partial = Reflect.get(value, "partial");
+		if (!isString(content) || !isBoolean(partial)) return void 0;
+		if (thinking !== void 0 && !isString(thinking)) return void 0;
+		let projectedUsage;
+		if (usage !== void 0) {
+			if (!isObject(usage)) return void 0;
+			const prompt = Reflect.get(usage, "prompt");
+			const completion = Reflect.get(usage, "completion");
+			const total = Reflect.get(usage, "total");
+			if (!isFiniteNumber(prompt) || !isFiniteNumber(completion) || !isFiniteNumber(total)) return;
+			projectedUsage = {
+				prompt,
+				completion,
+				total
+			};
+		}
+		return {
+			content,
+			...thinking === void 0 ? {} : { thinking },
+			...projectedUsage === void 0 ? {} : { usage: projectedUsage },
+			partial
+		};
+	});
+	return captured.success ? parseJSONValue(captured.value) : void 0;
 }
 /**
 * Filter a list of items by a {@link import('./types.js').ScopeInterface} allow-list of
@@ -850,201 +797,22 @@ function handleAgentRunnerJob(registry, allowPartial, controller) {
 	return settleAgentJob(registry.build(controller.input, controller.signal), allowPartial);
 }
 /**
-* Whether a {@link FileContent} is the TEXT arm — the narrowing guard for the text-vs-binary
-* union (AGENTS §14: narrow an untyped arm via a guard, never an `as`).
-*
-* @remarks
-* Tests `'text' in content` structurally — there is no `modality` discriminant. A `true`
-* narrows `content` to `{ text: string; language: string }`, unlocking `.text` / `.language`.
-* Total — never throws.
-*
-* @param content - The file content to test
-* @returns `true` when `content` is the text arm (carries `text` + `language`)
-*
-* @example
-* ```ts
-* if (isText(file.content)) file.content.text // the literal text + .language
-* ```
-*/
-function isText(content) {
-	return "text" in content;
-}
-/**
-* Whether a {@link FileContent} is the BINARY arm — the narrowing guard for the text-vs-binary
-* union (AGENTS §14: narrow an untyped arm via a guard, never an `as`).
-*
-* @remarks
-* Tests `'data' in content` structurally — there is no `modality` discriminant. A `true`
-* narrows `content` to `{ data: string; mime: BinaryMIME }`, unlocking `.data` / `.mime`. An
-* image is a binary whose `mime` starts with `image/` ({@link isImage}). Total — never throws.
-*
-* @param content - The file content to test
-* @returns `true` when `content` is the binary arm (carries base64 `data` + `mime`)
-*
-* @example
-* ```ts
-* if (isBinary(file.content)) file.content.data // the base64 payload + .mime
-* ```
-*/
-function isBinary(content) {
-	return "data" in content;
-}
-/**
-* Whether a {@link FileContent} is an IMAGE — a {@link isBinary} arm whose `mime` is an
-* `image/*` type (an image is just a binary with an image MIME).
-*
-* @remarks
-* Narrows to the binary arm first, then checks the `image/` MIME prefix — so a future
-* non-image binary (a PDF, `'application/pdf'`) is binary but NOT an image. Total — never
-* throws.
-*
-* @param content - The file content to test
-* @returns `true` when `content` is a binary arm with an `image/*` MIME
-*
-* @example
-* ```ts
-* isImage({ data: '<base64>', mime: 'image/png' }) // true
-* isImage({ text: 'hi', language: 'text' }) // false
-* ```
-*/
-function isImage(content) {
-	return isBinary(content) && content.mime.startsWith("image/");
-}
-/**
-* Whether an `unknown` is structurally a {@link FileInterface} record — the per-file step of the
-* {@link isWorkspaceSnapshot} read-boundary narrow (AGENTS §14: narrow an untrusted storage read
-* via a guard, never an `as`).
-*
-* @remarks
-* A total guard (it NEVER throws — adversarial input returns `false`). It checks the file's SHAPE:
-* a record with a `string` `path`, a `string` `state`, `number` `size` / `lines`, and a `content`
-* that is EITHER the TEXT arm (`{ text: string; language: string }`) OR the BINARY arm
-* (`{ data: string; mime: string }`) — the tagless {@link FileContent} union, told apart
-* structurally exactly as {@link isText} / {@link isBinary} do (no `modality` discriminant). Enough
-* to safely impose the {@link FileInterface} type at a storage boundary WITHOUT a cast; the `mime`
-* is left as a broad `string` here (an open {@link BinaryMIME}, so any storage-read MIME string is
-* accepted defensively rather than rejected against the current literal set).
-*
-* @param value - The value to test (one element of a snapshot's opaque `files` array)
-* @returns `true` when `value` has the structural shape of a {@link FileInterface}
-*
-* @example
-* ```ts
-* isFile({ path: 'a.ts', content: { text: 'x', language: 'typescript' }, state: 'created', size: 1, lines: 1 }) // true
-* isFile({ path: 'a.png', content: { data: 'AAAA', mime: 'image/png' }, state: 'created', size: 3, lines: 0 }) // true
-* isFile({ path: 'a.ts' }) // false (missing content / state / size / lines)
-* ```
-*/
-function isFile(value) {
-	if (!isRecord(value)) return false;
-	if (!isString(value.path) || !isString(value.state)) return false;
-	if (!isNumber(value.size) || !isNumber(value.lines)) return false;
-	if (!isRecord(value.content)) return false;
-	const text = isString(value.content.text) && isString(value.content.language);
-	const binary = isString(value.content.data) && isString(value.content.mime);
-	return text || binary;
-}
-/**
-* Narrow an `unknown` to a {@link WorkspaceSnapshot} — the AGENTS §14 boundary guard for an
-* UNTRUSTED snapshot read (a storage row a
-* {@link import('./workspaces/stores/DatabaseWorkspaceStore.js').DatabaseWorkspaceStore} reads back
-* from its opaque JSON column, a snapshot loaded from disk).
-*
-* @remarks
-* A total guard (it NEVER throws — adversarial input returns `false`). It checks the snapshot's
-* SHAPE: a `string` `id` and a `files` array EVERY element of which is a valid {@link FileInterface}
-* record ({@link isFile}) — enough to safely impose the {@link WorkspaceSnapshot} type at a storage
-* boundary WITHOUT a cast. The structural twin of
-* the analogous `isWorkflowSnapshot` in `@orkestrel/workflow`. A malformed blob (a non-record, a
-* missing / non-string `id`, a non-array `files`, or any malformed file element) resolves `false`,
-* so a {@link import('./workspaces/stores/DatabaseWorkspaceStore.js').DatabaseWorkspaceStore} read
-* yields `undefined` rather than a broken workspace.
-*
-* @param value - The value to test (an opaque storage read)
-* @returns `true` when `value` has the structural shape of a {@link WorkspaceSnapshot}
-*
-* @example
-* ```ts
-* isWorkspaceSnapshot({ id: 'w1', files: [] }) // true
-* isWorkspaceSnapshot({ id: 'w1', files: 'nope' }) // false
-* isWorkspaceSnapshot({ files: [] }) // false (missing id)
-* ```
-*/
-function isWorkspaceSnapshot(value) {
-	return isRecord(value) && isString(value.id) && isArray(value.files) && value.files.every(isFile);
-}
-/**
-* Whether an `unknown` is structurally a {@link ToolCall} record — the per-call step of the
-* {@link isMessage} read-boundary narrow (AGENTS §14: narrow an untrusted storage read via a
-* guard, never an `as`).
-*
-* @remarks
-* A total guard (it NEVER throws — adversarial input returns `false`). It checks the call's
-* SHAPE: a record with a `string` `id`, a `string` `name`, and a record `arguments` — the real
-* {@link ToolCall} shape a restored assistant turn replays to a provider. This is the ASI06
-* fail-CLOSED element check: a tampered persisted call (`null`, a bare string, a non-record
-* `arguments`) fails the guard, so {@link isMessage} — and through it
-* {@link isConversationSnapshot} — rejects the whole snapshot and a poisoned store row reads
-* back as ABSENT instead of replaying a malformed call into a chat template.
-*
-* @param value - The value to test (one element of an assistant message's `calls`)
-* @returns `true` when `value` has the structural shape of a {@link ToolCall}
-*
-* @example
-* ```ts
-* isToolCall({ id: 'c1', name: 'search', arguments: { q: 'acme' } }) // true
-* isToolCall({ id: 'c1', name: 'search' }) // false (missing arguments)
-* isToolCall({ id: 'c1', name: 123, arguments: {} }) // false (non-string name)
-* ```
-*/
-function isToolCall(value) {
-	if (!isRecord(value)) return false;
-	return isString(value.id) && isString(value.name) && isRecord(value.arguments);
-}
-/**
-* Project a {@link ToolResult} into the MCP `CallToolResult` shape — a top-level `error`
-* maps to a single `isError: true` text block (the failure reason), otherwise the `value`
-* is JSON-stringified into a single text block with no `isError`.
-*
-* @param result - The {@link ToolResult} to project (as returned by {@link import('./tools/ToolManager.js').ToolManager.execute})
-* @returns The equivalent {@link ToolCallResult}
-*
-* @example
-* ```ts
-* buildToolResult({ id: 'c1', name: 'search', error: 'max depth' })
-* // { content: [{ type: 'text', text: 'max depth' }], isError: true }
-* buildToolResult({ id: 'c1', name: 'search', value: { count: 1 } })
-* // { content: [{ type: 'text', text: '{"count":1}' }] }
-* ```
-*/
-function buildToolResult(result) {
-	if (result.error !== void 0) return {
-		content: [{
-			type: "text",
-			text: result.error
-		}],
-		isError: true
-	};
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(result.value)
-	}] };
-}
-/**
 * Whether an `unknown` is structurally a {@link MessageInterface} record — the per-message step of
 * the {@link isConversationSnapshot} read-boundary narrow (AGENTS §14: narrow an untrusted storage
-* read via a guard, never an `as`). The conversation analogue of {@link isFile}.
+* read via a guard, never an `as`). The conversation analogue of
+* {@link import('@orkestrel/workspace').isFile}.
 *
 * @remarks
 * A total guard (it NEVER throws — adversarial input returns `false`). It checks the message's
 * SHAPE: a record with a `string` `id`, a `string` `role`, a `string` `content`, and — WHEN present
-* — a `calls` array EVERY element of which is a valid {@link ToolCall} ({@link isToolCall} — the
+* — a `calls` array EVERY element of which is a valid
+* {@link import('@orkestrel/tool').ToolCall} ({@link isToolCall} — the
 * ASI06 fail-closed deepening: a tampered `calls` element rejects the message, so the snapshot
 * reads back as absent rather than replaying a malformed call) and an `images` that is an array
 * (an absent optional passes). The `role` is left as a broad `string` here (an open
 * {@link import('./types.js').MessageRole}, so any storage-read role string is accepted
-* defensively rather than rejected against the current literal set) — exactly as {@link isFile}
-* accepts a broad `state` / `mime`. Enough to safely impose the {@link MessageInterface} type at
+* defensively rather than rejected against the current literal set). Enough to safely impose the
+* {@link MessageInterface} type at
 * a storage boundary WITHOUT a cast.
 *
 * @param value - The value to test (one element of a snapshot's `messages` / a section's `messages`)
@@ -1095,7 +863,7 @@ function isSection(value) {
 * UNTRUSTED snapshot read (a storage row a
 * {@link import('./conversations/stores/DatabaseConversationStore.js').DatabaseConversationStore}
 * reads back from its opaque JSON column, a snapshot loaded from disk). The EXACT analogue of
-* {@link isWorkspaceSnapshot}.
+* {@link import('@orkestrel/workspace').isWorkspaceSnapshot}.
 *
 * @remarks
 * A total guard (it NEVER throws — adversarial input returns `false`). It checks the snapshot's
@@ -1104,7 +872,7 @@ function isSection(value) {
 * {@link SectionInterface} ({@link isSection}), and a `messages` array EVERY element of which is a
 * valid {@link MessageInterface} ({@link isMessage}) — enough to safely impose the
 * {@link ConversationSnapshot} type at a storage boundary WITHOUT a cast. The structural twin of
-* {@link isWorkspaceSnapshot}. A malformed blob (a non-record, a missing / non-string `id`, a
+* {@link import('@orkestrel/workspace').isWorkspaceSnapshot}. A malformed blob (a non-record, a missing / non-string `id`, a
 * non-string `summary` when present, a non-array `sections` / `messages`, or any malformed
 * element) resolves `false`, so a
 * {@link import('./conversations/stores/DatabaseConversationStore.js').DatabaseConversationStore}
@@ -1129,273 +897,6 @@ function isConversationSnapshot(value) {
 	return isArray(value.messages) && value.messages.every(isMessage);
 }
 /**
-* Compute the byte size of a {@link FileContent} — the `size` a {@link FileInterface} derives
-* once when built.
-*
-* @remarks
-* Dispatches on {@link isText}: a text arm is its UTF-8 byte length (via `new
-* TextEncoder().encode(text).length` — the standard Web/Node API, so a multi-byte
-* character like `'é'` or `'😀'` counts as its real encoded bytes, NOT its character
-* count); a binary arm is the decoded payload byte length of its base64 `data` (via
-* {@link decodedSize}, computed arithmetically — no `atob` / `Buffer`). Total — never throws.
-*
-* @param content - The file content to size
-* @returns The byte size (UTF-8 bytes for text; decoded payload bytes for binary)
-*
-* @example
-* ```ts
-* computeSize({ text: 'café', language: 'text' }) // 5 (é is two bytes)
-* computeSize({ data: 'AAAA', mime: 'image/png' }) // 3
-* ```
-*/
-function computeSize(content) {
-	if (isText(content)) return new TextEncoder().encode(content.text).length;
-	return decodedSize(content.data);
-}
-/**
-* Count the lines of a {@link FileContent} — the `lines` a {@link FileInterface} derives once
-* when built.
-*
-* @remarks
-* A text arm's line count is `0` for the empty string, otherwise one more than the
-* number of newline (`\n`) separators it contains — so `'a'` is one line, `'a\nb'` is two,
-* and a trailing newline `'a\n'` counts the empty final line as two. A binary arm has no
-* lines and returns `0`. Total — never throws.
-*
-* @param content - The file content to count lines for
-* @returns The line count (text line count; `0` for a binary arm or empty text)
-*
-* @example
-* ```ts
-* countLines({ text: '', language: 'text' }) // 0
-* countLines({ text: 'a\nb\nc', language: 'text' }) // 3
-* countLines({ data: 'AAAA', mime: 'image/png' }) // 0
-* ```
-*/
-function countLines(content) {
-	if (!isText(content)) return 0;
-	if (content.text.length === 0) return 0;
-	let count = 1;
-	for (const character of content.text) if (character === "\n") count += 1;
-	return count;
-}
-/**
-* Compute the decoded byte length of a base64 string ARITHMETICALLY — the image-payload
-* sizing primitive {@link computeSize} uses, with no `atob` / `Buffer` decode.
-*
-* @remarks
-* A base64 string encodes each group of 3 input bytes as 4 characters, so a well-formed
-* string's length is a multiple of 4 and its decoded length is `(length / 4) * 3` MINUS
-* the trailing `=` padding (one `=` ⇒ the last group held 2 bytes, two `==` ⇒ 1 byte).
-* The padding is counted from the trailing `=` characters, so both the `=` and `==` cases
-* are handled. The empty string decodes to `0`. Total — never throws (a malformed,
-* non-multiple-of-4 length still yields a defined non-negative estimate via `floor`).
-*
-* @param base64 - The base64-encoded string (e.g. an image's `data`)
-* @returns The decoded payload's byte length
-*
-* @example
-* ```ts
-* decodedSize('') // 0
-* decodedSize('AAAA') // 3  (no padding)
-* decodedSize('AAA=') // 2  (one '=')
-* decodedSize('AA==') // 1  (two '=')
-* ```
-*/
-function decodedSize(base64) {
-	if (base64.length === 0) return 0;
-	let padding = 0;
-	if (base64.endsWith("==")) padding = 2;
-	else if (base64.endsWith("=")) padding = 1;
-	return Math.floor(base64.length / 4) * 3 - padding;
-}
-/**
-* Whether a {@link Range} is STRUCTURALLY valid — the predicate a ranged `write` checks
-* before applying (a `false` here is the `RANGE` throw).
-*
-* @remarks
-* Structural validity is independent of any content: every component must be `>= 1`
-* (1-based lines and columns), and `start` must not come after `end` (an inverted range
-* is invalid). A range that is structurally valid but reaches PAST the end of a specific
-* text is still valid — it is {@link clampRange}d to the bounds when applied, not rejected.
-* Total — never throws.
-*
-* @param range - The range to validate
-* @returns `true` when every component is `>= 1` and `start` is at or before `end`
-*
-* @example
-* ```ts
-* isValidRange({ start: { line: 1, column: 1 }, end: { line: 2, column: 1 } }) // true
-* isValidRange({ start: { line: 2, column: 1 }, end: { line: 1, column: 1 } }) // false (inverted)
-* isValidRange({ start: { line: 0, column: 1 }, end: { line: 1, column: 1 } }) // false (sub-1 line)
-* ```
-*/
-function isValidRange(range) {
-	if (range.start.line < 1 || range.start.column < 1) return false;
-	if (range.end.line < 1 || range.end.column < 1) return false;
-	if (range.start.line > range.end.line) return false;
-	return !(range.start.line === range.end.line && range.start.column > range.end.column);
-}
-/**
-* Clamp a 1-based {@link Position} to the bounds of `text` — every component pinned into a
-* caret that actually exists in the content.
-*
-* @remarks
-* `line` is pinned to `[1, lineCount]` and `column` to `[1, lineLength + 1]` of the
-* resolved line (column `lineLength + 1` is the caret just past the line's last
-* character). So a position beyond the end of the text resolves to the end rather than
-* overflowing. Total — never throws.
-*
-* @param text - The text the position addresses
-* @param position - The 1-based position to clamp
-* @returns The clamped {@link Position}
-*
-* @example
-* ```ts
-* clampPosition('ab\ncd', { line: 9, column: 9 }) // { line: 2, column: 3 } (end of 'cd')
-* ```
-*/
-function clampPosition(text, position) {
-	const lines = text.split("\n");
-	const line = Math.max(1, Math.min(position.line, lines.length));
-	const lineText = lines[line - 1] ?? "";
-	return {
-		line,
-		column: Math.max(1, Math.min(position.column, lineText.length + 1))
-	};
-}
-/**
-* Clamp both ends of a {@link Range} to the bounds of `text` — the actual span a ranged
-* read / write applies (and the `range` a {@link import('./types.js').ReadResult} reports).
-*
-* @remarks
-* Clamps `start` and `end` independently via {@link clampPosition}, so a range reaching
-* past the end of the content is trimmed to the content's end. Total — never throws.
-*
-* @param text - The text the range addresses
-* @param range - The 1-based range to clamp
-* @returns The clamped {@link Range}
-*
-* @example
-* ```ts
-* clampRange('ab\ncd', { start: { line: 1, column: 1 }, end: { line: 9, column: 9 } })
-* // { start: { line: 1, column: 1 }, end: { line: 2, column: 3 } }
-* ```
-*/
-function clampRange(text, range) {
-	return {
-		start: clampPosition(text, range.start),
-		end: clampPosition(text, range.end)
-	};
-}
-/**
-* Convert a 1-based {@link Position} to a 0-based string offset into `text` — the indexing
-* primitive {@link sliceRange} / {@link spliceRange} use, clamped to `text.length`.
-*
-* @remarks
-* Sums each preceding line's length plus its `\n` separator, then adds the `column - 1`
-* within the target line, capped at `text.length`. Total — never throws (an out-of-bounds
-* position yields a defined in-range offset).
-*
-* @param text - The text to index into
-* @param position - The 1-based position to resolve
-* @returns The 0-based offset (in `[0, text.length]`)
-*
-* @example
-* ```ts
-* offsetAt('ab\ncd', { line: 2, column: 1 }) // 3 (just after 'ab\n')
-* ```
-*/
-function offsetAt(text, position) {
-	const lines = text.split("\n");
-	let offset = 0;
-	for (let index = 0; index < position.line - 1 && index < lines.length; index += 1) offset += (lines[index]?.length ?? 0) + 1;
-	offset += position.column - 1;
-	return Math.min(offset, text.length);
-}
-/**
-* Slice the substring of `text` spanned by a {@link Range} (start INCLUSIVE, end
-* EXCLUSIVE), clamping the range to the text's bounds first — the read half of the ranged
-* edit surface.
-*
-* @remarks
-* Clamps via {@link clampRange}, resolves each end to an offset via {@link offsetAt}, and
-* returns `text.slice(startOffset, endOffset)`. Total — never throws.
-*
-* @param text - The text to slice
-* @param range - The 1-based range to extract
-* @returns The spanned substring (empty when the clamped span is empty)
-*
-* @example
-* ```ts
-* sliceRange('hello\nworld', { start: { line: 1, column: 1 }, end: { line: 1, column: 6 } }) // 'hello'
-* ```
-*/
-function sliceRange(text, range) {
-	const clamped = clampRange(text, range);
-	return text.slice(offsetAt(text, clamped.start), offsetAt(text, clamped.end));
-}
-/**
-* Replace the span of `text` covered by a {@link Range} with `replacement` (start
-* INCLUSIVE, end EXCLUSIVE), clamping the range to the text's bounds first — the write
-* half of the ranged edit surface.
-*
-* @remarks
-* Clamps via {@link clampRange}, then stitches `before + replacement + after` around the
-* resolved offsets. An empty span (`start === end`) becomes a pure insertion. Total —
-* never throws.
-*
-* @param text - The original text
-* @param range - The 1-based range to overwrite
-* @param replacement - The text to splice in place of the spanned range
-* @returns The text with the spanned range replaced by `replacement`
-*
-* @example
-* ```ts
-* spliceRange('hello', { start: { line: 1, column: 1 }, end: { line: 1, column: 6 } }, 'bye') // 'bye'
-* ```
-*/
-function spliceRange(text, range, replacement) {
-	const clamped = clampRange(text, range);
-	const start = offsetAt(text, clamped.start);
-	const end = offsetAt(text, clamped.end);
-	return text.slice(0, start) + replacement + text.slice(end);
-}
-/**
-* Assemble a 1-based nested {@link Range} from four FLAT caret integers — the bridge a
-* workspace-editing tool (see `@orkestrel/tool`) uses from its small-model FLAT surface back to the
-* nested {@link Range} the {@link import('./workspaces/Workspace.js').Workspace} edit surface
-* speaks. Published as a public helper for that consumer.
-*
-* @remarks
-* Pairs `(fromLine, fromColumn)` into `start` and `(toLine, toColumn)` into `end` verbatim — a pure
-* structural lift, no validation (a structurally invalid range is rejected downstream by the ranged
-* `write` it feeds, via {@link isValidRange}). Total — never throws. Zero-Node.
-*
-* @param fromLine - The 1-based start line
-* @param fromColumn - The 1-based start column
-* @param toLine - The 1-based end line
-* @param toColumn - The 1-based end column
-* @returns The `{ start, end }` {@link Range}
-*
-* @example
-* ```ts
-* rangeOf(1, 11, 1, 12) // { start: { line: 1, column: 11 }, end: { line: 1, column: 12 } }
-* ```
-*/
-function rangeOf(fromLine, fromColumn, toLine, toColumn) {
-	return {
-		start: {
-			line: fromLine,
-			column: fromColumn
-		},
-		end: {
-			line: toLine,
-			column: toColumn
-		}
-	};
-}
-/**
 * Render a path-addressed text body as a fenced reference block — the framing an
 * {@link import('./AgentContext.js').AgentContext}'s ACTIVE-workspace text-file render emits (the
 * active workspace is the SOLE document/image context).
@@ -1405,7 +906,7 @@ function rangeOf(fromLine, fromColumn, toLine, toColumn) {
 * fenced code block tagged with `language`, the `content` verbatim inside. Pure string assembly,
 * total — never throws. The one fenced-file format string for the whole module — `AgentContext.build()`
 * frames an active workspace's text files with it (each carries its own `language` on its
-* {@link FileContent} text arm).
+* {@link import('@orkestrel/workspace').FileContent} text arm).
 *
 * @param path - The file path shown on the `File:` label line
 * @param language - The fenced-code language tag (e.g. `'typescript'`)
@@ -1424,29 +925,6 @@ function fencedFile(path, language, content) {
 	return `File: ${path}\n\`\`\`${language}\n${content}\n\`\`\``;
 }
 /**
-* Escape a string's regex-special characters so it matches LITERALLY inside a `RegExp` — the
-* primitive a {@link import('./workspaces/Workspace.js').Workspace} search builds a literal-text
-* search pattern through (as opposed to a caller-supplied regex pattern).
-*
-* @remarks
-* Prefixes every character in the class `. * + ? ^ $ { } ( ) | [ ] \` with a backslash, so the
-* escaped string, when compiled into a `RegExp`, matches only its own literal characters — no
-* character acts as a quantifier, anchor, group, or class. Pure string assembly, total — never
-* throws.
-*
-* @param value - The text to escape for literal use inside a `RegExp` pattern
-* @returns `value` with every regex-special character backslash-escaped
-*
-* @example
-* ```ts
-* escapeRegExp('a.b*c') // 'a\\.b\\*c'
-* new RegExp(escapeRegExp('a.b*c')).test('a.b*c') // true
-* ```
-*/
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-/**
 * Sanitize one reported token count into a safe non-negative integer.
 *
 * @param value - The token count to sanitize
@@ -1488,7 +966,7 @@ function sanitizeUsage(usage) {
 * at construction.
 *
 * @remarks
-* A thin immutable value object (mirroring {@link import('../tools/Tool.js').Tool}): the
+* A thin immutable value object (mirroring {@link import('@orkestrel/tool').Tool}): the
 * constructor mints a fresh `id` (`crypto.randomUUID()`), copies the input's `name` /
 * `content`, resolves `priority` to the input's value or `0`, and carries the input's
 * per-item `format` override ONLY when supplied (assigned just when present, mirroring a
@@ -1566,552 +1044,52 @@ var InstructionManager = class {
 		});
 		this.#format = options?.format;
 	}
-	get emitter() {
-		return this.#emitter;
-	}
-	get count() {
-		return this.#instructions.size;
-	}
-	get description() {
-		return this.#format?.open ?? "## Instructions";
-	}
-	get framing() {
-		return this.#format;
-	}
-	add(input) {
-		if (isArray(input)) return input.map((one) => this.#create(one));
-		return this.#create(input);
-	}
-	instruction(name) {
-		return this.#instructions.get(name);
-	}
-	instructions() {
-		return [...this.#instructions.values()].sort((a, b) => b.priority - a.priority);
-	}
-	format(instruction) {
-		return this.#format?.render?.(instruction) ?? instruction.content;
-	}
-	remove(names) {
-		if (isArray(names)) {
-			let removed = false;
-			for (const name of names) if (this.#delete(name)) removed = true;
-			return removed;
-		}
-		return this.#delete(names);
-	}
-	clear() {
-		this.#instructions.clear();
-		this.#emitter.emit("clear");
-	}
-	#create(input) {
-		const instruction = new Instruction(input);
-		this.#instructions.set(instruction.name, instruction);
-		this.#emitter.emit("add", instruction);
-		return instruction;
-	}
-	#delete(name) {
-		const removed = this.#instructions.delete(name);
-		if (removed) this.#emitter.emit("remove", name);
-		return removed;
-	}
-};
-//#endregion
-//#region src/core/tools/ToolManager.ts
-/**
-* The tool registry the agent loop dispatches model tool-calls through — resolves
-* names, lists {@link ToolDefinition}s for the provider, and executes calls with
-* per-call error isolation.
-*
-* @remarks
-* - **Registry.** Tools live in an insertion-ordered `Map` keyed by `tool.name`;
-*   `add` takes one or a batch (§9.2) and a re-`add` of the same name OVERWRITES it
-*   (last write wins). `count` is the map size, `tool(name)` looks one up, `tools()`
-*   lists them in insertion order, and `definitions()` maps each to a plain
-*   {@link ToolDefinition} (`name` / `description?` / `parameters?`, the `execute`
-*   handler stripped) — exactly what a provider advertises to the model, with
-*   `tool.summary ?? tool.description` advertised as `description` (a lean `summary`
-*   stands in for the full text when set).
-* - **Per-call error isolation (the load-bearing part).** `execute` resolves a
-*   {@link ToolCall}'s tool by name and ALWAYS resolves a {@link ToolResult}: an
-*   unknown name → `{ id, name, error: 'tool not found: <name>' }`; a successful run →
-*   `{ id, name, value }`; a handler throw is CAUGHT into `{ id, name, error }` (an
-*   `Error`'s message, else the stringified throw). A tool throw never escapes — it
-*   becomes a result the model can react to.
-* - **Batch never fails as a whole.** `execute(calls)` runs every call via
-*   `Promise.all(calls.map(...))` and resolves the results correlated by `id` in the
-*   input order — a mix of success, throw, and not-found all resolve; one bad call
-*   does not reject the batch.
-* - **Event-free.** A purely functional registry — no Emitter, no events.
-*
-* @example
-* ```ts
-* const manager = new ToolManager()
-* manager.add(new Tool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
-* const result = await manager.execute({ id: '1', name: 'add', arguments: { x: 1, y: 2 } })
-* result.value // 3
-* ```
-*/
-var ToolManager = class {
-	#tools = /* @__PURE__ */ new Map();
-	get count() {
-		return this.#tools.size;
-	}
-	add(tools) {
-		if (isArray(tools)) {
-			for (const tool of tools) this.#tools.set(tool.name, tool);
-			return;
-		}
-		this.#tools.set(tools.name, tools);
-	}
-	tool(name) {
-		return this.#tools.get(name);
-	}
-	tools() {
-		return [...this.#tools.values()];
-	}
-	definitions() {
-		return [...this.#tools.values()].map((tool) => this.#definition(tool));
-	}
-	execute(call) {
-		if (isArray(call)) return Promise.all(call.map((one) => this.#run(one)));
-		return this.#run(call);
-	}
-	remove(names) {
-		if (isArray(names)) {
-			let removed = false;
-			for (const name of names) if (this.#tools.delete(name)) removed = true;
-			return removed;
-		}
-		return this.#tools.delete(names);
-	}
-	clear() {
-		this.#tools.clear();
-	}
-	async #run(call) {
-		const tool = this.#tools.get(call.name);
-		if (tool === void 0) return {
-			id: call.id,
-			name: call.name,
-			error: `tool not found: ${call.name}`
-		};
-		try {
-			const value = await tool.execute(call.arguments);
-			return {
-				id: call.id,
-				name: call.name,
-				value
-			};
-		} catch (error) {
-			return {
-				id: call.id,
-				name: call.name,
-				error: error instanceof Error ? error.message : String(error)
-			};
-		}
-	}
-	#definition(tool) {
-		const definition = { name: tool.name };
-		const description = tool.summary ?? tool.description;
-		if (description !== void 0) definition.description = description;
-		if (tool.parameters !== void 0) definition.parameters = tool.parameters;
-		return definition;
-	}
-};
-//#endregion
-//#region src/core/workspaces/Workspace.ts
-/**
-* A mutable, `path`-keyed working set of immutable {@link FileInterface}s — the
-* in-memory editing surface over the file primitive.
-*
-* @remarks
-* - **Registry.** Files live in an insertion-ordered `Map` keyed by `path`; `count` is the
-*   map size, `file(path)` looks one up, and `files()` lists them in insertion order.
-* - **Write replaces the File (§11 immutability).** Every edit MINTS a replacement
-*   {@link FileInterface} (via {@link import('../factories.js').createFile}) rather than
-*   mutating in place, transitioning `state` to `'created'` for a brand-new path or
-*   `'modified'` for an existing one. A whole-file string write preserves an existing text
-*   file's `language`, else infers it from the `path` (`inferLanguage`); writing a string
-*   onto an existing BINARY path replaces it with a text file (a deliberate retype). A
-*   ranged `write` splices a `Range` of an existing text file.
-* - **Modality rules.** Text-only ops on a binary file are rejected: a ranged `read` /
-*   `write`, `prepend`, and `append` throw `MODALITY`; a plain `read(path)` of a binary
-*   file returns `undefined`; `search` / `replace` skip binary files (0 matches).
-* - **In-memory removal.** `remove(path)` / `remove(paths)` drop files outright (no
-*   tombstone — the `'loaded'` / `'deleted'` states are reserved for a future FileStore);
-*   `remove()` and `clear()` both empty the registry and emit the single `clear` signal.
-*   The disk/sync lifecycle (`load` / `revert` / `accept` / `purge` / `dirty`) is NOT part
-*   of this surface.
-* - **Observable (§13).** The owned {@link emitter} ({@link WorkspaceEventMap}) carries
-*   `write` (the resulting file) / `remove` (the path) / `move` (`{ from, to }`) / `clear`.
-*   Every event is emitted directly, strictly AFTER the map mutation completes; the
-*   emitter isolates a listener throw and routes it to its `error` handler, so a buggy
-*   observer can never corrupt a mutation.
-*
-* @example
-* ```ts
-* const workspace = new Workspace()
-* workspace.write('src/main.ts', 'const x = 1')
-* workspace.file('src/main.ts')?.state // 'created'
-* workspace.append('src/main.ts', '\nconst y = 2')
-* workspace.file('src/main.ts')?.state // 'modified'
-* workspace.read('src/main.ts') // 'const x = 1\nconst y = 2'
-* ```
-*/
-var Workspace = class {
-	#id;
-	#files = /* @__PURE__ */ new Map();
-	#emitter;
-	constructor(options, seed) {
-		this.#id = options?.id ?? crypto.randomUUID();
-		this.#emitter = new Emitter({
-			...options?.on === void 0 ? {} : { on: options.on },
-			...options?.error === void 0 ? {} : { error: options.error }
-		});
-		if (seed) for (const [path, file] of seed) this.#files.set(path, file);
-	}
-	get id() {
-		return this.#id;
-	}
-	get emitter() {
-		return this.#emitter;
-	}
-	get count() {
-		return this.#files.size;
-	}
-	file(path) {
-		return this.#files.get(path);
-	}
-	files() {
-		return [...this.#files.values()];
-	}
-	read(path, range) {
-		if (isArray(path)) {
-			const result = {};
-			for (const one of path) {
-				const file = this.#files.get(one);
-				if (file && isText(file.content)) result[one] = file.content.text;
-			}
-			return result;
-		}
-		const file = this.#files.get(path);
-		if (!file) return void 0;
-		if (!range) return isText(file.content) ? file.content.text : void 0;
-		if (!isText(file.content)) throw new WorkspaceError("MODALITY", `Cannot read a range of a binary file: ${path}`, { path });
-		return {
-			content: sliceRange(file.content.text, range),
-			range: clampRange(file.content.text, range)
-		};
-	}
-	has(path) {
-		if (isArray(path)) return path.some((one) => this.#files.has(one));
-		return this.#files.has(path);
-	}
-	search(query, options) {
-		const pattern = this.#pattern(query, options);
-		const limit = options?.limit;
-		const matches = [];
-		for (const file of this.#files.values()) {
-			if (limit !== void 0 && matches.length >= limit) break;
-			if (!isText(file.content)) continue;
-			const lines = file.content.text.split("\n");
-			for (let index = 0; index < lines.length; index += 1) {
-				if (limit !== void 0 && matches.length >= limit) break;
-				const lineText = lines[index] ?? "";
-				pattern.lastIndex = 0;
-				let hit = pattern.exec(lineText);
-				while (hit !== null) {
-					if (limit !== void 0 && matches.length >= limit) break;
-					matches.push({
-						path: file.path,
-						line: index + 1,
-						column: hit.index + 1,
-						length: hit[0].length,
-						content: lineText
-					});
-					if (hit[0].length === 0) pattern.lastIndex += 1;
-					hit = pattern.exec(lineText);
-				}
-			}
-		}
-		return matches;
-	}
-	replace(query, replacement, options) {
-		const pattern = this.#pattern(query, options);
-		const limit = options?.limit;
-		let replaced = 0;
-		let files = 0;
-		for (const [path, file] of this.#files) {
-			if (limit !== void 0 && replaced >= limit) break;
-			if (!isText(file.content)) continue;
-			const remaining = limit === void 0 ? void 0 : limit - replaced;
-			let count = 0;
-			pattern.lastIndex = 0;
-			const next = file.content.text.replace(pattern, (match) => {
-				if (remaining !== void 0 && count >= remaining) return match;
-				count += 1;
-				return replacement;
-			});
-			if (count > 0) {
-				replaced += count;
-				files += 1;
-				this.write(path, next);
-			}
-		}
-		return {
-			query,
-			replaced,
-			files
-		};
-	}
-	write(path, content, range) {
-		if (isRecord(path)) {
-			for (const [one, text] of Object.entries(path)) this.#write(one, text);
-			return;
-		}
-		const text = content ?? "";
-		if (!range) {
-			this.#write(path, text);
-			return;
-		}
-		this.#splice(path, text, range);
-	}
-	prepend(path, content) {
-		if (isRecord(path)) {
-			for (const [one, text] of Object.entries(path)) this.#prepend(one, text);
-			return;
-		}
-		this.#prepend(path, content ?? "");
-	}
-	append(path, content) {
-		if (isRecord(path)) {
-			for (const [one, text] of Object.entries(path)) this.#append(one, text);
-			return;
-		}
-		this.#append(path, content ?? "");
-	}
-	move(from, to) {
-		if (isRecord(from)) {
-			let moved = false;
-			for (const [one, target] of Object.entries(from)) if (this.#move(one, target)) moved = true;
-			return moved;
-		}
-		return this.#move(from, to ?? "");
-	}
-	remove(path) {
-		if (path === void 0) {
-			this.#files.clear();
-			this.#emitter.emit("clear");
-			return;
-		}
-		if (isArray(path)) {
-			let removed = false;
-			for (const one of path) if (this.#remove(one)) removed = true;
-			return removed;
-		}
-		return this.#remove(path);
-	}
-	clear() {
-		this.#files.clear();
-		this.#emitter.emit("clear");
-	}
-	snapshot() {
-		return {
-			id: this.#id,
-			files: this.files()
-		};
-	}
-	#write(path, content) {
-		const existing = this.#files.get(path);
-		const file = createFile({
-			path,
-			content: {
-				text: content,
-				language: existing && isText(existing.content) ? existing.content.language : inferLanguage(path)
-			},
-			state: existing ? "modified" : "created"
-		});
-		this.#files.set(path, file);
-		this.#emitter.emit("write", file);
-	}
-	#splice(path, content, range) {
-		const existing = this.#files.get(path);
-		if (!existing || !isText(existing.content)) throw new WorkspaceError("MODALITY", `Cannot splice a range of a non-text file: ${path}`, { path });
-		if (!isValidRange(range)) throw new WorkspaceError("RANGE", `Invalid range for file: ${path}`, {
-			path,
-			range
-		});
-		const file = createFile({
-			path,
-			content: {
-				text: spliceRange(existing.content.text, range, content),
-				language: existing.content.language
-			},
-			state: "modified"
-		});
-		this.#files.set(path, file);
-		this.#emitter.emit("write", file);
-	}
-	#prepend(path, content) {
-		this.#write(path, content + this.#text(path, "prepend"));
-	}
-	#append(path, content) {
-		this.#write(path, this.#text(path, "append") + content);
-	}
-	#text(path, operation) {
-		const existing = this.#files.get(path);
-		if (!existing) return "";
-		if (!isText(existing.content)) throw new WorkspaceError("MODALITY", `Cannot ${operation} text to a binary file: ${path}`, { path });
-		return existing.content.text;
-	}
-	#move(from, to) {
-		const file = this.#files.get(from);
-		if (!file) return false;
-		const moved = createFile({
-			path: to,
-			content: file.content,
-			state: "modified"
-		});
-		this.#files.delete(from);
-		this.#files.set(to, moved);
-		this.#emitter.emit("move", {
-			from,
-			to
-		});
-		return true;
-	}
-	#remove(path) {
-		const removed = this.#files.delete(path);
-		if (removed) this.#emitter.emit("remove", path);
-		return removed;
-	}
-	#pattern(query, options) {
-		const source = options?.regex === true ? query : escapeRegExp(query);
-		const flags = options?.exact === false ? "gi" : "g";
-		try {
-			return new RegExp(source, flags);
-		} catch {
-			throw new WorkspaceError("PATTERN", `Invalid search pattern: ${query}`, { query });
-		}
-	}
-};
-//#endregion
-//#region src/core/workspaces/WorkspaceManager.ts
-/**
-* The registry of {@link Workspace}s keyed by `id`, in insertion order, WITH an active pointer
-* — the §9 store over the workspace layer PLUS the `active` / `switch` seam the context renders.
-* Event-free (a registry, like {@link ConversationManager}); the observability lives on each
-* {@link Workspace}.
-*
-* @remarks
-* - **Registry.** Workspaces live in an insertion-ordered `Map` keyed by `id`. `add(input?)`
-*   mints a {@link Workspace} (its `id` from `input` or `crypto.randomUUID()`), flowing the
-*   manager's default `on` / `error` in unless the `input` OVERRIDES them, and stores it (an
-*   already-present `id` OVERWRITES — last write wins). `count` is the map size, `workspace(id)`
-*   looks one up, `workspaces()` lists them in insertion order.
-* - **Active pointer.** `active` is the active workspace (what the context renders), `undefined`
-*   until the FIRST `add` (which auto-activates it — a registry with workspaces always has one
-*   active). A subsequent `add` leaves `active` unchanged. `switch(id)` re-points `active` to the
-*   workspace with `id` and returns it; an unknown `id` returns `undefined` and leaves `active`
-*   unchanged (the lenient lookup style — never throws, no new error code).
-* - **Removal.** `remove` drops one by id, or a batch (§9.2) — `true` when any was removed;
-*   removing the ACTIVE workspace sets `active` to `undefined`. `clear` empties the registry and
-*   sets `active` to `undefined`.
-* - **Durable open / save (the optional `store`).** With a {@link WorkspaceStoreInterface} supplied
-*   (the `store` option), `open(id)` HYDRATES a workspace on a registry miss — it `store.get(id)`s
-*   the snapshot and rebuilds a fresh {@link Workspace} through the constructor `seed`
-*   (`snapshot.files` → path → File), then activates it — and `save(id)` PERSISTS a registered
-*   workspace's `snapshot()`. Both are LENIENT without a store (open resolves only registered ids,
-*   save is a no-op `false`), consistent with the lenient `switch`.
-* - **Event-free.** A purely registry store — no Emitter, no events (each workspace owns its own
-*   observable `emitter`).
-*
-* @example
-* ```ts
-* const manager = new WorkspaceManager()
-* const first = manager.add() // auto-activates — active === first
-* manager.add({ id: 'scratch' }) // leaves active unchanged
-* manager.switch('scratch') // re-points active to the 'scratch' workspace
-* manager.count // 2
-* ```
-*/
-var WorkspaceManager = class {
-	#workspaces = /* @__PURE__ */ new Map();
-	#active;
-	#on;
-	#error;
-	#store;
-	constructor(options) {
-		this.#on = options?.on;
-		this.#error = options?.error;
-		this.#store = options?.store;
+	get emitter() {
+		return this.#emitter;
 	}
 	get count() {
-		return this.#workspaces.size;
-	}
-	get active() {
-		return this.#active === void 0 ? void 0 : this.#workspaces.get(this.#active);
+		return this.#instructions.size;
 	}
-	workspace(id) {
-		return this.#workspaces.get(id);
+	get description() {
+		return this.#format?.open ?? "## Instructions";
 	}
-	workspaces() {
-		return [...this.#workspaces.values()];
+	get framing() {
+		return this.#format;
 	}
 	add(input) {
-		const on = input?.on ?? this.#on;
-		const error = input?.error ?? this.#error;
-		const workspace = new Workspace({
-			...input?.id === void 0 ? {} : { id: input.id },
-			...on === void 0 ? {} : { on },
-			...error === void 0 ? {} : { error }
-		}, input?.seed);
-		this.#workspaces.set(workspace.id, workspace);
-		if (this.#active === void 0) this.#active = workspace.id;
-		return workspace;
+		if (isArray(input)) return input.map((one) => this.#create(one));
+		return this.#create(input);
 	}
-	switch(id) {
-		const workspace = this.#workspaces.get(id);
-		if (workspace === void 0) return void 0;
-		this.#active = id;
-		return workspace;
+	instruction(name) {
+		return this.#instructions.get(name);
 	}
-	async open(id) {
-		const existing = this.#workspaces.get(id);
-		if (existing !== void 0) {
-			this.#active = id;
-			return existing;
-		}
-		if (this.#store === void 0) return void 0;
-		const snapshot = await this.#store.get(id);
-		if (snapshot === void 0) return void 0;
-		const workspace = this.add({
-			id,
-			seed: snapshot.files.map((file) => [file.path, file])
-		});
-		this.#active = workspace.id;
-		return workspace;
+	instructions() {
+		return [...this.#instructions.values()].sort((a, b) => b.priority - a.priority);
 	}
-	async save(id) {
-		const workspace = this.#workspaces.get(id);
-		if (this.#store === void 0 || workspace === void 0) return false;
-		await this.#store.set(workspace.snapshot());
-		return true;
+	format(instruction) {
+		return this.#format?.render?.(instruction) ?? instruction.content;
 	}
-	remove(ids) {
-		if (isArray(ids)) {
+	remove(names) {
+		if (isArray(names)) {
 			let removed = false;
-			for (const id of ids) if (this.#drop(id)) removed = true;
+			for (const name of names) if (this.#delete(name)) removed = true;
 			return removed;
 		}
-		return this.#drop(ids);
+		return this.#delete(names);
 	}
 	clear() {
-		this.#workspaces.clear();
-		this.#active = void 0;
+		this.#instructions.clear();
+		this.#emitter.emit("clear");
 	}
-	#drop(id) {
-		const removed = this.#workspaces.delete(id);
-		if (removed && this.#active === id) this.#active = void 0;
+	#create(input) {
+		const instruction = new Instruction(input);
+		this.#instructions.set(instruction.name, instruction);
+		this.#emitter.emit("add", instruction);
+		return instruction;
+	}
+	#delete(name) {
+		const removed = this.#instructions.delete(name);
+		if (removed) this.#emitter.emit("remove", name);
 		return removed;
 	}
 };
@@ -2288,7 +1266,7 @@ var AgentContext = class {
 	}
 	#workspaceImages(files) {
 		const data = [];
-		for (const file of files) if (isBinary(file.content) && isImage(file.content)) data.push(file.content.data);
+		for (const file of files) if (isBinary(file.content) && file.content.mime.startsWith("image/")) data.push(file.content.data);
 		return data;
 	}
 	#ensure() {
@@ -2622,7 +1600,7 @@ var Agent = class {
 					};
 					const toolMessage = this.#context.messages.add({
 						role: "tool",
-						content: JSON.stringify(outcomeResult.value ?? outcomeResult.error)
+						content: outcomeResult.success ? JSON.stringify(outcomeResult.value) : outcomeResult.error
 					});
 					messages.push(toolMessage);
 				}
@@ -2699,6 +1677,7 @@ var Agent = class {
 	}
 	#denial(call, reason) {
 		return {
+			success: false,
 			id: call.id,
 			name: call.name,
 			error: reason !== void 0 ? `denied: ${reason}` : "denied by authority"
@@ -2872,8 +1851,8 @@ var AgentRegistry = class {
 *   (an ALLOWLIST — only matched rules that allow get through), pass an `allowed: false`
 *   `fallback`.
 * - **Consulted before each tool call.** The agent loop calls `evaluate({ call })` for
-*   every {@link import('./types.js').ToolCall} the model emits; a denied call is fed
-*   back to the model as a denial {@link import('./types.js').ToolResult} (a `tool`
+*   every {@link import('@orkestrel/tool').ToolCall} the model emits; a denied call is fed
+*   back to the model as a denial {@link import('@orkestrel/tool').ToolResult} (a `tool`
 *   chunk + a tool message) instead of being executed — no tool run, no budget cost —
 *   so the model sees the denial and can react.
 * - **Synchronous now.** The async human-approval handshake (request / grant / deny) is
@@ -2916,7 +1895,7 @@ var Authority = class {
 * conversation's durable state IS a row, so persistence reduces to keyed point-access (`get` / `set`
 * / `delete`) over a {@link TableInterface}, the driver-pluggable twin of the plain-`Map`
 * {@link import('./MemoryConversationStore.js').MemoryConversationStore}. The EXACT twin of
-* {@link import('../../workspaces/stores/DatabaseWorkspaceStore.js').DatabaseWorkspaceStore}.
+* {@link import('@orkestrel/workspace').DatabaseWorkspaceStore}.
 *
 * @remarks
 * The store is driver-agnostic: it holds a single {@link TableInterface} whose backend (memory,
@@ -2924,7 +1903,7 @@ var Authority = class {
 * IndexedDB backend swaps in WITHOUT touching the
 * {@link import('../ConversationManager.js').ConversationManager} or the
 * {@link import('../Conversation.js').Conversation} — the same seam as
-* {@link import('../../workspaces/stores/DatabaseWorkspaceStore.js').DatabaseWorkspaceStore}. The
+* {@link import('@orkestrel/workspace').DatabaseWorkspaceStore}. The
 * driver defaults to memory ({@link import('../../factories.js').createDatabaseConversationStore}
 * passes `createMemoryDriver()`), so it ALSO works in memory out of the box; you opt into the
 * durable plumbing by passing a JSON / SQLite / IndexedDB driver.
@@ -2995,12 +1974,12 @@ var DatabaseConversationStore = class {
 * The in-memory {@link ConversationStoreInterface} — a process-lifetime `Map` of
 * {@link ConversationSnapshot}s keyed by conversation id, the DEFAULT store
 * {@link import('../../factories.js').createMemoryConversationStore} builds. The EXACT twin of
-* {@link import('../../workspaces/stores/MemoryWorkspaceStore.js').MemoryWorkspaceStore}.
+* {@link import('@orkestrel/workspace').MemoryWorkspaceStore}.
 *
 * @remarks
 * A plain `Map<string, ConversationSnapshot>` (AGENTS §21 — the snapshot is already pure,
 * self-contained JSON, so no encoding is needed for the memory tier). Like the
-* {@link import('../../workspaces/stores/MemoryWorkspaceStore.js').MemoryWorkspaceStore} it twins,
+* {@link import('@orkestrel/workspace').MemoryWorkspaceStore} it twins,
 * there is NO idle-TTL and NO eviction: a persisted conversation lives until an explicit `delete`. A
 * durable backend (JSON / SQLite / IndexedDB) swaps in through the SAME interface without touching
 * the {@link import('../ConversationManager.js').ConversationManager} or the
@@ -3298,238 +2277,8 @@ var ThinkSplitter = class {
 	}
 };
 //#endregion
-//#region src/core/tools/Tool.ts
-/**
-* A registered tool — its {@link import('../types.js').ToolDefinition} schema (the
-* `name` / `description` / `parameters` the model sees) bound to the `execute`
-* handler that runs a call.
-*
-* @remarks
-* A thin value object: the constructor stores the schema fields and the handler, and
-* `execute` delegates to the handler verbatim. `parameters` is kept by reference (the
-* open JSON-Schema the provider forwards as-is) — not cloned. The handler's `args` is
-* the model-supplied `unknown` arguments record, narrowed inside the handler (§14);
-* isolating a throw is the {@link ToolManager}'s job, not this class's. Event-free —
-* no Emitter, no events.
-*
-* @example
-* ```ts
-* const tool = new Tool({
-* 	name: 'add',
-* 	description: 'Add two numbers',
-* 	parameters: { type: 'object', properties: { a: { type: 'number' }, b: { type: 'number' } } },
-* 	execute: (args) => Number(args.a) + Number(args.b),
-* })
-* ```
-*/
-var Tool = class {
-	name;
-	description;
-	summary;
-	parameters;
-	#execute;
-	constructor(options) {
-		this.name = options.name;
-		if (options.description !== void 0) this.description = options.description;
-		if (options.summary !== void 0) this.summary = options.summary;
-		if (options.parameters !== void 0) this.parameters = options.parameters;
-		this.#execute = options.execute;
-	}
-	execute(args) {
-		return this.#execute(args);
-	}
-};
-//#endregion
-//#region src/core/workspaces/stores/DatabaseWorkspaceStore.ts
-/**
-* A {@link WorkspaceStoreInterface} backed by one table of the `databases` layer — a workspace's
-* durable state IS a row, so persistence reduces to keyed point-access (`get` / `set` / `delete`)
-* over a {@link TableInterface}, the driver-pluggable twin of the plain-`Map`
-* {@link import('./MemoryWorkspaceStore.js').MemoryWorkspaceStore}.
-*
-* @remarks
-* The store is driver-agnostic: it holds a single {@link TableInterface} whose backend (memory,
-* JSON, SQLite, IndexedDB) is chosen by whoever builds it (the factories), so a JSON / SQLite /
-* IndexedDB backend swaps in WITHOUT touching the
-* {@link import('../WorkspaceManager.js').WorkspaceManager} or the
-* {@link import('../Workspace.js').Workspace} — the same seam as
-* the analogous `DatabaseWorkflowStore` in `@orkestrel/workflow`. The
-* driver defaults to memory ({@link import('../../factories.js').createDatabaseWorkspaceStore}
-* passes `createMemoryDriver()`), so it ALSO works in memory out of the box; you opt into the
-* durable plumbing by passing a JSON / SQLite / IndexedDB driver.
-*
-* The {@link WorkspaceSnapshot} is stored as ONE OPAQUE JSON COLUMN — the table is a row of
-* `{ id; snapshot }` ({@link WorkspaceSnapshotRow}), the snapshot the whole JSON blob (a `rawShape`
-* column the factory builds) — exactly as `DatabaseWorkflowStore` stores its snapshot. The snapshot
-* is already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless AND
-* keeps the row type flat (`snapshot` reads back as `unknown`).
-*
-* - **`set(snapshot)` upserts under the snapshot's OWN `id`** (no separate id param) — it writes
-*   the row `{ id: snapshot.id, snapshot }`.
-* - **`get(id)` resolves the stored snapshot for an id**, narrowing the opaque JSON column back to
-*   a {@link WorkspaceSnapshot} ({@link import('../../helpers.js').isWorkspaceSnapshot} — the AGENTS
-*   §14 boundary narrow for an untrusted storage read), or `undefined` if none is stored.
-* - **`delete(id)` drops a snapshot by id**; an absent id is a no-op (no throw).
-*
-* UNLIKE a session store there is NO idle-TTL / eviction — a persisted workspace lives until an
-* explicit `delete`. The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the
-* §22 method bijection with {@link WorkspaceStoreInterface}). Hydration stays a caller concern: a
-* {@link import('../WorkspaceManager.js').WorkspaceManager} reads a snapshot back and rebuilds the
-* live workspace through the constructor `seed` (its `open` / `save`).
-*
-* @example
-* ```ts
-* import { createDatabaseWorkspaceStore, createMemoryDriver, createWorkspace } from '@src/core'
-*
-* const store = createDatabaseWorkspaceStore(createMemoryDriver()) // a durable driver swaps in here
-* const workspace = createWorkspace()
-* workspace.write('notes.txt', 'hello')
-* await store.set(workspace.snapshot())          // persist the workspace (one JSON column)
-* const snapshot = await store.get(workspace.id)
-* await store.delete(workspace.id)               // drop it
-* ```
-*/
-var DatabaseWorkspaceStore = class {
-	#table;
-	/**
-	* Wrap a table as a workspace store.
-	*
-	* @param table - The {@link TableInterface} holding the snapshots — its row is the
-	*   {@link WorkspaceSnapshotRow} `{ id; snapshot }` shape (the snapshot one opaque JSON column)
-	*/
-	constructor(table) {
-		this.#table = table;
-	}
-	/** Resolve the persisted snapshot for `id`, narrowing the opaque JSON column back to a `WorkspaceSnapshot`. */
-	async get(id) {
-		const row = await this.#table.get(id);
-		if (row === void 0) return void 0;
-		return isWorkspaceSnapshot(row.snapshot) ? row.snapshot : void 0;
-	}
-	/** Insert or replace under the snapshot's OWN `id` (no separate id param) — the row is `{ id, snapshot }`. */
-	async set(snapshot) {
-		await this.#table.set({
-			id: snapshot.id,
-			snapshot
-		});
-	}
-	/** Drop a snapshot by id; an absent id is a no-op (no throw). */
-	async delete(id) {
-		await this.#table.remove(id);
-	}
-};
-//#endregion
-//#region src/core/workspaces/stores/MemoryWorkspaceStore.ts
-/**
-* The in-memory {@link WorkspaceStoreInterface} — a process-lifetime `Map` of
-* {@link WorkspaceSnapshot}s keyed by workspace id, the DEFAULT store
-* {@link import('../../factories.js').createMemoryWorkspaceStore} builds.
-*
-* @remarks
-* A plain `Map<string, WorkspaceSnapshot>` (AGENTS §21 — the snapshot is already pure,
-* self-contained JSON, so no encoding is needed for the memory tier). Like the
-* the analogous `MemoryWorkflowStore` in `@orkestrel/workflow` it twins,
-* there is NO idle-TTL and NO eviction: a persisted workspace lives until an explicit `delete`. A
-* durable backend (JSON / SQLite / IndexedDB) swaps in through the SAME interface without touching
-* the {@link import('../WorkspaceManager.js').WorkspaceManager} or the
-* {@link import('../Workspace.js').Workspace} — its driver-pluggable twin is
-* {@link import('./DatabaseWorkspaceStore.js').DatabaseWorkspaceStore} (the snapshot as one opaque
-* JSON column).
-*
-* - **`get` resolves the persisted snapshot for an id**, or `undefined` if none is stored.
-* - **`set` inserts / replaces under the snapshot's OWN `id`** (no separate id param).
-* - **`delete` drops a snapshot by id**; an absent id is a no-op (no throw).
-*
-* The public surface is EXACTLY `get` / `set` / `delete` — no extra members (the §22 method
-* bijection with {@link WorkspaceStoreInterface}). Hydration is a caller concern: a
-* {@link import('../WorkspaceManager.js').WorkspaceManager} reads a snapshot back and rebuilds the
-* live workspace through the constructor `seed` (its `open` / `save`).
-*
-* @example
-* ```ts
-* import { createMemoryWorkspaceStore, createWorkspace } from '@src/core'
-*
-* const store = createMemoryWorkspaceStore()
-* const workspace = createWorkspace()
-* workspace.write('notes.txt', 'hello')
-* await store.set(workspace.snapshot())     // persist the workspace
-* const snapshot = await store.get(workspace.id)
-* await store.delete(workspace.id)          // drop it
-* ```
-*/
-var MemoryWorkspaceStore = class {
-	#snapshots = /* @__PURE__ */ new Map();
-	get(id) {
-		return Promise.resolve(this.#snapshots.get(id));
-	}
-	set(snapshot) {
-		this.#snapshots.set(snapshot.id, snapshot);
-		return Promise.resolve();
-	}
-	delete(id) {
-		this.#snapshots.delete(id);
-		return Promise.resolve();
-	}
-};
-//#endregion
 //#region src/core/factories.ts
 /**
-* Create a tool — a {@link ToolInterface} binding a {@link ToolDefinition} schema
-* (the `name` / `description` / `parameters` the model sees) to the `execute` handler
-* that runs a call.
-*
-* @remarks
-* Only `name` is required (it keys the tool in a {@link ToolManagerInterface} and is
-* what the model calls); `description` / `parameters` are the optional JSON-Schema the
-* provider advertises (forwarded verbatim). The handler's `args` is the model-supplied
-* `unknown` arguments record — narrow it inside (§14); a `createToolManager` registry
-* isolates a throw into a `ToolResult.error`.
-*
-* @param options - `name` (required), optional `description` / `parameters`, and the
-*   `execute` handler (see {@link ToolOptions})
-* @returns A working {@link ToolInterface}
-*
-* @example
-* ```ts
-* import { createTool } from '@src/core'
-*
-* const add = createTool({
-* 	name: 'add',
-* 	description: 'Add two numbers',
-* 	execute: (args) => Number(args.a) + Number(args.b),
-* })
-* ```
-*/
-function createTool(options) {
-	return new Tool(options);
-}
-/**
-* Create a tool registry — a {@link ToolManagerInterface} that resolves tool names,
-* lists {@link ToolDefinition}s for the provider, and executes calls with per-call
-* error isolation.
-*
-* @remarks
-* Starts empty; `add` registers one tool or a batch (§9.2), `definitions()` yields the
-* schemas to hand a provider, and `execute` runs a {@link ToolCall} (or a batch),
-* ALWAYS resolving a {@link ToolResult} — a handler throw becomes an `error` result and
-* an unknown name a not-found `error`, so a tool throw never escapes and a batch never
-* fails as a whole.
-*
-* @returns An empty {@link ToolManagerInterface}
-*
-* @example
-* ```ts
-* import { createTool, createToolManager } from '@src/core'
-*
-* const tools = createToolManager()
-* tools.add(createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
-* const result = await tools.execute({ id: '1', name: 'add', arguments: { x: 1, y: 2 } })
-* ```
-*/
-function createToolManager() {
-	return new ToolManager();
-}
-/**
 * Create a conversation — a {@link ConversationInterface} grouping messages above a flat
 * message store it OWNS DIRECTLY, with compaction into summarized sections, a regenerated
 * rollup `summary`, on-demand `rehydrate`, and substring `search`, driven by a
@@ -3603,11 +2352,13 @@ function createConversationManager(options) {
 * Create the in-memory conversation store — a {@link ConversationStoreInterface} backed by a
 * process-lifetime `Map` of {@link import('./types.js').ConversationSnapshot}s keyed by conversation
 * id, the DEFAULT backing for the durable {@link ConversationManagerInterface.open} /
-* {@link ConversationManagerInterface.save} seam. The EXACT twin of {@link createMemoryWorkspaceStore}.
+* {@link ConversationManagerInterface.save} seam. The exact twin of
+* {@link import('@orkestrel/workspace').createMemoryWorkspaceStore}.
 *
 * @remarks
 * A plain `Map` (the snapshot is already pure JSON, so no encoding is needed for the memory tier),
-* the structural twin of {@link createMemoryWorkspaceStore}. `get` / `set` / `delete` are async (the
+* the structural twin of {@link import('@orkestrel/workspace').createMemoryWorkspaceStore}.
+* `get` / `set` / `delete` are async (the
 * same shape a durable backend fits); UNLIKE a session store there is NO idle-TTL / eviction — a
 * persisted conversation lives until an explicit `delete`. Its driver-pluggable twin is
 * {@link createDatabaseConversationStore} (the snapshot as one opaque JSON column over a `databases`
@@ -3635,12 +2386,14 @@ function createMemoryConversationStore() {
 /**
 * Create a {@link DatabaseConversationStore} over any {@link DriverInterface} — the durable,
 * driver-pluggable backing for the conversation persistence seam, the opt-in twin of
-* {@link createMemoryConversationStore}. The EXACT twin of {@link createDatabaseWorkspaceStore}.
+* {@link createMemoryConversationStore}. The exact twin of
+* {@link import('@orkestrel/workspace').createDatabaseWorkspaceStore}.
 *
 * @remarks
 * Builds a one-table database (`conversations`, keyed by `id`) over the supplied driver, the snapshot
 * held as ONE OPAQUE JSON COLUMN — the column map is `{ id; snapshot }` where `snapshot` is a
-* `rawShape` (a JSON blob), exactly as {@link createDatabaseWorkspaceStore} stores its snapshot. The
+* `rawShape` (a JSON blob), exactly as
+* {@link import('@orkestrel/workspace').createDatabaseWorkspaceStore} stores its snapshot. The
 * snapshot is already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless
 * AND keeps the row type FLAT (the column reads back as `unknown`, narrowed on `get` by
 * {@link import('./helpers.js').isConversationSnapshot}). The `driver` DEFAULTS to
@@ -3664,12 +2417,13 @@ function createMemoryConversationStore() {
 * ```
 */
 function createDatabaseConversationStore(driver = createMemoryDriver()) {
+	const columns = {
+		id: stringShape(),
+		snapshot: rawShape({})
+	};
 	return new DatabaseConversationStore(createDatabase({
 		driver,
-		tables: { conversations: {
-			id: stringShape(),
-			snapshot: rawShape({})
-		} }
+		tables: { conversations: columns }
 	}).table("conversations"));
 }
 /**
@@ -3936,8 +2690,9 @@ function createAuthority(options) {
 *
 * @example
 * ```ts
+* import { createAgentRegistry } from '@src/core'
 * import type { ProviderInterface } from '@src/core'
-* import { createAgentRegistry, createTool } from '@src/core'
+* import { createTool } from '@orkestrel/tool'
 *
 * declare const provider: ProviderInterface // any concrete implementation supplied by the host app
 * const registry = createAgentRegistry({
@@ -4042,213 +2797,7 @@ function createAgentRunner(options) {
 		handler: handleAgentRunnerJob.bind(void 0, registry, allowPartial)
 	});
 }
-/**
-* Create a file — an immutable {@link FileInterface} from its `path` + {@link FileContent}
-* and optional {@link import('./types.js').FileState}, with `size` / `lines` DERIVED from the
-* content.
-*
-* @remarks
-* Returns a PLAIN `Object.freeze`d record (NOT a class instance) — the `path` IS its identity
-* (there is no `id`). Only `path` / `content` are required; `state` defaults to `'created'`
-* when omitted. `size` (via {@link computeSize}) and `lines` (via {@link countLines}) are
-* computed from the content here (so they never drift from it). Frozen + plain, so it
-* `structuredClone`s losslessly and is never mutated after creation.
-*
-* @param input - `path` / `content` (required) and an optional `state` (see {@link FileInput})
-* @returns A frozen {@link FileInterface} record
-*
-* @example
-* ```ts
-* import { createFile, createTextContent } from '@src/core'
-*
-* const file = createFile({ path: 'src/main.ts', content: createTextContent('const x = 1', 'typescript') })
-* file.lines // 1
-* ```
-*/
-function createFile(input) {
-	return Object.freeze({
-		path: input.path,
-		content: input.content,
-		state: input.state ?? "created",
-		size: computeSize(input.content),
-		lines: countLines(input.content)
-	});
-}
-/**
-* Build the TEXT {@link FileContent} arm — the §4.2.3 split constructor for text (a separate
-* function per arm, not one constructor dispatching on a discriminator parameter).
-*
-* @param text - The literal text body
-* @param language - The fenced-code language the text renders as (e.g. `'typescript'`)
-* @returns A `{ text; language }` content arm
-*
-* @example
-* ```ts
-* import { createTextContent } from '@src/core'
-*
-* createTextContent('const x = 1', 'typescript') // { text: 'const x = 1', language: 'typescript' }
-* ```
-*/
-function createTextContent(text, language) {
-	return {
-		text,
-		language
-	};
-}
-/**
-* Build the BINARY {@link FileContent} arm — the §4.2.3 split constructor for binary (a
-* separate function per arm, not one constructor dispatching on a discriminator parameter).
-* An image is just a binary with an image {@link BinaryMIME}.
-*
-* @param data - The base64-encoded binary payload
-* @param mime - The {@link BinaryMIME} that labels the payload
-* @returns A `{ data; mime }` content arm
-*
-* @example
-* ```ts
-* import { createBinaryContent } from '@src/core'
-*
-* createBinaryContent('<base64>', 'image/png') // { data: '<base64>', mime: 'image/png' }
-* ```
-*/
-function createBinaryContent(data, mime) {
-	return {
-		data,
-		mime
-	};
-}
-/**
-* Create a workspace — a mutable, `path`-keyed working set of immutable
-* {@link FileInterface}s with the in-memory edit surface (read / write / search / replace /
-* move / remove), observable through its `EmitterInterface` (from `@orkestrel/emitter`).
-*
-* @param options - Optional initial {@link import('./types.js').WorkspaceEventMap} listeners (`on`) and the emitter's `error` handler (see {@link WorkspaceOptions})
-* @returns A working {@link WorkspaceInterface}
-*
-* @example
-* ```ts
-* import { createWorkspace } from '@src/core'
-*
-* const workspace = createWorkspace({ on: { write: (file) => console.log(file.path) } })
-* workspace.write('src/main.ts', 'const x = 1')
-* workspace.file('src/main.ts')?.state // 'created'
-* ```
-*/
-function createWorkspace(options) {
-	return new Workspace(options);
-}
-/**
-* Create the in-memory workspace store — a {@link WorkspaceStoreInterface} backed by a
-* process-lifetime `Map` of {@link import('./types.js').WorkspaceSnapshot}s keyed by workspace id,
-* the DEFAULT backing for the durable {@link WorkspaceManagerInterface.open} /
-* {@link WorkspaceManagerInterface.save} seam.
-*
-* @remarks
-* A plain `Map` (the snapshot is already pure JSON, so no encoding is needed for the memory tier),
-* the structural twin of the analogous `createMemoryWorkflowStore` in `@orkestrel/workflow`.
-* `get` / `set` / `delete` are async (the same shape a durable backend fits); UNLIKE a session
-* store there is NO idle-TTL / eviction — a persisted workspace lives until an explicit `delete`.
-* Its driver-pluggable twin is {@link createDatabaseWorkspaceStore} (the snapshot as one opaque
-* JSON column over a `databases` table) — for a DURABLE store pass it a JSON / SQLite / IndexedDB
-* driver, and it swaps in WITHOUT touching the manager or the workspace. Hydration stays a manager
-* concern: read a snapshot back and rebuild the live workspace through the constructor `seed`.
-*
-* @returns A memory-backed {@link WorkspaceStoreInterface}
-*
-* @example
-* ```ts
-* import { createMemoryWorkspaceStore, createWorkspaceManager } from '@src/core'
-*
-* const store = createMemoryWorkspaceStore()
-* const manager = createWorkspaceManager({ store })
-* const workspace = manager.add()
-* workspace.write('notes.txt', 'hello')
-* await manager.save(workspace.id)               // persist the workspace
-* ```
-*/
-function createMemoryWorkspaceStore() {
-	return new MemoryWorkspaceStore();
-}
-/**
-* Create a {@link DatabaseWorkspaceStore} over any {@link DriverInterface} — the durable,
-* driver-pluggable backing for the workspace persistence seam, the opt-in twin of
-* {@link createMemoryWorkspaceStore}.
-*
-* @remarks
-* Builds a one-table database (`workspaces`, keyed by `id`) over the supplied driver, the snapshot
-* held as ONE OPAQUE JSON COLUMN — the column map is `{ id; snapshot }` where `snapshot` is a
-* `rawShape` (a JSON blob), exactly as
-* the analogous `createDatabaseWorkflowStore` in `@orkestrel/workflow` stores its snapshot. The
-* snapshot is already a COMPLETE, self-contained, pure-JSON payload, so storing it whole is lossless
-* AND keeps the row type FLAT (the column reads back as `unknown`, narrowed on `get` by
-* {@link import('./helpers.js').isWorkspaceSnapshot}). The `driver` DEFAULTS to
-* {@link createMemoryDriver}, so the store ALSO works in memory out of the box; pass a server
-* `createJSONDriver` / `createSQLiteDriver` (or a browser IndexedDB driver) for a persistent one —
-* the durability is the driver's job, the store engine is shared. It swaps in behind
-* {@link WorkspaceStoreInterface} WITHOUT touching the manager or the workspace.
-*
-* @param driver - The storage backend the snapshots persist to (defaults to {@link createMemoryDriver})
-* @returns A {@link WorkspaceStoreInterface} over the driver
-*
-* @example
-* ```ts
-* import { createDatabaseWorkspaceStore, createMemoryDriver, createWorkspaceManager } from '@src/core'
-*
-* const store = createDatabaseWorkspaceStore(createMemoryDriver()) // a durable driver swaps in here
-* const manager = createWorkspaceManager({ store })
-* const workspace = manager.add()
-* workspace.write('notes.txt', 'hello')
-* await manager.save(workspace.id)               // persist the workspace (one JSON column)
-* ```
-*/
-function createDatabaseWorkspaceStore(driver = createMemoryDriver()) {
-	return new DatabaseWorkspaceStore(createDatabase({
-		driver,
-		tables: { workspaces: {
-			id: stringShape(),
-			snapshot: rawShape({})
-		} }
-	}).table("workspaces"));
-}
-/**
-* Create a workspace registry — a {@link WorkspaceManagerInterface} holding
-* {@link WorkspaceInterface}s keyed by their `id` (in insertion order) WITH an active pointer:
-* the §9 store over the workspace layer plus the `active` / `switch` seam the context renders.
-*
-* @remarks
-* Starts empty; `add(input?)` mints a {@link WorkspaceInterface} (its `id` from the input or a
-* random UUID), flowing the manager's default `on` / `error` in unless the input overrides them,
-* and stores it (an already-present `id` overwrites — last write wins) — and AUTO-ACTIVATES the
-* FIRST one (a registry with workspaces always has one `active`); a later `add` leaves `active`
-* unchanged. `switch(id)` re-points `active` (an unknown `id` returns `undefined`, leaving
-* `active` unchanged — lenient, never throws); `workspace(id)` / `workspaces()` look up;
-* `remove` (one or a batch, §9.2) reports whether any was removed AND clears `active` if it was
-* the removed one; `clear` empties it and clears `active`. Event-free (each workspace owns its
-* own observable `emitter`).
-*
-* With the optional `store` ({@link WorkspaceStoreInterface}, e.g. `createMemoryWorkspaceStore` /
-* `createDatabaseWorkspaceStore`), `open(id)` HYDRATES a workspace on a registry miss (rebuilding it
-* through the constructor `seed` from the snapshot's `files`, then activating it) and `save(id)`
-* PERSISTS a registered workspace's `snapshot()`. Both are LENIENT without a store (open resolves
-* only registered ids, save is a no-op `false`).
-*
-* @param options - Optional default `on` / `error` for created workspaces + the durable `store`
-*   (see {@link WorkspaceManagerOptions})
-* @returns An empty {@link WorkspaceManagerInterface}
-*
-* @example
-* ```ts
-* import { createWorkspaceManager } from '@src/core'
-*
-* const workspaces = createWorkspaceManager()
-* const scratch = workspaces.add() // auto-activates — workspaces.active === scratch
-* scratch.write('notes.txt', 'hello')
-* ```
-*/
-function createWorkspaceManager(options) {
-	return new WorkspaceManager(options);
-}
 //#endregion
-export { Agent, AgentContext, AgentError, AgentJobError, AgentRegistry, Authority, CONVERSATION_RECAP_PREFIX, Channel, Conversation, ConversationError, ConversationManager, DEFAULT_AGENT_LIMIT, DEFAULT_AUTHORITY_ZONE, DEFAULT_CONVERSATION_KEEP, DatabaseConversationStore, DatabaseWorkspaceStore, EXTENSION_TO_LANGUAGE, IMAGE_TOKEN_ESTIMATE, Instruction, InstructionManager, MESSAGE_TOKEN_OVERHEAD, MemoryConversationStore, MemoryWorkspaceStore, ProviderAbortError, Scope, ScopeManager, THINK_CLOSE, THINK_OPEN, ThinkSplitter, Tool, ToolManager, WORKSPACE_SECTION_HEADER, Workspace, WorkspaceError, WorkspaceManager, buildToolResult, clampPosition, clampRange, computeSize, countLines, createAgent, createAgentContext, createAgentQueue, createAgentRegistry, createAgentRunner, createAuthority, createBinaryContent, createConversation, createConversationManager, createDatabaseConversationStore, createDatabaseWorkspaceStore, createFile, createInstruction, createInstructionManager, createMemoryConversationStore, createMemoryWorkspaceStore, createScope, createScopeManager, createTextContent, createThinkSplitter, createTool, createToolManager, createWorkspace, createWorkspaceManager, decodedSize, escapeRegExp, estimateMessages, estimateTokens, fencedFile, filterAllowList, handleAgentQueueJob, handleAgentRunnerJob, inferLanguage, isAgentError, isAgentJobError, isBinary, isConversationError, isConversationSnapshot, isFile, isImage, isMessage, isProviderAbortError, isSection, isText, isToolCall, isValidRange, isWorkspaceError, isWorkspaceSnapshot, offsetAt, rangeOf, sanitizeToken, sanitizeUsage, settleAgentJob, sliceRange, spliceRange };
+export { Agent, AgentContext, AgentError, AgentJobError, AgentRegistry, Authority, CONVERSATION_RECAP_PREFIX, Channel, Conversation, ConversationError, ConversationManager, DEFAULT_AGENT_LIMIT, DEFAULT_AUTHORITY_ZONE, DEFAULT_CONVERSATION_KEEP, DatabaseConversationStore, IMAGE_TOKEN_ESTIMATE, Instruction, InstructionManager, MESSAGE_TOKEN_OVERHEAD, MemoryConversationStore, ProviderAbortError, Scope, ScopeManager, THINK_CLOSE, THINK_OPEN, ThinkSplitter, WORKSPACE_SECTION_HEADER, agentResultToJSON, createAgent, createAgentContext, createAgentQueue, createAgentRegistry, createAgentRunner, createAuthority, createConversation, createConversationManager, createDatabaseConversationStore, createInstruction, createInstructionManager, createMemoryConversationStore, createScope, createScopeManager, createThinkSplitter, estimateMessages, estimateTokens, fencedFile, filterAllowList, handleAgentQueueJob, handleAgentRunnerJob, isAgentError, isAgentJobError, isConversationError, isConversationSnapshot, isMessage, isProviderAbortError, isSection, sanitizeToken, sanitizeUsage, settleAgentJob };
 
 //# sourceMappingURL=index.js.map