scream-code 0.15.1 → 0.15.2

package/dist/{dispatch-ATQMQq1p.mjs → dispatch-B_ViYZer.mjs}

@@ -34205,14 +34205,27 @@ function convertMediaUrl(url, fallbackMimeType) {
 function createAbortError() {
 	return new DOMException("The operation was aborted.", "AbortError");
 }
-async function abortPromise(signal) {
-	if (signal === void 0) return new Promise(() => {});
+/**
+* Race async work against an abort signal, ALWAYS detaching the listener.
+* The Google GenAI SDK does not accept an AbortSignal, so callers race the
+* SDK call against the signal manually. A bare `addEventListener({ once })`
+* inside a losing promise leaks the listener on the caller's signal for the
+* rest of its lifetime - with a session-scoped signal that accumulates one
+* listener per request. This wrapper guarantees cleanup in both outcomes.
+*/
+async function abortRace(signal, work) {
+	if (signal === void 0) return work;
 	if (signal.aborted) throw createAbortError();
-	return new Promise((_, reject) => {
-		signal.addEventListener("abort", () => {
-			reject(createAbortError());
-		}, { once: true });
+	let onAbort = void 0;
+	const abortPromise = new Promise((_, reject) => {
+		onAbort = () => reject(createAbortError());
+		signal.addEventListener("abort", onAbort, { once: true });
 	});
+	try {
+		return await Promise.race([work, abortPromise]);
+	} finally {
+		if (onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+	}
 }
 function messageToGoogleGenAI(message) {
 	if (message.role === "tool") throw new ChatProviderError("Tool messages must be converted via messagesToGoogleGenAIContents.");
@@ -34582,8 +34595,8 @@ var GoogleGenAIChatProvider = class {
 				contents,
 				config
 			};
-			if (this._stream) return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContentStream(params), abortPromise(options?.signal)]), true, options?.signal);
-			return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContent(params), abortPromise(options?.signal)]), false, options?.signal);
+			if (this._stream) return new GoogleGenAIStreamedMessage(await abortRace(options?.signal, models.generateContentStream(params)), true, options?.signal);
+			return new GoogleGenAIStreamedMessage(await abortRace(options?.signal, models.generateContent(params)), false, options?.signal);
 		} catch (error) {
 			if (error instanceof DOMException && error.name === "AbortError") throw error;
 			throw convertGoogleGenAIError(error);
@@ -53403,6 +53416,17 @@ var MemoryMemoStore = class MemoryMemoStore {
 	async append(entry) {
 		return this.withWriteLock(() => this.appendInternal(entry));
 	}
+	/**
+	* True when a memo with the same source session + user need + approach
+	* already exists. Used by compaction-summary recovery to re-store memos
+	* idempotently after a crash between compaction apply and extraction.
+	* The approach field keeps two distinct memos that happen to share the
+	* same user need from being collapsed into one.
+	*/
+	existsBySourceAndNeed(sourceSessionId, userNeed, approach) {
+		if (this.db === void 0) return false;
+		return this.db.prepare("SELECT 1 FROM memos WHERE source_session_id = ? AND user_need = ? AND approach = ? LIMIT 1").get(sourceSessionId, userNeed, approach) !== void 0;
+	}
 	/** Delete a memo by id. */
 	async delete(id) {
 		return this.withWriteLock(() => this.deleteInternal(id));
@@ -79164,6 +79188,31 @@ function extractPreviousSummary(history) {
 	const text = head.content.filter((p) => p.type === "text").map((p) => p.text).join("");
 	return text.length > 0 ? text : null;
 }
+/**
+* Crash-recovery path for compaction memos. `context.apply_compaction` is
+* written to wire before the extraction step runs; if the process dies in
+* that window the memos are lost forever (nothing re-extracts them). On wire
+* replay the summary is available again, so re-parse it and store anything
+* missing. Idempotent: a healthy replay finds the memos already stored
+* (existsBySourceAndNeed) and skips them, so recovery never duplicates.
+*/
+async function recoverMemosFromCompactionSummary(agent, summary) {
+	const memoStore = agent.memoStore;
+	if (!memoStore || summary === void 0 || summary.trim().length === 0) return;
+	const memos = parseMemoryMemos(summary);
+	if (memos.length === 0) return;
+	const sessionId = agent.homedir ? basename$1(dirname$2(dirname$2(agent.homedir))) : "unknown";
+	const sessionTitle = await agent.getSessionTitle().catch(() => void 0);
+	const projectDir = agent.config.cwd;
+	const failed = (await Promise.allSettled(memos.map(async (memo) => {
+		if (memoStore.existsBySourceAndNeed(sessionId, memo.userNeed, memo.approach)) return;
+		memo.sourceSessionId = sessionId;
+		memo.sourceSessionTitle = sessionTitle ?? "";
+		memo.projectDir = projectDir;
+		await memoStore.append(memo);
+	}))).filter((result) => result.status === "rejected").length;
+	if (failed > 0) agent.log.warn("Some recovered memory memos failed to store", { failed });
+}
 //#endregion
 //#region ../../packages/agent-core/src/flags/registry.ts
 /**
@@ -84844,6 +84893,7 @@ var FileSystemAgentRecordPersistence = class {
 	pendingRecords = [];
 	shouldClear = false;
 	directorySynced = false;
+	rewriteSeq = 0;
 	flushPromise;
 	error;
 	constructor(filePath, options = {}) {
@@ -84953,7 +85003,21 @@ var FileSystemAgentRecordPersistence = class {
 		const content = (this.options.blobStore !== void 0 ? await Promise.all(batch.map((record) => this.options.blobStore.offload(record))) : batch).map((e) => JSON.stringify(e) + "\n").join("");
 		const directory = dirname$2(this.filePath);
 		await mkdir(directory, { recursive: true });
-		const fh = await open(this.filePath, shouldClear ? "w" : "a");
+		if (shouldClear) {
+			const tmpPath = `${this.filePath}.${process.pid}.${this.rewriteSeq++}.tmp`;
+			const tmp = await open(tmpPath, "w");
+			try {
+				if (content.length > 0) await tmp.writeFile(content, "utf8");
+				await tmp.sync();
+			} finally {
+				await tmp.close();
+			}
+			await rename(tmpPath, this.filePath);
+			await syncDir(directory);
+			this.directorySynced = true;
+			return;
+		}
+		const fh = await open(this.filePath, "a");
 		try {
 			if (content.length > 0) await fh.writeFile(content, "utf8");
 			await fh.sync();
@@ -85310,6 +85374,7 @@ function restoreAgentRecord(agent, input) {
 			return;
 		case "context.apply_compaction":
 			agent.context.applyCompaction(input);
+			recoverMemosFromCompactionSummary(agent, input.summary);
 			return;
 		case "context.snapshot":
 			agent.context.restoreJSONSnapshot(input.snapshot);
@@ -85406,11 +85471,19 @@ var AgentRecords = class {
 			snapshotIndex = i;
 			break;
 		}
+		let foldedCompactionSummary;
 		for (let i = 0; i < replayedRecords.length; i++) {
 			const record = replayedRecords[i];
 			if (!record) continue;
-			if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) continue;
+			if (i < snapshotIndex && isSnapshotFoldedContextRecord(record.type)) {
+				if (record.type === "context.apply_compaction") foldedCompactionSummary = record.summary;
+				continue;
+			}
 			this.restore(record);
+			if (record.type === "context.snapshot" && foldedCompactionSummary !== void 0) {
+				recoverMemosFromCompactionSummary(this.agent, foldedCompactionSummary);
+				foldedCompactionSummary = void 0;
+			}
 		}
 		this.agent.context.dropVacuousOpenMessages();
 		if (shouldRewrite) {
@@ -105566,6 +105639,9 @@ var SessionSubagentHost = class {
 	backgroundTaskTimeoutMs;
 	modelBindings;
 	activeChildren = /* @__PURE__ */ new Map();
+	/** Per-child per-model usage already folded into the parent totals, so a
+	* resumed child's aggregation only adds the delta. */
+	aggregatedChildUsage = /* @__PURE__ */ new WeakMap();
 	constructor(session, ownerAgentId, backgroundTaskTimeoutMs, modelBindings) {
 		this.session = session;
 		this.ownerAgentId = ownerAgentId;
@@ -105709,6 +105785,21 @@ var SessionSubagentHost = class {
 				result = lastAssistantText$1(child);
 			}
 			const usage = child.usage.data().total;
+			const childByModel = child.usage.data().byModel ?? {};
+			const previous = this.aggregatedChildUsage.get(child) ?? {};
+			for (const [model, childUsage] of Object.entries(childByModel)) {
+				const delta = previous[model] === void 0 ? childUsage : subtractUsage(childUsage, previous[model]);
+				if (isZeroUsage(delta)) continue;
+				try {
+					parent.usage.record(model, delta, "session");
+				} catch (error) {
+					parent.log.warn("Failed to aggregate subagent usage", {
+						model,
+						error: String(error)
+					});
+				}
+			}
+			this.aggregatedChildUsage.set(child, childByModel);
 			let findingsBlock = "";
 			if (profileName === "reviewer") {
 				const findings = getFindingsFromStore(child.tools.toolStore);
@@ -105813,6 +105904,18 @@ var SessionSubagentHost = class {
 		});
 	}
 };
+/** Element-wise subtraction clamped at zero (usage can never go negative). */
+function subtractUsage(current, previous) {
+	return {
+		inputOther: Math.max(0, current.inputOther - previous.inputOther),
+		output: Math.max(0, current.output - previous.output),
+		inputCacheRead: Math.max(0, current.inputCacheRead - previous.inputCacheRead),
+		inputCacheCreation: Math.max(0, current.inputCacheCreation - previous.inputCacheCreation)
+	};
+}
+function isZeroUsage(usage) {
+	return usage.inputOther === 0 && usage.output === 0 && usage.inputCacheRead === 0 && usage.inputCacheCreation === 0;
+}
 async function runChildTurnToCompletion(child, signal) {
 	const completion = await child.turn.waitForCurrentTurn(signal);
 	const turnEnded = completion.event;
@@ -123049,28 +123152,24 @@ var ScreamCore = class {
 		return this.config;
 	}
 	async setScreamConfig(input) {
-		return this.enqueueConfigMutation(async () => {
-			const config = mergeConfigPatch(readConfigFile(this.configPath), input);
-			await writeConfigFile(this.configPath, config);
-			return this.config = loadRuntimeConfig(this.configPath);
-		});
+		const config = mergeConfigPatch(readConfigFile(this.configPath), input);
+		await writeConfigFile(this.configPath, config);
+		return this.config = loadRuntimeConfig(this.configPath);
 	}
 	async removeScreamProvider(input) {
-		return this.enqueueConfigMutation(async () => {
-			const config = readConfigFile(this.configPath);
-			delete config.providers[input.providerId];
-			let removedDefault = false;
-			const existingModels = config.models ?? {};
-			for (const [key, model] of Object.entries(existingModels)) if (typeof model === "object" && model !== null && !Array.isArray(model) && model["provider"] === input.providerId) {
-				delete existingModels[key];
-				if (config.defaultModel === key) removedDefault = true;
-			}
-			config.models = existingModels;
-			if (removedDefault) config.defaultModel = void 0;
-			if (config.defaultProvider === input.providerId) config.defaultProvider = void 0;
-			await writeConfigFile(this.configPath, config);
-			return this.config = loadRuntimeConfig(this.configPath);
-		});
+		const config = readConfigFile(this.configPath);
+		delete config.providers[input.providerId];
+		let removedDefault = false;
+		const existingModels = config.models ?? {};
+		for (const [key, model] of Object.entries(existingModels)) if (typeof model === "object" && model !== null && !Array.isArray(model) && model["provider"] === input.providerId) {
+			delete existingModels[key];
+			if (config.defaultModel === key) removedDefault = true;
+		}
+		config.models = existingModels;
+		if (removedDefault) config.defaultModel = void 0;
+		if (config.defaultProvider === input.providerId) config.defaultProvider = void 0;
+		await writeConfigFile(this.configPath, config);
+		return this.config = loadRuntimeConfig(this.configPath);
 	}
 	setRuntimeSystemPrompt({ sessionId, ...payload }) {
 		return this.sessionApi(sessionId).setRuntimeSystemPrompt(payload);
@@ -123612,23 +123711,6 @@ var ScreamCore = class {
 	reloadProviderManager() {
 		return this.config = loadRuntimeConfig(this.configPath);
 	}
-	/**
-	* Serialize config-file mutations. Both setScreamConfig and
-	* removeScreamProvider are read-modify-write cycles that read the file
-	* synchronously and then await the write; two calls issued together (e.g.
-	* cycling thinking levels plus confirming a model in the picker fire
-	* back-to-back setConfig patches) would otherwise read the SAME stale
-	* snapshot, and the later write silently reverts the earlier patch — a
-	* lost update that makes e.g. a just-selected default model flip back to
-	* the old one. The queue guarantees each cycle re-reads after the
-	* previous write completed.
-	*/
-	configMutationQueue = Promise.resolve();
-	enqueueConfigMutation(mutate) {
-		const run = this.configMutationQueue.then(mutate, mutate);
-		this.configMutationQueue = run.catch(() => void 0);
-		return run;
-	}
 	async refreshSessionRuntimeConfig(session, config) {
 		const api = new SessionAPIImpl(session);
 		const requested = (await api.getModel({ agentId: "main" })).trim();
@@ -130817,10 +130899,11 @@ async function changeThinkingLevel(host, alias, level) {
 	}
 	const prevLevel = host.state.appState.thinkingLevel;
 	const isActiveModel = alias === host.state.appState.model;
-	const session = host.session;
 	if (isActiveModel && level !== prevLevel) {
+		const session = host.session;
 		try {
-			if (session !== void 0) await session.setThinking(level);
+			if (session === void 0) await host.authFlow.activateModelAfterLogin(alias, level);
+			else await session.setThinking(level);
 		} catch (error) {
 			const msg = formatErrorMessage(error);
 			host.showError(`Failed to set thinking: ${msg}`);
@@ -130836,7 +130919,7 @@ async function changeThinkingLevel(host, alias, level) {
 		host.showError(`Failed to save thinking default: ${msg}`);
 		return;
 	}
-	const status = isActiveModel && level !== prevLevel ? session === void 0 ? persisted ? `No active session - thinking ${level} for ${alias} saved as default.` : `No active session - thinking ${level} was NOT saved (${alias} is not the default model, so its level applies only when a new session selects it).` : `Thinking set to ${level} for ${alias}.` : persisted ? `Saved thinking ${level} as default for ${alias}.` : `Thinking already ${level} for ${alias}.`;
+	const status = isActiveModel && level !== prevLevel ? `Thinking set to ${level} for ${alias}.` : persisted ? `Saved thinking ${level} as default for ${alias}.` : `Thinking already ${level} for ${alias}.`;
 	host.showStatus(status, host.state.theme.colors.success);
 }
 async function persistThinkingDefault(host, alias, level) {
@@ -130865,16 +130948,18 @@ async function performModelSwitch(host, alias, thinkingLevel) {
 	const prevThinkingLevel = host.state.appState.thinkingLevel;
 	const modelChanged = alias !== prevModel;
 	const thinkingChanged = thinkingLevel !== prevThinkingLevel;
-	const session = host.session;
-	const overflow = session !== void 0 && alias !== prevModel ? contextOverflowForModel(host.state.appState, alias) : null;
+	const needsSessionActivation = modelChanged || thinkingChanged;
+	const overflow = alias !== prevModel ? contextOverflowForModel(host.state.appState, alias) : null;
 	if (overflow !== null) {
 		host.showNotice("Storm Breaker（风暴守护者）", `无法切换到模型「${alias}」：当前会话上下文 ${formatTokenCount$1(overflow.currentTokens)} 已超出该模型上限 ${formatTokenCount$1(overflow.maxContextTokens)}。建议先执行 /compact 压缩上下文，或选择上下文窗口更大的模型。`);
 		return;
 	}
+	const session = host.session;
 	let effectiveAlias = alias;
 	let effectiveThinking = thinkingLevel;
 	try {
-		if (session !== void 0) {
+		if (session === void 0 && needsSessionActivation) await host.authFlow.activateModelAfterLogin(alias, thinkingLevel);
+		else if (session !== void 0) {
 			if (modelChanged) await session.setModel(alias);
 			if (thinkingChanged) await session.setThinking(thinkingLevel);
 			const confirmed = await session.getStatus().catch(() => null);
@@ -130897,13 +130982,12 @@ async function performModelSwitch(host, alias, thinkingLevel) {
 		persisted = await persistModelSelection(host, alias, thinkingLevel);
 	} catch (error) {
 		const msg = formatErrorMessage(error);
-		host.showError(`${session === void 0 ? "Selected" : "Switched to"} ${effectiveAlias}, but failed to save default: ${msg}`);
+		host.showError(`Switched to ${effectiveAlias}, but failed to save default: ${msg}`);
 		return;
 	}
 	const hasHistory = host.state.appState.contextTokens > 0;
 	const cacheWarning = modelChanged && hasHistory ? " Note: switching models invalidates the existing prompt cache - use /new to avoid extra token costs." : "";
 	const status = (() => {
-		if (session === void 0 && (modelChanged || thinkingChanged)) return `No active session - ${effectiveAlias} (thinking ${effectiveThinking}) saved as default. It applies when you start a new session.`;
 		if (modelChanged) return `Switched to ${effectiveAlias} with thinking ${effectiveThinking}.${cacheWarning}`;
 		if (thinkingChanged) return `Thinking set to ${effectiveThinking} for ${effectiveAlias}.`;
 		if (persisted) return `Saved ${effectiveAlias} with thinking ${effectiveThinking} as default.`;

package/dist/{dispatch-Doe-DlpL.mjs → dispatch-Dur5jHVw.mjs}

@@ -3,5 +3,5 @@ import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
-import { Kt as handleConnectCommand } from "./dispatch-ATQMQq1p.mjs";
+import { Kt as handleConnectCommand } from "./dispatch-B_ViYZer.mjs";
 export { handleConnectCommand };

package/dist/main.mjs

@@ -6,7 +6,7 @@ const __dirname = __cjsShimDirname(__filename);
 import "./suppress-sqlite-warning-C2VB0doZ.mjs";
 //#region src/main.ts
 try {
-	(await import("./app-C3aR5fdI.mjs")).main();
+	(await import("./app-6Hcxs2tP.mjs")).main();
 } catch (error) {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exit(1);