scream-code 0.14.6 → 0.14.8

package/dist/{dispatch-DEFMbHSe.mjs → dispatch-usl5yQnT.mjs}

@@ -6,7 +6,7 @@ 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 { 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-C7gjr4Gk.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 { 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
@@ -59083,7 +59097,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 +59210,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
@@ -64662,7 +64676,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 +64740,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 +66212,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 +66412,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 +66531,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 +66602,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 +66610,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 +66623,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 +66798,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 +66809,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 +66969,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 +67078,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 +67396,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 +67666,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 +67785,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 +67838,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 +67961,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 +68015,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 +68052,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 +68116,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,
@@ -74686,6 +75241,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\", \"what plugins do you have\"). In both cases, remove or disable additions again when the work is done unless the capability is broadly reusable.\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. 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
@@ -76615,19 +77960,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 +83001,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 +83313,7 @@ function createPermissionDecisionPolicies(agent) {
 		new YoloModeApprovePermissionPolicy(agent),
 		new WolfPackModeApprovePermissionPolicy(agent),
 		new DefaultToolApprovePermissionPolicy(),
+		new ManagePluginReadOnlyApprovePermissionPolicy(),
 		new GitCwdWriteApprovePermissionPolicy(agent),
 		new FallbackAskPermissionPolicy()
 	];
@@ -83243,6 +84633,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 +84684,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 +85054,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 +85256,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 +93129,7 @@ function parseToolCallArguments(raw) {
 		} catch {
 			return {
 				success: false,
-				error: errorMessage$4(error)
+				error: errorMessage$5(error)
 			};
 		}
 	}
@@ -91755,7 +93223,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 +93282,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 +93323,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 +93350,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 +93382,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 +93895,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 +97841,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 +98035,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 +98196,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 +98430,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 +98492,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 +98509,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 +98559,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 +98680,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))
+							const invoke = async () => {
+								const runCall = async (targetClient) => {
+									return mcpResultToExecutableOutput(await targetClient.callTool(tool.name, args ?? {}, context.signal), qualified);
 								};
 								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))
-								};
-								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}" failed after reconnect: ` + (retryError instanceof Error ? retryError.message : String(retryError))
+										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))
+									};
+									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 +98834,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 +98931,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 +98957,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 +99844,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 +99858,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 +101312,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 +101321,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 +106166,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 +106204,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 +106220,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 +106269,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 +120817,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 +120879,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 +120896,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 +120905,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 +122967,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 +123144,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 +123348,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 +123360,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 +123397,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;
@@ -127027,9 +128971,8 @@ function lerpGradient(t) {
 	const b = Math.round(b0 + (b1 - b0) * localT);
 	return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
 }
-function buildStatusLine(streamingPhase, streamingStartTime, reconnectAttempt) {
+function buildStatusLine(streamingPhase, streamingStartTime) {
 	if (streamingPhase === "idle") return t("status.idle");
-	if (reconnectAttempt > 0 && streamingPhase === "waiting") return chalk.hex("#E85454").bold("◎") + " " + chalk.hex("#E85454")(`${t("status.reconnecting")} ${String(reconnectAttempt)}`);
 	let label;
 	if (streamingPhase === "tool") label = t("status.tool");
 	else if (streamingPhase === "waiting") label = t("status.waiting");
@@ -127207,7 +129150,7 @@ var FooterComponent = class {
 		let rightText;
 		if (this.transientHint) rightText = chalk.hex(colors.warning).bold(this.transientHint);
 		else {
-			const statusLine = buildStatusLine(state.streamingPhase, state.streamingStartTime, state.reconnectAttempt);
+			const statusLine = buildStatusLine(state.streamingPhase, state.streamingStartTime);
 			const ccDot = state.ccConnectActive ? chalk.hex(colors.success)("●") : chalk.hex(colors.textDim)("●");
 			const sessionUsage = state.sessionUsage ?? {
 				inputOther: 0,
@@ -127302,7 +129245,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
@@ -129526,7 +131469,7 @@ async function guidedGoalSetup(host) {
 		host.showNotice(t("goal.storm_breaker"), t("goal.conflict_loop"));
 		return;
 	}
-	const { TextInputDialogComponent } = await import("./text-input-dialog-FGVh3qGR.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-B9uwX1Uy.mjs");
 	const initialDesc = await promptText(host, TextInputDialogComponent, {
 		title: t("goal.setup_title_initial"),
 		subtitle: t("goal.setup_desc_hint"),
@@ -129547,7 +131490,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-FGVh3qGR.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-B9uwX1Uy.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -131629,7 +133572,7 @@ var TruncatedOutputComponent = class {
 		const remaining = contentLines.length - this.maxLines;
 		const tail = this.maxLines <= 0 ? [] : contentLines.slice(-this.maxLines);
 		const expandHint = this.hintFormatter ? this.hintFormatter(remaining) : t("shell.more_lines", { count: String(remaining) });
-		return [chalk.dim(expandHint), ...tail];
+		return [...new Text(chalk.dim(expandHint), 2, 0).render(width), ...tail];
 	}
 };
 const renderTruncated = (_toolCall, result, ctx) => {