flavor-code 1.3.2 → 1.3.4

package/README.md

@@ -252,10 +252,10 @@ flavor mcp disable docs
 
 A Skill is a `SKILL.md` with YAML frontmatter, placed in `.flavor/skills/<name>/` or `~/.flavor-code/skills/<name>/`. Flavor loads skills progressively based on the task, and you can invoke one explicitly with `/<skill-name>`. Skill bodies support `$ARGUMENTS`, `$ARGUMENTS[N]`, and `$N` substitutions. A running composite Skill can load a dependency through the read-only `Skill` tool; plugin-qualified names such as `superharness:test-driven-development` resolve to discovered skills.
 
-Plugins live in `.flavor/plugins/` and can register commands, tools, hooks, Skill roots, and model adapters. `additionalContext` returned by `SessionStart` and `UserPromptSubmit` hooks is added to the current task context, enabling reliable project-level engineering policy injection. Production plugin activation is isolated in a Worker/vm realm by default and records a content fingerprint plus declared capabilities.
+Plugins live in `.flavor/plugins/` and can register commands, tools, hooks, Skill roots, and model adapters. `additionalContext` returned by `SessionStart` and `UserPromptSubmit` hooks is added to the current task context, enabling reliable project-level engineering policy injection. Plugin loads record a content fingerprint plus declared capabilities. Worker/vm isolation is available through the embedding API's `pluginSandbox: true` option; the compatibility default remains in-process because bundled and existing plugins use Node.js APIs that the isolated runtime does not yet mediate.
 
 > [!WARNING]
-> Sandboxing reduces ambient access but does not make untrusted instructions safe. Only install and enable plugins you trust; legacy `pluginSandbox: false` activation grants full in-process Node.js access.
+> The default in-process plugin runtime grants full Node.js access. Only install and enable plugins you trust. Sandboxing reduces ambient access but does not make untrusted instructions safe, and plugins that import Node.js built-ins will not load with `pluginSandbox: true` yet.
 
 ## Sessions, Memory & Execution Records
 

package/README.zh-CN.md

@@ -252,10 +252,10 @@ flavor mcp disable docs
 
 Skill 是带有 YAML 头信息的 `SKILL.md`，放在 `.flavor/skills/<name>/` 或 `~/.flavor-code/skills/<name>/`。Flavor 会按任务渐进加载，也支持通过 `/<skill-name>` 显式调用。Skill 正文支持 `$ARGUMENTS`、`$ARGUMENTS[N]` 和 `$N` 参数占位符；运行中的组合 Skill 可以使用只读 `Skill` 工具继续加载依赖 Skill，插件限定名称（如 `superharness:test-driven-development`）会安全解析到已发现的 Skill。
 
-插件放在 `.flavor/plugins/`，可以注册命令、工具、Hook、Skill 根目录和模型适配器。`SessionStart` 与 `UserPromptSubmit` Hook 返回的 `additionalContext` 会进入当前任务上下文，可用于注入项目级工程规则。产品运行时默认在 Worker/vm 隔离环境激活插件，并记录内容指纹与声明的能力。
+插件放在 `.flavor/plugins/`，可以注册命令、工具、Hook、Skill 根目录和模型适配器。`SessionStart` 与 `UserPromptSubmit` Hook 返回的 `additionalContext` 会进入当前任务上下文，可用于注入项目级工程规则。插件加载会记录内容指纹与声明的能力。可通过嵌入 API 的 `pluginSandbox: true` 启用 Worker/vm 隔离；由于内置插件和已有插件依赖沙箱尚未代理的 Node.js API，当前兼容默认值仍为进程内运行。
 
 > [!WARNING]
-> 沙箱会降低环境权限，但不能让不可信指令自动变安全。只安装和启用可信插件；旧版兼容选项 `pluginSandbox: false` 会授予完整的进程内 Node.js 权限。
+> 默认的进程内插件运行时拥有完整 Node.js 权限，只安装和启用你信任的插件。沙箱会降低环境权限，但不能让不可信指令自动变安全；目前导入 Node.js 内置模块的插件在 `pluginSandbox: true` 下仍无法加载。
 
 ## 会话、记忆与执行记录
 

package/dist/{app-F6FEEF46.js → app-EHB3XAQY.js}

@@ -16,7 +16,7 @@ import {
   redactErrorText,
   transcriptReducer,
   withTimeout
-} from "./chunk-Q5EQ4T3F.js";
+} from "./chunk-YKSMZDUZ.js";
 import "./chunk-IG4Z23CL.js";
 import {
   Box_default,

package/dist/{chunk-DFSMJ5SX.js → chunk-RDBTC35M.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-Q5EQ4T3F.js";
+} from "./chunk-YKSMZDUZ.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";

package/dist/{chunk-Q5EQ4T3F.js → chunk-YKSMZDUZ.js}

@@ -561,7 +561,7 @@ function redactSecrets(input, secrets) {
 
 // src/init/project.ts
 import { lstat, mkdir, readdir, readFile, realpath, writeFile } from "fs/promises";
-import { copyFileSync, mkdirSync, readdirSync, readFileSync } from "fs";
+import { copyFileSync, mkdirSync, readdirSync } from "fs";
 import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join, relative as relative2, sep as sep2 } from "path";
 import { fileURLToPath } from "url";
 var GENERATED_START = "<!-- flavor-code:start -->";
@@ -1014,22 +1014,6 @@ async function createExampleFlavorConfig(cwd) {
   };
   await writeFile(configPath, JSON.stringify(example, null, 2) + "\n");
 }
-var CODEISLAND_SRC_DIR = join(dirname2(fileURLToPath(import.meta.url)), "codeisland");
-var CODEISLAND_FILES = ["flavor-plugin.json", "activate.mjs", "bridge.mjs"];
-async function copyCodeIslandPlugin(cwd) {
-  const pluginDir = join(cwd, ".flavor", "plugins", "codeisland");
-  try {
-    await lstat(pluginDir);
-    return;
-  } catch (error) {
-    if (!isMissingPathError(error)) throw error;
-  }
-  await mkdir(pluginDir, { recursive: true, mode: 448 });
-  for (const name of CODEISLAND_FILES) {
-    const content = readFileSync(join(CODEISLAND_SRC_DIR, name), "utf8");
-    await writeFile(join(pluginDir, name), content);
-  }
-}
 var ASTGRAPH_SRC_DIR = join(dirname2(fileURLToPath(import.meta.url)), "astgraph");
 async function copyAstgraphPlugin(cwd) {
   const pluginDir = join(cwd, ".flavor", "plugins", "astgraph");
@@ -1052,7 +1036,6 @@ function copyDirectory(from, to) {
 }
 async function initializeFlavor(cwd) {
   await ensureFlavorDirectories(cwd);
-  await copyCodeIslandPlugin(cwd);
   await copyAstgraphPlugin(cwd);
   await createExampleFlavorConfig(cwd);
   const facts = await inspectProject(cwd);
@@ -1074,7 +1057,7 @@ async function initializeFlavor(cwd) {
 }
 
 // src/utils/version.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync } from "fs";
 import { dirname as dirname3, join as join2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cached;
@@ -1083,7 +1066,7 @@ function packageVersion() {
   let directory = dirname3(fileURLToPath2(import.meta.url));
   for (; ; ) {
     try {
-      const manifest = JSON.parse(readFileSync2(join2(directory, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync(join2(directory, "package.json"), "utf8"));
       if (typeof manifest.version === "string" && manifest.version.length > 0) {
         cached = manifest.version;
         return cached;
@@ -8002,7 +7985,7 @@ function toModelTool(tool) {
 
 // src/harness/journal.ts
 import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
-import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, realpathSync as realpathSync2, statSync, truncateSync, writeSync } from "fs";
+import { closeSync, constants, existsSync as existsSync2, fsyncSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync as realpathSync2, renameSync, statSync, truncateSync, unlinkSync, writeSync } from "fs";
 import { join as join8, relative as relative7, resolve as resolve8, sep as sep7 } from "path";
 import { z as z10 } from "zod";
 
@@ -8013,8 +7996,10 @@ function harnessInvariantViolations(records) {
   const tools = /* @__PURE__ */ new Set();
   const models = /* @__PURE__ */ new Set();
   const turns = /* @__PURE__ */ new Set();
+  const firstSequence = records[0]?.sequence ?? 1;
   records.forEach((record, index) => {
-    if (record.sequence !== index + 1) violations.push(`sequence ${record.sequence} is not ${index + 1}`);
+    const expectedSequence = firstSequence + index;
+    if (record.sequence !== expectedSequence) violations.push(`sequence ${record.sequence} is not ${expectedSequence}`);
     const id = typeof record.payload.id === "string" ? record.payload.id : "";
     if (record.type === "queue.admitted") {
       if (queues.has(id)) violations.push(`queue ${id} was admitted twice`);
@@ -8030,13 +8015,13 @@ function harnessInvariantViolations(records) {
       if (!tools.delete(id)) violations.push(`${record.type} references unknown tool ${id}`);
     } else if (record.type === "model.requested") {
       if (models.has(id)) violations.push(`model ${id} was requested twice`);
-      if (!Array.isArray(record.payload.messages)) violations.push(`model ${id} has no replayable messages`);
+      if (!isHash(record.payload.messagesHash)) violations.push(`model ${id} has no valid messages hash`);
       models.add(id);
     } else if (record.type === "model.completed") {
       if (!models.delete(id)) violations.push(`model.completed references unknown model ${id}`);
     } else if (record.type === "turn.started") {
       if (turns.has(id)) violations.push(`turn ${id} was started twice`);
-      if (!("prompt" in record.payload)) violations.push(`turn ${id} has no replayable prompt`);
+      if (!isHash(record.payload.promptHash)) violations.push(`turn ${id} has no valid prompt hash`);
       turns.add(id);
     } else if (record.type === "turn.completed" || record.type === "turn.interrupted") {
       if (!turns.delete(id)) violations.push(`${record.type} references unknown turn ${id}`);
@@ -8044,6 +8029,9 @@ function harnessInvariantViolations(records) {
   });
   return violations;
 }
+function isHash(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
 function assertHarnessInvariants(records) {
   const violations = harnessInvariantViolations(records);
   if (violations.length > 0) throw new Error(`Harness invariant violation: ${violations.join("; ")}`);
@@ -8124,7 +8112,7 @@ var HarnessJournal = class {
   }
   startTurn(config, prompt) {
     const id = randomUUID8();
-    this.#append("turn.started", { id, config: structuredClone(config), configHash: hashJson(config), prompt: structuredClone(prompt), promptHash: hashJson(prompt) });
+    this.#append("turn.started", { id, configHash: hashJson(config), promptHash: hashJson(prompt) });
     return id;
   }
   completeTurn(id) {
@@ -8135,7 +8123,14 @@ var HarnessJournal = class {
   }
   startModel(input) {
     const id = randomUUID8();
-    this.#append("model.requested", { id, ...structuredClone(input), messagesHash: hashJson(input.messages) });
+    this.#append("model.requested", {
+      id,
+      agent: input.agent,
+      model: input.model,
+      iteration: input.iteration,
+      attempt: input.attempt,
+      messagesHash: hashJson(input.messages)
+    });
     return id;
   }
   completeModel(id, completed, error) {
@@ -8143,11 +8138,11 @@ var HarnessJournal = class {
   }
   startTool(tool, input, retrySafe) {
     const id = randomUUID8();
-    this.#append("tool.started", { id, tool, input: structuredClone(input), inputHash: hashJson(input), retrySafe });
+    this.#append("tool.started", { id, tool, inputHash: hashJson(input), retrySafe });
     return id;
   }
   completeTool(id, result) {
-    this.#append("tool.completed", { id, result: structuredClone(result) });
+    this.#append("tool.completed", { id, resultHash: hashJson(result) });
   }
   interruptTool(id, reason) {
     this.#append("tool.interrupted", { id, reason });
@@ -8220,51 +8215,157 @@ var HarnessJournal = class {
     const metadata = statSync(this.#path);
     if (!metadata.isFile()) throw new Error("Harness journal path is not a regular file");
     if (metadata.size > this.#maxBytes) throw new Error(`Harness journal exceeds ${this.#maxBytes} bytes`);
-    const raw = readFileSync3(this.#path, "utf8");
+    const raw = readFileSync2(this.#path, "utf8");
     const committed = raw.endsWith("\n") ? raw : raw.slice(0, Math.max(0, raw.lastIndexOf("\n") + 1));
     if (committed.length !== raw.length) truncateSync(this.#path, Buffer.byteLength(committed));
     const lines = committed.split("\n").filter(Boolean);
-    let previousHash = null;
+    let previousHash;
+    let expectedSequence;
     for (const line of lines) {
       const record = JournalRecordSchema.parse(JSON.parse(line));
-      if (record.sequence !== this.#records.length + 1) throw new Error("Harness journal sequence is not contiguous");
+      expectedSequence ??= record.sequence;
+      previousHash ??= record.previousHash;
+      if (record.sequence !== expectedSequence) throw new Error("Harness journal sequence is not contiguous");
       if (record.previousHash !== previousHash) throw new Error("Harness journal hash chain is broken");
       if (record.hash !== recordHash(record)) throw new Error("Harness journal record hash is invalid");
       this.#records.push(record);
       previousHash = record.hash;
+      expectedSequence += 1;
     }
-    this.#sequence = this.#records.length;
-    this.#lastHash = previousHash;
+    this.#sequence = this.#records.at(-1)?.sequence ?? 0;
+    this.#lastHash = previousHash ?? null;
     assertHarnessInvariants(this.#records);
+    const hasRotatedPrefix = (this.#records[0]?.sequence ?? 1) !== 1;
+    if (metadata.size > this.#maxBytes * 0.75 || hasRotatedPrefix || this.#records.some(hasLegacyPayload)) this.#compact();
   }
   #append(type, payload) {
     const normalizedPayload = jsonSafeRecord(payload);
+    let record = this.#createRecord(type, normalizedPayload);
+    let line = `${JSON.stringify(record)}
+`;
+    let priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+      this.#compact();
+      record = this.#createRecord(type, normalizedPayload);
+      line = `${JSON.stringify(record)}
+`;
+      priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
+      if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) {
+        throw new Error(`Harness journal event exceeds the ${this.#maxBytes} byte bounded journal capacity`);
+      }
+    }
+    const fd = openSync(this.#path, constants.O_CREAT | constants.O_APPEND | constants.O_WRONLY, 384);
+    try {
+      writeSync(fd, line, void 0, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    this.#records.push(record);
+    this.#sequence = record.sequence;
+    this.#lastHash = record.hash;
+  }
+  #createRecord(type, payload) {
     const unsigned = {
       version: HARNESS_JOURNAL_VERSION,
       sequence: this.#sequence + 1,
       id: randomUUID8(),
       timestamp: this.#now(),
       type,
-      payload: normalizedPayload,
+      payload,
       previousHash: this.#lastHash
     };
-    const record = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
-    const line = `${JSON.stringify(record)}
-`;
-    const priorBytes = existsSync2(this.#path) ? statSync(this.#path).size : 0;
-    if (priorBytes + Buffer.byteLength(line) > this.#maxBytes) throw new Error(`Harness journal exceeds ${this.#maxBytes} bytes`);
-    const fd = openSync(this.#path, constants.O_CREAT | constants.O_APPEND | constants.O_WRONLY, 384);
+    return JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+  }
+  #compact() {
+    const queues = /* @__PURE__ */ new Map();
+    const claims = /* @__PURE__ */ new Map();
+    const tools = /* @__PURE__ */ new Map();
+    const models = /* @__PURE__ */ new Map();
+    const turns = /* @__PURE__ */ new Map();
+    let savepoint;
+    for (const record of this.#records) {
+      const id = typeof record.payload.id === "string" ? record.payload.id : "";
+      if (record.type === "queue.admitted") queues.set(id, record);
+      else if (record.type === "queue.claimed") claims.set(id, record);
+      else if (record.type === "queue.released") claims.delete(id);
+      else if (record.type === "queue.acked") {
+        queues.delete(id);
+        claims.delete(id);
+      } else if (record.type === "tool.started") tools.set(id, record);
+      else if (record.type === "tool.completed" || record.type === "tool.interrupted") tools.delete(id);
+      else if (record.type === "model.requested") models.set(id, record);
+      else if (record.type === "model.completed") models.delete(id);
+      else if (record.type === "turn.started") turns.set(id, record);
+      else if (record.type === "turn.completed" || record.type === "turn.interrupted") turns.delete(id);
+      else if (record.type === "savepoint.created") savepoint = record;
+    }
+    const retained = [
+      ...queues.values(),
+      ...claims.values(),
+      ...tools.values(),
+      ...models.values(),
+      ...turns.values(),
+      ...savepoint === void 0 ? [] : [savepoint]
+    ].sort((left, right) => left.sequence - right.sequence);
+    const compacted = [];
+    let previousHash = null;
+    for (const source of retained) {
+      const unsigned = {
+        version: HARNESS_JOURNAL_VERSION,
+        sequence: compacted.length + 1,
+        id: randomUUID8(),
+        timestamp: source.timestamp,
+        type: source.type,
+        payload: compactPayload(source),
+        previousHash
+      };
+      const record = JournalRecordSchema.parse({ ...unsigned, hash: hashJson(unsigned) });
+      compacted.push(record);
+      previousHash = record.hash;
+    }
+    const contents = compacted.map((record) => `${JSON.stringify(record)}
+`).join("");
+    if (Buffer.byteLength(contents) > this.#maxBytes) return;
+    const temporary = `${this.#path}.compact-${process.pid}-${randomUUID8()}`;
+    const fd = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
     try {
-      writeSync(fd, line, void 0, "utf8");
+      writeSync(fd, contents, void 0, "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);
     }
-    this.#records.push(record);
-    this.#sequence = record.sequence;
-    this.#lastHash = record.hash;
+    try {
+      renameSync(temporary, this.#path);
+    } catch (error) {
+      if (existsSync2(temporary)) unlinkSync(temporary);
+      throw error;
+    }
+    this.#records = compacted;
+    this.#sequence = compacted.length;
+    this.#lastHash = previousHash;
   }
 };
+function compactPayload(record) {
+  const payload = record.payload;
+  if (record.type === "queue.admitted") return payload;
+  if (record.type === "queue.claimed") return { id: payload.id };
+  if (record.type === "tool.started") return pick(payload, ["id", "tool", "inputHash", "retrySafe"]);
+  if (record.type === "model.requested") return pick(payload, ["id", "agent", "model", "iteration", "attempt", "messagesHash"]);
+  if (record.type === "turn.started") return pick(payload, ["id", "configHash", "promptHash"]);
+  if (record.type === "savepoint.created") return pick(payload, ["id", "phase", "configHash"]);
+  return payload;
+}
+function hasLegacyPayload(record) {
+  if (record.type === "turn.started") return "config" in record.payload || "prompt" in record.payload;
+  if (record.type === "model.requested") return "messages" in record.payload;
+  if (record.type === "tool.started") return "input" in record.payload;
+  if (record.type === "tool.completed") return "result" in record.payload;
+  return false;
+}
+function pick(source, keys) {
+  return Object.fromEntries(keys.flatMap((key) => key in source ? [[key, source[key]]] : []));
+}
 function jsonSafeRecord(value) {
   const json = JSON.stringify(value, (_key, item) => typeof item === "bigint" ? `${item}n` : item);
   return JSON.parse(json);
@@ -20524,7 +20625,10 @@ async function createProductionRuntime(options) {
     globalPluginDirs: [join24(home, ".flavor-code", "plugins")],
     projectPluginDirs: [join24(workspace, ".flavor", "plugins")],
     config,
-    sandbox: options.pluginSandbox ?? true,
+    // Existing project plugins (including astgraph and superharness) use Node.js
+    // built-ins. The Worker/vm sandbox deliberately blocks those imports, so it
+    // must stay opt-in until equivalent mediated capabilities are available.
+    sandbox: options.pluginSandbox ?? false,
     registrations: {
       command(name, handler, description) {
         if (typeof handler !== "function") throw new Error(`Plugin command "${name}" must be a function.`);

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-DFSMJ5SX.js";
+} from "./chunk-RDBTC35M.js";
 import {
   staticTaskLines
 } from "./chunk-KKIBYDJI.js";
@@ -23,7 +23,7 @@ import {
   packageVersion,
   redactErrorText,
   runPalBroker
-} from "./chunk-Q5EQ4T3F.js";
+} from "./chunk-YKSMZDUZ.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -877,7 +877,7 @@ async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
     import("./claude-ink-ORUA7GWG.js"),
     import("react"),
-    import("./app-F6FEEF46.js")
+    import("./app-EHB3XAQY.js")
   ]);
   const instance = await render(createElement(
     AlternateScreen,