scream-code 0.12.4 → 0.12.6

package/dist/{app-DSS4PdWO.mjs → app-NZLMIJND.mjs}

@@ -7,7 +7,7 @@ import { i as __require, o as __toESM, r as __exportAll, t as __commonJSMin } fr
 import "./suppress-sqlite-warning-C2VB0doZ.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-DHhRrX3G.mjs";
+import { a as setLocale, i as getLocale, n as assertScreamHostIdentity, o as t, r as createScreamDefaultHeaders, t as TextInputDialogComponent } from "./text-input-dialog-BI6Q02oM.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fs$1 from "node:fs/promises";
@@ -54,7 +54,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { Command, Option } from "commander";
 import { createInterface } from "node:readline/promises";
 import chalk, { chalkStderr } from "chalk";
-import { CombinedAutocompleteProvider, Container, Editor, FlexSpacer, Image, Input, Key, Markdown, ProcessTerminal, Spacer, TUI, Text, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, getImageDimensions, isKeyRelease, matchesKey, setTightMode, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@liutod-scream/pi-tui";
+import { CombinedAutocompleteProvider, Container, Editor, HStack, Image, Input, Key, Markdown, ProcessTerminal, ScrollView, Spacer, Text, TuiAltScreen, VStack, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, getImageDimensions, isKeyRelease, matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@liutod-scream/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
 import { diffWords } from "diff";
 import { gt, valid } from "semver";
@@ -53309,7 +53309,8 @@ function createMemoryMemo(partial) {
 		extractionSource: partial.extractionSource,
 		recordedAt: partial.recordedAt ?? Date.now(),
 		projectDir: partial.projectDir ?? "",
-		tags: normalizedTags(partial.tags)
+		tags: normalizedTags(partial.tags),
+		note: partial.note
 	};
 }
 function normalizedTags(value) {
@@ -53329,7 +53330,8 @@ function toSummary(memo) {
 		extractionSource: memo.extractionSource,
 		recordedAt: memo.recordedAt,
 		projectDir: memo.projectDir,
-		tags: memo.tags
+		tags: memo.tags,
+		note: memo.note
 	};
 }
 //#endregion
@@ -54214,6 +54216,7 @@ function parseMemoryMemos(text) {
 			if (userNeed.length === 0) continue;
 			const rawTags = parsed["tags"];
 			const tags = Array.isArray(rawTags) ? normalizeTags(rawTags) : void 0;
+			const note = typeof parsed["note"] === "string" ? parsed["note"].trim() : void 0;
 			memos.push(createMemoryMemo({
 				userNeed,
 				approach: typeof parsed["approach"] === "string" ? parsed["approach"].trim() : "",
@@ -54221,6 +54224,7 @@ function parseMemoryMemos(text) {
 				whatFailed: typeof parsed["whatFailed"] === "string" ? parsed["whatFailed"].trim() : "none",
 				whatWorked: typeof parsed["whatWorked"] === "string" ? parsed["whatWorked"].trim() : "none",
 				tags,
+				note: note && note.length > 0 ? note : void 0,
 				extractionSource: "compaction",
 				sourceSessionId: "",
 				sourceSessionTitle: ""
@@ -54259,7 +54263,8 @@ function buildExitExtractionPrompt(sessionId, messageCount, sampleText) {
   "outcome": "<最终结果，如'完成'、'部分完成'、'失败：原因'>",
   "whatFailed": "<踩坑记录：试了但不行的路，无则填 'none'>",
   "whatWorked": "<成功经验：最终奏效的关键动作，无则填 'none'>",
-  "tags": ["<标签1>", "<标签2>", "<标签3>"]
+  "tags": ["<标签1>", "<标签2>", "<标签3>"],
+  "note": "<可选：给 AI 的补充说明/建议——让未来理解这条经验更容易，如'这类任务先查接口可用性再写代码'。无则省略>"
 }
 \`\`\`
 
@@ -54267,9 +54272,10 @@ function buildExitExtractionPrompt(sessionId, messageCount, sampleText) {
 - tags 是 3-5 个语义标签，概括任务领域/技术栈/动作类型，例如 ["react", "auth", "部署"]
 - whatFailed 记录重要的错误尝试，帮助未来避免重蹈覆辙
 - whatWorked 记录最终成功的关键动作，帮助未来复用经验
+- note 是可选字段，写一句能让未来 AI 更快理解/复用这条经验的说明或建议（软性提示，非强制规则）
 - 跳过未完成的工作，除非其中包含有价值的踩坑经验
 - 将紧密相关的子任务合并为一条记录
-- 严格遵守字段名和 JSON 格式，不要添加额外字段
+- 严格遵守字段名和 JSON 格式（除 note 外不要添加额外字段）
 
 如果没有已完成的任务闭环，输出：
 \`\`\`memory-memo
@@ -54964,7 +54970,8 @@ const MemoryWriteInputSchema = z.object({
 	outcome: z.string().min(1).describe("Final outcome, e.g. \"完成\", \"部分完成\", \"失败\"."),
 	whatFailed: z.string().optional().describe("Dead ends tried — things that did not work. Use \"none\" if nothing notable."),
 	whatWorked: z.string().optional().describe("What ultimately worked — key actions that led to success. Use \"none\" if nothing notable."),
-	tags: z.array(z.string()).optional().describe("3-5 semantic tags summarizing the task domain, tech stack, or action type (e.g. [\"react\", \"auth\", \"部署\"]).")
+	tags: z.array(z.string()).optional().describe("3-5 semantic tags summarizing the task domain, tech stack, or action type (e.g. [\"react\", \"auth\", \"部署\"])."),
+	note: z.string().optional().describe("Optional advisory note that helps future AI understand/reuse this memo faster — a soft suggestion, not a user-enforced rule.")
 });
 /**
 * Lets the model actively write a new memory memo to the global store.
@@ -54997,6 +55004,7 @@ var MemoryWriteTool = class {
 				const whatFailed = stripMemoryTags(args.whatFailed ?? "");
 				const whatWorked = stripMemoryTags(args.whatWorked ?? "");
 				const tags = normalizeTags(args.tags !== void 0 && args.tags.length > 0 ? args.tags : generateTags(`${userNeed} ${approach}`));
+				const note = args.note ? stripMemoryTags(args.note).trim() : void 0;
 				const memo = createMemoryMemo({
 					sourceSessionId: sessionId,
 					sourceSessionTitle,
@@ -55006,6 +55014,7 @@ var MemoryWriteTool = class {
 					whatFailed: whatFailed.length === 0 ? "none" : whatFailed,
 					whatWorked: whatWorked.length === 0 ? "none" : whatWorked,
 					tags,
+					note: note && note.length > 0 ? note : void 0,
 					extractionSource: "manual",
 					projectDir: this.agent.config.cwd
 				});
@@ -72330,7 +72339,7 @@ z.object({
 	numMatches: z.number().int().nonnegative().optional(),
 	appliedLimit: z.number().int().nonnegative().optional()
 });
-const DEFAULT_TIMEOUT_MS = 2e4;
+const DEFAULT_TIMEOUT_MS$1 = 2e4;
 const SIGTERM_GRACE_MS$1 = 5e3;
 const MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 const RG_MAX_COLUMNS = 500;
@@ -72443,7 +72452,7 @@ var GrepTool = class {
 		if (bufferTruncated || timedOut) stdoutText = omitIncompleteTrailingRecord(stdoutText, mode);
 		if (timedOut && stdoutText.trim() === "") return {
 			isError: true,
-			output: `Grep timed out after ${String(DEFAULT_TIMEOUT_MS / 1e3)}s. Try a more specific path or pattern.`
+			output: `Grep timed out after ${String(DEFAULT_TIMEOUT_MS$1 / 1e3)}s. Try a more specific path or pattern.`
 		};
 		if (signal.aborted) return {
 			isError: true,
@@ -72483,7 +72492,7 @@ var GrepTool = class {
 			else messages.push(paginationNotice);
 		}
 		if (bufferTruncated) messages.push(`[stdout truncated at ${String(MAX_OUTPUT_BYTES)} bytes; incomplete trailing line omitted]`);
-		if (timedOut) messages.push(`Grep timed out after ${String(DEFAULT_TIMEOUT_MS / 1e3)}s; partial results returned`);
+		if (timedOut) messages.push(`Grep timed out after ${String(DEFAULT_TIMEOUT_MS$1 / 1e3)}s; partial results returned`);
 		const contentIncludesLineNumbers = mode === "content" && args["-n"] !== false;
 		const contentBody = limited.map((line) => formatDisplayLine(line, mode, this.workspace.workspaceDir, pathClass, contentIncludesLineNumbers)).join("\n");
 		const visibleBody = orderedLines.length === 0 && filteredSensitive.size > 0 ? "No non-sensitive matches found" : contentBody;
@@ -72600,7 +72609,7 @@ async function runRipgrepOnce(jian, rgArgs, signal) {
 	const timeoutHandle = setTimeout(() => {
 		timedOut = true;
 		killProc();
-	}, DEFAULT_TIMEOUT_MS);
+	}, DEFAULT_TIMEOUT_MS$1);
 	let exitCode = 0;
 	let stdoutText = "";
 	let stderrText = "";
@@ -74711,6 +74720,466 @@ function truncateUtf8$1(input, maxBytes) {
 	return `${input.slice(0, low)}${suffix}`;
 }
 //#endregion
+//#region ../../packages/agent-core/src/tools/builtin/python/python.ts
+const PY_DONE_MARKER = "__SCREAM_PY_DONE__";
+const DEFAULT_TIMEOUT_MS = 6e4;
+const MAX_TIMEOUT_MS = 5 * 6e4;
+const KERNEL_START_TIMEOUT_MS = 3e4;
+const PythonInputSchema = z.object({
+	code: z.string().min(1).describe("Python code to execute in the persistent kernel. Variables, imports, and loaded data persist across calls, unlike Bash. State is kept for the whole session while the /rlm mode is enabled."),
+	timeout: z.number().int().positive().max(MAX_TIMEOUT_MS / 1e3).optional().describe("Execution timeout in seconds (default 60, max 300).")
+});
+const RLM_BOOTSTRAP_PY = `import json, os, sys, tempfile, time, itertools, pickle
+_RLM_ID = itertools.count(1)
+_SNAP = __SNAP_PATH__
+
+def _host_request(method, payload, timeout=120):
+    rid = next(_RLM_ID)
+    sys.stdout.write(json.dumps({"type": "host_request", "id": rid, "method": method, "payload": payload}) + "\\n")
+    sys.stdout.flush()
+    reply_file = os.path.join(tempfile.gettempdir(), "scream-rlm-" + str(os.getpid()) + "-" + str(rid) + ".json")
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        if os.path.exists(reply_file):
+            try:
+                with open(reply_file, "r", encoding="utf-8") as f:
+                    reply = json.load(f)
+                os.remove(reply_file)
+            except Exception:
+                time.sleep(0.1)
+                continue
+            if "error" in reply:
+                raise RuntimeError(reply["error"])
+            return reply.get("result")
+        time.sleep(0.1)
+    raise RuntimeError("host bridge timeout")
+
+def rlm(task, name="subagent", **meta):
+    payload = {"task": task, "name": name}
+    payload.update(meta)
+    return _host_request("rlm.run", payload)
+
+def rlm_wait(handle, timeout=120):
+    return _host_request("rlm.result", {"id": handle, "timeout": timeout}, timeout=timeout)
+
+def _snapshot(path=_SNAP):
+    saved = {}
+    for k, v in list(globals().items()):
+        if k.startswith("_") or callable(v) or isinstance(v, type(sys)):
+            continue
+        try:
+            pickle.dumps(v)
+            saved[k] = v
+        except Exception:
+            pass
+    try:
+        with open(path, "wb") as f:
+            pickle.dump(saved, f)
+        return len(saved)
+    except Exception:
+        return 0
+
+def _restore(path=_SNAP):
+    if not os.path.exists(path):
+        return 0
+    try:
+        with open(path, "rb") as f:
+            saved = pickle.load(f)
+    except Exception:
+        return 0
+    for k, v in saved.items():
+        globals()[k] = v
+    return len(saved)
+
+_restore()
+`;
+/** Builds the single-line bootstrap exec for this tool instance, embedding
+* the snapshot path so each PythonTool has its own persistent state file. */
+function buildRlmBootstrap(snapshotPath) {
+	const py = RLM_BOOTSTRAP_PY.replace("__SNAP_PATH__", JSON.stringify(snapshotPath));
+	return `exec(__import__('base64').b64decode('${Buffer.from(py).toString("base64")}').decode())\nprint("__SCREAM_BOOT_DONE__")`;
+}
+/**
+* Executes Python code in a persistent interactive kernel (`python3 -u -i`
+* over a pipe). The kernel process is lazily started on first use and lives
+* for the lifetime of this tool instance (the /rlm session), so variables,
+* imports, and loaded data survive across calls — unlike the stateless Bash
+* tool. Runs under the normal permission mode like any other tool; the code
+* can read/write files, so it is gated exactly like a mutating tool.
+*/
+var PythonTool = class PythonTool {
+	cwd;
+	options;
+	name = "python";
+	description;
+	parameters = toInputJsonSchema(PythonInputSchema);
+	kernel;
+	kernelBusy = false;
+	/** Accumulated stderr from the kernel (tracebacks land here). */
+	kernelStderr = "";
+	/** Bytes of kernelStderr consumed by the last execution (race-safe drain). */
+	kernelStderrOffset = 0;
+	/** Per-instance snapshot file so RLM state survives kernel restarts. */
+	snapshotPath;
+	hostHandlers;
+	constructor(cwd, options = {}) {
+		this.cwd = cwd;
+		this.options = options;
+		this.hostHandlers = options.hostHandlers;
+		this.snapshotPath = options.snapshotPath ?? join(tmpdir(), `scream-rlm-state-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.pkl`);
+		this.description = "Execute Python code in a persistent kernel. Variables, imports, and loaded data persist across calls (unlike Bash) — ideal for data analysis and multi-step processing. Run shell commands with the Bash tool instead. In RLM mode the kernel also provides `rlm(task, name=\"subagent\")` to spawn a subagent (returns a handle immediately) and `rlm_wait(handle, timeout)` to await its final summary. Multi-line code (def/for/if) is fully supported. Code runs under the current permission mode; mutating operations follow the same approval rules as other tools.";
+	}
+	dispose() {
+		if (this.hostHandlers !== void 0) this.hostHandlers["__dispose__"]?.({}).catch(() => {});
+		this.kernel?.kill("SIGKILL");
+		this.kernel = void 0;
+		this.kernelBusy = false;
+		this.kernelStderr = "";
+		this.kernelStderrOffset = 0;
+		unlink(this.snapshotPath).catch(() => {});
+	}
+	/** Lazily starts the persistent kernel. The banner and REPL prompts are
+	* emitted on stderr (not stdout), so we drain stderr continuously and drop
+	* the startup banner; stdout only carries print() output. */
+	async ensureKernel() {
+		if (this.kernel !== void 0 && this.kernel.exitCode === null) return this.kernel;
+		this.kernelBusy = false;
+		this.kernelStderr = "";
+		this.kernelStderrOffset = 0;
+		const proc = await this.spawnKernel();
+		this.kernel = proc;
+		let spawnError;
+		proc.on("error", (error) => {
+			spawnError = error;
+		});
+		proc.stdin?.on("error", () => {});
+		proc.stdout?.on("error", () => {});
+		proc.stderr?.on("error", () => {});
+		this.drainStderr(proc);
+		if (this.hostHandlers !== void 0) {
+			proc.stdin.write(`${buildRlmBootstrap(this.snapshotPath)}\n`);
+			if (!(await this.readUntilMarker(proc.stdout, "__SCREAM_BOOT_DONE__", KERNEL_START_TIMEOUT_MS)).found) {
+				proc.kill("SIGKILL");
+				this.kernel = void 0;
+				throw new Error(`Python kernel failed to start: ${spawnError?.message ?? "bootstrap did not complete"}`);
+			}
+		}
+		return proc;
+	}
+	/** Candidate python commands, platform-first order. Exposed for tests:
+	* POSIX prefers `python3`, Windows prefers `python`. Both fall back to the
+	* other on ENOENT so a machine with either interpreter works. */
+	static pythonCandidates(platform = process.platform) {
+		return platform === "win32" ? ["python", "python3"] : ["python3", "python"];
+	}
+	/**
+	* Spawns the kernel, resolving the python command per platform.
+	*
+	* The command name differs across platforms: POSIX ships `python3`; Windows
+	* commonly exposes only `python` (python3 may or may not exist as an alias).
+	* We prefer the platform-default name first and fall back to the other on
+	* ENOENT, so a Windows install with either `python` or `python3` works.
+	*/
+	async spawnKernel() {
+		const candidates = PythonTool.pythonCandidates();
+		let lastError;
+		for (const command of candidates) try {
+			return await this.trySpawn(command);
+		} catch (error) {
+			lastError = error;
+			if (error.code !== "ENOENT") throw error;
+		}
+		throw lastError ?? /* @__PURE__ */ new Error(`No python interpreter found (tried: ${candidates.join(", ")})`);
+	}
+	trySpawn(command) {
+		return new Promise((resolve, reject) => {
+			const proc = spawn(command, ["-u", "-i"], {
+				cwd: this.cwd,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			proc.once("error", (error) => {
+				reject(error);
+			});
+			proc.once("spawn", () => {
+				proc.off("error", reject);
+				resolve(proc);
+			});
+		});
+	}
+	drainStderr(proc) {
+		const decoder = new StringDecoder("utf8");
+		proc.stderr?.on("data", (chunk) => {
+			this.kernelStderr += decoder.write(chunk);
+		});
+	}
+	/**
+	* Reads stdout until `marker` appears (or the deadline passes). Uses the
+	* 'data' event instead of an async iterator: a `for await` that returns
+	* early destroys the stream, which breaks the next call on the same
+	* persistent kernel. `'data'` keeps the stream alive across calls.
+	*/
+	async readUntilMarker(stream, marker, timeoutMs) {
+		if (stream === null) return {
+			lines: [],
+			found: false
+		};
+		return new Promise((resolve) => {
+			const lines = [];
+			let buffer = "";
+			const decoder = new StringDecoder("utf8");
+			const cleanup = () => {
+				clearTimeout(timer);
+				stream.off("data", onData);
+				stream.off("end", onEnd);
+				stream.off("close", onEnd);
+				stream.off("error", onEnd);
+			};
+			const finish = (found) => {
+				cleanup();
+				resolve({
+					lines,
+					found
+				});
+			};
+			const onEnd = () => finish(false);
+			const onData = (chunk) => {
+				buffer += decoder.write(chunk);
+				const parts = buffer.split("\n");
+				buffer = parts.pop() ?? "";
+				for (const line of parts) {
+					if (line.includes(marker)) return finish(true);
+					if (line.includes("\"host_request\"")) {
+						this.handleHostRequest(line, stream).catch(() => {});
+						continue;
+					}
+					lines.push(line);
+				}
+				if (buffer.includes(marker)) {
+					lines.push(buffer);
+					buffer = "";
+					return finish(true);
+				}
+			};
+			const timer = setTimeout(() => finish(false), timeoutMs);
+			stream.on("data", onData);
+			stream.on("end", onEnd);
+			stream.on("close", onEnd);
+			stream.on("error", onEnd);
+		});
+	}
+	/**
+	* Handles a kernel `host_request` line: invokes the registered handler and
+	* writes the reply to the kernel's expected reply file (the kernel polls
+	* that file — replies must not go over stdin, which is used for code input
+	* and would race with the REPL). Fire-and-forget from the read loop.
+	*/
+	/** Writes a bridge reply to the kernel's expected reply file. Uses the
+	* pid captured when the request was received: if the kernel is restarted
+	* (timeout kill) while a bridge handler is still running, the late reply
+	* must still land in the file the originating kernel is polling. */
+	writeHostReply(pid, id, body) {
+		if (pid === void 0) return;
+		writeFile(join(tmpdir(), `scream-rlm-${pid}-${id}.json`), JSON.stringify({
+			type: "host_reply",
+			id,
+			...body
+		}), "utf8").catch(() => {});
+	}
+	async handleHostRequest(line, stream) {
+		const replyPid = this.kernel?.pid;
+		if (replyPid === void 0) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			return;
+		}
+		const { id, method, payload } = parsed;
+		if (typeof id !== "number" || typeof method !== "string" || payload === void 0) return;
+		const handler = this.hostHandlers?.[method];
+		if (handler === void 0) {
+			this.writeHostReply(replyPid, id, { error: `no handler for ${method}` });
+			return;
+		}
+		try {
+			const result = await handler(payload);
+			this.writeHostReply(replyPid, id, { result });
+		} catch (error) {
+			this.writeHostReply(replyPid, id, { error: error instanceof Error ? error.message : String(error) });
+		}
+	}
+	resolveExecution(args) {
+		return {
+			description: `Python: ${args.code.length > 50 ? `${args.code.slice(0, 50)}…` : args.code}`,
+			display: {
+				kind: "command",
+				command: args.code,
+				cwd: this.cwd
+			},
+			approvalRule: this.name,
+			execute: (ctx) => this.execution(args, ctx)
+		};
+	}
+	async execution(args, _ctx) {
+		if (this.kernelBusy) return { output: "The Python kernel is busy executing a previous call. Wait for it to finish, or stop it with TaskStop." };
+		this.kernelBusy = true;
+		try {
+			const proc = await this.ensureKernel();
+			const timeoutMs = (args.timeout ?? DEFAULT_TIMEOUT_MS / 1e3) * 1e3;
+			const wrapperPy = `import ast as _ast, base64 as _b
+__c = _b.b64decode('${Buffer.from(args.code, "utf8").toString("base64")}').decode()\ntry:
+    try:
+        __r = eval(__c, globals())
+        if __r is not None:
+            print(repr(__r))
+    except SyntaxError:
+        __tree = _ast.parse(__c)
+        __tail = __tree.body[-1] if __tree.body else None
+        if isinstance(__tail, _ast.Expr) and not any(
+            isinstance(n, (_ast.ClassDef, _ast.FunctionDef, _ast.AsyncFunctionDef))
+            for n in _ast.walk(__tail)):
+            __lines = __c.split("\\n")
+            __head = "\\n".join(__lines[: __tail.lineno - 1] + [__lines[__tail.lineno - 1][: __tail.col_offset]])
+            if __head.strip():
+                exec(__head, globals())
+            __r = eval(_ast.unparse(__tail.value), globals())
+            if __r is not None:
+                print(repr(__r))
+        else:
+            exec(__c, globals())
+except BaseException as __e:
+    # Show the user’s own source lines (the raw REPL traceback
+    # only exposes the base64 wrapper line, which is useless for
+    # debugging), then re-raise so the kernel prints the real stack
+    # and the tool flags the call as an error.
+    print("Traceback (most recent call last):")
+    for __i, __ln in enumerate(__c.split("\\n"), 1):
+        print(f"  File \\"<user_code>\\", line {__i}")
+        print(f"    {__ln}")
+    print(f"{type(__e).__name__}: {__e}")
+    raise`;
+			const wrapperB64 = Buffer.from(wrapperPy, "utf8").toString("base64");
+			const codeWithDone = this.hostHandlers !== void 0 ? `exec(__import__('base64').b64decode('${wrapperB64}').decode(), globals())\nprint('${PY_DONE_MARKER}')\n_snapshot()\n` : `exec(__import__('base64').b64decode('${wrapperB64}').decode(), globals())\nprint('${PY_DONE_MARKER}')\n`;
+			if (!proc.stdin.write(codeWithDone)) await new Promise((resolve) => {
+				const onError = () => resolve();
+				proc.stdin.once("close", onError);
+				proc.stdin.once("error", onError);
+				proc.stdin.once("drain", () => {
+					proc.stdin.off("close", onError);
+					proc.stdin.off("error", onError);
+					resolve();
+				});
+			});
+			const { lines, found } = await this.readUntilMarker(proc.stdout, PY_DONE_MARKER, timeoutMs);
+			const output = lines.filter((line) => !line.includes(PY_DONE_MARKER) && !line.trimStart().startsWith(">>> ") && !line.trimStart().startsWith("... ")).join("\n").trim();
+			await this.drainStderrQuiet(proc);
+			const stderr = this.kernelStderr.slice(this.kernelStderrOffset).split("\n").filter((line) => !line.trimStart().startsWith(">>> ") && !line.trimStart().startsWith("... ") && !line.trimStart().startsWith("Python ") && !line.trimStart().startsWith("Type \"help\"")).join("\n").trim();
+			this.kernelStderrOffset = this.kernelStderr.length;
+			const merged = [output, stderr].filter((part) => part.length > 0).join("\n");
+			if (!found) {
+				const preInterruptOffset = this.kernelStderrOffset;
+				if (process.platform === "win32" ? true : await this.interruptKernel(proc, 1500)) {
+					proc.kill("SIGKILL");
+					this.kernel = void 0;
+					return {
+						isError: true,
+						output: `Python execution timed out after ${Math.round(timeoutMs / 1e3)}s (kernel restarted).\n${merged}`
+					};
+				}
+				if (!await this.syncKernel(proc)) {
+					proc.kill("SIGKILL");
+					this.kernel = void 0;
+					return {
+						isError: true,
+						output: `Python execution timed out after ${Math.round(timeoutMs / 1e3)}s (kernel restarted).\n${merged}`
+					};
+				}
+				await this.drainStderrQuiet(proc);
+				const interruptStderr = this.kernelStderr.slice(preInterruptOffset).split("\n").filter((line) => !line.trimStart().startsWith(">>> ") && !line.trimStart().startsWith("... ") && !line.trimStart().startsWith("Python ") && !line.trimStart().startsWith("Type \"help\"")).join("\n").trim();
+				this.kernelStderrOffset = this.kernelStderr.length;
+				const timedOutMerged = [merged, interruptStderr].filter((part) => part.length > 0).join("\n");
+				return {
+					isError: true,
+					output: `Python execution timed out after ${Math.round(timeoutMs / 1e3)}s (kernel interrupted; state preserved).\n${timedOutMerged}`
+				};
+			}
+			return {
+				isError: merged.includes("Traceback") || merged.toLowerCase().includes("error:"),
+				output: merged.length > 0 ? merged : "(no output)"
+			};
+		} finally {
+			this.kernelBusy = false;
+		}
+	}
+	/**
+	* Sends SIGINT to the kernel and waits (up to `graceMs`) for it to exit.
+	* Returns true when the process exited — meaning the kernel is gone and a
+	* fresh one must be started; false when it is still alive after the signal,
+	* which for `python3 -i` means the REPL interrupted the running statement
+	* and is ready again with state intact.
+	*
+	* `proc.killed` is NOT used as an exit check: it flips true the first time
+	* `kill()` is called, so on a second timeout it would falsely report the
+	* process as exited. Only `exitCode`/`signalCode` reflect a real exit.
+	*/
+	interruptKernel(proc, graceMs) {
+		if (proc.exitCode !== null || proc.signalCode !== null) return Promise.resolve(true);
+		return new Promise((resolve) => {
+			const exited = () => resolve(true);
+			const onExit = () => {
+				clearTimeout(timer);
+				exited();
+			};
+			const timer = setTimeout(() => {
+				proc.off("exit", onExit);
+				resolve(false);
+			}, graceMs);
+			proc.once("exit", onExit);
+			proc.kill("SIGINT");
+		});
+	}
+	/**
+	* Round-trips a sync marker through the (interrupted) kernel: writes
+	* `print('__SCREAM_SYNC__')` and waits for it to appear on stdout. Any
+	* residual queued output (a DONE marker written before the timeout, a
+	* partially-flushed traceback) is consumed by the same read loop, so the
+	* next execution starts from a clean marker state. Returns true when the
+	* marker came back — the REPL is idle and reusable.
+	*/
+	async syncKernel(proc, timeoutMs = 3e3) {
+		const SYNC_MARKER = "__SCREAM_SYNC__";
+		if (!proc.stdin.write(`print('${SYNC_MARKER}')\n`)) await new Promise((resolve) => {
+			const onError = () => resolve();
+			proc.stdin.once("close", onError);
+			proc.stdin.once("error", onError);
+			proc.stdin.once("drain", () => {
+				proc.stdin.off("close", onError);
+				proc.stdin.off("error", onError);
+				resolve();
+			});
+		});
+		const { found } = await this.readUntilMarker(proc.stdout, SYNC_MARKER, timeoutMs);
+		return found;
+	}
+	/** Waits (bounded) for stderr to go quiet so tracebacks settle before the
+	* execution snapshot is committed. */
+	async drainStderrQuiet(proc, quietMs = 40, capMs = 400) {
+		const start = Date.now();
+		let quietSince = Date.now();
+		while (Date.now() - start < capMs) {
+			const before = this.kernelStderr.length;
+			await new Promise((resolve) => setTimeout(resolve, 10));
+			if (this.kernelStderr.length === before) {
+				if (Date.now() - quietSince >= quietMs) return;
+			} else quietSince = Date.now();
+		}
+	}
+};
+//#endregion
 //#region ../../packages/agent-core/src/tools/builtin/shell/bash.md
 var bash_default = "Execute a `{{ SHELL_NAME }}` command. Use this for shell semantics — pipes, env, processes, git, package managers, build/test runners, anything genuinely interactive or multi-step.\n\n**Translate these to a dedicated tool instead:**\n- `cat` / `head` / `tail` (known path) → `Read`\n- `sed` / `awk` (in-place edit) → `Edit`\n- `echo > file` / `cat <<EOF` → `Write`\n- `find` / recursive `ls` to locate files by name pattern → `Glob` (plain `ls <known-directory>` is fine for listing a directory)\n- `grep` / `rg` (search file contents) → `Grep`\n- `echo` / `printf` (talk to the user) → just output text directly\n\nThe dedicated tools render in the per-tool permission UI and keep raw stdout out of the conversation; that is why they are worth reaching for whenever one fits.\n\n**Output:**\nThe stdout and stderr will be combined and returned as a string. The output may be truncated if it is too long. If the command failed, the output will end with a `Command failed with exit code: N` line stating the non-zero exit code.\n\nIf `run_in_background=true`, the command will be started as a background task and this tool will return a task ID instead of waiting for command completion. When doing that, you must provide a short `description`. Background commands default to a {{ DEFAULT_BACKGROUND_TIMEOUT_S }}s timeout and `timeout` is capped at {{ MAX_BACKGROUND_TIMEOUT_S }}s; set `disable_timeout=true` only when the task should run without a timeout. You will be automatically notified when the task completes. Use `TaskOutput` for a non-blocking status/output snapshot, and only set `block=true` when you explicitly want to wait for completion. Use `TaskStop` only if the task must be cancelled. If a human user wants to inspect background tasks themselves, point them to the `/tasks` command, which opens an interactive panel; it has no subcommands.\n\n**Guidelines for safety and security:**\n- Each shell tool call will be executed in a fresh shell environment. The shell variables, current working directory changes, and the shell history is not preserved between calls.\n- The tool call will return after the command is finished. You shall not use this tool to execute an interactive command or a command that may run forever. For possibly long-running foreground commands, set the `timeout` argument in seconds. Foreground commands default to {{ DEFAULT_TIMEOUT_S }}s and allow up to {{ MAX_TIMEOUT_S }}s.\n- Avoid using `..` to access files or directories outside of the working directory.\n- Avoid modifying files outside of the working directory unless explicitly instructed to do so.\n- Never run commands that require superuser privileges unless explicitly instructed to do so.\n\n**Guidelines for efficiency:**\n- For multiple related commands, use `&&` to chain them in a single call, e.g. `cd /path && ls -la`\n- Use `;` to run commands sequentially regardless of success/failure\n- Use `||` for conditional execution (run second command only if first fails)\n- Use pipe operations (`|`) and redirections (`>`, `>>`) to chain input and output between commands\n- Always quote file paths containing spaces with double quotes (e.g., cd \"/path with spaces/\")\n- Compose multi-step logic in a single call with `if` / `case` / `for` / `while` control flows.\n- Prefer `run_in_background=true` for long-running builds, tests, watchers, or servers when you need the conversation to continue before the command finishes.\n\n**Commands available:**\nThe following common command categories are usually available. Availability still depends on the host, so when in doubt run `which <command>` first to confirm a command exists before relying on it.\n- Navigation and inspection: `ls`, `pwd`, `cd`, `stat`, `file`, `du`, `df`, `tree`\n- File and directory management: `cp`, `mv`, `rm`, `mkdir`, `touch`, `ln`, `chmod`, `chown`\n- Text and data processing: `wc`, `sort`, `uniq`, `cut`, `tr`, `diff`, `xargs`\n- Archives and compression: `tar`, `gzip`, `gunzip`, `zip`, `unzip`\n- Networking and transfer: `curl`, `wget`, `ping`, `ssh`, `scp`\n- Version control: `git`\n- Process and system: `ps`, `kill`, `top`, `env`, `date`, `uname`, `whoami`\n- Language and package toolchains: `node`, `npm`, `pnpm`, `yarn`, `python`, `pip` (use whichever the project actually relies on)\n";
 //#endregion
@@ -75926,7 +76395,7 @@ function stripContextMetadata(message) {
 }
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/compaction-instruction.md
-var compaction_instruction_default = "\n--- This message is a direct task, not part of the above conversation ---\n\nYou are now given a task to compact this conversation context according to specific priorities and output requirements.\n\nOutput text only. DO NOT CALL ANY TOOLS. Calling tools will be rejected and fails the task. You already have all the information you need in the conversation history. You have only one chance.\n\nThe goal of compaction is to keep essential code patterns, technical details, and architectural decisions for continuing development without losing context after the above messages are cleared work.\n\n{{ customInstruction }}\n\n<!-- Memory Memo Extraction (PRIORITY — do not skip) -->\n\n## 任务经验提取\n\nAFTER completing the compaction summary below, scan the messages being compacted for **completed task loops**. A task loop is \"completed\" when:\n- The user made a clear request or asked a specific question\n- You provided a solution or answer\n- The outcome is clear (success, partial success, or failure)\n\nFor each completed task loop found, output a structured experience record **at the very end of your response**:\n\n```memory-memo\n{\n  \"userNeed\": \"<the user's need or goal, one sentence>\",\n  \"approach\": \"<what was done — the approach taken, 2-4 sentences>\",\n  \"outcome\": \"<final result, e.g. '完成', '部分完成', '失败: reason'>\",\n  \"whatFailed\": \"<dead ends tried — things that didn't work, or 'none'>\",\n  \"whatWorked\": \"<key actions that ultimately worked, or 'none'>\",\n  \"tags\": [\"<tag1>\", \"<tag2>\", \"<tag3>\"]\n}\n```\n\nGuidelines:\n- Record important failed attempts in \"whatFailed\" to help avoid repeating mistakes.\n- Record key successful actions in \"whatWorked\" to help reuse effective approaches.\n- Include 3-5 semantic \"tags\" summarizing the task domain, tech stack, or action type (e.g. [\"react\", \"auth\", \"部署\"]).\n- Skip in-progress work unless it contains a valuable error+fix experience.\n- Merge closely related sub-tasks into a single record.\n- Use the exact field names and JSON format shown above.\n\nIf no completed task loops are found in the compacted messages, output:\n```memory-memo\n{\"none\": true}\n```\n\n<!-- Compression Priorities (in order) -->\n\n1. **Current Task State**: What is being worked on RIGHT NOW\n2. **Errors & Solutions**: All encountered errors and their resolutions\n3. **Code Evolution**: Final working versions only (remove intermediate attempts)\n4. **System Context**: Project structure, dependencies, environment setup\n5. **Design Decisions**: Architectural choices and their rationale\n6. **TODO Items**: Unfinished tasks and known issues\n\n<!-- Required Output Structure -->\n\n## Current Focus\n\n[What we're working on now]\n\n## Environment\n\n- [Key setup/config points]\n- ...\n\n## Completed Tasks\n\n- [Task]: [Brief outcome]\n- ...\n\n## Active Issues\n\n- [Issue]: [Status/Next steps]\n- ...\n\n## Code State\n\n### [Critical file name]\n\n[Brief description of the file's purpose and current state]\n\n```\n[The latest version of critical code snippets in this file, <20 lines]\n```\n\n### [Critical file name]\n\n- [Useful classes/methods/functions]: [Brief description/usage]\n- ...\n\n<!-- Omit non-critical code, intermediate attempts, and resolved errors -->\n\n## Important Context\n\n- [Any crucial information not covered above]\n- ...\n\n## All User Messages\n\n- [Detailed non tool use user message]\n- ...\n";
+var compaction_instruction_default = "\n--- This message is a direct task, not part of the above conversation ---\n\nYou are now given a task to compact this conversation context according to specific priorities and output requirements.\n\nOutput text only. DO NOT CALL ANY TOOLS. Calling tools will be rejected and fails the task. You already have all the information you need in the conversation history. You have only one chance.\n\nThe goal of compaction is to keep essential code patterns, technical details, and architectural decisions for continuing development without losing context after the above messages are cleared work.\n\n{{ customInstruction }}\n\n<!-- Memory Memo Extraction (PRIORITY — do not skip) -->\n\n## 任务经验提取\n\nAFTER completing the compaction summary below, scan the messages being compacted for **completed task loops**. A task loop is \"completed\" when:\n- The user made a clear request or asked a specific question\n- You provided a solution or answer\n- The outcome is clear (success, partial success, or failure)\n\nFor each completed task loop found, output a structured experience record **at the very end of your response**:\n\n```memory-memo\n{\n  \"userNeed\": \"<the user's need or goal, one sentence>\",\n  \"approach\": \"<what was done — the approach taken, 2-4 sentences>\",\n  \"outcome\": \"<final result, e.g. '完成', '部分完成', '失败: reason'>\",\n  \"whatFailed\": \"<dead ends tried — things that didn't work, or 'none'>\",\n  \"whatWorked\": \"<key actions that ultimately worked, or 'none'>\",\n  \"tags\": [\"<tag1>\", \"<tag2>\", \"<tag3>\"],\n  \"note\": \"<optional: a soft, AI-readable note/suggestion that makes the record easier for future turns to understand — e.g. '这类任务先查接口可用性再写代码'. Omit if none>\"\n}\n```\n\nGuidelines:\n- Record important failed attempts in \"whatFailed\" to help avoid repeating mistakes.\n- Record key successful actions in \"whatWorked\" to help reuse effective approaches.\n- Include 3-5 semantic \"tags\" summarizing the task domain, tech stack, or action type (e.g. [\"react\", \"auth\", \"部署\"]).\n- \"note\" is optional: a one-sentence advisory note that helps future AI understand/reuse the record faster. It is a soft suggestion, not a user-enforced rule.\n- Skip in-progress work unless it contains a valuable error+fix experience.\n- Merge closely related sub-tasks into a single record.\n- Use the exact field names and JSON format shown above (no extra fields beyond \"note\").\n\nIf no completed task loops are found in the compacted messages, output:\n```memory-memo\n{\"none\": true}\n```\n\n<!-- Compression Priorities (in order) -->\n\n1. **Current Task State**: What is being worked on RIGHT NOW\n2. **Errors & Solutions**: All encountered errors and their resolutions\n3. **Code Evolution**: Final working versions only (remove intermediate attempts)\n4. **System Context**: Project structure, dependencies, environment setup\n5. **Design Decisions**: Architectural choices and their rationale\n6. **TODO Items**: Unfinished tasks and known issues\n\n<!-- Required Output Structure -->\n\n## Current Focus\n\n[What we're working on now]\n\n## Environment\n\n- [Key setup/config points]\n- ...\n\n## Completed Tasks\n\n- [Task]: [Brief outcome]\n- ...\n\n## Active Issues\n\n- [Issue]: [Status/Next steps]\n- ...\n\n## Code State\n\n### [Critical file name]\n\n[Brief description of the file's purpose and current state]\n\n```\n[The latest version of critical code snippets in this file, <20 lines]\n```\n\n### [Critical file name]\n\n- [Useful classes/methods/functions]: [Brief description/usage]\n- ...\n\n<!-- Omit non-critical code, intermediate attempts, and resolved errors -->\n\n## Important Context\n\n- [Any crucial information not covered above]\n- ...\n\n## All User Messages\n\n- [Detailed non tool use user message]\n- ...\n\n## Skill candidates\n\nScan the compressed messages for reusable processes (project-specific build\nsteps, recurring debugging patterns, or tool workflows). If any is genuinely\nworth capturing as a reusable skill, output at the very end, at most one:\n\n[[skill-candidate: <name>|<one-line purpose>|<evidence>]]\n\nOmit if none.\n";
 //#endregion
 //#region ../../packages/agent-core/src/agent/compaction/compaction-update-instruction.md
 var compaction_update_instruction_default = "\n--- This message is a direct task, not part of the above conversation ---\n\nYou are now given a task to UPDATE an existing compaction summary with new messages that came in after the last compaction.\n\nA previous compaction summary already exists at the top of the conversation (the first assistant message). You must NOT discard it. Instead, merge the new information into the existing structure, keeping all previously captured state intact unless explicitly contradicted or resolved by the new messages.\n\nOutput text only. DO NOT CALL ANY TOOLS. Calling tools will be rejected and fails the task. You have only one chance.\n\n{{ customInstruction }}\n\n<!-- Previous Summary Reference -->\n\nThe first assistant message above is the PREVIOUS summary. Treat it as the source of truth for everything that happened before the new messages. Do not restate it verbatim — produce an updated, merged summary.\n\n<!-- Memory Memo Extraction (PRIORITY — do not skip) -->\n\n## 任务经验提取\n\nAFTER completing the updated summary below, scan ONLY the new messages being compacted (not those already covered by the previous summary) for **completed task loops**. A task loop is \"completed\" when:\n- The user made a clear request or asked a specific question\n- You provided a solution or answer\n- The outcome is clear (success, partial success, or failure)\n\nFor each completed task loop found, output a structured experience record **at the very end of your response**:\n\n```memory-memo\n{\n  \"userNeed\": \"<the user's need or goal, one sentence>\",\n  \"approach\": \"<what was done — the approach taken, 2-4 sentences>\",\n  \"outcome\": \"<final result, e.g. '完成', '部分完成', '失败: reason'>\",\n  \"whatFailed\": \"<dead ends tried — things that didn't work, or 'none'>\",\n  \"whatWorked\": \"<key actions that ultimately worked, or 'none'>\",\n  \"tags\": [\"<tag1>\", \"<tag2>\", \"<tag3>\"]\n}\n```\n\nGuidelines:\n- Record important failed attempts in \"whatFailed\" to help avoid repeating mistakes.\n- Record key successful actions in \"whatWorked\" to help reuse effective approaches.\n- Include 3-5 semantic \"tags\" summarizing the task domain, tech stack, or action type.\n- Skip in-progress work unless it contains a valuable error+fix experience.\n- Merge closely related sub-tasks into a single record.\n- Use the exact field names and JSON format shown above.\n\nIf no completed task loops are found in the new compacted messages, output:\n```memory-memo\n{\"none\": true}\n```\n\n<!-- Update Rules -->\n\n1. Preserve the section structure of the previous summary (Current Focus, Environment, Completed Tasks, Active Issues, Code State, Important Context, All User Messages).\n2. Move newly-completed tasks from \"Current Focus\" / \"Active Issues\" into \"Completed Tasks\".\n3. Update \"Current Focus\" to reflect what is being worked on RIGHT NOW.\n4. Append new user messages to \"All User Messages\" — do not repeat those already captured.\n5. Refresh \"Code State\" code snippets only if newer versions exist in the new messages.\n6. Drop resolved issues from \"Active Issues\"; add newly-discovered ones.\n7. Do not invent new information. If the new messages say nothing about a section, carry the previous content forward unchanged.\n\n<!-- Required Output Structure -->\n\n## Current Focus\n\n[What we're working on now]\n\n## Environment\n\n- [Key setup/config points]\n- ...\n\n## Completed Tasks\n\n- [Task]: [Brief outcome]\n- ...\n\n## Active Issues\n\n- [Issue]: [Status/Next steps]\n- ...\n\n## Code State\n\n### [Critical file name]\n\n[Brief description of the file's purpose and current state]\n\n```\n[The latest version of critical code snippets in this file, <20 lines]\n```\n\n## Important Context\n\n- [Any crucial information not covered above]\n- ...\n\n## All User Messages\n\n- [Detailed non tool use user message]\n- ...\n";
@@ -76551,6 +77020,7 @@ var FullCompaction = class {
 			this.lowWaterMark = Math.floor(this.effectiveTokenCount * 1.1);
 			await this.extractAndStoreMemos(processedSummary);
 			this.triggerPostCompactHook(data, result);
+			this.detectSkillCandidates(processedSummary);
 			this.consecutiveCompactionFailures = 0;
 			this._shouldInjectSessionSummary = true;
 		} catch (error) {
@@ -76641,6 +77111,33 @@ var FullCompaction = class {
 		});
 	}
 	/**
+	* Detects [[skill-candidate: <name>|<purpose>|<evidence>]] markers in the
+	* compaction summary and emits a `skill_candidate` event for each one (at
+	* most one per compact). Best-effort and fully isolated: a parse failure or
+	* a missing marker never affects compaction or memory extraction — this
+	* method only reads the summary and emits an event.
+	*/
+	detectSkillCandidates(summary) {
+		try {
+			const matches = summary.matchAll(/\[\[skill-candidate:\s*([^|\]]+)\|([^|\]]+)\|([^|\]]+)\]\]/g);
+			for (const m of matches) {
+				const name = m[1].trim();
+				if (name.length === 0) continue;
+				this.agent.emitEvent({
+					type: "skill_candidate",
+					candidate: {
+						name,
+						purpose: m[2].trim(),
+						evidence: m[3].trim()
+					}
+				});
+				break;
+			}
+		} catch (error) {
+			this.agent.log.warn("Skill candidate detection failed", { error: String(error) });
+		}
+	}
+	/**
 	* Append the current todo list and file operations as markdown sections to
 	* the compaction summary so active tasks and file context survive
 	* compression. Without this, both are lost after compaction because the
@@ -82111,6 +82608,12 @@ function restoreAgentRecord(agent, input) {
 		case "wolfpack.exit":
 			agent.wolfpackMode.exit();
 			return;
+		case "rlm.enter":
+			agent.restoreRlm(true);
+			return;
+		case "rlm.exit":
+			agent.restoreRlm(false);
+			return;
 		case "goal.create":
 			agent.goal.restoreCreate(input);
 			return;
@@ -95160,6 +95663,70 @@ function createGoalGrader(agent) {
 		};
 	};
 }
+/**
+* Host bridge handlers for the /rlm python kernel: `rlm.run` spawns a
+* subagent (reusing the subagent host) and returns its handle id;
+* `rlm.result` waits for that subagent's final summary. Handles are kept in
+* a closure map for the lifetime of the ToolManager (one per session).
+*
+* Recursion guard: a subagent may only spawn its own rlm() children if its
+* depth is below the cap. Depth is carried on each agent instance (root = 0,
+* every spawned subagent = parent + 1). The cap is per-agent
+* (setRlmMaxDepth / /rlm-max-depth); it is `Infinity` by default — unlimited
+* recursion — and a positive integer when the user opts into a limit.
+*/
+function createRlmHostHandlers(agent) {
+	const handles = /* @__PURE__ */ new Map();
+	return {
+		"rlm.run": async (payload) => {
+			const host = agent.subagentHost;
+			if (host === void 0) throw new Error("subagent host unavailable");
+			if (agent.getRlmDepth() >= agent.getRlmMaxDepth()) throw new Error(`RLM recursion depth limit reached (depth ${agent.getRlmDepth()}, max ${agent.getRlmMaxDepth()}). Nested rlm() subagents are not allowed.`);
+			const task = String(payload["task"] ?? "");
+			const name = String(payload["name"] ?? "subagent").slice(0, 64);
+			const controller = new AbortController();
+			const handle = await host.spawn("coder", {
+				parentToolCallId: `rlm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+				prompt: task,
+				description: `rlm subagent: ${name}`,
+				runInBackground: false,
+				signal: controller.signal
+			});
+			const entry = {
+				completion: handle.completion,
+				name,
+				controller
+			};
+			handles.set(handle.agentId, entry);
+			handle.completion.then((result) => {
+				entry.result = result;
+			}, () => {
+				entry.result = void 0;
+			});
+			return {
+				id: handle.agentId,
+				name
+			};
+		},
+		"rlm.result": async (payload) => {
+			const id = String(payload["id"]);
+			const entry = handles.get(id);
+			if (entry === void 0) throw new Error(`unknown rlm handle: ${id}`);
+			if (entry.result !== void 0) {
+				handles.delete(id);
+				return { result: entry.result };
+			}
+			const result = (await entry.completion).result;
+			handles.delete(id);
+			return { result };
+		},
+		__dispose__: async () => {
+			for (const { controller } of handles.values()) controller.abort(/* @__PURE__ */ new Error("rlm kernel disposed"));
+			handles.clear();
+			return {};
+		}
+	};
+}
 var ToolManager = class {
 	agent;
 	builtinTools = /* @__PURE__ */ new Map();
@@ -95417,6 +95984,12 @@ var ToolManager = class {
 			} })
 		});
 	}
+	getActiveTools() {
+		return [...this.enabledTools];
+	}
+	getBuiltinTool(name) {
+		return this.builtinTools.get(name);
+	}
 	setActiveTools(names) {
 		this.agent.records.logRecord({
 			type: "tools.set_active_tools",
@@ -95477,6 +96050,7 @@ var ToolManager = class {
 				allowBackground,
 				availableTools: this.enabledTools
 			}),
+			new PythonTool(cwd, { hostHandlers: createRlmHostHandlers(this.agent) }),
 			(modelCapabilities.image_in || modelCapabilities.video_in) && new ReadMediaFileTool(jian, workspace, modelCapabilities, videoUploader),
 			new EnterPlanModeTool(this.agent),
 			new ExitPlanModeTool(this.agent),
@@ -97095,6 +97669,96 @@ var Agent = class {
 			}
 		})();
 	}
+	rlmEnabled = false;
+	/** RLM recursion depth: 0 for the root agent, +1 per spawned subagent. */
+	rlmDepth = 0;
+	/** Maximum allowed RLM recursion depth. `Infinity` (the default) means
+	* unlimited recursion. Set to a positive integer via /rlm-max-depth to
+	* cap the chain (e.g. 1 = root may spawn children, children may not spawn
+	* grandchildren); 0 is treated as unlimited as well. */
+	rlmMaxDepth = Infinity;
+	getRlmDepth() {
+		return this.rlmDepth;
+	}
+	setRlmDepth(depth) {
+		this.rlmDepth = Math.max(0, depth);
+	}
+	getRlmMaxDepth() {
+		return this.rlmMaxDepth;
+	}
+	setRlmMaxDepth(maxDepth) {
+		if (!Number.isFinite(maxDepth) || maxDepth <= 0) {
+			this.rlmMaxDepth = Infinity;
+			return;
+		}
+		this.rlmMaxDepth = Math.trunc(maxDepth);
+	}
+	/** Disposes the persistent python kernel (if any) and resets RLM mode.
+	* Called on session close so no orphaned kernel process is left behind.
+	* Only touches state when RLM was actually enabled — a session that never
+	* used /rlm must not emit a spurious setActiveTools record (which would
+	* pollute the wire log and, on a subagent that does not re-apply a profile
+	* on resume, could strip MCP access patterns). */
+	disposeRlm() {
+		if (!this.rlmEnabled) return;
+		this.rlmEnabled = false;
+		const withoutPython = this.tools.getActiveTools().filter((name) => name !== "python");
+		this.tools.setActiveTools(withoutPython);
+		this.tools.getBuiltinTool("python")?.dispose?.();
+		this.records.logRecord({ type: "rlm.exit" });
+	}
+	/**
+	* Enables or disables the /rlm persistent-python mode. On enable, the
+	* `python` tool is added to the active tools; on disable it is removed and
+	* its kernel is disposed. Default state (disabled) leaves the tool list and
+	* default behaviour untouched.
+	*/
+	setRlmEnabled(enabled) {
+		this.rlmEnabled = enabled;
+		const current = this.tools.getActiveTools();
+		if (enabled) {
+			if (!current.includes("python")) this.tools.setActiveTools([...current, "python"]);
+		} else {
+			const withoutPython = current.filter((name) => name !== "python");
+			if (withoutPython.length !== current.length) this.tools.setActiveTools(withoutPython);
+			this.tools.getBuiltinTool("python")?.dispose?.();
+		}
+		this.records.logRecord({ type: enabled ? "rlm.enter" : "rlm.exit" });
+		this.emitStatusUpdated();
+	}
+	/** Returns whether RLM (persistent python mode) is currently enabled. */
+	getRlmEnabled() {
+		return this.rlmEnabled;
+	}
+	/**
+	* Lets a subagent inherit RLM mode from its parent at spawn time: mounts
+	* the python tool (so the child can keep recursing) and records rlm.enter,
+	* mirroring setRlmEnabled(true). The rlm.enter record keeps enter/exit
+	* symmetric: the child's disposeRlm (triggered by session close) emits
+	* rlm.exit, so a subagent's records must contain the matching enter or the
+	* pair is unbalanced. A status event is NOT emitted here — the child's own
+	* turn is about to start and the parent's record already represents this
+	* recursion chain. Non-RLM parents never call this.
+	*/
+	inheritRlm() {
+		this.rlmEnabled = true;
+		const current = this.tools.getActiveTools();
+		if (!current.includes("python")) this.tools.setActiveTools([...current, "python"]);
+		this.records.logRecord({ type: "rlm.enter" });
+	}
+	/** Restores RLM mode from a persisted record during replay. Does not log
+	* a new record and does not emit a status update (both are suppressed while
+	* records are restoring). */
+	restoreRlm(enabled) {
+		this.rlmEnabled = enabled;
+		const current = this.tools.getActiveTools();
+		if (enabled) {
+			if (!current.includes("python")) this.tools.setActiveTools([...current, "python"]);
+		} else {
+			const withoutPython = current.filter((name) => name !== "python");
+			if (withoutPython.length !== current.length) this.tools.setActiveTools(withoutPython);
+		}
+	}
 	initKnowledgeStore(store) {
 		if (store === void 0) return Promise.resolve();
 		return (async () => {
@@ -97262,6 +97926,12 @@ var Agent = class {
 			setActiveTools: (payload) => {
 				this.tools.setActiveTools(payload.names);
 			},
+			setRlmEnabled: (payload) => {
+				this.setRlmEnabled(payload.enabled);
+			},
+			setRlmMaxDepth: (payload) => {
+				this.setRlmMaxDepth(payload.maxDepth);
+			},
 			stopBackground: (payload) => {
 				this.background.stop(payload.taskId, payload.reason);
 			},
@@ -97335,6 +98005,9 @@ var Agent = class {
 			},
 			getWolfpackMode: () => {
 				return this.wolfpackMode.isActive;
+			},
+			getRlmEnabled: () => {
+				return this.rlmEnabled;
 			}
 		};
 	}
@@ -97459,6 +98132,7 @@ var Agent = class {
 			planMode: this.planMode.isActive,
 			planStrategy: this.planMode.isActive ? this.planMode.strategy : void 0,
 			wolfpackMode: this.wolfpackMode.isActive,
+			rlmEnabled: this.rlmEnabled,
 			permission: this.permission.mode,
 			usage
 		});
@@ -101779,6 +102453,8 @@ var SessionSubagentHost = class {
 			type: "sub",
 			generate: parent.rawGenerate
 		}, void 0, this.ownerAgentId);
+		agent.setRlmDepth(parent.getRlmDepth() + 1);
+		agent.setRlmMaxDepth(parent.getRlmMaxDepth());
 		const controller = new AbortController();
 		const unlinkAbortSignal = linkAbortSignal(options.signal, controller);
 		this.activeChildren.set(id, {
@@ -101946,6 +102622,7 @@ var SessionSubagentHost = class {
 		});
 		const context = await prepareSystemPromptContext(child.jian);
 		child.useProfile(profile, context);
+		if (parent.getRlmEnabled()) child.inheritRlm();
 	}
 	resolveModelBinding(profileName) {
 		const bindings = this.modelBindings?.();
@@ -102127,6 +102804,7 @@ var Session$1 = class {
 		try {
 			for (const agent of this.agents.values()) if (agent.turn.hasActiveTurn) agent.turn.cancel();
 			await Promise.allSettled(Array.from(this.agents.values(), async (agent) => agent.cron?.stop()));
+			for (const agent of this.agents.values()) agent.disposeRlm?.();
 			await this.stopBackgroundTasksOnExit();
 			await this.flushMetadata();
 			await this.triggerSessionEnd("exit");
@@ -117314,6 +117992,12 @@ var SessionAPIImpl = class {
 	setActiveTools({ agentId, ...payload }) {
 		return this.getAgent(agentId).setActiveTools(payload);
 	}
+	setRlmEnabled({ agentId, ...payload }) {
+		return this.getAgent(agentId).setRlmEnabled(payload);
+	}
+	setRlmMaxDepth({ agentId, ...payload }) {
+		return this.getAgent(agentId).setRlmMaxDepth(payload);
+	}
 	stopBackground({ agentId, ...payload }) {
 		return this.getAgent(agentId).stopBackground(payload);
 	}
@@ -117387,6 +118071,9 @@ var SessionAPIImpl = class {
 	getWolfpackMode({ agentId }) {
 		return this.getAgent(agentId).getWolfpackMode({});
 	}
+	getRlmEnabled({ agentId }) {
+		return this.getAgent(agentId).getRlmEnabled({});
+	}
 	getAgent(agentId) {
 		const agent = this.session.agents.get(agentId);
 		if (agent === void 0) throw new ScreamError(ErrorCodes.AGENT_NOT_FOUND, `Agent "${agentId}" was not found`);
@@ -119063,6 +119750,12 @@ var ScreamCore = class {
 	setActiveTools({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).setActiveTools(payload);
 	}
+	setRlmEnabled({ sessionId, ...payload }) {
+		return this.sessionApi(sessionId).setRlmEnabled(payload);
+	}
+	setRlmMaxDepth({ sessionId, ...payload }) {
+		return this.sessionApi(sessionId).setRlmMaxDepth(payload);
+	}
 	stopBackground({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).stopBackground(payload);
 	}
@@ -119135,6 +119828,9 @@ var ScreamCore = class {
 	getWolfpackMode({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).getWolfpackMode(payload);
 	}
+	getRlmEnabled({ sessionId, ...payload }) {
+		return this.sessionApi(sessionId).getRlmEnabled(payload);
+	}
 	updateSessionMetadata({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).updateSessionMetadata(payload);
 	}
@@ -119773,7 +120469,7 @@ var SDKRpcClient = class {
 	async getStatus(input) {
 		const rpc = await this.getRpc();
 		const agentId = this.interactiveAgentId;
-		const [config, context, permission, plan, usage, wolfpackMode] = await Promise.all([
+		const [config, context, permission, plan, usage, wolfpackMode, rlmEnabled] = await Promise.all([
 			rpc.getConfig({
 				sessionId: input.sessionId,
 				agentId
@@ -119797,6 +120493,10 @@ var SDKRpcClient = class {
 			rpc.getWolfpackMode({
 				sessionId: input.sessionId,
 				agentId
+			}),
+			rpc.getRlmEnabled({
+				sessionId: input.sessionId,
+				agentId
 			})
 		]);
 		const maxContextTokens = config.modelCapabilities?.max_context_tokens ?? 0;
@@ -119810,6 +120510,7 @@ var SDKRpcClient = class {
 			planMode: plan !== null,
 			planStrategy: plan?.strategy,
 			wolfpackMode,
+			rlmEnabled,
 			contextTokens,
 			maxContextTokens,
 			contextUsage,
@@ -119854,6 +120555,20 @@ var SDKRpcClient = class {
 			taskId: input.taskId
 		});
 	}
+	async setRlmEnabled(input) {
+		return (await this.getRpc()).setRlmEnabled({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId,
+			enabled: input.enabled
+		});
+	}
+	async setRlmMaxDepth(input) {
+		return (await this.getRpc()).setRlmMaxDepth({
+			sessionId: input.sessionId,
+			agentId: this.interactiveAgentId,
+			maxDepth: input.maxDepth
+		});
+	}
 	async stopBackgroundTask(input) {
 		return (await this.getRpc()).stopBackground({
 			sessionId: input.sessionId,
@@ -120279,6 +120994,27 @@ var Session = class {
 	* for unknown or already-terminal task ids are no-ops at the core
 	* level — this method does not throw in those cases.
 	*/
+	/**
+	* Enables or disables the /rlm persistent-python mode. When enabled, the
+	* `python` tool (persistent kernel) is added to the active tools; when
+	* disabled it is removed and its kernel is disposed. Default is disabled.
+	*/
+	async setRlmEnabled(enabled) {
+		this.ensureOpen();
+		await this.rpc.setRlmEnabled({
+			sessionId: this.id,
+			enabled
+		});
+	}
+	/** Sets the maximum RLM recursion depth (default 1). Depth 1 means the root
+	* kernel may spawn rlm() children but they cannot spawn grandchildren. */
+	async setRlmMaxDepth(maxDepth) {
+		this.ensureOpen();
+		await this.rpc.setRlmMaxDepth({
+			sessionId: this.id,
+			maxDepth
+		});
+	}
 	async stopBackgroundTask(taskId, options = {}) {
 		this.ensureOpen();
 		const trimmedTaskId = normalizeRequiredString(taskId, "Task id cannot be empty", ErrorCodes.BACKGROUND_TASK_ID_EMPTY);
@@ -120898,7 +121634,7 @@ function optionalBuildString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 const SCREAM_BUILD_INFO = {
-	version: optionalBuildString("0.12.4"),
+	version: optionalBuildString("0.12.6"),
 	channel: optionalBuildString(""),
 	commit: optionalBuildString(""),
 	buildTarget: optionalBuildString("darwin-arm64")
@@ -121899,28 +122635,43 @@ const BUILTIN_SLASH_COMMANDS = [
 		name: "ask",
 		aliases: ["ask"],
 		description: "registry.ask_desc",
-		priority: 122,
+		priority: 123,
+		availability: "always"
+	},
+	{
+		name: "rlm",
+		aliases: ["rlm"],
+		description: "registry.rlm_desc",
+		priority: 121,
+		availability: "always"
+	},
+	{
+		name: "rlm-max-depth",
+		aliases: [],
+		description: "registry.rlm_max_depth_desc",
+		argumentHint: "[N]",
+		priority: 119,
 		availability: "always"
 	},
 	{
 		name: "wolfpack",
 		aliases: ["wp"],
 		description: "registry.wolfpack_desc",
-		priority: 123,
+		priority: 122,
 		availability: "always"
 	},
 	{
 		name: "sessions",
 		aliases: ["resume"],
 		description: "registry.sessions_desc",
-		priority: 122
+		priority: 119
 	},
 	{
 		name: "goal",
 		aliases: ["goaloff"],
 		description: "registry.goal_desc",
 		argumentHint: "[objective]",
-		priority: 122,
+		priority: 120,
 		availability: (args) => {
 			const trimmed = args.trim();
 			return trimmed === "" || trimmed === "status" || trimmed === "pause" || trimmed === "off" ? "always" : "idle-only";
@@ -123242,7 +123993,7 @@ async function handleConnectCommand(host, args) {
 						ok: false,
 						label: "Failed to load catalog."
 					});
-					host.showError(`Failed to fetch catalog: ${formatErrorMessage(error)}`);
+					host.showError(t("auth.catalog_fetch_failed", { error: formatErrorMessage(error) }));
 				}
 			}
 		}
@@ -124391,6 +125142,7 @@ var FooterComponent = class {
 			left.push(chalk.hex(isFusion ? colors.fusionPlanMode : colors.planMode).bold(isFusion ? t("badge.fusion") : t("badge.plan")));
 		}
 		if (state.wolfpackMode) left.push(chalk.hex(colors.wolfpackMode).bold(t("badge.wolfpack")));
+		if (state.rlmEnabled) left.push(chalk.hex(colors.rlmMode).bold(t("badge.rlm")));
 		if (state.goalActive && state.goal) {
 			const goalLabel = formatGoalBadge(state.goal);
 			left.push(chalk.hex(colors.primary).bold(goalLabel));
@@ -124679,6 +125431,7 @@ const darkColors = {
 	planMode: dark.cyan400,
 	fusionPlanMode: dark.amber500,
 	wolfpackMode: "#C084FC",
+	rlmMode: "#FFD700",
 	text: dark.gray100,
 	textStrong: dark.gray50,
 	textDim: dark.gray500,
@@ -124710,6 +125463,7 @@ const lightColors = {
 	planMode: light.cyan800,
 	fusionPlanMode: light.amber700,
 	wolfpackMode: "#7C3AED",
+	rlmMode: "#A16207",
 	text: light.gray900,
 	textStrong: light.gray900,
 	textDim: light.gray700,
@@ -125509,6 +126263,61 @@ async function handleAskCommand(host, args) {
 		host.setAppState({ permissionMode: "ask" });
 	}
 }
+async function handleRlmCommand(host, args) {
+	const session = host.session;
+	if (session === void 0) {
+		host.showError(getNoActiveSessionMessage());
+		return;
+	}
+	const subcmd = args.trim().toLowerCase();
+	let enabled;
+	if (subcmd.length === 0) enabled = !host.state.appState.rlmEnabled;
+	else if (subcmd === "on") enabled = true;
+	else if (subcmd === "off") enabled = false;
+	else {
+		host.showError(`Unknown rlm subcommand: ${subcmd}`);
+		return;
+	}
+	try {
+		await session.setRlmEnabled(enabled);
+		host.setAppState({ rlmEnabled: enabled });
+		if (enabled) {
+			host.showNotice(t("config.rlm_on"));
+			return;
+		}
+		host.showNotice(t("config.rlm_off"));
+	} catch (error) {
+		const msg = formatErrorMessage(error);
+		host.showError(`Failed to set rlm mode: ${msg}`);
+	}
+}
+/** /rlm-max-depth [N] — query or set the maximum RLM recursion depth.
+* N=0 or no limit means unlimited (the default). */
+async function handleRlmMaxDepthCommand(host, args) {
+	const session = host.session;
+	if (session === void 0) {
+		host.showError(getNoActiveSessionMessage());
+		return;
+	}
+	const arg = args.trim();
+	if (arg.length === 0) {
+		host.showStatus("RLM max depth: run /rlm-max-depth <N> (0 or blank = unlimited) to set it.");
+		return;
+	}
+	const parsed = Number(arg);
+	if (!Number.isInteger(parsed) || parsed < 0) {
+		host.showError(`Invalid rlm-max-depth: ${arg} (expected a non-negative integer, 0 = unlimited).`);
+		return;
+	}
+	try {
+		await session.setRlmMaxDepth(parsed);
+		if (parsed === 0) host.showStatus("RLM recursion depth set to unlimited.", host.state.theme.colors.success);
+		else host.showStatus(`RLM max depth set to ${parsed}.`, host.state.theme.colors.success);
+	} catch (error) {
+		const msg = formatErrorMessage(error);
+		host.showError(`Failed to set rlm max depth: ${msg}`);
+	}
+}
 async function handleAutoCommand(host, args) {
 	const session = host.session;
 	if (session === void 0) {
@@ -126639,7 +127448,7 @@ async function guidedGoalSetup(host) {
 		host.showNotice(t("goal.storm_breaker"), t("goal.conflict_loop"));
 		return;
 	}
-	const { TextInputDialogComponent } = await import("./text-input-dialog-K1S_ir1m.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-BViNsv5f.mjs");
 	const initialDesc = await promptText(host, TextInputDialogComponent, {
 		title: t("goal.setup_title_initial"),
 		subtitle: t("goal.setup_desc_hint"),
@@ -126660,7 +127469,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-K1S_ir1m.mjs");
+	const { TextInputDialogComponent } = await import("./text-input-dialog-BViNsv5f.mjs");
 	const turnInput = await promptNumber(host, TextInputDialogComponent, {
 		title: t("goal.wizard_title", { objective }),
 		subtitle: t("goal.budget_turns_hint"),
@@ -127472,7 +128281,7 @@ var AssistantMessageComponent = class {
 			const age = Date.now() - (this.fadeStartMs ?? 0);
 			this.cachedWidth = void 0;
 			this.cachedLines = void 0;
-			this.ui?.requestComponentRender(this);
+			this.ui?.requestRender();
 			if (age >= 1200) this.stopFade();
 		}, FADE_TICK_MS);
 		this.ui.requestRender();
@@ -127966,7 +128775,7 @@ var ThinkingComponent = class {
 		if (this.ui === void 0 || this.spinnerInterval !== void 0) return;
 		this.spinnerInterval = setInterval(() => {
 			this.spinnerFrame = (this.spinnerFrame + 1) % BRAILLE_SPINNER_FRAMES.length;
-			this.ui?.requestComponentRender(this);
+			this.ui?.requestRender();
 		}, 80);
 	}
 	stopSpinner() {
@@ -132408,7 +133217,7 @@ var MoonLoader = class extends Text {
 		const frame = BRAILLE_SPINNER_FRAMES[this.currentFrame];
 		const coloredFrame = this.colorFn ? this.colorFn(frame) : frame;
 		this.setText(this.label ? `${coloredFrame} ${this.label}` : coloredFrame);
-		this.ui.requestComponentRender(this);
+		this.ui.requestRender();
 	}
 };
 //#endregion
@@ -132544,9 +133353,6 @@ function getFallbackSkillMarketplace() {
 }
 //#endregion
 //#region src/tui/utils/component-capabilities.ts
-function isExpandable(obj) {
-	return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
-}
 function isPlanExpandable(obj) {
 	return typeof obj === "object" && obj !== null && "setPlanExpanded" in obj && typeof obj.setPlanExpanded === "function";
 }
@@ -135345,6 +136151,12 @@ async function handleBuiltInSlashCommand(host, name, args) {
 		case "ask":
 			await handleAskCommand(host, args);
 			return;
+		case "rlm":
+			await handleRlmCommand(host, args);
+			return;
+		case "rlm-max-depth":
+			await handleRlmMaxDepthCommand(host, args);
+			return;
 		case "auto":
 			await handleAutoCommand(host, args);
 			return;
@@ -135420,6 +136232,17 @@ var AuthFlowController = class {
 			availableModels: config.models ?? {},
 			availableProviders: config.providers ?? {}
 		});
+		this.prefetchCatalogCache();
+	}
+	/**
+	* Best-effort background catalog refresh. Fetches the remote catalog and,
+	* on success, updates the on-disk cache. On failure it stays silent: the
+	* existing cache (or built-in) keeps working. Never throws.
+	*/
+	async prefetchCatalogCache() {
+		try {
+			saveCatalogCache(await fetchCatalog(DEFAULT_CATALOG_URL), resolveScreamHome());
+		} catch {}
 	}
 	async activateModelAfterLogin(model, thinkingLevel) {
 		const { host } = this;
@@ -136885,6 +137708,9 @@ var SessionEventHandler = class {
 			case "compaction.cancelled":
 				this.handleCompactionCancel(event, sendQueued);
 				break;
+			case "skill_candidate":
+				this.handleSkillCandidate(event);
+				break;
 			case "subagent.spawned":
 				this.handleSubagentSpawned(event);
 				break;
@@ -137219,6 +138045,7 @@ var SessionEventHandler = class {
 		if (event.maxContextTokens !== void 0) patch.maxContextTokens = event.maxContextTokens;
 		if (event.planMode !== void 0) patch.planMode = event.planMode ? event.planStrategy === "fusion" ? "fusionplan" : "plan" : "off";
 		if (event.wolfpackMode !== void 0) patch.wolfpackMode = event.wolfpackMode;
+		if (event.rlmEnabled !== void 0) patch.rlmEnabled = event.rlmEnabled;
 		if (event.permission !== void 0) patch.permissionMode = event.permission;
 		if (Object.keys(patch).length > 0) this.host.setAppState(patch);
 	}
@@ -137391,6 +138218,28 @@ var SessionEventHandler = class {
 		this.lastCompactionTrigger = void 0;
 		this.finishCompaction(sendQueued);
 	}
+	/** Candidates already prompted this session, to avoid repeating the request. */
+	promptedSkillCandidates = /* @__PURE__ */ new Set();
+	/**
+	* Handles a `skill_candidate` event emitted after compaction detected a
+	* reusable process in the summary. Best-effort and non-fatal: if the session
+	* is unavailable or the prompt fails, nothing happens — the user simply sees
+	* no confirmation. When it works, the model runs an AskUserQuestion dialog
+	* (确定/忽略) so the user can confirm or dismiss with a single keystroke,
+	* then generates the skill via MakeSkillPlanTool on confirmation.
+	*/
+	handleSkillCandidate(event) {
+		try {
+			const { name, purpose } = event.candidate;
+			if (name.length === 0) return;
+			if (this.promptedSkillCandidates.has(name)) return;
+			this.promptedSkillCandidates.add(name);
+			const session = this.host.session;
+			if (session === void 0) return;
+			const request = `检测到可复用过程「${name}」${purpose ? `（${purpose}）` : ""}。请用 AskUserQuestion 工具询问用户是否将其保存为可复用技能（选项：生成 / 忽略）。用户选择「生成」后，用 MakeSkillPlanTool 生成该技能；选择「忽略」则直接说明已跳过。`;
+			session.prompt(request).catch(() => {});
+		} catch {}
+	}
 	finishCompaction(sendQueued) {
 		if (!this.host.streamingUI.hasActiveTurn()) {
 			this.host.setAppState({
@@ -139749,9 +140598,8 @@ var TasksBrowserController = class {
 			colors: state.theme.colors,
 			...this.buildCallbacks()
 		}, state.terminal);
-		const savedChildren = [...state.ui.children];
-		state.ui.clear();
-		state.ui.addChild(component);
+		const savedLayoutRoot = state.layoutRoot;
+		state.ui.setLayoutRoot(component);
 		state.ui.setFocus(component);
 		state.ui.requestRender(true);
 		const pollTimer = setInterval(() => {
@@ -139759,7 +140607,7 @@ var TasksBrowserController = class {
 		}, 1e3);
 		this.host.setTasksBrowser({
 			component,
-			savedChildren,
+			savedLayoutRoot,
 			filter,
 			selectedTaskId,
 			tailOutput: void 0,
@@ -139779,8 +140627,7 @@ var TasksBrowserController = class {
 		if (browser.viewer !== void 0) this.closeOutputViewer();
 		if (browser.pollTimer !== void 0) clearInterval(browser.pollTimer);
 		if (browser.flashTimer !== void 0) clearTimeout(browser.flashTimer);
-		state.ui.clear();
-		for (const child of browser.savedChildren) state.ui.addChild(child);
+		state.ui.setLayoutRoot(browser.savedLayoutRoot);
 		this.host.setTasksBrowser(void 0);
 		state.ui.setFocus(state.editor);
 		state.ui.requestRender(true);
@@ -139950,9 +140797,8 @@ var TasksBrowserController = class {
 				this.closeOutputViewer();
 			}
 		}, state.terminal);
-		const savedBrowserChildren = [...state.ui.children];
-		state.ui.clear();
-		state.ui.addChild(viewer);
+		const savedBrowserLayout = state.layoutRoot;
+		state.ui.setLayoutRoot(viewer);
 		state.ui.setFocus(viewer);
 		state.ui.requestRender(true);
 		const pollTimer = setInterval(() => {
@@ -139960,7 +140806,7 @@ var TasksBrowserController = class {
 		}, 1e3);
 		browser.viewer = {
 			component: viewer,
-			savedChildren: savedBrowserChildren,
+			savedLayoutRoot: savedBrowserLayout,
 			taskId,
 			output,
 			refreshId: 0,
@@ -140016,8 +140862,7 @@ var TasksBrowserController = class {
 		const viewer = browser.viewer;
 		clearInterval(viewer.pollTimer);
 		browser.viewer = void 0;
-		this.host.state.ui.clear();
-		for (const child of viewer.savedChildren) this.host.state.ui.addChild(child);
+		this.host.state.ui.setLayoutRoot(viewer.savedLayoutRoot);
 		this.host.state.ui.setFocus(browser.component);
 		this.host.state.ui.requestRender(true);
 	}
@@ -140453,13 +141298,6 @@ var TranscriptController = class TranscriptController {
 	toggleToolOutputExpansion() {
 		const { state } = this.host;
 		state.toolOutputExpanded = !state.toolOutputExpanded;
-		const walk = (children) => {
-			for (const child of children) {
-				if (isExpandable(child)) child.setExpanded(state.toolOutputExpanded);
-				if ("children" in child && Array.isArray(child.children)) walk(child.children);
-			}
-		};
-		walk(state.transcriptContainer.children);
 		state.ui.requestRender();
 	}
 	togglePlanExpansion() {
@@ -140508,6 +141346,44 @@ var GutterContainer = class extends Container {
 	}
 };
 //#endregion
+//#region src/tui/components/panes/status-bar-pane.ts
+/**
+* A fixed one-line status bar shown directly above the input editor: it
+* displays the current work phase (idle / waiting / thinking / composing /
+* tool) with its spinner, pinned to the bottom of the terminal via the dock
+* VStack. Designed to hold more status widgets later — add children to the
+* container when needed.
+*/
+var StatusBarPaneComponent = class extends Container {
+	constructor(options) {
+		super();
+		this.update(options);
+	}
+	/** Re-renders the bar for a new mode/label. The spinner/pulse are the
+	* caller's shared instances (kept alive across mode changes), so this only
+	* swaps which children are visible. */
+	update(options) {
+		this.clear();
+		if (options.mode === "idle") return;
+		if (options.mode === "waiting" || options.mode === "tool" || options.mode === "composing" || options.mode === "thinking") {
+			if (options.pulseWave !== void 0) {
+				if (options.label.length > 0) {
+					const row = new HStack();
+					row.addChild(options.pulseWave);
+					row.addChild(new Text(` ${options.label}`, 1, 0));
+					this.addChild(row);
+				} else this.addChild(options.pulseWave);
+				return;
+			}
+			if (options.spinner !== void 0) {
+				this.addChild(options.spinner);
+				return;
+			}
+			if (options.label.length > 0) this.addChild(new Text(options.label, 1, 0));
+		}
+	}
+};
+//#endregion
 //#region src/tui/theme/bundle.ts
 function createScreamTUIThemeBundle(theme, resolvedTheme) {
 	const actualTheme = resolvedTheme ?? resolveThemeSync(theme);
@@ -140799,36 +141675,11 @@ var PulseWaveLoader = class extends Text {
 	}
 };
 //#endregion
-//#region src/tui/components/panes/activity-pane.ts
-var ActivityPaneComponent = class extends Container {
-	constructor(options) {
-		super();
-		if (options.mode === "waiting" || options.mode === "tool") {
-			if (options.spinner !== void 0) {
-				this.addChild(new Spacer(1));
-				this.addChild(options.spinner);
-			}
-			if (options.pulseWave !== void 0) {
-				this.addChild(new Spacer(1));
-				this.addChild(options.pulseWave);
-			}
-			return;
-		}
-		if (options.mode === "composing" && options.spinner !== void 0) {
-			this.addChild(new Spacer(1));
-			this.addChild(options.spinner);
-			if (options.pulseWave !== void 0) {
-				this.addChild(new Spacer(1));
-				this.addChild(options.pulseWave);
-			}
-		}
-	}
-};
-//#endregion
 //#region src/tui/controllers/lifecycle-controller.ts
 var LifecycleController = class LifecycleController {
 	host;
 	signalCleanupHandlers = [];
+	footerWrap;
 	ccConnectPollTimer;
 	memoryIdleTimer;
 	memoryCountdownTimer;
@@ -140836,6 +141687,9 @@ var LifecycleController = class LifecycleController {
 	terminalFocusTrackingDispose;
 	terminalThemeTrackingDispose;
 	lastActivityMode;
+	/** The active status-bar loader (PulseWaveLoader or MoonLoader). Owned by
+	* this controller; stopped before replacement to avoid leaking timers. */
+	statusBarLoader;
 	static MEMORY_IDLE_MS = 900 * 1e3;
 	static MEMORY_COUNTDOWN_MS = 15 * 1e3;
 	static MEMORY_EXTRACT_COOLDOWN_MS = 600 * 1e3;
@@ -140975,19 +141829,72 @@ var LifecycleController = class LifecycleController {
 	buildLayout() {
 		const { ui } = this.host.state;
 		ui.clear();
-		ui.addChild(this.host.state.transcriptContainer);
-		ui.addChild(this.host.state.activityContainer);
-		ui.addChild(this.host.state.todoPanelContainer);
-		ui.addChild(this.host.state.queueContainer);
-		ui.addChild(this.host.state.errorBannerContainer);
-		ui.addChild(this.host.state.planModeBannerContainer);
-		ui.addChild(new FlexSpacer());
-		ui.addChild(this.host.state.editorContainer);
+		const scrollContent = new Container();
+		scrollContent.addChild(this.host.state.transcriptContainer);
+		scrollContent.addChild(this.host.state.activityContainer);
+		scrollContent.addChild(this.host.state.queueContainer);
+		const transcriptScrollView = new ScrollView(scrollContent, {
+			follow: "end",
+			primary: true,
+			scrollbar: "auto"
+		});
+		const dock = new VStack([
+			{
+				component: this.host.state.todoPanelContainer,
+				shrink: 1,
+				minSize: 0,
+				visible: (viewport) => viewport.width >= 90
+			},
+			{
+				component: this.host.state.errorBannerContainer,
+				shrink: 1,
+				minSize: 0
+			},
+			{
+				component: this.host.state.planModeBannerContainer,
+				shrink: 1,
+				minSize: 0
+			},
+			{
+				component: this.host.state.statusBarContainer,
+				shrink: 1,
+				minSize: 1,
+				visible: (viewport) => viewport.width >= 60
+			},
+			{
+				component: this.host.state.editorContainer,
+				shrink: 1,
+				minSize: 3
+			},
+			{
+				component: this.ensureFooterWrap(),
+				shrink: 1,
+				minSize: 1
+			}
+		]);
+		const layoutRoot = new VStack([{
+			component: transcriptScrollView,
+			basis: 0,
+			grow: 1,
+			shrink: 1,
+			minSize: 1
+		}, {
+			component: dock,
+			basis: "auto",
+			grow: 0,
+			shrink: 1,
+			minSize: 1
+		}]);
+		ui.setLayoutRoot(layoutRoot);
+		this.host.state.layoutRoot = layoutRoot;
 	}
 	mountFooter() {
-		const footerWrap = new GutterContainer(1, 1);
-		footerWrap.addChild(this.host.state.footer);
-		this.host.state.ui.addChild(footerWrap);
+		this.ensureFooterWrap();
+		this.footerWrap.addChild(this.host.state.footer);
+	}
+	ensureFooterWrap() {
+		if (this.footerWrap === void 0) this.footerWrap = new GutterContainer(1, 1);
+		return this.footerWrap;
 	}
 	refreshTerminalThemeTracking() {
 		this.stopTerminalThemeTracking();
@@ -141022,48 +141929,57 @@ var LifecycleController = class LifecycleController {
 		this.syncTerminalProgress(this.shouldShowTerminalProgress(effectiveMode));
 		if (effectiveMode === this.lastActivityMode) return;
 		this.lastActivityMode = effectiveMode;
+		this.updateStatusBar(effectiveMode);
 		const { state } = this.host;
 		state.activityContainer.clear();
 		switch (effectiveMode) {
 			case "hidden":
+			case "idle":
 				this.stopActivitySpinner();
 				this.stopPulseWave();
-				state.ui.requestRender();
-				return;
-			case "waiting": {
-				this.stopActivitySpinner();
-				const pulseWave = this.ensurePulseWave();
-				state.activityContainer.addChild(new ActivityPaneComponent({
-					mode: "waiting",
-					pulseWave
-				}));
 				break;
-			}
+			case "waiting":
 			case "thinking":
+			case "composing":
+			case "tool":
 				this.stopActivitySpinner();
 				this.stopPulseWave();
 				break;
-			case "composing": {
-				const spinner = this.ensureActivitySpinner("working...", (s) => chalk.hex(state.theme.colors.primary)(s));
-				state.activityContainer.addChild(new ActivityPaneComponent({
-					mode: "composing",
-					spinner
-				}));
-				break;
-			}
-			case "tool": {
-				this.stopActivitySpinner();
-				const pulseWave = this.ensurePulseWave();
-				state.activityContainer.addChild(new ActivityPaneComponent({
-					mode: "tool",
-					pulseWave
-				}));
+		}
+		state.ui.requestRender();
+	}
+	/**
+	* Updates the fixed status bar above the editor to reflect the current
+	* work phase. Called only when the phase actually changes. Uses its OWN
+	* spinner/pulse instances (a component can only have one parent, so the
+	* activity pane's instances must not be shared). Recreating a loader on
+	* every call would leak setInterval timers (each PulseWaveLoader.start()
+	* registers one and the old instance is never stopped), so the previous
+	* instance is explicitly stopped before a new one is mounted. Idle leaves
+	* the bar empty.
+	*/
+	updateStatusBar(mode) {
+		const { state } = this.host;
+		state.statusBarContainer.clear();
+		this.statusBarLoader?.stop();
+		this.statusBarLoader = void 0;
+		switch (mode) {
+			case "waiting":
+			case "composing":
+			case "tool":
+				{
+					const loader = new PulseWaveLoader(state.ui, state.theme.colors.primary);
+					this.statusBarLoader = loader;
+					state.statusBarContainer.addChild(new StatusBarPaneComponent({
+						mode,
+						label: "",
+						pulseWave: loader
+					}));
+				}
 				break;
-			}
+			case "thinking": break;
 			case "idle":
-				this.stopActivitySpinner();
-				this.stopPulseWave();
-				break;
+			case "hidden": break;
 		}
 		state.ui.requestRender();
 	}
@@ -141086,28 +142002,12 @@ var LifecycleController = class LifecycleController {
 		this.host.state.terminal.setProgress(active);
 		this.host.state.terminalState.progressActive = active;
 	}
-	ensureActivitySpinner(label = "", colorFn) {
-		if (this.host.state.activitySpinner === null) {
-			const instance = new MoonLoader(this.host.state.ui, colorFn, label);
-			this.host.state.activitySpinner = { instance };
-			return instance;
-		}
-		this.host.state.activitySpinner.instance.setLabel(label);
-		if (colorFn !== void 0) this.host.state.activitySpinner.instance.setColorFn(colorFn);
-		return this.host.state.activitySpinner.instance;
-	}
 	stopActivitySpinner() {
 		if (this.host.state.activitySpinner !== null) {
 			this.host.state.activitySpinner.instance.stop();
 			this.host.state.activitySpinner = null;
 		}
 	}
-	ensurePulseWave() {
-		if (this.host.state.pulseWave !== null) return this.host.state.pulseWave;
-		const instance = new PulseWaveLoader(this.host.state.ui, this.host.state.theme.colors.primary);
-		this.host.state.pulseWave = instance;
-		return instance;
-	}
 	stopPulseWave() {
 		if (this.host.state.pulseWave !== null) {
 			this.host.state.pulseWave.stop();
@@ -141534,18 +142434,10 @@ var InputController = class InputController {
 		this.host = host;
 	}
 	setupAutocomplete() {
-		const visible = this.host.getSlashCommands().filter((cmd) => !(cmd.name.startsWith("skill:") && cmd.source === "builtin"));
-		const slashCommands = visible.map((cmd) => cmd);
+		const slashCommands = this.host.getSlashCommands().filter((cmd) => !(cmd.name.startsWith("skill:") && cmd.source === "builtin")).map((cmd) => cmd);
 		const { state } = this.host;
 		const provider = new FileMentionProvider(slashCommands, state.appState.workDir, state.fdPath, state.gitLsFilesCache);
 		state.editor.setAutocompleteProvider(provider);
-		const argumentHints = /* @__PURE__ */ new Map();
-		for (const cmd of visible) {
-			if (cmd.argumentHint === void 0) continue;
-			argumentHints.set(cmd.name, cmd.argumentHint);
-			for (const alias of cmd.aliases) argumentHints.set(alias, cmd.argumentHint);
-		}
-		state.editor.setArgumentHints(argumentHints);
 		state.editor.onFirstInput = () => {
 			this.host.stopWelcomeBreathing();
 			this.#permanentlyStopBreathing();
@@ -142840,8 +143732,7 @@ function createTUIState(options) {
 	const initialAppState = options.initialAppState;
 	const theme = createScreamTUIThemeBundle(initialAppState.theme, options.resolvedTheme);
 	const terminal = new ProcessTerminal();
-	const ui = new TUI(terminal);
-	ui.setClearOnShrink(true);
+	const ui = new TuiAltScreen(terminal);
 	const uiAny = ui;
 	const originalDoRender = uiAny["doRender"].bind(ui);
 	let recovering = false;
@@ -142867,6 +143758,7 @@ function createTUIState(options) {
 	};
 	const transcriptContainer = new GutterContainer(1, 1);
 	const activityContainer = new GutterContainer(1, 1);
+	const statusBarContainer = new GutterContainer(1, 1);
 	const todoPanelContainer = new GutterContainer(1, 1);
 	const todoPanel = new TodoPanelComponent(theme.colors);
 	const queueContainer = new GutterContainer(1, 1);
@@ -142884,8 +143776,10 @@ function createTUIState(options) {
 	return {
 		ui,
 		terminal,
+		layoutRoot: void 0,
 		transcriptContainer,
 		activityContainer,
+		statusBarContainer,
 		todoPanelContainer,
 		todoPanel,
 		queueContainer,
@@ -143372,9 +144266,12 @@ const PRUNE_EMPTY_SESSION_GRACE_MS = 300 * 1e3;
 function isPrunableEmptySession(summary, now, graceMs = PRUNE_EMPTY_SESSION_GRACE_MS) {
 	if (summary.archived) return false;
 	if (summary.lastPrompt !== void 0) return false;
-	if (summary.title) return false;
+	if (isUntitledTitle(summary.title)) return false;
 	return now - summary.updatedAt > graceMs;
 }
+function isUntitledTitle(title) {
+	return typeof title === "string" && title.trim().length > 0 && title !== "New Session";
+}
 /**
 * Encapsulates all session lifecycle operations:
 * create / resume / switch / close / sync state / reset runtime.
@@ -143471,6 +144368,7 @@ var SessionManager$1 = class {
 			thinkingLevel: status.thinkingLevel,
 			planMode: status.planMode ? status.planStrategy === "fusion" ? "fusionplan" : "plan" : "off",
 			wolfpackMode: status.wolfpackMode,
+			rlmEnabled: status.rlmEnabled,
 			contextTokens: status.contextTokens,
 			maxContextTokens: status.maxContextTokens,
 			contextUsage: status.contextUsage,
@@ -143789,7 +144687,7 @@ var ApprovalPanelComponent = class extends Container {
 		};
 		if (this.ui !== void 0) this.intervalId = setInterval(() => {
 			this.animFrame = (this.animFrame + 1) % PIXEL_PULSE_FRAMES.length;
-			this.ui?.requestComponentRender(this);
+			this.ui?.requestRender();
 		}, 100);
 	}
 	/** Stop the selection pulse. Idempotent; called on submit and on hide. */
@@ -144644,6 +145542,15 @@ var MemoryPickerComponent = class extends Container {
 			}
 			lines.push("");
 		}
+		if (memo.note !== void 0 && memo.note.length > 0) {
+			const label = t("memory.note_label");
+			const wrapped = wrapText(memo.note, contentWidth - visibleWidth(label));
+			for (let i = 0; i < wrapped.length; i++) {
+				const prefix = i === 0 ? `${indent}${label}` : indent + " ".repeat(visibleWidth(label));
+				lines.push(truncateToWidth(chalk.hex(c.textMuted)(prefix + wrapped[i]), width, ELLIPSIS$1));
+			}
+			lines.push("");
+		}
 		lines.push(chalk.hex(c.textMuted)(truncateToWidth(t("memory.detail_nav_hint"), width, ELLIPSIS$1)));
 		lines.push(chalk.hex(c.primary)("─".repeat(width)));
 		return lines;
@@ -145009,7 +145916,7 @@ var QuestionDialogComponent = class extends Container {
 		this.answers = Array.from({ length: total }, () => void 0);
 		if (this.ui !== void 0) this.intervalId = setInterval(() => {
 			this.animFrame = (this.animFrame + 1) % PIXEL_PULSE_FRAMES.length;
-			this.ui?.requestComponentRender(this);
+			this.ui?.requestRender();
 		}, 100);
 	}
 	/** Stop the wizard pulse. Idempotent; called on respond and on hide. */
@@ -145721,7 +146628,7 @@ var DialogManager = class {
 	}
 	openApprovalPreview(panel, block) {
 		if (this.approvalPreview !== void 0) return;
-		const savedChildren = [...this.host.state.ui.children];
+		const savedLayoutRoot = this.host.state.layoutRoot;
 		const viewer = new ApprovalPreviewViewer({
 			block,
 			colors: this.host.state.theme.colors,
@@ -145729,13 +146636,12 @@ var DialogManager = class {
 				this.closeApprovalPreview();
 			}
 		}, this.host.state.terminal);
-		this.host.state.ui.clear();
-		this.host.state.ui.addChild(viewer);
+		this.host.state.ui.setLayoutRoot(viewer);
 		this.host.state.ui.setFocus(viewer);
 		this.host.state.ui.requestRender(true);
 		this.approvalPreview = {
 			component: viewer,
-			savedChildren,
+			savedLayoutRoot,
 			panel
 		};
 	}
@@ -145743,8 +146649,7 @@ var DialogManager = class {
 		const preview = this.approvalPreview;
 		if (preview === void 0) return;
 		this.approvalPreview = void 0;
-		this.host.state.ui.clear();
-		for (const child of preview.savedChildren) this.host.state.ui.addChild(child);
+		this.host.state.ui.setLayoutRoot(preview.savedLayoutRoot);
 		this.host.state.ui.setFocus(preview.panel);
 		this.host.state.ui.requestRender(true);
 	}
@@ -145814,6 +146719,7 @@ function createInitialAppState(input) {
 		goalContinuationCount: 0,
 		ccConnectActive: false,
 		wolfpackMode: input.cliOptions.wolfpack === true,
+		rlmEnabled: false,
 		reconnectAttempt: 0,
 		recentSessions: [],
 		subagentUsage: {}
@@ -145834,7 +146740,6 @@ var ScreamTUI = class {
 	deferUserMessages = false;
 	aborted = false;
 	isShuttingDown = false;
-	tightModeHandler = null;
 	reverseRpcDisposers = [];
 	startupNotice;
 	/** Interval handle for the periodic provider-balance refresh. */
@@ -145933,11 +146838,6 @@ var ScreamTUI = class {
 		this.inputController.setupAutocomplete();
 	}
 	async start() {
-		this.tightModeHandler = () => {
-			setTightMode((process.stdout.columns ?? 80) < 60);
-		};
-		this.tightModeHandler();
-		process.stdout.on("resize", this.tightModeHandler);
 		this.lifecycleController.installSignalHandlers();
 		try {
 			const shouldReplayHistory = await this.initMainTui();
@@ -146028,11 +146928,6 @@ var ScreamTUI = class {
 	async stop(exitCode) {
 		if (this.isShuttingDown) return;
 		this.isShuttingDown = true;
-		if (this.tightModeHandler !== null) {
-			process.stdout.off("resize", this.tightModeHandler);
-			this.tightModeHandler = null;
-		}
-		setTightMode(false);
 		this.lifecycleController.stopCcConnectPolling();
 		if (this.balancePollTimer !== void 0) {
 			clearInterval(this.balancePollTimer);
@@ -148641,6 +149536,7 @@ var WebSession = class {
 				permission: this.permission,
 				planMode: false,
 				wolfpackMode: false,
+				rlmEnabled: false,
 				contextTokens: 0,
 				maxContextTokens: 0,
 				contextUsage: 0