scream-code 0.19.3 → 0.19.6

package/dist/{app-NpW56jQ9.mjs → app-CE9aji1S.mjs}

@@ -5,8 +5,8 @@ const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
 import { A as sharedMemoStore } from "./src-Cu3sUIJK.mjs";
-import { $ as clearGoalState, $n as validateFeishuCredentials, A as langFromPath, An as embeddingFailureDetail, Ar as resolveGlobalLogPath, At as isTurnElapsedEnabled, B as charsForTokenBudget, Bn as WeixinApiError, Bt as ENABLE_TERMINAL_THEME_REPORTING, Cn as getNoActiveSessionMessage, Cr as ScreamHarness, Ct as clearInfoPanelState, D as renderDiffLines, Dn as isExperimentalFlagEnabled, Dr as resolveScreamHome, Dt as createEditorTheme, E as ToolCallComponent, En as sortSlashCommands, Er as isRealUserPrompt, Et as resolveThemeSync, F as replaceTabs, Fn as PULSE_WAVE_FRAMES, Ft as detectTerminalTheme, G as lerpHex, Gn as buildCdnDownloadUrl, Gt as QUERY_TERMINAL_THEME, H as getSharedSpeedTracker, Hn as isSendThrottled, Ht as OSC11_RESPONSE, I as sanitizeShellOutput, In as readLineDaemonStatus, It as parseOsc11BackgroundTheme, J as WelcomeComponent, Jn as TuiConfigParseError, Jt as TERMINAL_THEME_DARK, K as BackgroundAgentStatusComponent, Kn as decryptAesEcb, Kt as TERMINAL_FOCUS_IN, L as SkillActivationComponent, Ln as startLineDaemonDetached, Lt as DISABLE_TERMINAL_FOCUS_REPORTING, M as ThinkingComponent, Mn as hasEmbeddingModelCache, Mr as isOrphanedToolCallError, Mt as createThemeStyles, N as NoticeMessageComponent, Nn as startManualEmbeddingDownload, Nr as SCREAM_ERROR_INFO, Nt as contrastTextHex, O as renderDiffLinesClustered, On as setExperimentalFlags, Or as flushDiagnosticLogs, Ot as createMarkdownTheme, P as StatusMessageComponent, Pn as PIXEL_PULSE_FRAMES, Pt as getColorPalette, Q as CompactionComponent, Qn as feishuFileType, R as AssistantMessageComponent, Rn as stopLineDaemon, Rt as DISABLE_TERMINAL_THEME_REPORTING, S as readJsonlFile, Sn as getLlmNotSetMessage, Sr as saveCatalogCache, St as supportsBalance, T as UserMessageComponent, Tn as BUILTIN_SLASH_COMMANDS, U as GRADIENT_CYCLE_MS, Un as validateWeixinToken, Ut as OSC11_RESPONSE_PREFIX, V as estimateTokens, Vn as WeixinClient, Vt as OSC11_QUERY, W as lerpGradient, Wt as OSC11_RESPONSE_PREFIX_NO_ESC, X as getBreathingFrame, Xn as FeishuClient, Xt as safeUsageRatio, Y as BREATHE_CYCLE_MS, Yn as loadTuiConfig, Yt as TERMINAL_THEME_LIGHT, Z as resetBreathingClock, Zn as FeishuCredentialError, Zt as SubagentSlots, _n as MAIN_AGENT_ID, _r as CLI_UI_MODE, a as writeTextClipboard, an as STATUS_BULLET, ar as getWeixinCursorFile, at as toTerminalHyperlink, b as readUpdateCache, bn as getCtrlCHint, br as DEFAULT_CATALOG_URL, cn as argsRecord, cr as resolveCustomCommands, d as isExpandable, dn as parseStreamingArgs, dr as detectShellEnvironment, er as LineConfigError, f as isPlanExpandable, fn as serializeToolResultOutput, fr as getDataDir, ft as handleFusionPlanCommand, gn as EXIT_CONFIRM_WINDOW_MS, gr as CLI_COMMAND_NAME, hr as detectInstallSource, i as openUrl, in as printableChar, ir as getWeixinContextTokensFile, j as CachedContainer, jn as getKnowledgeStore, jr as isScreamError, jt as toggleEmptySessionHint, k as highlightLines, kn as embeddingProgressLabel, kr as log, kt as isEmptySessionHintDismissed, l as disposeChildren, ln as formatErrorMessage, lr as resolveFeishuOptions, m as formatMemoryMemoForInjection, mn as truncateErrorMessage, mr as getLogDir, mt as handlePlanCommand, n as clearEvalPanelState, nn as isBusy, nr as getLineConfigPath, o as syncDiagramCapabilityPrompt, on as appendSessionHeaderHint, or as getWeixinStateDir, ot as changeThinkingLevel, p as MoonLoader, pn as stringValue, pr as getInputHistoryFile, q as AgentGroupComponent, qn as parseAesKey, qt as TERMINAL_FOCUS_OUT, rn as isStreaming, rr as getLinePidFile, sn as appendStreamingArgsPreview, sr as loadLineConfig, st as getModelCycleLevel, t as dispatchInput, tr as assertSinglePlatformConfig, u as hasDispose, un as isTodoItemShape, ur as resolveWeixinOptions, v as selectUpdateTarget, vn as SESSION_TIPS, vr as CLI_USER_AGENT_PRODUCT, wn as buildSkillSlashCommands, wr as normalizeWorkDir, x as appendJsonlLine, xn as getCtrlDHint, xr as fetchCatalog, xt as refreshProviderBalance, y as refreshUpdateCache, yn as TIP_ROTATION_INTERVAL_MS, yr as PRODUCT_NAME, z as ActivityGroupComponent, zn as UPLOAD_MEDIA_TYPE, zt as ENABLE_TERMINAL_FOCUS_REPORTING } from "./dispatch-BziMqJ_r.mjs";
-import { i as t, n as getLocale, r as setLocale } from "./text-input-dialog-yvsx17gg.mjs";
+import { $n as validateFeishuCredentials, A as langFromPath, An as hasEmbeddingModelCache, Ar as flushDiagnosticLogs, At as createThemeStyles, B as getSharedSpeedTracker, Bn as isSendThrottled, Bt as OSC11_RESPONSE, Cn as BUILTIN_SLASH_COMMANDS, Cr as fetchCatalog, D as renderDiffLines, Dn as embeddingProgressLabel, Dt as isEmptySessionHintDismissed, E as ToolCallComponent, En as setExperimentalFlags, Er as normalizeWorkDir, Et as createMarkdownTheme, F as SkillActivationComponent, Fn as startLineDaemonDetached, Fr as SCREAM_ERROR_INFO, Ft as DISABLE_TERMINAL_FOCUS_REPORTING, G as AgentGroupComponent, Gn as parseAesKey, Gt as TERMINAL_FOCUS_OUT, H as lerpGradient, Ht as OSC11_RESPONSE_PREFIX_NO_ESC, I as AssistantMessageComponent, In as stopLineDaemon, It as DISABLE_TERMINAL_THEME_REPORTING, J as getBreathingFrame, Jn as TuiConfigParseError, Jt as safeUsageRatio, K as WelcomeComponent, Kn as replaceTabs, Kt as TERMINAL_THEME_DARK, L as ActivityGroupComponent, Ln as UPLOAD_MEDIA_TYPE, Lt as ENABLE_TERMINAL_FOCUS_REPORTING, M as ThinkingComponent, Mn as PIXEL_PULSE_FRAMES, Mr as resolveGlobalLogPath, Mt as getColorPalette, N as NoticeMessageComponent, Nn as PULSE_WAVE_FRAMES, Nr as isScreamError, Nt as detectTerminalTheme, O as renderDiffLinesClustered, On as embeddingFailureDetail, Or as isRealUserPrompt, Ot as isTurnElapsedEnabled, P as StatusMessageComponent, Pn as readLineDaemonStatus, Pr as isOrphanedToolCallError, Pt as parseOsc11BackgroundTheme, Qn as feishuFileType, R as charsForTokenBudget, Rn as WeixinApiError, Rt as ENABLE_TERMINAL_THEME_REPORTING, S as readJsonlFile, Sn as buildSkillSlashCommands, Sr as DEFAULT_CATALOG_URL, T as UserMessageComponent, Tn as isExperimentalFlagEnabled, Tr as ScreamHarness, Tt as createEditorTheme, U as lerpHex, Un as buildCdnDownloadUrl, Ut as QUERY_TERMINAL_THEME, V as GRADIENT_CYCLE_MS, Vn as validateWeixinToken, Vt as OSC11_RESPONSE_PREFIX, W as BackgroundAgentStatusComponent, Wn as decryptAesEcb, Wt as TERMINAL_FOCUS_IN, X as CompactionComponent, Xn as FeishuClient, Y as resetBreathingClock, Yn as loadTuiConfig, Yt as SubagentSlots, Z as clearGoalState, Zn as FeishuCredentialError, _n as TIP_ROTATION_INTERVAL_MS, _r as detectInstallSource, a as writeTextClipboard, an as appendStreamingArgsPreview, ar as getWeixinContextTokensFile, at as getModelCycleLevel, b as readUpdateCache, bn as getLlmNotSetMessage, br as CLI_USER_AGENT_PRODUCT, bt as supportsBalance, cn as isTodoItemShape, cr as loadLineConfig, d as isExpandable, dn as stringValue, dr as resolveTurnTimeoutMs, en as isBusy, er as LineConfigError, f as isPlanExpandable, fn as truncateErrorMessage, fr as resolveWeixinOptions, ft as handlePlanCommand, gn as SESSION_TIPS, gr as getLogDir, hn as MAIN_AGENT_ID, hr as getInputHistoryFile, i as openUrl, in as appendSessionHeaderHint, ir as getLinePidFile, it as changeThinkingLevel, j as CachedContainer, jn as startManualEmbeddingDownload, jr as log, jt as contrastTextHex, k as highlightLines, kn as getKnowledgeStore, kr as resolveScreamHome, kt as toggleEmptySessionHint, l as disposeChildren, ln as parseStreamingArgs, lr as resolveCustomCommands, m as formatMemoryMemoForInjection, mn as EXIT_CONFIRM_WINDOW_MS, mr as getDataDir, n as clearEvalPanelState, nn as printableChar, nr as assertSinglePlatformConfig, o as syncDiagramCapabilityPrompt, on as argsRecord, or as getWeixinCursorFile, p as MoonLoader, pr as detectShellEnvironment, q as BREATHE_CYCLE_MS, qn as sanitizeShellOutput, qt as TERMINAL_THEME_LIGHT, rn as STATUS_BULLET, rr as getLineConfigPath, rt as toTerminalHyperlink, sn as formatErrorMessage, sr as getWeixinStateDir, t as dispatchInput, tn as isStreaming, tr as MINUTE_MS, u as hasDispose, un as serializeToolResultOutput, ur as resolveFeishuOptions, ut as handleFusionPlanCommand, v as selectUpdateTarget, vn as getCtrlCHint, vr as CLI_COMMAND_NAME, wn as sortSlashCommands, wr as saveCatalogCache, wt as resolveThemeSync, x as appendJsonlLine, xn as getNoActiveSessionMessage, xr as PRODUCT_NAME, xt as clearInfoPanelState, y as refreshUpdateCache, yn as getCtrlDHint, yr as CLI_UI_MODE, yt as refreshProviderBalance, z as estimateTokens, zn as WeixinClient, zt as OSC11_QUERY } from "./dispatch-XPKo0cQR.mjs";
+import { i as t, n as getLocale, r as setLocale } from "./text-input-dialog-BqMy3ifH.mjs";
 import { createRequire } from "node:module";
 import { createHash, randomInt, randomUUID } from "node:crypto";
 import { mkdir, mkdtemp, open, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
@@ -21,14 +21,14 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command, Option } from "commander";
 import { createInterface } from "node:readline/promises";
 import { createInterface as createInterface$1 } from "node:readline";
-import chalk, { chalkStderr } from "chalk";
 import { CombinedAutocompleteProvider, Container, Editor, HStack, Input, Key, ProcessTerminal, ScrollView, Spacer, Text, TuiAltScreen, VStack, decodeKittyPrintable, deleteAllKittyImages, fuzzyFilter, fuzzyMatch, getCapabilities, isKeyRelease, matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@liutod-scream/pi-tui";
+import chalk, { chalkStderr } from "chalk";
 //#region src/cli/build-info.ts
 function optionalBuildString(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 const SCREAM_BUILD_INFO = {
-	version: optionalBuildString("0.19.3"),
+	version: optionalBuildString("0.19.6"),
 	channel: optionalBuildString(""),
 	commit: optionalBuildString(""),
 	buildTarget: optionalBuildString("darwin-arm64")
@@ -719,6 +719,31 @@ var FeishuPlatform = class {
 		await this.client.sendToChat(chatId, "file", JSON.stringify({ file_key: fileKey }));
 		return kind === "voice" ? "（飞书按文件发送，语音气泡仅微信支持）" : "";
 	}
+	/**
+	* Sends text to the chat that owns this session with no inbound message to
+	* reply to — the scheduled-task path. Lark only needs the chat id, which is
+	* cached per session on every inbound message, so a fire at 3am still lands.
+	*/
+	async sendProactive(sessionKey, text) {
+		const body = text.trim();
+		if (body === "") return "no-target";
+		const chatId = this.chatBySession.get(sessionKey);
+		if (chatId === void 0) {
+			log.warn("line-feishu: no chat recorded for proactive send", { sessionKey });
+			return "no-target";
+		}
+		try {
+			const outbound = buildReplyContent(truncateForLine(body));
+			await this.client.sendToChat(chatId, outbound.msgType, outbound.body);
+			return "sent";
+		} catch (error) {
+			log.warn("line-feishu: proactive send failed", {
+				sessionKey,
+				error: String(error)
+			});
+			return "failed";
+		}
+	}
 	/** Cancels pending batch timers (daemon shutdown). */
 	stop() {
 		for (const batch of this.pendingImages.values()) clearTimeout(batch.timer);
@@ -1667,12 +1692,66 @@ function buildChannelPrompt(platform) {
 	].join("\n");
 }
 //#endregion
+//#region src/line/cron-commands.ts
+const PROMPT_PREVIEW_CHARS = 60;
+/** `add <min hour dom mon dow> <prompt…>` → the two fields the RPC wants. */
+function parseCronAdd(parts) {
+	const rest = [...parts];
+	let silent = false;
+	let mute = false;
+	while (rest[0] === "--silent" || rest[0] === "--mute") if (rest.shift() === "--silent") silent = true;
+	else mute = true;
+	if (rest.length < 6) return null;
+	const cron = rest.slice(0, 5).join(" ");
+	const prompt = rest.slice(5).join(" ").trim();
+	if (prompt === "") return null;
+	return {
+		cron,
+		prompt,
+		...silent ? { silent: true } : {},
+		...mute ? { mute: true } : {}
+	};
+}
+function describeNext(task, now) {
+	if (task.nextFireAt === null) return task.recurring ? "不再触发" : "已触发";
+	const minutes = Math.max(0, Math.round((task.nextFireAt - now) / 6e4));
+	if (minutes <= 1) return "即将触发";
+	return `下次 ${minutes} 分钟后`;
+}
+function shorten$1(text) {
+	const chars = Array.from(text);
+	return chars.length > PROMPT_PREVIEW_CHARS ? `${chars.slice(0, PROMPT_PREVIEW_CHARS - 1).join("")}…` : text;
+}
+/** Listing for `/cron` / `/cron list`; `now` is injectable for tests. */
+function formatCronList(tasks, now = Date.now()) {
+	if (tasks.length === 0) return "还没有定时任务。\n/cron add <分 时 日 月 周> <要做的事>";
+	const lines = [`定时任务（${tasks.length}）`];
+	for (const task of tasks) {
+		const flags = [
+			describeNext(task, now),
+			task.stale ? "已过期" : "",
+			task.recurring ? "" : "一次性",
+			task.silent === true ? "静默" : "",
+			task.mute === true ? "静音" : ""
+		].filter((part) => part !== "").join(" · ");
+		lines.push(`${task.id}  ${task.cron}  ${flags}`);
+		lines.push(`  ${shorten$1(task.prompt)}`);
+		if (task.lastError !== void 0 && task.lastError !== null) lines.push(`  上次失败：${shorten$1(task.lastError)}`);
+	}
+	lines.push("回复 /cron rm <id> 删除。");
+	return lines.join("\n");
+}
+const CRON_USAGE = "用法：/cron list · /cron add [--silent|--mute] <分 时 日 月 周> <要做的事> · /cron rm <id>";
+//#endregion
 //#region src/line/command-router.ts
 const HELP_TEXT = [
 	"可用命令：",
 	"/status            查看当前模型、权限与上下文占用",
 	"/model <名称>      切换模型（不带参数查看当前值）",
 	"/compact           压缩上下文",
+	"/stop              停止正在运行的任务",
+	"/cron              查看定时任务（add/rm 见用法）",
+	"/cancel            停止并开始新会话",
 	"/new               开启新会话",
 	"/help              显示本帮助",
 	"",
@@ -1686,7 +1765,7 @@ const DESKTOP_ONLY = new Set([
 	"/login",
 	"/image"
 ]);
-const BUSY_TEXT = "当前有任务正在处理中，请等这一轮结束后再发该命令。";
+const BUSY_TEXT = "当前有任务正在处理中：回复 /stop 可中止，或等这一轮结束后再发该命令。";
 /** Built-ins plus the user's configured commands. */
 function helpText(commands) {
 	if (commands.length === 0) return HELP_TEXT;
@@ -1738,6 +1817,71 @@ async function runLineCommand$1(rawText, deps) {
 			handled: true,
 			text: await modelText(deps, arg)
 		};
+		case "/stop":
+			if (!(deps.stopTurn?.() ?? false)) return {
+				handled: true,
+				text: "当前没有正在运行的任务。"
+			};
+			return {
+				handled: true,
+				text: "已停止当前任务。"
+			};
+		case "/cron": {
+			let session;
+			try {
+				session = await deps.getSession();
+			} catch (error) {
+				return {
+					handled: true,
+					text: `读取会话失败：${describeError(error)}`
+				};
+			}
+			const tokens = arg.trim() === "" ? [] : arg.trim().split(/\s+/);
+			const sub = tokens[0];
+			const parts = tokens.slice(1);
+			try {
+				if (sub === void 0 || sub === "list") return {
+					handled: true,
+					text: formatCronList(await session.listCronTasks())
+				};
+				if (sub === "add") {
+					const parsed = parseCronAdd(parts);
+					if (parsed === null) return {
+						handled: true,
+						text: CRON_USAGE
+					};
+					const task = await session.createCronTask(parsed);
+					return {
+						handled: true,
+						text: `已创建定时任务 ${task.cron}：\n${task.prompt}`
+					};
+				}
+				if (sub === "rm" || sub === "remove") {
+					if (parts.length === 0) return {
+						handled: true,
+						text: CRON_USAGE
+					};
+					const removed = await session.removeCronTasks(parts);
+					return {
+						handled: true,
+						text: removed.length === 0 ? "没有找到该任务。" : `已删除 ${removed.length} 个任务。`
+					};
+				}
+				return {
+					handled: true,
+					text: CRON_USAGE
+				};
+			} catch (error) {
+				return {
+					handled: true,
+					text: `定时任务操作失败：${describeError(error)}`
+				};
+			}
+		}
+		case "/cancel": return {
+			handled: true,
+			text: await deps.cancelSession?.() ?? false ? "已停止当前任务并开始新会话。" : "已开始新会话。"
+		};
 		case "/compact":
 			if (deps.isBusy()) return {
 				handled: true,
@@ -1813,7 +1957,9 @@ async function statusText$1(deps) {
 			`模型：${status.model ?? (deps.defaultModel || "未知")}`,
 			`模式：${modes.join(" · ")}`,
 			`上下文：${percent}（${formatTokens(status.contextTokens)}/${formatTokens(status.maxContextTokens)}）`,
-			`思考级别：${status.thinkingLevel}`
+			`思考级别：${status.thinkingLevel}`,
+			...deps.turnTimeoutMinutes === void 0 ? [] : [`单轮上限：${deps.turnTimeoutMinutes} 分钟`],
+			...deps.voiceStatus === void 0 || deps.voiceStatus === null ? [] : [deps.voiceStatus]
 		].join("\n");
 	} catch (error) {
 		return `读取状态失败：${describeError(error)}`;
@@ -1846,19 +1992,174 @@ function expandPrompt(template, arg) {
 	return arg.length > 0 ? `${template}\n\n${arg}` : template;
 }
 //#endregion
-//#region src/line/session-driver.ts
+//#region src/line/voice-support.ts
 /**
-* Line session driver — maps Feishu chats to scream agent sessions.
+* Startup capability probe for outbound voice.
 *
-* Uses the same headless layer as `scream stream-json` (`ScreamHarness`),
-* including the create/resume/repair session lifecycle (ported from
-* `run-stream-json.ts` L659-726) and the approval-handler mapping. Turns are
-* serialized per session (one FIFO chain each) and run in parallel across
-* sessions; a bounded queue rejects new work with a friendly busy reply
-* instead of growing unbounded.
+* Voice sending is the one path that depends on the host's ffmpeg being built
+* with an AMR-NB *encoder* — plenty of package-manager builds ship the decoder
+* only. Discovering that at send time turns every voice reply into a fallback
+* file plus an apology, so the daemon probes once at startup and reports the
+* answer in `/status`.
+*
+* The probe never throws: a failure to answer is `unknown`, which is treated as
+* "try anyway" rather than "unavailable".
 */
-const MAX_QUEUE_PER_SESSION = 3;
-const ORPHAN_RESET_NOTICE = "会话已自动重置，请重新发送你的消息。";
+const execFileAsync$2 = promisify(execFile);
+const PROBE_TIMEOUT_MS = 5e3;
+/** Parses `ffmpeg -encoders` output for an AMR-NB encoder. */
+function parseAmrEncoderListing(stdout) {
+	return stdout.split(/\r?\n/).some((line) => /\bamr_nb\b|\blibopencore_amrnb\b/i.test(line) && /^\s*A/.test(line));
+}
+/** One-shot probe; callers cache the result (ffmpeg does not appear mid-run). */
+async function probeVoiceSupport() {
+	try {
+		const { stdout } = await execFileAsync$2("ffmpeg", ["-hide_banner", "-encoders"], {
+			timeout: PROBE_TIMEOUT_MS,
+			maxBuffer: 4 * 1024 * 1024,
+			windowsHide: true
+		});
+		return parseAmrEncoderListing(stdout) ? "ready" : "no-encoder";
+	} catch (error) {
+		return error.code === "ENOENT" ? "no-ffmpeg" : "unknown";
+	}
+}
+/** One-line description for `/status`; `null` when no probe has run yet. */
+function describeVoiceSupport(support) {
+	switch (support) {
+		case "ready": return "语音：可用（AMR-NB）";
+		case "no-ffmpeg": return "语音：不可用（未找到 ffmpeg，将改发文件）";
+		case "no-encoder": return "语音：不可用（ffmpeg 缺少 AMR-NB 编码器，将改发文件）";
+		case "unknown": return "语音：未确认（ffmpeg 探测失败，发送时再判断）";
+		case null: return null;
+	}
+}
+//#endregion
+//#region src/tui/utils/child-request-notice.ts
+const CHILD_REQUEST_KINDS = [
+	"info",
+	"handoff",
+	"escalate"
+];
+/**
+* Longest previewed value kept on one row. The kernel allows 8192 chars
+* (`contact-parent.ts`); the ticker is one terminal line, so anything longer is
+* cut here and the full text remains reachable via the agent card.
+*/
+const TEXT_PREVIEW = 200;
+/**
+* Collapse the request onto previewable single-paragraph form.
+*
+* The text comes from a child agent's model output, i.e. untrusted input that
+* is about to be written into a terminal row: control sequences (CSI/OSC/DCS —
+* screen clears, cursor moves, OSC 52 clipboard writes) are stripped first, the
+* same way shell output is sanitized elsewhere. The cap counts code points, not
+* UTF-16 units, so a surrogate pair is never split into a replacement glyph.
+*/
+function previewText(value) {
+	const flattened = sanitizeShellOutput(value).replaceAll(/\s*\n\s*/g, " ").trim();
+	const codePoints = Array.from(flattened);
+	return codePoints.length > TEXT_PREVIEW ? `${codePoints.slice(0, TEXT_PREVIEW).join("")}…` : flattened;
+}
+function kindOf(raw) {
+	return typeof raw === "string" && CHILD_REQUEST_KINDS.includes(raw) ? raw : "info";
+}
+function textOf(raw) {
+	if (typeof raw !== "string") return void 0;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/**
+* Live producer: the delivery event the kernel emits once a request landed in
+* the parent's turn. Events cross the wire as untyped JSON, so every field is
+* re-checked here rather than trusted from the declared type.
+*/
+function childRequestFieldsFromEvent(event) {
+	const record = event;
+	const message = textOf(record["message"]);
+	if (message === void 0) return null;
+	const listOf = (key) => {
+		const raw = record[key];
+		if (!Array.isArray(raw)) return void 0;
+		const items = raw.map((item) => textOf(item)).filter((item) => item !== void 0);
+		return items.length > 0 ? items : void 0;
+	};
+	return {
+		requestType: kindOf(record["requestType"]),
+		message,
+		needs: textOf(record["needs"]),
+		expecting: textOf(record["expecting"]),
+		artifacts: listOf("artifacts"),
+		evidence: listOf("evidence"),
+		missing: listOf("missing")
+	};
+}
+//#endregion
+//#region src/tui/utils/cron-chip.ts
+/**
+* Scheduled-task reminder → one-line status chip.
+*
+* A fired cron task already owns a transcript block (`CronMessageComponent`) and
+* a turn. The status bar adds the *live* signal: the reminder is time-sensitive,
+* so it must be visible above the editor for a few seconds even when the user is
+* looking at the input box, not the transcript.
+*
+* Copy follows the shared chip grammar `<symbol> <label>：<value>` — the symbol
+* lives in the copy, the colour comes from the caller (`accent` for a normal
+* fire, `warning` for a stale/overdue one).
+*/
+/** Longest task prompt shown on the row. The full text stays in the transcript
+*  block, so the chip only needs enough words to recognise the task. */
+const CRON_PREVIEW_CHARS = 40;
+function shorten(value, max) {
+	const codePoints = Array.from(value);
+	return codePoints.length > max ? `${codePoints.slice(0, max - 1).join("")}…` : value;
+}
+/**
+* Build the chip for one `cron.fired` delivery.
+*
+* `previewText` runs first: the prompt is model/tool-authored text about to be
+* written into a terminal row, so control sequences are stripped and newlines
+* collapse before the length cap is applied.
+*
+* Precedence, most notable first:
+*   stale (7-day cutoff) → coalesced (missed theoretical fires) → one-shot →
+*   plain recurring fire.
+*/
+function buildCronReminderChip(event) {
+	const origin = event.origin;
+	const preview = shorten(previewText(event.prompt), CRON_PREVIEW_CHARS) || origin.cron;
+	if (origin.stale) return {
+		text: t("status.cron_stale", { preview }),
+		tone: "missed"
+	};
+	if (origin.coalescedCount > 1) return {
+		text: t("status.cron_fired_coalesced", {
+			count: String(origin.coalescedCount),
+			preview
+		}),
+		tone: "fired"
+	};
+	if (!origin.recurring) return {
+		text: t("status.cron_once", { preview }),
+		tone: "fired"
+	};
+	return {
+		text: t("status.cron_fired", { preview }),
+		tone: "fired"
+	};
+}
+/**
+* Chat-side notice for a fired task that finished without any reply text — an
+* error swallowed by the agent, or a turn the model ended silently. The chat
+* should hear *something*; silence is the one outcome a reminder must not have.
+*/
+function buildCronFailureNotice(event) {
+	const origin = event.origin;
+	return t("status.cron_empty", { preview: shorten(previewText(event.prompt), CRON_PREVIEW_CHARS) || origin.cron });
+}
+//#endregion
+//#region src/line/turn-collector.ts
 /**
 * Collects the final content output of one turn from the session event
 * stream (main agent only).
@@ -1912,9 +2213,125 @@ var LineTurnCollector = class {
 		}
 	}
 };
-/** A turn that never settles is cancelled after this long (product default). */
-const TURN_TIMEOUT_MS = 900 * 1e3;
-const TURN_TIMEOUT_TEXT = "本轮执行超时（15 分钟），已取消。请重试或拆分任务。";
+//#endregion
+//#region src/line/cron-relay.ts
+/**
+* Scheduled-task relay.
+*
+* A fired cron task runs *inside* the session, not through `submit()`, so its
+* turn carries no inbound context for the platform to reply to. This class
+* turns that turn into a delivery: announce the fire, collect the final text,
+* hand it to the caller's `send`.
+*
+* Two rules keep it from double-posting:
+*  - a fire that lands while a user turn is running is dropped — `steer()` has
+*    already merged it into that turn, whose reply reaches the chat anyway;
+*  - one forward at a time per session; a second fire during collection is
+*    skipped rather than interleaved.
+*/
+/**
+* A fired turn that never reports its end must not block later fires. Follows
+* the channel's turn cap, so a long scheduled task is not dropped early.
+*/
+const DEFAULT_COLLECT_TIMEOUT_MS = 60 * MINUTE_MS;
+var CronRelay = class {
+	options;
+	collector;
+	guard;
+	constructor(options) {
+		this.options = options;
+	}
+	/**
+	* A scheduled task fired; `notice` is the one-liner shown before the result.
+	*
+	* `pendingStart` is the `turn.started` event the core emits *before* the
+	* `cron.fired` event (`steer()` launches the turn synchronously). Without
+	* replaying it the collector would ignore every delta of that turn and never
+	* settle, so no result would ever be delivered.
+	*/
+	onFire(notice, pendingStart, failureNotice) {
+		if (this.options.isBusy()) return;
+		if (this.collector !== void 0) {
+			log.warn("line: cron fire ignored, previous forward still collecting");
+			return;
+		}
+		const collector = new LineTurnCollector(() => {
+			this.clearGuard();
+			this.collector = void 0;
+			this.deliver(collector, failureNotice);
+		});
+		this.collector = collector;
+		this.guard = setTimeout(() => {
+			if (this.collector !== collector) return;
+			this.collector = void 0;
+			log.warn("line: scheduled task turn produced no end event", { timeoutMs: this.options.collectTimeoutMs ?? DEFAULT_COLLECT_TIMEOUT_MS });
+		}, this.options.collectTimeoutMs ?? DEFAULT_COLLECT_TIMEOUT_MS);
+		this.guard.unref?.();
+		if (pendingStart !== void 0) collector.handleEvent(pendingStart);
+		if (notice !== null) this.options.send(notice).then((result) => {
+			if (result !== "sent") log.warn("line: cron notice not delivered", { result });
+		});
+	}
+	/** True while a fired task's turn is being collected. */
+	isCollecting() {
+		return this.collector !== void 0;
+	}
+	/** Drops any in-flight collection (session reset / shutdown). */
+	dispose() {
+		this.clearGuard();
+		this.collector = void 0;
+	}
+	clearGuard() {
+		if (this.guard === void 0) return;
+		clearTimeout(this.guard);
+		this.guard = void 0;
+	}
+	/** Every other event of the session; ignored unless a fire is being collected. */
+	onEvent(event) {
+		if (this.collector === void 0) return;
+		if (this.options.isBusy()) {
+			this.clearGuard();
+			this.collector = void 0;
+			return;
+		}
+		this.collector.handleEvent(event);
+	}
+	async deliver(collector, failureNotice) {
+		if (this.options.isBusy()) return;
+		const text = collector.text.trim();
+		if (text === "") {
+			log.warn("line: scheduled task produced no reply text", { ended: collector.ended });
+			if (failureNotice !== void 0) {
+				const result = await this.options.send(failureNotice);
+				if (result !== "sent") log.warn("line: cron failure notice not delivered", { result });
+			}
+			return;
+		}
+		const result = await this.options.send(text);
+		if (result !== "sent") log.warn("line: cron result not delivered", { result });
+	}
+};
+//#endregion
+//#region src/line/session-driver.ts
+/**
+* Line session driver — maps Feishu chats to scream agent sessions.
+*
+* Uses the same headless layer as `scream stream-json` (`ScreamHarness`),
+* including the create/resume/repair session lifecycle (ported from
+* `run-stream-json.ts` L659-726) and the approval-handler mapping. Turns are
+* serialized per session (one FIFO chain each) and run in parallel across
+* sessions; a bounded queue rejects new work with a friendly busy reply
+* instead of growing unbounded.
+*/
+const MAX_QUEUE_PER_SESSION = 3;
+const ORPHAN_RESET_NOTICE = "会话已自动重置，请重新发送你的消息。";
+/**
+* `/stop` interrupts in-process. A tool that ignores the abort would otherwise
+* keep the chat busy until the turn cap, so after this window the live session is
+* closed: history stays on disk and the next message resumes the same session
+* id — the same end result as tearing down the agent process.
+*/
+const STOP_ESCALATION_MS = 1e4;
 /** `exec`-type custom commands are bounded like any other IM command. */
 const CUSTOM_COMMAND_TIMEOUT_MS = 3e4;
 const CUSTOM_COMMAND_MAX_BUFFER = 1024 * 1024;
@@ -1939,19 +2356,41 @@ var LineSessionDriver = class {
 	promptedSessions = /* @__PURE__ */ new WeakSet();
 	/** sessionKey → platform sender for outbound media (registered by the daemon). */
 	mediaSenders = /* @__PURE__ */ new Map();
+	/** Fallback sender resolved from the platform's own target cache, so a
+	*  scheduled-task turn can still send media after a reset or restart. */
+	mediaSenderResolver;
 	/** Session id → sessionKey, so a host tool call can find its channel. */
 	sessionKeyBySessionId = /* @__PURE__ */ new Map();
 	/** Chats currently executing `/new`; a turn must not start meanwhile. */
 	resetting = /* @__PURE__ */ new Set();
-	/** Deadline timer for the running turn (see `turnDeadline`). */
-	turnTimer;
+	/** The turn executing right now per chat, so `/stop` has something to abort.
+	*  Chats run in parallel, so this is keyed by session — a single slot would
+	*  let one chat's turn hide another's from `/stop`. */
+	activeTurns = /* @__PURE__ */ new Map();
+	/** Bumped by `/stop`: turns queued before the bump are dropped instead of
+	*  running. "Stop" has to mean the messages I just sent, not only the one
+	*  that happens to be executing. */
+	stopEpoch = /* @__PURE__ */ new Map();
+	/** Escalation timers for a `/stop` whose turn never settles, per chat. */
+	stopEscalations = /* @__PURE__ */ new Map();
+	/** Injected by the daemon: sends to a chat with no inbound message to reply
+	*  to. Undefined when no platform supports proactive delivery. */
+	proactiveSender;
+	/** One relay + event subscription per live session, so scheduled tasks can
+	*  reach the chat. Replaced on session reset, dropped on close. */
+	cronForwarders = /* @__PURE__ */ new Map();
+	/** Cached ffmpeg capability answer (see `probeVoice`). */
+	voiceSupport = null;
 	/** In-flight creations, so a command and a turn cannot create two sessions. */
 	sessionCreations = /* @__PURE__ */ new Map();
 	/** Per-chat lifecycle mutex: session creation must never interleave a reset. */
 	lifecycleLocks = /* @__PURE__ */ new Map();
+	/** Wall-clock cap for one turn; see `turnDeadline`. */
+	turnTimeoutMs;
 	closed = false;
 	constructor(options) {
 		this.options = options;
+		this.turnTimeoutMs = options.turnTimeoutMs ?? 36e5;
 	}
 	async init() {
 		const harness = new ScreamHarness({
@@ -1966,6 +2405,100 @@ var LineSessionDriver = class {
 		this.harness = harness;
 	}
 	/**
+	* Probes the host for an AMR-NB encoder once. Called by the daemon at startup
+	* so `/status` can warn before the first voice reply falls back to a file.
+	* Never throws.
+	*/
+	async probeVoice() {
+		try {
+			this.voiceSupport = await probeVoiceSupport();
+			if (describeVoiceSupport(this.voiceSupport) !== null) log.info("line: voice capability", { support: this.voiceSupport });
+		} catch (error) {
+			this.voiceSupport = "unknown";
+			log.warn("line: voice probe failed", { error: String(error) });
+		}
+	}
+	/**
+	* `/stop`: aborts the turn that is running now. The cancel itself happens
+	* inside `runTurn` so the queue unwinds in one place; this only requests it.
+	*/
+	stopActiveTurn(sessionKey) {
+		const running = this.activeTurns.get(sessionKey);
+		const pending = this.queues.get(sessionKey)?.pending ?? 0;
+		const forwarder = this.cronForwarders.get(sessionKey);
+		const forwarding = forwarder?.relay.isCollecting() ?? false;
+		const cronTurn = forwarder?.isCronTurnRunning() ?? false;
+		if (running === void 0 && pending === 0 && !forwarding && !cronTurn) return false;
+		this.stopEpoch.set(sessionKey, (this.stopEpoch.get(sessionKey) ?? 0) + 1);
+		if (running !== void 0) {
+			running.stop();
+			this.armStopEscalation(sessionKey);
+		}
+		if (forwarding || cronTurn) {
+			forwarder?.relay.dispose();
+			this.sessions.get(sessionKey)?.cancel().catch(() => {});
+			log.info("line: dropped a scheduled-task turn", { sessionKey });
+		}
+		log.info("line: stop requested", {
+			sessionKey,
+			running: running !== void 0,
+			pending
+		});
+		return true;
+	}
+	/**
+	* `/cancel`: stop whatever runs and start a clean session. Falls back to
+	* closing the live session when a hung tool refuses to settle, then resets.
+	*/
+	async cancelSession(sessionKey) {
+		const stopped = this.stopActiveTurn(sessionKey);
+		const timeout = new Promise((resolve) => {
+			setTimeout(() => {
+				resolve("timeout");
+			}, STOP_ESCALATION_MS).unref?.();
+		});
+		const reset = this.resetSession(sessionKey).then(() => "done", () => "done");
+		if (await Promise.race([reset, timeout]) === "timeout") {
+			log.warn("line: cancel could not reset in time, closing live session", { sessionKey });
+			await this.forceCloseSession(sessionKey);
+			await this.resetSession(sessionKey).catch((error) => {
+				log.warn("line: cancel reset failed after close", {
+					sessionKey,
+					error: String(error)
+				});
+			});
+		}
+		return stopped;
+	}
+	armStopEscalation(sessionKey) {
+		this.clearStopEscalation(sessionKey);
+		const timer = setTimeout(() => {
+			this.stopEscalations.delete(sessionKey);
+			if (!this.activeTurns.has(sessionKey)) return;
+			log.warn("line: /stop did not settle, closing the live session", { sessionKey });
+			this.forceCloseSession(sessionKey);
+		}, STOP_ESCALATION_MS);
+		timer.unref?.();
+		this.stopEscalations.set(sessionKey, timer);
+	}
+	clearStopEscalation(sessionKey) {
+		const timer = this.stopEscalations.get(sessionKey);
+		if (timer === void 0) return;
+		clearTimeout(timer);
+		this.stopEscalations.delete(sessionKey);
+	}
+	/** Closes the live session without deleting it: the next message resumes. */
+	async forceCloseSession(sessionKey) {
+		this.stopCronForwarder(sessionKey);
+		const session = this.sessions.get(sessionKey);
+		this.sessions.delete(sessionKey);
+		if (session !== void 0) {
+			this.sessionKeyBySessionId.delete(session.id);
+			await session.close().catch(() => {});
+		}
+		this.mediaSenders.delete(sessionKey);
+	}
+	/**
 	* Submit a turn on the session for `sessionKey`. Serialized per session;
 	* resolves with the turn outcome (final text or a friendly error).
 	*/
@@ -2003,10 +2536,28 @@ var LineSessionDriver = class {
 				text: "上一条消息还在处理中，队列已满，请稍后再发。"
 			};
 		}
+		const epoch = this.stopEpoch.get(effectiveJob.sessionKey) ?? 0;
+		const waitingBehind = queue.pending;
 		queue.pending += 1;
 		this.queues.set(effectiveJob.sessionKey, queue);
+		if (waitingBehind > 0) try {
+			effectiveJob.onQueued?.(waitingBehind);
+		} catch (error) {
+			log.warn("line: queued notice failed", {
+				sessionKey: effectiveJob.sessionKey,
+				error: String(error)
+			});
+		}
 		let outcome;
 		const next = queue.chain.then(async () => {
+			if ((this.stopEpoch.get(effectiveJob.sessionKey) ?? 0) !== epoch) {
+				outcome = {
+					ok: false,
+					text: "",
+					silent: true
+				};
+				return;
+			}
 			try {
 				outcome = await this.runTurn(effectiveJob);
 			} catch (error) {
@@ -2028,24 +2579,44 @@ var LineSessionDriver = class {
 		return outcome;
 	}
 	/**
-	* Resolves after `TURN_TIMEOUT_MS`. Raced against the turn promise so a
+	* Resolves after the configured turn cap. Raced against the turn promise so a
 	* provider that never emits a settlement event cannot wedge the chat queue.
+	*
+	* The timer belongs to this turn, not to the driver: chats run in parallel,
+	* so a shared field would let the first chat to finish cancel the second
+	* chat's deadline and leave that turn with no way out.
 	*/
 	turnDeadline() {
-		return new Promise((resolve) => {
-			this.turnTimer = setTimeout(resolve, TURN_TIMEOUT_MS);
-			this.turnTimer.unref?.();
-		});
+		let timer;
+		return {
+			promise: new Promise((resolve) => {
+				timer = setTimeout(resolve, this.turnTimeoutMs);
+				timer.unref?.();
+			}),
+			clear: () => {
+				if (timer !== void 0) clearTimeout(timer);
+				timer = void 0;
+			}
+		};
 	}
-	clearTurnDeadline() {
-		if (this.turnTimer !== void 0) {
-			clearTimeout(this.turnTimer);
-			this.turnTimer = void 0;
-		}
+	/** The cap in whole minutes, for `/status` and the timeout reply. */
+	get turnTimeoutMinutes() {
+		return Math.max(1, Math.round(this.turnTimeoutMs / 6e4));
+	}
+	turnTimeoutText() {
+		return `本轮执行超时（${this.turnTimeoutMinutes} 分钟），已取消。请重试或拆分任务。`;
 	}
 	/** Close all sessions and the harness (daemon shutdown). */
 	async close() {
 		this.closed = true;
+		for (const timer of this.stopEscalations.values()) clearTimeout(timer);
+		this.stopEscalations.clear();
+		const forwarders = [...this.cronForwarders.values()];
+		this.cronForwarders.clear();
+		for (const forwarder of forwarders) {
+			forwarder.unsubscribe();
+			forwarder.relay.dispose();
+		}
 		const sessions = [...this.sessions.values()];
 		this.sessions.clear();
 		for (const session of sessions) await session.close().catch(() => {});
@@ -2066,26 +2637,54 @@ var LineSessionDriver = class {
 		const turnPromise = new Promise((resolve) => {
 			resolveTurn = resolve;
 		});
+		let stopRequested = false;
+		let requestStop;
+		const stopPromise = new Promise((resolve) => {
+			requestStop = () => {
+				stopRequested = true;
+				resolve();
+			};
+		});
 		const collector = new LineTurnCollector(resolveTurn);
 		const unsubscribe = session.onEvent((event) => {
 			collector.handleEvent(event);
 		});
+		const registration = {
+			sessionKey: job.sessionKey,
+			stop: requestStop
+		};
+		this.activeTurns.set(job.sessionKey, registration);
+		const deadline = this.turnDeadline();
 		try {
 			session.prompt(buildPromptParts(job)).catch((error) => {
 				promptError = error;
 				resolveTurn();
 			});
-			await Promise.race([turnPromise, this.turnDeadline()]);
+			await Promise.race([
+				turnPromise,
+				deadline.promise,
+				stopPromise
+			]);
+			if (stopRequested) {
+				await session.cancel().catch(() => {});
+				return {
+					ok: false,
+					text: "",
+					silent: true
+				};
+			}
 			if (!collector.ended) {
 				await session.cancel().catch(() => {});
 				return {
 					ok: false,
-					text: TURN_TIMEOUT_TEXT
+					text: this.turnTimeoutText()
 				};
 			}
 		} finally {
+			if (this.activeTurns.get(job.sessionKey) === registration) this.activeTurns.delete(job.sessionKey);
+			this.clearStopEscalation(job.sessionKey);
 			unsubscribe();
-			this.clearTurnDeadline();
+			deadline.clear();
 		}
 		if (promptError !== void 0 && isOrphanedToolCallError(promptError)) {
 			log.warn("line: resetting session after tool call mismatch", {
@@ -2133,6 +2732,13 @@ var LineSessionDriver = class {
 	* Waits for in-flight turns to finish (bounded), so a shutdown does not cut a
 	* reply mid-flight. Only the per-chat queues are awaited.
 	*/
+	/** How many turns are queued or running. Read by the shutdown path so a
+	*  timed-out drain is reported instead of looking like a clean exit. */
+	pendingTurnCount() {
+		let total = 0;
+		for (const queue of this.queues.values()) total += queue.pending;
+		return total;
+	}
 	async waitIdle(timeoutMs) {
 		this.closed = true;
 		const chains = [...[...this.queues.values()].map((queue) => queue.chain.catch(() => {})), ...[...this.sessionCreations.values()].map((creation) => creation.then(() => {}).catch(() => {}))];
@@ -2203,6 +2809,64 @@ var LineSessionDriver = class {
 		}
 	}
 	/** Registers the channel's outbound-media sender for one chat. */
+	/** Wired once by the daemon after the platforms are up. */
+	setProactiveSender(sender) {
+		this.proactiveSender = sender;
+	}
+	/**
+	* Watches one session for `cron.fired`.
+	*
+	* A scheduled task runs inside the session, not through `submit()`, so this
+	* subscription is the only path that carries its output back to the chat.
+	*/
+	attachCronForwarder(sessionKey, session) {
+		this.stopCronForwarder(sessionKey);
+		const relay = new CronRelay({
+			send: (text) => this.proactiveSender?.(sessionKey, text) ?? Promise.resolve("no-target"),
+			isBusy: () => this.activeTurns.has(sessionKey),
+			collectTimeoutMs: this.turnTimeoutMs
+		});
+		let pendingStart;
+		let cronTurnId;
+		const unsubscribe = session.onEvent((event) => {
+			if (event.type === "turn.started") {
+				pendingStart = event;
+				if (event.agentId === "main") cronTurnId = event.origin.kind === "cron_job" ? event.turnId : void 0;
+				relay.onEvent(event);
+				return;
+			}
+			if (event.type === "turn.ended") {
+				pendingStart = void 0;
+				if (event.turnId === cronTurnId) cronTurnId = void 0;
+				relay.onEvent(event);
+				return;
+			}
+			if (event.type === "cron.fired") {
+				if (event.agentId !== "main") return;
+				if (event.origin.mute === true) return;
+				relay.onFire(event.origin.silent === true ? null : buildCronReminderChip(event).text, pendingStart, event.origin.silent === true ? void 0 : buildCronFailureNotice(event));
+				return;
+			}
+			relay.onEvent(event);
+		});
+		this.cronForwarders.set(sessionKey, {
+			unsubscribe,
+			relay,
+			isCronTurnRunning: () => cronTurnId !== void 0
+		});
+	}
+	stopCronForwarder(sessionKey) {
+		const entry = this.cronForwarders.get(sessionKey);
+		if (entry === void 0) return;
+		entry.unsubscribe();
+		entry.relay.dispose();
+		this.cronForwarders.delete(sessionKey);
+	}
+	/** Wired once by the daemon; covers sessions whose per-message sender is gone
+	*  (scheduled tasks, after `/stop`, after a restart). */
+	setMediaSenderResolver(resolver) {
+		this.mediaSenderResolver = resolver;
+	}
 	setMediaSender(sessionKey, sender) {
 		this.mediaSenders.set(sessionKey, sender);
 	}
@@ -2214,7 +2878,11 @@ var LineSessionDriver = class {
 		};
 		return runLineCommand$1(text, {
 			defaultModel: this.defaultModel,
-			isBusy: () => (this.queues.get(sessionKey)?.pending ?? 0) > 0,
+			isBusy: () => (this.queues.get(sessionKey)?.pending ?? 0) > 0 || (this.cronForwarders.get(sessionKey)?.relay.isCollecting() ?? false),
+			stopTurn: () => this.stopActiveTurn(sessionKey),
+			cancelSession: () => this.cancelSession(sessionKey),
+			voiceStatus: describeVoiceSupport(this.voiceSupport),
+			turnTimeoutMinutes: this.turnTimeoutMinutes,
 			getSession: () => this.resolveSession(sessionKey),
 			resetSession: () => this.resetSession(sessionKey),
 			commands: this.options.commands ?? [],
@@ -2272,12 +2940,14 @@ var LineSessionDriver = class {
 		const session = await this.getOrCreateSession(harness, sessionKey, workDir, permission, planMode);
 		this.sessions.set(sessionKey, session);
 		this.sessionKeyBySessionId.set(session.id, sessionKey);
+		this.attachCronForwarder(sessionKey, session);
 		await this.applyChannelPrompt(session);
 		return session;
 	}
 	/** Drops the chat's session so the next message starts a fresh one. */
 	async resetSession(sessionKey) {
 		this.resetting.add(sessionKey);
+		this.stopCronForwarder(sessionKey);
 		try {
 			const queue = this.queues.get(sessionKey);
 			if (queue !== void 0) {
@@ -2340,7 +3010,7 @@ var LineSessionDriver = class {
 			isError: true
 		};
 		const sessionKey = request.sessionId === void 0 ? void 0 : this.sessionKeyBySessionId.get(request.sessionId);
-		const sender = sessionKey === void 0 ? void 0 : this.mediaSenders.get(sessionKey);
+		const sender = sessionKey === void 0 ? void 0 : this.mediaSenders.get(sessionKey) ?? this.mediaSenderResolver?.(sessionKey);
 		if (sender === void 0) return {
 			output: "当前会话没有可用的发送通道（该工具仅在 IM 会话中可用）。",
 			isError: true
@@ -3077,6 +3747,41 @@ var WeixinPlatform = class {
 	}
 	/** Reply text to a peer; chunked, fence-aware, throttle fail-fast. */
 	/**
+	* Sends text to the peer that owns this session with no inbound message to
+	* reply to — the scheduled-task path. WeChat requires a `context_token`,
+	* cached from the last inbound message; without one there is nothing we can
+	* legally address, so this reports `no-target` instead of failing a send.
+	*/
+	async sendProactive(sessionKey, text) {
+		const body = text.trim();
+		if (body === "") return "no-target";
+		const target = this.latestTargets.get(sessionKey);
+		const peer = target?.peerUserId;
+		if (peer === void 0) {
+			log.warn("line-weixin: no peer recorded for proactive send", { sessionKey });
+			return "no-target";
+		}
+		const token = (target?.contextToken ?? "").trim() || (this.contextTokens.get(peer) ?? "");
+		if (token === "") {
+			log.warn("line-weixin: no context_token for proactive send (user must message first)", { sessionKey });
+			return "no-target";
+		}
+		try {
+			const chunks = splitMessageCodeFenceAware(body);
+			for (let i = 0; i < chunks.length; i++) {
+				if (i > 0) await sleep(100);
+				await this.client.sendText(peer, chunks[i] ?? "", token, this.client.newClientId());
+			}
+			return "sent";
+		} catch (error) {
+			log.warn("line-weixin: proactive send failed", {
+				sessionKey,
+				error: String(error)
+			});
+			return "failed";
+		}
+	}
+	/**
 	* Sends a local image or file to the chat that owns this session: upload to
 	* the CDN (AES-128-ECB), then `sendmessage` with the media item. Ported from
 	* the reference `SendImage`/`SendFile`.
@@ -3136,6 +3841,11 @@ var WeixinPlatform = class {
 			}
 		};
 		await this.client.sendMediaItem(target.peerUserId, target.contextToken, this.client.newClientId(), item);
+		if (effectiveKind === "voice") log.warn("line: voice submitted without delivery receipt", {
+			sessionKey,
+			bytes: data.length,
+			note: "gateway ret=0 is not a delivery confirmation"
+		});
 		return note;
 	}
 	/** Indirection so tests can exercise the ffmpeg-missing fallback. */
@@ -3255,6 +3965,24 @@ function sleep(ms) {
 	});
 }
 //#endregion
+//#region src/line/notices.ts
+/**
+* Short receipts the IM channels send outside a turn's own reply.
+*
+* Kept apart from the routers so the wording has one home: the same sentence is
+* sent from the Feishu and WeChat paths, and both need to answer the two
+* questions a silent queue leaves open — "did you get my message" and "can I get
+* out of this".
+*/
+/**
+* Sent when a message had to wait behind a running turn.
+*
+* @param position how many turns are ahead of this message (1 = one running).
+*/
+function queuedNotice(position) {
+	return `收到，前面还有 ${position} 条在处理中。回复 /stop 可中止当前任务。`;
+}
+//#endregion
 //#region src/line/daemon.ts
 /**
 * Line daemon entry point (`scream line`).
@@ -3270,12 +3998,21 @@ function sleep(ms) {
 * indicator) — all platform-specific behavior lives in the platform modules.
 */
 const GROUP_FILTER_RETRY_INTERVAL_MS = 300 * 1e3;
-const SHUTDOWN_GRACE_MS = 1e4;
+/**
+* How long a shutdown waits for the in-flight turn to finish before forcing an
+* exit. Ten seconds used to be enough in theory but cut real turns mid-tool, so
+* the window matches a slow tool call; the wait is announced on stderr.
+*/
+const SHUTDOWN_GRACE_MS = 6e4;
+/** `daemon.log` is read long after the fact, so every line carries a stamp. */
+function stamp() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
 function out$1(message) {
-	process.stdout.write(`${message}\n`);
+	process.stdout.write(`${stamp()} ${message}\n`);
 }
 function err(message) {
-	process.stderr.write(`${message}\n`);
+	process.stderr.write(`${stamp()} ${message}\n`);
 }
 /** Run the daemon in the foreground; resolves on graceful shutdown. */
 async function runLineDaemon() {
@@ -3302,12 +4039,17 @@ async function runLineDaemon() {
 		process.exitCode = 1;
 		return;
 	}
+	const resolvedWorkDir = lineConfig.workDir ?? process.cwd();
+	if (lineConfig.workDir === void 0) err(`警告（line）：配置未设置 workDir，本次以启动目录作为工作目录：${resolvedWorkDir}（建议在 /line 向导里固定它）`);
+	else out$1(`工作目录：${resolvedWorkDir}`);
 	const driver = new LineSessionDriver({
 		permissionMode: lineConfig.permissionMode,
 		workDir: lineConfig.workDir,
 		platform: lineConfig.feishu !== void 0 ? "feishu" : "weixin",
-		commands: resolveCustomCommands(lineConfig.commands)
+		commands: resolveCustomCommands(lineConfig.commands),
+		turnTimeoutMs: resolveTurnTimeoutMs(lineConfig)
 	});
+	out$1(`单轮上限：${Math.round(resolveTurnTimeoutMs(lineConfig) / 6e4)} 分钟（config.json 的 turnTimeoutMinutes）`);
 	const handles = [];
 	const failures = [];
 	let shuttingDown = false;
@@ -3315,6 +4057,7 @@ async function runLineDaemon() {
 		if (shuttingDown) return;
 		shuttingDown = true;
 		log.info("line: shutting down", { signal });
+		err(`正在等待当前回合结束（最多 ${SHUTDOWN_GRACE_MS / 1e3}s），收到再次信号将立即退出`);
 		const forceTimer = setTimeout(() => {
 			err(`line: shutdown exceeded ${SHUTDOWN_GRACE_MS / 1e3}s, forcing exit`);
 			process.exit(1);
@@ -3350,6 +4093,7 @@ async function runLineDaemon() {
 		await gracefulShutdown(handles, driver);
 		process.exit(1);
 	}
+	await driver.probeVoice();
 	if (lineConfig.feishu) try {
 		handles.push(await startFeishu(lineConfig.feishu, driver));
 	} catch (error) {
@@ -3360,6 +4104,19 @@ async function runLineDaemon() {
 	} catch (error) {
 		failures.push(`微信：${error instanceof Error ? error.message : String(error)}`);
 	}
+	const proactivePlatforms = new Map(handles.map((handle) => [handle.name, handle]));
+	driver.setProactiveSender(async (sessionKey, text) => {
+		const name = sessionKey.startsWith("line-feishu-") ? "feishu" : sessionKey.startsWith("line-weixin-") ? "weixin" : void 0;
+		const platform = name === void 0 ? void 0 : proactivePlatforms.get(name);
+		if (platform === void 0) return "no-target";
+		return platform.sendProactive(sessionKey, text);
+	});
+	driver.setMediaSenderResolver((sessionKey) => {
+		const name = sessionKey.startsWith("line-feishu-") ? "feishu" : sessionKey.startsWith("line-weixin-") ? "weixin" : void 0;
+		const platform = name === void 0 ? void 0 : proactivePlatforms.get(name);
+		if (platform === void 0) return void 0;
+		return (kind, path) => platform.sendMedia(sessionKey, kind, path);
+	});
 	for (const failure of failures) err(`平台启动失败：${failure}`);
 	if (handles.length === 0) {
 		err("所有平台启动失败，line 守护进程退出。");
@@ -3387,20 +4144,29 @@ async function startFeishu(cfg, driver) {
 	const platform = new FeishuPlatform(client, options, async (message) => {
 		try {
 			driver.setMediaSender(message.sessionKey, (kind, path) => platform.sendMedia(message.sessionKey, kind, path));
-			const outbound = buildReplyContent(truncateForLine((await driver.submit({
+			const outcome = await driver.submit({
 				sessionKey: message.sessionKey,
 				text: message.text,
 				images: message.images,
-				files: message.files
-			})).text));
+				files: message.files,
+				onQueued: (position) => {
+					const notice = buildReplyContent(queuedNotice(position));
+					client.reply(message.context.messageId, notice.msgType, notice.body).catch((error) => {
+						log.warn("line: feishu queued notice failed", { error: String(error) });
+					});
+				}
+			});
+			if (outcome.silent === true) return;
+			const outbound = buildReplyContent(truncateForLine(outcome.text));
 			await client.reply(message.context.messageId, outbound.msgType, outbound.body);
 		} catch (error) {
 			log.error("line: feishu reply failed", {
 				messageId: message.context.messageId,
 				error: String(error)
 			});
+		} finally {
+			await platform.finishMessage(message.context.messageId).catch(() => {});
 		}
-		await platform.finishMessage(message.context.messageId).catch(() => {});
 	});
 	await client.connect(async (event) => {
 		try {
@@ -3422,6 +4188,8 @@ async function startFeishu(cfg, driver) {
 	});
 	return {
 		name: "feishu",
+		sendProactive: (sessionKey, text) => platform.sendProactive(sessionKey, text),
+		sendMedia: (sessionKey, kind, path) => platform.sendMedia(sessionKey, kind, path),
 		close: async () => {
 			platform.stop();
 			await client.close();
@@ -3441,8 +4209,14 @@ async function startWeixin(cfg, driver) {
 				sessionKey: message.sessionKey,
 				text: message.text,
 				images: message.images,
-				files: message.files
+				files: message.files,
+				onQueued: (position) => {
+					platform.replyText(message.context, queuedNotice(position)).catch((error) => {
+						log.warn("line: weixin queued notice failed", { error: String(error) });
+					});
+				}
 			});
+			if (outcome.silent === true) return;
 			await platform.replyText(message.context, outcome.text);
 		} catch (error) {
 			log.error("line: weixin reply failed", {
@@ -3459,6 +4233,8 @@ async function startWeixin(cfg, driver) {
 	log.info("line: weixin platform started", { baseUrl: options.baseUrl });
 	return {
 		name: "weixin",
+		sendProactive: (sessionKey, text) => platform.sendProactive(sessionKey, text),
+		sendMedia: (sessionKey, kind, path) => platform.sendMedia(sessionKey, kind, path),
 		close: async () => {
 			await platform.stop();
 		}
@@ -3502,6 +4278,11 @@ function scheduleGroupFilterSupervisor(client) {
 }
 async function gracefulShutdown(handles, driver) {
 	await driver.waitIdle(SHUTDOWN_GRACE_MS).catch(() => {});
+	const abandoned = driver.pendingTurnCount();
+	if (abandoned > 0) {
+		log.warn("line: shutdown timed out with pending turns", { pending: abandoned });
+		err(`警告：仍有 ${abandoned} 个回合未完成，退出后这些消息不会有回复`);
+	}
 	for (const handle of handles) try {
 		await handle.close();
 	} catch {}
@@ -5413,121 +6194,6 @@ var EditorKeyboardController = class {
 	}
 };
 //#endregion
-//#region src/tui/utils/child-request-notice.ts
-const CHILD_REQUEST_KINDS = [
-	"info",
-	"handoff",
-	"escalate"
-];
-/**
-* Longest previewed value kept on one row. The kernel allows 8192 chars
-* (`contact-parent.ts`); the ticker is one terminal line, so anything longer is
-* cut here and the full text remains reachable via the agent card.
-*/
-const TEXT_PREVIEW = 200;
-/**
-* Collapse the request onto previewable single-paragraph form.
-*
-* The text comes from a child agent's model output, i.e. untrusted input that
-* is about to be written into a terminal row: control sequences (CSI/OSC/DCS —
-* screen clears, cursor moves, OSC 52 clipboard writes) are stripped first, the
-* same way shell output is sanitized elsewhere. The cap counts code points, not
-* UTF-16 units, so a surrogate pair is never split into a replacement glyph.
-*/
-function previewText(value) {
-	const flattened = sanitizeShellOutput(value).replaceAll(/\s*\n\s*/g, " ").trim();
-	const codePoints = Array.from(flattened);
-	return codePoints.length > TEXT_PREVIEW ? `${codePoints.slice(0, TEXT_PREVIEW).join("")}…` : flattened;
-}
-function kindOf(raw) {
-	return typeof raw === "string" && CHILD_REQUEST_KINDS.includes(raw) ? raw : "info";
-}
-function textOf(raw) {
-	if (typeof raw !== "string") return void 0;
-	const trimmed = raw.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
-/**
-* Live producer: the delivery event the kernel emits once a request landed in
-* the parent's turn. Events cross the wire as untyped JSON, so every field is
-* re-checked here rather than trusted from the declared type.
-*/
-function childRequestFieldsFromEvent(event) {
-	const record = event;
-	const message = textOf(record["message"]);
-	if (message === void 0) return null;
-	const listOf = (key) => {
-		const raw = record[key];
-		if (!Array.isArray(raw)) return void 0;
-		const items = raw.map((item) => textOf(item)).filter((item) => item !== void 0);
-		return items.length > 0 ? items : void 0;
-	};
-	return {
-		requestType: kindOf(record["requestType"]),
-		message,
-		needs: textOf(record["needs"]),
-		expecting: textOf(record["expecting"]),
-		artifacts: listOf("artifacts"),
-		evidence: listOf("evidence"),
-		missing: listOf("missing")
-	};
-}
-//#endregion
-//#region src/tui/utils/cron-chip.ts
-/**
-* Scheduled-task reminder → one-line status chip.
-*
-* A fired cron task already owns a transcript block (`CronMessageComponent`) and
-* a turn. The status bar adds the *live* signal: the reminder is time-sensitive,
-* so it must be visible above the editor for a few seconds even when the user is
-* looking at the input box, not the transcript.
-*
-* Copy follows the shared chip grammar `<symbol> <label>：<value>` — the symbol
-* lives in the copy, the colour comes from the caller (`accent` for a normal
-* fire, `warning` for a stale/overdue one).
-*/
-/** Longest task prompt shown on the row. The full text stays in the transcript
-*  block, so the chip only needs enough words to recognise the task. */
-const CRON_PREVIEW_CHARS = 40;
-function shorten(value, max) {
-	const codePoints = Array.from(value);
-	return codePoints.length > max ? `${codePoints.slice(0, max - 1).join("")}…` : value;
-}
-/**
-* Build the chip for one `cron.fired` delivery.
-*
-* `previewText` runs first: the prompt is model/tool-authored text about to be
-* written into a terminal row, so control sequences are stripped and newlines
-* collapse before the length cap is applied.
-*
-* Precedence, most notable first:
-*   stale (7-day cutoff) → coalesced (missed theoretical fires) → one-shot →
-*   plain recurring fire.
-*/
-function buildCronReminderChip(event) {
-	const origin = event.origin;
-	const preview = shorten(previewText(event.prompt), CRON_PREVIEW_CHARS) || origin.cron;
-	if (origin.stale) return {
-		text: t("status.cron_stale", { preview }),
-		tone: "missed"
-	};
-	if (origin.coalescedCount > 1) return {
-		text: t("status.cron_fired_coalesced", {
-			count: String(origin.coalescedCount),
-			preview
-		}),
-		tone: "fired"
-	};
-	if (!origin.recurring) return {
-		text: t("status.cron_once", { preview }),
-		tone: "fired"
-	};
-	return {
-		text: t("status.cron_fired", { preview }),
-		tone: "fired"
-	};
-}
-//#endregion
 //#region src/tui/utils/background-agent-status.ts
 const MAX_BACKGROUND_FIELD_LENGTH = 240;
 function normalizeBackgroundField(value) {
@@ -19536,7 +20202,7 @@ var ScreamTUI = class {
 		const card = new OnboardingCardComponent({
 			colors: this.state.theme.colors,
 			onConfigure: () => {
-				import("./dispatch-CB9ZdDBD.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
+				import("./dispatch-DNYdiEo4.mjs").then(({ handleConnectCommand }) => handleConnectCommand(this, "")).finally(() => {
 					this.restoreEditor();
 					onDone?.();
 				});