flavor-code 1.4.0-beta.3 → 1.4.0-beta.5

package/dist/{chunk-3BHKW5A7.js → chunk-JZVC4477.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-NIKCPCJG.js";
+} from "./chunk-J7TLT6LR.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";
@@ -44,7 +44,13 @@ var FlavorRpcServer = class {
     this.#runtime = await this.#options.createRuntime({
       workspace: this.#options.workspace,
       output: (event) => {
-        void this.#emit({ type: "event", sessionId: this.#runtime?.sessionId, event }, "output");
+        const emitted = this.#emit({ type: "event", sessionId: this.#runtime?.sessionId, event }, "output");
+        if (event.type === "exit") {
+          void emitted.finally(() => {
+            this.#closing = true;
+            this.#lines?.close();
+          });
+        }
       }
     });
     await this.#runtime.session.start();

package/dist/{chunk-KBHWS7M6.js → chunk-KQMKY7C5.js}

@@ -127,6 +127,10 @@ var FlavorConfigSchema = z.object({
     maxTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(5e5),
     isolation: z.literal("auto").default("auto")
   }).prefault({}),
+  goal: z.object({
+    maxRounds: z.number().int().positive().max(1e4).default(100),
+    maxStallStreak: z.number().int().positive().max(100).default(3)
+  }).prefault({}),
   context: z.object({
     windowTokens: z.number().int().positive().default(2e5),
     reservedOutputTokens: z.number().int().nonnegative().default(2e4),

package/dist/chunk-N5MXHJKD.js

@@ -0,0 +1,107 @@
+#!/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 = 24;
+var MEMORY_RESTART_WINDOW_MS = 60 * 60 * 1e3;
+var MEMORY_RESTART_MIN_GAP_MS = 5 * 60 * 1e3;
+var MEMORY_RESTART_CONTINUATION_TTL_MS = 24 * 60 * 60 * 1e3;
+var SESSION_ID_PATTERN = /^session-[A-Za-z0-9_-]+$/u;
+var rotationActive = false;
+function markMemoryRotation() {
+  rotationActive = true;
+}
+function memoryRotationActive() {
+  return rotationActive;
+}
+function memoryRestartMarkerPath(workspace) {
+  return join(workspace, ".flavor", "tmp", MEMORY_RESTART_MARKER_FILE);
+}
+function nextMemoryRestartMarker(previous, sessionId, now, continuation) {
+  const previousWindowStart = previous?.windowStartedAt ?? previous?.requestedAt;
+  const reusable = previous !== void 0 && previous.sessionId === sessionId && previousWindowStart !== void 0 && now.getTime() - Date.parse(previousWindowStart) < MEMORY_RESTART_WINDOW_MS && Number.isInteger(previous.attempts) && previous.attempts > 0;
+  return {
+    sessionId,
+    windowStartedAt: reusable ? previousWindowStart : now.toISOString(),
+    requestedAt: now.toISOString(),
+    attempts: reusable ? previous.attempts + 1 : 1,
+    ...continuation === void 0 ? {} : { continuation }
+  };
+}
+function consumedMemoryRestartMarker(marker) {
+  return {
+    sessionId: marker.sessionId,
+    ...marker.windowStartedAt === void 0 ? {} : { windowStartedAt: marker.windowStartedAt },
+    requestedAt: marker.requestedAt,
+    attempts: marker.attempts
+  };
+}
+function rotationCooldownActive(marker, sessionId, now) {
+  return marker !== void 0 && marker.sessionId === sessionId && now.getTime() - Date.parse(marker.requestedAt) < MEMORY_RESTART_MIN_GAP_MS;
+}
+function pendingContinuation(marker, sessionId, now) {
+  if (marker === void 0 || marker.sessionId !== sessionId) return void 0;
+  if (now.getTime() - Date.parse(marker.requestedAt) > MEMORY_RESTART_CONTINUATION_TTL_MS) return void 0;
+  const continuation = marker.continuation;
+  if (continuation === void 0) return void 0;
+  if (continuation.kind !== "loop" && continuation.kind !== "goal") return void 0;
+  if (typeof continuation.id !== "string" || continuation.id.length === 0) return void 0;
+  return continuation;
+}
+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;
+    if (argument === "--memory-restart") continue;
+    stripped.push(argument);
+  }
+  return [...stripped, "--resume", marker.sessionId, "--memory-restart"];
+}
+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;
+    }
+    const continuation = value.continuation;
+    if (continuation !== void 0 && (typeof continuation !== "object" || continuation === null || continuation.kind !== "loop" && continuation.kind !== "goal" || typeof continuation.id !== "string")) {
+      return void 0;
+    }
+    const windowStartedAt = value.windowStartedAt;
+    if (windowStartedAt !== void 0 && typeof windowStartedAt !== "string") return void 0;
+    return {
+      sessionId: value.sessionId,
+      ...windowStartedAt === void 0 ? {} : { windowStartedAt },
+      requestedAt: value.requestedAt,
+      attempts: value.attempts,
+      ...continuation === void 0 ? {} : { continuation }
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  MEMORY_RESTART_EXIT_CODE,
+  markMemoryRotation,
+  memoryRotationActive,
+  memoryRestartMarkerPath,
+  nextMemoryRestartMarker,
+  consumedMemoryRestartMarker,
+  rotationCooldownActive,
+  pendingContinuation,
+  memoryRestartArgs,
+  parseMemoryRestartMarker
+};

package/dist/cli-main.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-3BHKW5A7.js";
+} from "./chunk-JZVC4477.js";
 import {
   staticTaskLines
 } from "./chunk-2BF7CVWZ.js";
@@ -29,8 +29,10 @@ import {
   redactErrorText,
   runDoctor,
   runPalBroker
-} from "./chunk-NIKCPCJG.js";
-import "./chunk-CIVPKHF4.js";
+} from "./chunk-J7TLT6LR.js";
+import {
+  MEMORY_RESTART_EXIT_CODE
+} from "./chunk-N5MXHJKD.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -39,7 +41,7 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-KBHWS7M6.js";
+} from "./chunk-KQMKY7C5.js";
 import {
   gt,
   isValidVersion
@@ -728,7 +730,7 @@ async function runEvaluationFile(path, outputPath) {
     })),
     ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
   };
-  const configured = await import("./load-SLSL3IWR.js").then(({ loadConfig: loadConfig2 }) => loadConfig2({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
+  const configured = await import("./load-F4AYLCF6.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 {
@@ -752,7 +754,7 @@ async function runEvaluationFile(path, outputPath) {
 
 // src/cli.tsx
 function createProgram(dependencies = {}) {
-  const program = new Command().name("flavor").description("Interactive coding agent").version(packageVersion()).option("-p, --print <prompt>", "run one prompt without the interactive UI").option("--resume [session-id]", "resume a saved session (latest when id is omitted)").option("--mode <mode>", "runtime mode: interactive or rpc").option("--workspace <path>", "workspace path (RPC mode)").option("--rpc-approvals", "allow an RPC client to resolve interactive tool approvals").option("--rpc-streamed-writes", "stream proposed file writes to an RPC client before committing them").option("--trace <path>", "write a redacted JSONL execution trace").option("--pal-name <alias>", "name this interactive Flavor instance for /pals and /chat").addOption(new Option("--pals-broker <address>").hideHelp());
+  const program = new Command().name("flavor").description("Interactive coding agent").version(packageVersion()).option("-p, --print <prompt>", "run one prompt without the interactive UI").option("--resume [session-id]", "resume a saved session (latest when id is omitted)").option("--mode <mode>", "runtime mode: interactive or rpc").option("--workspace <path>", "workspace path (RPC mode)").option("--rpc-approvals", "allow an RPC client to resolve interactive tool approvals").option("--rpc-streamed-writes", "stream proposed file writes to an RPC client before committing them").option("--trace <path>", "write a redacted JSONL execution trace").option("--pal-name <alias>", "name this interactive Flavor instance for /pals and /chat").addOption(new Option("--memory-restart").hideHelp()).addOption(new Option("--pals-broker <address>").hideHelp());
   program.command("init [directory]").description("Initialize Flavor project files in a directory (defaults to cwd)").action(async (directory) => {
     const cwd = directory ? resolve3(directory) : process.cwd();
     try {
@@ -869,7 +871,7 @@ function createProgram(dependencies = {}) {
       return;
     }
     if (options.print !== void 0) {
-      process.exitCode = await runPrint(options.print, {}, resumeSession);
+      process.exitCode = await runPrint(options.print, {}, resumeSession, options.memoryRestart === true);
       return;
     }
     if (!(dependencies.isTTY?.() ?? process.stdin.isTTY)) {
@@ -898,7 +900,7 @@ async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
     import("./claude-ink-ECZ6QF3P.js"),
     import("react"),
-    import("./app-H7RYDMD3.js")
+    import("./app-SXNJDSI2.js")
   ]);
   const instance = await render(createElement(
     AlternateScreen,
@@ -961,7 +963,7 @@ async function runRpcMode(options) {
     });
     await server.start();
     await recorder?.close();
-    return 0;
+    return process.exitCode === MEMORY_RESTART_EXIT_CODE ? MEMORY_RESTART_EXIT_CODE : 0;
   } catch (error) {
     await recorder?.close().catch(() => void 0);
     process.stderr.write(`rpc: ${safeError(error)}
@@ -972,7 +974,7 @@ async function runRpcMode(options) {
 function setInteractiveProcessTitle(target = process) {
   target.title = "Flavor Code";
 }
-async function runPrint(prompt, dependencies = {}, resumeSession) {
+async function runPrint(prompt, dependencies = {}, resumeSession, memoryRestart = false) {
   let code = 0;
   let runtime;
   const stdout = dependencies.stdout ?? ((text) => process.stdout.write(text));
@@ -1004,7 +1006,11 @@ async function runPrint(prompt, dependencies = {}, resumeSession) {
   }
   try {
     await runtime.session.start();
-    await runtime.session.submit(prompt);
+    if (runtime.session.rotationContinuationResumed) {
+      await runtime.session.whenIdle();
+    } else if (!memoryRestart) {
+      await runtime.session.submit(prompt);
+    }
   } catch (error) {
     stderr(`runtime: ${safeError(error)}
 `);
@@ -1025,8 +1031,9 @@ async function runPrint(prompt, dependencies = {}, resumeSession) {
       code = 1;
     }
   }
-  if (code === 0) stdout("\n");
-  return code;
+  const restarting = process.exitCode === MEMORY_RESTART_EXIT_CODE;
+  if (code === 0 && !restarting) stdout("\n");
+  return restarting ? MEMORY_RESTART_EXIT_CODE : code;
 }
 function safeError(error) {
   return redactErrorText(message(error));

package/dist/cli.js

@@ -5,19 +5,25 @@ import {
   memoryRestartArgs,
   memoryRestartMarkerPath,
   parseMemoryRestartMarker
-} from "./chunk-CIVPKHF4.js";
+} from "./chunk-N5MXHJKD.js";
 import "./chunk-S32JRDZK.js";
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import { realpathSync, readFileSync } from "fs";
+import { mkdirSync, realpathSync, readFileSync, rmSync } from "fs";
+import { totalmem } from "os";
+import { join } from "path";
 import { fileURLToPath } from "url";
 function needsRelaunch(runtime) {
   if (!runtime.execArgv.some((argument) => argument === "--report-on-fatalerror")) return true;
-  return !runtime.execArgv.some((argument) => argument.startsWith("--heapsnapshot-near-heap-limit"));
+  if (!runtime.execArgv.some((argument) => argument.startsWith("--heapsnapshot-near-heap-limit"))) return true;
+  if (!runtime.execArgv.some((argument) => argument === "--heap-prof")) return true;
+  return !runtime.execArgv.some((argument) => argument === "--expose-gc");
 }
-function cliMainArguments(mainPath, argv) {
-  return [
+var HEAP_HEADROOM_MB = 8192;
+var HEAP_HEADROOM_MIN_TOTALMEM = 12 * 1024 * 1024 * 1024;
+function cliMainArguments(mainPath, argv, heapProfile) {
+  const flags = [
     // Fatal V8 errors (heap OOM, native crashes) bypass crash-guard.ts and
     // leave only an unusable native stack. Ask Node to dump a diagnostic
     // report next to the working directory so the next crash has a scene.
@@ -27,9 +33,33 @@ function cliMainArguments(mainPath, argv) {
     // Capture one heap snapshot as the heap nears its limit so the next
     // crash leaves a .heapsnapshot retainer trail next to the report.
     "--heapsnapshot-near-heap-limit=1",
-    mainPath,
-    ...argv
+    // A full snapshot is intentionally reserved for a hard OOM. Sparse
+    // allocation sampling has much lower overhead and still records the
+    // allocating call stacks responsible for a controlled watermark
+    // restart, where --heapsnapshot-near-heap-limit never fires.
+    "--heap-prof",
+    "--heap-prof-interval=1048576",
+    // The heap watermarks are GC-verified: heapUsed counts uncollected
+    // garbage, and stopping turns or rotating on garbage alone would waste
+    // work. Exposing gc lets the watermark measure the live set instead.
+    "--expose-gc"
   ];
+  if (heapProfile !== void 0) {
+    flags.push(`--heap-prof-dir=${heapProfile.directory}`, `--heap-prof-name=${heapProfile.name}`);
+  }
+  const processHeapFlag = process.execArgv.find((argument) => argument.startsWith("--max-old-space-size"));
+  const argvHeapFlag = argv.find((argument) => argument.startsWith("--max-old-space-size"));
+  const userHeapFlag = processHeapFlag ?? argvHeapFlag;
+  if (userHeapFlag !== void 0) {
+    flags.push(userHeapFlag);
+  } else {
+    const constrained = process.constrainedMemory?.() ?? 0;
+    const availableLimit = constrained > 0 ? Math.min(totalmem(), constrained) : totalmem();
+    if (availableLimit >= HEAP_HEADROOM_MIN_TOTALMEM) {
+      flags.push(`--max-old-space-size=${HEAP_HEADROOM_MB}`);
+    }
+  }
+  return [...flags, mainPath, ...argv.filter((argument) => argument !== argvHeapFlag)];
 }
 async function launchCli() {
   const mainUrl = new URL("./cli-main.js", import.meta.url);
@@ -43,8 +73,19 @@ async function launchCli() {
   }
   const mainPath = fileURLToPath(mainUrl);
   let argv = process.argv.slice(2);
+  let childSequence = 0;
   for (; ; ) {
-    const code = await spawnAndWait(mainPath, argv);
+    const profileDirectory = join(process.cwd(), ".flavor", "tmp");
+    mkdirSync(profileDirectory, { recursive: true });
+    const profileName = `heap-profile-${Date.now()}-${process.pid}-${childSequence++}.heapprofile`;
+    const profilePath = join(profileDirectory, profileName);
+    const code = await spawnAndWait(mainPath, argv, { directory: profileDirectory, name: profileName });
+    if (code === 0) {
+      rmSync(profilePath, { force: true });
+    } else {
+      process.stderr.write(`flavor launcher: retained allocation profile ${profilePath}
+`);
+    }
     if (code === MEMORY_RESTART_EXIT_CODE) {
       let marker;
       try {
@@ -67,8 +108,8 @@ async function launchCli() {
     return;
   }
 }
-async function spawnAndWait(mainPath, argv) {
-  const child = spawn(process.execPath, cliMainArguments(mainPath, argv), { stdio: "inherit" });
+async function spawnAndWait(mainPath, argv, heapProfile) {
+  const child = spawn(process.execPath, cliMainArguments(mainPath, argv, heapProfile), { stdio: "inherit" });
   const ignoreSignal = () => {
   };
   process.on("SIGINT", ignoreSignal);

package/dist/config/schema.d.ts

@@ -164,6 +164,10 @@ export declare const FlavorConfigSchema: z.ZodObject<{
         maxTokens: z.ZodDefault<z.ZodNumber>;
         isolation: z.ZodDefault<z.ZodLiteral<"auto">>;
     }, z.core.$strip>>;
+    goal: z.ZodPrefault<z.ZodObject<{
+        maxRounds: z.ZodDefault<z.ZodNumber>;
+        maxStallStreak: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     context: z.ZodPrefault<z.ZodObject<{
         windowTokens: z.ZodDefault<z.ZodNumber>;
         reservedOutputTokens: z.ZodDefault<z.ZodNumber>;

package/dist/context/manager.d.ts

@@ -97,6 +97,15 @@ export declare class ContextManager {
     restore(snapshot: ContextSnapshot): void;
     messagesForModel(): ModelMessage[];
     estimatedTokens(): number;
+    /** Retained sizes for the rotation census: what this context holds right now. */
+    census(): {
+        messages: number;
+        messageChars: number;
+        visibilityEntries: number;
+        visibilityChars: number;
+        transientEntries: number;
+        transientChars: number;
+    };
     needsCompaction(): boolean;
     get lastRecordedInputTokens(): number | undefined;
     get consecutiveAutoCompactFailures(): number;