@eclipse-docks/extension-ai-system 0.7.139 → 0.7.141

package/dist/runtime-DfNGzEjU.js

@@ -0,0 +1,2952 @@
+import { Directory, File, commandRegistry, persistenceService, 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. */
+var RuntimeEvents = class {
+	constructor() {
+		this.handlers = /* @__PURE__ */ new Map();
+	}
+	publish(topic, payload) {
+		const set = this.handlers.get(topic);
+		if (!set) return;
+		for (const handler of set) handler(payload);
+	}
+	subscribe(topic, handler) {
+		let set = this.handlers.get(topic);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.handlers.set(topic, set);
+		}
+		set.add(handler);
+		return () => set.delete(handler);
+	}
+};
+var TOPIC = {
+	sessionChanged: "cognitive/session/changed",
+	messagePart: "cognitive/message/part",
+	messageDone: "cognitive/message/done",
+	permissionAsked: "cognitive/permission/asked",
+	modelRouted: "cognitive/model/routed",
+	coreTick: "cognitive/core/tick",
+	checkpoint: "cognitive/checkpoint",
+	providersChanged: "cognitive/providers/changed",
+	approvalModeChanged: "cognitive/approval-mode/changed"
+};
+//#endregion
+//#region src/runtime/constants.ts
+/** Sidebar contribution / tab panel name for the AI chat view. */
+var AI_VIEW_NAME = "cognitiveview";
+/** EditorInput.key for the AI settings editor. */
+var AI_SETTINGS_KEY = ".system.cognitive-ai-settings";
+/** editorRegistry editorId for the AI settings editor. */
+var AI_SETTINGS_EDITOR_ID = "system.cognitive-ai-settings-editor";
+/** Command that opens AI settings. */
+var OPEN_AI_SETTINGS_COMMAND = "open_cognitive_ai_settings";
+//#endregion
+//#region src/runtime/core/plutchik.ts
+var PLUTCHIK_EMOTIONS = [
+	"joy",
+	"trust",
+	"fear",
+	"surprise",
+	"sadness",
+	"disgust",
+	"anger",
+	"anticipation"
+];
+function createNeutralState() {
+	return Object.fromEntries(PLUTCHIK_EMOTIONS.map((e) => [e, 0]));
+}
+function clampEmotion(value) {
+	if (Number.isNaN(value)) return 0;
+	return Math.max(-1, Math.min(1, value));
+}
+function blendStates(base, delta, weight = 1) {
+	const next = { ...base };
+	for (const key of PLUTCHIK_EMOTIONS) {
+		const d = delta[key];
+		if (d === void 0) continue;
+		next[key] = clampEmotion(base[key] + d * weight);
+	}
+	return next;
+}
+function valenceScore(state) {
+	return (state.joy + state.trust + state.anticipation + state.surprise - (state.fear + state.sadness + state.disgust + state.anger)) / 4;
+}
+function diffStates(prev, next) {
+	const out = createNeutralState();
+	for (const key of PLUTCHIK_EMOTIONS) out[key] = clampEmotion(next[key] - prev[key]);
+	return out;
+}
+//#endregion
+//#region src/runtime/core/needs.ts
+function defaultNeeds() {
+	return [
+		{
+			id: "progress",
+			label: "Make progress on goals",
+			weight: 1,
+			urgency: .4
+		},
+		{
+			id: "clarity",
+			label: "Reduce uncertainty",
+			weight: .8,
+			urgency: .3
+		},
+		{
+			id: "safety",
+			label: "Avoid harmful actions",
+			weight: 1.2,
+			urgency: .5
+		},
+		{
+			id: "coherence",
+			label: "Keep context coherent",
+			weight: .7,
+			urgency: .2
+		}
+	];
+}
+function dominantNeed(needs) {
+	let best = needs[0];
+	for (const need of needs) {
+		const score = need.weight * need.urgency;
+		if (!best || score > best.weight * best.urgency) best = need;
+	}
+	return best;
+}
+//#endregion
+//#region src/runtime/core/tick.ts
+function contextDelta(context) {
+	if (!context) return {};
+	const kind = String(context.slots.kind ?? context.type);
+	if (kind === "error" || kind === "failure") return {
+		fear: .15,
+		sadness: .1,
+		anticipation: -.05
+	};
+	if (kind === "success" || kind === "progress") return {
+		joy: .2,
+		anticipation: .1,
+		trust: .05
+	};
+	if (kind === "isolation" || kind === "empty") return {
+		sadness: .2,
+		fear: .05,
+		surprise: .1
+	};
+	if (kind === "user") return {
+		anticipation: .15,
+		trust: .05
+	};
+	return { surprise: .05 };
+}
+function createCoreState(needs) {
+	return {
+		conscious: createNeutralState(),
+		subconscious: createNeutralState(),
+		needs: [...needs]
+	};
+}
+function emptyBuffers() {
+	return {
+		goal: null,
+		retrieval: null,
+		imaginal: null,
+		emotion: null,
+		motor: null
+	};
+}
+/** One ICOM-inspired Core tick: update valence from context + needs, emit intent when useful. */
+function coreTick(input) {
+	const prev = input.state.conscious;
+	const need = dominantNeed(input.state.needs);
+	const delta = contextDelta(input.context ?? input.buffers.retrieval);
+	const needBias = need.id === "safety" ? {
+		fear: .05 * need.urgency,
+		trust: .02
+	} : need.id === "progress" ? {
+		anticipation: .08 * need.urgency,
+		joy: .03 * need.urgency
+	} : need.id === "clarity" ? {
+		surprise: .05 * need.urgency,
+		anticipation: .04 * need.urgency
+	} : { trust: .03 * need.urgency };
+	const conscious = blendStates(blendStates(prev, delta), needBias);
+	const subconscious = blendStates(input.state.subconscious, delta, .5);
+	const qualia = diffStates(prev, conscious);
+	const valenceDelta = valenceScore(conscious) - valenceScore(prev);
+	const summary = input.context?.slots.summary ?? input.buffers.goal?.slots.summary ?? need.label;
+	const intent = valenceDelta !== 0 || Boolean(input.context) || Boolean(input.buffers.goal) ? {
+		id: `intent-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+		summary: String(summary),
+		motivation: need.id,
+		valenceDelta,
+		createdAt: Date.now()
+	} : null;
+	const goalChunk = intent ? {
+		id: `goal-${intent.id}`,
+		type: "goal",
+		slots: {
+			summary: intent.summary,
+			motivation: intent.motivation,
+			intentId: intent.id
+		},
+		activation: 1,
+		createdAt: intent.createdAt,
+		updatedAt: intent.createdAt,
+		scope: "session"
+	} : input.buffers.goal;
+	const emotionChunk = {
+		id: `emotion-${Date.now()}`,
+		type: "emotion",
+		slots: {
+			conscious,
+			valence: valenceScore(conscious)
+		},
+		activation: 1,
+		createdAt: Date.now(),
+		updatedAt: Date.now(),
+		scope: "run"
+	};
+	return {
+		state: {
+			conscious,
+			subconscious,
+			needs: input.state.needs
+		},
+		buffers: {
+			...input.buffers,
+			goal: goalChunk,
+			emotion: emotionChunk,
+			motor: null
+		},
+		intent,
+		valenceDelta,
+		qualia
+	};
+}
+//#endregion
+//#region src/runtime/memory/store.ts
+function now() {
+	return Date.now();
+}
+function id() {
+	return `chunk-${now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/** In-memory declarative/episodic store with ACT-R-like activation ranking. */
+var CognitiveMemory = class {
+	constructor() {
+		this.chunks = /* @__PURE__ */ new Map();
+	}
+	upsert(input) {
+		const existing = input.id ? this.chunks.get(input.id) : void 0;
+		const chunk = {
+			id: input.id ?? existing?.id ?? id(),
+			type: input.type,
+			slots: { ...input.slots },
+			activation: input.activation ?? existing?.activation ?? .5,
+			createdAt: existing?.createdAt ?? now(),
+			updatedAt: now(),
+			scope: input.scope,
+			sessionId: input.sessionId,
+			pinned: input.pinned ?? existing?.pinned
+		};
+		this.chunks.set(chunk.id, chunk);
+		return chunk;
+	}
+	get(chunkId) {
+		return this.chunks.get(chunkId);
+	}
+	touch(chunkId, boost = .15) {
+		const chunk = this.chunks.get(chunkId);
+		if (!chunk) return void 0;
+		const next = {
+			...chunk,
+			activation: Math.min(2, chunk.activation + boost),
+			updatedAt: now()
+		};
+		this.chunks.set(chunkId, next);
+		return next;
+	}
+	decay(amount = .02) {
+		for (const [key, chunk] of this.chunks) {
+			if (chunk.pinned) continue;
+			const activation = Math.max(0, chunk.activation - amount);
+			if (activation <= .01 && chunk.scope !== "workspace") {
+				this.chunks.delete(key);
+				continue;
+			}
+			this.chunks.set(key, {
+				...chunk,
+				activation
+			});
+		}
+	}
+	forget(chunkId) {
+		return this.chunks.delete(chunkId);
+	}
+	clear(scope) {
+		if (!scope) {
+			this.chunks.clear();
+			return;
+		}
+		for (const [key, chunk] of this.chunks) if (chunk.scope === scope) this.chunks.delete(key);
+	}
+	search(query = {}) {
+		const min = query.minActivation ?? 0;
+		const limit = query.limit ?? 8;
+		return [...this.chunks.values()].filter((c) => query.type ? c.type === query.type : true).filter((c) => query.scope ? c.scope === query.scope : true).filter((c) => query.sessionId ? c.sessionId === query.sessionId : true).filter((c) => c.activation >= min || c.pinned).sort((a, b) => b.activation - a.activation || b.updatedAt - a.updatedAt).slice(0, limit);
+	}
+	/** Spreading-style boost: chunks whose slots overlap context terms rise. */
+	retrieveForContext(terms, limit = 5) {
+		const lower = terms.map((t) => t.toLowerCase()).filter(Boolean);
+		if (lower.length === 0) return this.search({ limit });
+		return [...this.chunks.values()].map((chunk) => {
+			const hay = `${chunk.type} ${JSON.stringify(chunk.slots)}`.toLowerCase();
+			let hits = 0;
+			for (const term of lower) if (hay.includes(term)) hits += 1;
+			return {
+				chunk,
+				score: chunk.activation + hits * .35 + (chunk.pinned ? .5 : 0)
+			};
+		}).filter((s) => s.score > .2).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => {
+			this.touch(s.chunk.id, .05);
+			return this.chunks.get(s.chunk.id);
+		});
+	}
+	snapshot() {
+		return [...this.chunks.values()].map((c) => ({
+			...c,
+			slots: { ...c.slots }
+		}));
+	}
+	restore(chunks) {
+		this.chunks.clear();
+		for (const chunk of chunks) this.chunks.set(chunk.id, {
+			...chunk,
+			slots: { ...chunk.slots }
+		});
+	}
+};
+//#endregion
+//#region src/runtime/models/provider-registry.ts
+var ProviderRegistry = class {
+	constructor() {
+		this.settingsProviders = /* @__PURE__ */ new Map();
+		this.externalProviders = /* @__PURE__ */ new Map();
+	}
+	/** Settings-backed providers — cleared on each settings rebuild. */
+	register(provider) {
+		this.settingsProviders.set(provider.id, provider);
+	}
+	/** Plugin providers (e.g. WebLLM) that survive settings rebuilds. */
+	registerExternal(provider) {
+		this.externalProviders.set(provider.id, provider);
+	}
+	unregisterExternal(id) {
+		this.externalProviders.delete(id);
+	}
+	clear() {
+		this.settingsProviders.clear();
+	}
+	get(id) {
+		return this.settingsProviders.get(id) ?? this.externalProviders.get(id);
+	}
+	list() {
+		const byId = /* @__PURE__ */ new Map();
+		for (const provider of this.externalProviders.values()) byId.set(provider.id, provider);
+		for (const provider of this.settingsProviders.values()) byId.set(provider.id, provider);
+		return [...byId.values()];
+	}
+	listExternal() {
+		return [...this.externalProviders.values()];
+	}
+	resolveProvider(modelId) {
+		const slash = modelId.indexOf("/");
+		if (slash === -1) return this.list()[0];
+		return this.get(modelId.slice(0, slash));
+	}
+};
+//#endregion
+//#region src/runtime/models/effort-support.ts
+var NO_EFFORT = {
+	supported: false,
+	withTools: false,
+	levels: ["none"],
+	default: "none"
+};
+var EFFORT_ORDER$1 = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+var KNOWN_EFFORTS = new Set(EFFORT_ORDER$1);
+var providersCache;
+var loadPromise;
+/** Load Models.dev provider catalog (network, then offline snapshot fallback). */
+async function loadModelsCatalog(force = false) {
+	if (providersCache && !force) return;
+	if (!loadPromise || force) loadPromise = (async () => {
+		try {
+			providersCache = await Models.make().providers({ signal: AbortSignal.timeout(1e4) });
+		} catch {
+			providersCache = (await import("@opencode-ai/models/snapshot")).providers;
+		}
+	})();
+	await loadPromise;
+}
+function splitModelRef(modelRef) {
+	const trimmed = modelRef.trim();
+	const slash = trimmed.indexOf("/");
+	if (slash === -1) return { modelId: trimmed };
+	return {
+		providerId: trimmed.slice(0, slash),
+		modelId: trimmed.slice(slash + 1)
+	};
+}
+function findCatalogModel(modelRef) {
+	if (!providersCache) return void 0;
+	const { providerId, modelId } = splitModelRef(modelRef);
+	if (!modelId) return void 0;
+	if (providerId) {
+		const exact = providersCache[providerId]?.models?.[modelId];
+		if (exact) return exact;
+	}
+	const lower = modelId.toLowerCase();
+	for (const provider of Object.values(providersCache)) {
+		const models = provider?.models;
+		if (!models) continue;
+		if (models[modelId]) return models[modelId];
+		for (const [id, meta] of Object.entries(models)) if (id.toLowerCase() === lower) return meta;
+	}
+}
+var DEFAULT_CONTEXT_LIMIT = 128e3;
+/** Context window size from Models.dev (`limit.context`), with a safe default. */
+function getModelContextLimit(modelRef) {
+	const limit = findCatalogModel(modelRef)?.limit?.context;
+	return typeof limit === "number" && limit > 0 ? limit : DEFAULT_CONTEXT_LIMIT;
+}
+function mapEffortValue(value) {
+	if (value === null || value === "none" || value === "default") return "none";
+	if (typeof value === "string" && KNOWN_EFFORTS.has(value)) return value;
+}
+function levelsFromOptions(options) {
+	const found = /* @__PURE__ */ new Set();
+	for (const opt of options ?? []) {
+		if (opt.type === "toggle") {
+			found.add("none");
+			continue;
+		}
+		if (opt.type === "effort") for (const value of opt.values) {
+			const mapped = mapEffortValue(value);
+			if (mapped) found.add(mapped);
+		}
+		if (opt.type === "budget_tokens") {
+			found.add("low");
+			found.add("medium");
+			found.add("high");
+		}
+	}
+	if (!found.size) return [
+		"none",
+		"low",
+		"medium",
+		"high"
+	];
+	if (![...found].some((l) => l !== "none")) found.add("medium");
+	return EFFORT_ORDER$1.filter((level) => found.has(level));
+}
+function pickDefault(levels) {
+	if (levels.includes("medium")) return "medium";
+	if (levels.includes("low")) return "low";
+	return levels.find((l) => l !== "none") ?? "none";
+}
+/**
+* Resolve effort capability from Models.dev catalog.
+* Unknown / unloaded models → no effort (safe for chat/completions).
+*/
+function detectEffortCapability(modelRef) {
+	const meta = findCatalogModel(modelRef);
+	if (!meta?.reasoning) return NO_EFFORT;
+	const levels = levelsFromOptions(meta.reasoning_options);
+	return {
+		supported: true,
+		withTools: false,
+		levels,
+		default: pickDefault(levels)
+	};
+}
+//#endregion
+//#region src/runtime/models/provider-config.ts
+var PROVIDERS_PERSIST_KEY = "cognitive/v1/providers";
+function defaultProvidersSettings() {
+	return {
+		defaultProviderId: "openai",
+		providers: [{
+			id: "openai",
+			baseUrl: "https://api.openai.com/v1",
+			apiKey: "",
+			models: "gpt-4o-mini,gpt-4o",
+			enabled: true
+		}, {
+			id: "ollama",
+			baseUrl: "http://127.0.0.1:11434/v1",
+			apiKey: "",
+			models: "llama3.2",
+			enabled: true
+		}]
+	};
+}
+function parseModelIds(models) {
+	return models.split(",").map((m) => m.trim()).filter(Boolean);
+}
+/** Model refs (`providerId/modelId`) the user enabled in AI Settings. */
+function listConfiguredModelIds(settings) {
+	const ids = [];
+	for (const provider of settings.providers) {
+		if (!provider.enabled || !provider.id.trim()) continue;
+		for (const modelId of parseModelIds(provider.models)) ids.push(`${provider.id}/${modelId}`);
+	}
+	return ids;
+}
+function catalogFromSettings(settings) {
+	const entries = [];
+	for (const provider of settings.providers) {
+		if (!provider.enabled || !provider.id.trim()) continue;
+		const modelIds = parseModelIds(provider.models);
+		modelIds.forEach((modelId, index) => {
+			const tier = modelIds.length === 1 ? "standard" : index === 0 ? "economy" : index === modelIds.length - 1 ? "frontier" : "standard";
+			entries.push({
+				id: `${provider.id}/${modelId}`,
+				providerId: provider.id,
+				tier,
+				strengths: ["code", "fast"],
+				effort: detectEffortCapability(`${provider.id}/${modelId}`)
+			});
+		});
+	}
+	return entries;
+}
+function normalizeProvidersSettings(raw) {
+	const providers = raw.providers.map((p) => ({
+		id: p.id.trim(),
+		baseUrl: p.baseUrl.trim(),
+		apiKey: p.apiKey ?? "",
+		models: p.models ?? "",
+		enabled: p.enabled !== false,
+		...p.extra && Object.keys(p.extra).length ? { extra: { ...p.extra } } : {}
+	}));
+	return {
+		defaultProviderId: providers.find((p) => p.id === raw.defaultProviderId)?.id ?? providers.find((p) => p.enabled)?.id ?? "",
+		providers
+	};
+}
+//#endregion
+//#region src/runtime/models/openai-compatible.ts
+function wireContent(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content;
+	return content ?? "";
+}
+/** Map internal messages to OpenAI chat/completions wire shape. */
+function toOpenAIMessages(messages) {
+	return messages.map((m) => {
+		if (m.role === "tool") return {
+			role: "tool",
+			tool_call_id: m.toolCallId,
+			content: typeof m.content === "string" ? m.content || "" : "",
+			...m.name ? { name: m.name } : {}
+		};
+		if (m.role === "assistant" && m.toolCalls?.length) return {
+			role: "assistant",
+			content: typeof m.content === "string" ? m.content : "",
+			tool_calls: m.toolCalls.map((tc) => ({
+				id: tc.id,
+				type: "function",
+				function: {
+					name: tc.name,
+					arguments: tc.arguments || "{}"
+				}
+			}))
+		};
+		return {
+			role: m.role,
+			content: wireContent(m.content)
+		};
+	});
+}
+/** GET `{baseUrl}/models` — baseUrl should already include `/v1` when required. */
+async function fetchOpenAICompatibleModels(baseUrl, apiKey, signal) {
+	const root = baseUrl.trim().replace(/\/$/, "");
+	if (!root) return [];
+	const headers = { Accept: "application/json" };
+	if (apiKey?.trim()) headers.Authorization = `Bearer ${apiKey.trim()}`;
+	const response = await fetch(`${root}/models`, {
+		method: "GET",
+		headers,
+		signal
+	});
+	if (!response.ok) throw new Error(`Failed to list models (HTTP ${response.status})`);
+	const data = await response.json();
+	return (Array.isArray(data.data) ? data.data : []).map((m) => {
+		const id = (m.id ?? "").trim();
+		if (!id) return null;
+		return {
+			id,
+			name: (m.name ?? id).trim() || id
+		};
+	}).filter((m) => m != null).sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Build a chat/completions request body.
+*
+* Reasoning models default to a non-none effort when the field is omitted.
+* With function tools, chat/completions requires an explicit
+* `reasoning_effort: "none"` — omitting still 400s.
+*/
+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 body = {
+		model,
+		messages: toOpenAIMessages(params.messages),
+		stream: true,
+		...safeOptions
+	};
+	const requestedEffort = params.providerOptions?.reasoning_effort ?? params.providerOptions?.reasoningEffort;
+	const reasoningModel = detectEffortCapability(params.model).supported || requestedEffort != null;
+	if (params.tools?.length) {
+		body.tools = params.tools.map((t) => ({
+			type: "function",
+			function: {
+				name: t.name,
+				description: t.description,
+				parameters: t.parameters
+			}
+		}));
+		if (reasoningModel) body.reasoning_effort = "none";
+	} else if (requestedEffort != null && requestedEffort !== "none") body.reasoning_effort = requestedEffort;
+	return body;
+}
+/** Minimal OpenAI-compatible streaming provider (chat/completions SSE). */
+var OpenAICompatibleProvider = class {
+	constructor(config) {
+		this.config = config;
+	}
+	get id() {
+		return this.config.id;
+	}
+	listModels() {
+		return this.config.defaultModels ?? [{
+			id: "default",
+			name: "Default"
+		}];
+	}
+	async fetchRemoteModels(signal) {
+		return fetchOpenAICompatibleModels(this.config.baseUrl, this.config.apiKey, signal);
+	}
+	async *stream(params) {
+		const url = `${this.config.baseUrl.replace(/\/$/, "")}/chat/completions`;
+		const body = buildChatCompletionBody(params);
+		const headers = { "Content-Type": "application/json" };
+		if (this.config.apiKey) headers.Authorization = `Bearer ${this.config.apiKey}`;
+		let response;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(body),
+				signal: params.signal
+			});
+		} catch (err) {
+			yield {
+				type: "error",
+				error: err instanceof Error ? err.message : String(err)
+			};
+			return;
+		}
+		if (!response.ok || !response.body) {
+			yield {
+				type: "error",
+				error: `HTTP ${response.status}: ${await response.text()}`
+			};
+			return;
+		}
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		const toolAcc = /* @__PURE__ */ new Map();
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			for (const line of lines) {
+				const trimmed = line.trim();
+				if (!trimmed.startsWith("data:")) continue;
+				const data = trimmed.slice(5).trim();
+				if (data === "[DONE]") {
+					yield { type: "done" };
+					return;
+				}
+				try {
+					const delta = JSON.parse(data).choices?.[0]?.delta;
+					if (!delta) continue;
+					if (delta.content) yield {
+						type: "text",
+						text: delta.content
+					};
+					if (delta.reasoning_content || delta.reasoning) yield {
+						type: "reasoning",
+						text: String(delta.reasoning_content ?? delta.reasoning)
+					};
+					if (Array.isArray(delta.tool_calls)) for (const tc of delta.tool_calls) {
+						const idx = tc.index ?? 0;
+						const cur = toolAcc.get(idx) ?? {
+							id: tc.id ?? `call-${idx}`,
+							name: "",
+							arguments: ""
+						};
+						if (tc.id) cur.id = tc.id;
+						if (tc.function?.name) cur.name += tc.function.name;
+						if (tc.function?.arguments) cur.arguments += tc.function.arguments;
+						toolAcc.set(idx, cur);
+						yield {
+							type: "tool_call_delta",
+							toolCall: { ...cur }
+						};
+					}
+				} catch {}
+			}
+		}
+		yield { type: "done" };
+	}
+};
+//#endregion
+//#region src/runtime/models/router.ts
+var EFFORT_ORDER = [
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+var ROLE_TIER = {
+	compact: "economy",
+	title: "economy",
+	summary: "economy",
+	explore: "economy",
+	plan: "standard",
+	build: "standard",
+	general: "standard"
+};
+var ROLE_EFFORT = {
+	compact: "none",
+	title: "none",
+	summary: "low",
+	explore: "low",
+	plan: "medium",
+	build: "medium",
+	general: "medium"
+};
+function effortIndex(level) {
+	return EFFORT_ORDER.indexOf(level);
+}
+function clampEffort(level, max) {
+	if (!max) return level;
+	return effortIndex(level) > effortIndex(max) ? max : level;
+}
+function resolveEffort(entry, desired, requireTools) {
+	if (!entry.effort.supported) return "none";
+	if (requireTools) return "none";
+	if (!entry.effort.levels.includes(desired)) return entry.effort.default;
+	return desired;
+}
+function mapEffortOptions(entry, effort, requireTools) {
+	if (!entry.effort.supported) return {};
+	if (requireTools) return { reasoning_effort: "none" };
+	if (effort === "none") return { reasoning_effort: "none" };
+	return { reasoning_effort: effort };
+}
+var ModelRouter = class {
+	constructor() {
+		this.catalog = [];
+		this.utility = /* @__PURE__ */ new Map();
+	}
+	setCatalog(entries) {
+		this.catalog = [...entries];
+	}
+	recordOutcome(role, model, effort, success, cost = 1) {
+		const key = `${role}|${model}|${effort}`;
+		const prev = this.utility.get(key) ?? 0;
+		this.utility.set(key, prev + (success ? 1 : -.5) - cost * .05);
+	}
+	resolve(request, policy) {
+		if (policy.mode === "manual") {
+			const model = policy.model;
+			const entry = this.catalog.find((c) => c.id === model) ?? this.fallbackEntry(model);
+			const effort = resolveEffort(entry, policy.effort && policy.effort !== "auto" ? policy.effort : this.pickEffort(request, policy.maxEffort ?? entry.effort.default, "balance"), request.requireTools);
+			return {
+				model: entry.id,
+				providerId: entry.providerId,
+				effort,
+				providerOptions: mapEffortOptions(entry, effort, request.requireTools),
+				reason: `manual:${entry.id}+effort:${effort}`
+			};
+		}
+		const optimizeFor = request.optimizeFor ?? policy.optimizeFor;
+		const complexity = request.complexity ?? .3;
+		let tier = ROLE_TIER[request.role];
+		if (optimizeFor === "intelligence" || complexity > .7) tier = "frontier";
+		if (optimizeFor === "cost" && complexity < .5) tier = "economy";
+		const candidates = this.catalog.filter((c) => c.tier === tier);
+		const entry = [...candidates.length ? candidates : this.catalog].sort((a, b) => {
+			const ua = this.utility.get(`${request.role}|${a.id}|${ROLE_EFFORT[request.role]}`) ?? 0;
+			return (this.utility.get(`${request.role}|${b.id}|${ROLE_EFFORT[request.role]}`) ?? 0) - ua;
+		})[0] ?? this.fallbackEntry(`${this.catalog[0]?.providerId ?? "openai"}/default`);
+		const effort = resolveEffort(entry, this.pickEffort(request, policy.maxEffort, optimizeFor), request.requireTools);
+		return {
+			model: entry.id,
+			providerId: entry.providerId,
+			effort,
+			providerOptions: mapEffortOptions(entry, effort, request.requireTools),
+			reason: `auto:${optimizeFor}+role:${request.role}+tier:${entry.tier}+effort:${effort}`
+		};
+	}
+	pickEffort(request, maxEffort, optimizeFor) {
+		if (request.manualEffort && request.manualEffort !== "auto") return clampEffort(request.manualEffort, maxEffort);
+		let effort = ROLE_EFFORT[request.role];
+		const complexity = request.complexity ?? .3;
+		if (optimizeFor === "intelligence" || complexity > .6) effort = EFFORT_ORDER[Math.min(EFFORT_ORDER.length - 1, effortIndex(effort) + 1)];
+		if (optimizeFor === "cost") effort = EFFORT_ORDER[Math.max(0, effortIndex(effort) - 1)];
+		return clampEffort(effort, maxEffort);
+	}
+	fallbackEntry(model) {
+		const slash = model.indexOf("/");
+		const providerId = slash === -1 ? "openai" : model.slice(0, slash);
+		const id = slash === -1 ? `${providerId}/${model}` : model;
+		return {
+			id,
+			providerId,
+			tier: "standard",
+			strengths: ["code"],
+			effort: detectEffortCapability(id)
+		};
+	}
+};
+//#endregion
+//#region src/runtime/tools/broker.ts
+function matchPattern(pattern, name) {
+	if (pattern === "*" || pattern === name) return true;
+	if (pattern.endsWith("*")) return name.startsWith(pattern.slice(0, -1));
+	return false;
+}
+/** Evaluates allow/ask/deny and dispatches tool executors. */
+var ToolBroker = class {
+	constructor() {
+		this.approvalMode = "auto_safe";
+		this.rules = [];
+		this.executors = /* @__PURE__ */ new Map();
+		this.definitions = [];
+		this.permissionHandler = null;
+		this.effectLog = [];
+	}
+	setApprovalMode(mode) {
+		this.approvalMode = mode;
+	}
+	getApprovalMode() {
+		return this.approvalMode;
+	}
+	setRules(rules) {
+		this.rules = rules;
+	}
+	setPermissionHandler(handler) {
+		this.permissionHandler = handler;
+	}
+	register(definition, executor) {
+		this.definitions = this.definitions.filter((d) => d.name !== definition.name).concat(definition);
+		this.executors.set(definition.name, executor);
+	}
+	unregister(name) {
+		this.definitions = this.definitions.filter((d) => d.name !== name);
+		this.executors.delete(name);
+	}
+	clearDefinitions() {
+		this.definitions = [];
+		this.executors.clear();
+	}
+	listDefinitions(role) {
+		if (role === "plan" || role === "explore") return this.definitions.filter((d) => !isMutatingName(d.name));
+		return [...this.definitions];
+	}
+	resolveAction(toolName, risk) {
+		for (const rule of this.rules) if (matchPattern(rule.pattern, toolName) && rule.action === "deny") return "deny";
+		let action;
+		switch (this.approvalMode) {
+			case "auto_all":
+				action = "allow";
+				break;
+			case "manual":
+				action = "ask";
+				break;
+			default: action = risk === "safe" ? "allow" : "ask";
+		}
+		for (const rule of this.rules) if (matchPattern(rule.pattern, toolName) && rule.action === "allow" && action === "ask") action = "allow";
+		return action;
+	}
+	async execute(call, sessionId, role, opts = {}) {
+		if ((role === "plan" || role === "explore") && isMutatingName(call.name)) return {
+			id: call.id,
+			name: call.name,
+			ok: false,
+			output: null,
+			error: "Tool denied in plan/explore mode"
+		};
+		let action = this.resolveAction(call.name, opts.risk);
+		if (action === "ask" && this.permissionHandler) action = await this.permissionHandler({
+			toolName: call.name,
+			args: call.arguments,
+			sessionId
+		});
+		if (action === "deny") return {
+			id: call.id,
+			name: call.name,
+			ok: false,
+			output: null,
+			error: "Permission denied"
+		};
+		if (action === "ask") return {
+			id: call.id,
+			name: call.name,
+			ok: false,
+			output: null,
+			error: "Permission ask unresolved"
+		};
+		const executor = this.executors.get(call.name);
+		if (!executor) return {
+			id: call.id,
+			name: call.name,
+			ok: false,
+			output: null,
+			error: `Unknown tool: ${call.name}`
+		};
+		const result = await executor(call, sessionId);
+		if (result.mutating || isMutatingName(call.name)) this.effectLog.push({
+			sessionId,
+			tool: call.name,
+			at: Date.now()
+		});
+		return result;
+	}
+	effectCount(sessionId, since) {
+		return this.effectLog.filter((e) => e.sessionId === sessionId && (!since || e.at >= since)).length;
+	}
+};
+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 : {};
+}
+/** 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)
+				};
+			}
+		});
+	}
+}
+//#endregion
+//#region src/runtime/attachments.ts
+/** Soft cap per attached text file when stored / returned by attachment_read. */
+var MAX_ATTACHMENT_CHARS = 1e5;
+/** Soft cap for visual media attachments (bytes). */
+var MAX_IMAGE_BYTES = 4e6;
+/** Well-known visual media types (raster icons/images + SVG). */
+var MEDIA_BY_MIME = /* @__PURE__ */ new Map([
+	["image/jpeg", {
+		mime: "image/jpeg",
+		mode: "raster",
+		vision: true
+	}],
+	["image/jpg", {
+		mime: "image/jpeg",
+		mode: "raster",
+		vision: true
+	}],
+	["image/pjpeg", {
+		mime: "image/jpeg",
+		mode: "raster",
+		vision: true
+	}],
+	["image/png", {
+		mime: "image/png",
+		mode: "raster",
+		vision: true
+	}],
+	["image/x-png", {
+		mime: "image/png",
+		mode: "raster",
+		vision: true
+	}],
+	["image/gif", {
+		mime: "image/gif",
+		mode: "raster",
+		vision: true
+	}],
+	["image/webp", {
+		mime: "image/webp",
+		mode: "raster",
+		vision: true
+	}],
+	["image/bmp", {
+		mime: "image/bmp",
+		mode: "raster",
+		vision: true
+	}],
+	["image/x-ms-bmp", {
+		mime: "image/bmp",
+		mode: "raster",
+		vision: true
+	}],
+	["image/avif", {
+		mime: "image/avif",
+		mode: "raster",
+		vision: true
+	}],
+	["image/tiff", {
+		mime: "image/tiff",
+		mode: "raster",
+		vision: false
+	}],
+	["image/tif", {
+		mime: "image/tiff",
+		mode: "raster",
+		vision: false
+	}],
+	["image/x-icon", {
+		mime: "image/x-icon",
+		mode: "raster",
+		vision: true
+	}],
+	["image/vnd.microsoft.icon", {
+		mime: "image/x-icon",
+		mode: "raster",
+		vision: true
+	}],
+	["image/ico", {
+		mime: "image/x-icon",
+		mode: "raster",
+		vision: true
+	}],
+	["image/svg+xml", {
+		mime: "image/svg+xml",
+		mode: "svg",
+		vision: false
+	}],
+	["image/svg", {
+		mime: "image/svg+xml",
+		mode: "svg",
+		vision: false
+	}]
+]);
+var MEDIA_BY_EXT = /* @__PURE__ */ new Map([
+	["jpg", MEDIA_BY_MIME.get("image/jpeg")],
+	["jpeg", MEDIA_BY_MIME.get("image/jpeg")],
+	["jpe", MEDIA_BY_MIME.get("image/jpeg")],
+	["jfif", MEDIA_BY_MIME.get("image/jpeg")],
+	["png", MEDIA_BY_MIME.get("image/png")],
+	["gif", MEDIA_BY_MIME.get("image/gif")],
+	["webp", MEDIA_BY_MIME.get("image/webp")],
+	["bmp", MEDIA_BY_MIME.get("image/bmp")],
+	["avif", MEDIA_BY_MIME.get("image/avif")],
+	["tif", MEDIA_BY_MIME.get("image/tiff")],
+	["tiff", MEDIA_BY_MIME.get("image/tiff")],
+	["ico", MEDIA_BY_MIME.get("image/x-icon")],
+	["cur", MEDIA_BY_MIME.get("image/x-icon")],
+	["svg", MEDIA_BY_MIME.get("image/svg+xml")],
+	["svgz", MEDIA_BY_MIME.get("image/svg+xml")]
+]);
+/** File picker `accept` list for visual media + common text sources. */
+var ATTACHMENT_FILE_ACCEPT = [
+	"image/*",
+	".svg",
+	".svgz",
+	".ico",
+	".cur",
+	".bmp",
+	".tif",
+	".tiff",
+	".avif",
+	"text/*",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".json",
+	".md",
+	".css",
+	".html",
+	".py",
+	".rs",
+	".go",
+	".sql",
+	".yml",
+	".yaml",
+	".toml",
+	".txt",
+	".csv"
+].join(",");
+function fileExtension(name) {
+	const base = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
+	const dot = base.lastIndexOf(".");
+	return dot >= 0 ? base.slice(dot + 1).toLowerCase() : "";
+}
+function resolveMediaType(input) {
+	const mime = (input.mime || "").toLowerCase().trim();
+	if (mime && MEDIA_BY_MIME.has(mime)) return MEDIA_BY_MIME.get(mime);
+	const ext = fileExtension(input.name);
+	return MEDIA_BY_EXT.get(ext) ?? null;
+}
+function isImageAttachment(part) {
+	if (part.kind === "image") return true;
+	if (part.dataUrl?.startsWith("data:image/")) return true;
+	return resolveMediaType({
+		name: part.name,
+		mime: part.mime
+	}) != null;
+}
+function isSvgAttachment(part) {
+	return resolveMediaType({
+		name: part.name,
+		mime: part.mime
+	})?.mode === "svg" || Boolean(part.text && part.mime?.includes("svg"));
+}
+function newAttachmentId() {
+	return `att-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Persistable session entry holding the full payload (not sent in chat history). */
+function toSessionAttachment(attachment, opts = {}) {
+	if ((isImageAttachment(attachment) ? "image" : "text") === "image") {
+		let text = attachment.text;
+		let truncated = Boolean(attachment.truncated);
+		if (text && text.length > 1e5) {
+			text = text.slice(0, MAX_ATTACHMENT_CHARS);
+			truncated = true;
+		}
+		return {
+			id: opts.id ?? newAttachmentId(),
+			name: attachment.name,
+			path: attachment.path,
+			mime: attachment.mime,
+			kind: "image",
+			text,
+			dataUrl: attachment.dataUrl,
+			byteLength: attachment.byteLength,
+			truncated: text ? truncated : attachment.truncated,
+			createdAt: Date.now(),
+			messageId: opts.messageId
+		};
+	}
+	let text = attachment.text ?? "";
+	let truncated = Boolean(attachment.truncated);
+	if (text.length > 1e5) {
+		text = text.slice(0, MAX_ATTACHMENT_CHARS);
+		truncated = true;
+	}
+	return {
+		id: opts.id ?? newAttachmentId(),
+		name: attachment.name,
+		path: attachment.path,
+		mime: attachment.mime,
+		kind: "text",
+		text,
+		byteLength: attachment.byteLength,
+		truncated,
+		createdAt: Date.now(),
+		messageId: opts.messageId
+	};
+}
+/** Lightweight history/UI reference — no payload. */
+function toFileRefPart(stored) {
+	return {
+		type: "file",
+		id: stored.id,
+		name: stored.name,
+		path: stored.path,
+		mime: stored.mime,
+		kind: stored.kind,
+		byteLength: stored.byteLength
+	};
+}
+/** One-line catalog entry published into the user turn for the model. */
+function formatAttachmentRefForModel(part) {
+	const label = part.path?.trim() || part.name;
+	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}"`;
+}
+/**
+* Build provider user content from history parts.
+* File parts are references only — payloads stay in the session store.
+*/
+function userContentFromParts(parts) {
+	const texts = [];
+	const refs = [];
+	for (const part of parts) {
+		if (part.type === "text" && part.text.trim()) texts.push(part.text);
+		if (part.type === "file") refs.push(formatAttachmentRefForModel(part));
+	}
+	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
+		}
+	};
+}
+/** 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 };
+	delete copy.dataUrl;
+	delete copy[IMAGE_PRESENT_KEY];
+	return copy;
+}
+function looksBinaryText(sample) {
+	return sample.includes("\0");
+}
+function bytesToBase64(bytes) {
+	const chunk = 32768;
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += chunk) binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(binary);
+}
+function textToBase64(text) {
+	return bytesToBase64(new TextEncoder().encode(text));
+}
+async function readFileAsDataUrl(file, mime) {
+	const buffer = await file.arrayBuffer();
+	return `data:${mime};base64,${bytesToBase64(new Uint8Array(buffer))}`;
+}
+function svgDataUrl(text) {
+	return `data:image/svg+xml;base64,${textToBase64(text)}`;
+}
+/** Read a browser `File` into a prompt attachment (payload kept until publish). */
+async function readPromptAttachmentFromFile(file) {
+	const mime = file.type || "application/octet-stream";
+	const media = resolveMediaType({
+		name: file.name,
+		mime
+	});
+	if (media) {
+		if (file.size > 4e6) return {
+			ok: false,
+			error: `${file.name}: media is larger than ${Math.round(MAX_IMAGE_BYTES / 1e6)}MB`
+		};
+		if (media.mode === "svg") try {
+			const text = await file.text();
+			if (!text.trim()) return {
+				ok: false,
+				error: `${file.name}: empty SVG`
+			};
+			let storedText = text;
+			let truncated = false;
+			if (storedText.length > 1e5) {
+				storedText = storedText.slice(0, MAX_ATTACHMENT_CHARS);
+				truncated = true;
+			}
+			return {
+				ok: true,
+				attachment: {
+					name: file.name,
+					mime: media.mime,
+					kind: "image",
+					text: storedText,
+					dataUrl: svgDataUrl(storedText),
+					byteLength: file.size,
+					truncated
+				}
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				error: `${file.name}: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+		try {
+			const dataUrl = await readFileAsDataUrl(file, media.mime);
+			return {
+				ok: true,
+				attachment: {
+					name: file.name,
+					mime: media.mime,
+					kind: "image",
+					dataUrl,
+					byteLength: file.size
+				}
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				error: `${file.name}: ${err instanceof Error ? err.message : String(err)}`
+			};
+		}
+	}
+	if (mime.startsWith("audio/") || mime.startsWith("video/")) return {
+		ok: false,
+		error: `${file.name}: audio/video attachments are not supported`
+	};
+	if (mime.startsWith("image/")) return {
+		ok: false,
+		error: `${file.name}: unsupported image type (try jpeg, png, gif, webp, svg, ico, bmp, avif)`
+	};
+	if (file.size > 2e6) return {
+		ok: false,
+		error: `${file.name}: file is larger than 2MB`
+	};
+	let text;
+	try {
+		text = await file.text();
+	} catch (err) {
+		return {
+			ok: false,
+			error: `${file.name}: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	if (looksBinaryText(text.slice(0, 2048))) return {
+		ok: false,
+		error: `${file.name}: binary files are not supported`
+	};
+	let truncated = false;
+	if (text.length > 1e5) {
+		text = text.slice(0, MAX_ATTACHMENT_CHARS);
+		truncated = true;
+	}
+	return {
+		ok: true,
+		attachment: {
+			name: file.name,
+			mime,
+			kind: "text",
+			text,
+			byteLength: file.size,
+			truncated
+		}
+	};
+}
+//#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
+			}
+		};
+	});
+	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.",
+		parameters: {
+			type: "object",
+			properties: {
+				id: {
+					type: "string",
+					description: "Attachment id from attachment_list or the user message"
+				},
+				offset: {
+					type: "number",
+					description: "Text start offset (characters)"
+				},
+				limit: {
+					type: "number",
+					description: "Max text characters to return"
+				}
+			},
+			required: ["id"]
+		}
+	}, 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 {
+			id: call.id,
+			name: call.name,
+			ok: false,
+			output: null,
+			error: `Unknown attachment: ${id}`
+		};
+		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
+			});
+			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
+			};
+		}
+		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
+		};
+	});
+}
+//#endregion
+//#region src/runtime/compact/compaction.ts
+var COMPACT_SYSTEM = `You compress older chat turns into a durable summary for future assistant turns.
+Preserve: user goals, decisions, constraints, important file/paths, tool outcomes that still matter, and open questions.
+Omit chit-chat, repeated content, and raw tool dumps.
+Reply with concise markdown only (short sections or bullets). No preamble.`;
+/** Format one message for extractive / LLM compaction input. */
+function formatMessageForCompaction(msg, maxChars = 280) {
+	const bits = [];
+	for (const part of msg.parts) {
+		const piece = formatPart(part);
+		if (piece) bits.push(piece);
+	}
+	const body = bits.join(" · ").replace(/\s+/g, " ").trim();
+	if (!body) return "";
+	const clipped = body.length <= maxChars ? body : `${body.slice(0, maxChars)}…`;
+	return `${msg.role}: ${clipped}`;
+}
+function formatPart(part) {
+	if (part.type === "text") return part.text;
+	if (part.type === "file") {
+		const label = part.path || part.name;
+		return `${part.kind === "image" ? "image" : "file"} ${label} (${part.id})`;
+	}
+	if (part.type === "reasoning") return `(thinking) ${part.text}`;
+	if (part.type === "tool") {
+		const status = part.status === "error" ? "error" : part.status === "done" ? "ok" : part.status;
+		const result = part.result === void 0 ? "" : ` → ${JSON.stringify(part.result).slice(0, 120)}`;
+		return `tool ${part.name} [${status}]${result}`;
+	}
+	if (part.type === "step") return `step ${part.title}`;
+	return "";
+}
+/** Anchored summary compaction: keep recent messages, summarize the rest. */
+function compactHistory(history, options = {}) {
+	const keepCount = options.keepCount ?? 12;
+	if (history.length <= keepCount) return {
+		summary: options.previousSummary ?? "",
+		kept: [...history],
+		dropped: [],
+		didCompact: false
+	};
+	const kept = history.slice(-keepCount);
+	const dropped = history.slice(0, -keepCount);
+	return {
+		summary: buildExtractiveSummary(dropped, options.previousSummary),
+		kept,
+		dropped,
+		didCompact: true
+	};
+}
+function buildExtractiveSummary(dropped, previousSummary) {
+	const lines = [];
+	if (previousSummary?.trim()) lines.push(`Prior: ${previousSummary.trim()}`);
+	for (const msg of dropped) {
+		const line = formatMessageForCompaction(msg);
+		if (line) lines.push(line);
+	}
+	return [
+		"## Objective",
+		"Continue prior work from compacted history.",
+		"## Notes",
+		...lines.slice(-24)
+	].join("\n");
+}
+/** Ask the model to summarize dropped turns; returns null on empty/failure. */
+async function summarizeDroppedHistory(input) {
+	if (!input.dropped.length) return null;
+	const transcript = input.dropped.map((msg) => formatMessageForCompaction(msg, 600)).filter(Boolean).join("\n");
+	if (!transcript.trim()) return null;
+	const userParts = [input.previousSummary?.trim() ? `## Existing summary\n${input.previousSummary.trim()}` : "", `## Older turns to fold in\n${transcript}`].filter(Boolean);
+	const messages = [{
+		role: "system",
+		content: COMPACT_SYSTEM
+	}, {
+		role: "user",
+		content: userParts.join("\n\n")
+	}];
+	let text = "";
+	try {
+		for await (const chunk of input.provider.stream({
+			model: input.model,
+			messages,
+			providerOptions: input.providerOptions ?? { reasoning_effort: "none" },
+			signal: input.signal
+		})) {
+			if (chunk.type === "error") return null;
+			if (chunk.type === "text" && chunk.text) text += chunk.text;
+		}
+	} catch {
+		return null;
+	}
+	return text.trim() || null;
+}
+/** System message body injected ahead of live history when a summary exists. */
+function compactionContextMessage(summary) {
+	return `## Compacted prior context\nThe following summarizes earlier turns that were removed from the live transcript. Treat it as authoritative background.\n\n${summary.trim()}`;
+}
+//#endregion
+//#region src/runtime/session/session-runtime.ts
+function sid() {
+	return `session-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+function cloneBuffers(buffers) {
+	return {
+		goal: buffers.goal ? {
+			...buffers.goal,
+			slots: { ...buffers.goal.slots }
+		} : null,
+		retrieval: buffers.retrieval ? {
+			...buffers.retrieval,
+			slots: { ...buffers.retrieval.slots }
+		} : null,
+		imaginal: buffers.imaginal ? {
+			...buffers.imaginal,
+			slots: { ...buffers.imaginal.slots }
+		} : null,
+		emotion: buffers.emotion ? {
+			...buffers.emotion,
+			slots: { ...buffers.emotion.slots }
+		} : null,
+		motor: buffers.motor ? {
+			...buffers.motor,
+			slots: { ...buffers.motor.slots }
+		} : null
+	};
+}
+var SessionRuntime = class {
+	constructor() {
+		this.sessions = /* @__PURE__ */ new Map();
+		this.checkpoints = /* @__PURE__ */ new Map();
+		this.focusedId = null;
+	}
+	createSession(input = {}) {
+		const session = {
+			id: sid(),
+			title: input.title ?? "New session",
+			status: "idle",
+			history: [],
+			attachments: [],
+			buffers: emptyBuffers(),
+			specialistMode: input.specialistMode ?? "build",
+			parentSessionId: input.parentSessionId,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+		this.sessions.set(session.id, session);
+		this.checkpoints.set(session.id, []);
+		this.focusedId = session.id;
+		return session;
+	}
+	get(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	list() {
+		return [...this.sessions.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+	}
+	focus(sessionId) {
+		if (!this.sessions.has(sessionId)) return false;
+		this.focusedId = sessionId;
+		return true;
+	}
+	focused() {
+		return this.focusedId ? this.sessions.get(this.focusedId) : void 0;
+	}
+	remove(sessionId) {
+		if (!this.sessions.has(sessionId)) return false;
+		this.sessions.delete(sessionId);
+		this.checkpoints.delete(sessionId);
+		if (this.focusedId === sessionId) this.focusedId = this.list()[0]?.id ?? null;
+		return true;
+	}
+	update(sessionId, patch) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return void 0;
+		const next = {
+			...session,
+			...patch,
+			updatedAt: Date.now()
+		};
+		this.sessions.set(sessionId, next);
+		return next;
+	}
+	addMessage(sessionId, message) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return;
+		session.history = [...session.history, message];
+		session.updatedAt = Date.now();
+		this.sessions.set(sessionId, session);
+	}
+	checkpoint(sessionId, label, toolEffectCount = 0) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return void 0;
+		const cp = {
+			id: `cp-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+			sessionId,
+			label: label ?? `Checkpoint ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
+			createdAt: Date.now(),
+			messageSeq: session.history.length,
+			buffers: cloneBuffers(session.buffers),
+			compactionSummary: session.compactionSummary,
+			specialistMode: session.specialistMode,
+			toolEffectCount
+		};
+		const list = this.checkpoints.get(sessionId) ?? [];
+		list.push(cp);
+		this.checkpoints.set(sessionId, list);
+		return cp;
+	}
+	listCheckpoints(sessionId) {
+		return [...this.checkpoints.get(sessionId) ?? []];
+	}
+	restore(input) {
+		const session = this.sessions.get(input.sessionId);
+		const cp = (this.checkpoints.get(input.sessionId) ?? []).find((c) => c.id === input.checkpointId);
+		if (!session || !cp) return void 0;
+		const history = session.history.slice(0, cp.messageSeq);
+		const buffers = cloneBuffers(cp.buffers);
+		if (input.mode === "fork") {
+			const forked = this.createSession({
+				title: `${session.title} (restored)`,
+				specialistMode: cp.specialistMode
+			});
+			this.update(forked.id, {
+				history,
+				buffers,
+				compactionSummary: cp.compactionSummary,
+				status: "idle"
+			});
+			return { sessionId: forked.id };
+		}
+		this.update(input.sessionId, {
+			history,
+			buffers,
+			compactionSummary: cp.compactionSummary,
+			specialistMode: cp.specialistMode,
+			status: "idle"
+		});
+		return { sessionId: input.sessionId };
+	}
+	/**
+	* Truncate history and store a compaction summary.
+	* Pass `summary` to override the extractive default (e.g. LLM summary).
+	* Returns whether history was shortened.
+	*/
+	compact(sessionId, keepCount = 12, summary) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return {
+			didCompact: false,
+			summary: ""
+		};
+		const result = compactHistory(session.history, {
+			keepCount,
+			previousSummary: session.compactionSummary
+		});
+		if (!result.didCompact) return {
+			didCompact: false,
+			summary: session.compactionSummary ?? ""
+		};
+		const nextSummary = (summary?.trim() || result.summary || session.compactionSummary || "").trim();
+		this.update(sessionId, {
+			history: result.kept,
+			compactionSummary: nextSummary
+		});
+		return {
+			didCompact: true,
+			summary: nextSummary
+		};
+	}
+	/** Preview a compact without mutating (for LLM summarization of dropped turns). */
+	prepareCompact(sessionId, keepCount = 12) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return null;
+		return compactHistory(session.history, {
+			keepCount,
+			previousSummary: session.compactionSummary
+		});
+	}
+	snapshot() {
+		const checkpoints = {};
+		for (const [id, list] of this.checkpoints) checkpoints[id] = list.map((c) => ({
+			...c,
+			buffers: cloneBuffers(c.buffers)
+		}));
+		return {
+			sessions: this.list().map((s) => ({
+				...s,
+				attachments: [...s.attachments ?? []],
+				history: s.history.map((m) => ({
+					...m,
+					parts: [...m.parts]
+				})),
+				buffers: cloneBuffers(s.buffers)
+			})),
+			checkpoints
+		};
+	}
+	loadSnapshot(data) {
+		this.sessions.clear();
+		this.checkpoints.clear();
+		for (const session of data.sessions) this.sessions.set(session.id, {
+			...session,
+			attachments: [...session.attachments ?? []],
+			buffers: cloneBuffers(session.buffers),
+			history: [...session.history]
+		});
+		for (const [id, list] of Object.entries(data.checkpoints ?? {})) this.checkpoints.set(id, list.map((c) => ({
+			...c,
+			buffers: cloneBuffers(c.buffers)
+		})));
+		this.focusedId = this.list()[0]?.id ?? null;
+	}
+};
+//#endregion
+//#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).
+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. */
+async function classifyToolRisks(input) {
+	const risks = /* @__PURE__ */ new Map();
+	if (!input.tools.length) return risks;
+	for (const tool of input.tools) risks.set(tool.id, "critical");
+	const catalog = input.tools.map((t) => ({
+		id: t.id,
+		name: t.name,
+		arguments: truncate(t.arguments, 800)
+	}));
+	const messages = [{
+		role: "system",
+		content: CLASSIFY_SYSTEM
+	}, {
+		role: "user",
+		content: JSON.stringify(catalog)
+	}];
+	let text = "";
+	for await (const chunk of input.provider.stream({
+		model: input.model,
+		messages,
+		providerOptions: { reasoning_effort: "none" },
+		signal: input.signal
+	})) {
+		if (chunk.type === "error") return risks;
+		if (chunk.type === "text" && chunk.text) text += chunk.text;
+	}
+	for (const row of parseRiskRows(text)) {
+		if (!risks.has(row.id)) continue;
+		risks.set(row.id, row.risk === "safe" ? "safe" : "critical");
+	}
+	return risks;
+}
+function truncate(value, max) {
+	return value.length <= max ? value : `${value.slice(0, max)}…`;
+}
+function parseRiskRows(text) {
+	const json = extractJsonArray(text);
+	if (!json) return [];
+	try {
+		const parsed = JSON.parse(json);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.map((row) => {
+			if (!row || typeof row !== "object") return null;
+			const id = String(row.id ?? "");
+			const risk = String(row.risk ?? "");
+			if (!id) return null;
+			return {
+				id,
+				risk
+			};
+		}).filter((row) => row != null);
+	} catch {
+		return [];
+	}
+}
+function extractJsonArray(text) {
+	const trimmed = text.trim();
+	if (trimmed.startsWith("[")) {
+		const end = trimmed.lastIndexOf("]");
+		return end >= 0 ? trimmed.slice(0, end + 1) : null;
+	}
+	const start = trimmed.indexOf("[");
+	const end = trimmed.lastIndexOf("]");
+	if (start >= 0 && end > start) return trimmed.slice(start, end + 1);
+	return null;
+}
+//#endregion
+//#region src/runtime/specialists/loop.ts
+var MAX_TOOL_ITERATIONS = 8;
+function textFromParts(parts) {
+	return parts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+}
+function historyToProviderMessages(systemPrompt, history, compactionSummary) {
+	const messages = [{
+		role: "system",
+		content: systemPrompt
+	}];
+	if (compactionSummary?.trim()) messages.push({
+		role: "system",
+		content: compactionContextMessage(compactionSummary)
+	});
+	for (const msg of history) {
+		if (msg.role === "user") {
+			const content = userContentFromParts(msg.parts);
+			if (!(typeof content === "string" ? !content.trim() : !content.length)) messages.push({
+				role: "user",
+				content
+			});
+			continue;
+		}
+		if (msg.role === "system") {
+			const text = textFromParts(msg.parts);
+			if (text) messages.push({
+				role: "system",
+				content: text
+			});
+			continue;
+		}
+		const text = textFromParts(msg.parts);
+		const tools = msg.parts.filter((p) => p.type === "tool");
+		if (tools.length) {
+			messages.push({
+				role: "assistant",
+				content: text,
+				toolCalls: tools.map((t) => ({
+					id: t.id,
+					name: t.name,
+					arguments: JSON.stringify(t.args ?? {})
+				}))
+			});
+			for (const tool of tools) messages.push({
+				role: "tool",
+				toolCallId: tool.id,
+				name: tool.name,
+				content: JSON.stringify(tool.result ?? {})
+			});
+			continue;
+		}
+		if (text) messages.push({
+			role: "assistant",
+			content: text
+		});
+	}
+	return messages;
+}
+async function runSpecialistLoop(input) {
+	const parts = [];
+	const emit = (part) => {
+		parts.push(part);
+		input.onPart?.(part);
+	};
+	const messages = historyToProviderMessages(input.systemPrompt, input.history, input.compactionSummary);
+	let success = true;
+	for (let iter = 0; iter < MAX_TOOL_ITERATIONS; iter++) {
+		input.refreshTools?.();
+		const tools = input.broker.listDefinitions(input.role);
+		let pendingTools = [];
+		let assistantText = "";
+		for await (const chunk of input.provider.stream({
+			model: input.resolved.model,
+			messages,
+			tools: tools.length ? tools : void 0,
+			providerOptions: input.resolved.providerOptions,
+			signal: input.signal
+		})) {
+			if (chunk.type === "error") {
+				emit({
+					type: "text",
+					text: `Error: ${chunk.error}`
+				});
+				success = false;
+				break;
+			}
+			if (chunk.type === "reasoning" && chunk.text) emit({
+				type: "reasoning",
+				text: chunk.text,
+				status: "streaming"
+			});
+			if (chunk.type === "text" && chunk.text) {
+				assistantText += chunk.text;
+				emit({
+					type: "text",
+					text: chunk.text
+				});
+			}
+			if (chunk.type === "tool_call_delta" && chunk.toolCall) {
+				const existing = pendingTools.find((t) => t.id === chunk.toolCall.id);
+				if (existing) {
+					existing.name = chunk.toolCall.name || existing.name;
+					existing.arguments = chunk.toolCall.arguments;
+				} else pendingTools.push({ ...chunk.toolCall });
+			}
+		}
+		if (!pendingTools.length) {
+			if (assistantText && !parts.some((p) => p.type === "text")) emit({
+				type: "text",
+				text: assistantText
+			});
+			break;
+		}
+		messages.push({
+			role: "assistant",
+			content: assistantText,
+			toolCalls: pendingTools.map((t) => ({
+				id: t.id,
+				name: t.name,
+				arguments: t.arguments || "{}"
+			}))
+		});
+		const risks = input.broker.getApprovalMode() === "auto_safe" ? await classifyToolRisks({
+			provider: input.provider,
+			model: input.resolved.model,
+			tools: pendingTools.map((t) => ({
+				id: t.id,
+				name: t.name,
+				arguments: t.arguments || "{}"
+			})),
+			signal: input.signal
+		}) : null;
+		for (const tool of pendingTools) {
+			let args = {};
+			try {
+				args = tool.arguments ? JSON.parse(tool.arguments) : {};
+			} catch {
+				args = { raw: tool.arguments };
+			}
+			emit({
+				type: "tool",
+				id: tool.id,
+				name: tool.name,
+				args,
+				status: "running"
+			});
+			const started = Date.now();
+			const result = await input.broker.execute({
+				id: tool.id,
+				name: tool.name,
+				arguments: args
+			}, input.sessionId, input.role, { risk: risks?.get(tool.id) });
+			const rawOutput = result.ok ? result.output : { error: result.error };
+			const presentImage = result.ok && rawOutput && typeof rawOutput === "object" && rawOutput["_presentImage"] === true && typeof rawOutput.dataUrl === "string";
+			const safeOutput = result.ok ? stripAttachmentToolOutput(rawOutput) : rawOutput;
+			emit({
+				type: "tool",
+				id: tool.id,
+				name: tool.name,
+				args,
+				result: safeOutput,
+				status: result.ok ? "done" : "error",
+				durationMs: Date.now() - started
+			});
+			messages.push({
+				role: "tool",
+				toolCallId: tool.id,
+				name: tool.name,
+				content: JSON.stringify(presentImage ? {
+					...safeOutput ?? {},
+					note: "Image bytes follow in the next user message 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 (!result.ok) success = false;
+		}
+	}
+	return {
+		message: {
+			id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+			role: "assistant",
+			parts: coalesceParts(parts),
+			createdAt: Date.now(),
+			routedModel: input.resolved.model,
+			effort: input.resolved.effort
+		},
+		success
+	};
+}
+function coalesceParts(parts) {
+	const out = [];
+	for (const part of parts) {
+		const last = out[out.length - 1];
+		if (part.type === "text" && last?.type === "text") {
+			last.text += part.text;
+			continue;
+		}
+		if (part.type === "reasoning" && last?.type === "reasoning") {
+			last.text += part.text;
+			last.status = part.status;
+			continue;
+		}
+		if (part.type === "tool" && last?.type === "tool" && last.id === part.id) {
+			out[out.length - 1] = part;
+			continue;
+		}
+		out.push(part);
+	}
+	for (const part of out) if (part.type === "reasoning") part.status = "done";
+	return out;
+}
+//#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."}`;
+	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}`;
+		case "build": return `${preamble}\nMode: BUILD. Implement the goal using tools when needed: ${goal}`;
+		default: return `${preamble}\nGoal: ${goal}`;
+	}
+}
+//#endregion
+//#region src/runtime/context/usage.ts
+/** Rough token estimate (~4 chars / token) with a small structural overhead. */
+function estimateTokens(text) {
+	if (!text) return 0;
+	return Math.max(1, Math.ceil(text.length / 4));
+}
+function estimatePartTokens(part) {
+	if (part.type === "text" || part.type === "reasoning") return estimateTokens(part.text);
+	if (part.type === "file") return estimateTokens(part.name) + estimateTokens(part.id) + 8;
+	if (part.type === "tool") return estimateTokens(part.name) + estimateTokens(JSON.stringify(part.args ?? {})) + estimateTokens(JSON.stringify(part.result ?? {})) + 8;
+	if (part.type === "step") return estimateTokens(part.title) + 4;
+	return 0;
+}
+function estimateMessageTokens(message) {
+	let messages = 4;
+	let tools = 0;
+	let reasoning = 0;
+	let toolCount = 0;
+	let reasoningCount = 0;
+	for (const part of message.parts) if (part.type === "tool") {
+		tools += estimatePartTokens(part);
+		toolCount += 1;
+	} else if (part.type === "reasoning") {
+		reasoning += estimatePartTokens(part);
+		reasoningCount += 1;
+	} else messages += estimatePartTokens(part);
+	return {
+		messages,
+		tools,
+		reasoning,
+		toolCount,
+		reasoningCount
+	};
+}
+function contextUsageLevel(percent) {
+	if (percent > 85) return "critical";
+	if (percent > 60) return "warn";
+	return "ok";
+}
+/** Estimate how much of the model context window the session currently occupies. */
+function estimateSessionContextUsage(session, modelRef) {
+	const limit = getModelContextLimit(modelRef);
+	const buckets = [
+		{
+			id: "summary",
+			label: "Summary",
+			tokens: 0,
+			count: 0
+		},
+		{
+			id: "messages",
+			label: "Chat text",
+			tokens: 0,
+			count: 0
+		},
+		{
+			id: "tools",
+			label: "Tools",
+			tokens: 0,
+			count: 0
+		},
+		{
+			id: "reasoning",
+			label: "Thinking",
+			tokens: 0,
+			count: 0
+		}
+	];
+	if (session?.compactionSummary) {
+		buckets[0].tokens = estimateTokens(session.compactionSummary);
+		buckets[0].count = 1;
+	}
+	for (const message of session?.history ?? []) {
+		const parts = estimateMessageTokens(message);
+		buckets[1].tokens += parts.messages;
+		buckets[1].count += 1;
+		buckets[2].tokens += parts.tools;
+		buckets[2].count += parts.toolCount;
+		buckets[3].tokens += parts.reasoning;
+		buckets[3].count += parts.reasoningCount;
+	}
+	const used = buckets.reduce((sum, b) => sum + b.tokens, 0);
+	const percent = limit > 0 ? Math.min(100, used / limit * 100) : 0;
+	return {
+		used,
+		limit,
+		percent,
+		remaining: Math.max(0, limit - used),
+		level: contextUsageLevel(percent),
+		buckets: buckets.filter((b) => b.tokens > 0),
+		modelRef
+	};
+}
+function formatTokenCount(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e4) return `${Math.round(n / 1e3)}k`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+	return String(Math.round(n));
+}
+function formatContextPercent(percent) {
+	if (percent <= 0) return "0%";
+	if (percent < 1) return "<1%";
+	if (percent < 10) return `${percent.toFixed(1)}%`;
+	return `${Math.round(percent)}%`;
+}
+function formatBucketDetail(bucket) {
+	const tokens = `${formatTokenCount(bucket.tokens)} tok`;
+	if (bucket.id === "summary") return tokens;
+	if (bucket.id === "messages") {
+		const n = bucket.count;
+		return `${n} msg${n === 1 ? "" : "s"} · ${tokens}`;
+	}
+	if (bucket.id === "tools") {
+		const n = bucket.count;
+		return `${n} call${n === 1 ? "" : "s"} · ${tokens}`;
+	}
+	return `${bucket.count} · ${tokens}`;
+}
+//#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. */
+var AUTO_COMPACT_AFTER = 40;
+/** Messages retained in the live transcript after compaction. */
+var COMPACT_KEEP_COUNT = 12;
+var CognitiveRuntime = class {
+	constructor() {
+		this.events = new RuntimeEvents();
+		this.sessions = new SessionRuntime();
+		this.memory = new CognitiveMemory();
+		this.providers = new ProviderRegistry();
+		this.models = new ModelRouter();
+		this.tools = new ToolBroker();
+		this.core = createCoreState(defaultNeeds());
+		this.policy = {
+			mode: "auto",
+			optimizeFor: "balance"
+		};
+		this.providersSettings = defaultProvidersSettings();
+		this.approvalMode = "auto_safe";
+		this.promptEnhancers = [];
+		this.permissionResolvers = /* @__PURE__ */ new Map();
+		this.started = false;
+		this.ready = Promise.resolve();
+	}
+	start() {
+		if (this.started) return;
+		this.started = true;
+		this.applyProvidersSettings(defaultProvidersSettings(), {
+			persist: false,
+			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] : [];
+		});
+		this.tools.setApprovalMode(this.approvalMode);
+		this.tools.setPermissionHandler(async (req) => this.requestPermission(req));
+		this.ready = this.hydrateAll();
+	}
+	/** Resolves after initial provider/settings hydrate. */
+	whenReady() {
+		this.start();
+		return this.ready;
+	}
+	getProvidersSettings() {
+		return structuredClone(this.providersSettings);
+	}
+	/** Models available for routing (`providerId/modelId`), including external plugins. */
+	listConfiguredModels() {
+		const ids = listConfiguredModelIds(this.providersSettings);
+		const seen = new Set(ids);
+		for (const provider of this.providers.listExternal()) {
+			const models = provider.listModels();
+			if (!Array.isArray(models)) continue;
+			for (const model of models) {
+				const id = `${provider.id}/${model.id}`;
+				if (seen.has(id)) continue;
+				seen.add(id);
+				ids.push(id);
+			}
+		}
+		return ids;
+	}
+	async setProvidersSettings(settings) {
+		this.applyProvidersSettings(settings, {
+			persist: true,
+			emit: true
+		});
+	}
+	/**
+	* Register a plugin ModelProvider (e.g. WebLLM) that survives settings rebuilds.
+	* Models from listModels() are merged into the router catalog as `providerId/modelId`.
+	*/
+	registerExternalProvider(provider) {
+		this.providers.registerExternal(provider);
+		this.rebuildCatalog();
+		this.events.publish(TOPIC.providersChanged, this.providersSettings);
+	}
+	unregisterExternalProvider(id) {
+		this.providers.unregisterExternal(id);
+		this.rebuildCatalog();
+		this.events.publish(TOPIC.providersChanged, this.providersSettings);
+	}
+	/** Append instructions to the specialist system prompt (e.g. RAG guidance). */
+	addSystemPromptEnhancer(enhancer) {
+		this.promptEnhancers.push(enhancer);
+		return () => {
+			this.promptEnhancers = this.promptEnhancers.filter((e) => e !== enhancer);
+		};
+	}
+	/** 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;
+	}
+	getModelPolicy() {
+		return this.policy;
+	}
+	getApprovalMode() {
+		return this.approvalMode;
+	}
+	setApprovalMode(mode) {
+		const changed = this.approvalMode !== mode;
+		this.approvalMode = mode;
+		this.tools.setRules([]);
+		this.tools.setApprovalMode(mode);
+		this.tools.setPermissionHandler(async (req) => this.requestPermission(req));
+		if (!changed) return;
+		this.events.publish(TOPIC.approvalModeChanged, mode);
+		this.persist();
+	}
+	/** Low-level override; prefer {@link setApprovalMode} for the convenience modes. */
+	setPermissionPolicy(policy) {
+		if (typeof policy === "function") {
+			this.tools.setPermissionHandler(policy);
+			return;
+		}
+		if (policy === "allow") this.setApprovalMode("auto_all");
+		else if (policy === "ask") this.setApprovalMode("manual");
+		else {
+			this.setApprovalMode("manual");
+			this.tools.setRules([{
+				pattern: "*",
+				action: "deny"
+			}]);
+		}
+		this.tools.setPermissionHandler(policy === "allow" ? null : async (req) => this.requestPermission(req));
+	}
+	resolvePermission(requestId, action) {
+		const resolve = this.permissionResolvers.get(requestId);
+		if (!resolve) return;
+		this.permissionResolvers.delete(requestId);
+		const focused = this.sessions.focused();
+		if (focused?.status === "waiting_approval") {
+			this.sessions.update(focused.id, { status: "running" });
+			this.emitSessions();
+		}
+		resolve(action);
+	}
+	/** Emit session list changes and persist them. */
+	commitSessions() {
+		this.emitSessions();
+		this.persist();
+	}
+	/** Ensure a focused session exists and return its id. */
+	ensureSessionId(sessionId) {
+		this.start();
+		if (sessionId && this.sessions.get(sessionId)) {
+			this.sessions.focus(sessionId);
+			return sessionId;
+		}
+		const focused = this.sessions.focused();
+		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) {
+		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));
+		if (!accepted.length) return [];
+		this.sessions.update(id, { attachments: [...session.attachments ?? [], ...accepted] });
+		this.commitSessions();
+		return accepted;
+	}
+	/** Remove an attachment payload from the session store. */
+	removeAttachment(sessionId, attachmentId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return false;
+		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();
+		return true;
+	}
+	/**
+	* Compact a session: drop older turns, store a summary (LLM when possible),
+	* and persist. The summary is injected into later model calls.
+	*/
+	async compactSession(sessionId, keepCount = COMPACT_KEEP_COUNT, signal) {
+		this.start();
+		await this.ready;
+		const prepared = this.sessions.prepareCompact(sessionId, keepCount);
+		if (!prepared?.didCompact) return { didCompact: false };
+		this.sessions.update(sessionId, { status: "compact" });
+		this.emitSessions();
+		let summary = prepared.summary;
+		const resolved = this.models.resolve({
+			role: "compact",
+			complexity: .2,
+			requireTools: false
+		}, this.policy);
+		const provider = this.providers.resolveProvider(resolved.model) ?? this.providers.list()[0];
+		if (provider) {
+			const llmSummary = await summarizeDroppedHistory({
+				provider,
+				model: resolved.model,
+				dropped: prepared.dropped,
+				previousSummary: this.sessions.get(sessionId)?.compactionSummary,
+				providerOptions: resolved.providerOptions,
+				signal
+			});
+			if (llmSummary) summary = llmSummary;
+		}
+		this.sessions.update(sessionId, {
+			history: prepared.kept,
+			compactionSummary: summary,
+			status: "idle"
+		});
+		this.commitSessions();
+		return { didCompact: true };
+	}
+	async prompt(input) {
+		this.start();
+		await loadModelsCatalog().catch(() => void 0);
+		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 existingIds = (input.attachmentIds ?? []).filter(Boolean);
+		const stored = this.sessions.get(session.id)?.attachments ?? [];
+		const byId = new Map(stored.map((a) => [a.id, a]));
+		const published = [];
+		for (const item of fresh) published.push(item);
+		for (const id of existingIds) {
+			const found = byId.get(id);
+			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");
+		const parts = [];
+		if (text) parts.push({
+			type: "text",
+			text
+		});
+		for (const item of published) parts.push(toFileRefPart(item));
+		const promptSummary = summarizePrompt(text, published.map((a) => ({
+			name: a.name,
+			kind: a.kind
+		})));
+		const userMessage = {
+			id: messageId,
+			role: "user",
+			parts,
+			createdAt: Date.now()
+		};
+		this.sessions.addMessage(session.id, userMessage);
+		if (isDefaultChatTitle(session.title)) this.sessions.update(session.id, { title: titleFromPrompt(promptSummary) });
+		const contextChunk = this.memory.upsert({
+			type: "context",
+			slots: {
+				kind: "user",
+				summary: promptSummary
+			},
+			scope: "session",
+			sessionId: session.id,
+			activation: .8
+		});
+		const retrieved = this.memory.retrieveForContext(promptSummary.split(/\s+/).slice(0, 12));
+		const buffers = {
+			...session.buffers,
+			retrieval: retrieved[0] ?? contextChunk
+		};
+		const tick = coreTick({
+			state: this.core,
+			buffers,
+			context: contextChunk
+		});
+		this.core = tick.state;
+		this.sessions.update(session.id, {
+			buffers: tick.buffers,
+			status: "running"
+		});
+		this.events.publish(TOPIC.coreTick, {
+			valenceDelta: tick.valenceDelta,
+			intent: tick.intent,
+			conscious: tick.state.conscious
+		});
+		const role = input.role ?? session.specialistMode ?? "build";
+		refreshCommandTools(this.tools, role);
+		const routeReq = {
+			role,
+			complexity: Math.min(1, text.length / 800),
+			requireTools: true
+		};
+		const resolved = this.models.resolve(routeReq, this.policy);
+		this.events.publish(TOPIC.modelRouted, resolved);
+		const provider = this.providers.resolveProvider(resolved.model) ?? this.providers.list()[0];
+		if (!provider) {
+			const err = {
+				id: `msg-${Date.now()}-e`,
+				role: "assistant",
+				parts: [{
+					type: "text",
+					text: "No model provider configured. Open AI Settings to add one."
+				}],
+				createdAt: Date.now()
+			};
+			this.sessions.addMessage(session.id, err);
+			this.sessions.update(session.id, { status: "idle" });
+			this.emitSessions();
+			return err;
+		}
+		const goal = tick.intent?.summary ?? promptSummary;
+		let systemPrompt = systemPromptFor(role, goal, { hasAttachments: published.length > 0 || (this.sessions.get(session.id)?.attachments?.length ?? 0) > 0 });
+		for (const enhance of this.promptEnhancers) systemPrompt = await enhance(systemPrompt, {
+			role,
+			goal,
+			sessionId: session.id
+		});
+		const liveSession = this.sessions.get(session.id);
+		const result = await runSpecialistLoop({
+			role,
+			systemPrompt,
+			history: liveSession.history,
+			compactionSummary: liveSession.compactionSummary,
+			resolved,
+			provider,
+			broker: this.tools,
+			refreshTools: () => refreshCommandTools(this.tools, role),
+			sessionId: session.id,
+			signal: input.signal,
+			onPart: (part) => this.events.publish(TOPIC.messagePart, {
+				sessionId: session.id,
+				part
+			})
+		});
+		this.models.recordOutcome(role, resolved.model, resolved.effort, result.success);
+		this.sessions.addMessage(session.id, result.message);
+		this.memory.upsert({
+			type: "episodic",
+			slots: {
+				kind: result.success ? "progress" : "error",
+				summary: goal
+			},
+			scope: "workspace",
+			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);
+		this.sessions.update(session.id, { status: "idle" });
+		this.events.publish(TOPIC.messageDone, {
+			sessionId: session.id,
+			message: result.message
+		});
+		this.emitSessions();
+		this.persist();
+		return result.message;
+	}
+	applyProvidersSettings(settings, opts) {
+		const normalized = normalizeProvidersSettings(settings);
+		this.providersSettings = normalized;
+		this.providers.clear();
+		const externalIds = new Set(this.providers.listExternal().map((p) => p.id));
+		for (const entry of normalized.providers) {
+			if (!entry.enabled || !entry.id) continue;
+			if (externalIds.has(entry.id)) continue;
+			const modelIds = parseModelIds(entry.models);
+			this.providers.register(new OpenAICompatibleProvider({
+				id: entry.id,
+				baseUrl: entry.baseUrl || "http://127.0.0.1",
+				apiKey: entry.apiKey || void 0,
+				defaultModels: modelIds.map((id) => ({
+					id,
+					name: id
+				}))
+			}));
+		}
+		this.rebuildCatalog();
+		if (opts.emit) this.events.publish(TOPIC.providersChanged, normalized);
+		if (opts.persist) this.persistProviders();
+	}
+	rebuildCatalog() {
+		const catalog = catalogFromSettings(this.providersSettings);
+		const seen = new Set(catalog.map((e) => e.id));
+		for (const provider of this.providers.listExternal()) {
+			const models = provider.listModels();
+			const list = Array.isArray(models) ? models : [];
+			for (const model of list) {
+				const id = `${provider.id}/${model.id}`;
+				if (seen.has(id)) continue;
+				seen.add(id);
+				catalog.push(externalCatalogEntry(id, provider.id));
+			}
+		}
+		this.models.setCatalog(catalog);
+	}
+	async requestPermission(req) {
+		const requestId = `perm-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+		this.sessions.update(req.sessionId, { status: "waiting_approval" });
+		this.emitSessions();
+		return new Promise((resolve) => {
+			this.permissionResolvers.set(requestId, resolve);
+			this.events.publish(TOPIC.permissionAsked, {
+				requestId,
+				...req
+			});
+		});
+	}
+	emitSessions() {
+		this.events.publish(TOPIC.sessionChanged, {
+			sessions: this.sessions.list(),
+			focusedId: this.sessions.focused()?.id ?? null
+		});
+	}
+	async hydrateAll() {
+		await loadModelsCatalog().catch(() => void 0);
+		await this.hydrateProviders();
+		this.applyProvidersSettings(this.providersSettings, {
+			persist: false,
+			emit: true
+		});
+		await this.hydrate();
+		if (!this.sessions.list().length) this.sessions.createSession({ title: "Chat" });
+		const mostRecent = this.sessions.list()[0];
+		if (mostRecent) this.sessions.focus(mostRecent.id);
+		this.emitSessions();
+	}
+	async hydrateProviders() {
+		try {
+			const saved = await persistenceService.getObject(PROVIDERS_PERSIST_KEY);
+			if (!saved?.providers?.length) return;
+			this.applyProvidersSettings(saved, {
+				persist: false,
+				emit: true
+			});
+		} catch {}
+	}
+	async persistProviders() {
+		try {
+			await persistenceService.persistObject(PROVIDERS_PERSIST_KEY, this.providersSettings);
+		} catch {}
+	}
+	async hydrate() {
+		try {
+			const saved = await persistenceService.getObject(PERSIST_KEY);
+			if (!saved) return;
+			if (saved.sessions) this.sessions.loadSnapshot(saved.sessions);
+			if (saved.memory) this.memory.restore(saved.memory);
+			if (saved.approvalMode && isToolApprovalMode(saved.approvalMode)) {
+				this.approvalMode = saved.approvalMode;
+				this.tools.setApprovalMode(saved.approvalMode);
+			}
+		} catch {}
+	}
+	async persist() {
+		try {
+			await persistenceService.persistObject(PERSIST_KEY, {
+				sessions: this.sessions.snapshot(),
+				memory: this.memory.snapshot(),
+				approvalMode: this.approvalMode
+			});
+		} catch {}
+	}
+};
+function isToolApprovalMode(value) {
+	return value === "manual" || value === "auto_safe" || value === "auto_all";
+}
+function externalCatalogEntry(id, providerId) {
+	return {
+		id,
+		providerId,
+		tier: "standard",
+		strengths: ["fast"],
+		effort: detectEffortCapability(id)
+	};
+}
+var cognitiveRuntime = new CognitiveRuntime();
+function isDefaultChatTitle(title) {
+	const t = title.trim().toLowerCase();
+	return !t || t === "chat" || t === "new chat" || t === "new session";
+}
+function titleFromPrompt(text) {
+	const trimmed = text.trim().replace(/\s+/g, " ");
+	if (!trimmed) return "Chat";
+	return trimmed.length <= 42 ? trimmed : `${trimmed.slice(0, 42).trimEnd()}…`;
+}
+function summarizePrompt(text, attachments) {
+	if (text) return text;
+	if (!attachments.length) return "";
+	if (attachments.length === 1) return `Attached ${attachments[0].name}`;
+	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 };
+
+//# sourceMappingURL=runtime-DfNGzEjU.js.map