scream-code 0.15.0 → 0.15.2

package/dist/{dispatch-D8ovLbmr.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;

package/dist/{dispatch-BPcn43Vw.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-D8ovLbmr.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-CPu6R7nd.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);