scream-code 0.14.7 → 0.14.9

package/dist/{dispatch-MWaAkj2l.mjs → dispatch-1ojfKMwf.mjs}

@@ -4,9 +4,9 @@ import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import { i as __require, o as __toESM, r as __exportAll, t as __commonJSMin } from "./chunk-D90kvbyJ.mjs";
-import { C as join$1, D as resolve$1, E as relative$1, S as isAbsolute$1, T as parse$7, a as isSupportedFile, b as basename$1, i as ingestFile, r as ingestDirectory, t as multiSearch, w as normalize, x as dirname$2, y as KnowledgeStore } from "./src-BH9W5k24.mjs";
+import { C as join$1, D as resolve$1, E as relative$1, S as isAbsolute$1, T as parse$7, a as isSupportedFile, b as basename$1, i as ingestFile, r as ingestDirectory, t as multiSearch, w as normalize, x as dirname$2, y as KnowledgeStore } from "./src-tDEINaMV.mjs";
 import { t as require_base64_js } from "./base64-js-DzVmk6Nb.mjs";
-import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-B0yHChBj.mjs";
+import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-BUXAKycx.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fs$1 from "node:fs/promises";
@@ -37,11 +37,11 @@ import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import Pi from "assert";
 import ro from "node:assert";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import * as posixPath from "node:path/posix";
 import * as win32Path from "node:path/win32";
 import { createServer } from "node:http";
 import * as z$1 from "zod/v4";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { parse as parse$1, stringify } from "smol-toml";
 import "zod/v3";
 import * as z4mini from "zod/v4-mini";
@@ -751,7 +751,7 @@ function isOrphanedToolCallMessage(lowerMessage) {
 */
 function isOrphanedToolCallError(error) {
 	if (error instanceof APIOrphanedToolCallError) return true;
-	return isOrphanedToolCallMessage(errorMessage$5(error).toLowerCase());
+	return isOrphanedToolCallMessage(errorMessage$6(error).toLowerCase());
 }
 /**
 * The API returned an empty response (no content, no tool calls).
@@ -829,7 +829,7 @@ function isRequestTooLargeError(error) {
 	if (error instanceof APIStatusError) return error.statusCode === 413;
 	return false;
 }
-function errorMessage$5(error) {
+function errorMessage$6(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
@@ -1841,16 +1841,16 @@ const parseLogLevel$2 = (maybeLevel, sourceName, client) => {
 	if (hasOwn$3(levelNumbers$2, maybeLevel)) return maybeLevel;
 	loggerFor$2(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers$2))}`);
 };
-function noop$3() {}
+function noop$4() {}
 function makeLogFn$2(fnLevel, logger, logLevel) {
-	if (!logger || levelNumbers$2[fnLevel] > levelNumbers$2[logLevel]) return noop$3;
+	if (!logger || levelNumbers$2[fnLevel] > levelNumbers$2[logLevel]) return noop$4;
 	else return logger[fnLevel].bind(logger);
 }
 const noopLogger$2 = {
-	error: noop$3,
-	warn: noop$3,
-	info: noop$3,
-	debug: noop$3
+	error: noop$4,
+	warn: noop$4,
+	info: noop$4,
+	debug: noop$4
 };
 let cachedLoggers$2 = /* @__PURE__ */ new WeakMap();
 function loggerFor$2(client) {
@@ -10411,7 +10411,7 @@ var require_gaxios = /* @__PURE__ */ __commonJSMin(((exports) => {
 		}
 		static async #getFetch() {
 			const hasWindow = typeof window !== "undefined" && !!window;
-			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-C8lOjRbK.mjs")).default;
+			this.#fetch ||= hasWindow ? window.fetch : (await import("./src-C3oCiVNb.mjs")).default;
 			return this.#fetch;
 		}
 		/**
@@ -31847,16 +31847,16 @@ const parseLogLevel$1 = (maybeLevel, sourceName, client) => {
 	if (hasOwn$2(levelNumbers$1, maybeLevel)) return maybeLevel;
 	loggerFor$1(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers$1))}`);
 };
-function noop$2() {}
+function noop$3() {}
 function makeLogFn$1(fnLevel, logger, logLevel) {
-	if (!logger || levelNumbers$1[fnLevel] > levelNumbers$1[logLevel]) return noop$2;
+	if (!logger || levelNumbers$1[fnLevel] > levelNumbers$1[logLevel]) return noop$3;
 	else return logger[fnLevel].bind(logger);
 }
 const noopLogger$1 = {
-	error: noop$2,
-	warn: noop$2,
-	info: noop$2,
-	debug: noop$2
+	error: noop$3,
+	warn: noop$3,
+	info: noop$3,
+	debug: noop$3
 };
 let cachedLoggers$1 = /* @__PURE__ */ new WeakMap();
 function loggerFor$1(client) {
@@ -34836,7 +34836,7 @@ function normalizeScreamToolSchema(schema) {
 }
 function ensureScreamPropertyTypes(schema) {
 	const normalized = cloneJsonValue(schema);
-	if (!isRecord$4(normalized)) throw new Error("JSON Schema root must normalize to an object.");
+	if (!isRecord$5(normalized)) throw new Error("JSON Schema root must normalize to an object.");
 	recurseSchema(normalized);
 	return normalized;
 }
@@ -34897,7 +34897,7 @@ function resolveLocalJsonPointer(root, ref) {
 	let current = root;
 	for (const rawPart of ref.slice(2).split("/")) {
 		const part = unescapeJsonPointerPart(rawPart);
-		if (isRecord$4(current)) {
+		if (isRecord$5(current)) {
 			if (!hasOwn$1(current, part)) return { found: false };
 			current = current[part];
 		} else if (Array.isArray(current)) {
@@ -34919,20 +34919,20 @@ function parseJsonPointerArrayIndex(part) {
 	return Number(part);
 }
 function recurseSchema(node) {
-	if (!isRecord$4(node)) return;
+	if (!isRecord$5(node)) return;
 	visitChildSchemas(node, normalizeProperty);
 }
 function visitChildSchemas(node, visit) {
 	for (const { key, kind } of CHILD_SCHEMA_SLOTS) {
 		const value = node[key];
 		if (kind === "single") {
-			if (isRecord$4(value)) visit(value);
+			if (isRecord$5(value)) visit(value);
 		} else if (kind === "array") {
 			if (Array.isArray(value)) for (const item of value) visit(item);
 		} else if (kind === "map") {
-			if (isRecord$4(value)) for (const item of Object.values(value)) visit(item);
+			if (isRecord$5(value)) for (const item of Object.values(value)) visit(item);
 		} else if (kind === "schema-or-array") {
-			if (isRecord$4(value)) visit(value);
+			if (isRecord$5(value)) visit(value);
 			else if (Array.isArray(value)) for (const item of value) visit(item);
 		}
 	}
@@ -34944,7 +34944,7 @@ function childSchemaKeysForParentType(parentType) {
 	});
 }
 function normalizeProperty(node) {
-	if (!isRecord$4(node)) return;
+	if (!isRecord$5(node)) return;
 	if (!hasOwn$1(node, "type") && !hasAnyKey(node, TYPE_COMPLETION_SKIP_KEYS)) {
 		const enumValues = node["enum"];
 		if (Array.isArray(enumValues) && enumValues.length > 0) node["type"] = inferTypeFromValues(enumValues);
@@ -35008,14 +35008,14 @@ function hasAnyKey(obj, keys) {
 }
 function cloneJsonValue(value) {
 	if (Array.isArray(value)) return value.map((item) => cloneJsonValue(item));
-	if (isRecord$4(value)) {
+	if (isRecord$5(value)) {
 		const cloned = {};
 		for (const [key, child] of Object.entries(value)) cloned[key] = cloneJsonValue(child);
 		return cloned;
 	}
 	return value;
 }
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasOwn$1(obj, key) {
@@ -35785,16 +35785,16 @@ const parseLogLevel = (maybeLevel, sourceName, client) => {
 	if (hasOwn(levelNumbers, maybeLevel)) return maybeLevel;
 	loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
 };
-function noop$1() {}
+function noop$2() {}
 function makeLogFn(fnLevel, logger, logLevel) {
-	if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) return noop$1;
+	if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) return noop$2;
 	else return logger[fnLevel].bind(logger);
 }
 const noopLogger = {
-	error: noop$1,
-	warn: noop$1,
-	info: noop$1,
-	debug: noop$1
+	error: noop$2,
+	warn: noop$2,
+	info: noop$2,
+	debug: noop$2
 };
 let cachedLoggers = /* @__PURE__ */ new WeakMap();
 function loggerFor(client) {
@@ -44510,8 +44510,8 @@ function reasoningEffortToThinkingEffort(reasoning) {
 		case "minimal": return "low";
 		case "medium": return "medium";
 		case "high": return "high";
-		case "xhigh":
-		case "max": return "xhigh";
+		case "xhigh": return "xhigh";
+		case "max": return "max";
 		case "none": return "off";
 		default: return "off";
 	}
@@ -44941,6 +44941,7 @@ var ScreamChatProvider = class {
 	_baseUrl;
 	_defaultHeaders;
 	_generationKwargs;
+	_forceThinking;
 	_client;
 	_clientFactory;
 	_files;
@@ -44952,6 +44953,7 @@ var ScreamChatProvider = class {
 		this._clientFactory = options.clientFactory;
 		this._model = options.model;
 		this._stream = options.stream ?? true;
+		this._forceThinking = options.forceThinking;
 		this._generationKwargs = { ...options.generationKwargs };
 		this._client = this._apiKey === void 0 ? void 0 : new OpenAI({
 			apiKey: this._apiKey,
@@ -45024,12 +45026,8 @@ var ScreamChatProvider = class {
 		return UNKNOWN_CAPABILITY;
 	}
 	withThinking(effort) {
-		const thinking = { type: effort === "off" ? "disabled" : "enabled" };
 		let reasoningEffort;
 		switch (effort) {
-			case "off":
-				reasoningEffort = void 0;
-				break;
 			case "low":
 				reasoningEffort = "low";
 				break;
@@ -45037,11 +45035,18 @@ var ScreamChatProvider = class {
 				reasoningEffort = "medium";
 				break;
 			case "high":
+				reasoningEffort = "high";
+				break;
 			case "xhigh":
 			case "max":
-				reasoningEffort = "high";
+				reasoningEffort = "max";
+				break;
+			case "off":
+				reasoningEffort = void 0;
 				break;
 		}
+		if (effort === "off" && this._forceThinking === true) return this._withGenerationKwargs({ reasoning_effort: "low" }).withExtraBody({ thinking: { type: "enabled" } });
+		const thinking = { type: effort === "off" ? "disabled" : "enabled" };
 		return this._withGenerationKwargs({ reasoning_effort: reasoningEffort }).withExtraBody({ thinking });
 	}
 	withGenerationKwargs(kwargs) {
@@ -45247,6 +45252,7 @@ var OpenAILegacyChatProvider = class {
 	_reasoningKey;
 	_reasoningEffort;
 	_thinkingExplicitlyOff = false;
+	_forceThinking;
 	_generationKwargs;
 	_toolMessageConversion;
 	_client;
@@ -45262,6 +45268,7 @@ var OpenAILegacyChatProvider = class {
 		const normalizedReasoningKey = options.reasoningKey?.trim();
 		this._reasoningKey = normalizedReasoningKey !== void 0 && normalizedReasoningKey.length > 0 ? normalizedReasoningKey : void 0;
 		this._reasoningEffort = void 0;
+		this._forceThinking = options.forceThinking;
 		this._generationKwargs = {};
 		if (options.maxTokens !== void 0) this._generationKwargs.max_tokens = options.maxTokens;
 		this._toolMessageConversion = options.toolMessageConversion ?? null;
@@ -45315,9 +45322,16 @@ var OpenAILegacyChatProvider = class {
 		}
 	}
 	withThinking(effort) {
-		const reasoningEffort = thinkingEffortToReasoningEffort(effort);
+		let mapped = thinkingEffortToReasoningEffort(effort);
+		if (mapped === "xhigh") mapped = "max";
+		if (effort === "off" && this._forceThinking === true) {
+			const clone = this._clone();
+			clone._reasoningEffort = "low";
+			clone._thinkingExplicitlyOff = false;
+			return clone;
+		}
 		const clone = this._clone();
-		clone._reasoningEffort = reasoningEffort;
+		clone._reasoningEffort = mapped;
 		clone._thinkingExplicitlyOff = effort === "off";
 		return clone;
 	}
@@ -47448,7 +47462,7 @@ function isAbortError$1(err) {
 	if (err instanceof Error) return err.name === "AbortError";
 	return false;
 }
-function errorMessage$4(err) {
+function errorMessage$5(err) {
 	if (err instanceof Error) return err.message;
 	return String(err);
 }
@@ -52717,7 +52731,7 @@ var UpdateGoalTool = class {
 		try {
 			await goal.pauseGoal({ reason: "verifying" }, "system");
 		} catch (error) {
-			return toolError(`Failed to pause goal for verification: ${errorMessage$3(error)}`, goal);
+			return toolError(`Failed to pause goal for verification: ${errorMessage$4(error)}`, goal);
 		}
 		let rawGrade;
 		try {
@@ -52725,7 +52739,7 @@ var UpdateGoalTool = class {
 		} catch (error) {
 			const resumeError = await resumeAfterGrading(goal);
 			if (resumeError !== void 0) return resumeError;
-			const reason = `Goal verification could not be completed: ${errorMessage$3(error)}`;
+			const reason = `Goal verification could not be completed: ${errorMessage$4(error)}`;
 			this.appendGradingFeedback(reason);
 			return {
 				isError: true,
@@ -52753,7 +52767,7 @@ var UpdateGoalTool = class {
 					name: GOAL_COMPLETION_REMINDER_NAME
 				});
 			} catch (error) {
-				return toolError(`Failed to mark verified goal complete: ${errorMessage$3(error)}`, goal);
+				return toolError(`Failed to mark verified goal complete: ${errorMessage$4(error)}`, goal);
 			}
 			return {
 				output: `Goal verified and marked complete.\n${grade.reason}`,
@@ -52788,7 +52802,7 @@ async function resumeAfterGrading(goal) {
 		await goal.resumeGoal({}, "system");
 		return;
 	} catch (error) {
-		return toolError(`Failed to restore active goal after verification: ${errorMessage$3(error)}`, goal);
+		return toolError(`Failed to restore active goal after verification: ${errorMessage$4(error)}`, goal);
 	}
 }
 function toolError(message, goal) {
@@ -52797,7 +52811,7 @@ function toolError(message, goal) {
 		output: `${message}. Current goal status: ${goal.getGoal().goal?.status ?? "missing"}.`
 	};
 }
-function errorMessage$3(error) {
+function errorMessage$4(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
@@ -53178,12 +53192,15 @@ function createFastEmbedEngine(cacheDir) {
 	engineCache.set(key, engine);
 	return engine;
 }
+/** Stable identity of the model used by every engine created here. */
+const EMBEDDING_MODEL_NAME = "bge-small-zh-v1.5";
 function createFastEmbedEngineImpl(cacheDir) {
 	let embedder = null;
 	let initPromise = null;
 	let loadFailed = false;
 	let lastError;
 	return {
+		modelName: EMBEDDING_MODEL_NAME,
 		get available() {
 			return embedder !== null && !loadFailed;
 		},
@@ -53581,7 +53598,7 @@ var MemoryMemoStore = class MemoryMemoStore {
       CREATE TABLE IF NOT EXISTS memory_embeddings (
         memory_id TEXT PRIMARY KEY REFERENCES memos(id) ON DELETE CASCADE,
         embedding_json TEXT NOT NULL,
-        model TEXT NOT NULL DEFAULT 'bge-small-zh-v1.5',
+        model TEXT NOT NULL DEFAULT '${EMBEDDING_MODEL_NAME}',
         created_at INTEGER NOT NULL
       );
 
@@ -53887,7 +53904,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 			const now = Date.now();
 			this.db.exec("BEGIN TRANSACTION");
 			try {
-				for (let i = 0; i < pending.length; i++) insert.run(pending[i].id, JSON.stringify([...vectors[i]]), "bge-small-zh-v1.5", now);
+				for (let i = 0; i < pending.length; i++) insert.run(pending[i].id, JSON.stringify([...vectors[i]]), EMBEDDING_MODEL_NAME, now);
 				this.db.exec("COMMIT");
 			} catch (error) {
 				this.db.exec("ROLLBACK");
@@ -54896,7 +54913,7 @@ var KnowledgeLookupTool = class {
 				const llm = { generate: async (systemPrompt, userPrompt) => {
 					return this.agent.generateText(systemPrompt, userPrompt);
 				} };
-				const { multiSearchWithTrace } = await import("./src-DCp4eCi5.mjs");
+				const { multiSearchWithTrace } = await import("./src-h6ZExh4A.mjs");
 				const { results, trace } = await multiSearchWithTrace(store, llm, query, { topK });
 				if (results.length === 0) return {
 					isError: false,
@@ -59083,7 +59100,7 @@ function parseSkillText(options) {
 		throw error;
 	}
 	const frontmatter = parsed.data ?? {};
-	if (!isRecord$3(frontmatter)) throw new SkillParseError(`Frontmatter in ${options.skillMdPath} must be a mapping at the top level`);
+	if (!isRecord$4(frontmatter)) throw new SkillParseError(`Frontmatter in ${options.skillMdPath} must be a mapping at the top level`);
 	const metadata = normalizeMetadata(frontmatter);
 	if (!isSupportedSkillType(metadata.type)) throw new UnsupportedSkillTypeError(metadata.type ?? String(frontmatter["type"]));
 	const name = nonEmptyString$1(metadata.name);
@@ -59196,7 +59213,7 @@ function tokenizeArgs(raw) {
 function nonEmptyString$1(value) {
 	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
 }
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
@@ -64654,7 +64671,7 @@ function renderPrompt(template, vars) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/skill-tool.md
-var skill_tool_default = "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do NOT call the same skill repeatedly inside one turn — recursive depth is capped at {{ MAX_SKILL_QUERY_DEPTH }}.\n\n## Currently model-invocable skills\n{{ AVAILABLE_SKILLS }}\nThis list is a construction-time snapshot; for the live catalog inspect the skill registry.\n\n## Matching guide\n\n- A skill matches when the user's request involves the scenarios/trigger conditions listed in the skill's \"When to use\" line.\n- Look for: (a) keywords in the user's request that match the skill's trigger phrases, (b) the task type or scenario described in the skill's \"When to use\", (c) similar requests the skill was designed for.\n- If a skill seems relevant, invoke it first — if it doesn't fit, you can always fall back to doing it yourself.";
+var skill_tool_default = "Invoke a registered skill from the current skill listing. BLOCKING REQUIREMENT: when a skill from the listing matches the user's request, you MUST call this tool (not free-form text). Do NOT call the same skill repeatedly inside one turn — recursive depth is capped at {{ MAX_SKILL_QUERY_DEPTH }}.\n\n## Currently model-invocable skills\n{{ AVAILABLE_SKILLS }}\nThis list is a construction-time snapshot; for the live catalog inspect the skill registry.\n\n**Not for inventory questions**: when the user asks what you have — in any wording (skills / plugins / capabilities / MCP / tools) — answer with **InspectOwnAssets** (the full read-only catalog), not this listing. To find or install new capabilities, use **ManagePlugin**. This listing exists for **invocation**: when one of the skills above matches the task at hand.\n\n## Matching guide\n\n- A skill matches when the user's request involves the scenarios/trigger conditions listed in the skill's \"When to use\" line.\n- Look for: (a) keywords in the user's request that match the skill's trigger phrases, (b) the task type or scenario described in the skill's \"When to use\", (c) similar requests the skill was designed for.\n- If a skill seems relevant, invoke it first — if it doesn't fit, you can always fall back to doing it yourself.";
 /** Max skills to list inline in the tool description; rest are summarized. */
 const MAX_INLINE_SKILLS = 15;
 /** Max description length per skill line. */
@@ -64662,7 +64679,7 @@ const MAX_SKILL_DESC_CHARS = 100;
 function buildSkillToolDescription(agent) {
 	const skills = agent.skills?.registry.listInvocableSkills() ?? [];
 	const lines = skills.slice(0, MAX_INLINE_SKILLS).map((s) => {
-		const desc = s.description.trim().replaceAll(/\n/g, " ").slice(0, MAX_SKILL_DESC_CHARS);
+		const desc = s.description.trim().replaceAll("\n", " ").slice(0, MAX_SKILL_DESC_CHARS);
 		return `- ${s.name}: ${desc}`;
 	});
 	if (skills.length > MAX_INLINE_SKILLS) lines.push(`…${String(skills.length - MAX_INLINE_SKILLS)} more (see skill registry)`);
@@ -64726,6 +64743,8 @@ var SkillTool = class SkillTool {
 		if (skill.metadata.disableModelInvocation === true) return errorResult$1(`Skill "${args.skill}" can only be triggered by the user (model invocation is disabled).`);
 		const skillArgs = args.args ?? "";
 		if (!isInlineSkillType(skill.metadata.type)) return errorResult$1(`Skill "${skill.name}" is not an inline skill and cannot be invoked by the model in v1.`);
+		const owningPluginId = skill.plugin?.id;
+		if (owningPluginId !== void 0) this.agent.toolServices?.plugins?.recordUsage?.(owningPluginId, true);
 		const origin = skillOrigin(skill, skillArgs, currentDepth);
 		skills.recordActivation(origin);
 		const skillContent = skills.registry.renderSkillPrompt(skill, skillArgs);
@@ -66196,6 +66215,7 @@ const ModelAliasSchema = z.object({
 	displayName: z.string().optional(),
 	reasoningKey: z.string().optional(),
 	adaptiveThinking: z.boolean().optional(),
+	forceThinking: z.boolean().optional(),
 	thinkingLevels: z.array(ThinkingEffortSchema).optional()
 });
 const ThinkingConfigSchema = z.object({
@@ -66395,6 +66415,13 @@ const PLUGIN_NAME_REGEX = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 function normalizePluginId(name) {
 	return name.toLowerCase();
 }
+function summarizePluginSync(report) {
+	return {
+		ok: report.ok,
+		applied: report.applied,
+		failed: report.failed
+	};
+}
 //#endregion
 //#region ../../packages/agent-core/src/plugin/manifest.ts
 const SCREAM_PLUGIN_ROOT_PATH = "scream.plugin.json";
@@ -66507,11 +66534,11 @@ async function parseManifest(pluginRoot) {
 	return {
 		manifest: {
 			name,
-			version: stringField$1(raw, "version"),
-			description: stringField$1(raw, "description"),
-			keywords: stringArrayField$1(raw, "keywords"),
-			homepage: stringField$1(raw, "homepage"),
-			license: stringField$1(raw, "license"),
+			version: stringField$2(raw, "version"),
+			description: stringField$2(raw, "description"),
+			keywords: stringArrayField$2(raw, "keywords"),
+			homepage: stringField$2(raw, "homepage"),
+			license: stringField$2(raw, "license"),
 			author: readAuthor(raw["author"]),
 			skills,
 			sessionStart: readSessionStart(raw["sessionStart"], diagnostics),
@@ -66578,7 +66605,7 @@ function readHooks(pluginRoot, raw, diagnostics) {
 			});
 			continue;
 		}
-		const event = stringField$1(entry, "event");
+		const event = stringField$2(entry, "event");
 		if (event === void 0) {
 			diagnostics.push({
 				severity: "warn",
@@ -66586,7 +66613,7 @@ function readHooks(pluginRoot, raw, diagnostics) {
 			});
 			continue;
 		}
-		let command = stringField$1(entry, "command");
+		let command = stringField$2(entry, "command");
 		if (command === void 0) {
 			diagnostics.push({
 				severity: "warn",
@@ -66599,7 +66626,7 @@ function readHooks(pluginRoot, raw, diagnostics) {
 		const hook = {
 			event,
 			command,
-			...stringField$1(entry, "matcher") !== void 0 ? { matcher: stringField$1(entry, "matcher") } : {},
+			...stringField$2(entry, "matcher") !== void 0 ? { matcher: stringField$2(entry, "matcher") } : {},
 			...timeout !== void 0 ? { timeout } : {}
 		};
 		out.push(hook);
@@ -66774,8 +66801,8 @@ async function normalizePluginMcpServer(input) {
 function readAuthor(raw) {
 	if (typeof raw === "string") return { name: raw };
 	if (!isObject(raw)) return void 0;
-	const name = stringField$1(raw, "name");
-	const email = stringField$1(raw, "email");
+	const name = stringField$2(raw, "name");
+	const email = stringField$2(raw, "email");
 	if (name === void 0 && email === void 0) return void 0;
 	return {
 		name,
@@ -66785,21 +66812,21 @@ function readAuthor(raw) {
 function readInterface(raw) {
 	if (!isObject(raw)) return void 0;
 	const out = {
-		displayName: stringField$1(raw, "displayName"),
-		shortDescription: stringField$1(raw, "shortDescription"),
-		longDescription: stringField$1(raw, "longDescription"),
-		developerName: stringField$1(raw, "developerName"),
-		websiteURL: stringField$1(raw, "websiteURL")
+		displayName: stringField$2(raw, "displayName"),
+		shortDescription: stringField$2(raw, "shortDescription"),
+		longDescription: stringField$2(raw, "longDescription"),
+		developerName: stringField$2(raw, "developerName"),
+		websiteURL: stringField$2(raw, "websiteURL")
 	};
 	return Object.values(out).some((value) => value !== void 0) ? out : void 0;
 }
-function stringField$1(raw, key) {
+function stringField$2(raw, key) {
 	const value = raw[key];
 	if (typeof value !== "string") return void 0;
 	const trimmed = value.trim();
 	return trimmed.length === 0 ? void 0 : trimmed;
 }
-function stringArrayField$1(raw, key) {
+function stringArrayField$2(raw, key) {
 	const value = raw[key];
 	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) return;
 	return value;
@@ -66945,6 +66972,24 @@ async function writeInstalled(screamHomeDir, data) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/plugin/source.ts
+/** Compare dotted numeric versions (e.g. "1.2.0"); undefined when either side has no leading dotted-numeric segment. */
+function compareManifestVersions(a, b) {
+	const parse = (value) => {
+		if (typeof value !== "string") return void 0;
+		const captured = value.trim().match(/^v?(\d+(?:\.\d+){0,3})/)?.[1];
+		if (captured === void 0) return void 0;
+		return captured.split(".").map(Number);
+	};
+	const left = parse(a);
+	const right = parse(b);
+	if (left === void 0 || right === void 0) return void 0;
+	for (let index = 0; index < 3; index += 1) {
+		const lhs = left[index] ?? 0;
+		const rhs = right[index] ?? 0;
+		if (lhs !== rhs) return lhs < rhs ? -1 : 1;
+	}
+	return 0;
+}
 const SHA_RE = /^[0-9a-f]{7,40}$/;
 const GITHUB_NAME_RE = /^[A-Za-z0-9._-]+$/;
 function resolveInstallSource(source) {
@@ -67036,6 +67081,198 @@ function decodeRefSegments(segments) {
 	}).join("/");
 }
 //#endregion
+//#region ../../packages/agent-core/src/plugin/quarantine.ts
+function quarantinePath(screamHomeDir) {
+	return path.join(screamHomeDir, "plugins", "quarantine.json");
+}
+/** Normalize a raw user-provided source string into its origin key. */
+function sourceKeyFromRawSource(source) {
+	const trimmed = source.trim();
+	const github = trimmed.match(/github\.com[/]([^/]+)[/]([^/#?\s]+)/);
+	if (github !== null) return `github:${github[1]}/${github[2]}`;
+	return trimmed;
+}
+/** Origin key for an installed record's persisted fields. */
+function sourceKeyFromFields(fields) {
+	if (fields.github !== void 0) return `github:${fields.github.owner}/${fields.github.repo}`;
+	return fields.originalSource ?? "";
+}
+async function readQuarantine(screamHomeDir) {
+	try {
+		const entries = JSON.parse(await readFile(quarantinePath(screamHomeDir), "utf8")).entries;
+		return Array.isArray(entries) ? entries : [];
+	} catch {
+		return [];
+	}
+}
+async function appendQuarantine(screamHomeDir, entry) {
+	const entries = await readQuarantine(screamHomeDir);
+	entries.push(entry);
+	const file = {
+		version: 1,
+		entries: entries.slice(-200)
+	};
+	await mkdir(path.dirname(quarantinePath(screamHomeDir)), { recursive: true });
+	await writeFile(quarantinePath(screamHomeDir), `${JSON.stringify(file, null, 2)}\n`, "utf8");
+}
+/** Mark the newest unacknowledged entry for this key; no-op when absent. */
+async function acknowledgeQuarantine(screamHomeDir, sourceKey) {
+	const entries = await readQuarantine(screamHomeDir);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	let changed = false;
+	for (let index = 0; index < entries.length; index += 1) {
+		const candidate = entries[index];
+		if (candidate === void 0) continue;
+		if (candidate.sourceKey === sourceKey && candidate.acknowledgedAt === void 0) {
+			entries[index] = {
+				...candidate,
+				acknowledgedAt: now
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return;
+	const file = {
+		version: 1,
+		entries
+	};
+	await writeFile(quarantinePath(screamHomeDir), `${JSON.stringify(file, null, 2)}\n`, "utf8");
+}
+/** Newest unacknowledged entry for a normalized origin key, if any. */
+function matchQuarantine(entries, sourceKey) {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const candidate = entries[index];
+		if (candidate === void 0) continue;
+		if (candidate.sourceKey === sourceKey && candidate.acknowledgedAt === void 0) return candidate;
+	}
+}
+//#endregion
+//#region ../../packages/agent-core/src/plugin/stats.ts
+const STATS_DEBOUNCE_MS = 5e3;
+const caches = /* @__PURE__ */ new Map();
+function statsPath(screamHomeDir) {
+	return path.join(screamHomeDir, "plugins", "stats.json");
+}
+function cacheFor(screamHomeDir) {
+	let cache = caches.get(screamHomeDir);
+	if (cache === void 0) {
+		cache = {
+			loaded: false,
+			base: /* @__PURE__ */ new Map(),
+			deltas: /* @__PURE__ */ new Map(),
+			timer: void 0
+		};
+		caches.set(screamHomeDir, cache);
+	}
+	return cache;
+}
+async function loadIntoCache(screamHomeDir) {
+	const cache = cacheFor(screamHomeDir);
+	if (cache.loaded) return cache.base;
+	try {
+		const byId = JSON.parse(await readFile(statsPath(screamHomeDir), "utf8")).byId ?? {};
+		for (const [id, entry] of Object.entries(byId)) if (typeof entry.calls === "number" && typeof entry.okCalls === "number") cache.base.set(id, {
+			calls: entry.calls,
+			okCalls: entry.okCalls,
+			lastUsedAt: entry.lastUsedAt
+		});
+	} catch {}
+	cache.loaded = true;
+	return cache.base;
+}
+function mergeEntry(entry, delta) {
+	entry.calls += delta.calls;
+	entry.okCalls += delta.okCalls;
+	entry.lastUsedAt = delta.lastUsedAt;
+}
+/** Effective view = base ⊕ current deltas (deltas survive independently of load timing). */
+async function effectiveEntries(screamHomeDir) {
+	const cache = cacheFor(screamHomeDir);
+	const base = await loadIntoCache(screamHomeDir);
+	if (cache.deltas.size === 0) return base;
+	const merged = new Map(base);
+	for (const [id, delta] of cache.deltas) {
+		const entry = { ...merged.get(id) ?? {
+			calls: 0,
+			okCalls: 0,
+			lastUsedAt: void 0
+		} };
+		mergeEntry(entry, delta);
+		merged.set(id, entry);
+	}
+	return merged;
+}
+/** Force-write base⊕deltas for one home; safe to call repeatedly. */
+async function flushStats(screamHomeDir) {
+	const cache = cacheFor(screamHomeDir);
+	if (cache.timer !== void 0) {
+		clearTimeout(cache.timer);
+		cache.timer = void 0;
+	}
+	const base = await loadIntoCache(screamHomeDir);
+	for (const [id, delta] of cache.deltas) {
+		const entry = base.get(id) ?? {
+			calls: 0,
+			okCalls: 0,
+			lastUsedAt: void 0
+		};
+		mergeEntry(entry, delta);
+		base.set(id, entry);
+	}
+	cache.deltas.clear();
+	const byId = {};
+	for (const [id, entry] of base) byId[id] = { ...entry };
+	await mkdir(path.dirname(statsPath(screamHomeDir)), { recursive: true });
+	const file = {
+		version: 1,
+		byId
+	};
+	await writeFile(statsPath(screamHomeDir), `${JSON.stringify(file, null, 2)}\n`, "utf8");
+}
+/** Arm the debounced writer at most once per home (first-schedule semantics). */
+function ensureFlushScheduled(screamHomeDir) {
+	const cache = cacheFor(screamHomeDir);
+	if (cache.timer !== void 0) return;
+	cache.timer = setTimeout(() => {
+		cache.timer = void 0;
+		flushStats(screamHomeDir).catch(() => {});
+	}, STATS_DEBOUNCE_MS);
+}
+/** Synchronous counter bump into the delta layer; disk write is debounced. */
+function recordUsageInMemory(screamHomeDir, pluginId, ok) {
+	const cache = cacheFor(screamHomeDir);
+	const existing = cache.deltas.get(pluginId) ?? {
+		calls: 0,
+		okCalls: 0,
+		lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	cache.deltas.set(pluginId, {
+		calls: existing.calls + 1,
+		okCalls: existing.okCalls + (ok ? 1 : 0),
+		lastUsedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	loadIntoCache(screamHomeDir);
+	ensureFlushScheduled(screamHomeDir);
+}
+/** Drop counters for a removed/uninstalled plugin id (base and deltas).
+* Best-effort: the in-memory delete always happens; a failed disk flush must
+* never fail the removal whose caller depends on it. */
+async function forgetStats(screamHomeDir, pluginId) {
+	cacheFor(screamHomeDir).deltas.delete(pluginId);
+	(await loadIntoCache(screamHomeDir)).delete(pluginId);
+	try {
+		await flushStats(screamHomeDir);
+	} catch {}
+}
+/** Read-through snapshot used by tool surfaces (check/list views). */
+async function getUsage(screamHomeDir, pluginId) {
+	return (await effectiveEntries(screamHomeDir)).get(pluginId) ?? {
+		calls: 0,
+		okCalls: 0,
+		lastUsedAt: void 0
+	};
+}
+//#endregion
 //#region ../../packages/agent-core/src/plugin/manager.ts
 const SCREAM_NODE_FALLBACK_SUBCOMMAND = "__plugin_run_node";
 var PluginManager = class {
@@ -67162,6 +67399,243 @@ var PluginManager = class {
 		await this.persist();
 		return record;
 	}
+	/**
+	* Replace an already-installed plugin's files from `source`, keeping a
+	* single-slot backup of the previous contents under
+	* `plugins/backups/<id>/`. Unlike a plain reinstall this records the
+	* version transition and refuses to run for unknown ids, so it can always
+	* be paired with `rollback`.
+	*/
+	async upgrade(source) {
+		const resolved = resolveInstallSource(source);
+		const isLocal = resolved.kind === "local-path";
+		let stagedRoot;
+		let originalSource;
+		let sourceType;
+		let parsed;
+		let github;
+		let remoteTmpRoot;
+		if (resolved.kind === "local-path") {
+			stagedRoot = await normalizeInstallRoot(resolved.path);
+			originalSource = resolved.path;
+			sourceType = "local-path";
+			parsed = await parseManifest(stagedRoot);
+			if (parsed.manifest === void 0) {
+				const msg = parsed.diagnostics.find((d) => d.severity === "error")?.message ?? "no manifest";
+				throw new Error(`Cannot upgrade plugin at ${stagedRoot}: ${msg}`);
+			}
+		} else {
+			let zipUrl;
+			const tmpDir = await mkdtemp(path.join(tmpdir(), "scream-plugin-upgrade-"));
+			stagedRoot = tmpDir;
+			remoteTmpRoot = tmpDir;
+			try {
+				if (resolved.kind === "github") {
+					const githubResolution = await resolveGithubSource(resolved);
+					zipUrl = githubResolution.tarballUrl;
+					originalSource = source.trim();
+					sourceType = "github";
+					github = {
+						owner: resolved.owner,
+						repo: resolved.repo,
+						ref: githubResolution.ref
+					};
+				} else {
+					zipUrl = resolved.path;
+					originalSource = resolved.path;
+					sourceType = "zip-url";
+				}
+				stagedRoot = await extractZip(await downloadZip(zipUrl), tmpDir);
+				parsed = await parseManifest(stagedRoot);
+				if (parsed.manifest === void 0) {
+					const msg = parsed.diagnostics.find((d) => d.severity === "error")?.message ?? "no manifest";
+					throw new Error(`Cannot upgrade plugin from ${originalSource}: ${msg}`);
+				}
+			} catch (error) {
+				await rm(tmpDir, {
+					recursive: true,
+					force: true
+				});
+				throw error;
+			}
+		}
+		const disposeStaged = async () => {
+			if (!isLocal) {
+				await rm(stagedRoot, {
+					recursive: true,
+					force: true
+				});
+				if (remoteTmpRoot !== void 0 && remoteTmpRoot !== stagedRoot) await rm(remoteTmpRoot, {
+					recursive: true,
+					force: true
+				});
+			}
+		};
+		try {
+			const id = normalizePluginId(parsed.manifest.name);
+			const existing = this.records.get(id);
+			if (existing === void 0) throw new Error(`Plugin "${id}" is not installed; upgrade requires an existing installation`);
+			const oldVersion = existing.manifest?.version;
+			const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-");
+			const backupsForId = path.join(this.screamHomeDir, "plugins", "backups", id);
+			const backupPath = path.join(backupsForId, `${stamp}-${(oldVersion ?? "unknown").replaceAll(/[:.]/g, "-")}`);
+			await mkdir(backupPath, { recursive: true });
+			await cp(existing.root, backupPath, { recursive: true });
+			try {
+				await writeFile(path.join(backupPath, ".scream-rollback.json"), JSON.stringify({
+					originalSource: existing.originalSource,
+					source: existing.source,
+					...existing.github !== void 0 ? { github: existing.github } : {}
+				}), "utf8");
+			} catch {}
+			await keepNewestBackupOnly(backupsForId);
+			const comparison = compareManifestVersions(oldVersion, parsed.manifest.version);
+			const warn = comparison === void 0 ? "unknown" : comparison === 0 ? "same" : comparison === 1 ? "downgrade" : void 0;
+			const promotedRoot = await copyPluginToManagedRoot(this.screamHomeDir, id, stagedRoot);
+			const promoted = await parseManifest(promotedRoot);
+			const baseRecord = await recordFrom({
+				id,
+				root: promotedRoot,
+				enabled: existing.enabled,
+				installedAt: existing.installedAt,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				originalSource,
+				source: sourceType,
+				capabilities: existing.capabilities,
+				github,
+				parsed: promoted
+			});
+			const note = `upgraded ${oldVersion ?? "unknown"} -> ${promoted.manifest?.version ?? "unknown"}`;
+			const record = {
+				...baseRecord,
+				diagnostics: [...baseRecord.diagnostics, {
+					severity: "info",
+					message: note
+				}]
+			};
+			this.records.set(id, record);
+			await this.persist();
+			return {
+				record,
+				from: oldVersion,
+				to: promoted.manifest?.version,
+				...warn !== void 0 ? { warn } : {},
+				backupPath
+			};
+		} finally {
+			await disposeStaged();
+		}
+	}
+	/**
+	* Restore a plugin's files from its newest backup (created by `upgrade`),
+	* then reload the table. The backup manifest is validated BEFORE anything
+	* under plugins/managed is touched.
+	*/
+	async rollback(id) {
+		const key = normalizePluginId(id);
+		const existing = this.records.get(key);
+		if (existing === void 0) throw new Error(`Plugin "${id}" is not installed`);
+		const backupsForId = path.join(this.screamHomeDir, "plugins", "backups", key);
+		let newest;
+		try {
+			newest = (await readdir(backupsForId)).toSorted().at(-1);
+		} catch {
+			newest = void 0;
+		}
+		if (newest === void 0) throw new Error(`No backup available for "${key}"`);
+		const backupRoot = path.join(backupsForId, newest);
+		if ((await parseManifest(backupRoot)).manifest === void 0) throw new Error(`Backup at ${backupRoot} has no readable manifest`);
+		let preUpgrade = {};
+		try {
+			preUpgrade = JSON.parse(await readFile(path.join(backupRoot, ".scream-rollback.json"), "utf8"));
+		} catch {}
+		const promotedRoot = await copyPluginToManagedRoot(this.screamHomeDir, key, backupRoot);
+		await rm(path.join(promotedRoot, ".scream-rollback.json"), {
+			recursive: true,
+			force: true
+		});
+		const promoted = await parseManifest(promotedRoot);
+		const baseRecord = await recordFrom({
+			id: key,
+			root: promotedRoot,
+			enabled: existing.enabled,
+			installedAt: existing.installedAt,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			originalSource: preUpgrade.originalSource ?? existing.originalSource,
+			source: preUpgrade.source ?? existing.source,
+			capabilities: existing.capabilities,
+			github: preUpgrade.github ?? existing.github,
+			parsed: promoted
+		});
+		const record = {
+			...baseRecord,
+			diagnostics: [...baseRecord.diagnostics, {
+				severity: "info",
+				message: `rolled back to backup ${newest}`
+			}]
+		};
+		this.records.set(key, record);
+		await this.persist();
+		return {
+			record,
+			restoredFrom: backupRoot
+		};
+	}
+	/**
+	* Immune memory: remember the ORIGIN of a circuit-tripped plugin so future
+	* sessions can warn before installing from the same repository again.
+	* Best-effort bookkeeping; unknown/local-less records are silently skipped.
+	*/
+	async appendQuarantine(pluginId, reason) {
+		const key = normalizePluginId(pluginId);
+		const record = this.records.get(key);
+		if (record === void 0) return void 0;
+		const sourceKey = sourceKeyFromFields({
+			github: record.github,
+			originalSource: record.originalSource
+		});
+		if (sourceKey === "") return void 0;
+		const entry = {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			pluginId: key,
+			...record.manifest?.name !== void 0 ? { name: record.manifest.name } : {},
+			sourceKey,
+			reason
+		};
+		await appendQuarantine(this.screamHomeDir, entry);
+		return entry;
+	}
+	/** Newest unacknowledged quarantine hit for a raw source string, if any.
+	* Both the verbatim and the realpath-resolved forms are tried, because
+	* temp-dir fixtures and user paths can differ by symlinks (macOS /var).
+	*/
+	async matchQuarantineForSource(source) {
+		const entries = await readQuarantine(this.screamHomeDir);
+		for (const key of await this.quarantineKeysFor(source)) {
+			const hit = matchQuarantine(entries, key);
+			if (hit !== void 0) return hit;
+		}
+	}
+	/** Clear the pending warning for a source once an approved install landed. */
+	async acknowledgeQuarantineForSource(source) {
+		for (const key of await this.quarantineKeysFor(source)) await acknowledgeQuarantine(this.screamHomeDir, key);
+	}
+	/** Advisory usage counters (see plugin/stats.ts); unknown ids are ignored. */
+	recordUsage(pluginId, ok) {
+		const key = normalizePluginId(pluginId);
+		if (!this.records.has(key)) return;
+		recordUsageInMemory(this.screamHomeDir, key, ok);
+	}
+	async getUsage(pluginId) {
+		return getUsage(this.screamHomeDir, normalizePluginId(pluginId));
+	}
+	async quarantineKeysFor(source) {
+		const keys = [sourceKeyFromRawSource(source)];
+		try {
+			keys.push(sourceKeyFromRawSource(await realpath(source)));
+		} catch {}
+		return [...new Set(keys.filter((key) => key !== ""))];
+	}
 	async setEnabled(id, enabled) {
 		const key = normalizePluginId(id);
 		const current = this.records.get(key);
@@ -67195,9 +67669,37 @@ var PluginManager = class {
 		});
 		await this.persist();
 	}
+	/**
+	* Flag a plugin as failed at runtime (typically its code entry point threw
+	* while activating). The record keeps the reason as an error diagnostic so
+	* `/plugin info` and listings show why the plugin is not usable.
+	*/
+	async markError(id, message) {
+		const key = normalizePluginId(id);
+		const current = this.records.get(key);
+		if (current === void 0) {
+			log.warn("plugin markError for an unknown plugin", {
+				pluginId: id,
+				message
+			});
+			return;
+		}
+		const diagnostic = {
+			severity: "error",
+			message
+		};
+		this.records.set(key, {
+			...current,
+			state: "error",
+			diagnostics: [...current.diagnostics, diagnostic],
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		await this.persist();
+	}
 	async remove(id) {
 		const key = normalizePluginId(id);
 		if (!this.records.delete(key)) throw new Error(`Plugin "${id}" is not installed`);
+		await forgetStats(this.screamHomeDir, key);
 		await this.persist();
 	}
 	async reload() {
@@ -67286,6 +67788,9 @@ var PluginManager = class {
 			version: 1,
 			plugins: installed
 		});
+		try {
+			await flushStats(this.screamHomeDir);
+		} catch {}
 	}
 	async materialize(entry) {
 		const parsed = await parseManifest(entry.root);
@@ -67336,6 +67841,25 @@ async function copyPluginToManagedRoot(screamHomeDir, id, sourceRoot) {
 	}
 	return realpath(managedRoot);
 }
+/**
+* Keep only the newest backup slot per plugin id: upgrade creates a fresh
+* timestamped directory each run, so older siblings are removed here to keep
+* backups bounded. Names sort chronologically because they embed an
+* ISO-derived stamp.
+*/
+async function keepNewestBackupOnly(backupsForId) {
+	let names;
+	try {
+		names = await readdir(backupsForId);
+	} catch {
+		return;
+	}
+	const ordered = names.toSorted();
+	for (const name of ordered.slice(0, Math.max(0, ordered.length - 1))) await rm(path.join(backupsForId, name), {
+		recursive: true,
+		force: true
+	});
+}
 async function recordFrom(input) {
 	const { parsed } = input;
 	const hasError = parsed.diagnostics.some((d) => d.severity === "error");
@@ -67440,7 +67964,26 @@ function withMcpServerEnabled(config, enabled) {
 	};
 }
 function pluginMcpRuntimeName(pluginId, serverName) {
-	return `plugin-${pluginId}:${serverName}`;
+	return `${PLUGIN_MCP_RUNTIME_PREFIX}${pluginId}:${serverName}`;
+}
+/** Runtime-name prefix that marks an MCP server as contributed by a plugin. */
+const PLUGIN_MCP_RUNTIME_PREFIX = "plugin-";
+/**
+* True when an MCP runtime name belongs to a plugin. Anything else is
+* user-configured and must never be touched by the plugin hot-apply pass.
+*/
+function isPluginMcpRuntimeName(name) {
+	return name.startsWith(PLUGIN_MCP_RUNTIME_PREFIX);
+}
+/**
+* The plugin id embedded in a plugin MCP runtime name, or `undefined` for a
+* user-configured server or a name that is not well-formed.
+*/
+function pluginIdFromMcpRuntimeName(name) {
+	if (!isPluginMcpRuntimeName(name)) return void 0;
+	const separator = name.indexOf(":");
+	if (separator <= 7) return void 0;
+	return name.slice(7, separator);
 }
 function withPluginMcpRuntime(config, pluginRoot, screamHomeDir) {
 	if (config.transport === "http") return config;
@@ -67475,7 +68018,7 @@ function isSafeRelativePath(filePath) {
 	return !normalized.startsWith("/");
 }
 async function writePluginSkillPackage(options) {
-	const { jian, screamHomeDir, package: pkg } = options;
+	const { jian, screamHomeDir, manager, package: pkg } = options;
 	const name = sanitizeSkillName(pkg.name);
 	const targetDir = join$1(screamHomeDir, "plugins", "managed", name);
 	if (await pathExists$1(jian, targetDir)) throw new ScreamError(ErrorCodes.SKILL_ALREADY_EXISTS, `Skill "${name}" already exists at ${targetDir}. Choose a different name or delete the existing skill first.`);
@@ -67512,14 +68055,21 @@ async function writePluginSkillPackage(options) {
 		if (error instanceof ScreamError) throw error;
 		throw new ScreamError(ErrorCodes.SKILL_INSTALL_FAILED, `Failed to write skill files to ${targetDir}: ${error instanceof Error ? error.message : String(error)}`);
 	}
+	let registered;
 	try {
-		const manager = new PluginManager({ screamHomeDir });
-		await manager.load();
-		await manager.registerGenerated(targetDir);
+		if (manager !== void 0) registered = await manager.registerGenerated(targetDir);
+		else {
+			const owned = new PluginManager({ screamHomeDir });
+			await owned.load();
+			registered = await owned.registerGenerated(targetDir);
+		}
 	} catch (error) {
 		throw new ScreamError(ErrorCodes.SKILL_INSTALL_FAILED, `Failed to register skill in plugin center: ${error instanceof Error ? error.message : String(error)}`);
 	}
-	return { targetDir };
+	return {
+		targetDir,
+		pluginId: registered.id
+	};
 }
 async function pathExists$1(jian, filePath) {
 	try {
@@ -67569,11 +68119,19 @@ var MakeSkillApplyTool = class {
 				content: args.content,
 				files: args.files ?? []
 			};
-			return { output: `Skill installed to ${(await writePluginSkillPackage({
+			const result = await writePluginSkillPackage({
 				jian: this.agent.jian,
 				screamHomeDir,
+				manager: this.agent.toolServices?.plugins,
 				package: pkg
-			})).targetDir}\n\nYou can manage it in the Skill Center with /plugin, and invoke it with /${sanitizeSkillName(args.name)} in a new session.` };
+			});
+			const sync = this.agent.toolServices?.pluginSync;
+			let hotApplied = false;
+			if (sync !== void 0) try {
+				const report = await sync([result.pluginId], { skipMcpAdd: true });
+				hotApplied = report.ok || report.applied.length > 0;
+			} catch {}
+			return { output: `Skill installed to ${result.targetDir}\n\nYou can manage it in the Skill Center with /plugin, and invoke it with /${sanitizeSkillName(args.name)}` + (hotApplied ? " right away — it was hot-applied to this session." : " in a new session.") };
 		} catch (error) {
 			if (error instanceof ScreamError) return {
 				isError: true,
@@ -71847,10 +72405,10 @@ async function findExistingRg(shareDir) {
 		source: "share-bin-cached"
 	};
 }
-let downloadPromise;
+let downloadPromise$1;
 async function downloadRgWithLock(shareDir) {
-	if (downloadPromise !== void 0) return downloadPromise;
-	downloadPromise = (async () => {
+	if (downloadPromise$1 !== void 0) return downloadPromise$1;
+	downloadPromise$1 = (async () => {
 		try {
 			const existing = await findExistingRg(shareDir);
 			if (existing) return existing;
@@ -71859,10 +72417,10 @@ async function downloadRgWithLock(shareDir) {
 				source: "share-bin-downloaded"
 			};
 		} finally {
-			downloadPromise = void 0;
+			downloadPromise$1 = void 0;
 		}
 	})();
-	return downloadPromise;
+	return downloadPromise$1;
 }
 function rgBinaryName() {
 	return process.platform === "win32" ? "rg.exe" : "rg";
@@ -74686,6 +75244,796 @@ function truncateUtf8$1(input, maxBytes) {
 	return `${input.slice(0, low)}${suffix}`;
 }
 //#endregion
+//#region ../../packages/agent-core/src/plugin/marketplace.ts
+/**
+* Read-only plugin marketplace catalog.
+*
+* This module mirrors the shape the TUI consumes so a main agent can browse the
+* same catalog from inside a session. It intentionally does NOT download or
+* install anything: it only reads a JSON document and returns display fields.
+* Nothing here feeds the permission chain — a marketplace `tier` is a label, and
+* `install` always goes through its own approval gate regardless of it.
+*/
+/** Env var that overrides the catalog location. Shared name with the TUI copy. */
+const SCREAM_CODE_PLUGIN_MARKETPLACE_URL_ENV$1 = "SCREAM_CODE_PLUGIN_MARKETPLACE_URL";
+/** Network budget for a catalog read. The catalog is small; fail fast. */
+const MARKETPLACE_FETCH_TIMEOUT_MS = 15e3;
+const PLUGIN_MARKETPLACE_TIERS$1 = ["official", "curated"];
+/**
+* Load and parse the marketplace catalog.
+*
+* Throws on an unreadable or malformed catalog; callers surface the failure as a
+* tool error with an actionable `next`.
+*/
+async function loadPluginMarketplace$1(options = {}) {
+	const location = resolveMarketplaceLocation$1(options.source ?? process.env["SCREAM_CODE_PLUGIN_MARKETPLACE_URL"] ?? "https://raw.githubusercontent.com/LIUTod/scream-code/main/plugins/marketplace.json", options.workDir);
+	return parsePluginMarketplace$1(await readMarketplaceText$1(location, options.fetchImpl ?? fetch), location);
+}
+/**
+* Case-insensitive substring filter over the searchable fields.
+*
+* An empty/omitted query returns every entry, so callers can pass the raw
+* argument straight through.
+*/
+function filterMarketplaceEntries(entries, query) {
+	const needle = query?.trim().toLowerCase();
+	if (needle === void 0 || needle.length === 0) return entries;
+	return entries.filter((entry) => {
+		return [
+			entry.id,
+			entry.displayName,
+			entry.description ?? "",
+			...entry.keywords ?? []
+		].join(" ").toLowerCase().includes(needle);
+	});
+}
+function resolveMarketplaceLocation$1(source, workDir) {
+	const trimmed = source.trim();
+	if (trimmed.length === 0) throw new Error(`Marketplace source is empty (${SCREAM_CODE_PLUGIN_MARKETPLACE_URL_ENV$1} must not be blank)`);
+	if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return {
+		raw: trimmed,
+		kind: "remote",
+		resolved: trimmed
+	};
+	if (trimmed.startsWith("file://")) return {
+		raw: trimmed,
+		kind: "local",
+		resolved: fileURLToPath(trimmed)
+	};
+	return {
+		raw: trimmed,
+		kind: "local",
+		resolved: resolveLocalPath$1(trimmed, workDir)
+	};
+}
+async function readMarketplaceText$1(location, fetchImpl) {
+	if (location.kind === "local") try {
+		return await readFile(location.resolved, "utf8");
+	} catch (error) {
+		throw new Error(`Cannot read the marketplace file at ${location.resolved}: ${messageOf(error)}`, { cause: error });
+	}
+	const response = await fetchImpl(location.resolved, { signal: AbortSignal.timeout(MARKETPLACE_FETCH_TIMEOUT_MS) });
+	if (!response.ok) throw new Error(`The marketplace at ${location.resolved} returned HTTP ${String(response.status)}`);
+	return response.text();
+}
+/**
+* Parse the catalog document.
+*
+* The array key is tolerated as either `entries` or `plugins` because both
+* shapes are in the wild. Per-entry fields are optional except `source`: without
+* one there is nothing to install. `id` falls back to the manifest name so a
+* hand-written catalog without ids still browses.
+*/
+function parsePluginMarketplace$1(raw, location) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`The marketplace at ${location.resolved} is not valid JSON: ${messageOf(error)}`, { cause: error });
+	}
+	if (!isRecord$3(parsed)) throw new TypeError(`The marketplace at ${location.resolved} must be a JSON object.`);
+	const rawEntries = rawEntriesOf(parsed);
+	if (rawEntries === void 0) throw new TypeError(`The marketplace at ${location.resolved} must contain an "entries" (or "plugins") array.`);
+	const entries = [];
+	rawEntries.forEach((value, index) => {
+		const entry = parseMarketplaceEntry$1(value, index, location);
+		if (entry !== void 0) entries.push(entry);
+	});
+	return {
+		source: location.resolved,
+		version: stringField$1(parsed, "version"),
+		entries
+	};
+}
+function rawEntriesOf(parsed) {
+	for (const key of ["entries", "plugins"]) {
+		const value = parsed[key];
+		if (Array.isArray(value)) return value;
+	}
+}
+function parseMarketplaceEntry$1(value, index, location) {
+	if (!isRecord$3(value)) return void 0;
+	const source = stringField$1(value, "source") ?? stringField$1(value, "url") ?? stringField$1(value, "downloadUrl");
+	if (source === void 0) return;
+	const id = stringField$1(value, "id") ?? stringField$1(value, "name") ?? `entry-${String(index + 1)}`;
+	return {
+		id,
+		displayName: stringField$1(value, "displayName") ?? stringField$1(value, "name") ?? id,
+		source: resolveEntrySource$1(source, location),
+		tier: parseMarketplaceTier$1(value),
+		version: stringField$1(value, "version"),
+		description: stringField$1(value, "description") ?? stringField$1(value, "shortDescription"),
+		homepage: stringField$1(value, "homepage") ?? stringField$1(value, "websiteURL"),
+		keywords: stringArrayField$1(value, "keywords") ?? stringArrayField$1(value, "tags")
+	};
+}
+function parseMarketplaceTier$1(value) {
+	const raw = value["tier"];
+	if (typeof raw !== "string") return void 0;
+	const tier = raw.trim();
+	return PLUGIN_MARKETPLACE_TIERS$1.includes(tier) ? tier : void 0;
+}
+function resolveEntrySource$1(source, location) {
+	const trimmed = source.trim();
+	if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("~/") || trimmed === "~" || isAbsolute(trimmed)) return trimmed;
+	if (trimmed.startsWith("file://")) return fileURLToPath(trimmed);
+	if (location.kind === "remote") return new URL(trimmed, location.resolved).toString();
+	return resolve(dirname$1(location.resolved), trimmed);
+}
+function resolveLocalPath$1(input, workDir) {
+	if (input === "~") return homedir();
+	if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+	return isAbsolute(input) ? input : resolve(workDir ?? process.cwd(), input);
+}
+function stringField$1(value, field) {
+	const raw = value[field];
+	if (typeof raw !== "string") return void 0;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function stringArrayField$1(value, field) {
+	const raw = value[field];
+	if (!Array.isArray(raw)) return void 0;
+	const out = raw.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0);
+	return out.length > 0 ? out : void 0;
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region ../../packages/agent-core/src/tools/builtin/plugin/manage-plugin.md
+var manage_plugin_default = "Manage this product's own plugins. Plugins are the vehicle for add-on capabilities: each one can contribute skills, MCP servers, shell hooks, and — only after an explicit activate — code that runs in this process.\n\nUse this tool in two situations: (a) a task needs a capability you do not currently have — exhaust your existing tools first and add a plugin only when the gap is real; (b) the user asks you to find, install, configure, inspect, or clean up a capability (e.g. \"install something that can render mermaid\", \"disable the plugin I no longer use\"). In both cases, remove or disable additions again when the work is done unless the capability is broadly reusable.\n\n**Not for inventory questions**: when the user asks what you have — in any wording (skills / plugins / capabilities / MCP / tools / 技能 / 插件 / 能力) — answer with **InspectOwnAssets** (the read-only inventory: every skill package on disk with live `invocable` status, plus MCP declarations). `{\"action\":\"list\"}` here is the **plugin management view**: a pre-change check of the plugin table before installing or modifying, not the answer to \"what can you do\".\n\nChoose the lightest vehicle that solves the problem, in this order: a skill (prompt instructions — safest, no code, no process), an MCP server (an external process), a code plugin (runs in this process — the most powerful, needs its own approved `activate`).\n\n## Workflow\n\n1. `{\"action\":\"list\"}` — see what is already installed before adding anything. To confirm the gap is real, start from an `InspectOwnAssets` inventory (what exists on disk and what is invocable), then check this table for an existing plugin that already covers it. Do not grow a second plugin that duplicates an existing capability; enable, disable, or extend the one you already have.\n2. `{\"action\":\"marketplace\",\"query\":\"pdf\"}` — browse the catalog for a matching capability. Pass `source` to read a different catalog. `tier` is a display label only; judge an entry by its description and source. Entries whose origin previously produced a tripped plugin carry `quarantined: true`.\n3. `{\"action\":\"precheck\",\"source\":\"https://github.com/owner/repo\"}` — free read-only origin check before installing anything external that you have not vetted in this session: it reports past incidents recorded by the plugin center's immune memory (`quarantined:true` + the reason). Surface such a warning to the user BEFORE asking for the install approval.\n4. If nothing in the catalog fits and precheck is clean, you may search the web (`WebSearch` / `FetchURL`) and evaluate a repository yourself: read its README and manifest, prefer a pinned branch/tag/commit URL over a moving default, and check that it does something you cannot already do.\n5. To **make a capability yourself**: if the user invoked `/make-skill`, use the `MakeSkillPlan` → `MakeSkillApply` pair (it produces a valid skill package and registers it into this table automatically). Otherwise build a plugin directory by hand (a `scream.plugin.json` manifest plus your SKILL.md under `skills/`) and register it with `register_generated` — that route lands in this table, hot-applies the same turn, and stays manageable here (disable/remove/circuit). Writing a plain SKILL.md into the user skills directory is also a legitimate skill, but it does NOT appear in this table and cannot be managed with this tool.\n6. `{\"action\":\"install\",\"source\":\"https://github.com/owner/repo/tree/v1.2.0\"}` — install from a local path, a GitHub URL, or a zip URL. **Installing never executes code.** The plugin's files are copied and its record is registered; a manifest `entryPoint` stays dormant until step 8.\n7. `{\"action\":\"install\",\"source\":\"...\",\"upgrade\":true}` — same-name refresh: backs up the current files (single slot under `plugins/backups/<id>/`), swaps in the new ones, and reloads; `from`/`to` versions and any downgrade warning are reported. If activation then fails, `rollback` restores the previous files in one approved step.\n8. `{\"action\":\"enable\",\"id\":\"...\"}` / `{\"action\":\"disable\",\"id\":\"...\"}` / `{\"action\":\"set_mcp_enabled\",\"id\":\"...\",\"server\":\"...\",\"enabled\":false}` — turn contributed capabilities on and off.\n9. `{\"action\":\"activate\",\"id\":\"...\"}` — the only action that runs a plugin's code entry point in this process. Skip it for skill-only and MCP-only plugins; they need no activation.\n10. `{\"action\":\"info\",\"id\":\"...\"}` / `{\"action\":\"check\"}` — inspect one record in full, or the health of the table. Each entry also carries `usage: {calls, okCalls, okRate, lastUsedAt}` from this machine: zero calls since install marks it as a cleanup candidate; high usage with a high okRate is worth keeping when you must choose.\n11. `{\"action\":\"reset\",\"id\":\"...\"}` — recover a circuit-tripped or manually disabled plugin: clears its failure ledger, re-derives the record from disk, enables it, and hot-applies its capabilities. It never runs code — a code plugin still needs its own approved `activate`.\n12. `{\"action\":\"rollback\",\"id\":\"...\"}` — restore the pre-upgrade backup taken by step 7 in one approved step.\n13. `{\"action\":\"reload\"}` — re-read the plugin table from disk and get an added/removed/error summary.\n14. `{\"action\":\"remove\",\"id\":\"...\"}` (or `disable` to keep the record) — retreat once the capability is no longer wanted.\n\n## Circuit breaker (limbs that fail get pulled, the loop never dies)\n\nPlugin-owned capabilities are counted per plugin: every failed tool call (in-process plugin tools and plugin MCP servers) and every faulty event handler. A success clears the streak; three consecutive failures trip the breaker, and the failing result arrives with a `[circuit]` advisory: the plugin was marked with the reason, disabled persistently, its code deactivated, and its tools, MCP servers, skills, and hooks pulled from every live session. Nothing retries automatically — read the state with `check` (each plugin carries `circuit: {failures, tripped}`), then `reset` to give it another chance or `remove` to let it go. User-configured MCP servers and built-in tools are never charged to anyone's breaker.\n\nEvery trip ALSO writes the origin into the plugin center's immune memory (quarantine ledger): future `precheck`/`install`/`marketplace` calls for the same repository will surface that history before anything is executed again, even across sessions — and even if the broken plugin was removed afterwards.\n\nChanges are hot-applied to the running session wherever the host supports it: mutating results carry a `sync` report (`{ok, applied[], failed[]}`) naming exactly what landed — `skills.inject`, `mcp.add`/`mcp.remove`, tool teardown. An `install` deliberately reports no `mcp.add`: installing never starts a plugin's MCP process; that waits for an approved `enable`/`activate`/`reload`. Treat `sync.failed` as advisory (the mutation itself already succeeded) and re-check with `info`/`check` rather than re-running the mutation. Reload before judging whether a change landed.\n\n## Registration of your own output\n\n`{\"action\":\"register_generated\",\"source\":\"/abs/path/to/generated/plugin\"}` registers a plugin directory you produced locally, without a copy step. It refuses any manifest that declares an `entryPoint`: this action is normally auto-approved and must never become a route to running code. For a code plugin, use `install` and then `activate`.\n\n## Approval contract\n\n- Read-only actions (`list`, `info`, `check`, `marketplace`) run without prompting.\n- Every mutating action (`install`, `register_generated`, `enable`, `disable`, `set_mcp_enabled`, `activate`, `deactivate`, `remove`, `reset`, `reload`) requires the user's approval. State what you are about to do and why in one line, then call the tool — never describe a plugin change you have not made.\n- The approval prompt for `install` and `register_generated` shows the full source string, and a session grant applies to that exact source only.\n- `activate` is the step that executes third-party code; treat it as its own decision, made after you have read what the plugin does.\n- A rejected approval is an answer, not a retry cue. Report the refusal and continue without the capability.\n\n## Output\n\nEvery action returns a JSON string. Success is a compact result object; failure is\n`{\"error\":{\"code\",\"message\",\"next\"}}` with `isError: true`. Follow `next` rather than\nguessing at a repair — it names the call that resolves the problem.\n";
+//#endregion
+//#region ../../packages/agent-core/src/tools/builtin/plugin/manage-plugin.ts
+/** Every action this tool understands. */
+const MANAGE_PLUGIN_ACTIONS = [
+	"list",
+	"info",
+	"check",
+	"marketplace",
+	"precheck",
+	"install",
+	"register_generated",
+	"enable",
+	"disable",
+	"set_mcp_enabled",
+	"activate",
+	"deactivate",
+	"remove",
+	"reset",
+	"rollback",
+	"reload"
+];
+/**
+* Actions that only read plugin state. The permission policy auto-approves
+* exactly this set; nothing here may write state or run plugin code.
+*/
+const MANAGE_PLUGIN_READ_ONLY_ACTIONS = [
+	"list",
+	"info",
+	"check",
+	"marketplace",
+	"precheck"
+];
+const ManagePluginInputSchema = z.object({
+	action: z.enum(MANAGE_PLUGIN_ACTIONS).describe("Which plugin operation to run."),
+	id: z.string().optional().describe("Plugin id. Required for info, check, enable, disable, set_mcp_enabled, activate, deactivate, remove, reset."),
+	source: z.string().optional().describe("install: absolute path / GitHub URL / zip URL. register_generated: the generated plugin directory. marketplace: optional catalog URL or local JSON path."),
+	upgrade: z.boolean().optional().describe("install onto an existing plugin id: back up its current files, replace with the incoming ones, and reload. Without it, installing over an existing id silently overwrites."),
+	server: z.string().optional().describe("MCP server name, for set_mcp_enabled."),
+	enabled: z.boolean().optional().describe("Target state, for set_mcp_enabled."),
+	query: z.string().optional().describe("Case-insensitive substring filter, for marketplace.")
+});
+/**
+* The two actions that bring third-party code in. Their approval identity
+* includes the source, so a "approve for session" grant cannot be replayed
+* against a different URL later in the same session.
+*/
+const SOURCE_SCOPED_ACTIONS = new Set(["install", "register_generated"]);
+/**
+* Actions that cannot be answered without naming a plugin. `check` is not here:
+* without an id it reports the health of the whole table.
+*/
+const NEEDS_ID = new Set([
+	"info",
+	"enable",
+	"disable",
+	"set_mcp_enabled",
+	"activate",
+	"deactivate",
+	"remove",
+	"reset",
+	"rollback"
+]);
+function isKnownAction(action) {
+	return MANAGE_PLUGIN_ACTIONS.includes(action);
+}
+function isReadOnlyAction(action) {
+	return MANAGE_PLUGIN_READ_ONLY_ACTIONS.includes(action);
+}
+function isSourceScoped(action) {
+	return SOURCE_SCOPED_ACTIONS.has(action);
+}
+function fail$1(code, message, next) {
+	return { error: {
+		code,
+		message,
+		next
+	} };
+}
+function errorMessage$3(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function result(payload, isError = false) {
+	return isError ? {
+		output: JSON.stringify(payload),
+		isError: true
+	} : { output: JSON.stringify(payload) };
+}
+/**
+* Same payload as {@link result} but typed as the error variant, which is what
+* `resolveExecution` may return to reject a call before it reaches approval.
+*/
+function preflightError(envelope) {
+	return {
+		output: JSON.stringify(envelope),
+		isError: true
+	};
+}
+var ManagePluginTool = class {
+	agent;
+	name = "ManagePlugin";
+	description = manage_plugin_default;
+	parameters = toInputJsonSchema(ManagePluginInputSchema);
+	constructor(agent) {
+		this.agent = agent;
+	}
+	resolveExecution(args) {
+		if (!isKnownAction(args.action)) return preflightError(fail$1("unknown_action", `Unknown ManagePlugin action "${String(args.action)}".`, `Pick one of: ${MANAGE_PLUGIN_ACTIONS.join(", ")}.`));
+		const missing = missingRequiredArgs(args);
+		if (missing !== void 0) return preflightError(missing);
+		const subject = ruleSubject(args);
+		return {
+			accesses: isReadOnlyAction(args.action) ? ToolAccesses.none() : ToolAccesses.all(),
+			description: approvalDescription(args),
+			approvalRule: literalRulePattern(this.name, subject),
+			matchesRule: (ruleArgs) => matchesGlobRuleSubject(ruleArgs, subject),
+			execute: () => this.run(args)
+		};
+	}
+	/**
+	* Single funnel for every action. Contract: JSON in `output`, failures as
+	* `isError` with `{error:{code,message,next}}`, and no exception ever
+	* escapes — a plugin-center bug must not surface as a tool crash.
+	*/
+	async run(args) {
+		const manager = this.agent.toolServices?.plugins;
+		if (manager === void 0) return result(fail$1("plugin_center_unavailable", "The shared plugin manager is not available in this runtime.", "Report this so the host can expose its PluginManager, or use the /plugin command."), true);
+		try {
+			switch (args.action) {
+				case "list": return result({
+					action: "list",
+					count: manager.list().length,
+					plugins: manager.list().map(listView),
+					note: "Enabled plugins contribute skills and MCP servers; a code plugin only runs after a separate activate."
+				});
+				case "info": return this.info(manager, args.id);
+				case "check": return await this.check(manager, args.id);
+				case "precheck": return await this.precheck(args.source);
+				case "marketplace": return await this.marketplace(args.source, args.query);
+				case "install": return await this.install(manager, args.source, args.upgrade === true);
+				case "register_generated": return await this.registerGenerated(manager, args.source);
+				case "enable":
+				case "disable": {
+					const record = manager.get(args.id);
+					if (record === void 0) return result(notFound(args.id, manager), true);
+					const enabled = args.action === "enable";
+					await manager.setEnabled(record.id, enabled);
+					const sync = await this.sync([record.id]);
+					return result({
+						action: args.action,
+						id: record.id,
+						enabled,
+						record: listView(manager.get(record.id)),
+						...sync !== void 0 ? { sync } : {},
+						note: enabled ? "Enabled; skills and MCP servers hot-applied when sync reports them. Code still needs a separate activate." : "Disabled; its skills, MCP servers, and plugin tools were pulled from live sessions."
+					});
+				}
+				case "set_mcp_enabled": {
+					const record = manager.get(args.id);
+					if (record === void 0) return result(notFound(args.id, manager), true);
+					await manager.setMcpServerEnabled(record.id, args.server, args.enabled);
+					const info = manager.info(record.id);
+					const sync = await this.sync([record.id]);
+					return result({
+						action: args.action,
+						id: record.id,
+						server: args.server,
+						enabled: args.enabled,
+						mcpServers: info?.mcpServers ?? [],
+						...sync !== void 0 ? { sync } : {},
+						note: "MCP server state changed; live sessions were reconciled when sync reports mcp.add/mcp.remove."
+					});
+				}
+				case "activate": return await this.activate(manager, args.id);
+				case "deactivate": return await this.deactivate(manager, args.id);
+				case "remove": return await this.remove(manager, args.id);
+				case "reset": return await this.reset(manager, args.id);
+				case "rollback": return await this.rollbackPlugin(manager, args.id);
+				case "reload": {
+					const summary = await manager.reload();
+					const sync = await this.sync();
+					return result({
+						action: "reload",
+						...summary,
+						...sync !== void 0 ? { sync } : {}
+					});
+				}
+				default: return result(fail$1("unknown_action", `Unknown ManagePlugin action "${String(args.action)}".`, `Pick one of: ${MANAGE_PLUGIN_ACTIONS.join(", ")}.`), true);
+			}
+		} catch (error) {
+			return result(fail$1("plugin_operation_failed", errorMessage$3(error), nextForError(args, error)), true);
+		}
+	}
+	info(manager, id) {
+		const info = manager.info(id);
+		if (info === void 0) return result(notFound(id, manager), true);
+		return result({
+			action: "info",
+			plugin: projectInfo(info),
+			active: this.runtime?.isActive(info.id) === true
+		});
+	}
+	/**
+	* Health view built from the diagnostics each record already carries. There
+	* is no persistent reload log, so none is invented: `reload` is what returns
+	* a fresh summary after re-reading the table from disk.
+	*/
+	async check(manager, id) {
+		if (id !== void 0 && manager.get(id) === void 0) return result(notFound(id, manager), true);
+		const records = id === void 0 ? manager.list() : [manager.get(id)];
+		const plugins = await Promise.all(records.map(async (record) => ({
+			...checkView(record, this.runtime?.isActive(record.id) === true),
+			circuit: this.circuitView(record.id),
+			usage: await this.usageView(record.id)
+		})));
+		const unhealthy = plugins.filter((plugin) => plugin.errors.length > 0 || plugin.state === "error");
+		return result({
+			action: "check",
+			checked: plugins.length,
+			healthy: unhealthy.length === 0,
+			unhealthy: unhealthy.map((plugin) => plugin.id),
+			plugins,
+			note: "Diagnostics are the ones stored on each record from the last load or reload. Run action:\"reload\" to re-read the plugin table from disk and get a fresh summary."
+		});
+	}
+	async marketplace(source, query) {
+		try {
+			const catalog = await loadPluginMarketplace$1({
+				source,
+				workDir: this.agent.config.cwd
+			});
+			const filtered = filterMarketplaceEntries(catalog.entries, query);
+			const quarantinedIds = /* @__PURE__ */ new Set();
+			for (const entry of filtered) if (await this.matchQuarantine(entry.source) !== void 0) quarantinedIds.add(entry.id);
+			const entries = filtered.map((entry) => ({
+				...entry,
+				...quarantinedIds.has(entry.id) ? { quarantined: true } : {}
+			}));
+			return result({
+				action: "marketplace",
+				catalog: catalog.source,
+				version: catalog.version,
+				query: query ?? null,
+				count: entries.length,
+				entries,
+				note: "Catalog metadata only. \"tier\" is a display label and never skips the approval prompt; nothing was downloaded or installed here."
+			});
+		} catch (error) {
+			return result(fail$1("marketplace_unavailable", `Could not load the plugin marketplace: ${errorMessage$3(error)}`, "Check the URL or file path, or pass one explicitly: {action:\"marketplace\", source:\"<https url or local json path>\"}."), true);
+		}
+	}
+	/**
+	* Install only lands files and registers the record. Nothing is imported or
+	* run: activation stays a separate, separately-approved action.
+	*/
+	async precheck(source) {
+		const entry = await this.agent.toolServices?.plugins?.matchQuarantineForSource?.(source) ?? void 0;
+		return result({
+			action: "precheck",
+			source,
+			quarantined: entry !== void 0,
+			...entry !== void 0 ? { entry: {
+				at: entry.at,
+				pluginId: entry.pluginId,
+				reason: entry.reason
+			} } : {},
+			note: entry === void 0 ? "No unacknowledged incident on record for this origin." : "This origin previously produced a circuit-tripped plugin; proceed only with explicit user consent."
+		});
+	}
+	/** Quarantine lookup helper tolerant of hosts without the ledger. */
+	async matchQuarantine(source) {
+		return await this.agent.toolServices?.plugins?.matchQuarantineForSource?.(source) ?? void 0;
+	}
+	/** Acknowledge the quarantine warning after an approved install landed. */
+	async acknowledgeQuarantine(source) {
+		try {
+			await this.agent.toolServices?.plugins?.acknowledgeQuarantineForSource?.(source);
+		} catch {}
+	}
+	async install(manager, source, upgrade = false) {
+		const quarantineHit = await this.agent.toolServices?.plugins?.matchQuarantineForSource?.(source) ?? void 0;
+		const quarantineNote = quarantineHit !== void 0 ? { quarantine: {
+			at: quarantineHit.at,
+			reason: quarantineHit.reason
+		} } : {};
+		if (upgrade) {
+			const upgraded = await manager.upgrade(source);
+			const sync = await this.sync([upgraded.record.id], { skipMcpAdd: true });
+			await this.acknowledgeQuarantine(source);
+			return result({
+				action: "install",
+				id: upgraded.record.id,
+				installed: true,
+				upgraded: true,
+				from: upgraded.from,
+				to: upgraded.to,
+				...upgraded.warn !== void 0 ? { warn: upgraded.warn } : {},
+				backupPath: upgraded.backupPath,
+				...quarantineNote,
+				codeExecuted: false,
+				hasCodeEntryPoint: upgraded.record.manifest?.entryPoint !== void 0,
+				record: listView(upgraded.record),
+				...sync !== void 0 ? { sync } : {},
+				message: "files replaced from backup-safe upgrade; previous contents restorable via {action:\"rollback\"}; skills live now, MCP servers start after an approved enable/activate" + (quarantineHit !== void 0 ? ` \u26A0 origin previously tripped (${quarantineHit.reason})` : "")
+			});
+		}
+		const record = await manager.install(source);
+		const sync = await this.sync([record.id], { skipMcpAdd: true });
+		await this.acknowledgeQuarantine(source);
+		return result({
+			action: "install",
+			id: record.id,
+			installed: true,
+			activated: false,
+			codeExecuted: false,
+			hasCodeEntryPoint: record.manifest?.entryPoint !== void 0,
+			record: listView(record),
+			...quarantineNote,
+			...sync !== void 0 ? { sync } : {},
+			message: "installed, code not executed yet — its skills are live now, MCP servers start after an approved activate/enable; run activate to enable its code tools" + (quarantineHit !== void 0 ? ` \u26A0 origin previously tripped (${quarantineHit.reason})` : "")
+		});
+	}
+	/**
+	* Register a locally generated plugin directory. A manifest with an
+	* `entryPoint` is refused: the generated-skill flow is auto-approved, so it
+	* must never become a channel for running unapproved code.
+	*/
+	async registerGenerated(manager, source) {
+		const parsed = await parseManifest(source);
+		if (parsed.manifest === void 0) return result(fail$1("manifest_invalid", `Cannot register "${source}" as a generated plugin: ${parsed.diagnostics.find((diagnostic) => diagnostic.severity === "error")?.message ?? "no plugin manifest found"}`, "Write a valid plugin manifest in that directory first (see the MakeSkillPlan / MakeSkillApply flow)."), true);
+		if (parsed.manifest.entryPoint !== void 0) return result(fail$1("code_entry_point_not_allowed", `Refusing to register "${parsed.manifest.name}": its manifest declares an entryPoint, which would run code through a path that is normally auto-approved.`, "Install it from its source instead, then activate it as a separate approved step: {action:\"install\", source:\"<path or url>\"} followed by {action:\"activate\", id:\"<plugin id>\"}."), true);
+		const record = await manager.registerGenerated(source);
+		const sync = await this.sync([record.id], { skipMcpAdd: true });
+		return result({
+			action: "register_generated",
+			id: record.id,
+			registered: true,
+			enabled: record.enabled,
+			hasCodeEntryPoint: false,
+			record: listView(record),
+			...sync !== void 0 ? { sync } : {},
+			note: "Registered in place; its skills are hot-applied to this session when sync reports skills.inject."
+		});
+	}
+	async activate(manager, id) {
+		const record = manager.get(id);
+		if (record === void 0) return result(notFound(id, manager), true);
+		const runtime = this.runtime;
+		if (runtime === void 0) return result(fail$1("extension_runtime_unavailable", "This runtime has no extension manager, so plugin code cannot be activated.", "The plugin stays installed; use the /plugin command or report this so the host can expose an ExtensionRuntime."), true);
+		if (runtime.isActive(record.id)) return result({
+			action: "activate",
+			id: record.id,
+			active: true,
+			alreadyActive: true,
+			note: "Nothing ran again — the plugin is already live in this process."
+		});
+		const [extension] = runtime.discover([record]);
+		if (extension === void 0) return result(fail$1("no_code_entry_point", `Plugin "${record.id}" has no manifest entryPoint, so there is no code to activate.`, `Enable it instead: {action:"enable", id:"${record.id}"}.`), true);
+		try {
+			await runtime.activate(this.agent, extension);
+		} catch (error) {
+			await manager.markError(record.id, errorMessage$3(error)).catch(() => void 0);
+			const upgradedRecently = record.diagnostics.some((d) => d.message.startsWith("upgraded "));
+			return result(fail$1("activation_failed", `Failed to activate "${record.id}": ${errorMessage$3(error)}`, `Inspect {action:"info", id:"${record.id}"} for the stored diagnostics; fix it, or ${upgradedRecently ? `{action:"rollback", id:"${record.id}"} to restore the pre-upgrade files, or ` : ""}{action:"remove", id:"${record.id}"}.`), true);
+		}
+		const sync = await this.sync([record.id]);
+		return result({
+			action: "activate",
+			id: record.id,
+			active: true,
+			entryPoint: extension.entryPoint,
+			enabled: record.enabled,
+			...sync !== void 0 ? { sync } : {},
+			...record.enabled ? {} : { warning: "The plugin record is disabled; enable it so its capabilities survive the next reload." }
+		});
+	}
+	async deactivate(manager, id) {
+		const record = manager.get(id);
+		if (record === void 0) return result(notFound(id, manager), true);
+		const runtime = this.runtime;
+		if (runtime === void 0) return result(fail$1("extension_runtime_unavailable", "This runtime has no extension manager to deactivate from.", "Use the /plugin command or report this so the host can expose an ExtensionRuntime."), true);
+		const wasActive = runtime.isActive(record.id);
+		await runtime.deactivate(record.id);
+		const toolsUnregistered = this.agent.services?.tools?.unregisterToolsByOwner?.(record.id) ?? 0;
+		return result({
+			action: "deactivate",
+			id: record.id,
+			active: false,
+			wasActive,
+			toolsUnregistered,
+			...wasActive ? {} : { note: "The plugin was not active; nothing to unwind." }
+		});
+	}
+	async remove(manager, id) {
+		const record = manager.get(id);
+		if (record === void 0) return result(notFound(id, manager), true);
+		const runtime = this.runtime;
+		const wasActive = runtime?.isActive(record.id) === true;
+		if (wasActive && runtime !== void 0) await runtime.deactivate(record.id);
+		await manager.remove(record.id);
+		const sync = await this.sync([record.id]);
+		return result({
+			action: "remove",
+			id: record.id,
+			removed: true,
+			deactivatedFirst: wasActive,
+			...sync !== void 0 ? { sync } : {},
+			note: "The plugin record is gone; files on disk were not deleted."
+		});
+	}
+	get runtime() {
+		return this.agent.toolServices?.extensionRuntime;
+	}
+	/** Live circuit-breaker state for one plugin, read from the agent ledger. */
+	circuitView(id) {
+		const tools = this.agent.services?.tools;
+		return {
+			failures: tools?.getCircuitFailures?.(id) ?? 0,
+			tripped: tools?.isCircuitTripped?.(id) ?? false
+		};
+	}
+	/** Advisory usage counters from the host sidecar, formatted for the model. */
+	async usageView(id) {
+		const usage = await this.agent.toolServices?.plugins?.getUsage?.(id) ?? {
+			calls: 0,
+			okCalls: 0,
+			lastUsedAt: void 0
+		};
+		const okRate = usage.calls === 0 ? null : Math.round(usage.okCalls / usage.calls * 100);
+		return {
+			calls: usage.calls,
+			okCalls: usage.okCalls,
+			okRate,
+			lastUsedAt: usage.lastUsedAt
+		};
+	}
+	/**
+	* Recover a circuit-tripped (or otherwise disabled) plugin: clear the
+	* failure ledger, re-derive the record state from disk, enable it, and hot
+	* -apply its capabilities. A code entry point still needs a separate,
+	* approved `activate` — reset never runs plugin code.
+	*/
+	async reset(manager, id) {
+		const record = manager.get(id);
+		if (record === void 0) return result(notFound(id, manager), true);
+		const recordId = record.id;
+		this.agent.services?.tools?.resetCircuit?.(recordId);
+		await manager.reload();
+		const after = manager.get(recordId);
+		if (after === void 0) return result(fail$1("plugin_not_found", `Plugin "${recordId}" disappeared when reset re-read the table.`, "call action:'list' to see what is installed now"), true);
+		await manager.setEnabled(recordId, true);
+		const sync = await this.sync([recordId]);
+		return result({
+			action: "reset",
+			id: recordId,
+			enabled: true,
+			state: after.state,
+			circuit: { cleared: true },
+			...sync !== void 0 ? { sync } : {},
+			note: after.state === "error" ? "Circuit cleared, but the record still reports errors after re-reading the manifest — see {action:\"info\"}." : "Circuit cleared and capabilities hot-applied. Code entry points still need a separate approved activate."
+		});
+	}
+	/**
+	* Restore a plugin's files from the single-slot backup written by
+	* `upgrade` (install with upgrade:true). Reads-only until success; any
+	* failure is reported as an ordinary tool error.
+	*/
+	async rollbackPlugin(manager, id) {
+		const record = manager.get(id);
+		if (record === void 0) return result(notFound(id, manager), true);
+		try {
+			const restored = await manager.rollback(record.id);
+			const sync = await this.sync([record.id]);
+			return result({
+				action: "rollback",
+				id: record.id,
+				rolledBack: true,
+				restoredFrom: restored.restoredFrom,
+				state: restored.record.state,
+				version: restored.record.manifest?.version,
+				...sync !== void 0 ? { sync } : {},
+				note: "Previous files restored and the table reloaded; code entry points still need a separate approved activate."
+			});
+		} catch (error) {
+			return result(fail$1("rollback_unavailable", error instanceof Error ? error.message : String(error), "call action:'info' to confirm the plugin is installed"), true);
+		}
+	}
+	/**
+	* Hot-apply a successful mutation into live sessions through the host-owned
+	* sync entry point. Advisory by design: the plugin change is already durable
+	* when this runs, so the report is surfaced but never flips the action's
+	* outcome, and a missing entry point (older hosts) degrades to `undefined`.
+	*/
+	async sync(changedIds, options) {
+		const pluginSync = this.agent.toolServices?.pluginSync;
+		if (pluginSync === void 0) return void 0;
+		try {
+			return summarizePluginSync(await pluginSync(changedIds, options));
+		} catch (error) {
+			return {
+				ok: false,
+				applied: [],
+				failed: [{
+					step: "mcp.add",
+					message: error instanceof Error ? error.message : String(error)
+				}]
+			};
+		}
+	}
+};
+/**
+* The string that identifies what is being approved. For the source-scoped
+* actions the source is part of the identity, so the recorded session rule
+* reads `ManagePlugin(install <source>)` and only replays for that exact source.
+*/
+function ruleSubject(args) {
+	if (isSourceScoped(args.action) && args.source !== void 0) return `${args.action} ${args.source}`;
+	return args.action;
+}
+/** Human-readable approval line. Source-scoped actions must show the full source. */
+function approvalDescription(args) {
+	switch (args.action) {
+		case "list": return "Listing installed plugins";
+		case "info": return `Reading plugin "${args.id}"`;
+		case "check": return args.id === void 0 ? "Checking all plugins" : `Checking plugin "${args.id}"`;
+		case "marketplace": return `Browsing the plugin marketplace${args.source === void 0 ? "" : ` at ${args.source}`}`;
+		case "precheck": return `Prechecking install origin "${args.source}"`;
+		case "install": return `Install plugin from source: ${args.source} (downloads code; it is not executed until a separate activate)`;
+		case "register_generated": return `Register generated plugin from directory: ${args.source}`;
+		case "enable": return `Enable plugin "${args.id}"`;
+		case "disable": return `Disable plugin "${args.id}"`;
+		case "set_mcp_enabled": return `${args.enabled ? "Enable" : "Disable"} MCP server "${args.server}" of plugin "${args.id}"`;
+		case "activate": return `Activate plugin "${args.id}" — this runs its code entry point in this process`;
+		case "deactivate": return `Deactivate plugin "${args.id}"`;
+		case "remove": return `Remove plugin "${args.id}" from the plugin center`;
+		case "reset": return `Reset plugin "${args.id}" — clear its circuit breaker and re-enable it`;
+		case "rollback": return `Roll back plugin "${args.id}" to its pre-upgrade backup`;
+		case "reload": return "Reload the plugin table from disk";
+		default: return "Managing plugins";
+	}
+}
+function missingRequiredArgs(args) {
+	if (NEEDS_ID.has(args.action) && args.id === void 0) return fail$1("missing_id", `Action "${args.action}" needs a plugin id.`, "call action:'list' to see installed plugin ids");
+	if (isSourceScoped(args.action) && (args.source === void 0 || args.source.trim().length === 0)) return fail$1("missing_source", `Action "${args.action}" needs a source.`, "pass source:\"<absolute path | GitHub url | zip url>\", or browse first with action:\"marketplace\"");
+	if (args.action === "set_mcp_enabled") {
+		if (args.server === void 0) return fail$1("missing_server", "Action \"set_mcp_enabled\" needs the MCP server name.", `call {action:"info", id:"${String(args.id)}"} and read its mcpServers list`);
+		if (typeof args.enabled !== "boolean") return fail$1("missing_enabled", "Action \"set_mcp_enabled\" needs enabled:true or enabled:false.", "pass the desired boolean state");
+	}
+}
+function notFound(id, manager) {
+	return fail$1("plugin_not_found", `Plugin "${id}" is not installed.`, `call action:'list' to see installed plugin ids (${String(manager.list().length)} installed)`);
+}
+/** Turn a manager-thrown message into the next step the model can act on. */
+function nextForError(args, error) {
+	const message = errorMessage$3(error);
+	if (/already exists/i.test(message)) return `use {action:"enable", id:"${args.id ?? args.source ?? ""}"} or install under a different name`;
+	if (/not installed/i.test(message)) return "call action:'list' to see installed plugin ids";
+	if (/does not declare MCP server/i.test(message)) return `call {action:"info", id:"${String(args.id)}"} and pick one of its listed servers`;
+	if (/absolute path|does not exist|not a directory/i.test(message)) return "pass an absolute directory path, a https GitHub url, or a https zip url";
+	return "inspect {action:\"list\"} and retry; if a record is broken, {action:\"remove\", id:\"<id>\"} it";
+}
+function listView(record) {
+	return {
+		id: record.id,
+		name: record.manifest?.name ?? record.id,
+		displayName: record.manifest?.interface?.displayName ?? record.id,
+		version: record.manifest?.version,
+		state: record.state,
+		enabled: record.enabled,
+		source: record.source,
+		originalSource: record.originalSource,
+		path: record.root,
+		keywords: record.manifest?.keywords ?? [],
+		skillCount: record.skillCount,
+		mcpServerCount: Object.keys(record.manifest?.mcpServers ?? {}).length,
+		hasCodeEntryPoint: record.manifest?.entryPoint !== void 0,
+		hasErrors: record.diagnostics.some((diagnostic) => diagnostic.severity === "error")
+	};
+}
+function checkView(record, active) {
+	return {
+		id: record.id,
+		state: record.state,
+		enabled: record.enabled,
+		active,
+		hasCodeEntryPoint: record.manifest?.entryPoint !== void 0,
+		errors: record.diagnostics.filter((diagnostic) => diagnostic.severity === "error").map((diagnostic) => diagnostic.message),
+		warnings: record.diagnostics.filter((diagnostic) => diagnostic.severity === "warn").map((diagnostic) => diagnostic.message)
+	};
+}
+/**
+* Full detail for one plugin, minus the raw manifest blob: `mcpServers`,
+* `skillRoots` and `diagnostics` are already projected by the manager.
+*/
+function projectInfo(info) {
+	return {
+		id: info.id,
+		name: info.manifest?.name ?? info.displayName,
+		displayName: info.displayName,
+		version: info.version,
+		description: info.manifest?.description,
+		state: info.state,
+		enabled: info.enabled,
+		source: info.source,
+		originalSource: info.originalSource,
+		path: info.root,
+		keywords: info.manifest?.keywords ?? [],
+		skillCount: info.skillCount,
+		skills: info.skills,
+		skillRoots: info.manifest?.skills ?? [],
+		skillInstructions: info.manifest?.skillInstructions,
+		mcpServerCount: info.mcpServerCount,
+		enabledMcpServerCount: info.enabledMcpServerCount,
+		mcpServers: info.mcpServers,
+		hasCodeEntryPoint: info.manifest?.entryPoint !== void 0,
+		entryPoint: info.manifest?.entryPoint,
+		hooks: (info.manifest?.hooks ?? []).map((hook) => hook.event),
+		hasErrors: info.hasErrors,
+		diagnostics: info.diagnostics,
+		installedAt: info.installedAt,
+		updatedAt: info.updatedAt,
+		manifestKind: info.manifestKind,
+		manifestPath: info.manifestPath,
+		shadowedManifestPath: info.shadowedManifestPath,
+		github: info.github,
+		homepage: info.manifest?.homepage
+	};
+}
+//#endregion
 //#region ../../packages/agent-core/src/tools/builtin/python/python.ts
 const PY_DONE_MARKER = "__SCREAM_PY_DONE__";
 /** Head/tail output cap for python tool results — mirrors the generic tool
@@ -75794,7 +77142,7 @@ function describeError(error) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/state/inspect-own-assets.md
-var inspect_own_assets_default = "Use this tool to inspect the agent's own persistent assets: skills, MCP server declarations, configuration files, the memory store, and the knowledge base. It reports what exists, where it lives, and whether it looks valid.\n\n**When to use:**\n- The user asks \"what skills do you have?\", \"show me your mcp config\", \"how is your memory set up?\", \"where is your knowledge base?\"\n- Auditing your own configuration and data (e.g. checking whether mcp.json parses, whether skill frontmatter is intact)\n\nYou must NOT modify any of these assets unless the user explicitly asks you to — this tool is strictly read-only.\n\n**When NOT to use:**\n- Reading the user's workspace files — use `read` / `glob` / `grep` instead\n- Writing or editing anything — this tool is strictly read-only\n\n**How to use:**\n- Call with no arguments (or `scope: \"all\"`) to inspect everything\n- Narrow with `scope: \"skills\"` / `\"mcp\"` / `\"config\"` / `\"memory\"` / `\"knowledge\"` to inspect a single category\n\nThis tool never writes, creates, or modifies any file.\n";
+var inspect_own_assets_default = "Use this tool to inspect the agent's own persistent assets: skills, MCP server declarations, configuration files, the memory store, and the knowledge base. It reports what exists, where it lives, and whether it looks valid.\n\n**When to use:**\n- The user asks \"what skills do you have?\", \"show me your mcp config\", \"how is your memory set up?\", \"where is your knowledge base?\"\n- Auditing your own configuration and data (e.g. checking whether mcp.json parses, whether skill frontmatter is intact)\n\n**Inventory questions — this tool is the single answering view.** When the user asks what you have, in ANY wording (skills / plugins / capabilities / MCP / tools / 技能 / 插件 / 能力), treat it as one intent and answer from this inventory: it reports the skill packages in the three standard skill scopes (user, plugin-managed, project) with live `invocable` status from the skill registry, plus MCP declarations. Skills discovered from non-standard locations (nested directories, `.agents/skills`) may not appear here. Pair it with the system-prompt skills section for the \"callable right now\" view. Division of labor: **InspectOwnAssets = inventory (read-only)**, **ManagePlugin = changes (install/enable/remove)**, **Skill tool = invocation**.\n\nYou must NOT modify any of these assets unless the user explicitly asks you to — this tool is strictly read-only.\n\n**When NOT to use:**\n- Reading the user's workspace files — use `read` / `glob` / `grep` instead\n- Writing or editing anything — this tool is strictly read-only\n\n**How to use:**\n- Call with no arguments (or `scope: \"all\"`) to inspect everything\n- Narrow with `scope: \"skills\"` / `\"mcp\"` / `\"config\"` / `\"memory\"` / `\"knowledge\"` to inspect a single category\n\nThis tool never writes, creates, or modifies any file.\n";
 const InspectOwnAssetsInputSchema = z.object({ scope: z.enum([
 	"all",
 	"skills",
@@ -75887,17 +77235,20 @@ async function listSkills(dir) {
 			if (!await isSkillDir(join$1(dir, entry.name))) continue;
 			const skillMd = join$1(dir, entry.name, "SKILL.md");
 			const fm = await checkFrontmatter(skillMd);
+			const skillName = await readSkillName(skillMd) ?? entry.name;
 			out.push({
-				name: entry.name,
+				name: skillName,
 				path: skillMd,
 				kind: "dir",
 				frontmatter: fm
 			});
 		} else if (entry.isFile() && entry.name.endsWith(".md")) {
 			if (DOCUMENTATION_MARKDOWN_LOWER.has(entry.name.toLowerCase())) continue;
+			const path = join$1(dir, entry.name);
+			const skillName = await readSkillName(path) ?? entry.name.slice(0, -3);
 			out.push({
-				name: entry.name.slice(0, -3),
-				path: join$1(dir, entry.name),
+				name: skillName,
+				path,
 				kind: "flat",
 				frontmatter: "ok"
 			});
@@ -75905,8 +77256,12 @@ async function listSkills(dir) {
 	}
 	return out.toSorted((a, b) => a.name.localeCompare(b.name));
 }
-function formatSkillEntry(entry) {
-	return `- ${entry.name} — ${entry.kind === "dir" ? "dir" : "flat"} — ${entry.frontmatter} — \`${entry.path}\``;
+function buildInvocableNameSet(agent) {
+	return new Set((agent.skills?.registry.listInvocableSkills() ?? []).map((s) => s.name));
+}
+function formatSkillEntry(entry, invocable) {
+	const origin = entry.plugin === void 0 ? "" : ` — plugin: ${entry.plugin}`;
+	return `- ${entry.name} — ${entry.kind === "dir" ? "dir" : "flat"} — ${entry.frontmatter} — ${invocable ? "invocable" : "not invocable"}${origin} — \`${entry.path}\``;
 }
 async function inspectConfig(home, userHome) {
 	const items = [
@@ -75922,27 +77277,66 @@ async function inspectConfig(home, userHome) {
 	}
 	return lines.join("\n");
 }
-async function inspectSkills(home, userHome, cwd) {
+async function inspectSkills(home, userHome, cwd, agent) {
 	const { userDir, projectDir } = await resolveSkillInstallPaths({
 		userHomeDir: userHome,
 		workDir: cwd
 	});
+	const invocableNames = buildInvocableNameSet(agent);
 	const sections = ["## Skills", ""];
+	let invocableCount = 0;
+	let totalCount = 0;
+	const isInvocable = (entry) => invocableNames.has(entry.name) || entry.plugin !== void 0 && invocableNames.has(`${entry.plugin}:${entry.name}`);
+	const track = (entry, invocable) => {
+		totalCount++;
+		if (invocable) invocableCount++;
+		return formatSkillEntry(entry, invocable);
+	};
 	const userEntries = await listSkills(userDir);
 	sections.push(`User skills (${userDir}): ${userEntries.length === 0 ? "none" : ""}`);
-	sections.push(...userEntries.length > 0 ? userEntries.map(formatSkillEntry) : []);
+	sections.push(...userEntries.map((e) => track(e, isInvocable(e))));
 	const extraDir = join$1(home, "plugins", "managed");
 	const extraEntries = await listManagedSkills(extraDir);
 	sections.push("");
 	sections.push(`Plugin-managed skills (${extraDir}): ${extraEntries.length === 0 ? "none" : ""}`);
-	sections.push(...extraEntries.length > 0 ? extraEntries.map(formatSkillEntry) : []);
+	sections.push(...extraEntries.map((e) => track(e, isInvocable(e))));
 	const projectEntries = await listSkills(projectDir);
 	sections.push("");
 	sections.push(`Project skills (${projectDir}): ${projectEntries.length === 0 ? "none" : ""}`);
-	sections.push(...projectEntries.length > 0 ? projectEntries.map(formatSkillEntry) : []);
+	sections.push(...projectEntries.map((e) => track(e, isInvocable(e))));
+	sections.push("");
+	sections.push(`Invocable now: ${invocableCount}/${totalCount} (against the live skill registry; entries marked "not invocable" exist on disk but are disabled, shadowed, renamed, or broken)`);
 	return sections.join("\n");
 }
 /**
+* Extracts the skill name from SKILL.md frontmatter (best effort) so the
+* inventory name matches what the skill registry holds; returns null when
+* frontmatter is missing or has no name line.
+*/
+async function readSkillName(path) {
+	let handle;
+	try {
+		handle = await open(path, "r");
+		const buffer = Buffer.alloc(FRONTMATTER_READ_LIMIT);
+		const { bytesRead } = await handle.read(buffer, 0, FRONTMATTER_READ_LIMIT, 0);
+		const head = buffer.subarray(0, bytesRead).toString("utf-8").split("\n").slice(0, 25);
+		if (head[0]?.trim() !== "---") return null;
+		for (const line of head.slice(1)) {
+			if (line.trim() === "---") break;
+			const m = /^name\s*:\s*(.+)$/.exec(line);
+			if (m !== null) {
+				const value = m[1].trim().replaceAll(/^["']|["']$/g, "");
+				return value.length > 0 ? value : null;
+			}
+		}
+		return null;
+	} catch {
+		return null;
+	} finally {
+		await handle?.close().catch(() => {});
+	}
+}
+/**
 * List plugin-managed skills: each `<dir>/SKILL.md` under a managed plugin
 * directory is a skill entry (Extra source, mirroring plugin/manager.ts).
 */
@@ -75959,11 +77353,13 @@ async function listManagedSkills(managedDir) {
 		const skillMd = join$1(managedDir, plugin.name, "SKILL.md");
 		if (!await isSkillDir(join$1(managedDir, plugin.name))) continue;
 		const fm = await checkFrontmatter(skillMd);
+		const skillName = await readSkillName(skillMd) ?? plugin.name;
 		out.push({
-			name: plugin.name,
+			name: skillName,
 			path: skillMd,
 			kind: "dir",
-			frontmatter: fm
+			frontmatter: fm,
+			plugin: plugin.name
 		});
 	}
 	return out.toSorted((a, b) => a.name.localeCompare(b.name));
@@ -76059,7 +77455,7 @@ var InspectOwnAssetsTool = class {
 				const scope = args.scope ?? "all";
 				const sections = [];
 				if (scope === "all" || scope === "config") sections.push(await inspectConfig(home, userHome));
-				if (scope === "all" || scope === "skills") sections.push(await inspectSkills(home, userHome, cwd));
+				if (scope === "all" || scope === "skills") sections.push(await inspectSkills(home, userHome, cwd, this.agent));
 				if (scope === "all" || scope === "mcp") sections.push(await inspectMcp(home, cwd));
 				if (scope === "all" || scope === "memory") sections.push(await inspectMemory(home));
 				if (scope === "all" || scope === "knowledge") sections.push(await inspectKnowledge(home));
@@ -76615,19 +78011,23 @@ var EventSubscriptionBus = class {
 		this.wildcard.clear();
 	}
 	/**
-	* Deliver an event to matching handlers. A handler that throws is isolated
-	* so a subscriber bug can never break the agent's event loop.
+	* Deliver an event to matching handlers. A handler that throws synchronously
+	* is caught here, and a handler that returns a rejected promise has that
+	* rejection swallowed, so a subscriber bug can never break the agent's event
+	* loop nor crash the process through `unhandledRejection`.
 	*/
 	dispatch(event) {
 		const typed = this.byType.get(event.type);
 		if (typed !== void 0) for (const handler of typed) try {
-			handler(event);
+			Promise.resolve(handler(event)).catch(noop$1);
 		} catch {}
 		if (this.wildcard.size > 0) for (const handler of this.wildcard) try {
-			handler(event);
+			Promise.resolve(handler(event)).catch(noop$1);
 		} catch {}
 	}
 };
+/** Rejection sink for async subscribers: their failures are deliberately dropped. */
+function noop$1() {}
 //#endregion
 //#region ../../packages/agent-core/src/agent/context/projector.ts
 /** Synthetic error text used when a tool result is missing and must be
@@ -81652,6 +83052,46 @@ var GitCwdWriteApprovePermissionPolicy = class {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/agent/permission/policies/manage-plugin-read-only-approve.ts
+const READ_ONLY_ACTIONS = new Set(MANAGE_PLUGIN_READ_ONLY_ACTIONS);
+/**
+* Auto-approves the read-only faces of `ManagePlugin`.
+*
+* Listing and inspecting the plugin table has no side effects, so gating it
+* would only train the model to skip the "look before you add" step the tool
+* exists to enforce. Anything that writes state or runs plugin code decides
+* nothing here and falls through the chain to the ordinary approval prompt.
+*
+* The action is read off the invocation arguments. A missing or unparseable
+* payload decides nothing on purpose, so the fail-open direction is always
+* "ask the user".
+*/
+var ManagePluginReadOnlyApprovePermissionPolicy = class {
+	name = "manage-plugin-read-only-approve";
+	evaluate(context) {
+		if (context.toolCall.name !== "ManagePlugin") return;
+		const action = readAction(context);
+		if (action === void 0 || !READ_ONLY_ACTIONS.has(action)) return;
+		return {
+			kind: "approve",
+			reason: { manage_plugin_action: action }
+		};
+	}
+};
+/** Read `action` from the resolved args, falling back to the raw tool-call JSON. */
+function readAction(context) {
+	const fromArgs = context.args?.action;
+	if (typeof fromArgs === "string") return fromArgs;
+	const rawArguments = context.toolCall.arguments;
+	if (typeof rawArguments !== "string") return void 0;
+	try {
+		const raw = JSON.parse(rawArguments);
+		return typeof raw?.action === "string" ? raw.action : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region ../../packages/agent-core/src/agent/permission/policies/plan-mode-guard-deny.ts
 var PlanModeGuardDenyPermissionPolicy = class {
 	agent;
@@ -81924,6 +83364,7 @@ function createPermissionDecisionPolicies(agent) {
 		new YoloModeApprovePermissionPolicy(agent),
 		new WolfPackModeApprovePermissionPolicy(agent),
 		new DefaultToolApprovePermissionPolicy(),
+		new ManagePluginReadOnlyApprovePermissionPolicy(),
 		new GitCwdWriteApprovePermissionPolicy(agent),
 		new FallbackAskPermissionPolicy()
 	];
@@ -83243,6 +84684,43 @@ function compareWireVersions(a, b) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/agent/records/persistence.ts
+/**
+* Record types whose state is fully captured by a `context.snapshot` record.
+* Canonical definition — records/index.ts imports it for the restore
+* fast-path. It also drives the parse-skipping fast path in `read()` below:
+* serialized lines of these types that predate the last snapshot are never
+* JSON.parse'd.
+*/
+const SNAPSHOT_FOLDED_CONTEXT_TYPES = new Set([
+	"context.append_message",
+	"context.append_loop_event",
+	"context.apply_compaction",
+	"micro_compaction.apply",
+	"full_compaction.complete"
+]);
+/**
+* Serialized-line prefix of a context.snapshot record. Persisted records
+* always serialize "type" as the first key (locked by test), so a startsWith
+* probe is exact — a false positive would require an entire line to start
+* with this JSON prefix, which no other record (or any message content, whose
+* line starts with its own record "type") can produce.
+*
+* Probes run on raw UTF-8 bytes (see SNAPSHOT_RECORD_LINE_PREFIX_BYTES): all
+* characters in these prefixes are ASCII, so byte-level matching is exact.
+*/
+const SNAPSHOT_RECORD_LINE_PREFIX = "{\"type\":\"context.snapshot\"";
+/** Line prefixes of the folded record types, derived from the set above. */
+const SNAPSHOT_FOLDED_LINE_PREFIXES = [...SNAPSHOT_FOLDED_CONTEXT_TYPES].map((type) => `{"type":"${type}"`);
+/** UTF-8 bytes of {@link SNAPSHOT_RECORD_LINE_PREFIX}. */
+const SNAPSHOT_RECORD_LINE_PREFIX_BYTES = Buffer.from(SNAPSHOT_RECORD_LINE_PREFIX, "utf8");
+/** UTF-8 bytes of each entry of {@link SNAPSHOT_FOLDED_LINE_PREFIXES}. */
+const SNAPSHOT_FOLDED_LINE_PREFIX_BYTES = SNAPSHOT_FOLDED_LINE_PREFIXES.map((prefix) => Buffer.from(prefix, "utf8"));
+function startsWithPrefix(data, prefix) {
+	return data.length >= prefix.length && data.subarray(0, prefix.length).equals(prefix);
+}
+function startsWithAnyPrefix(data, prefixes) {
+	return prefixes.some((prefix) => startsWithPrefix(data, prefix));
+}
 var FileSystemAgentRecordPersistence = class {
 	filePath;
 	options;
@@ -83257,29 +84735,53 @@ var FileSystemAgentRecordPersistence = class {
 	}
 	async *read() {
 		await this.flush();
-		let line = "";
+		const lines = [];
+		let lastSnapshotLineNumber = -1;
 		let lineNumber = 0;
-		const stream = createReadStream(this.filePath, { encoding: "utf8" });
+		let openChunks = [];
+		const stream = createReadStream(this.filePath);
 		try {
 			for await (const chunk of stream) {
-				line += chunk;
-				let newlineIndex = line.indexOf("\n");
-				while (newlineIndex !== -1) {
-					const rawLine = line.slice(0, newlineIndex);
-					line = line.slice(newlineIndex + 1);
+				let searchFrom = 0;
+				for (;;) {
+					const newlineIndex = chunk.indexOf(10, searchFrom);
+					if (newlineIndex === -1) break;
+					const parts = openChunks.length > 0 ? [...openChunks, chunk.subarray(searchFrom, newlineIndex)] : [chunk.subarray(searchFrom, newlineIndex)];
+					let lineData = Buffer.concat(parts);
+					if (lineData.length > 0 && lineData.at(-1) === 13) lineData = lineData.subarray(0, lineData.length - 1);
 					lineNumber++;
-					const record = parseRecordLine(rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine, lineNumber, this.filePath, false);
-					if (record !== void 0) yield record;
-					newlineIndex = line.indexOf("\n");
+					if (startsWithPrefix(lineData, SNAPSHOT_RECORD_LINE_PREFIX_BYTES)) lastSnapshotLineNumber = lineNumber;
+					lines.push({
+						data: lineData,
+						lineNumber,
+						allowTruncated: false
+					});
+					openChunks = [];
+					searchFrom = newlineIndex + 1;
 				}
+				if (searchFrom < chunk.length) openChunks.push(chunk.subarray(searchFrom));
 			}
 		} catch (error) {
 			if (error.code === "ENOENT") return;
 			throw error;
 		}
-		if (line.length > 0) {
+		if (openChunks.length > 0) {
 			lineNumber++;
-			const record = parseRecordLine(line, lineNumber, this.filePath, true);
+			lines.push({
+				data: Buffer.concat(openChunks),
+				lineNumber,
+				allowTruncated: true
+			});
+		}
+		let skipFoldedBeforeSnapshot = false;
+		if (lines.length > 0) try {
+			skipFoldedBeforeSnapshot = JSON.parse(lines[0].data.toString("utf8")).protocol_version === "1.4";
+		} catch {
+			skipFoldedBeforeSnapshot = false;
+		}
+		for (const entry of lines) {
+			if (skipFoldedBeforeSnapshot && entry.lineNumber < lastSnapshotLineNumber && startsWithAnyPrefix(entry.data, SNAPSHOT_FOLDED_LINE_PREFIX_BYTES)) continue;
+			const record = parseRecordLine(entry.data.toString("utf8"), entry.lineNumber, this.filePath, entry.allowTruncated);
 			if (record !== void 0) yield record;
 		}
 	}
@@ -83603,14 +85105,10 @@ function asMediaContainer(value) {
 * pushing onto `compactedHistory` — a debug trail rendered from the pre-fold
 * history. Snapshot replay skips that pre-fold history, so the trail would be
 * re-rendered as empty; the snapshot carries the trail itself instead.
+*
+* The canonical definition lives in persistence.ts (it also drives the
+* parse-skipping fast path during read); imported from there.
 */
-const SNAPSHOT_FOLDED_CONTEXT_TYPES = new Set([
-	"context.append_message",
-	"context.append_loop_event",
-	"context.apply_compaction",
-	"micro_compaction.apply",
-	"full_compaction.complete"
-]);
 function isSnapshotFoldedContextRecord(type) {
 	return SNAPSHOT_FOLDED_CONTEXT_TYPES.has(type);
 }
@@ -83809,16 +85307,37 @@ var AgentRecords = class {
 		await this.persistence?.flush();
 	}
 };
-//#endregion
-//#region ../../packages/agent-core/src/agent/replay/index.ts
+/** Mirrors the TUI's isReplayUserTurnRecord predicate (message-replay.ts):
+* a replay record starts a user turn when it is a user-role message from the
+* user (or a user-slash skill activation). */
+function isUserTurnStartRecord(record) {
+	if (record.type !== "message") return false;
+	const { message } = record;
+	if (message.role !== "user") return false;
+	switch (message.origin?.kind) {
+		case void 0:
+		case "user": return true;
+		case "skill_activation": return message.origin.trigger === "user-slash";
+		default: return false;
+	}
+}
 var ReplayBuilder = class {
 	agent;
 	records = [];
+	/** Indices (into `records`) of user-turn-start records, oldest first. */
+	userTurnStarts = [];
 	constructor(agent) {
 		this.agent = agent;
 	}
 	push(record) {
-		if (this.agent.records.restoring) this.records.push(record);
+		if (!this.agent.records.restoring) return;
+		this.records.push(record);
+		if (!isUserTurnStartRecord(record)) return;
+		this.userTurnStarts.push(this.records.length - 1);
+		if (this.userTurnStarts.length <= 10) return;
+		const dropBefore = this.userTurnStarts[this.userTurnStarts.length - 10];
+		this.records.splice(0, dropBefore);
+		this.userTurnStarts = this.userTurnStarts.slice(-10).map((i) => i - dropBefore);
 	}
 	buildResult() {
 		return this.records;
@@ -91661,7 +93180,7 @@ function parseToolCallArguments(raw) {
 		} catch {
 			return {
 				success: false,
-				error: errorMessage$4(error)
+				error: errorMessage$5(error)
 			};
 		}
 	}
@@ -91755,7 +93274,7 @@ async function prepareToolCall(step, call) {
 			toolCallId: call.toolCall.id,
 			error
 		});
-		return settleError(effectiveArgs, error instanceof PathSecurityError ? error.message : `Tool "${call.toolName}" failed to resolve execution: ${errorMessage$4(error)}`);
+		return settleError(effectiveArgs, error instanceof PathSecurityError ? error.message : `Tool "${call.toolName}" failed to resolve execution: ${errorMessage$5(error)}`);
 	}
 	const displayFields = toolCallDisplayFieldsFromExecution(execution);
 	const settleAborted = () => settleError(effectiveArgs, abortedToolOutput(call.toolName, step.signal), displayFields);
@@ -91814,7 +93333,7 @@ async function runPrepareToolExecutionHook(step, call) {
 		return {
 			kind: "hookFailed",
 			args,
-			output: `prepareToolExecution hook failed for "${call.toolName}": ${errorMessage$4(error)}`
+			output: `prepareToolExecution hook failed for "${call.toolName}": ${errorMessage$5(error)}`
 		};
 	}
 	const effectiveArgs = hookResult?.updatedArgs ?? args;
@@ -91855,7 +93374,7 @@ async function runAuthorizeToolExecutionHook(step, call, args, execution) {
 		};
 		return {
 			block: true,
-			reason: `authorizeToolExecution hook failed for "${call.toolName}": ${errorMessage$4(error)}`
+			reason: `authorizeToolExecution hook failed for "${call.toolName}": ${errorMessage$5(error)}`
 		};
 	}
 }
@@ -91882,7 +93401,7 @@ async function runRunnableToolCall(step, call, effectiveArgs, metadata, executio
 			toolCallId: toolCall.id,
 			error
 		});
-		return makeErrorToolResult(call, effectiveArgs, aborted ? abortedToolOutput(toolName, signal) : `Tool "${toolName}" failed: ${errorMessage$4(error)}`);
+		return makeErrorToolResult(call, effectiveArgs, aborted ? abortedToolOutput(toolName, signal) : `Tool "${toolName}" failed: ${errorMessage$5(error)}`);
 	}
 	return makeToolResult(call, effectiveArgs, toolResult);
 }
@@ -91914,7 +93433,7 @@ async function finalizePendingToolResult(step, pendingResult) {
 			toolCallId: pendingResult.toolCall.id,
 			error
 		});
-		const output = aborted ? `Tool "${pendingResult.toolName}" aborted during finalizeToolResult hook.` : `finalizeToolResult hook failed for "${pendingResult.toolName}": ${errorMessage$4(error)}`;
+		const output = aborted ? `Tool "${pendingResult.toolName}" aborted during finalizeToolResult hook.` : `finalizeToolResult hook failed for "${pendingResult.toolName}": ${errorMessage$5(error)}`;
 		return {
 			...pendingResult,
 			stopTurn: pendingResult.stopTurn,
@@ -92427,7 +93946,7 @@ async function runTurn(input) {
 				usage
 			};
 		}
-		dispatchEvent(makeInterruptedEvent(isMaxStepsExceededError(error) ? "max_steps" : "error", steps, activeStep, errorMessage$4(error)));
+		dispatchEvent(makeInterruptedEvent(isMaxStepsExceededError(error) ? "max_steps" : "error", steps, activeStep, errorMessage$5(error)));
 		throw error;
 	}
 	return {
@@ -96373,7 +97892,7 @@ function buildSelfMap(options) {
 		"",
 		"Data:",
 		`- skills/ — user skills: \`${userSkillsDir}\` (project skills are listed with their \`Path\` under Available skills above)`,
-		`- plugins/ — managed plugins and plugin-managed skills: \`${pluginsDir}\` (installed.json + managed/<name>/)`,
+		`- plugins/ — managed plugins and plugin-managed skills: \`${pluginsDir}\` (installed.json + managed/<name>/); manage them with the \`ManagePlugin\` builtin (read-only actions are free, mutations ask for approval) — never edit installed.json by hand`,
 		`- memory/ — persistent cross-session memory: \`${memoryDir}\` (memos.sqlite + entries.jsonl)`,
 		`- knowledge/ — local knowledge base (via the KnowledgeLookup tool): \`${knowledgeDir}\` (knowledge.db)`,
 		"",
@@ -96567,7 +98086,7 @@ function normalizeSourcePath(path) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/profile/default/agent.yaml
-var agent_default = "name: agent\ndescription: Default Scream Code agent\n\nsystemPromptPath: ./system.md\npromptVars:\n  roleAdditional: ''\n\ntools:\n  - Read\n  - Write\n  - Edit\n  - Grep\n  - Glob\n  - Bash\n  - TaskList\n  - TaskOutput\n  - TaskStop\n  - CronCreate\n  - CronList\n  - CronDelete\n  - CreateGoal\n  - GetGoal\n  - SetGoalBudget\n  - UpdateGoal\n  - ReadMediaFile\n  - TodoList\n  - MemoryLookup\n  - MemoryConsolidatePlan\n  - MemoryConsolidateApply\n  - MemoryWrite\n  - KnowledgeLookup\n  - InspectOwnAssets\n  - Skill\n  - MakeSkillPlan\n  - MakeSkillApply\n  - WebSearch\n  - Agent\n  - WolfPack\n\n  - FetchURL\n  - AskUserQuestion\n  - EnterPlanMode\n  - FusionPlan\n  - ExitPlanMode\n  - mcp__*\n\nsubagents:\n  coder:\n    description: Good at general software engineering tasks.\n  explore:\n    description: Fast codebase exploration with prompt-enforced read-only behavior.\n  plan:\n    description: Read-only implementation planning and architecture design.\n  verify:\n    description: Verification specialist. Runs build, test, and lint commands to validate code changes.\n  reviewer:\n    description: Code review specialist. Identifies bugs and API contract violations before merge.\n  oracle:\n    description: Deep debugging, architecture decisions, and second opinions.\n  worker:\n    description: Office and document automation worker. Performs format conversion, batch file processing, file organization, and document transformation; never modifies code and does not write content.\n  writer:\n    description: Professional writing and document specialist. Researches, drafts, rewrites, edits, translates, summarizes, and uses available workspace-local toolchains to produce or revise Markdown, text, HTML, PDF/Office-compatible, spreadsheet-style, and presentation-oriented artifacts.\n";
+var agent_default = "name: agent\ndescription: Default Scream Code agent\n\nsystemPromptPath: ./system.md\npromptVars:\n  roleAdditional: ''\n\ntools:\n  - Read\n  - Write\n  - Edit\n  - Grep\n  - Glob\n  - Bash\n  - TaskList\n  - TaskOutput\n  - TaskStop\n  - CronCreate\n  - CronList\n  - CronDelete\n  - CreateGoal\n  - GetGoal\n  - SetGoalBudget\n  - UpdateGoal\n  - ReadMediaFile\n  - TodoList\n  - MemoryLookup\n  - MemoryConsolidatePlan\n  - MemoryConsolidateApply\n  - MemoryWrite\n  - KnowledgeLookup\n  - InspectOwnAssets\n  - Skill\n  - MakeSkillPlan\n  - MakeSkillApply\n  # Main-agent capability management. Subagent profiles inherit this list, but\n  # the tool is only registered for main agents, so it never reaches their\n  # model-visible tool set.\n  - ManagePlugin\n  - WebSearch\n  - Agent\n  - WolfPack\n\n  - FetchURL\n  - AskUserQuestion\n  - EnterPlanMode\n  - FusionPlan\n  - ExitPlanMode\n  - mcp__*\n\nsubagents:\n  coder:\n    description: Good at general software engineering tasks.\n  explore:\n    description: Fast codebase exploration with prompt-enforced read-only behavior.\n  plan:\n    description: Read-only implementation planning and architecture design.\n  verify:\n    description: Verification specialist. Runs build, test, and lint commands to validate code changes.\n  reviewer:\n    description: Code review specialist. Identifies bugs and API contract violations before merge.\n  oracle:\n    description: Deep debugging, architecture decisions, and second opinions.\n  worker:\n    description: Office and document automation worker. Performs format conversion, batch file processing, file organization, and document transformation; never modifies code and does not write content.\n  writer:\n    description: Professional writing and document specialist. Researches, drafts, rewrites, edits, translates, summarizes, and uses available workspace-local toolchains to produce or revise Markdown, text, HTML, PDF/Office-compatible, spreadsheet-style, and presentation-oriented artifacts.\n";
 //#endregion
 //#region ../../packages/agent-core/src/profile/default/coder.yaml
 var coder_default = "extends: agent\nname: coder\npromptVars:\n  roleAdditional: |\n    You are now running as a subagent. All the `user` messages are sent by the main agent. The main agent cannot see your context, it can only see your last message when you finish the task. You must treat the parent agent as your caller. Do not directly ask the end user questions. If something is unclear, explain the ambiguity in your final summary to the parent agent.\nwhenToUse: |\n  Use this agent for non-trivial software engineering work that may require reading files, editing code, running commands, and returning a compact but technically complete summary to the parent agent.\ntools:\n  - Bash\n  - Read\n  - ReadMediaFile\n  - Glob\n  - Grep\n  - Write\n  - Edit\n  - WebSearch\n  - FetchURL\n  - MemoryLookup\n  - MemoryConsolidatePlan\n  - MemoryConsolidateApply\n  - mcp__*\n";
@@ -96728,6 +98247,20 @@ function cloneTodos(todos) {
 		phase: todo.phase
 	}));
 }
+/** Parse `plugin-<id>:<server>` back to the owning plugin id (undefined otherwise). */
+function pluginOwnerFromMcpServerName(serverName) {
+	if (!serverName.startsWith("plugin-")) return void 0;
+	const colon = serverName.indexOf(":");
+	return colon > 7 ? serverName.slice(7, colon) : void 0;
+}
+/** Advisory appended to a tool result when its plugin just tripped the circuit. */
+function circuitTripNote(pluginId) {
+	return `[circuit] Plugin "${pluginId}" failed ${String(3)} tool calls in a row and was disabled; its tools, MCP servers, skills, and hooks were pulled from this session. Inspect it with ManagePlugin {action:"check", id:"${pluginId}"}; recover with {action:"reset", id:"${pluginId}"} or abandon it with {action:"remove", id:"${pluginId}"}.`;
+}
+/** Render any tool payload for the advisory appendage without '[object Object]'. */
+function describeToolOutput(output) {
+	return typeof output === "string" ? output : JSON.stringify(output);
+}
 const CRITERIA_SYSTEM_PROMPT = [
 	"You generate concrete, verifiable acceptance criteria for a given objective.",
 	"Criteria must be specific and testable — state what should work end-to-end, not just what should exist.",
@@ -96948,6 +98481,11 @@ var ToolManager = class {
 	agent;
 	builtinTools = /* @__PURE__ */ new Map();
 	userTools = /* @__PURE__ */ new Map();
+	/** tool name → owning plugin id; the index `unregisterToolsByOwner` reads. */
+	toolOwners = /* @__PURE__ */ new Map();
+	/** plugin id → consecutive capability failures; a success resets to zero. */
+	circuitFailures = /* @__PURE__ */ new Map();
+	trippedPlugins = /* @__PURE__ */ new Set();
 	mcpTools = /* @__PURE__ */ new Map();
 	/** server name → list of qualified tool names registered for that server. */
 	mcpToolsByServer = /* @__PURE__ */ new Map();
@@ -97005,11 +98543,14 @@ var ToolManager = class {
 	* this method takes a hand-written registration.
 	*/
 	registerUserTool(input) {
+		const { name, description, parameters, ownerPluginId, execute } = input;
 		this.agent.records.logRecord({
 			type: "tools.register_user_tool",
-			...input
+			name,
+			description,
+			parameters,
+			...ownerPluginId !== void 0 ? { ownerPluginId } : {}
 		});
-		const { name, description, parameters } = input;
 		const tool = {
 			name,
 			description,
@@ -97019,17 +98560,48 @@ var ToolManager = class {
 					description,
 					approvalRule: name,
 					execute: async (context) => {
-						return this.agent.rpc.toolCall({
+						const noteOutcome = (outcome) => {
+							if (ownerPluginId === void 0) return outcome;
+							if (this.reportOwnerOutcome(ownerPluginId, outcome.isError !== true) !== "tripped") return outcome;
+							return {
+								...outcome,
+								output: `${describeToolOutput(outcome.output)}\n\n${circuitTripNote(ownerPluginId)}`
+							};
+						};
+						if (execute !== void 0) try {
+							return noteOutcome(await execute(args ?? {}, context) ?? {
+								output: `Tool "${name}" returned no result.`,
+								isError: true
+							});
+						} catch (error) {
+							return noteOutcome({
+								output: `Tool "${name}" failed: ${error instanceof Error ? error.message : String(error)}`,
+								isError: true
+							});
+						}
+						const rpc = this.agent.rpc;
+						if (rpc?.toolCall === void 0) return {
+							output: `User-registered tool "${name}" cannot execute: host does not support in-band tool callbacks.`,
+							isError: true
+						};
+						return noteOutcome(await rpc.toolCall({
 							turnId: Number(context.turnId),
 							toolCallId: context.toolCallId,
 							args
-						}, { signal: context.signal });
+						}, { signal: context.signal }));
 					}
 				};
 			}
 		};
 		this.userTools.set(name, tool);
 		this.enabledTools.add(name);
+		if (ownerPluginId !== void 0) this.toolOwners.set(name, ownerPluginId);
+		else this.toolOwners.delete(name);
+		this.agent.emitEvent({
+			type: "tool.list.updated",
+			reason: "user.registered",
+			toolName: name
+		});
 	}
 	unregisterUserTool(name) {
 		this.agent.records.logRecord({
@@ -97038,6 +98610,80 @@ var ToolManager = class {
 		});
 		this.userTools.delete(name);
 		this.enabledTools.delete(name);
+		this.toolOwners.delete(name);
+		this.agent.emitEvent({
+			type: "tool.list.updated",
+			reason: "user.unregistered",
+			toolName: name
+		});
+	}
+	/**
+	* Drop every user tool owned by `ownerPluginId` (a plugin being removed,
+	* disabled, or circuit-tripped). Returns the removed count. The loop rebuilds
+	* its tool list from `loopTools` on the next step, so no extra refresh is
+	* needed beyond the per-tool events emitted here.
+	*/
+	unregisterToolsByOwner(ownerPluginId) {
+		let removed = 0;
+		for (const [toolName, owner] of this.toolOwners) {
+			if (owner !== ownerPluginId) continue;
+			this.unregisterUserTool(toolName);
+			removed += 1;
+		}
+		return removed;
+	}
+	/**
+	* Circuit breaker bookkeeping (see `PLUGIN_CIRCUIT_TRIP_THRESHOLD`): every
+	* plugin-owned capability outcome flows here. `ok` clears the streak; a
+	* failure streak reaching the threshold trips the plugin exactly once and
+	* starts its asynchronous teardown. Returns 'tripped' on the call that
+	* crossed the line, so the caller can attach the advisory to its result.
+	*/
+	reportOwnerOutcome(pluginId, ok) {
+		this.agent.toolServices?.plugins?.recordUsage?.(pluginId, ok);
+		if (this.trippedPlugins.has(pluginId)) return void 0;
+		if (ok) {
+			this.circuitFailures.delete(pluginId);
+			return;
+		}
+		const failures = (this.circuitFailures.get(pluginId) ?? 0) + 1;
+		this.circuitFailures.set(pluginId, failures);
+		if (failures < 3) return void 0;
+		this.trippedPlugins.add(pluginId);
+		this.tripPlugin(pluginId, failures);
+		return "tripped";
+	}
+	getCircuitFailures(pluginId) {
+		return this.circuitFailures.get(pluginId) ?? 0;
+	}
+	isCircuitTripped(pluginId) {
+		return this.trippedPlugins.has(pluginId);
+	}
+	/** Clear the breaker for a plugin (ManagePlugin `reset`); it starts clean. */
+	resetCircuit(pluginId) {
+		this.circuitFailures.delete(pluginId);
+		this.trippedPlugins.delete(pluginId);
+	}
+	/**
+	* Take a tripped plugin out of service: record why, persist it disabled,
+	* then let the host's session-sync pass tear its code, tools, MCP servers,
+	* and skills out of every live session. Best-effort: a teardown surprise
+	* must never propagate back into the tool loop that detected the failures.
+	*/
+	async tripPlugin(pluginId, failures) {
+		const services = this.agent.toolServices;
+		try {
+			if (services?.plugins !== void 0) {
+				await services.plugins.markError(pluginId, `circuit tripped after ${String(failures)} consecutive tool failures`);
+				await services.plugins.setEnabled(pluginId, false);
+			}
+		} catch {}
+		try {
+			await services?.pluginSync?.([pluginId]);
+		} catch {}
+		try {
+			await services?.plugins?.appendQuarantine(pluginId, `circuit tripped after ${String(failures)} consecutive tool failures`);
+		} catch {}
 	}
 	/**
 	* Register an MCP server (and its tools). Public entry point for third-party
@@ -97085,38 +98731,48 @@ var ToolManager = class {
 						description: tool.description,
 						approvalRule: qualified,
 						execute: async (context) => {
-							const runCall = async (targetClient) => {
-								return mcpResultToExecutableOutput(await targetClient.callTool(tool.name, args ?? {}, context.signal), qualified);
-							};
-							try {
-								return await runCall(client);
-							} catch (error) {
-								const mcp = options?.mcp;
-								if (mcp === void 0 || context.signal.aborted || !(isRetriableMcpCallError(error) || mcp.get(serverName)?.status !== "connected")) return {
-									isError: true,
-									output: `MCP tool "${tool.name}" failed: ` + (error instanceof Error ? error.message : String(error))
-								};
-								try {
-									await mcp.reconnect(serverName);
-								} catch {}
-								if (context.signal.aborted) return {
-									isError: true,
-									output: `MCP tool "${tool.name}" aborted during reconnect.`
-								};
-								const resolved = mcp.resolved(serverName);
-								if (resolved === void 0) return {
-									isError: true,
-									output: `MCP tool "${tool.name}" failed: ` + (error instanceof Error ? error.message : String(error))
+							const invoke = async () => {
+								const runCall = async (targetClient) => {
+									return mcpResultToExecutableOutput(await targetClient.callTool(tool.name, args ?? {}, context.signal), qualified);
 								};
 								try {
-									return await runCall(resolved.client);
-								} catch (retryError) {
-									return {
+									return await runCall(client);
+								} catch (error) {
+									const mcp = options?.mcp;
+									if (mcp === void 0 || context.signal.aborted || !(isRetriableMcpCallError(error) || mcp.get(serverName)?.status !== "connected")) return {
+										isError: true,
+										output: `MCP tool "${tool.name}" failed: ` + (error instanceof Error ? error.message : String(error))
+									};
+									try {
+										await mcp.reconnect(serverName);
+									} catch {}
+									if (context.signal.aborted) return {
+										isError: true,
+										output: `MCP tool "${tool.name}" aborted during reconnect.`
+									};
+									const resolved = mcp.resolved(serverName);
+									if (resolved === void 0) return {
 										isError: true,
-										output: `MCP tool "${tool.name}" failed after reconnect: ` + (retryError instanceof Error ? retryError.message : String(retryError))
+										output: `MCP tool "${tool.name}" failed: ` + (error instanceof Error ? error.message : String(error))
 									};
+									try {
+										return await runCall(resolved.client);
+									} catch (retryError) {
+										return {
+											isError: true,
+											output: `MCP tool "${tool.name}" failed after reconnect: ` + (retryError instanceof Error ? retryError.message : String(retryError))
+										};
+									}
 								}
-							}
+							};
+							const outcome = await invoke();
+							const owner = pluginOwnerFromMcpServerName(serverName);
+							if (owner === void 0) return outcome;
+							if (this.reportOwnerOutcome(owner, outcome.isError !== true) !== "tripped") return outcome;
+							return {
+								...outcome,
+								output: `${describeToolOutput(outcome.output)}\n\n${circuitTripNote(owner)}`
+							};
 						}
 					};
 				}
@@ -97229,6 +98885,26 @@ var ToolManager = class {
 	isMcpToolEnabled(name) {
 		return this.mcpAccessPatterns.some((pattern) => import_picomatch.default.isMatch(name, pattern));
 	}
+	/** The enabled-name filter a turn freezes at its start. */
+	snapshotEnabledTools() {
+		return {
+			names: new Set(this.enabledTools),
+			mcpPatterns: [...this.mcpAccessPatterns]
+		};
+	}
+	/**
+	* Build the offered tool table against an explicit enabled-name filter
+	* while the registration maps (user tools, MCP servers) stay live. A turn
+	* uses this with its frozen filter: a mid-turn `setActiveTools` then
+	* applies to the NEXT turn by design (turn config stability), while a
+	* plugin tool registered — or reclaimed by the breaker — mid-turn still
+	* shows up on the very next step.
+	*/
+	loopToolsFor(filter) {
+		const mcpNames = [...this.mcpTools.keys()].filter((name) => filter.mcpPatterns.some((pattern) => import_picomatch.default.isMatch(name, pattern)));
+		const hideGoalMutationTools = this.agent.goal.getGoal().goal === null;
+		return uniq([...filter.names, ...mcpNames]).toSorted((a, b) => a.localeCompare(b)).filter((name) => !(hideGoalMutationTools && (name === "SetGoalBudget" || name === "UpdateGoal" || name === "WriteGoalNote"))).map((name) => this.userTools.get(name) ?? this.mcpTools.get(name)?.tool ?? this.builtinTools.get(name)).filter((tool) => !!tool);
+	}
 	*toolInfos() {
 		for (const tool of this.builtinTools.values()) yield {
 			name: tool.name,
@@ -97306,6 +98982,7 @@ var ToolManager = class {
 			this.agent.skills?.registry.listInvocableSkills().length && new SkillTool(this.agent),
 			this.agent.type === "main" && new MakeSkillPlanTool(this.agent),
 			this.agent.type === "main" && new MakeSkillApplyTool(this.agent),
+			this.agent.type === "main" && new ManagePluginTool(this.agent),
 			canSpawn && new AgentTool(this.agent.subagentHost, background, visibleSubagents, {
 				allowBackground,
 				log: this.agent.log,
@@ -97331,9 +99008,10 @@ var ToolManager = class {
 		return (input) => withAuth((auth) => uploadVideo(input, { auth }));
 	}
 	get loopTools() {
-		const mcpNames = [...this.mcpTools.keys()].filter((name) => this.isMcpToolEnabled(name));
-		const hideGoalMutationTools = this.agent.goal.getGoal().goal === null;
-		return uniq([...this.enabledTools, ...mcpNames]).toSorted((a, b) => a.localeCompare(b)).filter((name) => !(hideGoalMutationTools && (name === "SetGoalBudget" || name === "UpdateGoal" || name === "WriteGoalNote"))).map((name) => this.userTools.get(name) ?? this.mcpTools.get(name)?.tool ?? this.builtinTools.get(name)).filter((tool) => !!tool);
+		return this.loopToolsFor({
+			names: this.enabledTools,
+			mcpPatterns: this.mcpAccessPatterns
+		});
 	}
 };
 //#endregion
@@ -98217,6 +99895,7 @@ var TurnFlow = class {
 	async runTurn(turnId, signal) {
 		let stopHookContinuationUsed = false;
 		const deduper = new ToolCallDeduplicator();
+		const turnToolFilter = this.agent.tools.snapshotEnabledTools();
 		await Promise.race([this.agent.mcp?.waitForInitialLoad(signal) ?? Promise.resolve(), new Promise((resolve) => setTimeout(resolve, MCP_WAIT_TIMEOUT_MS))]);
 		while (true) {
 			signal.throwIfAborted();
@@ -98230,6 +99909,7 @@ var TurnFlow = class {
 					buildMessages: () => this.agent.context.messagesForLLM(),
 					dispatchEvent: this.buildDispatchEvent(turnId),
 					tools: this.agent.tools.loopTools,
+					buildTools: () => this.agent.tools.loopToolsFor(turnToolFilter),
 					log: this.agent.log,
 					maxSteps: loopControl?.maxStepsPerTurn,
 					maxRetryAttempts: loopControl?.maxRetriesPerStep,
@@ -99683,6 +101363,7 @@ function applyEnvModelConfig(config, env = process.env) {
 	const displayName = trimmed(env["SCREAM_MODEL_DISPLAY_NAME"]);
 	const reasoningKey = trimmed(env["SCREAM_MODEL_REASONING_KEY"]);
 	const adaptiveThinking = parseBooleanVar(env["SCREAM_MODEL_ADAPTIVE_THINKING"], "SCREAM_MODEL_ADAPTIVE_THINKING");
+	const forceThinking = parseBooleanVar(env["SCREAM_MODEL_FORCE_THINKING"], "SCREAM_MODEL_FORCE_THINKING");
 	const alias = {
 		provider: ENV_MODEL_PROVIDER_KEY,
 		model,
@@ -99691,7 +101372,8 @@ function applyEnvModelConfig(config, env = process.env) {
 		...displayName !== void 0 ? { displayName } : {},
 		...maxOutputSize !== void 0 ? { maxOutputSize } : {},
 		...reasoningKey !== void 0 ? { reasoningKey } : {},
-		...adaptiveThinking !== void 0 ? { adaptiveThinking } : {}
+		...adaptiveThinking !== void 0 ? { adaptiveThinking } : {},
+		...forceThinking !== void 0 ? { forceThinking } : {}
 	};
 	const thinkingMode = trimmed(env["SCREAM_MODEL_THINKING_MODE"]);
 	const thinkingEffort = trimmed(env["SCREAM_MODEL_THINKING_EFFORT"]);
@@ -104535,9 +106217,10 @@ function createRPC() {
 * - `load()` — dynamic-import the entry point (cached per path)
 * - `activate()` — inject declared manifest hooks into the agent's HookEngine,
 *   then call the plugin's `activate(context)`; tools are registered by the
-*   plugin itself via `context.services.tools.registerUserTool`
-* - `deactivate()` — symmetric removal (hooks + deactivate hook), isolated so
-*   a failing plugin never breaks the agent
+*   plugin itself via `context.services.tools.registerUserTool`. Hooks and
+*   event subscriptions made during a failed activation are rolled back
+* - `deactivate()` — symmetric removal (hooks + event subscriptions +
+*   deactivate hook), isolated so a failing plugin never breaks the agent
 *
 * Activation is deliberately lazy (a `/plugin activate` command or explicit
 * config opt-in), so merely installing a plugin never executes its code.
@@ -104572,9 +106255,15 @@ var ExtensionRuntime = class {
 		const module = await this.load(extension.entryPoint);
 		let hooksUnregister;
 		if (extension.manifest.hooks !== void 0 && extension.manifest.hooks.length > 0) hooksUnregister = agent.hooks?.registerAll(extension.manifest.hooks);
+		const subscriptions = [];
+		let handlerFaults = 0;
+		const onHandlerFault = () => {
+			handlerFaults += 1;
+			if (handlerFaults >= 3 && this.isActive(extension.pluginId)) this.deactivate(extension.pluginId);
+		};
 		const context = {
-			services: agent.services,
-			events: agent.eventBus,
+			services: withPluginToolOwnership(agent.services, extension.pluginId),
+			events: createTrackedEventBus(agent.eventBus, subscriptions, onHandlerFault),
 			config: extension.manifest.config,
 			pluginId: extension.pluginId
 		};
@@ -104582,20 +106271,42 @@ var ExtensionRuntime = class {
 			await module.activate(context);
 		} catch (error) {
 			hooksUnregister?.();
+			releaseSubscriptions(subscriptions);
 			throw error;
 		}
 		this.activations.set(extension.pluginId, {
 			module,
-			hooksUnregister
+			hooksUnregister,
+			subscriptions,
+			log: agent.log,
+			agent
 		});
 	}
-	/** Deactivate a plugin: remove its hooks and call its deactivate hook. */
+	/** Deactivate a plugin: drop its hooks/subscriptions, then call its deactivate. */
 	async deactivate(pluginId) {
 		const activation = this.activations.get(pluginId);
 		if (activation === void 0) return;
 		activation.hooksUnregister?.();
+		releaseSubscriptions(activation.subscriptions);
 		this.activations.delete(pluginId);
-		await activation.module.deactivate?.();
+		try {
+			activation.agent.services.tools?.unregisterToolsByOwner?.(pluginId);
+		} catch {}
+		try {
+			await activation.module.deactivate?.();
+		} catch (error) {
+			activation.log?.warn("plugin deactivate failed", {
+				pluginId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	/**
+	* Deactivate every live plugin. Provided so a host can tear down all code
+	* plugins in one call; each plugin's failure is isolated from the others.
+	*/
+	async deactivateAll() {
+		for (const pluginId of Array.from(this.activations.keys())) await this.deactivate(pluginId);
 	}
 	isActive(pluginId) {
 		return this.activations.has(pluginId);
@@ -104609,6 +106320,67 @@ function normalizeExtensionModule(mod) {
 	if (candidate === void 0 || typeof candidate.activate !== "function") throw new Error("Plugin entry point must export an activate(context) function");
 	return candidate;
 }
+/**
+* Wrap the agent's bus in a per-activation view that records every unsubscribe
+* handle the plugin gets, so the runtime can release them if activation fails.
+*/
+function createTrackedEventBus(bus, subscriptions, onFault) {
+	return {
+		subscribe: (type, handler) => {
+			const guarded = (event) => {
+				try {
+					const out = handler(event);
+					if (out !== null && typeof out.then === "function") out.catch(() => {
+						onFault?.();
+					});
+					return out;
+				} catch (error) {
+					onFault?.();
+					throw error;
+				}
+			};
+			const unsubscribe = bus.subscribe(type, guarded);
+			subscriptions.push(unsubscribe);
+			return unsubscribe;
+		},
+		clear: () => {
+			releaseSubscriptions(subscriptions);
+		}
+	};
+}
+/** Release every subscription recorded for one activation, isolating failures. */
+function releaseSubscriptions(subscriptions) {
+	while (subscriptions.length > 0) {
+		const unsubscribe = subscriptions.pop();
+		try {
+			unsubscribe?.();
+		} catch {}
+	}
+}
+/**
+* A services view handed to one activated plugin. It forwards everything to
+* the agent's real manifest except `tools.registerUserTool`, where it stamps
+* `ownerPluginId` with this plugin's id (an explicit id from the plugin wins).
+* Ownership is what lets remove/disable/circuit-trip reclaim the plugin's
+* tools from live agents without trusting the plugin to clean up after itself.
+*/
+function withPluginToolOwnership(services, pluginId) {
+	const tools = services.tools;
+	if (typeof tools !== "object" || tools === null) return services;
+	const ownedTools = new Proxy(tools, { get(target, prop, receiver) {
+		if (prop === "registerUserTool") return (input) => {
+			target.registerUserTool({
+				...input,
+				ownerPluginId: input.ownerPluginId ?? pluginId
+			});
+		};
+		return Reflect.get(target, prop, receiver);
+	} });
+	return {
+		...services,
+		tools: ownedTools
+	};
+}
 //#endregion
 //#region ../../packages/agent-core/src/tools/providers/fetch-cache.ts
 /**
@@ -119096,7 +120868,7 @@ var ProviderManager = class {
 		const providerConfig = this.config.providers[providerName];
 		if (providerConfig === void 0) throw new ScreamError(ErrorCodes.CONFIG_INVALID, `Provider "${providerName}" for model "${model}" is not configured.`);
 		if (!Number.isInteger(alias.maxContextSize) || alias.maxContextSize <= 0) throw new ScreamError(ErrorCodes.CONFIG_INVALID, `Model "${model}" must define a positive max_context_size in config.toml.`);
-		const provider = toLtodProviderConfig(providerConfig, alias.model, this.options.screamRequestHeaders, alias.maxOutputSize, alias.reasoningKey, this.options.promptCacheKey, alias.adaptiveThinking);
+		const provider = toLtodProviderConfig(providerConfig, alias.model, this.options.screamRequestHeaders, alias.maxOutputSize, alias.reasoningKey, this.options.promptCacheKey, alias.adaptiveThinking, alias.forceThinking);
 		return {
 			providerName,
 			provider,
@@ -119158,7 +120930,7 @@ function resolveModelCapabilities(alias, provider) {
 		max_context_tokens: alias.maxContextSize
 	};
 }
-function toLtodProviderConfig(provider, model, screamRequestHeaders, maxOutputSize, reasoningKey, promptCacheKey, adaptiveThinking) {
+function toLtodProviderConfig(provider, model, screamRequestHeaders, maxOutputSize, reasoningKey, promptCacheKey, adaptiveThinking, forceThinking) {
 	switch (provider.type) {
 		case "anthropic": return {
 			type: "anthropic",
@@ -119175,6 +120947,7 @@ function toLtodProviderConfig(provider, model, screamRequestHeaders, maxOutputSi
 			baseUrl: providerValue(provider.baseUrl, provider.env, "OPENAI_BASE_URL"),
 			apiKey: providerApiKey(provider),
 			reasoningKey,
+			...forceThinking !== void 0 ? { forceThinking } : {},
 			...defaultHeadersField(provider.customHeaders)
 		};
 		case "scream": return {
@@ -119183,6 +120956,7 @@ function toLtodProviderConfig(provider, model, screamRequestHeaders, maxOutputSi
 			baseUrl: providerValue(provider.baseUrl, provider.env, "SCREAM_BASE_URL"),
 			apiKey: providerApiKey(provider),
 			generationKwargs: { prompt_cache_key: promptCacheKey },
+			...forceThinking !== void 0 ? { forceThinking } : {},
 			...defaultHeadersField({
 				...screamRequestHeaders,
 				...provider.customHeaders
@@ -121244,12 +123018,36 @@ var ScreamCore = class {
 		if (plugin === void 0) throw new ScreamError(ErrorCodes.PLUGIN_NOT_FOUND, `Plugin "${pluginId}" was not found`, { details: { pluginId } });
 		const [extension] = this.extensionRuntime.discover([plugin]);
 		if (extension === void 0) throw new ScreamError(ErrorCodes.PLUGIN_NOT_FOUND, `Plugin "${pluginId}" has no code entry point`, { details: { pluginId } });
-		await this.extensionRuntime.activate(agent, extension);
+		try {
+			await this.extensionRuntime.activate(agent, extension);
+		} catch (error) {
+			await this.markPluginError(pluginId, error);
+			throw error;
+		}
+		await this.syncSessionsBestEffort([pluginId]);
+	}
+	/**
+	* Best-effort bookkeeping for a failed activation: a `markError` failure must
+	* not replace the activation error the caller is about to see.
+	*/
+	async markPluginError(pluginId, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		try {
+			await this.plugins.markError(pluginId, message);
+		} catch (markError) {
+			log.warn("failed to record plugin activation error", {
+				pluginId,
+				reason: markError instanceof Error ? markError.message : String(markError)
+			});
+		}
 	}
 	/** Deactivate a code plugin (removes its hooks and runs its deactivate). */
 	async deactivatePlugin({ pluginId }) {
 		await this.pluginsReady;
 		await this.extensionRuntime.deactivate(pluginId);
+		for (const session of this.sessions.values()) for (const agent of session.agents.values()) try {
+			agent.tools.unregisterToolsByOwner(pluginId);
+		} catch {}
 	}
 	/** Code plugins the runtime can load, with their activation state. */
 	async pluginExtensionStatus() {
@@ -121397,13 +123195,202 @@ var ScreamCore = class {
 	removeMcpServer({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).removeMcpServer(payload);
 	}
+	/**
+	* Push the current plugin table into every live session: plugin MCP servers,
+	* plugin skills, and in-process code/tool teardown for plugins that stopped
+	* being live. This is the hot-apply path behind `ToolServices.pluginSync`
+	* and the plugin write RPCs.
+	*
+	* Contract:
+	* - MCP edits are confined to plugin-owned runtime names (`plugin-<id>:<server>`);
+	*   user-configured servers are never touched.
+	* - `skipMcpAdd` honors "install never executes": skill data hot-applies, but
+	*   no plugin MCP process is started until an explicit enable/activate/reload.
+	* - A changed id whose record is gone, disabled, or errored gets its code
+	*   deactivated and its owned user tools dropped before its capabilities are
+	*   pulled from sessions. A live id is never activated here — running code
+	*   still requires an explicit, separately approved `activate`.
+	* - Every sub-action is isolated: failures accumulate in `failed[]` and this
+	*   returns a report; it never throws back to a caller whose plugin mutation
+	*   already succeeded.
+	*/
+	async applyPluginChangesToSessions(changedIds, options) {
+		await this.pluginsReady;
+		const applied = [];
+		const failed = [];
+		const messageOf = (error) => error instanceof Error ? error.message : String(error);
+		let desired = {};
+		let desiredUnknown = false;
+		try {
+			desired = this.plugins.enabledMcpServers();
+		} catch (error) {
+			desiredUnknown = true;
+			failed.push({
+				step: "mcp.add",
+				message: messageOf(error)
+			});
+		}
+		const targets = new Set(changedIds ?? []);
+		if (changedIds === void 0) {
+			try {
+				for (const record of this.plugins.list()) targets.add(record.id);
+			} catch (error) {
+				failed.push({
+					step: "mcp.add",
+					message: messageOf(error)
+				});
+			}
+			for (const [sessionId, session] of this.sessions) try {
+				for (const entry of session.mcp.list()) {
+					if (!isPluginMcpRuntimeName(entry.name)) continue;
+					const id = pluginIdFromMcpRuntimeName(entry.name);
+					if (id !== void 0) targets.add(id);
+				}
+			} catch (error) {
+				failed.push({
+					step: "mcp.remove",
+					message: `session ${sessionId}: ${messageOf(error)}`
+				});
+			}
+		}
+		const isLive = (id) => {
+			const record = this.plugins.get(id);
+			return record !== void 0 && record.enabled && record.state === "ok";
+		};
+		for (const id of targets) {
+			if (isLive(id)) continue;
+			if (this.extensionRuntime.isActive(id)) try {
+				await this.extensionRuntime.deactivate(id);
+				applied.push({
+					kind: "plugin.deactivate",
+					name: id,
+					session: "host"
+				});
+			} catch (error) {
+				failed.push({
+					step: "plugin.deactivate",
+					pluginId: id,
+					message: messageOf(error)
+				});
+			}
+			for (const [sessionId, session] of this.sessions) for (const agent of session.agents.values()) try {
+				if (agent.tools.unregisterToolsByOwner(id) > 0) applied.push({
+					kind: "tools.remove",
+					name: id,
+					session: sessionId
+				});
+			} catch (error) {
+				failed.push({
+					step: "tools.remove",
+					pluginId: id,
+					message: messageOf(error)
+				});
+			}
+		}
+		for (const [sessionId, session] of this.sessions) {
+			let actualNames = /* @__PURE__ */ new Set();
+			try {
+				actualNames = new Set(session.mcp.list().map((entry) => entry.name));
+			} catch (error) {
+				failed.push({
+					step: "mcp.add",
+					message: messageOf(error)
+				});
+			}
+			for (const id of targets) {
+				const live = isLive(id);
+				if (!desiredUnknown) {
+					for (const name of actualNames) {
+						if (!isPluginMcpRuntimeName(name)) continue;
+						if (pluginIdFromMcpRuntimeName(name) !== id) continue;
+						if (live && desired[name] !== void 0) continue;
+						try {
+							await session.mcp.removeServer(name);
+							applied.push({
+								kind: "mcp.remove",
+								name,
+								session: sessionId
+							});
+							actualNames.delete(name);
+						} catch (error) {
+							failed.push({
+								step: "mcp.remove",
+								pluginId: id,
+								message: messageOf(error)
+							});
+						}
+					}
+					if (live && options?.skipMcpAdd !== true) for (const [name, config] of Object.entries(desired)) {
+						if (pluginIdFromMcpRuntimeName(name) !== id) continue;
+						if (actualNames.has(name)) continue;
+						try {
+							await session.mcp.addServer(name, config);
+							applied.push({
+								kind: "mcp.add",
+								name,
+								session: sessionId
+							});
+							actualNames.add(name);
+						} catch (error) {
+							failed.push({
+								step: "mcp.add",
+								pluginId: id,
+								message: messageOf(error)
+							});
+						}
+					}
+				}
+				try {
+					session.ejectPlugin(id);
+					applied.push({
+						kind: "skills.eject",
+						name: id,
+						session: sessionId
+					});
+					if (live) {
+						const roots = this.plugins.pluginSkillRoots().filter((root) => root.plugin?.id === id);
+						if (roots.length > 0) {
+							await session.injectSkillRoots(roots);
+							applied.push({
+								kind: "skills.inject",
+								name: id,
+								session: sessionId
+							});
+						}
+					}
+				} catch (error) {
+					failed.push({
+						step: live ? "skills.inject" : "skills.eject",
+						pluginId: id,
+						message: messageOf(error)
+					});
+				}
+			}
+		}
+		return {
+			ok: failed.length === 0,
+			sessions: this.sessions.size,
+			applied,
+			failed
+		};
+	}
+	/**
+	* Best-effort wrapper for hot-apply after a successful plugin write: the
+	* mutation already landed, so a sync surprise must never fail the RPC or
+	* the tool call that triggered it.
+	*/
+	async syncSessionsBestEffort(changedIds, options) {
+		try {
+			await this.applyPluginChangesToSessions(changedIds, options);
+		} catch (error) {
+			log.warn("plugin hot-apply failed", { reason: error instanceof Error ? error.message : String(error) });
+		}
+	}
 	async removePlugin({ id }) {
 		await this.pluginsReady;
 		this.assertPluginsLoaded();
 		await this.plugins.remove(id);
-		for (const session of this.sessions.values()) try {
-			session.ejectPlugin(id);
-		} catch {}
+		await this.applyPluginChangesToSessions([id]);
 	}
 	generateAgentsMd({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).generateAgentsMd(payload);
@@ -121412,6 +123399,7 @@ var ScreamCore = class {
 		await this.pluginsReady;
 		this.assertPluginsLoaded();
 		const record = await this.plugins.install(payload.source);
+		await this.syncSessionsBestEffort([record.id], { skipMcpAdd: true });
 		return this.plugins.summaries().find((s) => s.id === record.id);
 	}
 	async listPlugins(_) {
@@ -121423,16 +123411,19 @@ var ScreamCore = class {
 		await this.pluginsReady;
 		this.assertPluginsLoaded();
 		await this.plugins.setEnabled(id, enabled);
+		await this.syncSessionsBestEffort([id]);
 	}
 	async setPluginMcpServerEnabled({ id, server, enabled }) {
 		await this.pluginsReady;
 		this.assertPluginsLoaded();
 		await this.plugins.setMcpServerEnabled(id, server, enabled);
+		await this.syncSessionsBestEffort([id]);
 	}
 	async reloadPlugins(_) {
 		try {
 			const summary = await this.plugins.reload();
 			this.pluginsLoadError = void 0;
+			await this.syncSessionsBestEffort();
 			return summary;
 		} catch (error) {
 			this.pluginsLoadError = error instanceof Error ? error : new Error(String(error));
@@ -121457,10 +123448,14 @@ var ScreamCore = class {
 		});
 	}
 	async resolveRuntime(config) {
-		if (this.runtime !== void 0) return this.runtime;
-		const runtime = await createRuntimeConfig({ config });
-		this.runtime = runtime;
-		return runtime;
+		const base = this.runtime ?? await createRuntimeConfig({ config });
+		this.runtime = base;
+		return {
+			...base,
+			plugins: this.plugins,
+			extensionRuntime: this.extensionRuntime,
+			pluginSync: (changedIds, syncOptions) => this.applyPluginChangesToSessions(changedIds, syncOptions)
+		};
 	}
 	resolveSessionSkillConfig(config) {
 		const explicitDirs = this.skillDirs.length > 0 ? this.skillDirs : void 0;
@@ -123445,6 +125440,92 @@ const PULSE_WAVE_FRAMES = [
 	}
 ];
 //#endregion
+//#region src/tui/commands/knowledge-store.ts
+let knowledgeStoreInstance;
+let embeddingEngineInstance;
+let embeddingStatus = "idle";
+function getEmbeddingCacheDir() {
+	const dir = join(getDataDir(), "cache", "fastembed");
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+/** Subdirectory fastembed uses for the BGESmallZH model inside the cache dir. */
+const EMBEDDING_MODEL_DIR = "fast-bge-small-zh-v1.5";
+/**
+* Whether the embedding model has been downloaded to the local cache.
+* Checks the ONNX weights plus the config and tokenizer sidecars — all
+* required for FlagEmbedding.init to load without network access (a missing
+* tokenizer would trigger a network fetch and violate the warm-up's
+* offline-load guarantee).
+*/
+function isEmbeddingModelCached() {
+	const modelDir = join(getEmbeddingCacheDir(), EMBEDDING_MODEL_DIR);
+	return existsSync(join(modelDir, "model_optimized.onnx")) && existsSync(join(modelDir, "config.json")) && existsSync(join(modelDir, "tokenizer.json"));
+}
+async function getKnowledgeStore() {
+	if (knowledgeStoreInstance === void 0) {
+		knowledgeStoreInstance = new KnowledgeStore(getDataDir());
+		await knowledgeStoreInstance.init();
+		embeddingEngineInstance = createFastEmbedEngine(getEmbeddingCacheDir());
+		knowledgeStoreInstance.setEmbeddingEngine(embeddingEngineInstance);
+	}
+	return knowledgeStoreInstance;
+}
+function getEmbeddingStatus() {
+	return embeddingStatus;
+}
+/**
+* Manually trigger the embedding model download/load.
+* Only mutates embeddingStatus; the actual download is delegated to
+* EmbeddingEngine.ensureReady() and saves the model to the shared cache dir.
+* Returns { ok: true } on success, or { ok: false, error } on failure.
+* Concurrent calls join the in-flight download and share its result instead
+* of failing — the startup warm-up and a user-initiated download must never
+* race into a spurious "download already in progress" error.
+*/
+async function startManualEmbeddingDownload() {
+	if (embeddingEngineInstance === void 0) return {
+		ok: false,
+		error: "embedding engine not initialized"
+	};
+	if (embeddingEngineInstance.available) {
+		embeddingStatus = "ready";
+		return {
+			ok: true,
+			alreadyReady: true
+		};
+	}
+	if (downloadPromise !== void 0) return downloadPromise;
+	embeddingStatus = "downloading";
+	downloadPromise = performDownload().finally(() => {
+		downloadPromise = void 0;
+	});
+	return downloadPromise;
+}
+let downloadPromise;
+async function performDownload() {
+	try {
+		let ok = await embeddingEngineInstance.ensureReady();
+		let error = ok ? void 0 : embeddingEngineInstance.lastError;
+		if (!ok) {
+			clearEmbeddingModelCache(getEmbeddingCacheDir());
+			ok = await embeddingEngineInstance.ensureReady();
+			error = ok ? void 0 : embeddingEngineInstance.lastError;
+		}
+		embeddingStatus = ok ? "ready" : "failed";
+		return {
+			ok,
+			error
+		};
+	} catch (error) {
+		embeddingStatus = "failed";
+		return {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+//#endregion
 //#region src/tui/commands/experimental-flags.ts
 let snapshot = {};
 /** Replace the cached flag snapshot. Call once after fetching via `harness.getExperimentalFlags()`. */
@@ -124754,31 +126835,16 @@ function getWireTypeOptions() {
 }
 function getThinkingOptions() {
 	return [
-		{
-			value: "off",
-			label: t("prompts.thinking_off")
-		},
-		{
-			value: "low",
-			label: t("prompts.thinking_low")
-		},
-		{
-			value: "medium",
-			label: t("prompts.thinking_medium")
-		},
-		{
-			value: "high",
-			label: t("prompts.thinking_high")
-		},
-		{
-			value: "xhigh",
-			label: t("prompts.thinking_xhigh")
-		},
-		{
-			value: "max",
-			label: t("prompts.thinking_max")
-		}
-	];
+		"off",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	].map((level) => ({
+		value: level,
+		label: level
+	}));
 }
 function getImageOptions() {
 	return [{
@@ -127301,7 +129367,7 @@ function isStreaming(state) {
 /** True when the session is busy and should reject state-changing operations.
 *  Covers both active streaming and context compaction. */
 function isBusy(state) {
-	return isStreaming(state) || state.isCompacting;
+	return isStreaming(state) || state.isCompacting || state.isSwitchingSession;
 }
 //#endregion
 //#region src/tui/constant/terminal.ts
@@ -129525,7 +131591,7 @@ async function guidedGoalSetup(host) {
 		host.showNotice(t("goal.storm_breaker"), t("goal.conflict_loop"));
 		return;
 	}
-	const { TextInputDialogComponent } = await import("./text-input-dialog-B9uwX1Uy.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-Dr42qLMU.mjs");
 	const initialDesc = await promptText(host, TextInputDialogComponent, {
 		title: t("goal.setup_title_initial"),
 		subtitle: t("goal.setup_desc_hint"),
@@ -129546,7 +131612,7 @@ async function guidedGoalSetup(host) {
 	await showGoalConfigWizard(host, session, confirmed.trim() || objective, false);
 }
 async function showGoalConfigWizard(host, session, objective, replace) {
-	const { TextInputDialogComponent } = await import("./text-input-dialog-B9uwX1Uy.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-Dr42qLMU.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -136352,7 +138418,7 @@ function buildRoleAdditionalText(prefs) {
 	if (items.length === 0 && (doNot === void 0 || doNot.length === 0) && !hasToolPriority) return "";
 	lines.push("", ...items);
 	if (doNot !== void 0 && doNot.length > 0) lines.push("", "## Do NOT (explicit prohibitions — NEVER do these)", doNot);
-	if (hasToolPriority) lines.push("", "## Tool priority (set via /like — HIGHEST PRIORITY)", prefs.toolPriority === "skill" ? "For every user request: (1) first analyze the intent, (2) then identify whether any installed skill matches THIS request, (3) if one matches, invoke the Skill tool with it as your FIRST action — before MCP tools or doing it yourself, (4) if none matches, proceed with MCP tools or solve it yourself. Consult the skill list shown in the Skill tool description whenever you are unsure what is installed." : "For every user request: (1) first analyze the intent, (2) then identify whether any available MCP tool matches THIS request, (3) if one matches, use it as your FIRST action — before the Skill tool or doing it yourself, (4) if none matches, proceed with the Skill tool or solve it yourself.");
+	if (hasToolPriority) lines.push("", "## Tool priority (set via /like — HIGHEST PRIORITY)", prefs.toolPriority === "skill" ? "For every user request: (1) first analyze the intent, (2) then identify whether any installed skill matches THIS request, (3) if one matches, invoke the Skill tool with it as your FIRST action — before MCP tools or doing it yourself, (4) if none matches, proceed with MCP tools or solve it yourself. When the user asks what you have (skills / plugins / capabilities, any wording), answer from an InspectOwnAssets inventory; the skills section of the system prompt is the authoritative view of what is invocable right now." : "For every user request: (1) first analyze the intent, (2) then identify whether any available MCP tool matches THIS request, (3) if one matches, use it as your FIRST action — before the Skill tool or doing it yourself, (4) if none matches, proceed with the Skill tool or solve it yourself.");
 	lines.push("", t("like.priority"));
 	return lines.join("\n");
 }
@@ -136482,65 +138548,6 @@ function openUrl(url) {
 	execFile(command[0], command[1], () => {});
 }
 //#endregion
-//#region src/tui/commands/knowledge-store.ts
-let knowledgeStoreInstance;
-let embeddingEngineInstance;
-let embeddingStatus = "idle";
-function getEmbeddingCacheDir() {
-	const dir = join(getDataDir(), "cache", "fastembed");
-	mkdirSync(dir, { recursive: true });
-	return dir;
-}
-async function getKnowledgeStore() {
-	if (knowledgeStoreInstance === void 0) {
-		knowledgeStoreInstance = new KnowledgeStore(getDataDir());
-		await knowledgeStoreInstance.init();
-		embeddingEngineInstance = createFastEmbedEngine(getEmbeddingCacheDir());
-		knowledgeStoreInstance.setEmbeddingEngine(embeddingEngineInstance);
-	}
-	return knowledgeStoreInstance;
-}
-function getEmbeddingStatus() {
-	return embeddingStatus;
-}
-/**
-* Manually trigger the embedding model download/load.
-* Only mutates embeddingStatus; the actual download is delegated to
-* EmbeddingEngine.ensureReady() and saves the model to the shared cache dir.
-* Returns { ok: true } on success, or { ok: false, error } on failure.
-* Concurrent calls while a download is already in flight are ignored.
-*/
-async function startManualEmbeddingDownload() {
-	if (embeddingEngineInstance === void 0) return {
-		ok: false,
-		error: "embedding engine not initialized"
-	};
-	if (embeddingStatus === "downloading") return {
-		ok: false,
-		error: "download already in progress"
-	};
-	if (embeddingEngineInstance.available) {
-		embeddingStatus = "ready";
-		return {
-			ok: true,
-			alreadyReady: true
-		};
-	}
-	embeddingStatus = "downloading";
-	let ok = await embeddingEngineInstance.ensureReady();
-	let error = ok ? void 0 : embeddingEngineInstance.lastError;
-	if (!ok) {
-		clearEmbeddingModelCache(getEmbeddingCacheDir());
-		ok = await embeddingEngineInstance.ensureReady();
-		error = ok ? void 0 : embeddingEngineInstance.lastError;
-	}
-	embeddingStatus = ok ? "ready" : "failed";
-	return {
-		ok,
-		error
-	};
-}
-//#endregion
 //#region src/tui/commands/knowledge-web.ts
 /**
 * /knowledge web — 知识图谱可视化
@@ -138230,6 +140237,7 @@ async function handleIngest(host) {
 	}
 	const store = await getKnowledgeStore();
 	const llm = makeLlmCaller(host);
+	if (!await ensureEmbeddingReadyInteractive(host)) return;
 	const spinner = host.showProgressSpinner(t("knowledge.ingesting"));
 	try {
 		if (stats.isDirectory()) {
@@ -138240,21 +140248,35 @@ async function handleIngest(host) {
 				ok: result.failed === 0,
 				label: t("knowledge.batch_done")
 			});
+			const coverage = await store.embeddingCoverage();
+			const syncLine = t("knowledge.sync_counts", {
+				created: String(result.created),
+				updated: String(result.updated),
+				unchanged: String(result.unchanged)
+			});
 			if (result.failed > 0) {
 				const summary = [
 					t("knowledge.succeeded", { count: String(result.succeeded) }),
+					syncLine,
 					t("knowledge.failed", { count: String(result.failed) }),
 					t("knowledge.ingest_summary", {
 						chunks: String(result.totalChunks),
 						events: String(result.totalEvents),
 						entities: String(result.totalEntities)
 					}),
+					t("knowledge.vector_coverage", {
+						embedded: String(coverage.embedded),
+						total: String(coverage.total)
+					}),
 					"",
 					t("knowledge.failed_files"),
 					...result.errors.map((e) => `  • ${basename(e.filePath)}: ${e.message}`)
 				].join("\n");
 				host.showNotice(t("knowledge.batch_partial"), summary);
-			} else host.showNotice(t("knowledge.batch_done"), `${t("knowledge.succeeded", { count: String(result.succeeded) })}\n${result.totalChunks} chunks, ${result.totalEvents} events, ${result.totalEntities} entities`);
+			} else host.showNotice(t("knowledge.batch_done"), `${syncLine}\n${result.totalChunks} chunks, ${result.totalEvents} events, ${result.totalEntities} entities\n${t("knowledge.vector_coverage", {
+				embedded: String(coverage.embedded),
+				total: String(coverage.total)
+			})}`);
 		} else {
 			if (!isSupportedFile(filePath)) {
 				spinner.stop({
@@ -138267,11 +140289,19 @@ async function handleIngest(host) {
 			const result = await ingestFile(store, llm, filePath, (progress) => {
 				spinner.setLabel(formatProgress(progress));
 			});
+			const outcomeLabel = result.outcome === "unchanged" ? t("knowledge.ingest_unchanged") : result.outcome === "updated" ? t("knowledge.ingest_updated") : t("knowledge.ingest_done");
 			spinner.stop({
 				ok: true,
-				label: t("knowledge.ingest_done")
+				label: outcomeLabel
 			});
-			host.showNotice(t("knowledge.ingest_done"), `${t("knowledge.file_label")}: ${basename(filePath)}\nchunks: ${result.chunkCount}\nevents: ${result.eventCount}\nentities: ${result.entityCount}`);
+			if (result.outcome === "unchanged") host.showNotice(outcomeLabel, `${t("knowledge.file_label")}: ${basename(filePath)}`);
+			else {
+				const coverage = await store.embeddingCoverage();
+				host.showNotice(outcomeLabel, `${t("knowledge.file_label")}: ${basename(filePath)}\nchunks: ${result.chunkCount}\nevents: ${result.eventCount}\nentities: ${result.entityCount}\n${t("knowledge.vector_coverage", {
+					embedded: String(coverage.embedded),
+					total: String(coverage.total)
+				})}`);
+			}
 		}
 	} catch (error) {
 		spinner.stop({
@@ -138281,6 +140311,31 @@ async function handleIngest(host) {
 		throw error;
 	}
 }
+/**
+* Ensure the shared embedding engine is ready before a vector-dependent
+* operation. Returns true when ready; otherwise shows an error (missing
+* download) or attempts a cached-model load and reports the outcome.
+*/
+async function ensureEmbeddingReadyInteractive(host) {
+	const engine = (await getKnowledgeStore()).getEmbeddingEngine();
+	if (engine !== void 0 && engine.available) return true;
+	if (!isEmbeddingModelCached()) {
+		host.showError(t("knowledge.model_missing"));
+		return false;
+	}
+	const spinner = host.showProgressSpinner(t("knowledge.loading_model"));
+	const { ok, error } = await startManualEmbeddingDownload();
+	spinner.stop({
+		ok,
+		label: ok ? t("kw.embedding_ready") : t("kw.embedding_failed")
+	});
+	if (!ok) {
+		const detail = [t("knowledge.download_model_retry_hint"), error].filter(Boolean).join("\n");
+		host.showNotice(t("knowledge.model_load_failed"), detail);
+		return false;
+	}
+	return true;
+}
 async function handleList(host) {
 	const store = await getKnowledgeStore();
 	const docs = await store.listDocuments();
@@ -138430,6 +140485,97 @@ async function handleDelete(host) {
 	if (await store.deleteSource(sourceId)) host.showNotice(t("knowledge.deleted"), t("knowledge.doc_removed"));
 	else host.showError(t("knowledge.delete_fail_not_found"));
 }
+function pickSourceToReembed(host, sources) {
+	const { promise, resolve } = Promise.withResolvers();
+	const options = sources.map((s) => ({
+		value: s.id,
+		label: s.name,
+		description: s.filePath ?? void 0
+	}));
+	const picker = new ChoicePickerComponent({
+		title: t("knowledge.reembed_pick"),
+		options,
+		colors: host.state.theme.colors,
+		onSelect: (value) => {
+			host.restoreEditor();
+			resolve(value);
+		},
+		onCancel: () => {
+			host.restoreEditor();
+			resolve(void 0);
+		}
+	});
+	host.mountEditorReplacement(picker);
+	return promise;
+}
+function confirmReembedSource(host, source) {
+	const { promise, resolve } = Promise.withResolvers();
+	const options = [{
+		value: "cancel",
+		label: t("common.cancel")
+	}, {
+		value: "confirm",
+		label: t("knowledge.reembed"),
+		description: t("knowledge.reembed_confirm_desc")
+	}];
+	const picker = new ChoicePickerComponent({
+		title: t("knowledge.reembed_confirm_name", { name: source.name }),
+		options,
+		colors: host.state.theme.colors,
+		onSelect: (value) => {
+			host.restoreEditor();
+			resolve(value === "confirm");
+		},
+		onCancel: () => {
+			host.restoreEditor();
+			resolve(false);
+		}
+	});
+	host.mountEditorReplacement(picker);
+	return promise;
+}
+async function handleReembed(host) {
+	const store = await getKnowledgeStore();
+	const sources = await store.listSources();
+	if (sources.length === 0) {
+		host.showNotice(t("knowledge.empty"), t("knowledge.reembed_none"));
+		return;
+	}
+	const sourceId = await pickSourceToReembed(host, sources);
+	if (sourceId === void 0) return;
+	const source = sources.find((s) => s.id === sourceId);
+	if (source === void 0) return;
+	if (!await confirmReembedSource(host, source)) {
+		host.showNotice(t("knowledge.cancelled"));
+		return;
+	}
+	if (!await ensureEmbeddingReadyInteractive(host)) return;
+	const engine = store.getEmbeddingEngine();
+	if (engine === void 0) {
+		host.showError(t("knowledge.model_missing"));
+		return;
+	}
+	const spinner = host.showProgressSpinner(t("knowledge.reembed"));
+	try {
+		const counts = await store.reembedSource(sourceId, engine);
+		spinner.stop({
+			ok: true,
+			label: t("knowledge.reembed_done")
+		});
+		host.showNotice(t("knowledge.reembed_done"), t("knowledge.reembed_summary", {
+			chunks: String(counts.chunks),
+			events: String(counts.events),
+			entities: String(counts.entities),
+			relations: String(counts.relations)
+		}));
+	} catch (error) {
+		spinner.stop({
+			ok: false,
+			label: t("knowledge.reembed")
+		});
+		throw error;
+	}
+}
 async function handleDownloadModel(host) {
 	await getKnowledgeStore();
 	const spinner = host.showProgressSpinner(t("kw.embedding_downloading"));
@@ -138511,6 +140657,11 @@ async function handleKnowledgeCommand(host, _args) {
 				description: t("knowledge.delete_desc"),
 				tone: "danger"
 			},
+			{
+				value: "reembed",
+				label: "🔁 " + t("knowledge.reembed"),
+				description: t("knowledge.reembed_desc")
+			},
 			{
 				value: "stats",
 				label: "📊 " + t("knowledge.stats"),
@@ -138536,6 +140687,7 @@ async function handleKnowledgeCommand(host, _args) {
 						else if (value === "list") await handleList(host);
 						else if (value === "search") await handleSearch(host);
 						else if (value === "delete") await handleDelete(host);
+						else if (value === "reembed") await handleReembed(host);
 						else if (value === "stats") await handleStats(host);
 						else if (value === "web") await handleWeb(host);
 					} catch (error) {
@@ -139183,4 +141335,4 @@ async function handleBuiltInSlashCommand(host, name, args) {
 	}
 }
 //#endregion
-export { handleTitleCommand as $, isTodoItemShape as $t, renderDiffLinesClustered as A, CLI_COMMAND_NAME as An, ENABLE_TERMINAL_FOCUS_REPORTING as At, BackgroundAgentStatusComponent as B, MemoryMemoStore as Bn, TERMINAL_THEME_LIGHT as Bt, handleRevokeCommand as C, loadTuiConfig as Cn, createThemeStyles as Ct, toggleEmptySessionHint as D, getInputHistoryFile as Dn, parseOsc11BackgroundTheme as Dt, isTurnElapsedEnabled as E, getDataDir as En, detectTerminalTheme as Et, estimateTokens as F, fetchCatalog as Fn, OSC11_RESPONSE_PREFIX_NO_ESC as Ft, getBreathingFrame as G, isOrphanedToolCallError as Gn, handleSearchCommand as Gt, AgentGroupComponent as H, log as Hn, isStreaming as Ht, getSharedSpeedTracker as I, saveCatalogCache as In, QUERY_TERMINAL_THEME as It, refineGoal as J, printableChar as Jt, resetBreathingClock as K, ErrorCodes as Kn, handleConnectCommand as Kt, SkillActivationComponent as L, ScreamHarness as Ln, TERMINAL_FOCUS_IN as Lt, langFromPath as M, CLI_USER_AGENT_PRODUCT as Mn, OSC11_QUERY as Mt, CachedContainer as N, PRODUCT_NAME as Nn, OSC11_RESPONSE as Nt, ToolCallComponent as O, getLogDir as On, DISABLE_TERMINAL_FOCUS_REPORTING as Ot, ThinkingComponent as P, DEFAULT_CATALOG_URL as Pn, OSC11_RESPONSE_PREFIX as Pt, handleInitCommand as Q, formatErrorMessage as Qt, ReadGroupComponent as R, MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE as Rn, TERMINAL_FOCUS_OUT as Rt, getDaemonInstructions as S, TuiLikePreferencesSchema as Sn, createMarkdownTheme as St, isEmptySessionHintDismissed as T, detectShellEnvironment as Tn, getColorPalette as Tt, WelcomeComponent as U, resolveGlobalLogPath as Un, FooterComponent as Ut, AssistantMessageComponent as V, flushDiagnosticLogs as Vn, isBusy as Vt, BREATHE_CYCLE_MS as W, isScreamError as Wn, handleTraceCommand as Wt, handleExportMdCommand as X, appendStreamingArgsPreview as Xt, handleExportDebugZipCommand as Y, STATUS_BULLET as Yt, handleForkCommand as Z, argsRecord as Zt, refreshUpdateCache as _, isExperimentalFlagEnabled as _n, clearInfoPanelState as _t, handleExtensionCommand as a, EMPTY_SESSION_HINT_URL as an, handleEditorCommand as at, readJsonlFile as b, PULSE_WAVE_FRAMES as bn, resolveThemeSync as bt, hasDispose as c, SESSION_TIPS as cn, handlePlanCommand as ct, formatMemoryMemoForInjection as d, getCtrlDHint as dn, handleYoloCommand as dt, parseStreamingArgs as en, toTerminalHyperlink as et, handleMemoryCommand as f, getLlmNotSetMessage as fn, showModelPicker as ft, selectUpdateTarget as g, sortSlashCommands as gn, supportsBalance as gt, handleUpdateCommand as h, BUILTIN_SLASH_COMMANDS as hn, refreshProviderBalance as ht, buildRoleAdditionalText as i, CHARS_PER_TOKEN as in, handleCompactCommand as it, highlightLines as j, CLI_UI_MODE as jn, ENABLE_TERMINAL_THEME_REPORTING as jt, renderDiffLines as k, detectInstallSource as kn, DISABLE_TERMINAL_THEME_REPORTING as kt, isPlanExpandable as l, TIP_ROTATION_INTERVAL_MS as ln, handleThemeCommand as lt, handleMcpCommand as m, buildSkillSlashCommands as mn, showSettingsSelector as mt, clearEvalPanelState as n, stringValue as nn, getModelCycleLevel as nt, handleSkillCommand as o, EXIT_CONFIRM_WINDOW_MS as on, handleFusionPlanCommand as ot, handleChannelCommand as p, getNoActiveSessionMessage as pn, showPermissionPicker as pt, clearGoalState as q, SCREAM_ERROR_INFO as qn, handleLogoutCommand as qt, openUrl as r, truncateErrorMessage as rn, handleAutoCommand as rt, disposeChildren as s, MAIN_AGENT_ID$1 as sn, handleModelCommand as st, dispatchInput as t, serializeToolResultOutput as tn, changeThinkingLevel as tt, MoonLoader as u, getCtrlCHint as un, handleWolfpackCommand as ut, readUpdateCache as v, setExperimentalFlags as vn, showStatusReport as vt, UserMessageComponent as w, saveTuiConfig as wn, contrastTextHex as wt, handleCcCommand as x, TuiConfigParseError as xn, createEditorTheme as xt, appendJsonlLine as y, PIXEL_PULSE_FRAMES as yn, showUsage as yt, parseReadGroupOutput as z, resolveScreamHome as zn, TERMINAL_THEME_DARK as zt };
+export { handleTitleCommand as $, isTodoItemShape as $t, renderDiffLinesClustered as A, getInputHistoryFile as An, ENABLE_TERMINAL_FOCUS_REPORTING as At, BackgroundAgentStatusComponent as B, ScreamHarness as Bn, TERMINAL_THEME_LIGHT as Bt, handleRevokeCommand as C, PULSE_WAVE_FRAMES as Cn, createThemeStyles as Ct, toggleEmptySessionHint as D, saveTuiConfig as Dn, parseOsc11BackgroundTheme as Dt, isTurnElapsedEnabled as E, loadTuiConfig as En, detectTerminalTheme as Et, estimateTokens as F, CLI_USER_AGENT_PRODUCT as Fn, OSC11_RESPONSE_PREFIX_NO_ESC as Ft, getBreathingFrame as G, log as Gn, handleSearchCommand as Gt, AgentGroupComponent as H, resolveScreamHome as Hn, isStreaming as Ht, getSharedSpeedTracker as I, PRODUCT_NAME as In, QUERY_TERMINAL_THEME as It, refineGoal as J, isOrphanedToolCallError as Jn, printableChar as Jt, resetBreathingClock as K, resolveGlobalLogPath as Kn, handleConnectCommand as Kt, SkillActivationComponent as L, DEFAULT_CATALOG_URL as Ln, TERMINAL_FOCUS_IN as Lt, langFromPath as M, detectInstallSource as Mn, OSC11_QUERY as Mt, CachedContainer as N, CLI_COMMAND_NAME as Nn, OSC11_RESPONSE as Nt, ToolCallComponent as O, detectShellEnvironment as On, DISABLE_TERMINAL_FOCUS_REPORTING as Ot, ThinkingComponent as P, CLI_UI_MODE as Pn, OSC11_RESPONSE_PREFIX as Pt, handleInitCommand as Q, formatErrorMessage as Qt, ReadGroupComponent as R, fetchCatalog as Rn, TERMINAL_FOCUS_OUT as Rt, getDaemonInstructions as S, PIXEL_PULSE_FRAMES as Sn, createMarkdownTheme as St, isEmptySessionHintDismissed as T, TuiLikePreferencesSchema as Tn, getColorPalette as Tt, WelcomeComponent as U, MemoryMemoStore as Un, FooterComponent as Ut, AssistantMessageComponent as V, MCP_OAUTH_AUTHORIZATION_URL_TOOL_UPDATE as Vn, isBusy as Vt, BREATHE_CYCLE_MS as W, flushDiagnosticLogs as Wn, handleTraceCommand as Wt, handleExportMdCommand as X, SCREAM_ERROR_INFO as Xn, appendStreamingArgsPreview as Xt, handleExportDebugZipCommand as Y, ErrorCodes as Yn, STATUS_BULLET as Yt, handleForkCommand as Z, argsRecord as Zt, refreshUpdateCache as _, isExperimentalFlagEnabled as _n, clearInfoPanelState as _t, handleExtensionCommand as a, EMPTY_SESSION_HINT_URL as an, handleEditorCommand as at, readJsonlFile as b, isEmbeddingModelCached as bn, resolveThemeSync as bt, hasDispose as c, SESSION_TIPS as cn, handlePlanCommand as ct, formatMemoryMemoForInjection as d, getCtrlDHint as dn, handleYoloCommand as dt, parseStreamingArgs as en, toTerminalHyperlink as et, handleMemoryCommand as f, getLlmNotSetMessage as fn, showModelPicker as ft, selectUpdateTarget as g, sortSlashCommands as gn, supportsBalance as gt, handleUpdateCommand as h, BUILTIN_SLASH_COMMANDS as hn, refreshProviderBalance as ht, buildRoleAdditionalText as i, CHARS_PER_TOKEN as in, handleCompactCommand as it, highlightLines as j, getLogDir as jn, ENABLE_TERMINAL_THEME_REPORTING as jt, renderDiffLines as k, getDataDir as kn, DISABLE_TERMINAL_THEME_REPORTING as kt, isPlanExpandable as l, TIP_ROTATION_INTERVAL_MS as ln, handleThemeCommand as lt, handleMcpCommand as m, buildSkillSlashCommands as mn, showSettingsSelector as mt, clearEvalPanelState as n, stringValue as nn, getModelCycleLevel as nt, handleSkillCommand as o, EXIT_CONFIRM_WINDOW_MS as on, handleFusionPlanCommand as ot, handleChannelCommand as p, getNoActiveSessionMessage as pn, showPermissionPicker as pt, clearGoalState as q, isScreamError as qn, handleLogoutCommand as qt, openUrl as r, truncateErrorMessage as rn, handleAutoCommand as rt, disposeChildren as s, MAIN_AGENT_ID$1 as sn, handleModelCommand as st, dispatchInput as t, serializeToolResultOutput as tn, changeThinkingLevel as tt, MoonLoader as u, getCtrlCHint as un, handleWolfpackCommand as ut, readUpdateCache as v, setExperimentalFlags as vn, showStatusReport as vt, UserMessageComponent as w, TuiConfigParseError as wn, contrastTextHex as wt, handleCcCommand as x, startManualEmbeddingDownload as xn, createEditorTheme as xt, appendJsonlLine as y, getKnowledgeStore as yn, showUsage as yt, parseReadGroupOutput as z, saveCatalogCache as zn, TERMINAL_THEME_DARK as zt };