flavor-code 1.4.0-beta.1 → 1.4.0-beta.4

package/dist/{chunk-ODRWR4KK.js → chunk-IQAZ42TM.js}

@@ -5,7 +5,7 @@ import {
   getGraphemeSegmenter,
   isEnvTruthy,
   logError
-} from "./chunk-3WCDZ6ZL.js";
+} from "./chunk-ZJCAQXA7.js";
 import {
   __commonJS,
   __require,

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

@@ -117,16 +117,20 @@ var FlavorConfigSchema = z.object({
     evaluationTimeoutMs: z.number().int().min(100).max(3e4).default(2e3)
   }).prefault({}),
   maxIterations: z.object({
-    main: z.number().int().min(10).max(500).default(80),
-    subagent: z.number().int().min(10).max(200).default(40),
+    main: z.number().int().min(10).max(500).default(300),
+    subagent: z.number().int().min(10).max(200).default(100),
     softLimitFactor: z.number().min(0.5).max(1).default(0.8),
-    extendBy: z.number().int().min(5).max(100).default(20)
+    extendBy: z.number().int().min(5).max(100).default(50)
   }).prefault({}),
   loop: z.object({
-    maxCycles: z.number().int().positive().max(1e4).default(20),
+    maxCycles: z.number().int().positive().max(1e4).default(100),
     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-LKQTBL3R.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 = 10 * 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/{chunk-3WCDZ6ZL.js → chunk-ZJCAQXA7.js}

@@ -10,7 +10,8 @@ function execFileNoThrow(file, args, options = {}) {
       cwd: options.useCwd === false ? void 0 : process.cwd(),
       env: options.env,
       encoding: "utf8",
-      windowsHide: true
+      windowsHide: true,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
     }, (error, stdout, stderr) => {
       resolve2({
         stdout,

package/dist/{claude-ink-LP32NSX5.js → claude-ink-ECZ6QF3P.js}

@@ -10,8 +10,8 @@ import {
   useStdout,
   use_app_default,
   use_input_default
-} from "./chunk-ODRWR4KK.js";
-import "./chunk-3WCDZ6ZL.js";
+} from "./chunk-IQAZ42TM.js";
+import "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 export {
   AlternateScreen,

package/dist/cli-main.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-FOTMP4ZS.js";
+} from "./chunk-4RR5VVX4.js";
 import {
   staticTaskLines
 } from "./chunk-2BF7CVWZ.js";
@@ -29,8 +29,10 @@ import {
   redactErrorText,
   runDoctor,
   runPalBroker
-} from "./chunk-6MNOZ2TX.js";
-import "./chunk-CIVPKHF4.js";
+} from "./chunk-DCNUBQCH.js";
+import {
+  MEMORY_RESTART_EXIT_CODE
+} from "./chunk-LKQTBL3R.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -39,11 +41,11 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-URUVFECH.js";
+} from "./chunk-KQMKY7C5.js";
 import {
   gt,
   isValidVersion
-} from "./chunk-3WCDZ6ZL.js";
+} from "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 
 // src/cli.tsx
@@ -728,7 +730,7 @@ async function runEvaluationFile(path, outputPath) {
     })),
     ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
   };
-  const configured = await import("./load-V2UIYYQI.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)) {
@@ -896,9 +898,9 @@ function createProgram(dependencies = {}) {
 }
 async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-    import("./claude-ink-LP32NSX5.js"),
+    import("./claude-ink-ECZ6QF3P.js"),
     import("react"),
-    import("./app-C5ZQUOKJ.js")
+    import("./app-UWIEIWBQ.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,23 @@ import {
   memoryRestartArgs,
   memoryRestartMarkerPath,
   parseMemoryRestartMarker
-} from "./chunk-CIVPKHF4.js";
+} from "./chunk-LKQTBL3R.js";
 import "./chunk-S32JRDZK.js";
 
 // src/launcher.ts
 import { spawn } from "child_process";
 import { realpathSync, readFileSync } from "fs";
+import { totalmem } from "os";
 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;
+  return !runtime.execArgv.some((argument) => argument === "--expose-gc");
 }
+var HEAP_HEADROOM_MB = 8192;
+var HEAP_HEADROOM_MIN_TOTALMEM = 12 * 1024 * 1024 * 1024;
 function cliMainArguments(mainPath, argv) {
-  return [
+  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 +31,24 @@ 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
+    // 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"
   ];
+  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);

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;