flavor-code 1.3.15 → 1.3.17

package/dist/{chunk-WB4IJXFT.js → chunk-BKOOYSGH.js}

@@ -1,5 +1,11 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  MEMORY_RESTART_EXIT_CODE,
+  memoryRestartMarkerPath,
+  nextMemoryRestartMarker,
+  parseMemoryRestartMarker
+} from "./chunk-CIVPKHF4.js";
 import {
   PERMISSION_MODES,
   PermissionModeSchema,
@@ -12,7 +18,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-JFKRX2KG.js";
+} from "./chunk-HJOCNKPN.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -1308,6 +1314,8 @@ function appendThinkingText(previous, delta) {
 }
 
 // src/ui/transcript.ts
+var MAX_TRANSCRIPT_TURNS = 200;
+var MAX_TRANSCRIPT_CHARS = 2e6;
 function createTranscriptState() {
   return { completed: [], nextId: 1 };
 }
@@ -1604,7 +1612,7 @@ function hydrateHistory(messages, compact) {
     }
   }
   if (turn !== void 0) completed.push(turn);
-  return { completed, nextId: completed.length + 1 };
+  return { completed: boundedCompleted(completed), nextId: completed.length + 1 };
 }
 function transcriptFromLegacyConversation(messages, compact) {
   return hydrateHistory(messages, compact);
@@ -1698,10 +1706,10 @@ function finishActive(state) {
   if (state.active === void 0) return state;
   const active = withoutModelActivity(state.active);
   return {
-    completed: [...state.completed, {
+    completed: boundedCompleted([...state.completed, {
       ...active,
       completedAt: active.completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
-    }],
+    }]),
     nextId: state.nextId,
     ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
   };
@@ -1730,12 +1738,26 @@ function withoutModelActivity(turn, id) {
 function restoreTranscriptState(state) {
   const completed = state.completed.map(cloneTurn);
   if (state.active !== void 0) completed.push(normalizeInterruptedTurn(cloneTurn(state.active)));
+  const nextId = Math.max(state.nextId, ...completed.map((turn) => turn.id + 1), 1);
   return {
-    completed,
-    nextId: Math.max(state.nextId, ...completed.map((turn) => turn.id + 1), 1),
+    completed: boundedCompleted(completed),
+    nextId,
     ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
   };
 }
+function boundedCompleted(input) {
+  const recent = input.slice(-MAX_TRANSCRIPT_TURNS);
+  let chars = 0;
+  let start = recent.length;
+  for (let index = recent.length - 1; index >= 0; index -= 1) {
+    const turn = recent[index];
+    const size = JSON.stringify(turn).length;
+    if (start < recent.length && chars + size > MAX_TRANSCRIPT_CHARS) break;
+    chars += size;
+    start = index;
+  }
+  return recent.slice(start);
+}
 function compactionTurn(compact) {
   const text = `Original execution steps before ${compact.compactedAt} are unavailable.`;
   return {
@@ -2026,6 +2048,8 @@ function isCode(error, code) {
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname5, join as join4, resolve as resolve3 } from "path";
+var MAX_SESSION_HISTORY_NODES = 100;
+var MAX_SESSION_HISTORY_CONTEXT_CHARS = 2e6;
 var SessionHistory = class _SessionHistory {
   #path;
   #checkpoints;
@@ -2037,8 +2061,8 @@ var SessionHistory = class _SessionHistory {
     this.#path = join4(resolve3(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
     this.#checkpoints = new WorkspaceCheckpointStore({ workspace: options.workspace });
     this.#restoreContext = options.restoreContext;
-    this.#nodes = document.nodes;
-    this.#leafId = document.leafId;
+    this.#nodes = boundedNodes(document.nodes);
+    this.#leafId = document.leafId !== null && this.#nodes.some((node) => node.id === document.leafId) ? document.leafId : this.#nodes.at(-1)?.id ?? null;
   }
   static async open(options) {
     const path = join4(resolve3(options.workspace), ".flavor", "session-trees", options.sessionId, "tree.json");
@@ -2050,7 +2074,9 @@ var SessionHistory = class _SessionHistory {
     } catch (error) {
       if (!isCode2(error, "ENOENT")) throw error;
     }
-    return new _SessionHistory(options, document);
+    const history = new _SessionHistory(options, document);
+    if (history.#nodes.length !== document.nodes.length) await history.#persist();
+    return history;
   }
   get leafId() {
     return this.#leafId;
@@ -2070,6 +2096,7 @@ var SessionHistory = class _SessionHistory {
     };
     this.#nodes.push(node);
     this.#leafId = node.id;
+    this.#boundNodes();
     await this.#persist();
     return structuredClone(node);
   }
@@ -2111,6 +2138,13 @@ var SessionHistory = class _SessionHistory {
     if (node === void 0) throw new Error(`Unknown session tree node: ${id}`);
     return node;
   }
+  #boundNodes() {
+    const bounded2 = boundedNodes(this.#nodes);
+    this.#nodes.splice(0, this.#nodes.length, ...bounded2);
+    if (this.#leafId !== null && !this.#nodes.some((node) => node.id === this.#leafId)) {
+      this.#leafId = this.#nodes.at(-1)?.id ?? null;
+    }
+  }
   async #persist() {
     const document = {
       version: 1,
@@ -2125,6 +2159,24 @@ var SessionHistory = class _SessionHistory {
     await rename2(temporary, this.#path);
   }
 };
+function boundedNodes(input) {
+  const recent = input.slice(-MAX_SESSION_HISTORY_NODES);
+  let contextChars = 0;
+  let start = recent.length;
+  for (let index = recent.length - 1; index >= 0; index -= 1) {
+    const node = recent[index];
+    const size = JSON.stringify(node.context).length;
+    if (start < recent.length && contextChars + size > MAX_SESSION_HISTORY_CONTEXT_CHARS) break;
+    contextChars += size;
+    start = index;
+  }
+  const retained = recent.slice(start).map((node) => structuredClone(node));
+  const ids = new Set(retained.map((node) => node.id));
+  for (const node of retained) {
+    if (node.parentId !== null && !ids.has(node.parentId)) node.parentId = null;
+  }
+  return retained;
+}
 function validate(value, sessionId) {
   if (value.version !== 1 || value.sessionId !== sessionId || !Array.isArray(value.nodes)) {
     throw new Error("Invalid session tree");
@@ -5326,9 +5378,10 @@ async function ensureOnce(options) {
 
 // src/production.ts
 import { readFile as readFile22 } from "fs/promises";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { createHash as createHash18, randomUUID as randomUUID20 } from "crypto";
 import { homedir as homedir2, release as osRelease, tmpdir as tmpdir4, version as osVersion } from "os";
-import { basename as basename6, join as join26, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
+import { basename as basename6, dirname as dirname19, join as join26, relative as relative20, resolve as resolve28, sep as sep20 } from "path";
 
 // src/agent/subagents.ts
 import { z as z5 } from "zod";
@@ -5877,7 +5930,9 @@ import { createHash as createHash4, randomUUID as randomUUID6 } from "crypto";
 var DEFAULT_COMPACTION_POLICY = {
   windowTokens: 2e5,
   reservedOutputTokens: 2e4,
-  autoCompactBufferTokens: 13e3,
+  // 85% of the effective window (180_000 - 27_000 = 153_000): compaction used
+  // to trigger at ~92.8%, which let sessions ride the threshold into heap OOM.
+  autoCompactBufferTokens: 27e3,
   warningBufferTokens: 2e4,
   blockingBufferTokens: 3e3,
   microcompactKeepRecentToolResults: 5,
@@ -6087,6 +6142,13 @@ var ContextManager = class _ContextManager {
   #epoch;
   #visibilityLog = [];
   #activeTransientSystem = /* @__PURE__ */ new Map();
+  /**
+   * The visibility audit log persists every transient system admission and is
+   * serialized in full on every session save. Bound both dimensions or a long
+   * subagent-driven run grows it into hundreds of megabytes (heap OOM).
+   */
+  static VISIBILITY_LOG_MAX_ENTRIES = 1e3;
+  static VISIBILITY_RECORD_CONTENT_LIMIT = 2048;
   constructor(options) {
     if (options.compactAtChars !== void 0 && options.compactAtChars <= 0) throw new Error("compactAtChars must be positive");
     if (options.toolOutputChars <= 0) throw new Error("toolOutputChars must be positive");
@@ -6182,11 +6244,14 @@ var ContextManager = class _ContextManager {
     const record = {
       id,
       role: "system",
-      content,
+      content: limitVisibilityContent(content),
       admittedAt: (/* @__PURE__ */ new Date()).toISOString(),
       scope: "run"
     };
     this.#visibilityLog.push(record);
+    if (this.#visibilityLog.length > _ContextManager.VISIBILITY_LOG_MAX_ENTRIES) {
+      this.#visibilityLog = this.#visibilityLog.slice(-_ContextManager.VISIBILITY_LOG_MAX_ENTRIES);
+    }
     this.#activeTransientSystem.set(id, { role: "system", content });
     return id;
   }
@@ -6222,7 +6287,7 @@ var ContextManager = class _ContextManager {
     for (const key of DYNAMIC_SOURCE_ORDER) {
       const value = next[key];
       if (value === void 0 || value === this.#epoch.sources[key]) continue;
-      updates.push(contextUpdateMessage(key, displaySourceValue(key, value)));
+      updates.push(contextUpdateMessage(key, deltaSourceValue(this.#epoch.sources[key], displaySourceValue(key, value))));
       this.#epoch.sources[key] = value;
     }
     for (const key of DYNAMIC_SOURCE_ORDER) {
@@ -6232,8 +6297,6 @@ var ContextManager = class _ContextManager {
     }
     if (updates.length === 0) return false;
     this.#messages.push(...updates);
-    this.#lastRecordedInputTokens = void 0;
-    this.#estimatedTokensAtLastRecordedUsage = void 0;
     return true;
   }
   snapshot() {
@@ -6249,7 +6312,7 @@ var ContextManager = class _ContextManager {
     const legacySummary = snapshot4.summary?.role === "system" && snapshot4.summary.content.startsWith("Conversation summary\n") ? snapshot4.summary.content.slice("Conversation summary\n".length) : void 0;
     this.#compact = snapshot4.compact === void 0 ? legacySummary === void 0 ? void 0 : { summary: legacySummary, compactedAt: (/* @__PURE__ */ new Date(0)).toISOString() } : { ...snapshot4.compact };
     if (snapshot4.epoch !== void 0) this.#epoch = cloneEpoch(snapshot4.epoch);
-    this.#visibilityLog = snapshot4.visibilityLog?.map((item) => ({ ...item })) ?? [];
+    this.#visibilityLog = boundVisibilityLog(snapshot4.visibilityLog);
     this.#activeTransientSystem.clear();
     this.#messages = messages.map((message2) => message2.role === "tool" ? { ...message2, content: truncateToolOutput(message2.content, this.#toolOutputChars) } : cloneMessage2(message2));
     this.#lastRecordedInputTokens = void 0;
@@ -6293,6 +6356,7 @@ var ContextManager = class _ContextManager {
   async prepareForModelCall(signal = new AbortController().signal) {
     signal.throwIfAborted();
     this.refreshContextSources();
+    this.#dropStaleContextUpdates();
     if (!this.needsCompaction()) return false;
     const originalMessages = this.#messages;
     const originalRecordedUsage = this.#lastRecordedInputTokens;
@@ -6305,8 +6369,6 @@ var ContextManager = class _ContextManager {
     const microcompact = microcompactMessages(this.#messages, this.#compaction.microcompactKeepRecentToolResults);
     if (microcompact.changed) {
       this.#messages = microcompact.messages;
-      this.#lastRecordedInputTokens = void 0;
-      this.#estimatedTokensAtLastRecordedUsage = void 0;
     }
     if (!this.needsCompaction()) {
       if (microcompact.changed) {
@@ -6392,6 +6454,26 @@ var ContextManager = class _ContextManager {
     this.#reportCompactProgress(100);
     return true;
   }
+  #dropStaleContextUpdates() {
+    const latestBySource = /* @__PURE__ */ new Map();
+    for (let index = this.#messages.length - 1; index >= 0; index -= 1) {
+      const source = contextUpdateSource(this.#messages[index]);
+      if (source === void 0 || latestBySource.has(source)) continue;
+      latestBySource.set(source, index);
+    }
+    const next = [];
+    let changed = false;
+    this.#messages.forEach((message2, index) => {
+      const source = contextUpdateSource(message2);
+      if (source !== void 0 && latestBySource.get(source) !== index) {
+        changed = true;
+        return;
+      }
+      next.push(message2);
+    });
+    if (changed) this.#messages = next;
+    return changed;
+  }
   #reportCompactProgress(percentage) {
     const normalized = Math.max(0, Math.min(100, Math.floor(percentage / 10) * 10));
     if (normalized === this.#lastCompactProgress) return;
@@ -6503,6 +6585,33 @@ function contextUpdateMessage(source, content) {
   return { role: "system", content: `Context update [${source}]
 ${content}` };
 }
+var CONTEXT_UPDATE_PREFIX = "Context update [";
+function contextUpdateSource(message2) {
+  if (message2.role !== "system" || typeof message2.content !== "string") return void 0;
+  if (!message2.content.startsWith(CONTEXT_UPDATE_PREFIX)) return void 0;
+  const end = message2.content.indexOf("]\n", CONTEXT_UPDATE_PREFIX.length);
+  if (end < 0) return void 0;
+  return message2.content.slice(CONTEXT_UPDATE_PREFIX.length, end);
+}
+function deltaSourceValue(previous, display) {
+  if (previous === void 0 || !display.startsWith(previous)) return display;
+  return display.slice(previous.length).replace(/^\s+/, "") || display;
+}
+function limitVisibilityContent(content) {
+  const limit = ContextManager.VISIBILITY_RECORD_CONTENT_LIMIT;
+  if (content.length <= limit) return content;
+  return `${content.slice(0, limit)}
+...[truncated; original length: ${content.length} characters]...`;
+}
+function boundVisibilityLog(records) {
+  if (records === void 0) return [];
+  const limit = ContextManager.VISIBILITY_RECORD_CONTENT_LIMIT;
+  const bounded2 = records.map((item) => ({
+    ...item,
+    ...item.content.length <= limit ? {} : { content: limitVisibilityContent(item.content) }
+  }));
+  return bounded2.length > ContextManager.VISIBILITY_LOG_MAX_ENTRIES ? bounded2.slice(-ContextManager.VISIBILITY_LOG_MAX_ENTRIES) : bounded2;
+}
 function cloneEpoch(epoch) {
   return {
     ...epoch,
@@ -6797,6 +6906,9 @@ function reportProgress(callback, percentage) {
   }
 }
 
+// src/agent/loop.ts
+import { getHeapStatistics } from "v8";
+
 // src/models/structured.ts
 import { z as z7 } from "zod";
 var DEFAULT_RETRY_DELAYS = [1e3, 2e3, 4e3];
@@ -7214,6 +7326,18 @@ function envMaxIterations() {
   if (!Number.isInteger(parsed) || parsed <= 0) return void 0;
   return parsed;
 }
+var MEMORY_PRESSURE_HEAP_RATIO = 0.8;
+function memoryPressureError(heapUsed, heapLimit) {
+  if (heapLimit <= 0 || heapUsed < heapLimit * MEMORY_PRESSURE_HEAP_RATIO) return void 0;
+  const mb = (bytes) => Math.round(bytes / 1048576);
+  return {
+    code: "memory_pressure",
+    message: `Heap usage reached ${Math.round(heapUsed / heapLimit * 100)}% of the V8 limit (${mb(heapUsed)}MB of ${mb(heapLimit)}MB); stopping the current turn to avoid a crash. The saved session will reopen after restart.`
+  };
+}
+function currentMemoryPressure() {
+  return memoryPressureError(process.memoryUsage().heapUsed, getHeapStatistics().heap_size_limit);
+}
 var AgentLoop = class {
   #options;
   #iterationLimitMode = "standard";
@@ -7284,6 +7408,11 @@ var AgentLoop = class {
         yield { type: "error", error: { code: "cancelled", message: abortMessage(request.signal) } };
         return;
       }
+      const pressure = currentMemoryPressure();
+      if (pressure !== void 0) {
+        yield { type: "error", error: pressure };
+        return;
+      }
       const softLimit = Math.floor(maxIterations * this.#options.softLimitFactor);
       if (!warned && iteration >= softLimit) {
         warned = true;
@@ -7323,6 +7452,11 @@ var AgentLoop = class {
         yield { type: "error", error: normalizeProviderError(error) };
         return;
       }
+      const preparedPressure = currentMemoryPressure();
+      if (preparedPressure !== void 0) {
+        yield { type: "error", error: preparedPressure };
+        return;
+      }
       let assistantText = "";
       const collectedToolCalls = [];
       const collectedThinking = [];
@@ -7346,6 +7480,11 @@ var AgentLoop = class {
           tools: [...this.#options.tools],
           ...request.signal === void 0 ? {} : { signal: request.signal }
         };
+        const requestPressure = currentMemoryPressure();
+        if (requestPressure !== void 0) {
+          yield { type: "error", error: requestPressure };
+          return;
+        }
         let before;
         try {
           before = await this.#options.hooks.emit({
@@ -12679,7 +12818,8 @@ var BoundedOutput = class {
   #headLimit;
   #tailLimit;
   #head = Buffer.alloc(0);
-  #tail = Buffer.alloc(0);
+  #tailChunks = [];
+  #tailBytes = 0;
   #complete = Buffer.alloc(0);
   #bytes = 0;
   constructor(limit) {
@@ -12699,15 +12839,24 @@ var BoundedOutput = class {
       const count = Math.min(this.#headLimit - this.#head.length, chunk.length);
       this.#head = Buffer.concat([this.#head, chunk.subarray(0, count)]);
     }
-    if (this.#tailLimit > 0) this.#tail = Buffer.concat([this.#tail, chunk]).subarray(-this.#tailLimit);
+    if (this.#tailLimit > 0) {
+      this.#tailChunks.push(chunk);
+      this.#tailBytes += chunk.length;
+      if (this.#tailBytes >= this.#tailLimit * 2) {
+        const merged = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
+        this.#tailChunks = [merged];
+        this.#tailBytes = merged.length;
+      }
+    }
   }
   metadata() {
     return { truncated: this.truncated, originalBytes: this.#bytes, limitBytes: this.#limit };
   }
   text() {
     if (!this.truncated) return decodeOutput(this.#complete);
+    const tail = Buffer.concat(this.#tailChunks).subarray(-this.#tailLimit);
     const encoding = classifyUtf8(this.#complete) === "invalid" && process.platform === "win32" ? "gb18030" : "utf-8";
-    return `${decodePrefix(this.#head, encoding)}${ELLIPSIS}${decodeSuffix(this.#tail, encoding)}`;
+    return `${decodePrefix(this.#head, encoding)}${ELLIPSIS}${decodeSuffix(tail, encoding)}`;
   }
 };
 var AdaptiveOutputDecoder = class {
@@ -22634,7 +22783,7 @@ async function createProductionRuntime(options) {
           contextEpoch: harness.main.context.snapshot().epoch?.id ?? "legacy"
         });
         const turnId = harnessJournal.startTurn(turnConfig, { prompt, initialUserMessage: runOptions?.initialUserMessage });
-        return durableTurn(persistAndCheckpointAfter(runMain(
+        return monitorMemoryRestart(durableTurn(persistAfter(runMain(
           harness,
           skills,
           prompt,
@@ -22650,11 +22799,7 @@ async function createProductionRuntime(options) {
           runOptions?.initialUserMessage,
           runOptions?.additionalContext,
           ide
-        ), persist, () => sessionHistory.append({
-          prompt,
-          context: harness.main.context.snapshot(),
-          label: `turn: ${prompt.slice(0, 80)}`
-        })), harnessJournal, turnId, turnConfig);
+        ), persist), harnessJournal, turnId, turnConfig), () => requestMemoryRestart(workspace, sessionId, emitOutput));
       },
       runSkill: (skill, prompt, signal) => persistAfter(
         runExplicitSkill(harness, skills, skill, prompt, signal, selectedModels.mainError),
@@ -23364,14 +23509,6 @@ async function* persistAfter(source, persist) {
     await persist();
   }
 }
-async function* persistAndCheckpointAfter(source, persist, checkpoint) {
-  try {
-    for await (const item of source) yield item;
-    await checkpoint();
-  } finally {
-    await persist();
-  }
-}
 async function* persistEach(source, persist) {
   try {
     for await (const item of source) {
@@ -23403,6 +23540,31 @@ async function* durableTurn(source, journal, turnId, config) {
     }
   }
 }
+async function* monitorMemoryRestart(source, onRestartNeeded) {
+  let pressure = false;
+  for await (const event of source) {
+    if (event.type === "error" && event.error.code === "memory_pressure") pressure = true;
+    yield event;
+  }
+  if (pressure) onRestartNeeded();
+}
+function requestMemoryRestart(workspace, sessionId, emitOutput) {
+  try {
+    const markerPath = memoryRestartMarkerPath(workspace);
+    let previous;
+    try {
+      previous = parseMemoryRestartMarker(readFileSync3(markerPath, "utf8"));
+    } catch {
+    }
+    mkdirSync3(dirname19(markerPath), { recursive: true });
+    writeFileSync(markerPath, `${JSON.stringify(nextMemoryRestartMarker(previous, sessionId, /* @__PURE__ */ new Date()))}
+`, "utf8");
+  } catch {
+  }
+  process.exitCode = MEMORY_RESTART_EXIT_CODE;
+  emitOutput({ type: "notice", message: "Memory watermark reached; the session is saved and Flavor is restarting with a fresh heap." });
+  emitOutput({ type: "exit" });
+}
 async function runGitCommit(deps, hint, signal) {
   if (!await isGitRepository(deps.workspace)) return "Not a git repository \u2014 /commit needs git.";
   let summary2 = await changeSummary(deps.workspace);

package/dist/chunk-CIVPKHF4.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+
+// src/utils/memory-restart.ts
+import { join } from "path";
+var MEMORY_RESTART_EXIT_CODE = 75;
+var MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
+var MEMORY_RESTART_MAX_ATTEMPTS = 3;
+var MEMORY_RESTART_WINDOW_MS = 30 * 60 * 1e3;
+var SESSION_ID_PATTERN = /^session-[A-Za-z0-9_-]+$/u;
+function memoryRestartMarkerPath(workspace) {
+  return join(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+}
+function nextMemoryRestartMarker(previous, sessionId, now) {
+  const reusable = previous !== void 0 && previous.sessionId === sessionId && now.getTime() - Date.parse(previous.requestedAt) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
+  return { sessionId, requestedAt: now.toISOString(), attempts: reusable ? previous.attempts + 1 : 1 };
+}
+function shouldRelaunchForMemoryRestart(marker) {
+  return marker !== void 0 && SESSION_ID_PATTERN.test(marker.sessionId) && Number.isInteger(marker.attempts) && marker.attempts >= 1 && marker.attempts <= MEMORY_RESTART_MAX_ATTEMPTS;
+}
+function memoryRestartArgs(argv, marker) {
+  if (!shouldRelaunchForMemoryRestart(marker)) return void 0;
+  const stripped = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--resume") {
+      if (index + 1 < argv.length && !argv[index + 1].startsWith("-")) index += 1;
+      continue;
+    }
+    if (argument.startsWith("--resume=")) continue;
+    stripped.push(argument);
+  }
+  return [...stripped, "--resume", marker.sessionId];
+}
+function parseMemoryRestartMarker(json) {
+  try {
+    const value = JSON.parse(json);
+    if (typeof value.sessionId !== "string" || typeof value.requestedAt !== "string" || typeof value.attempts !== "number") {
+      return void 0;
+    }
+    return { sessionId: value.sessionId, requestedAt: value.requestedAt, attempts: value.attempts };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  MEMORY_RESTART_EXIT_CODE,
+  memoryRestartMarkerPath,
+  nextMemoryRestartMarker,
+  memoryRestartArgs,
+  parseMemoryRestartMarker
+};

package/dist/{chunk-JFKRX2KG.js → chunk-HJOCNKPN.js}

@@ -129,7 +129,7 @@ var FlavorConfigSchema = z.object({
   context: z.object({
     windowTokens: z.number().int().positive().default(2e5),
     reservedOutputTokens: z.number().int().nonnegative().default(2e4),
-    autoCompactBufferTokens: z.number().int().nonnegative().default(13e3),
+    autoCompactBufferTokens: z.number().int().nonnegative().default(27e3),
     warningBufferTokens: z.number().int().nonnegative().default(2e4),
     blockingBufferTokens: z.number().int().nonnegative().default(3e3),
     microcompactKeepRecentToolResults: z.number().int().nonnegative().default(5),

package/dist/{chunk-TQXNF337.js → chunk-RV3PTIQE.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-WB4IJXFT.js";
+} from "./chunk-BKOOYSGH.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";

package/dist/{claude-ink-ORUA7GWG.js → claude-ink-AUZBJ3BE.js}

@@ -10,7 +10,7 @@ import {
   useStdout,
   use_app_default,
   use_input_default
-} from "./chunk-F2HMO5Q2.js";
+} from "./chunk-36UKDXPF.js";
 import "./chunk-RQTYHUMK.js";
 import "./chunk-S32JRDZK.js";
 export {

package/dist/cli-main.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-TQXNF337.js";
+} from "./chunk-RV3PTIQE.js";
 import {
   staticTaskLines
 } from "./chunk-2BF7CVWZ.js";
@@ -23,7 +23,8 @@ import {
   packageVersion,
   redactErrorText,
   runPalBroker
-} from "./chunk-WB4IJXFT.js";
+} from "./chunk-BKOOYSGH.js";
+import "./chunk-CIVPKHF4.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -32,7 +33,7 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-JFKRX2KG.js";
+} from "./chunk-HJOCNKPN.js";
 import "./chunk-RQTYHUMK.js";
 import "./chunk-S32JRDZK.js";
 
@@ -750,7 +751,7 @@ async function runEvaluationFile(path, outputPath) {
     })),
     ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
   };
-  const configured = await import("./load-LTTKVPJZ.js").then(({ loadConfig: loadConfig2 }) => loadConfig2({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
+  const configured = await import("./load-DELQW42K.js").then(({ loadConfig: loadConfig2 }) => loadConfig2({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
   const environment = createExecutionEnvironment(workspace, configured.config.execution) ?? new LocalExecutionEnvironment();
   let report;
   try {
@@ -875,9 +876,9 @@ function createProgram(dependencies = {}) {
 }
 async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-    import("./claude-ink-ORUA7GWG.js"),
+    import("./claude-ink-AUZBJ3BE.js"),
     import("react"),
-    import("./app-DDYOKGCX.js")
+    import("./app-VPS5QIRK.js")
   ]);
   const instance = await render(createElement(
     AlternateScreen,