scream-code 0.16.9 → 0.17.0

package/dist/{dispatch-CIOuINvn.mjs → dispatch-IFcnZsGX.mjs}

@@ -78,6 +78,7 @@ const ErrorCodes = {
 	SESSION_FORK_ACTIVE_TURN: "session.fork_active_turn",
 	SESSION_EXPORT_NOT_FOUND: "session.export_not_found",
 	SESSION_EXPORT_MISSING_VERSION: "session.export_missing_version",
+	SESSION_DELETE_FAILED: "session.delete_failed",
 	SESSION_CLOSED: "session.closed",
 	SESSION_PERMISSION_MODE_INVALID: "session.permission_mode_invalid",
 	SESSION_THINKING_EMPTY: "session.thinking_empty",
@@ -201,6 +202,12 @@ const SCREAM_ERROR_INFO = {
 		public: true,
 		action: "Provide a version when exporting the session."
 	},
+	"session.delete_failed": {
+		title: "Failed to delete session",
+		retryable: true,
+		public: true,
+		action: "Close programs holding files in the session directory (editors, dev servers) and retry."
+	},
 	"session.closed": {
 		title: "Session is closed",
 		retryable: false,
@@ -46194,15 +46201,15 @@ function catalogProviderModels(entry) {
 /**
 * Idle-stream watchdog.
 *
-* Ported from oh-my-pi `packages/ai/src/utils/idle-iterator.ts:154-382`.
 * Reasoning models (deepseek-reasoner, mimo thinking) can sit silent for
 * 30s+ between tokens; without a watchdog the stream hangs forever and the
 * user thinks the agent died. This wraps any async iterable with a per-item
 * idle deadline, turning a stalled stream into a retryable `APITimeoutError`.
 *
-* Simplified from the upstream version: no `armPreResponseTimeout`, no
-* `iterateWithTerminalGrace`, no per-provider env-var aliases. The core
-* racer-reuse and single-timer-self-rearm design is preserved verbatim.
+* Deliberately narrow: no pre-response arming, no terminal grace iteration and
+* no per-provider env-var aliases. The core design — reuse one racer promise
+* across iterations (re-minted every 1024 races to bound retention) and
+* self-rearm a single timer per item — is all this needs.
 */
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 6e4;
 const DEFAULT_STREAM_FIRST_ITEM_TIMEOUT_MS = 12e4;
@@ -46811,6 +46818,33 @@ function extractError(value) {
 	} : { message: value.message };
 }
 //#endregion
+//#region ../../node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
+function uniq(array) {
+	return Array.from(new Set(array));
+}
+function notNullish(v) {
+	return v != null;
+}
+function objectMap(obj, fn) {
+	return Object.fromEntries(Object.entries(obj).map(([k, v]) => fn(k, v)).filter(notNullish));
+}
+function sleep$2(ms, callback) {
+	return new Promise((resolve) => setTimeout(async () => {
+		await callback?.();
+		resolve();
+	}, ms));
+}
+function createControlledPromise() {
+	let resolve, reject;
+	const promise = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	promise.resolve = resolve;
+	promise.reject = reject;
+	return promise;
+}
+//#endregion
 //#region ../../packages/agent-core/src/utils/fs.ts
 /**
 * Low-level POSIX durability primitives.
@@ -46911,6 +46945,50 @@ async function atomicWrite(filePath, content, _syncOverride) {
 		} catch {}
 	}
 }
+/**
+* Error codes that indicate a *transient* removal failure: another handle
+* holds the file or a parent directory right now (Windows keeps files
+* exclusively locked by editors, indexers, dev servers and virus scanners;
+* POSIX sees the same from racing deletions). Retrying with a short backoff
+* turns the common "lock released within a second" case into a success while
+* a genuinely stuck path still surfaces as an error after the budget.
+*/
+const RM_RETRY_CODES = new Set([
+	"EBUSY",
+	"EPERM",
+	"ENOTEMPTY",
+	"EMFILE",
+	"EACCES"
+]);
+const RM_RETRY_BACKOFF_MS = [
+	50,
+	150,
+	400,
+	1e3
+];
+/**
+* rm -rf with bounded retries on transient OS locks. Throws the last error
+* when every attempt fails, and never retries codes outside the transient
+* set. `rmOverride` is a fault-injection seam (same convention as
+* `atomicWrite`'s `_syncOverride`); production callers must never supply it.
+*/
+async function rmWithRetry(target, opts = {}) {
+	const rmImpl = opts.rmOverride ?? rm;
+	const backoff = opts.backoffMs ?? RM_RETRY_BACKOFF_MS;
+	const attempts = opts.attempts ?? backoff.length + 1;
+	for (let attempt = 1;; attempt += 1) try {
+		await rmImpl(target, {
+			recursive: true,
+			force: true
+		});
+		return;
+	} catch (error) {
+		const code = error.code;
+		const backoffMs = backoff[attempt - 1];
+		if (attempt >= attempts || backoffMs === void 0 || code === void 0 || !RM_RETRY_CODES.has(code)) throw error;
+		await sleep$2(backoffMs);
+	}
+}
 //#endregion
 //#region ../../packages/agent-core/src/logging/sinks.ts
 const PENDING_MAX = 1e3;
@@ -47431,33 +47509,6 @@ function ensureScreamHome(homeDir) {
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@antfu+utils@9.3.0/node_modules/@antfu/utils/dist/index.mjs
-function uniq(array) {
-	return Array.from(new Set(array));
-}
-function notNullish(v) {
-	return v != null;
-}
-function objectMap(obj, fn) {
-	return Object.fromEntries(Object.entries(obj).map(([k, v]) => fn(k, v)).filter(notNullish));
-}
-function sleep$2(ms, callback) {
-	return new Promise((resolve) => setTimeout(async () => {
-		await callback?.();
-		resolve();
-	}, ms));
-}
-function createControlledPromise() {
-	let resolve, reject;
-	const promise = new Promise((_resolve, _reject) => {
-		resolve = _resolve;
-		reject = _reject;
-	});
-	promise.resolve = resolve;
-	promise.reject = reject;
-	return promise;
-}
-//#endregion
 //#region ../../packages/agent-core/src/utils/abort.ts
 function abortError() {
 	const error = /* @__PURE__ */ new Error("Aborted");
@@ -47524,6 +47575,15 @@ function createMaxStepsExceededError(maxSteps, message) {
 function isMaxStepsExceededError(error) {
 	return isScreamError(error) && error.code === ErrorCodes.LOOP_MAX_STEPS_EXCEEDED;
 }
+/**
+* Context-window overflow, in both shapes it reaches the loop: the ltod error
+* class thrown by provider adapters, and the `ScreamError(CONTEXT_OVERFLOW)`
+* wrap produced by non-ltod adapters. Both need compaction, never a retry, so
+* retry.ts and the turn-level overflow handler must agree on this predicate.
+*/
+function isContextOverflowError(error) {
+	return error instanceof APIContextOverflowError || isScreamError(error) && error.code === ErrorCodes.CONTEXT_OVERFLOW;
+}
 function isAbortError$1(err) {
 	if (err instanceof Error) return err.name === "AbortError";
 	return false;
@@ -47551,7 +47611,7 @@ async function chatWithRetry(input) {
 	for (let attempt = 1;; attempt += 1) try {
 		return await input.llm.chat(paramsForAttempt(input, attempt, maxAttempts));
 	} catch (error) {
-		if (error instanceof APIContextOverflowError) {
+		if (isContextOverflowError(error)) {
 			logRequestFailure(input, error, attempt, maxAttempts);
 			throw error;
 		}
@@ -52335,9 +52395,8 @@ var AgentTool = class {
 	* When `timeoutMs` is set and background dispatch is available, the wait is
 	* bounded by a race: if the child has not finished by the deadline it is
 	* handed to the background task manager (never aborted) and the caller
-	* receives a `backgrounded` outcome carrying the task id. This mirrors the
-	* reference implementation's foreground-budget → auto-background behaviour:
-	* a timeout degrades the wait, it does not destroy the subagent's work.
+	* receives a `backgrounded` outcome carrying the task id. A timeout degrades
+	* the wait; it does not destroy the subagent's work.
 	*/
 	async awaitForegroundCompletion(handle, description, timeoutMs, childController, unlinkChild) {
 		if (timeoutMs === void 0 || !this.allowBackground || this.backgroundManager === void 0) return {
@@ -53080,11 +53139,10 @@ function formatTokens$2(tokens) {
 * context on every submission. This wastes context budget and can trap the
 * agent in a loop where it keeps retrying without new information.
 *
-* Inspired by oh-my-pi's `advisor/emission-guard.ts`, but adapted for
-* scream-code's grader model: the grader is called once per `complete`
-* submission (not continuously), so per-round limiting is unnecessary. The
-* guard focuses on normalization, content-free filtering, and exact-text
-* deduplication keyed by goal objective.
+* Scope is set by this codebase's grader model: the grader is called once per
+* `complete` submission (not continuously), so per-round limiting is
+* unnecessary. The guard focuses on normalization, content-free filtering,
+* and exact-text deduplication keyed by goal objective.
 */
 /** Short phrases that carry no actionable feedback. */
 const CONTENT_FREE_PHRASES = new Set([
@@ -68401,7 +68459,7 @@ const scanCache = new FsScanCache();
 * and, when found, appends a notice to the read result so the model does not
 * silently edit a file with unresolved conflicts.
 *
-* Marker shape is strict (ported from oh-my-pi `conflict-detect.ts:171-176`):
+* Marker shape is strict:
 * prefix alone, or prefix + single space + label. Lines that merely start
 * with `<` or `=` never match. Only fully-closed blocks (opener + separator
 * + closer all present in the scanned window) are reported — an open block
@@ -84389,6 +84447,10 @@ var AutoModeAskUserQuestionDenyPermissionPolicy = class {
 * unattended in bot mode): reads, in-workspace edits, lookups, planning,
 * coordination requests. Everything outside this allowlist is denied in bot
 * mode (fail-closed) — no ask prompt can reach a human who is not there.
+*
+* This list is intentionally separate from `#/tools/tool-catalog`: bot mode
+* answers "what is reversible unattended", not "what is read-only /
+* executable", so the two classifications must not be merged.
 */
 const REVERSIBLE_TOOLS = new Set([
 	"Read",
@@ -84491,36 +84553,105 @@ var BotModePermissionPolicy = class BotModePermissionPolicy {
 	}
 };
 //#endregion
+//#region ../../packages/agent-core/src/tools/tool-catalog.ts
+/**
+* Single catalog of builtin-tool name sets shared by permission and
+* capability policies. When adding a tool, classify it here once: the
+* subagent capability filter and the default-approve policy both read from
+* this file, so no list has to be synced by hand in two places.
+*
+* `DEFAULT_AUTO_APPROVE_TOOLS` is copied verbatim from the former per-file
+* record (including its legacy `SetTodoList` entry) so behavior is
+* unchanged; the sets are intentionally not re-derived from tool
+* definitions.
+*/
+/** Read-only inspection tools (no workspace mutation, no command execution). */
+const READ_TOOLS = new Set([
+	"AskUserQuestion",
+	"ContactParent",
+	"FetchURL",
+	"Glob",
+	"Grep",
+	"KnowledgeLookup",
+	"LSP",
+	"MemoryLookup",
+	"Read",
+	"ReadGroup",
+	"ReadMediaFile",
+	"ReportFinding",
+	"Skill",
+	"TodoList",
+	"WebSearch"
+]);
+/** Tools that mutate the workspace (files, memory, plans, skills). */
+const WRITE_TOOLS = new Set([
+	"Edit",
+	"InspectOwnAssets",
+	"MakeSkillApply",
+	"MakeSkillPlan",
+	"ManagePlugin",
+	"MemoryEdit",
+	"MemoryWrite",
+	"Write"
+]);
+/** Tools that execute commands. */
+const EXECUTE_TOOLS = new Set(["Bash", "python"]);
+/** Nesting/coordination tools — only `all` mode keeps them. A restricted
+*  child must not be able to spawn an unrestricted grandchild (that would
+*  bypass the tool filtering entirely). WolfPack is batch-spawn sugar over
+*  the same subagent host, so it is filtered too. */
+const NESTING_TOOLS = new Set([
+	"Agent",
+	"SendSubagentMessage",
+	"WolfPack"
+]);
+/** Goal/session-management tools, always available regardless of mode. */
+const CORE_TOOLS = new Set([
+	"CreateGoal",
+	"GetGoal",
+	"SetGoalBudget",
+	"UpdateGoal",
+	"WriteGoalNote",
+	"EnterPlanMode",
+	"ExitPlanMode"
+]);
+/**
+* Tools auto-approved without asking in manual mode, verbatim from the
+* former default-tool-approve record. `SetTodoList` is a legacy name kept
+* as-is: no current tool declares it, and removing it would be a behavior
+* change rather than a refactor.
+*/
+const DEFAULT_AUTO_APPROVE_TOOLS = new Set([
+	"Read",
+	"Grep",
+	"Glob",
+	"ReadMediaFile",
+	"InspectOwnAssets",
+	"SetTodoList",
+	"TodoList",
+	"TaskList",
+	"TaskOutput",
+	"CronList",
+	"WebSearch",
+	"FetchURL",
+	"Agent",
+	"AskUserQuestion",
+	"Skill",
+	"WolfPack",
+	"CreateGoal",
+	"UpdateGoal",
+	"GetGoal",
+	"SetGoalBudget",
+	"WriteGoalNote",
+	"MakeSkillPlan",
+	"MakeSkillApply"
+]);
+//#endregion
 //#region ../../packages/agent-core/src/agent/permission/policies/default-tool-approve.ts
-const DEFAULT_APPROVE_TOOLS = {
-	Read: true,
-	Grep: true,
-	Glob: true,
-	ReadMediaFile: true,
-	InspectOwnAssets: true,
-	SetTodoList: true,
-	TodoList: true,
-	TaskList: true,
-	TaskOutput: true,
-	CronList: true,
-	WebSearch: true,
-	FetchURL: true,
-	Agent: true,
-	AskUserQuestion: true,
-	Skill: true,
-	WolfPack: true,
-	CreateGoal: true,
-	UpdateGoal: true,
-	GetGoal: true,
-	SetGoalBudget: true,
-	WriteGoalNote: true,
-	MakeSkillPlan: true,
-	MakeSkillApply: true
-};
 var DefaultToolApprovePermissionPolicy = class {
 	name = "default-tool-approve";
 	evaluate(context) {
-		if (!DEFAULT_APPROVE_TOOLS[context.toolCall.name]) return;
+		if (!DEFAULT_AUTO_APPROVE_TOOLS.has(context.toolCall.name)) return;
 		return { kind: "approve" };
 	}
 };
@@ -85254,6 +85385,7 @@ var PermissionManager = class {
 		let response;
 		if (this.agent.rpc?.requestApproval) {
 			const approvalId = `approval-${String(++this.nextApprovalId)}`;
+			let timeoutHandle;
 			try {
 				const customPromise = new Promise((resolve, reject) => {
 					this.pendingApprovals.set(approvalId, {
@@ -85276,7 +85408,7 @@ var PermissionManager = class {
 					}, { signal }).then(resolve, reject);
 				});
 				const timeoutPromise = new Promise((_, reject) => {
-					setTimeout(() => {
+					timeoutHandle = setTimeout(() => {
 						reject(/* @__PURE__ */ new Error(`Approval request timed out after ${String(APPROVAL_TIMEOUT_MS)}ms`));
 					}, APPROVAL_TIMEOUT_MS);
 				});
@@ -85286,6 +85418,7 @@ var PermissionManager = class {
 				const resolved = result.resolveError?.(error);
 				return await (resolved === void 0 ? Promise.reject(error) : this.permissionPolicyResolutionToPrepare(resolved, context, policyName));
 			} finally {
+				if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
 				this.pendingApprovals.delete(approvalId);
 			}
 		} else response = {
@@ -95189,7 +95322,6 @@ function abortedToolOutput(toolName, signal) {
 	if (isUserCancellation(signal.reason)) return `The user manually interrupted "${toolName}" (and anything else running at the same time). This was a deliberate user action, not a system error, timeout, or capacity limit. Do not retry automatically or guess at the cause — wait for the user's next instruction.`;
 	return `Tool "${toolName}" was aborted`;
 }
-const executedToolCallBlockIndex = /* @__PURE__ */ new Map();
 /**
 * Record tool calls that arrived in a truncated response (max_tokens,
 * paused, unknown) but were never executed. Each call gets a `tool.call`
@@ -95781,8 +95913,7 @@ function makeErrorToolResult(call, args, output) {
 */
 async function dispatchToolCall(step, call, args, displayFields) {
 	const { toolCall, toolName } = call;
-	const index = executedToolCallBlockIndex.get(step.stepUuid) ?? 0;
-	executedToolCallBlockIndex.set(step.stepUuid, index + 1);
+	const index = step.toolCallBlockIndex.value++;
 	await step.dispatchEvent({
 		type: "block.start",
 		uuid: randomUUID(),
@@ -95850,7 +95981,8 @@ async function executeLoopStep(deps) {
 		turnId,
 		currentStep,
 		stepUuid,
-		hasPendingSteer: deps.hasPendingSteer
+		hasPendingSteer: deps.hasPendingSteer,
+		toolCallBlockIndex: { value: 0 }
 	};
 	await dispatchEvent({
 		type: "step.begin",
@@ -102654,7 +102786,7 @@ var TurnFlow = class {
 					}
 				})).stopReason;
 			} catch (error) {
-				if (error instanceof APIContextOverflowError || isScreamError(error) && error.code === ErrorCodes.CONTEXT_OVERFLOW) {
+				if (isContextOverflowError(error)) {
 					await this.agent.fullCompaction.handleOverflowError(signal, error);
 					continue;
 				}
@@ -102752,19 +102884,17 @@ function parseEnvBudget(raw) {
 /**
 * Compute the effective `max_completion_tokens` cap.
 *
-* Aligned with oh-my-pi's approach: use a reasonable output-token cap
-* instead of the full context window. `max_context_tokens` is the total
-* (input + output) budget, not the output-only budget. Using it as
-* max_tokens tells the API "generate up to 128K output tokens", which is
-* incorrect - the actual max output is much smaller. The API server
-* clamps it to context_window - input_tokens, which shrinks as context
-* grows, causing "max_tokens limit - no tool call" errors on long
-* sessions.
+* Use a reasonable output-token cap rather than the full context window:
+* `max_context_tokens` is the total (input + output) budget, not the
+* output-only budget. Using it as max_tokens tells the API "generate up to
+* 128K output tokens", which is incorrect - the actual max output is much
+* smaller. The API server clamps it to context_window - input_tokens, which
+* shrinks as context grows, causing "max_tokens limit - no tool call" errors
+* on long sessions.
 *
-* The 64K cap matches oh-my-pi's OUTPUT_CAP_WHEN_UNKNOWN and is well
-* above any current model's real output limit (typically 8K-32K), so it
-* never artificially limits output while preventing the context-window
-* value from being used directly.
+* The 64K cap is well above any current model's real output limit (typically
+* 8K-32K), so it never artificially limits output while preventing the
+* context-window value from being used directly.
 */
 const OUTPUT_TOKEN_CAP = 64e3;
 function computeCompletionBudgetCap(args) {
@@ -108195,56 +108325,25 @@ function buildSubagentMessage(fromAgentId, toAgentId, operation, text, overrides
 }
 //#endregion
 //#region ../../packages/agent-core/src/session/subagent-capability.ts
-/** Read-only inspection tools (no workspace mutation, no command execution). */
-const READ_TOOLS = new Set([
-	"AskUserQuestion",
-	"ContactParent",
-	"FetchURL",
-	"Glob",
-	"Grep",
-	"KnowledgeLookup",
-	"LSP",
-	"MemoryLookup",
-	"Read",
-	"ReadGroup",
-	"ReadMediaFile",
-	"ReportFinding",
-	"Skill",
-	"TodoList",
-	"WebSearch"
-]);
-/** Tools that mutate the workspace (files, memory, plans, skills). */
-const WRITE_TOOLS = new Set([
-	"Edit",
-	"InspectOwnAssets",
-	"MakeSkillApply",
-	"MakeSkillPlan",
-	"ManagePlugin",
-	"MemoryEdit",
-	"MemoryWrite",
-	"Write"
-]);
-/** Tools that execute commands. */
-const EXECUTE_TOOLS = new Set(["Bash", "python"]);
-/** Nesting/coordination tools — only `all` mode keeps them. A restricted
-*  child must not be able to spawn an unrestricted grandchild (that would
-*  bypass the tool filtering entirely). WolfPack is batch-spawn sugar over
-*  the same subagent host, so it is filtered too. */
-const NESTING_TOOLS = new Set([
-	"Agent",
-	"SendSubagentMessage",
-	"WolfPack"
-]);
-/** Goal/session-management tools, always available regardless of mode. */
-const CORE_TOOLS = new Set([
-	"CreateGoal",
-	"GetGoal",
-	"SetGoalBudget",
-	"UpdateGoal",
-	"WriteGoalNote",
-	"EnterPlanMode",
-	"ExitPlanMode"
-]);
+/**
+* Subagent capability modes and their tool-set policy.
+*
+* Capability modes (read-only / read-write / execute / all): a mode is
+* enforced at the tool level, not just by prompting. `all` keeps the profile's
+* full tool set; stricter modes strip it down to the tools the mode permits.
+*
+* Tool classification is by name; the sets live in `#/tools/tool-catalog`
+* (shared with the permission policies) so a new tool is classified once.
+* Unknown tool names are kept (a future tool should fail open rather than
+* being silently stripped from a read-only child).
+*/
+const KNOWN_TOOL_SETS = [
+	READ_TOOLS,
+	WRITE_TOOLS,
+	EXECUTE_TOOLS,
+	NESTING_TOOLS,
+	CORE_TOOLS
+];
 /**
 * Filter an active tool-name list down to what `mode` permits. `all` returns
 * the input unchanged. Unknown names are preserved.
@@ -108257,13 +108356,6 @@ function filterToolsForCapability(activeTools, mode) {
 		return allowed.has(name) || !KNOWN_TOOL_SETS.some((set) => set.has(name));
 	});
 }
-const KNOWN_TOOL_SETS = [
-	READ_TOOLS,
-	WRITE_TOOLS,
-	EXECUTE_TOOLS,
-	NESTING_TOOLS,
-	CORE_TOOLS
-];
 function union(...sets) {
 	const out = /* @__PURE__ */ new Set();
 	for (const s of sets) for (const v of s) out.add(v);
@@ -122330,7 +122422,7 @@ function installMuPdfWasmLogger() {
 }
 installMuPdfWasmLogger();
 let markit = async () => {
-	const promise = import("./markit-DG5XsAGz.mjs").then(({ Markit }) => {
+	const promise = import("./markit-Dga2W6G6.mjs").then(({ Markit }) => {
 		const instance = new Markit();
 		markit = () => instance;
 		return instance;
@@ -122486,7 +122578,7 @@ function resolveDocumentExtension(url, contentType) {
 		}
 	} catch {}
 }
-/** Hard ceiling for one markit conversion (omp uses 20s; allow slow hosts). */
+/** Hard ceiling for one markit conversion — generous enough for slow hosts. */
 const CONVERSION_TIMEOUT_MS = 3e4;
 const DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36";
 const DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
@@ -122692,7 +122784,7 @@ var LocalFetchURLProvider = class {
 //#endregion
 //#region ../../packages/agent-core/src/tools/providers/search-timeout.ts
 /**
-* Hard timeout for outbound web-search requests (omp pattern).
+* Hard timeout for outbound web-search requests.
 *
 * A stalled TCP/TLS connection can keep an undici fetch pending for minutes;
 * composing the caller's signal with a fixed ceiling guarantees the request
@@ -124740,8 +124832,7 @@ async function removeSessionIndexEntry(homeDir, sessionId) {
 		if (entry === void 0 || entry.sessionId === sessionId) continue;
 		kept.push(line);
 	}
-	if (kept.length === 0) await writeFile(indexPath, "", "utf-8");
-	else await writeFile(indexPath, kept.join("\n") + "\n", "utf-8");
+	await atomicWrite(indexPath, kept.length === 0 ? "" : `${kept.join("\n")}\n`);
 	invalidateSessionIndexCache();
 }
 function parseIndexLine(line) {
@@ -124792,18 +124883,6 @@ const SessionSummaryStateSchema = z.object({
 	title: z.string().optional(),
 	custom: z.record(z.string(), z.unknown()).optional()
 });
-let stateWriteCounter = 0;
-/**
-* Atomic state.json write: plain writeFile truncates the target before the
-* new bytes land, so a process killed mid-write leaves a 0-byte state.json
-* and the next resume crashes on JSON.parse. Temp-file + rename makes the
-* swap all-or-nothing.
-*/
-async function writeStateAtomically(statePath, content) {
-	const tmpPath = `${statePath}.${process.pid}.${Date.now().toString(36)}.${(stateWriteCounter++).toString(36)}.tmp`;
-	await writeFile(tmpPath, content, "utf-8");
-	await rename(tmpPath, statePath);
-}
 var SessionStore = class {
 	homeDir;
 	sessionsDir;
@@ -124823,10 +124902,7 @@ var SessionStore = class {
 			workDir
 		});
 		if (await this.findSessionEntry(input.id) !== void 0) await this.delete(input.id);
-		else if (await isDirectory(dir)) await rm(dir, {
-			recursive: true,
-			force: true
-		});
+		else if (await isDirectory(dir)) await rmWithRetry(dir);
 		await mkdir(dir, {
 			recursive: true,
 			mode: 448
@@ -124866,10 +124942,7 @@ var SessionStore = class {
 			});
 			return summary;
 		} catch (error) {
-			await rm(targetDir, {
-				recursive: true,
-				force: true
-			}).catch(() => {});
+			await rmWithRetry(targetDir).catch(() => {});
 			throw error;
 		}
 	}
@@ -124893,16 +124966,19 @@ var SessionStore = class {
 			title: normalized,
 			isCustomTitle: true
 		};
-		await writeStateAtomically(statePath, `${JSON.stringify(next, null, 2)}\n`);
+		await atomicWrite(statePath, `${JSON.stringify(next, null, 2)}\n`);
 	}
 	async delete(id) {
 		assertSafeSessionId(id);
 		const entry = await this.findSessionEntry(id);
-		if (entry !== void 0) await rm(entry.sessionDir, {
-			recursive: true,
-			force: true
-		}).catch(() => {});
-		await removeSessionIndexEntry(this.homeDir, id).catch(() => {});
+		if (entry !== void 0) {
+			try {
+				await rmWithRetry(entry.sessionDir);
+			} catch (error) {
+				throw new ScreamError(ErrorCodes.SESSION_DELETE_FAILED, `Session "${id}" could not be deleted`, { cause: error });
+			}
+			await removeSessionIndexEntry(this.homeDir, id).catch(() => {});
+		}
 	}
 	async list(options = {}) {
 		const workDir = options.workDir === void 0 ? void 0 : normalizeRequiredWorkDir(options.workDir);
@@ -124998,7 +125074,7 @@ var SessionStore = class {
 			agents: rewriteAgentHomedirs(parsed["agents"], sourceDir, targetDir),
 			custom: Object.assign({}, isRecord$1(parsed["custom"]) ? parsed["custom"] : {}, input.metadata)
 		};
-		await writeStateAtomically(statePath, `${JSON.stringify(next, null, 2)}\n`);
+		await atomicWrite(statePath, `${JSON.stringify(next, null, 2)}\n`);
 	}
 	async summaryFromDir(id, sessionDir, workDir) {
 		const dirStat = await stat(sessionDir);
@@ -129882,7 +129958,7 @@ async function handleDiyConfig(host) {
 * Open the full-screen conversation search overlay (same as Ctrl+Shift+F).
 * The overlay is owned by pi-tui; `openSearch` is a TS-private method but a
 * plain instance method at runtime, so we reach it through a cast instead of
-* adding an upstream API for a single caller.
+* adding a public API to the dependency for a single caller.
 */
 function handleSearchCommand(host) {
 	host.state.ui?.openSearch?.();
@@ -137396,7 +137472,6 @@ function renderDiffCode(code, colorFn, highlight, lang, colors) {
 * words with `chalk.inverse()`. Only the first removed/added part has its
 * leading whitespace stripped, so indentation isn't highlighted.
 *
-* Ported from oh-my-pi `packages/coding-agent/src/modes/components/diff.ts:55-95`.
 * Returns the two lines with inline inverse highlighting applied; caller wraps
 * them in the usual add/del gutter + line color.
 */

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-BJSym649.mjs")).main();
+	(await import("./app-BL4emsvp.mjs")).main();
 } catch (error) {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exit(1);