@eclipse-docks/extension-ai-system 0.8.0 → 0.8.2

package/dist/{runtime-DfNGzEjU.js → runtime-B0IHjzQO.js}

@@ -1,4 +1,4 @@
-import { Directory, File, commandRegistry, persistenceService, workspaceService } from "@eclipse-docks/core";
+import { Directory, File, IN_MEMORY_ROOT_NAME, commandRegistry, contributionRegistry, filebrowserDialog, getInMemoryRoot, persistenceService, registerAll, setInMemoryMountProjection, workspaceService } from "@eclipse-docks/core";
 import { Models } from "@opencode-ai/models";
 //#region src/runtime/events.ts
 /** Tiny in-process bus so runtime stays UI-agnostic. */
@@ -548,6 +548,17 @@ function normalizeProvidersSettings(raw) {
 	};
 }
 //#endregion
+//#region src/runtime/abort.ts
+/** True when an AbortSignal has already been aborted. */
+function isAborted(signal) {
+	return Boolean(signal?.aborted);
+}
+/** True for DOMException / Error abort failures from fetch and friends. */
+function isAbortError(err) {
+	if (!err || typeof err !== "object") return false;
+	return err.name === "AbortError";
+}
+//#endregion
 //#region src/runtime/models/openai-compatible.ts
 function wireContent(content) {
 	if (typeof content === "string") return content;
@@ -613,11 +624,16 @@ async function fetchOpenAICompatibleModels(baseUrl, apiKey, signal) {
 function buildChatCompletionBody(params) {
 	const model = params.model.includes("/") ? params.model.split("/").slice(1).join("/") : params.model;
 	const { reasoning_effort: _a, reasoningEffort: _b, reasoning: _c, ...safeOptions } = params.providerOptions ?? {};
+	const { stream_options: userStreamOptions, ...restSafeOptions } = safeOptions;
 	const body = {
 		model,
 		messages: toOpenAIMessages(params.messages),
 		stream: true,
-		...safeOptions
+		...restSafeOptions,
+		stream_options: {
+			...userStreamOptions && typeof userStreamOptions === "object" ? userStreamOptions : {},
+			include_usage: true
+		}
 	};
 	const requestedEffort = params.providerOptions?.reasoning_effort ?? params.providerOptions?.reasoningEffort;
 	const reasoningModel = detectEffortCapability(params.model).supported || requestedEffort != null;
@@ -665,6 +681,10 @@ var OpenAICompatibleProvider = class {
 				signal: params.signal
 			});
 		} catch (err) {
+			if (params.signal?.aborted || isAbortError(err)) {
+				yield { type: "done" };
+				return;
+			}
 			yield {
 				type: "error",
 				error: err instanceof Error ? err.message : String(err)
@@ -683,7 +703,21 @@ var OpenAICompatibleProvider = class {
 		let buffer = "";
 		const toolAcc = /* @__PURE__ */ new Map();
 		while (true) {
-			const { done, value } = await reader.read();
+			let done;
+			let value;
+			try {
+				({done, value} = await reader.read());
+			} catch (err) {
+				if (params.signal?.aborted || isAbortError(err)) {
+					yield { type: "done" };
+					return;
+				}
+				yield {
+					type: "error",
+					error: err instanceof Error ? err.message : String(err)
+				};
+				return;
+			}
 			if (done) break;
 			buffer += decoder.decode(value, { stream: true });
 			const lines = buffer.split("\n");
@@ -697,15 +731,22 @@ var OpenAICompatibleProvider = class {
 					return;
 				}
 				try {
-					const delta = JSON.parse(data).choices?.[0]?.delta;
+					const json = JSON.parse(data);
+					const usage = parseStreamUsage(json.usage);
+					if (usage) yield {
+						type: "usage",
+						usage
+					};
+					const delta = json.choices?.[0]?.delta;
 					if (!delta) continue;
-					if (delta.content) yield {
+					if (typeof delta.content === "string" && delta.content) yield {
 						type: "text",
 						text: delta.content
 					};
-					if (delta.reasoning_content || delta.reasoning) yield {
+					const reasoning = delta.reasoning_content ?? delta.reasoning;
+					if (reasoning) yield {
 						type: "reasoning",
-						text: String(delta.reasoning_content ?? delta.reasoning)
+						text: String(reasoning)
 					};
 					if (Array.isArray(delta.tool_calls)) for (const tc of delta.tool_calls) {
 						const idx = tc.index ?? 0;
@@ -729,6 +770,17 @@ var OpenAICompatibleProvider = class {
 		yield { type: "done" };
 	}
 };
+function parseStreamUsage(usage) {
+	if (!usage) return null;
+	const inputTokens = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0);
+	const outputTokens = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
+	if (!Number.isFinite(inputTokens) && !Number.isFinite(outputTokens)) return null;
+	if (inputTokens <= 0 && outputTokens <= 0) return null;
+	return {
+		inputTokens: Math.max(0, Math.round(inputTokens) || 0),
+		outputTokens: Math.max(0, Math.round(outputTokens) || 0)
+	};
+}
 //#endregion
 //#region src/runtime/models/router.ts
 var EFFORT_ORDER = [
@@ -955,227 +1007,40 @@ function isMutatingName(name) {
 	return /^(write|edit|delete|mkdir|rm|mv|save|apply)/i.test(name) || name.includes("write") || name.includes("delete");
 }
 //#endregion
-//#region src/runtime/tools/workspace-adapter.ts
-function asRecord(value) {
-	return value && typeof value === "object" ? value : {};
+//#region src/runtime/attachment-paths.ts
+/** Mirrors core `IN_MEMORY_ROOT_NAME` without importing the filesys graph. */
+var IN_MEMORY_ROOT_NAME$1 = "in-memory";
+/** URI scheme for UI references (`in-memory://<sessionId>/<file>`). */
+var IN_MEMORY_URI_SCHEME = "in-memory://";
+/** Sanitize a single path segment (no slashes). Prefer id-prefixed names for uniqueness. */
+function safeAttachmentFileName(name, id) {
+	return `${id}-${(name || "attachment").replace(/[/\\]/g, "_").trim() || "attachment"}`;
+}
+/** Workspace path used by workspace_* tools (no protocol). */
+function attachmentWorkspacePath(sessionId, stored) {
+	return `${IN_MEMORY_ROOT_NAME$1}/${sessionId}/${safeAttachmentFileName(stored.name, stored.id)}`;
+}
+/** UI / catalog URI form (`in-memory://<sessionId>/<file>`). */
+function attachmentUri(sessionId, stored) {
+	return `${IN_MEMORY_URI_SCHEME}${sessionId}/${safeAttachmentFileName(stored.name, stored.id)}`;
 }
-/** Registers built-in workspace file tools on the broker. */
-function registerWorkspaceTools(broker) {
-	broker.register({
-		name: "workspace_list",
-		description: "List children of a workspace directory path",
-		parameters: {
-			type: "object",
-			properties: { path: {
-				type: "string",
-				description: "Directory path relative to workspace"
-			} },
-			required: ["path"]
-		}
-	}, async (call) => {
-		try {
-			const path = String(call.arguments.path ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace"
-			};
-			const resource = await root.getResource(path.endsWith("/") ? path : `${path}/`);
-			if (!(resource instanceof Directory)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a directory"
-			};
-			const children = await resource.listChildren(true);
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: children.map((c) => ({
-					name: c.getName(),
-					path: c.getWorkspacePath()
-				}))
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	});
-	broker.register({
-		name: "workspace_read",
-		description: "Read a workspace file as text",
-		parameters: {
-			type: "object",
-			properties: { path: { type: "string" } },
-			required: ["path"]
-		}
-	}, async (call) => {
-		try {
-			const path = String(call.arguments.path ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace"
-			};
-			const resource = await root.getResource(path);
-			if (!(resource instanceof File)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a file"
-			};
-			const contents = await resource.getContents();
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: contents
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	});
-	broker.register({
-		name: "workspace_write",
-		description: "Write text contents to a workspace file (creates parents as needed)",
-		parameters: {
-			type: "object",
-			properties: {
-				path: { type: "string" },
-				contents: { type: "string" }
-			},
-			required: ["path", "contents"]
-		}
-	}, async (call) => {
-		try {
-			const args = asRecord(call.arguments);
-			const path = String(args.path ?? "");
-			const contents = String(args.contents ?? "");
-			const root = await workspaceService.getWorkspace();
-			if (!root) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "No workspace",
-				mutating: true
-			};
-			const resource = await root.getResource(path, { create: true });
-			if (!(resource instanceof File)) return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: "Not a file",
-				mutating: true
-			};
-			await resource.saveContents(contents);
-			return {
-				id: call.id,
-				name: call.name,
-				ok: true,
-				output: { path },
-				mutating: true
-			};
-		} catch (err) {
-			return {
-				id: call.id,
-				name: call.name,
-				ok: false,
-				output: null,
-				error: err instanceof Error ? err.message : String(err),
-				mutating: true
-			};
-		}
-	});
-}
-//#endregion
-//#region src/runtime/tools/command-adapter.ts
-var SKIP = /* @__PURE__ */ new Set(["open_cognitive_ai_settings", "open_ai_config"]);
-/** Built-in tools that must survive command refresh (not command-backed). */
-var KEEP_TOOLS = /* @__PURE__ */ new Set([
-	"workspace_list",
-	"workspace_read",
-	"workspace_write",
-	"attachment_list",
-	"attachment_read"
-]);
-function sanitizeName(id) {
-	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
-}
-/** Registers Docks commands as first-class LLM tools (tool name = command id). */
-function refreshCommandTools(broker, role) {
-	for (const def of broker.listDefinitions("build")) if (!KEEP_TOOLS.has(def.name)) broker.unregister(def.name);
-	const commands = commandRegistry.listCommands(commandRegistry.createExecutionContext());
-	const entries = Object.values(commands);
-	for (const command of entries) {
-		if (!command?.id || SKIP.has(command.id)) continue;
-		if (!command.description) continue;
-		if ((role === "plan" || role === "explore") && /delete|write|save|rm|mv/i.test(command.id)) continue;
-		const toolName = sanitizeName(command.id);
-		if (KEEP_TOOLS.has(toolName)) continue;
-		const properties = {};
-		const required = [];
-		for (const p of command.parameters ?? []) {
-			properties[p.name] = {
-				type: p.type ?? "string",
-				description: p.description,
-				...p.allowedValues ? { enum: p.allowedValues } : {}
-			};
-			if (p.required) required.push(p.name);
-		}
-		broker.register({
-			name: toolName,
-			description: `${command.name}: ${command.description}`,
-			parameters: {
-				type: "object",
-				properties,
-				required
-			}
-		}, async (call, _sessionId) => {
-			try {
-				const result = await commandRegistry.execute(command.id, { params: call.arguments });
-				return {
-					id: call.id,
-					name: call.name,
-					ok: true,
-					output: result
-				};
-			} catch (err) {
-				return {
-					id: call.id,
-					name: call.name,
-					ok: false,
-					output: null,
-					error: err instanceof Error ? err.message : String(err)
-				};
-			}
-		});
+/**
+* Map `in-memory://…` references to composite workspace paths.
+* Real workspace paths are returned unchanged.
+*/
+function toWorkspaceToolPath(path) {
+	const trimmed = path.trim();
+	const lower = trimmed.toLowerCase();
+	if (lower === "in-memory:" || lower === "in-memory://" || lower === "in-memory") return IN_MEMORY_ROOT_NAME$1;
+	if (lower.startsWith("in-memory://")) {
+		const rest = trimmed.slice(12).replace(/^\/+/, "");
+		return rest ? `${IN_MEMORY_ROOT_NAME$1}/${rest}` : IN_MEMORY_ROOT_NAME$1;
 	}
+	return trimmed;
 }
 //#endregion
 //#region src/runtime/attachments.ts
-/** Soft cap per attached text file when stored / returned by attachment_read. */
+/** Soft cap per attached text file when stored / returned via workspace_read. */
 var MAX_ATTACHMENT_CHARS = 1e5;
 /** Soft cap for visual media attachments (bytes). */
 var MAX_IMAGE_BYTES = 4e6;
@@ -1384,7 +1249,7 @@ function toSessionAttachment(attachment, opts = {}) {
 		messageId: opts.messageId
 	};
 }
-/** Lightweight history/UI reference — no payload. */
+/** Lightweight history/UI reference — no payload (path is an in-memory workspace path/URI). */
 function toFileRefPart(stored) {
 	return {
 		type: "file",
@@ -1398,14 +1263,15 @@ function toFileRefPart(stored) {
 }
 /** One-line catalog entry published into the user turn for the model. */
 function formatAttachmentRefForModel(part) {
-	const label = part.path?.trim() || part.name;
+	const display = part.path || part.name;
+	const toolPath = toWorkspaceToolPath(display);
 	const kind = part.kind ?? "file";
 	const bytes = part.byteLength != null ? ` bytes=${part.byteLength}` : "";
-	return `[Attachment published: id=${part.id} name="${label}" kind=${kind}${part.mime ? ` mime=${part.mime}` : ""}${bytes}] → use attachment_read with id="${part.id}"`;
+	return `[Attachment published: ${display} kind=${kind}${part.mime ? ` mime=${part.mime}` : ""}${bytes}] → workspace_read path="${toolPath}"`;
 }
 /**
 * Build provider user content from history parts.
-* File parts are references only — payloads stay in the session store.
+* File parts are references only — payloads live under the in-memory workspace root.
 */
 function userContentFromParts(parts) {
 	const texts = [];
@@ -1416,71 +1282,10 @@ function userContentFromParts(parts) {
 	}
 	const body = [...texts, ...refs].join("\n").trim();
 	if (!refs.length) return body;
-	return [body, "Attachments live in this session store only. Call attachment_read (or attachment_list) before answering about them. Do not use canvas/workspace/editor commands to locate attachments."].filter(Boolean).join("\n");
-}
-function attachmentMeta(stored) {
-	return {
-		id: stored.id,
-		name: stored.name,
-		path: stored.path,
-		mime: stored.mime,
-		kind: stored.kind,
-		byteLength: stored.byteLength,
-		truncated: stored.truncated
-	};
-}
-function readTextAttachment(stored, opts = {}) {
-	if (stored.kind !== "text" && !(stored.kind === "image" && stored.text)) return {
-		ok: false,
-		error: `${stored.name} is not a text attachment`
-	};
-	const full = stored.text ?? "";
-	const offset = Math.max(0, opts.offset ?? 0);
-	const limit = Math.max(1, opts.limit ?? 4e4);
-	const slice = full.slice(offset, offset + limit);
-	return {
-		ok: true,
-		output: {
-			...attachmentMeta(stored),
-			offset,
-			length: slice.length,
-			totalLength: full.length,
-			truncated: offset + slice.length < full.length,
-			content: slice
-		}
-	};
+	return [body, "Session attachments are files under the in-memory workspace root. List with workspace_list, read with workspace_read. Do not connect storage backends to find them."].filter(Boolean).join("\n");
 }
 /** Marker field: specialist loop presents image bytes in a follow-up multimodal message. */
 var IMAGE_PRESENT_KEY = "_presentImage";
-function readImageAttachment(stored, opts = {}) {
-	if (stored.kind !== "image") return {
-		ok: false,
-		error: `${stored.name} is not an image attachment`
-	};
-	if (stored.text != null && isSvgAttachment(stored)) return readTextAttachment(stored, opts);
-	if (!stored.dataUrl) return {
-		ok: false,
-		error: `${stored.name} has no image payload`
-	};
-	const present = resolveMediaType({
-		name: stored.name,
-		mime: stored.mime
-	})?.vision !== false;
-	return {
-		ok: true,
-		output: {
-			...attachmentMeta(stored),
-			...present ? {
-				[IMAGE_PRESENT_KEY]: true,
-				dataUrl: stored.dataUrl,
-				note: "Image bytes will be provided to the model in the next message for vision inspection."
-			} : {
-				dataUrlOmitted: true,
-				note: "This media type is stored for preview; vision presentation is skipped. Ask for a raster export if needed."
-			}
-		}
-	};
-}
 function stripAttachmentToolOutput(output) {
 	if (!output || typeof output !== "object") return output;
 	const copy = { ...output };
@@ -1608,107 +1413,579 @@ async function readPromptAttachmentFromFile(file) {
 			byteLength: file.size,
 			truncated
 		}
-	};
+	};
+}
+//#endregion
+//#region src/runtime/tools/workspace-path-qualify.ts
+function isInMemoryToolPath(path) {
+	return path === "in-memory" || path.startsWith(`in-memory/`);
+}
+function isWorkspaceRootPath(path) {
+	const trimmed = path.trim();
+	return !trimmed || trimmed === "." || trimmed === "/";
+}
+/** First path segment — composite roots are keyed by this name. */
+function firstPathSegment(path) {
+	return path.split("/").filter(Boolean)[0] ?? "";
+}
+function pathHasKnownRoot(path, rootNames) {
+	const first = firstPathSegment(path);
+	if (!first) return false;
+	return (rootNames instanceof Set ? rootNames : new Set(rootNames)).has(first);
+}
+function joinUnderRoot(rootPath, relativePath) {
+	const root = rootPath.replace(/\/+$/, "");
+	const relative = relativePath.replace(/^\/+/, "");
+	if (!root) return relative;
+	if (!relative) return root;
+	return `${root}/${relative}`;
+}
+/**
+* Decide how to qualify a workspace tool path that is missing a connected-root prefix.
+*/
+function decideRootQualification(path, durableRoots, mode) {
+	if (isInMemoryToolPath(path) || isWorkspaceRootPath(path)) return { action: "keep" };
+	if (pathHasKnownRoot(path, durableRoots)) return { action: "keep" };
+	if (durableRoots.length === 1) return {
+		action: "prefix",
+		root: durableRoots[0]
+	};
+	if (durableRoots.length === 0) return {
+		action: "error",
+		error: mode === "write" ? "No durable workspace folder connected. Connect a folder before writing, or use an in-memory/… path." : "No workspace folder connected."
+	};
+	if (mode === "write") return { action: "pick" };
+	return {
+		action: "error",
+		error: `Path must start with a workspace root (${durableRoots.join(", ")}). Example: ${durableRoots[0]}/${path}`
+	};
+}
+//#endregion
+//#region src/runtime/tools/workspace-path.ts
+/**
+* Ensure tool paths are under a composite workspace root.
+* - Already rooted / in-memory / empty → unchanged
+* - One durable root → auto-prefix
+* - Several durable roots (writes) → folder picker dialog
+*/
+async function qualifyWorkspaceToolPath(rawPath, mode = "write") {
+	const path = toWorkspaceToolPath(String(rawPath ?? ""));
+	if (isInMemoryToolPath(path) || isWorkspaceRootPath(path)) return {
+		ok: true,
+		path
+	};
+	const folders = await workspaceService.getFolders();
+	const allNames = folders.map((f) => f.name);
+	if (pathHasKnownRoot(path, allNames)) return {
+		ok: true,
+		path
+	};
+	const durableRoots = folders.filter((f) => f.type !== "in-memory").map((f) => f.name);
+	const decision = decideRootQualification(path, mode === "write" ? durableRoots : allNames.length ? allNames : durableRoots, mode);
+	if (decision.action === "keep") return {
+		ok: true,
+		path
+	};
+	if (decision.action === "prefix") return {
+		ok: true,
+		path: joinUnderRoot(decision.root, path),
+		resolvedFrom: path
+	};
+	if (decision.action === "error") return {
+		ok: false,
+		error: decision.error
+	};
+	const chosen = await filebrowserDialog("directory");
+	if (!chosen) return {
+		ok: false,
+		error: "Write cancelled: no workspace folder selected."
+	};
+	return {
+		ok: true,
+		path: joinUnderRoot(chosen, path),
+		resolvedFrom: path
+	};
+}
+//#endregion
+//#region src/runtime/tools/workspace-adapter.ts
+function asRecord$1(value) {
+	return value && typeof value === "object" ? value : {};
+}
+/** Some File backends (e.g. in-memory) expose mime; the abstract File does not. */
+function optionalMimeType(resource) {
+	const getMimeType = resource.getMimeType;
+	return typeof getMimeType === "function" ? getMimeType.call(resource) : void 0;
+}
+function fileNameFromPath(path) {
+	const parts = path.split("/").filter(Boolean);
+	return parts[parts.length - 1] || path;
+}
+/** Resolve a tool path against the shared in-memory root or the mounted workspace. */
+async function resolveResource(path, options) {
+	if (isInMemoryToolPath(path)) {
+		const root = getInMemoryRoot();
+		const relative = path === IN_MEMORY_ROOT_NAME ? "" : path.slice(`${IN_MEMORY_ROOT_NAME}/`.length);
+		if (!relative) return {
+			resource: root,
+			path: IN_MEMORY_ROOT_NAME
+		};
+		const lookup = options?.directory && !relative.endsWith("/") ? `${relative}/` : relative;
+		return {
+			resource: await root.getResource(lookup, options?.create ? { create: true } : void 0),
+			path
+		};
+	}
+	const workspace = await workspaceService.getWorkspace();
+	if (!workspace) return {
+		resource: null,
+		path
+	};
+	if (isWorkspaceRootPath(path)) return {
+		resource: workspace,
+		path: ""
+	};
+	const lookup = options?.directory && !path.endsWith("/") ? `${path}/` : path;
+	return {
+		resource: await workspace.getResource(lookup, options?.create ? { create: true } : void 0),
+		path
+	};
+}
+/**
+* Present image-like workspace files for vision (data URLs or known image extensions).
+* Returns null when the file should be treated as ordinary text.
+*/
+function visionToolOutput(path, contents, mimeHint) {
+	const name = fileNameFromPath(path);
+	const dataUrl = typeof contents === "string" && contents.startsWith("data:image/") ? contents : void 0;
+	const mime = mimeHint || (dataUrl ? dataUrl.slice(5, dataUrl.indexOf(";")) : void 0) || resolveMediaType({
+		name,
+		mime: mimeHint
+	})?.mime;
+	if (isSvgAttachment({
+		name,
+		mime,
+		text: dataUrl ? void 0 : contents
+	})) return null;
+	const media = resolveMediaType({
+		name,
+		mime
+	});
+	if (!dataUrl && media?.mode !== "raster") return null;
+	if (!dataUrl) return null;
+	return {
+		path,
+		name,
+		mime,
+		kind: "image",
+		...media?.vision !== false ? {
+			[IMAGE_PRESENT_KEY]: true,
+			dataUrl,
+			note: "Image bytes will be provided to the model in the next message for vision inspection."
+		} : {
+			dataUrlOmitted: true,
+			note: "This media type is stored for preview; vision presentation is skipped."
+		}
+	};
+}
+/** Registers built-in workspace file tools (paths may use in-memory:// URI form). */
+function registerWorkspaceTools(broker) {
+	broker.register({
+		name: "workspace_list",
+		description: "List children of a workspace directory. Omit path (or use \"\" / \"/\") for connected roots (use those path prefixes for writes). in-memory/… works without mounting.",
+		parameters: {
+			type: "object",
+			properties: { path: {
+				type: "string",
+				description: "Directory path under a connected root (empty = list roots). in-memory://… URIs are accepted."
+			} },
+			required: []
+		}
+	}, async (call) => {
+		try {
+			const path = toWorkspaceToolPath(String(call.arguments.path ?? ""));
+			const { resource } = await resolveResource(path, { directory: true });
+			if (!(resource instanceof Directory)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a directory" : "No workspace / not a directory"
+			};
+			const children = await resource.listChildren(true);
+			return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: children.map((c) => ({
+					name: c.getName(),
+					path: c.getWorkspacePath(),
+					kind: c instanceof Directory ? "directory" : "file"
+				}))
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	});
+	broker.register({
+		name: "workspace_read",
+		description: "Read a workspace file as text. Paths should be root/… from workspace_list; a bare name is auto-rooted when only one folder is connected. Image data-URL files are presented for vision.",
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "File path under a connected root (e.g. tests/readme.md)."
+				},
+				offset: {
+					type: "number",
+					description: "Text start offset"
+				},
+				limit: {
+					type: "number",
+					description: "Max text characters to return"
+				}
+			},
+			required: ["path"]
+		}
+	}, async (call) => {
+		try {
+			const qualified = await qualifyWorkspaceToolPath(String(call.arguments.path ?? ""), "read");
+			if (!qualified.ok) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: qualified.error
+			};
+			const path = qualified.path;
+			const { resource } = await resolveResource(path);
+			if (!(resource instanceof File)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a file" : "No workspace / not a file"
+			};
+			const contents = await resource.getContents();
+			const text = typeof contents === "string" ? contents : String(contents ?? "");
+			const vision = visionToolOutput(path, text, optionalMimeType(resource));
+			if (vision) return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: vision
+			};
+			const offset = typeof call.arguments.offset === "number" ? Math.max(0, call.arguments.offset) : 0;
+			const limit = typeof call.arguments.limit === "number" ? Math.max(1, call.arguments.limit) : void 0;
+			if (offset || limit != null) {
+				const slice = text.slice(offset, limit != null ? offset + limit : void 0);
+				return {
+					id: call.id,
+					name: call.name,
+					ok: true,
+					output: {
+						path,
+						offset,
+						length: slice.length,
+						totalLength: text.length,
+						truncated: offset + slice.length < text.length,
+						content: slice
+					}
+				};
+			}
+			return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: text
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	});
+	broker.register({
+		name: "workspace_write",
+		description: "Write text to a workspace file (creates parents as needed). Prefer root/… paths from workspace_list. A bare filename uses the only durable root, or opens a folder picker when several roots are connected.",
+		parameters: {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "File path under a connected root (e.g. tests/demo.canvas.js)."
+				},
+				contents: { type: "string" }
+			},
+			required: ["path", "contents"]
+		}
+	}, async (call) => {
+		try {
+			const args = asRecord$1(call.arguments);
+			const qualified = await qualifyWorkspaceToolPath(String(args.path ?? ""), "write");
+			if (!qualified.ok) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: qualified.error,
+				mutating: true
+			};
+			const path = qualified.path;
+			const contents = String(args.contents ?? "");
+			const { resource } = await resolveResource(path, { create: true });
+			if (!(resource instanceof File)) return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: isInMemoryToolPath(path) ? "Not a file" : "No workspace / not a file",
+				mutating: true
+			};
+			await resource.saveContents(contents);
+			return {
+				id: call.id,
+				name: call.name,
+				ok: true,
+				output: {
+					path,
+					...qualified.resolvedFrom ? { resolvedFrom: qualified.resolvedFrom } : {}
+				},
+				mutating: true
+			};
+		} catch (err) {
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: err instanceof Error ? err.message : String(err),
+				mutating: true
+			};
+		}
+	});
 }
 //#endregion
-//#region src/runtime/tools/attachment-adapter.ts
-/** Registers read-only session attachment tools. */
-function registerAttachmentTools(broker, lookup) {
-	broker.register({
-		name: "attachment_list",
-		description: "List chat-session attachments (id, name, kind, mime, size). Use this for files the user attached in chat — not workspace/canvas files. Payloads are omitted; call attachment_read to inspect one.",
-		parameters: {
-			type: "object",
-			properties: {}
-		}
-	}, async (call, sessionId) => {
-		const items = lookup(sessionId).map(attachmentMeta);
-		return {
-			id: call.id,
-			name: call.name,
-			ok: true,
-			output: {
-				count: items.length,
-				attachments: items
-			}
-		};
-	});
+//#region src/runtime/tools/fetch-adapter.ts
+var DEFAULT_MAX_BYTES = 512e3;
+var DEFAULT_MAX_CHARS = 12e4;
+var DEFAULT_TIMEOUT_MS = 2e4;
+function asRecord(value) {
+	return value && typeof value === "object" ? value : {};
+}
+function parseUrl(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return { error: "Missing url" };
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return { error: `Invalid url: ${trimmed}` };
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return { error: `Only http(s) URLs are allowed (got ${parsed.protocol})` };
+	return parsed;
+}
+function isTextualContentType(contentType) {
+	const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+	if (!type) return true;
+	if (type.startsWith("text/")) return true;
+	return type.includes("json") || type.includes("xml") || type.includes("javascript") || type.includes("svg") || type.includes("markdown") || type.includes("yaml") || type.includes("csv");
+}
+/** Registers a read-only HTTP(S) fetch tool for remote documentation and text content. */
+function registerFetchTools(broker) {
 	broker.register({
-		name: "attachment_read",
-		description: "Inspect a chat-session attachment by id from the user message or attachment_list. Prefer this whenever the user asks about an attached screenshot/file. Text returns content (optional offset/limit). Images are presented for vision inspection.",
+		name: "fetch",
+		description: "Fetch a remote http(s) URL and return text content (HTML, Markdown, JSON, etc.). Use for docs and references (e.g. Web Awesome agent skills on jsDelivr). Binary responses return metadata only.",
 		parameters: {
 			type: "object",
 			properties: {
-				id: {
+				url: {
 					type: "string",
-					description: "Attachment id from attachment_list or the user message"
-				},
-				offset: {
-					type: "number",
-					description: "Text start offset (characters)"
+					description: "Absolute http(s) URL to fetch"
 				},
-				limit: {
+				max_chars: {
 					type: "number",
-					description: "Max text characters to return"
+					description: `Max characters of body text to return (default ${DEFAULT_MAX_CHARS})`
 				}
 			},
-			required: ["id"]
+			required: ["url"]
 		}
-	}, async (call, sessionId) => {
-		const id = String(call.arguments.id ?? "").trim();
-		if (!id) return {
-			id: call.id,
-			name: call.name,
-			ok: false,
-			output: null,
-			error: "id is required"
-		};
-		const stored = lookup(sessionId, id)[0];
-		if (!stored) return {
+	}, async (call) => {
+		const args = asRecord(call.arguments);
+		const parsed = parseUrl(String(args.url ?? ""));
+		if ("error" in parsed) return {
 			id: call.id,
 			name: call.name,
 			ok: false,
 			output: null,
-			error: `Unknown attachment: ${id}`
+			error: parsed.error
 		};
-		if (stored.kind === "image") {
-			const result = readImageAttachment(stored, {
-				offset: typeof call.arguments.offset === "number" ? call.arguments.offset : void 0,
-				limit: typeof call.arguments.limit === "number" ? call.arguments.limit : void 0
+		const maxCharsRaw = Number(args.max_chars);
+		const maxChars = Number.isFinite(maxCharsRaw) && maxCharsRaw > 0 ? Math.min(Math.floor(maxCharsRaw), DEFAULT_MAX_CHARS * 2) : DEFAULT_MAX_CHARS;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+		try {
+			const response = await fetch(parsed.href, {
+				method: "GET",
+				redirect: "follow",
+				signal: controller.signal,
+				headers: { Accept: "text/*, application/json, application/xml, */*;q=0.1" }
 			});
-			if (!result.ok) return {
+			const contentType = response.headers.get("content-type") ?? "";
+			const buffer = new Uint8Array(await response.arrayBuffer());
+			const truncatedBytes = buffer.byteLength > DEFAULT_MAX_BYTES;
+			const slice = truncatedBytes ? buffer.subarray(0, DEFAULT_MAX_BYTES) : buffer;
+			if (!isTextualContentType(contentType) && !looksLikeUtf8Text(slice)) return {
 				id: call.id,
 				name: call.name,
-				ok: false,
-				output: null,
-				error: result.error
+				ok: response.ok,
+				output: {
+					url: response.url || parsed.href,
+					status: response.status,
+					contentType,
+					byteLength: buffer.byteLength,
+					binary: true,
+					note: "Response is not text; body omitted. Prefer documentation or raw text URLs."
+				},
+				error: response.ok ? void 0 : `HTTP ${response.status}`
 			};
+			const decoded = new TextDecoder("utf-8", { fatal: false }).decode(slice);
+			const truncatedChars = decoded.length > maxChars;
+			const body = truncatedChars ? decoded.slice(0, maxChars) : decoded;
 			return {
 				id: call.id,
 				name: call.name,
-				ok: true,
-				output: result.output
+				ok: response.ok,
+				output: {
+					url: response.url || parsed.href,
+					status: response.status,
+					contentType,
+					byteLength: buffer.byteLength,
+					truncated: truncatedBytes || truncatedChars,
+					body
+				},
+				error: response.ok ? void 0 : `HTTP ${response.status}`
+			};
+		} catch (err) {
+			const message = err instanceof Error && err.name === "AbortError" ? `Timed out after ${DEFAULT_TIMEOUT_MS}ms` : err instanceof Error ? err.message : String(err);
+			return {
+				id: call.id,
+				name: call.name,
+				ok: false,
+				output: null,
+				error: message
 			};
+		} finally {
+			clearTimeout(timer);
 		}
-		const result = readTextAttachment(stored, {
-			offset: typeof call.arguments.offset === "number" ? call.arguments.offset : void 0,
-			limit: typeof call.arguments.limit === "number" ? call.arguments.limit : void 0
-		});
-		if (!result.ok) return {
-			id: call.id,
-			name: call.name,
-			ok: false,
-			output: null,
-			error: result.error
-		};
-		return {
-			id: call.id,
-			name: call.name,
-			ok: true,
-			output: result.output
-		};
 	});
 }
+function looksLikeUtf8Text(bytes) {
+	if (!bytes.length) return true;
+	const sample = bytes.subarray(0, Math.min(bytes.length, 512));
+	let odd = 0;
+	for (const b of sample) {
+		if (b === 0) return false;
+		if (b < 7 || b > 13 && b < 32) odd += 1;
+	}
+	return odd / sample.length < .1;
+}
+//#endregion
+//#region src/runtime/tools/command-adapter.ts
+/** Commands that must never be exposed as LLM tools (pickers, storage boots, settings). */
+var SKIP = /* @__PURE__ */ new Set([
+	"open_cognitive_ai_settings",
+	"open_ai_config",
+	"load_workspace",
+	"connect_opfs",
+	"connect_indexeddb",
+	"disconnect_workspace",
+	"disconnect_folder",
+	"open_editor",
+	"list_extensions",
+	"enable_extension",
+	"disable_extension"
+]);
+var SKIP_PREFIXES = [
+	"connect_",
+	"disconnect_",
+	"install_",
+	"uninstall_"
+];
+/** Built-in tools that must survive command refresh (not command-backed). */
+var KEEP_TOOLS = /* @__PURE__ */ new Set([
+	"workspace_list",
+	"workspace_read",
+	"workspace_write",
+	"fetch"
+]);
+function sanitizeName(id) {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+function shouldSkipCommand(id) {
+	if (SKIP.has(id)) return true;
+	return SKIP_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+/** Registers Docks commands as first-class LLM tools (tool name = command id). */
+function refreshCommandTools(broker, role) {
+	for (const def of broker.listDefinitions("build")) if (!KEEP_TOOLS.has(def.name)) broker.unregister(def.name);
+	const commands = commandRegistry.listCommands(commandRegistry.createExecutionContext());
+	const entries = Object.values(commands);
+	for (const command of entries) {
+		if (!command?.id || shouldSkipCommand(command.id)) continue;
+		if (!command.description) continue;
+		if ((role === "plan" || role === "explore") && /delete|write|save|rm|mv/i.test(command.id)) continue;
+		const toolName = sanitizeName(command.id);
+		if (KEEP_TOOLS.has(toolName)) continue;
+		const properties = {};
+		const required = [];
+		for (const p of command.parameters ?? []) {
+			properties[p.name] = {
+				type: p.type ?? "string",
+				description: p.description,
+				...p.allowedValues ? { enum: p.allowedValues } : {}
+			};
+			if (p.required) required.push(p.name);
+		}
+		broker.register({
+			name: toolName,
+			description: `${command.name}: ${command.description}`,
+			parameters: {
+				type: "object",
+				properties,
+				required
+			}
+		}, async (call, _sessionId) => {
+			try {
+				const result = await commandRegistry.execute(command.id, { params: call.arguments });
+				return {
+					id: call.id,
+					name: call.name,
+					ok: true,
+					output: result
+				};
+			} catch (err) {
+				return {
+					id: call.id,
+					name: call.name,
+					ok: false,
+					output: null,
+					error: err instanceof Error ? err.message : String(err)
+				};
+			}
+		});
+	}
+}
 //#endregion
 //#region src/runtime/compact/compaction.ts
 var COMPACT_SYSTEM = `You compress older chat turns into a durable summary for future assistant turns.
@@ -2026,7 +2303,7 @@ var SessionRuntime = class {
 //#region src/runtime/specialists/classify-risk.ts
 var CLASSIFY_SYSTEM = `You classify tool calls for user approval.
 Mark risk "critical" if the call can change state: write/edit/delete files, connect or load a workspace, run shell/commands with side effects, install, deploy, publish, push, or otherwise mutate the environment.
-Mark risk "safe" only for read-only inspection (list, read, search, describe).
+Mark risk "safe" only for read-only inspection (list, read, search, describe, fetch).
 When unsure, choose "critical".
 Reply with ONLY a JSON array: [{"id":"<tool call id>","risk":"safe"|"critical"}]`;
 /** Ask the model whether pending tool calls are safe or critical. Unknown → critical. */
@@ -2163,7 +2440,25 @@ async function runSpecialistLoop(input) {
 	};
 	const messages = historyToProviderMessages(input.systemPrompt, input.history, input.compactionSummary);
 	let success = true;
+	let cancelled = false;
+	const usage = {
+		inputTokens: 0,
+		outputTokens: 0
+	};
+	const markCancelled = () => {
+		if (cancelled) return;
+		cancelled = true;
+		success = false;
+		if (!parts.some((p) => p.type === "text")) emit({
+			type: "text",
+			text: "Cancelled."
+		});
+	};
 	for (let iter = 0; iter < MAX_TOOL_ITERATIONS; iter++) {
+		if (isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
 		input.refreshTools?.();
 		const tools = input.broker.listDefinitions(input.role);
 		let pendingTools = [];
@@ -2175,6 +2470,7 @@ async function runSpecialistLoop(input) {
 			providerOptions: input.resolved.providerOptions,
 			signal: input.signal
 		})) {
+			if (isAborted(input.signal)) break;
 			if (chunk.type === "error") {
 				emit({
 					type: "text",
@@ -2183,6 +2479,10 @@ async function runSpecialistLoop(input) {
 				success = false;
 				break;
 			}
+			if (chunk.type === "usage" && chunk.usage) {
+				usage.inputTokens += chunk.usage.inputTokens;
+				usage.outputTokens += chunk.usage.outputTokens;
+			}
 			if (chunk.type === "reasoning" && chunk.text) emit({
 				type: "reasoning",
 				text: chunk.text,
@@ -2203,6 +2503,10 @@ async function runSpecialistLoop(input) {
 				} else pendingTools.push({ ...chunk.toolCall });
 			}
 		}
+		if (isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
 		if (!pendingTools.length) {
 			if (assistantText && !parts.some((p) => p.type === "text")) emit({
 				type: "text",
@@ -2229,7 +2533,12 @@ async function runSpecialistLoop(input) {
 			})),
 			signal: input.signal
 		}) : null;
+		const pendingImages = [];
 		for (const tool of pendingTools) {
+			if (isAborted(input.signal)) {
+				markCancelled();
+				break;
+			}
 			let args = {};
 			try {
 				args = tool.arguments ? JSON.parse(tool.arguments) : {};
@@ -2267,26 +2576,30 @@ async function runSpecialistLoop(input) {
 				name: tool.name,
 				content: JSON.stringify(presentImage ? {
 					...safeOutput ?? {},
-					note: "Image bytes follow in the next user message for vision inspection."
+					note: "Image bytes follow after all tool results for vision inspection."
 				} : safeOutput)
 			});
-			if (presentImage) {
-				const dataUrl = String(rawOutput.dataUrl);
-				const name = String(rawOutput.name ?? "image");
-				const id = String(rawOutput.id ?? "");
-				messages.push({
-					role: "user",
-					content: [{
-						type: "text",
-						text: `Attachment image for inspection: id=${id} name="${name}"`
-					}, {
-						type: "image_url",
-						image_url: { url: dataUrl }
-					}]
-				});
-			}
+			if (presentImage) pendingImages.push({
+				id: String(rawOutput.id ?? ""),
+				name: String(rawOutput.name ?? "image"),
+				dataUrl: String(rawOutput.dataUrl)
+			});
 			if (!result.ok) success = false;
 		}
+		if (cancelled || isAborted(input.signal)) {
+			markCancelled();
+			break;
+		}
+		if (pendingImages.length) messages.push({
+			role: "user",
+			content: [{
+				type: "text",
+				text: pendingImages.length === 1 ? `Attachment image for inspection: id=${pendingImages[0].id} name="${pendingImages[0].name}"` : `Attachment images for inspection:\n${pendingImages.map((img) => `- id=${img.id} name="${img.name}"`).join("\n")}`
+			}, ...pendingImages.map((img) => ({
+				type: "image_url",
+				image_url: { url: img.dataUrl }
+			}))]
+		});
 	}
 	return {
 		message: {
@@ -2295,7 +2608,8 @@ async function runSpecialistLoop(input) {
 			parts: coalesceParts(parts),
 			createdAt: Date.now(),
 			routedModel: input.resolved.model,
-			effort: input.resolved.effort
+			effort: input.resolved.effort,
+			...usage.inputTokens > 0 || usage.outputTokens > 0 ? { usage } : {}
 		},
 		success
 	};
@@ -2325,7 +2639,14 @@ function coalesceParts(parts) {
 //#endregion
 //#region src/runtime/specialists/index.ts
 function systemPromptFor(role, goal, opts = {}) {
-	const preamble = `You are a specialist in the Eclipse Docks AI runtime. Prefer tools for file and command actions. Be concise. ${opts.hasAttachments ? "This turn publishes session attachments. To inspect them, call attachment_read with the attachment id from the user message (attachment_list if you need ids). Do not open canvases, editors, workspaces, or unrelated commands to find attachment contents — they are not workspace files." : "When the user publishes attachments, use attachment_list / attachment_read to inspect them — do not assume their contents are already in the transcript."}`;
+	const preamble = `You are a specialist in the Eclipse Docks AI runtime. Prefer tools for file and command actions. Be concise. After tools finish, write a short human-friendly final reply (what you did and the outcome). Do not paste tool arguments, stdout, JSON, or command logs — those already appear in the UI details panel. ${opts.hasAttachments ? [
+		"This turn publishes session attachments under the shared in-memory root (in-memory/<sessionId>/… or in-memory://<sessionId>/…).",
+		"Read them with workspace_read / workspace_list — in-memory paths work without mounting that root into the workspace tree.",
+		"Do not call load_workspace / connect_opfs / connect_indexeddb to find attachments.",
+		"Canvas from a screenshot: skills.load eclipse-docks-canvas → workspace_read the attachment path → workspace_write a .canvas.js (into a durable workspace folder) → canvas.open / canvas.apply_source.",
+		"Qualify durable writes as <root>/<file> using a root from workspace_list (e.g. tests/demo.canvas.js); bare filenames are auto-rooted when a single durable folder is connected, otherwise a folder picker appears.",
+		"If no durable workspace folder is connected for writing canvases, say so and stop."
+	].join(" ") : "Session attachments live under the shared in-memory root and are readable via workspace_read / workspace_list."} Workspace paths use a connected root prefix from workspace_list (never write bare names at the composite root unless a single durable folder can auto-qualify them). For specialized workflows (e.g. canvas.js), call skills.list to discover registered skills, then skills.load with the matching name before following those instructions.`;
 	switch (role) {
 		case "plan": return `${preamble}\nMode: PLAN (read-only). Analyze and propose a plan for: ${goal}`;
 		case "explore": return `${preamble}\nMode: EXPLORE (read-only). Search and report findings for: ${goal}`;
@@ -2417,6 +2738,13 @@ function estimateSessionContextUsage(session, modelRef) {
 	}
 	const used = buckets.reduce((sum, b) => sum + b.tokens, 0);
 	const percent = limit > 0 ? Math.min(100, used / limit * 100) : 0;
+	let inputTokens = 0;
+	let outputTokens = 0;
+	for (const message of session?.history ?? []) {
+		if (!message.usage) continue;
+		inputTokens += message.usage.inputTokens;
+		outputTokens += message.usage.outputTokens;
+	}
 	return {
 		used,
 		limit,
@@ -2424,7 +2752,9 @@ function estimateSessionContextUsage(session, modelRef) {
 		remaining: Math.max(0, limit - used),
 		level: contextUsageLevel(percent),
 		buckets: buckets.filter((b) => b.tokens > 0),
-		modelRef
+		modelRef,
+		inputTokens,
+		outputTokens
 	};
 }
 function formatTokenCount(n) {
@@ -2453,6 +2783,184 @@ function formatBucketDetail(bucket) {
 	return `${bucket.count} · ${tokens}`;
 }
 //#endregion
+//#region src/runtime/session-workspace.ts
+function attachmentContents(stored) {
+	if (stored.kind === "image") {
+		if (stored.dataUrl) return stored.dataUrl;
+		if (stored.text) return stored.text;
+	}
+	return stored.text ?? "";
+}
+/** Build live-file callbacks that always re-read via the caller-provided resolver. */
+function attachmentLiveContents(resolve) {
+	return {
+		get mimeType() {
+			return resolve()?.mime;
+		},
+		getContents() {
+			const stored = resolve();
+			if (!stored) throw new Error("Attachment payload is no longer available");
+			return attachmentContents(stored);
+		},
+		size() {
+			const stored = resolve();
+			if (!stored) return null;
+			if (stored.byteLength != null) return stored.byteLength;
+			return attachmentContents(stored).length;
+		}
+	};
+}
+/** Relative path under the shared in-memory root (`<sessionId>/<file>`). */
+function relativeAttachmentPath(sessionId, stored) {
+	return attachmentWorkspacePath(sessionId, stored).slice(`${IN_MEMORY_ROOT_NAME}/`.length);
+}
+/**
+* Publish a live file node. Payload is resolved only through `resolve` — nothing is copied.
+*/
+async function syncAttachmentToWorkspace(sessionId, stored, resolve) {
+	const root = getInMemoryRoot();
+	const relative = relativeAttachmentPath(sessionId, stored);
+	root.writeLiveFile(relative, attachmentLiveContents(resolve));
+	return attachmentWorkspacePath(sessionId, stored);
+}
+async function syncAttachmentsToWorkspace(sessionId, attachments, resolveById) {
+	for (const attachment of attachments) await syncAttachmentToWorkspace(sessionId, attachment, () => resolveById(attachment.id));
+}
+async function removeAttachmentFromWorkspace(sessionId, stored) {
+	const root = getInMemoryRoot();
+	const relative = relativeAttachmentPath(sessionId, stored);
+	const resource = await root.getResource(relative);
+	if (resource) await resource.delete();
+}
+async function removeSessionWorkspaceFolder(sessionId) {
+	const dir = await getInMemoryRoot().getResource(sessionId);
+	if (dir instanceof Directory) await dir.delete();
+}
+/**
+* Restrict the workspace-mounted in-memory view to a single folder name (active session).
+* Pass `null` to show the full tree again.
+*/
+function projectInMemoryMountToFolder(folderName) {
+	if (!folderName) {
+		setInMemoryMountProjection(null);
+		return;
+	}
+	const name = folderName;
+	setInMemoryMountProjection({
+		async listChildren(root) {
+			return [root.ensureDirectoryEntry(name)];
+		},
+		async getResource(root, path, options) {
+			const segments = path.split("/").filter((s) => s.trim());
+			if (segments[0] !== name) return null;
+			if (segments.length === 1 && (path.endsWith("/") || path === name)) return root.ensureDirectoryEntry(name);
+			return root.getResource(path, options);
+		}
+	});
+}
+//#endregion
+//#region src/runtime/skills-parse.ts
+/**
+* Parse a SKILL.md document (YAML frontmatter + markdown body).
+* Compatible with Cursor Agent Skills layout.
+*/
+function parseSkillMarkdown(raw) {
+	const text = raw.replace(/^\uFEFF/, "");
+	const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+	if (!match) return {
+		name: "",
+		description: "",
+		body: text.trim()
+	};
+	const front = match[1] ?? "";
+	const body = (match[2] ?? "").trim();
+	return {
+		name: readFrontmatterString(front, "name"),
+		description: readFrontmatterString(front, "description"),
+		body
+	};
+}
+/** Short ambient prompt block (uses skill description). */
+function formatSkillForPrompt(skill) {
+	const description = skill.description.trim();
+	if (!description) return skill.body.trim();
+	return description;
+}
+function readFrontmatterString(front, key) {
+	const folded = front.match(new RegExp(`^${key}:\\s*>-\\s*\\r?\\n((?:[ \\t]+.*\\r?\\n?)*)`, "m"));
+	if (folded?.[1]) return folded[1].split(/\r?\n/).map((line) => line.replace(/^[ \t]+/, "").trimEnd()).filter((line, index, all) => line.length > 0 || index < all.length - 1).join(" ").replace(/\s+/g, " ").trim();
+	const quoted = front.match(new RegExp(`^${key}:\\s*[\"']([\\s\\S]*?)[\"']\\s*$`, "m"));
+	if (quoted?.[1]) return quoted[1].replace(/\s+/g, " ").trim();
+	return front.match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim() ?? "";
+}
+//#endregion
+//#region src/runtime/skills-types.ts
+function isSkillContribution(value) {
+	if (!value || typeof value !== "object") return false;
+	const skill = value;
+	const hasBody = typeof skill.body === "string";
+	const hasLoad = typeof skill.load === "function";
+	return typeof skill.name === "string" && skill.name.length > 0 && typeof skill.label === "string" && (hasBody || hasLoad);
+}
+//#endregion
+//#region src/runtime/skills-resolve.ts
+function rawFromLoadResult(result) {
+	if (typeof result === "string") return result;
+	return typeof result?.default === "string" ? result.default : "";
+}
+async function readSkillRaw(skill) {
+	if (typeof skill.body === "string" && skill.body.trim()) return skill.body.replace(/^\uFEFF/, "");
+	if (!skill.load) return "";
+	return rawFromLoadResult(await skill.load()).replace(/^\uFEFF/, "");
+}
+/**
+* Resolve SKILL.md (eager `body` or lazy `load`) into name/description/body.
+* Frontmatter wins for description unless the contribution sets an explicit override.
+*/
+async function resolveSkill(skill) {
+	const raw = (await readSkillRaw(skill)).trim();
+	const parsed = raw ? parseSkillMarkdown(raw) : {
+		name: "",
+		description: "",
+		body: ""
+	};
+	return {
+		name: skill.name || parsed.name,
+		label: skill.label || parsed.name || skill.name,
+		description: (skill.description ?? parsed.description).trim(),
+		body: parsed.body.trim() || (raw && !parsed.description && !parsed.name ? raw : "")
+	};
+}
+/** @deprecated Prefer {@link resolveSkill}; kept for callers that only need the body. */
+async function resolveSkillBody(skill) {
+	return (await resolveSkill(skill)).body;
+}
+//#endregion
+//#region src/runtime/skills.ts
+/** Contribution slot for AI agent skills (Cursor-compatible SKILL.md content). */
+var SYSTEM_SKILLS = "system.skills";
+function listSkillContributions() {
+	return contributionRegistry.getContributions(SYSTEM_SKILLS).filter(isSkillContribution);
+}
+/** Register a SKILL.md document on {@link SYSTEM_SKILLS}. Returns an unregister function. */
+function registerSkillMarkdown(raw, opts) {
+	const parsed = parseSkillMarkdown(raw);
+	const name = (opts?.name || parsed.name || `skill-${Date.now()}`).trim();
+	const contribution = {
+		name,
+		label: opts?.label || parsed.name || name,
+		body: (opts?.body || raw).trim(),
+		ranking: opts?.ranking,
+		icon: opts?.icon,
+		relevant: opts?.relevant,
+		load: opts?.load,
+		description: opts?.description
+	};
+	if (!contribution.body && !contribution.load) return () => void 0;
+	contributionRegistry.registerContribution(SYSTEM_SKILLS, contribution);
+	return () => contributionRegistry.unregisterContribution(SYSTEM_SKILLS, name);
+}
+//#endregion
 //#region src/runtime/cognitive-runtime.ts
 var PERSIST_KEY = "cognitive/v1/state";
 /** Auto-compact after a turn when live history exceeds this many messages. */
@@ -2487,12 +2995,7 @@ var CognitiveRuntime = class {
 			emit: false
 		});
 		registerWorkspaceTools(this.tools);
-		registerAttachmentTools(this.tools, (sessionId, attachmentId) => {
-			const list = this.sessions.get(sessionId)?.attachments ?? [];
-			if (!attachmentId) return list;
-			const found = list.find((a) => a.id === attachmentId);
-			return found ? [found] : [];
-		});
+		registerFetchTools(this.tools);
 		this.tools.setApprovalMode(this.approvalMode);
 		this.tools.setPermissionHandler(async (req) => this.requestPermission(req));
 		this.ready = this.hydrateAll();
@@ -2548,13 +3051,23 @@ var CognitiveRuntime = class {
 			this.promptEnhancers = this.promptEnhancers.filter((e) => e !== enhancer);
 		};
 	}
+	/**
+	* Register a Cursor-compatible SKILL.md document on {@link SYSTEM_SKILLS}.
+	* Relevant skills are selected into the specialist prompt each turn.
+	*/
+	addSkillMarkdown(raw) {
+		return registerSkillMarkdown(raw);
+	}
 	/** First catalog model for the default provider — used by Manual routing. */
 	defaultModelId() {
 		const catalog = catalogFromSettings(this.providersSettings);
 		return catalog.find((e) => e.providerId === this.providersSettings.defaultProviderId)?.id ?? catalog[0]?.id ?? "openai/gpt-4o-mini";
 	}
 	setModelPolicy(policy) {
-		this.policy = policy;
+		const next = normalizeModelPolicy(policy) ?? this.policy;
+		if (sameModelPolicy(this.policy, next)) return;
+		this.policy = next;
+		this.persist();
 	}
 	getModelPolicy() {
 		return this.policy;
@@ -2616,28 +3129,46 @@ var CognitiveRuntime = class {
 		if (focused) return focused.id;
 		return this.sessions.createSession().id;
 	}
-	/** Store attachment payloads on the session (not inlined into history until prompt). */
-	addAttachments(sessionId, attachments) {
+	/** Store attachment payloads on the session and mirror them into in-memory/<sessionId>/. */
+	async addAttachments(sessionId, attachments) {
 		const id = this.ensureSessionId(sessionId);
 		const session = this.sessions.get(id);
 		if (!session || !attachments.length) return [];
 		const room = Math.max(0, 8 - (session.attachments?.length ?? 0));
-		const accepted = attachments.slice(0, room).map((attachment) => toSessionAttachment(attachment));
+		const accepted = attachments.slice(0, room).map((attachment) => {
+			const stored = toSessionAttachment(attachment);
+			return {
+				...stored,
+				path: attachmentUri(id, stored)
+			};
+		});
 		if (!accepted.length) return [];
 		this.sessions.update(id, { attachments: [...session.attachments ?? [], ...accepted] });
 		this.commitSessions();
+		await this.mirrorAttachments(id, accepted).catch(() => void 0);
 		return accepted;
 	}
-	/** Remove an attachment payload from the session store. */
+	/** Remove an attachment payload from the session store and in-memory workspace. */
 	removeAttachment(sessionId, attachmentId) {
 		const session = this.sessions.get(sessionId);
 		if (!session) return false;
+		const removed = (session.attachments ?? []).find((a) => a.id === attachmentId);
 		const next = (session.attachments ?? []).filter((a) => a.id !== attachmentId);
 		if (next.length === (session.attachments?.length ?? 0)) return false;
 		this.sessions.update(sessionId, { attachments: next });
 		this.commitSessions();
+		if (removed) removeAttachmentFromWorkspace(sessionId, removed);
 		return true;
 	}
+	/** Drop a session and its in-memory attachment folder. */
+	removeSession(sessionId) {
+		const ok = this.sessions.remove(sessionId);
+		if (ok) {
+			removeSessionWorkspaceFolder(sessionId);
+			this.commitSessions();
+		}
+		return ok;
+	}
 	/**
 	* Compact a session: drop older turns, store a summary (LLM when possible),
 	* and persist. The summary is injected into later model calls.
@@ -2681,8 +3212,17 @@ var CognitiveRuntime = class {
 		const session = (input.sessionId ? this.sessions.get(input.sessionId) : this.sessions.focused()) ?? this.sessions.createSession();
 		const text = input.text.trim();
 		const messageId = `msg-${Date.now()}-u`;
-		const fresh = (input.attachments ?? []).slice(0, 8).map((attachment) => toSessionAttachment(attachment, { messageId }));
-		if (fresh.length) this.sessions.update(session.id, { attachments: [...this.sessions.get(session.id)?.attachments ?? [], ...fresh] });
+		const fresh = (input.attachments ?? []).slice(0, 8).map((attachment) => {
+			const stored = toSessionAttachment(attachment, { messageId });
+			return {
+				...stored,
+				path: attachmentUri(session.id, stored)
+			};
+		});
+		if (fresh.length) {
+			this.sessions.update(session.id, { attachments: [...this.sessions.get(session.id)?.attachments ?? [], ...fresh] });
+			await this.mirrorAttachments(session.id, fresh);
+		}
 		const existingIds = (input.attachmentIds ?? []).filter(Boolean);
 		const stored = this.sessions.get(session.id)?.attachments ?? [];
 		const byId = new Map(stored.map((a) => [a.id, a]));
@@ -2693,12 +3233,16 @@ var CognitiveRuntime = class {
 			if (found && !published.some((p) => p.id === found.id)) published.push(found);
 		}
 		if (!text && !published.length) throw new Error("Prompt requires text or at least one attachment");
+		if (published.length) await this.mirrorAttachments(session.id, published).catch(() => void 0);
 		const parts = [];
 		if (text) parts.push({
 			type: "text",
 			text
 		});
-		for (const item of published) parts.push(toFileRefPart(item));
+		for (const item of published) parts.push(toFileRefPart({
+			...item,
+			path: item.path || attachmentUri(session.id, item)
+		}));
 		const promptSummary = summarizePrompt(text, published.map((a) => ({
 			name: a.name,
 			kind: a.kind
@@ -2736,6 +3280,7 @@ var CognitiveRuntime = class {
 			buffers: tick.buffers,
 			status: "running"
 		});
+		this.emitSessions();
 		this.events.publish(TOPIC.coreTick, {
 			valenceDelta: tick.valenceDelta,
 			intent: tick.intent,
@@ -2802,7 +3347,7 @@ var CognitiveRuntime = class {
 			sessionId: session.id,
 			activation: .7
 		});
-		if ((this.sessions.get(session.id)?.history.length ?? 0) > AUTO_COMPACT_AFTER) await this.compactSession(session.id, COMPACT_KEEP_COUNT, input.signal);
+		if (!Boolean(input.signal?.aborted) && (this.sessions.get(session.id)?.history.length ?? 0) > AUTO_COMPACT_AFTER) await this.compactSession(session.id, COMPACT_KEEP_COUNT, input.signal);
 		this.sessions.update(session.id, { status: "idle" });
 		this.events.publish(TOPIC.messageDone, {
 			sessionId: session.id,
@@ -2863,11 +3408,17 @@ var CognitiveRuntime = class {
 		});
 	}
 	emitSessions() {
+		const focusedId = this.sessions.focused()?.id ?? null;
+		projectInMemoryMountToFolder(focusedId);
 		this.events.publish(TOPIC.sessionChanged, {
 			sessions: this.sessions.list(),
-			focusedId: this.sessions.focused()?.id ?? null
+			focusedId
 		});
 	}
+	/** Live in-memory file refs that resolve payloads from the session store. */
+	mirrorAttachments(sessionId, attachments) {
+		return syncAttachmentsToWorkspace(sessionId, attachments, (attachmentId) => this.sessions.get(sessionId)?.attachments?.find((a) => a.id === attachmentId));
+	}
 	async hydrateAll() {
 		await loadModelsCatalog().catch(() => void 0);
 		await this.hydrateProviders();
@@ -2879,6 +3430,16 @@ var CognitiveRuntime = class {
 		if (!this.sessions.list().length) this.sessions.createSession({ title: "Chat" });
 		const mostRecent = this.sessions.list()[0];
 		if (mostRecent) this.sessions.focus(mostRecent.id);
+		for (const session of this.sessions.list()) {
+			const list = session.attachments ?? [];
+			if (!list.length) continue;
+			const stamped = list.map((a) => a.path ? a : {
+				...a,
+				path: attachmentUri(session.id, a)
+			});
+			if (stamped.some((a, i) => a.path !== list[i]?.path)) this.sessions.update(session.id, { attachments: stamped });
+			await this.mirrorAttachments(session.id, stamped).catch(() => void 0);
+		}
 		this.emitSessions();
 	}
 	async hydrateProviders() {
@@ -2906,6 +3467,8 @@ var CognitiveRuntime = class {
 				this.approvalMode = saved.approvalMode;
 				this.tools.setApprovalMode(saved.approvalMode);
 			}
+			const policy = normalizeModelPolicy(saved.modelPolicy);
+			if (policy) this.policy = policy;
 		} catch {}
 	}
 	async persist() {
@@ -2913,7 +3476,8 @@ var CognitiveRuntime = class {
 			await persistenceService.persistObject(PERSIST_KEY, {
 				sessions: this.sessions.snapshot(),
 				memory: this.memory.snapshot(),
-				approvalMode: this.approvalMode
+				approvalMode: this.approvalMode,
+				modelPolicy: this.policy
 			});
 		} catch {}
 	}
@@ -2921,6 +3485,32 @@ var CognitiveRuntime = class {
 function isToolApprovalMode(value) {
 	return value === "manual" || value === "auto_safe" || value === "auto_all";
 }
+function isOptimizeFor(value) {
+	return value === "cost" || value === "balance" || value === "intelligence";
+}
+function isEffortOrAuto(value) {
+	return value === "auto" || value === "none" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
+function normalizeModelPolicy(value) {
+	if (!value || typeof value !== "object") return null;
+	const raw = value;
+	if (raw.mode === "auto" && isOptimizeFor(raw.optimizeFor)) return {
+		mode: "auto",
+		optimizeFor: raw.optimizeFor
+	};
+	if (raw.mode === "manual" && typeof raw.model === "string" && raw.model.trim()) return {
+		mode: "manual",
+		model: raw.model.trim(),
+		...isEffortOrAuto(raw.effort) ? { effort: raw.effort } : {}
+	};
+	return null;
+}
+function sameModelPolicy(a, b) {
+	if (a.mode !== b.mode) return false;
+	if (a.mode === "auto" && b.mode === "auto") return a.optimizeFor === b.optimizeFor;
+	if (a.mode === "manual" && b.mode === "manual") return a.model === b.model && (a.effort ?? "auto") === (b.effort ?? "auto");
+	return false;
+}
 function externalCatalogEntry(id, providerId) {
 	return {
 		id,
@@ -2947,6 +3537,57 @@ function summarizePrompt(text, attachments) {
 	return `Attached ${attachments.map((a) => a.name).join(", ")}`;
 }
 //#endregion
-export { AI_SETTINGS_KEY as _, formatContextPercent as a, TOPIC as b, readPromptAttachmentFromFile as c, defaultProvidersSettings as d, listConfiguredModelIds as f, AI_SETTINGS_EDITOR_ID as g, loadModelsCatalog as h, formatBucketDetail as i, OpenAICompatibleProvider as l, detectEffortCapability as m, cognitiveRuntime as n, formatTokenCount as o, parseModelIds as p, estimateSessionContextUsage as r, ATTACHMENT_FILE_ACCEPT as s, CognitiveRuntime as t, fetchOpenAICompatibleModels as u, AI_VIEW_NAME as v, OPEN_AI_SETTINGS_COMMAND as y };
+//#region src/runtime/skills-commands.ts
+/** Register skills.list / skills.load as Docks commands (also exposed as LLM tools). */
+function registerSkillCommands() {
+	registerAll({
+		command: {
+			id: "skills.list",
+			name: "List skills",
+			description: "List registered agent skills (name + description from SKILL.md). Call skills.load with a skill name to read the full instructions.",
+			parameters: []
+		},
+		handler: { execute: async () => Promise.all(listSkillContributions().map(async (skill) => {
+			const resolved = await resolveSkill(skill);
+			return {
+				name: resolved.name,
+				label: resolved.label,
+				description: resolved.description
+			};
+		})) }
+	});
+	registerAll({
+		command: {
+			id: "skills.load",
+			name: "Load skill",
+			description: "Load the full body of a registered agent skill by name. Prefer skills returned by skills.list.",
+			parameters: [{
+				name: "name",
+				description: "Skill name (e.g. eclipse-docks-canvas)",
+				required: true
+			}]
+		},
+		handler: { execute: async (context) => {
+			const name = String(context.params?.name ?? "").trim();
+			if (!name) return {
+				error: "Missing skill name",
+				available: listSkillContributions().map((skill) => skill.name)
+			};
+			const skill = listSkillContributions().find((entry) => entry.name === name);
+			if (!skill) return {
+				error: `Unknown skill: ${name}`,
+				available: listSkillContributions().map((entry) => entry.name)
+			};
+			const resolved = await resolveSkill(skill);
+			if (!resolved.body) return {
+				error: `Skill ${name} has no body`,
+				name: resolved.name
+			};
+			return resolved;
+		} }
+	});
+}
+//#endregion
+export { detectEffortCapability as C, AI_VIEW_NAME as D, AI_SETTINGS_KEY as E, OPEN_AI_SETTINGS_COMMAND as O, parseModelIds as S, AI_SETTINGS_EDITOR_ID as T, readPromptAttachmentFromFile as _, listSkillContributions as a, defaultProvidersSettings as b, resolveSkillBody as c, parseSkillMarkdown as d, estimateSessionContextUsage as f, ATTACHMENT_FILE_ACCEPT as g, formatTokenCount as h, SYSTEM_SKILLS as i, TOPIC as k, isSkillContribution as l, formatContextPercent as m, CognitiveRuntime as n, registerSkillMarkdown as o, formatBucketDetail as p, cognitiveRuntime as r, resolveSkill as s, registerSkillCommands as t, formatSkillForPrompt as u, OpenAICompatibleProvider as v, loadModelsCatalog as w, listConfiguredModelIds as x, fetchOpenAICompatibleModels as y };
 
-//# sourceMappingURL=runtime-DfNGzEjU.js.map
+//# sourceMappingURL=runtime-B0IHjzQO.js.map