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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flavor-code",
-  "version": "1.4.0-beta.1",
+  "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"

package//346/212/200/346/234/257/346/226/271/346/241/210/346/212/245/345/221/212.md

@@ -405,7 +405,7 @@ sequenceDiagram
     U->>CLI: 输入 prompt
     CLI->>L: submit(prompt, signal)
 
-    loop 每轮迭代（最多 80 轮）
+    loop 每轮迭代（最多 300 轮）
         L->>C: prepareForModelCall()
         C->>C: 微压缩（清理旧工具输出）
         alt 仍超阈值
@@ -560,13 +560,13 @@ FlavorConfigSchema = {
   },
   language: "zh-CN",                   // BCP47 语言标签
   maxIterations: {
-    main: 10-500,                      // 主 Agent 迭代上限（默认 80）
-    subagent: 10-200,                  // 子 Agent 迭代上限（默认 40）
+    main: 10-500,                      // 主 Agent 迭代上限（默认 300）
+    subagent: 10-200,                  // 子 Agent 迭代上限（默认 100）
     softLimitFactor: 0.8,              // 软限制比例
-    extendBy: 20                       // 扩展步数
+    extendBy: 50                       // 扩展步数
   },
   loop: {
-    maxCycles: 20,                     // 每次用户授权增加的 cycle 数
+    maxCycles: 100,                    // 每次用户授权增加的 cycle 数
     maxTokens: 500_000,                // 每次用户授权增加的模型 token 数
     isolation: "auto"                  // 只读用当前目录；改代码自动用 worktree
   },
@@ -749,8 +749,8 @@ flowchart TD
 maxTokens = 5,000,000
 5,000,000 → 确认 → 10,000,000 → 确认 → 15,000,000 → ...
 
-maxCycles = 20
-20 → 确认 → 40 → 确认 → 60 → ...
+maxCycles = 100
+100 → 确认 → 200 → 确认 → 300 → ...
 ```
 
 token 统计包括 worker 的所有模型调用以及上下文压缩模型调用；本地 Shell 验证命令不计 token。用户拒绝产生 `budget_exhausted`；非交互模式无法确认时产生 `needs_human`。预算批准记录维度、旧/新 checkpoint、当时累计用量和时间戳。

package/dist/astgraph/db.mjs

@@ -1,237 +0,0 @@
-// astgraph graph database — SQLite-backed node/edge graph (codegraph-inspired).
-// Uses node:sqlite with WAL mode so concurrent readers never block on a writer.
-
-import { mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-
-const SCHEMA = `
-CREATE TABLE IF NOT EXISTS schema_versions (
-    version INTEGER PRIMARY KEY,
-    applied_at INTEGER NOT NULL,
-    description TEXT
-);
-
-CREATE TABLE IF NOT EXISTS files (
-    path TEXT PRIMARY KEY,
-    content_hash TEXT NOT NULL,
-    language TEXT NOT NULL,
-    size INTEGER NOT NULL,
-    modified_at INTEGER NOT NULL DEFAULT 0,
-    indexed_at INTEGER NOT NULL DEFAULT 0,
-    node_count INTEGER NOT NULL DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS nodes (
-    id TEXT PRIMARY KEY,
-    kind TEXT NOT NULL,
-    name TEXT NOT NULL,
-    qualified_name TEXT NOT NULL,
-    file_path TEXT NOT NULL,
-    language TEXT NOT NULL,
-    start_line INTEGER NOT NULL,
-    end_line INTEGER NOT NULL,
-    signature TEXT,
-    docstring TEXT,
-    is_exported INTEGER NOT NULL DEFAULT 0,
-    is_async INTEGER NOT NULL DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS edges (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    source TEXT NOT NULL,
-    target TEXT NOT NULL,
-    kind TEXT NOT NULL,
-    line INTEGER,
-    col INTEGER,
-    FOREIGN KEY (source) REFERENCES nodes(id) ON DELETE CASCADE,
-    FOREIGN KEY (target) REFERENCES nodes(id) ON DELETE CASCADE
-);
-
-CREATE TABLE IF NOT EXISTS unresolved_refs (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    from_node_id TEXT,
-    reference_name TEXT NOT NULL,
-    reference_kind TEXT NOT NULL,
-    line INTEGER NOT NULL,
-    col INTEGER NOT NULL,
-    file_path TEXT NOT NULL DEFAULT '',
-    module_specifier TEXT,
-    status TEXT NOT NULL DEFAULT 'pending',
-    FOREIGN KEY (from_node_id) REFERENCES nodes(id) ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name);
-CREATE INDEX IF NOT EXISTS idx_nodes_lower_name ON nodes(lower(name));
-CREATE INDEX IF NOT EXISTS idx_nodes_file_path ON nodes(file_path);
-CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind);
-CREATE INDEX IF NOT EXISTS idx_edges_source_kind ON edges(source, kind);
-CREATE INDEX IF NOT EXISTS idx_edges_target_kind ON edges(target, kind);
-CREATE UNIQUE INDEX IF NOT EXISTS idx_edges_identity
-  ON edges(source, target, kind, IFNULL(line, -1), IFNULL(col, -1));
-CREATE INDEX IF NOT EXISTS idx_unresolved_from ON unresolved_refs(from_node_id);
-CREATE INDEX IF NOT EXISTS idx_unresolved_name ON unresolved_refs(reference_name);
-
-CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(
-    name,
-    qualified_name,
-    signature,
-    docstring,
-    content='nodes',
-    content_rowid='rowid'
-);
-
-CREATE TRIGGER IF NOT EXISTS nodes_ai AFTER INSERT ON nodes BEGIN
-    INSERT INTO nodes_fts(rowid, name, qualified_name, signature, docstring)
-    VALUES (NEW.rowid, NEW.name, NEW.qualified_name, NEW.signature, NEW.docstring);
-END;
-
-CREATE TRIGGER IF NOT EXISTS nodes_ad AFTER DELETE ON nodes BEGIN
-    INSERT INTO nodes_fts(nodes_fts, rowid, name, qualified_name, signature, docstring)
-    VALUES ('delete', OLD.rowid, OLD.name, OLD.qualified_name, OLD.signature, OLD.docstring);
-END;
-
-CREATE TRIGGER IF NOT EXISTS nodes_au AFTER UPDATE ON nodes BEGIN
-    INSERT INTO nodes_fts(nodes_fts, rowid, name, qualified_name, signature, docstring)
-    VALUES ('delete', OLD.rowid, OLD.name, OLD.qualified_name, OLD.signature, OLD.docstring);
-    INSERT INTO nodes_fts(rowid, name, qualified_name, signature, docstring)
-    VALUES (NEW.rowid, NEW.name, NEW.qualified_name, NEW.signature, NEW.docstring);
-END;
-
-CREATE TABLE IF NOT EXISTS project_metadata (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL,
-    updated_at INTEGER NOT NULL
-);
-`;
-
-/** Open (creating when absent) the graph database at `path`. Returns a DatabaseSync. */
-export function openDb(path) {
-  if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
-  const db = new DatabaseSync(path);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  db.exec("PRAGMA synchronous = NORMAL");
-  db.exec(SCHEMA);
-  const version = db.prepare("SELECT COUNT(*) AS count FROM schema_versions").get();
-  if (version.count === 0) {
-    db.prepare("INSERT INTO schema_versions(version, applied_at, description) VALUES (?, ?, ?)")
-      .run(1, Date.now(), "Initial astgraph schema");
-  }
-  return db;
-}
-
-/** Insert or replace the tracking record for one source file. */
-export function upsertFileRecord(db, record) {
-  db.prepare(`
-    INSERT INTO files(path, content_hash, language, size, modified_at, indexed_at, node_count)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(path) DO UPDATE SET
-      content_hash = excluded.content_hash,
-      language = excluded.language,
-      size = excluded.size,
-      modified_at = excluded.modified_at,
-      indexed_at = excluded.indexed_at,
-      node_count = excluded.node_count
-  `).run(
-    record.path, record.contentHash, record.language, record.size,
-    record.modifiedAt ?? Date.now(), record.indexedAt ?? Date.now(), record.nodeCount ?? 0,
-  );
-}
-
-/** Read the tracking record for one source file, or undefined when absent. */
-export function getFileRecord(db, path) {
-  const row = db.prepare("SELECT * FROM files WHERE path = ?").get(path);
-  if (row === undefined) return undefined;
-  return {
-    path: row.path, contentHash: row.content_hash, language: row.language,
-    size: row.size, modifiedAt: row.modified_at, indexedAt: row.indexed_at,
-    nodeCount: row.node_count,
-  };
-}
-
-/** Delete a file record; nodes cascade (and with them edges + refs + FTS rows). */
-export function deleteFileRecord(db, path) {
-  db.prepare("DELETE FROM nodes WHERE file_path = ?").run(path);
-  db.prepare("DELETE FROM files WHERE path = ?").run(path);
-}
-
-/**
- * Replace every node belonging to a file. Runs inside one transaction; the FTS
- * triggers keep nodes_fts in sync.
- */
-export function replaceNodes(db, filePath, nodes) {
-  const insert = db.prepare(`
-    INSERT OR REPLACE INTO nodes(
-      id, kind, name, qualified_name, file_path, language,
-      start_line, end_line, signature, docstring, is_exported, is_async
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  const clear = db.prepare("DELETE FROM nodes WHERE file_path = ?");
-  db.exec("BEGIN");
-  try {
-    clear.run(filePath);
-    for (const node of nodes) {
-      insert.run(
-        node.id, node.kind, node.name, node.qualifiedName, node.filePath, node.language,
-        node.startLine, node.endLine, node.signature ?? null, node.docstring ?? null,
-        node.isExported ? 1 : 0, node.isAsync ? 1 : 0,
-      );
-    }
-    db.exec("COMMIT");
-  } catch (error) {
-    db.exec("ROLLBACK");
-    throw error;
-  }
-}
-
-/** Insert one edge; duplicate (source, target, kind, line, col) rows are ignored. */
-export function insertEdge(db, edge) {
-  db.prepare(`
-    INSERT OR IGNORE INTO edges(source, target, kind, line, col) VALUES (?, ?, ?, ?, ?)
-  `).run(edge.source, edge.target, edge.kind, edge.line ?? null, edge.col ?? null);
-}
-
-/** Delete every edge whose source OR target belongs to a file. */
-export function deleteEdgesForFile(db, filePath) {
-  db.prepare(`
-    DELETE FROM edges WHERE source IN (SELECT id FROM nodes WHERE file_path = ?)
-       OR target IN (SELECT id FROM nodes WHERE file_path = ?)
-  `).run(filePath, filePath);
-}
-
-/** Insert one unresolved cross-file reference (status 'pending'). */
-export function insertUnresolvedRef(db, ref) {
-  db.prepare(`
-    INSERT INTO unresolved_refs(from_node_id, reference_name, reference_kind, line, col, file_path, module_specifier, status)
-    VALUES (?, ?, ?, ?, ?, ?, ?, 'pending')
-  `).run(ref.fromNodeId, ref.referenceName, ref.referenceKind, ref.line, ref.col, ref.filePath, ref.moduleSpecifier ?? null);
-}
-
-/** Delete every unresolved reference originating from a file. */
-export function deleteUnresolvedRefsForFile(db, filePath) {
-  db.prepare("DELETE FROM unresolved_refs WHERE file_path = ?").run(filePath);
-}
-
-/** Summary counters used by /ast status. */
-export function stats(db) {
-  const files = db.prepare("SELECT COUNT(*) AS count FROM files").get().count;
-  const nodes = db.prepare("SELECT COUNT(*) AS count FROM nodes").get().count;
-  const edges = db.prepare("SELECT COUNT(*) AS count FROM edges").get().count;
-  const unresolved = db.prepare("SELECT COUNT(*) AS count FROM unresolved_refs WHERE status = 'pending'").get().count;
-  return { files, nodes, edges, unresolved };
-}
-
-/** Store a provenance metadata value. */
-export function setMetadata(db, key, value) {
-  db.prepare(`
-    INSERT INTO project_metadata(key, value, updated_at) VALUES (?, ?, ?)
-    ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
-  `).run(key, value, Date.now());
-}
-
-/** Read a provenance metadata value, or undefined when absent. */
-export function getMetadata(db, key) {
-  const row = db.prepare("SELECT value FROM project_metadata WHERE key = ?").get(key);
-  return row?.value;
-}