flavor-code 1.3.23 → 1.4.0-beta.10

package/dist/tools/shell.d.ts

@@ -16,12 +16,18 @@ export interface ShellToolOptions {
     defaultTimeoutMs?: number;
     executionEnvironment?: ExecutionEnvironment;
     jobs?: JobRegistry;
+    environment?: NodeJS.ProcessEnv;
 }
 export interface TruncationMetadata {
     truncated: boolean;
     originalBytes: number;
     limitBytes: number;
 }
+export interface ShellDiagnostic {
+    kind: "command-not-found" | "path-not-found" | "permission-denied" | "shell-syntax" | "timeout" | "cancelled" | "non-zero-exit";
+    message: string;
+    hint?: string;
+}
 export interface ShellResult {
     exitCode: number | null;
     signal: NodeJS.Signals | null;
@@ -33,6 +39,7 @@ export interface ShellResult {
         stderr: TruncationMetadata;
     };
     terminationReason: "timeout" | "cancelled" | null;
+    diagnostic?: ShellDiagnostic;
 }
 export interface ShellBackgroundResult extends ShellResult {
     jobId: string;
@@ -55,17 +62,15 @@ export declare function normalizeShellCommand(input: {
     command: string;
     args: string[];
 };
-type WindowsShellKind = "pwsh" | "powershell" | "cmd";
-/**
- * Build the command line handed to cmd.exe via `spawn(shell: true)` on Windows.
- * `commandLine` is the pre-quoted line used directly for the cmd.exe fallback.
- *
- * For PowerShell we do not pass the raw line through cmd: `-EncodedCommand`
- * (UTF-16LE base64) carries the script untouched, so arguments with spaces,
- * quotes or `&` reach the child program exactly as given. `chcp 65001` keeps
- * the console code page UTF-8 so redirected pipes decode consistently.
- */
-export declare function buildWindowsCommandLine(kind: WindowsShellKind, commandLine: string, command: string, args: readonly string[]): string;
+export type RuntimeShell = {
+    kind: "pwsh" | "powershell" | "cmd";
+    command: string;
+} | {
+    kind: "posix";
+    command: string;
+};
+/** The shell reported to the model, checked by doctor, and used for fallbacks. */
+export declare function resolveRuntimeShell(platform?: NodeJS.Platform | string, environment?: NodeJS.ProcessEnv): RuntimeShell | undefined;
 export declare function createShellTool(workspace: string, options?: ShellToolOptions): ShellTool;
-export declare function executeShell(root: string, input: z.infer<typeof ShellInput>, cancellation: AbortSignal, maxBytes: number, onOutput?: (stream: "stdout" | "stderr", text: string) => void): Promise<ShellResult>;
+export declare function executeShell(root: string, input: z.infer<typeof ShellInput>, cancellation: AbortSignal, maxBytes: number, environment?: NodeJS.ProcessEnv, onOutput?: (stream: "stdout" | "stderr", text: string) => void): Promise<ShellResult>;
 export {};

package/dist/tools/types.d.ts

@@ -39,6 +39,7 @@ export interface TerminalToolPresentation {
     command?: string;
     stdout?: string;
     stderr?: string;
+    diagnostic?: string;
     exitCode?: number | null;
     state?: "running" | "completed" | "failed" | "cancelled";
     truncated?: boolean;
@@ -76,7 +77,7 @@ export interface JobToolPresentation {
 }
 export type ToolPresentation = ChangeSetPresentation | FileChangePresentation | GenericToolPresentation | TerminalToolPresentation | WebToolPresentation | JobToolPresentation;
 export declare function withToolPresentation<T extends object>(output: T, presentation: ToolPresentation): T;
-export declare function getToolPresentation(output: unknown): FileChangePresentation | undefined;
+export declare function getToolPresentation(output: unknown): ToolPresentation | undefined;
 export interface ToolDefinition<T, O = unknown> {
     name: string;
     description: string;

package/dist/ui/commands.d.ts

@@ -1,4 +1,4 @@
-export declare const MVP_COMMANDS: readonly ["model", "init", "config", "login", "logout", "permissions", "skills", "plugins", "hooks", "tasks", "finish", "compact", "clear", "help", "exit", "audit", "usage", "loop", "goal", "evolve", "mcp", "commit", "review", "explain", "ide", "memory", "remember", "forget", "forget-cold", "checkpoint", "tree", "rewind", "unrevert", "fork", "pals", "chat", "co-work", "tool"];
+export declare const MVP_COMMANDS: readonly ["model", "init", "config", "login", "logout", "permissions", "skills", "plugins", "hooks", "tasks", "finish", "compact", "clear", "help", "exit", "audit", "usage", "doctor", "loop", "goal", "evolve", "mcp", "commit", "review", "explain", "ide", "memory", "remember", "forget", "forget-cold", "checkpoint", "tree", "rewind", "unrevert", "fork", "pals", "chat", "co-work", "tool"];
 export declare const COMMAND_DESCRIPTIONS: Record<(typeof MVP_COMMANDS)[number], string>;
 export type PermissionCommandMode = PermissionMode;
 export type ModelRole = "main" | "subagent";

package/dist/ui/session.d.ts

@@ -4,6 +4,7 @@ import type { PermissionMode } from "../permissions/engine.js";
 import type { SkillMetadata } from "../skills/registry.js";
 import { type McpSlashCommand, type ModelRole } from "./commands.js";
 import type { QuestionBridge } from "../tools/ask-user-question.js";
+import type { MemoryRestartContinuation } from "../utils/memory-restart.js";
 import type { MemoryType } from "../memory/types.js";
 import { type AgentQueueSnapshot } from "../agent/message-queue.js";
 import type { SessionTreeNode } from "../session/tree.js";
@@ -113,6 +114,14 @@ export interface SessionServices {
     runSkill(skill: string, prompt: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
     runLoop(goal: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
     runGoal(goal: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    /** Resume a /loop interrupted by a heap rotation, keyed by its persisted id. */
+    resumeLoop?(loopId: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    /** Resume a /goal interrupted by a heap rotation, keyed by its persisted id. */
+    resumeGoal?(goalId: string, signal: AbortSignal): AsyncIterable<AgentEvent>;
+    /** The loop/goal a relaunched process should resume after a rotation, consumed once. */
+    continuation?(): MemoryRestartContinuation | undefined;
+    /** True after the runtime has committed to replacing the current heap. */
+    rotationPending?(): boolean;
     mcp(command: McpSlashCommand, signal: AbortSignal): Promise<string>;
     ide?(): Promise<string>;
     ideContext?(): Promise<IdeEditorContext | undefined>;
@@ -130,6 +139,7 @@ export interface SessionServices {
     hooksStatus(): readonly unknown[];
     tasks(): unknown;
     audit(toolFilter?: string): string | Promise<string>;
+    doctor?(): string | Promise<string>;
     evolve(args: readonly string[]): string | Promise<string>;
     gitCommit?(hint: string | undefined, signal: AbortSignal): Promise<string>;
     gitReview?(focus: string | undefined, signal: AbortSignal): Promise<string>;
@@ -185,6 +195,8 @@ export declare class FlavorSession {
     constructor(services: SessionServices);
     get active(): boolean;
     queueSnapshot(): AgentQueueSnapshot;
+    /** True when start() admitted a persisted /loop or /goal continuation. */
+    get rotationContinuationResumed(): boolean;
     clearQueue(): AgentQueueSnapshot;
     whenIdle(): Promise<void>;
     steer(input: string): void;

package/dist/ui/transcript.d.ts

@@ -77,6 +77,9 @@ export interface TranscriptState {
  */
 export declare const MAX_TRANSCRIPT_TURNS = 200;
 export declare const MAX_TRANSCRIPT_CHARS = 2000000;
+/** A /loop or /goal is one presentation turn and can run for days. */
+export declare const MAX_ACTIVE_TRANSCRIPT_BLOCKS = 160;
+export declare const MAX_ACTIVE_ASSISTANT_CHARS = 64000;
 export type TranscriptAction = {
     type: "hydrate";
     messages: readonly TranscriptHistoryMessage[];
@@ -102,3 +105,9 @@ export declare function createTranscriptState(): TranscriptState;
 export declare function transcriptReducer(state: TranscriptState, action: TranscriptAction): TranscriptState;
 export declare function transcriptFromLegacyConversation(messages: readonly TranscriptHistoryMessage[], compact?: TranscriptCompactBoundary): TranscriptState;
 export declare function restoreTranscriptState(state: TranscriptState): TranscriptState;
+/** Rotation-only diagnostic; callers invoke it at most once per restart. */
+export declare function transcriptCensus(state: TranscriptState): {
+    turns: number;
+    blocks: number;
+    chars: number;
+};

package/dist/update/check.d.ts

@@ -0,0 +1,20 @@
+export declare const NPM_PACKAGE_NAME = "flavor-code";
+interface RegistryResponse {
+    ok: boolean;
+    json(): Promise<unknown>;
+}
+export type RegistryFetch = (url: string, init?: {
+    signal?: AbortSignal;
+}) => Promise<RegistryResponse>;
+export interface UpdateCheckOptions {
+    /** Injectable fetch for tests; defaults to the global Node fetch. */
+    fetchImpl?: RegistryFetch;
+    timeoutMs?: number;
+}
+/** Returns `latest` only when it is a valid semver strictly newer than `current`. */
+export declare function findNewerVersion(current: string, latest: string): string | undefined;
+/** Fetch the latest published version from the npm registry; undefined on any failure. */
+export declare function fetchLatestVersion(options?: UpdateCheckOptions): Promise<string | undefined>;
+/** Resolves the newer version to upgrade to, or undefined when up to date / unreachable. */
+export declare function checkForUpdate(current: string, options?: UpdateCheckOptions): Promise<string | undefined>;
+export {};

package/dist/utils/abort.d.ts

@@ -0,0 +1,20 @@
+/** Wait without retaining an abort listener after the operation settles.
+ * The operation must still receive the signal when it supports cancellation.
+ */
+export declare function waitWithSignal<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T>;
+export interface ScopedAbortSignal {
+    readonly signal: AbortSignal;
+    dispose(): void;
+}
+/**
+ * Give one provider request its own short-lived signal while preserving
+ * cancellation from the enclosing turn.
+ *
+ * Some HTTP SDKs attach a once-only listener to the caller's signal and do
+ * not remove it after a successful request. Reusing a turn signal for
+ * hundreds of agent iterations then retains every request controller until
+ * the entire turn ends. Disposing this scope unlinks the turn and aborts the
+ * derived signal so SDK listeners and any unfinished response body release
+ * their references immediately.
+ */
+export declare function createScopedAbortSignal(parent?: AbortSignal): ScopedAbortSignal;

package/dist/utils/execFileNoThrow.d.ts

@@ -4,6 +4,7 @@ export interface ExecFileNoThrowOptions {
     env?: NodeJS.ProcessEnv;
     stdin?: "ignore" | "inherit" | "pipe";
     input?: string;
+    signal?: AbortSignal;
 }
 export declare function execFileNoThrow(file: string, args: string[], options?: ExecFileNoThrowOptions): Promise<{
     stdout: string;

package/dist/utils/heap.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Heap watermarks for the controlled rotation protocol.
+ *
+ * Long-running sessions (interactive turns, /loop cycles, /goal rounds) rotate
+ * onto a fresh heap instead of growing until V8 dies. Two watermarks:
+ *
+ * - MEMORY_PRESSURE_HEAP_RATIO: hard guard checked before every model call.
+ *   Tripping it stops the current turn; the session is persisted first.
+ * - MEMORY_ROTATION_HEAP_RATIO: soft guard checked only at turn/cycle/round
+ *   boundaries. Tripping it rotates between units of work, so multi-day runs
+ *   keep going on a fresh heap without losing the loop or goal in flight.
+ *
+ * Both readings are GC-verified when --expose-gc is available (the launcher
+ * injects it): heapUsed includes uncollected garbage, and declaring pressure
+ * on garbage alone would rotate or stop turns for no reason. A full GC before
+ * judging keeps the decision about the live set only.
+ */
+export declare const MEMORY_PRESSURE_HEAP_RATIO = 0.8;
+export declare const MEMORY_ROTATION_HEAP_RATIO = 0.6;
+export declare const MEMORY_PRESSURE_RSS_RATIO = 0.75;
+export declare const MEMORY_ROTATION_RSS_RATIO = 0.6;
+export interface HeapReading {
+    heapUsed: number;
+    heapLimit: number;
+    ratio: number;
+    /** Ratio measured after a forced full GC; undefined when gc is not exposed. */
+    verifiedRatio?: number;
+    gcVerified: boolean;
+    rss?: number;
+    memoryLimit?: number;
+    rssRatio?: number;
+    external?: number;
+    arrayBuffers?: number;
+}
+export declare function readHeap(): {
+    heapUsed: number;
+    heapLimit: number;
+    ratio: number;
+};
+/**
+ * Hard-guard reading. Returns undefined below the threshold; when the raw
+ * reading crosses it, a full GC (if exposed) decides whether the live set
+ * really is that large. Without --expose-gc the raw reading stands.
+ */
+export declare function verifiedHeapPressure(threshold: number): HeapReading | undefined;
+/**
+ * Boundary rotation decision. Cheap below the precheck ratio; above it the
+ * live set is measured with a full GC and compared against the soft
+ * watermark. Without --expose-gc only a raw reading at the hard watermark
+ * rotates, so an uninstrumented process degrades to the old behaviour.
+ */
+export declare function heapRotationNeeded(): HeapReading | undefined;
+/**
+ * Explicit opt-in only. The launcher already asks V8 for one near-limit
+ * snapshot; synchronously taking another in the recovery path can exhaust the
+ * very heap/RSS headroom needed to persist and exit cleanly.
+ */
+export declare function heapSnapshotWarranted(_reading: HeapReading): boolean;

package/dist/utils/memory-restart.d.ts

@@ -7,23 +7,62 @@
  * relaunches the CLI with `--resume <sessionId>`, so memory pressure restores
  * the saved session instead of ending in a fatal V8 OOM crash. The interrupted
  * turn is intentionally not replayed because it may contain non-idempotent tools.
+ *
+ * Boundary rotations (between turns, /loop cycles, /goal rounds) carry a
+ * `continuation` in the marker: the relaunched process picks the interrupted
+ * loop or goal back up from its persisted state, so multi-day autonomous runs
+ * survive heap rotation without losing the long-running task.
  */
 export declare const MEMORY_RESTART_EXIT_CODE = 75;
 export declare const MEMORY_RESTART_MARKER_FILE = "memory-restart.json";
-export declare const MEMORY_RESTART_MAX_ATTEMPTS = 3;
+/**
+ * Rotations are seamless (the session and any loop/goal resume automatically),
+ * so the budget only exists to stop a pathological spin: 24 rotations inside
+ * one hour still covers a multi-day run rotating every few hours.
+ */
+export declare const MEMORY_RESTART_MAX_ATTEMPTS = 24;
 export declare const MEMORY_RESTART_WINDOW_MS: number;
+/** Two rotations closer together than this mean the fresh heap is born heavy; stop rotating and let the hard guard decide. */
+export declare const MEMORY_RESTART_MIN_GAP_MS: number;
+/**
+ * Leave enough time for a slow launcher, host reboot, or unattended machine
+ * wake-up to recover a persisted long task. Session/id validation still keeps
+ * an unrelated stale marker from resuming in the wrong process.
+ */
+export declare const MEMORY_RESTART_CONTINUATION_TTL_MS: number;
+export interface MemoryRestartContinuation {
+    kind: "loop" | "goal";
+    id: string;
+}
 export interface MemoryRestartMarker {
     sessionId: string;
+    /** Start of the fixed accounting window; unlike requestedAt this does not slide. */
+    windowStartedAt?: string;
     requestedAt: string;
     attempts: number;
+    continuation?: MemoryRestartContinuation;
 }
+/** Recorded when a rotation is requested; orchestrators skip terminal bookkeeping on the way out. */
+export declare function markMemoryRotation(): void;
+export declare function memoryRotationActive(): boolean;
+/** In-process hosts clear this only after the old runtime has been fully disposed. */
+export declare function clearMemoryRotation(): void;
 export declare function memoryRestartMarkerPath(workspace: string): string;
 /**
- * Count restarts per session inside a rolling window. A marker for a
+ * Count restarts per session inside a fixed window. A marker for a
  * different session or an expired window starts counting from one again, so
  * a healthy long-lived session never exhausts the budget.
  */
-export declare function nextMemoryRestartMarker(previous: MemoryRestartMarker | undefined, sessionId: string, now: Date): MemoryRestartMarker;
+export declare function nextMemoryRestartMarker(previous: MemoryRestartMarker | undefined, sessionId: string, now: Date, continuation?: MemoryRestartContinuation): MemoryRestartMarker;
+/**
+ * Remove a consumed continuation without turning marker consumption into a
+ * second restart attempt or extending the accounting/cooldown windows.
+ */
+export declare function consumedMemoryRestartMarker(marker: MemoryRestartMarker): MemoryRestartMarker;
+/** True when the previous rotation for this session is too recent for another seamless one. */
+export declare function rotationCooldownActive(marker: MemoryRestartMarker | undefined, sessionId: string, now: Date): boolean;
+/** The continuation a relaunched process should pick up, if still fresh. */
+export declare function pendingContinuation(marker: MemoryRestartMarker | undefined, sessionId: string, now: Date): MemoryRestartContinuation | undefined;
 export declare function shouldRelaunchForMemoryRestart(marker: MemoryRestartMarker | undefined): boolean;
 /**
  * Rebuild the CLI arguments for the relaunched process: drop any existing

package/dist/utils/process-tree.d.ts

@@ -0,0 +1,2 @@
+/** POSIX callers must spawn the root in its own process group (detached=true). */
+export declare function terminateProcessTree(pid: number | undefined): Promise<void>;

package/dist/utils/rotation-census.d.ts

@@ -0,0 +1,36 @@
+import type { HeapReading } from "./heap.js";
+/**
+ * Rotation forensics. Every heap rotation leaves a retention census: each
+ * major in-memory holder reports its retained size, so the next recurrence
+ * names its own grower instead of restarting with zero evidence. A full
+ * .heapsnapshot accompanies rotations whose verified live set is near the
+ * hard limit (or every rotation under FLAVOR_HEAP_SNAPSHOT_ON_ROTATE=1).
+ */
+export interface RotationCensusHolder {
+    entries?: number;
+    chars?: number;
+    bytes?: number;
+}
+export interface RotationCensus {
+    at: string;
+    reason: string;
+    sessionId: string;
+    heap: {
+        heapUsedMb: number;
+        heapLimitMb: number;
+        rawRatio: number;
+        verifiedRatio?: number;
+        gcVerified: boolean;
+        rssMb: number;
+        externalMb: number;
+        arrayBuffersMb: number;
+        memoryLimitMb?: number;
+        rssRatio?: number;
+    };
+    holders: Record<string, RotationCensusHolder>;
+}
+export declare function censusHeapBlock(reading: HeapReading): RotationCensus["heap"];
+/** Best-effort: a failed census must never block the rotation itself. */
+export declare function writeRotationCensus(workspace: string, census: RotationCensus): string | undefined;
+/** Best-effort heap snapshot; synchronous and slow on large heaps by nature. */
+export declare function writeRotationHeapSnapshot(workspace: string): string | undefined;

package/dist/utils/semver.d.ts

@@ -0,0 +1,3 @@
+export declare function gte(a: string, b: string): boolean;
+export declare function gt(a: string, b: string): boolean;
+export declare function isValidVersion(value: string): boolean;

package/dist/utils/spawn-executable.d.ts

@@ -14,3 +14,5 @@ export interface PrepareSpawnOptions {
  * the original argv boundary and all other platforms are unchanged.
  */
 export declare function prepareSpawnInvocation(command: string, args: readonly string[], options?: PrepareSpawnOptions): PreparedSpawnInvocation;
+/** Resolve an executable exactly as the structured Shell runner will see it. */
+export declare function resolveExecutablePath(command: string, options?: PrepareSpawnOptions): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flavor-code",
-  "version": "1.3.23",
+  "version": "1.4.0-beta.10",
   "author": "YachuanWzh",
   "type": "module",
   "publishConfig": {
@@ -31,7 +31,7 @@
   "scripts": {
     "build": "npm run build:icons && npm run build:cli && npm run build:desktop",
     "build:icons": "node scripts/build-icons.mjs",
-    "build:cli": "tsup && tsc -p tsconfig.sdk.json && node -e \"require('fs').cpSync('src/init/astgraph','dist/astgraph',{recursive:true})\"",
+    "build:cli": "tsup && tsc -p tsconfig.sdk.json && node scripts/assert-production-cli.mjs",
     "build:desktop": "npm run build:desktop:main && npm run build:desktop:renderer",
     "build:desktop:main": "tsup --config tsup.desktop.config.ts",
     "build:desktop:renderer": "vite build --config vite.desktop.config.ts",
@@ -52,6 +52,7 @@
     "smoke:install": "node scripts/smoke-install.mjs",
     "smoke:d2c-worker": "npm run build:desktop:main && node scripts/smoke-d2c-worker.mjs",
     "stress:context": "vitest run scripts/stress-context-memory.test.ts --reporter=verbose",
+    "stress:tui-memory": "npm run build:cli && node scripts/run-tui-memory-stress.mjs",
     "stress:production-memory": "npm run build:cli && node scripts/stress-production-memory.mjs",
     "evidence:crash-fix": "vitest run scripts/evidence-crash-replay.test.ts --reporter=verbose",
     "prepack": "npm run build"