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

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-6EZHF64C.js}

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

package/dist/cli-main.js

@@ -3,10 +3,10 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-FOTMP4ZS.js";
+} from "./chunk-UO4DLWU5.js";
 import {
   staticTaskLines
-} from "./chunk-2BF7CVWZ.js";
+} from "./chunk-RAYH6K2H.js";
 import {
   DEFAULT_MAX_OUTPUT_BYTES,
   MAX_ALIAS_LENGTH,
@@ -29,8 +29,10 @@ import {
   redactErrorText,
   runDoctor,
   runPalBroker
-} from "./chunk-6MNOZ2TX.js";
-import "./chunk-CIVPKHF4.js";
+} from "./chunk-BYHO2CA5.js";
+import {
+  MEMORY_RESTART_EXIT_CODE
+} from "./chunk-N5MXHJKD.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -39,11 +41,11 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-URUVFECH.js";
+} from "./chunk-EXOSMO57.js";
 import {
   gt,
   isValidVersion
-} from "./chunk-3WCDZ6ZL.js";
+} from "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 
 // src/cli.tsx
@@ -83,6 +85,25 @@ async function runUpdate(options = {}) {
   return exitCode === 0 ? { status: "updated", current, latest } : { status: "install-failed", current, latest, exitCode };
 }
 
+// src/ui/user-timing.ts
+import { performance } from "perf_hooks";
+function clearUiUserTimingEntries() {
+  performance.clearMarks();
+  performance.clearMeasures();
+}
+function installUiUserTimingSweeper(intervalMs = 250) {
+  if (!Number.isSafeInteger(intervalMs) || intervalMs <= 0) {
+    throw new Error("User Timing sweep interval must be a positive integer");
+  }
+  clearUiUserTimingEntries();
+  const timer = setInterval(clearUiUserTimingEntries, intervalMs);
+  timer.unref();
+  return () => {
+    clearInterval(timer);
+    clearUiUserTimingEntries();
+  };
+}
+
 // src/skills/manager.ts
 import { lstat, mkdir, readFile, readdir, realpath, rm, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -728,7 +749,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-EW56Q2MM.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 +773,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 +890,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)) {
@@ -895,17 +916,22 @@ function createProgram(dependencies = {}) {
   return program;
 }
 async function runInteractiveCli(props) {
-  const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-    import("./claude-ink-LP32NSX5.js"),
-    import("react"),
-    import("./app-C5ZQUOKJ.js")
-  ]);
-  const instance = await render(createElement(
-    AlternateScreen,
-    { mouseTracking: true },
-    createElement(App, props)
-  ), { exitOnCtrlC: false });
-  await instance.waitUntilExit();
+  const disposeUserTimingSweeper = installUiUserTimingSweeper();
+  try {
+    const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
+      import("./claude-ink-6EZHF64C.js"),
+      import("react"),
+      import("./app-SMIB6P23.js")
+    ]);
+    const instance = await render(createElement(
+      AlternateScreen,
+      { mouseTracking: true },
+      createElement(App, props)
+    ), { exitOnCtrlC: false });
+    await instance.waitUntilExit();
+  } finally {
+    disposeUserTimingSweeper();
+  }
 }
 function parsePalAlias(value) {
   const alias = value.trim();
@@ -961,7 +987,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 +998,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 +1030,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 +1055,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,11 @@ 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",
+    env: { ...process.env, NODE_ENV: "production" }
+  });
   const ignoreSignal = () => {
   };
   process.on("SIGINT", ignoreSignal);

package/dist/config/schema.d.ts

@@ -24,6 +24,8 @@ export declare const ProviderConfigSchema: z.ZodObject<{
         high: "high";
         low: "low";
         medium: "medium";
+        minimal: "minimal";
+        xhigh: "xhigh";
     }>>;
     claudeClient: z.ZodOptional<z.ZodBoolean>;
     apiType: z.ZodOptional<z.ZodEnum<{
@@ -79,6 +81,8 @@ export declare const FlavorConfigSchema: z.ZodObject<{
             high: "high";
             low: "low";
             medium: "medium";
+            minimal: "minimal";
+            xhigh: "xhigh";
         }>>;
         claudeClient: z.ZodOptional<z.ZodBoolean>;
         apiType: z.ZodOptional<z.ZodEnum<{
@@ -164,6 +168,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;