flavor-code 1.3.23 → 1.4.0-beta.10

package/dist/{chunk-RQTYHUMK.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,
@@ -86,6 +87,18 @@ var AuditLogger = class {
   }
 };
 
+// src/utils/semver.ts
+import { gt as semverGt, gte as semverGte, valid as semverValid } from "semver";
+function gte(a, b) {
+  return semverGte(a, b, { loose: true });
+}
+function gt(a, b) {
+  return semverGt(a, b, { loose: true });
+}
+function isValidVersion(value) {
+  return semverValid(value, { loose: true }) !== null;
+}
+
 // src/utils/intl.ts
 var graphemeSegmenter;
 function getGraphemeSegmenter() {
@@ -147,6 +160,9 @@ export {
   currentUsageSession,
   appendUsageLog,
   AuditLogger,
+  gte,
+  gt,
+  isValidVersion,
   getGraphemeSegmenter,
   resolveLanguage,
   languageInstruction

package/dist/{claude-ink-6CEG2XZZ.js → claude-ink-6EZHF64C.js}

@@ -10,9 +10,8 @@ import {
   useStdout,
   use_app_default,
   use_input_default
-} from "./chunk-SUSLIHXO.js";
-import "./chunk-OTYFL4AG.js";
-import "./chunk-RQTYHUMK.js";
+} from "./chunk-XMRKRPNC.js";
+import "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 export {
   AlternateScreen,

package/dist/cli-main.js

@@ -3,32 +3,36 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-VEUSROUQ.js";
+} from "./chunk-UO4DLWU5.js";
 import {
-  NPM_PACKAGE_NAME,
-  fetchLatestVersion,
   staticTaskLines
-} from "./chunk-7OICVL2M.js";
+} from "./chunk-RAYH6K2H.js";
 import {
   DEFAULT_MAX_OUTPUT_BYTES,
   MAX_ALIAS_LENGTH,
   MEMORY_TYPES,
   MemoryStore,
+  NPM_PACKAGE_NAME,
   PluginManifestSchema,
   SkillRegistry,
   classifyMemoryHeat,
   createExecutionEnvironment,
   createProductionRuntime,
   executeShell,
+  fetchLatestVersion,
+  formatDoctorReport,
   initializeFlavor,
   installCrashGuard,
   message,
   packageVersion,
   prepareSpawnInvocation,
   redactErrorText,
+  runDoctor,
   runPalBroker
-} from "./chunk-Z62P4LL7.js";
-import "./chunk-CIVPKHF4.js";
+} from "./chunk-BYHO2CA5.js";
+import {
+  MEMORY_RESTART_EXIT_CODE
+} from "./chunk-N5MXHJKD.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -37,12 +41,11 @@ import {
   readRecoverableFile,
   setProjectSkillDisabled,
   updateProtectedFile
-} from "./chunk-RPFWB45Y.js";
+} from "./chunk-EXOSMO57.js";
 import {
   gt,
   isValidVersion
-} from "./chunk-OTYFL4AG.js";
-import "./chunk-RQTYHUMK.js";
+} from "./chunk-ZJCAQXA7.js";
 import "./chunk-S32JRDZK.js";
 
 // src/cli.tsx
@@ -82,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";
@@ -727,7 +749,7 @@ async function runEvaluationFile(path, outputPath) {
     })),
     ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
   };
-  const configured = await import("./load-4FWNXE6F.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 {
@@ -751,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 {
@@ -788,6 +810,21 @@ function createProgram(dependencies = {}) {
       }
     } catch (error) {
       process.stderr.write(`update: ${safeError(error)}
+`);
+      process.exitCode = 1;
+    }
+  });
+  program.command("doctor [directory]").description("Diagnose the local Flavor runtime, configuration, tools, plugins, and npm access").option("--json", "print the report as JSON").action(async (directory, command) => {
+    try {
+      const report = await (dependencies.runDoctor ?? runDoctor)({
+        workspace: resolve3(directory ?? process.cwd()),
+        home: homedir3()
+      });
+      process.stdout.write(command.json ? `${JSON.stringify(report, null, 2)}
+` : formatDoctorReport(report));
+      if (!report.ok) process.exitCode = 1;
+    } catch (error) {
+      process.stderr.write(`doctor: ${safeError(error)}
 `);
       process.exitCode = 1;
     }
@@ -853,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)) {
@@ -879,17 +916,22 @@ function createProgram(dependencies = {}) {
   return program;
 }
 async function runInteractiveCli(props) {
-  const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-    import("./claude-ink-6CEG2XZZ.js"),
-    import("react"),
-    import("./app-NTEUPJKJ.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();
@@ -945,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)}
@@ -956,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));
@@ -988,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)}
 `);
@@ -1009,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/load.d.ts

@@ -5,6 +5,8 @@ export interface LoadConfigOptions {
     home: string;
     cli?: ConfigObject;
     environment?: Record<string, string | undefined>;
+    /** Disable environment persistence for read-only diagnostics. */
+    seedGlobalEnv?: boolean;
 }
 export interface LoadedConfig {
     config: FlavorConfig;

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;