flavor-code 1.3.12 → 1.3.15

package/dist/cli.js

@@ -1,1032 +1,73 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
-import {
-  FlavorRpcServer,
-  TraceRecorder
-} from "./chunk-EZNIDHFZ.js";
-import {
-  staticTaskLines
-} from "./chunk-2BF7CVWZ.js";
-import {
-  DEFAULT_MAX_OUTPUT_BYTES,
-  MAX_ALIAS_LENGTH,
-  MEMORY_TYPES,
-  MemoryStore,
-  PluginManifestSchema,
-  SkillRegistry,
-  classifyMemoryHeat,
-  createExecutionEnvironment,
-  createProductionRuntime,
-  executeShell,
-  initializeFlavor,
-  message,
-  packageVersion,
-  redactErrorText,
-  runPalBroker
-} from "./chunk-QC5OYQTB.js";
-import {
-  McpServerConfigSchema,
-  McpServerNameSchema,
-  SkillNameSchema,
-  loadConfig,
-  readRecoverableFile,
-  setProjectSkillDisabled,
-  updateProtectedFile
-} from "./chunk-JFKRX2KG.js";
-import "./chunk-RQTYHUMK.js";
 import "./chunk-S32JRDZK.js";
 
-// src/cli.tsx
-import { randomUUID as randomUUID2 } from "crypto";
+// src/launcher.ts
+import { spawn } from "child_process";
 import { realpathSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { posix, resolve as resolve3 } from "path";
+import { release } from "os";
 import { fileURLToPath } from "url";
-import { Command, Option } from "commander";
-
-// src/utils/crash-guard.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-var installed = false;
-function installCrashGuard(options = {}) {
-  if (installed) return;
-  installed = true;
-  const crashLogDir = () => {
-    try {
-      return join((options.workspace ?? process.cwd)(), ".flavor");
-    } catch {
-      return process.cwd();
-    }
+function needsWindowsMaglevWorkaround(runtime) {
+  if (runtime.platform !== "win32") return false;
+  const build = Number(runtime.osRelease.split(".")[2]);
+  const major = Number(runtime.nodeVersion.replace(/^v/u, "").split(".")[0]);
+  if (build !== 26200 || major < 24) return false;
+  return !runtime.execArgv.some((argument) => argument === "--no-maglev" || argument === "--jitless");
+}
+function cliMainArguments(runtime, mainPath, argv) {
+  return [
+    ...needsWindowsMaglevWorkaround(runtime) ? ["--no-maglev"] : [],
+    mainPath,
+    ...argv
+  ];
+}
+async function launchCli() {
+  const mainUrl = new URL("./cli-main.js", import.meta.url);
+  const runtime = {
+    platform: process.platform,
+    osRelease: release(),
+    nodeVersion: process.version,
+    execArgv: process.execArgv
   };
-  const writeCrashLog = (kind, detail) => {
-    try {
-      const dir = crashLogDir();
-      mkdirSync(dir, { recursive: true });
-      const path = join(dir, `crash-${(/* @__PURE__ */ new Date()).toISOString().replace(/[^0-9]/g, "")}-${process.pid}.log`);
-      writeFileSync(path, [
-        `kind: ${kind}`,
-        `version: ${process.version}`,
-        `platform: ${process.platform}`,
-        `time: ${(/* @__PURE__ */ new Date()).toISOString()}`,
-        "",
-        detail
-      ].join("\n"), { encoding: "utf8", mode: 384 });
-      return path;
-    } catch {
-      return void 0;
-    }
-  };
-  const restoreTerminal = () => {
-    try {
-      if (process.stdout.isTTY === true) process.stdout.write("\x1B[?25h\x1B[?1049l");
-    } catch {
-    }
-  };
-  const describe = (reason) => {
-    if (reason instanceof Error) return `${reason.name}: ${reason.message}
-${reason.stack ?? ""}`;
-    return String(reason);
-  };
-  const crash = (kind, reason) => {
-    const detail = describe(reason);
-    const logPath = writeCrashLog(kind, detail);
-    restoreTerminal();
-    try {
-      const safe = redactErrorText(detail.split("\n").slice(0, 3).join("\n"));
-      process.stderr.write(`flavor crashed (${kind}): ${safe}
-`);
-      if (logPath !== void 0) process.stderr.write(`crash log: ${logPath}
-`);
-    } catch {
-    }
-    process.exit(1);
+  if (!needsWindowsMaglevWorkaround(runtime)) {
+    const cli = await import(mainUrl.href);
+    await cli.runCli(process.argv);
+    return;
+  }
+  const child = spawn(
+    process.execPath,
+    cliMainArguments(runtime, fileURLToPath(mainUrl), process.argv.slice(2)),
+    { stdio: "inherit" }
+  );
+  const ignoreSignal = () => {
   };
-  process.on("unhandledRejection", (reason) => crash("unhandledRejection", reason));
-  process.on("uncaughtException", (error) => crash("uncaughtException", error));
-}
-
-// src/skills/manager.ts
-import { lstat, mkdir, readFile, readdir, realpath, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { isAbsolute, join as join2, relative, resolve, sep } from "path";
-import { stringify } from "yaml";
-var SkillManager = class {
-  #workspace;
-  #home;
-  constructor(options) {
-    this.#workspace = resolve(options.workspace);
-    this.#home = resolve(options.home ?? homedir());
-  }
-  async list() {
-    const { registry, disabled } = await this.#registry();
-    return Promise.all((await registry.discover()).map((metadata) => this.#summary(metadata, disabled)));
-  }
-  async get(name) {
-    const validName = parseName(name);
-    const { registry, disabled } = await this.#registry();
-    const metadata = (await registry.discover()).find((skill) => skill.name === validName);
-    if (metadata === void 0) throw new Error(`Skill not found: ${validName}`);
-    return { ...await this.#summary(metadata, disabled), body: await registry.loadBody(metadata) };
-  }
-  async create(draft) {
-    const value = parseDraft(draft);
-    const projectRoot = this.#projectRoot();
-    const directory = join2(projectRoot, value.name);
-    await mkdir(projectRoot, { recursive: true, mode: 448 });
-    try {
-      await mkdir(directory, { mode: 448 });
-    } catch (error) {
-      if (isCode(error, "EEXIST")) throw new Error(`A project skill named "${value.name}" already exists`);
-      throw error;
-    }
-    try {
-      await writeFile(join2(directory, "SKILL.md"), renderSkill(value), { encoding: "utf8", flag: "wx", mode: 384 });
-      await this.#persistEnabled(value.name, true);
-      return this.get(value.name);
-    } catch (error) {
-      await rm(directory, { recursive: true, force: true }).catch(() => void 0);
-      throw error;
-    }
-  }
-  async update(name, draft) {
-    const validName = parseName(name);
-    const value = parseDraft(draft);
-    if (value.name !== validName) throw new Error("Rename is not supported; create a new skill instead");
-    const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat(directory).catch((error) => {
-      if (isCode(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
-      throw error;
-    });
-    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    const skillFile = join2(directory, "SKILL.md");
-    const fileInfo = await lstat(skillFile);
-    if (!fileInfo.isFile() || fileInfo.isSymbolicLink()) throw new Error(`Project skill file is not a real file: ${validName}`);
-    await writeFile(skillFile, renderSkill(value), { encoding: "utf8", mode: 384 });
-    return this.get(validName);
-  }
-  async delete(name) {
-    const validName = parseName(name);
-    const directory = this.#projectSkillDirectory(validName);
-    const info = await lstat(directory).catch((error) => {
-      if (isCode(error, "ENOENT")) throw new Error(`Project skill not found: ${validName}`);
-      throw error;
-    });
-    if (!info.isDirectory() || info.isSymbolicLink()) throw new Error(`Project skill path is not a real directory: ${validName}`);
-    await rm(directory, { recursive: true });
-    await this.#persistEnabled(validName, true);
-  }
-  async setEnabled(name, enabled) {
-    const validName = parseName(name);
-    const { registry } = await this.#registry();
-    if (!(await registry.discover()).some((skill) => skill.name === validName)) {
-      throw new Error(`Skill not found: ${validName}`);
-    }
-    await this.#persistEnabled(validName, enabled);
-  }
-  async #persistEnabled(validName, enabled) {
-    const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
-    await setProjectSkillDisabled(this.#workspace, validName, !enabled, loaded.config.skills.disabled);
-  }
-  async #registry() {
-    const loaded = await loadConfig({ cwd: this.#workspace, home: this.#home });
-    const [globalPluginRoots, projectPluginRoots] = await Promise.all([
-      discoverPluginSkillRoots(join2(this.#home, ".flavor-code", "plugins")),
-      discoverPluginSkillRoots(join2(this.#workspace, ".flavor", "plugins"))
-    ]);
-    return {
-      registry: new SkillRegistry({
-        globalRoots: [join2(this.#home, ".flavor-code", "skills"), ...globalPluginRoots],
-        projectRoots: [this.#projectRoot(), ...projectPluginRoots]
-      }),
-      disabled: new Set(loaded.config.skills.disabled)
-    };
-  }
-  async #summary(metadata, disabled) {
-    const expected = this.#projectSkillDirectory(metadata.name);
-    const editable = metadata.source === "project" && await realpath(expected).then((physical) => physical === metadata.root).catch(() => false);
-    return {
-      ...metadata,
-      enabled: !disabled.has(metadata.name),
-      editable
-    };
-  }
-  #projectRoot() {
-    return join2(this.#workspace, ".flavor", "skills");
-  }
-  #projectSkillDirectory(name) {
-    return join2(this.#projectRoot(), name);
-  }
-};
-function parseName(value) {
-  return SkillNameSchema.parse(value.trim());
-}
-function parseDraft(draft) {
-  const name = parseName(draft.name);
-  const description = draft.description.trim();
-  const body = draft.body.replace(/\r\n/g, "\n").trim();
-  if (description.length === 0 || description.length > 4e3) throw new Error("Skill description must be between 1 and 4,000 characters");
-  if (body.length === 0 || Buffer.byteLength(body, "utf8") > 256 * 1024) throw new Error("Skill instructions must be between 1 byte and 256 KiB");
-  return { name, description, body, disableModelInvocation: draft.disableModelInvocation ?? false };
-}
-function renderSkill(draft) {
-  const frontmatter = stringify({
-    name: draft.name,
-    description: draft.description,
-    "disable-model-invocation": draft.disableModelInvocation
-  }).trimEnd();
-  return `---
-${frontmatter}
----
-
-${draft.body}
-`;
-}
-function isCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-async function discoverPluginSkillRoots(directory) {
-  let entries;
+  process.on("SIGINT", ignoreSignal);
+  process.on("SIGBREAK", ignoreSignal);
   try {
-    entries = await readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if (isCode(error, "ENOENT")) return [];
-    throw error;
-  }
-  const roots = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.isSymbolicLink()) continue;
-    const pluginRoot = await realpath(join2(directory, entry.name));
-    try {
-      const manifest = PluginManifestSchema.parse(JSON.parse(await readFile(join2(pluginRoot, "flavor-plugin.json"), "utf8")));
-      for (const contribution of manifest.contributes.skillRoots) {
-        const candidate = resolve(pluginRoot, contribution.path);
-        const info = await lstat(candidate);
-        if (!info.isDirectory() || info.isSymbolicLink()) continue;
-        const physical = await realpath(candidate);
-        const relation = relative(pluginRoot, physical);
-        if (relation === ".." || relation.startsWith(`..${sep}`) || isAbsolute(relation)) continue;
-        roots.push(physical);
-      }
-    } catch {
-    }
-  }
-  return roots;
-}
-
-// src/memory/cli.ts
-import { homedir as homedir2 } from "os";
-
-// src/memory/manager.ts
-var ProjectMemoryManager = class {
-  #store;
-  #enabled;
-  constructor(store, enabled = true) {
-    this.#store = store;
-    this.#enabled = enabled;
-  }
-  async snapshot(now = /* @__PURE__ */ new Date()) {
-    const references = this.#enabled ? await this.#store.references() : [];
-    return {
-      enabled: this.#enabled,
-      path: this.#store.path,
-      entries: references.map((reference) => {
-        const lastRecalledAt = Object.values(reference.recalls).sort().at(-1);
-        return {
-          id: reference.id,
-          type: reference.type,
-          content: reference.summary,
-          recallTotal: reference.recallTotal,
-          heat: classifyMemoryHeat(reference, now),
-          ...lastRecalledAt === void 0 ? {} : { lastRecalledAt }
-        };
-      })
-    };
-  }
-  async remember(candidate) {
-    this.#assertEnabled();
-    const result = await this.#store.remember(candidate);
-    if (!result.added) throw new Error("Memory entry already exists or the configured capacity has been reached");
-    return result.entry;
-  }
-  async update(id, candidate) {
-    this.#assertEnabled();
-    return this.#store.update(id, candidate);
-  }
-  async delete(id) {
-    this.#assertEnabled();
-    return this.#store.delete(id);
-  }
-  async deleteCold(now = /* @__PURE__ */ new Date()) {
-    this.#assertEnabled();
-    return this.#store.forgetCold(now);
-  }
-  #assertEnabled() {
-    if (!this.#enabled) throw new Error("Long-term memory is disabled for this project");
-  }
-};
-async function createProjectMemoryManager(options) {
-  const { memory } = (await loadConfig({ cwd: options.workspace, home: options.home })).config;
-  const store = new MemoryStore({
-    workspace: options.workspace,
-    maxEntries: memory.maxEntries,
-    maxEntryChars: memory.maxEntryChars
-  });
-  return new ProjectMemoryManager(store, memory.enabled);
-}
-
-// src/memory/cli.ts
-function registerMemoryCommands(program, dependencies = {}) {
-  const open = dependencies.open ?? createProjectMemoryManager;
-  const cwd = dependencies.cwd ?? (() => process.cwd());
-  const home = dependencies.home ?? homedir2;
-  const write = dependencies.write ?? ((text) => process.stdout.write(text));
-  const manager = () => open({ workspace: cwd(), home: home() });
-  const memory = program.command("memory").description("Inspect and maintain project long-term memory");
-  memory.command("list", { isDefault: true }).description("List project memories").option("--json", "print a machine-readable snapshot").action(async (options) => {
-    const snapshot = await (await manager()).snapshot();
-    if (options.json) {
-      write(`${JSON.stringify(snapshot, null, 2)}
-`);
-      return;
-    }
-    write(`Memory file: ${snapshot.path}
-`);
-    if (!snapshot.enabled) {
-      write("Long-term memory is disabled for this project.\n");
-      return;
-    }
-    if (snapshot.entries.length === 0) {
-      write("No long-term memories.\n");
-      return;
-    }
-    for (const entry of snapshot.entries) write(`${entry.id}  ${entry.type}  ${entry.content}
-`);
-  });
-  memory.command("add").description("Add a memory").argument("<type>", "user, feedback, project, or reference").argument("<text...>", "memory text").action(async (type, words) => {
-    const entry = await (await manager()).remember({ type: parseMemoryType(type), content: words.join(" ") });
-    write(`Added ${entry.id}  ${entry.type}  ${entry.content}
-`);
-  });
-  memory.command("update").description("Replace one memory by id").argument("<id>", "12-character memory id").argument("<type>", "user, feedback, project, or reference").argument("<text...>", "replacement text").action(async (id, type, words) => {
-    const entry = await (await manager()).update(id, { type: parseMemoryType(type), content: words.join(" ") });
-    write(`Updated ${id} -> ${entry.id}  ${entry.type}  ${entry.content}
-`);
-  });
-  memory.command("delete").description("Delete one memory by id").argument("<id>", "12-character memory id").action(async (id) => {
-    const deleted = await (await manager()).delete(id);
-    if (!deleted) throw new Error(`Memory entry not found: ${id}`);
-    write(`Deleted ${id}
-`);
-  });
-  memory.command("path").description("Print the project memory file path").action(async () => write(`${(await (await manager()).snapshot()).path}
-`));
-}
-function parseMemoryType(value) {
-  if (!MEMORY_TYPES.includes(value)) {
-    throw new Error(`Unsupported memory type: ${value}. Use ${MEMORY_TYPES.join(", ")}.`);
-  }
-  return value;
-}
-
-// src/mcp/config-manager.ts
-import { join as join3 } from "path";
-var ProjectMcpConfigManager = class {
-  path;
-  constructor(workspace) {
-    this.path = join3(workspace, ".flavor", "flavor.json");
-  }
-  async list() {
-    const document = await readRecoverableFile(this.path, (raw) => parseDocument(this.path, raw));
-    return parseServers(this.path, document?.value["mcpServers"]);
-  }
-  async create(name, config) {
-    const validName = McpServerNameSchema.parse(name);
-    const validConfig = McpServerConfigSchema.parse(config);
-    await this.#mutate((servers) => {
-      if (servers[validName] !== void 0) throw new Error(`MCP service "${validName}" already exists`);
-      servers[validName] = validConfig;
+    const code = await new Promise((resolvePromise, reject) => {
+      child.once("error", reject);
+      child.once("exit", (exitCode) => resolvePromise(exitCode ?? 1));
     });
-    return managedServer(validName, validConfig);
-  }
-  async update(originalName, name, config) {
-    const validOriginal = McpServerNameSchema.parse(originalName);
-    const validName = McpServerNameSchema.parse(name);
-    const parsedConfig = McpServerConfigSchema.parse(config);
-    let persistedConfig = parsedConfig;
-    await this.#mutate((servers) => {
-      const current = servers[validOriginal];
-      if (current === void 0) throw new Error(`MCP service "${validOriginal}" not found`);
-      if (validName !== validOriginal && servers[validName] !== void 0) {
-        throw new Error(`MCP service "${validName}" already exists`);
-      }
-      const sameTransport = "command" in current && "command" in config || "url" in current && "url" in config;
-      persistedConfig = sameTransport ? McpServerConfigSchema.parse({ ...current, ...config }) : parsedConfig;
-      delete servers[validOriginal];
-      servers[validName] = persistedConfig;
-    });
-    return managedServer(validName, persistedConfig);
-  }
-  async setEnabled(name, enabled) {
-    const validName = McpServerNameSchema.parse(name);
-    let next;
-    await this.#mutate((servers) => {
-      const current = servers[validName];
-      if (current === void 0) throw new Error(`MCP service "${validName}" not found`);
-      next = McpServerConfigSchema.parse({ ...current, disabled: !enabled });
-      servers[validName] = next;
-    });
-    return managedServer(validName, next);
-  }
-  async delete(name) {
-    const validName = McpServerNameSchema.parse(name);
-    await this.#mutate((servers) => {
-      if (servers[validName] === void 0) throw new Error(`MCP service "${validName}" not found`);
-      delete servers[validName];
-    });
-  }
-  async #mutate(update) {
-    await updateProtectedFile({
-      path: this.path,
-      decode: (raw) => parseDocument(this.path, raw),
-      encode: (value) => `${JSON.stringify(value, null, 2)}
-`,
-      update: (current) => {
-        const document = { ...current ?? {} };
-        const servers = Object.fromEntries(parseServers(this.path, document["mcpServers"]).map((server) => [server.name, server.config]));
-        update(servers);
-        document["mcpServers"] = servers;
-        return document;
-      }
-    });
-  }
-};
-function parseDocument(path, raw) {
-  const value = JSON.parse(raw);
-  if (!isRecord(value)) throw new Error(`Configuration file ${path} must contain a JSON object`);
-  return value;
-}
-function parseServers(path, value) {
-  if (value === void 0) return [];
-  if (!isRecord(value)) throw new Error(`Configuration field mcpServers in ${path} must be an object`);
-  return Object.entries(value).map(([name, config]) => {
-    try {
-      return managedServer(McpServerNameSchema.parse(name), McpServerConfigSchema.parse(config));
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid MCP service "${name}" in ${path}: ${reason}`);
-    }
-  }).sort((left, right) => left.name.localeCompare(right.name));
-}
-function managedServer(name, config) {
-  return {
-    name,
-    transport: "command" in config ? "stdio" : "http",
-    enabled: !config.disabled,
-    config
-  };
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/mcp/cli.ts
-function registerMcpCommands(program, dependencies) {
-  const deps = {
-    open: dependencies?.open ?? (() => new ProjectMcpConfigManager(process.cwd())),
-    write: dependencies?.write ?? ((text) => process.stdout.write(text))
-  };
-  const mcp = program.command("mcp").description("Manage project MCP service configurations");
-  mcp.command("list", { isDefault: true }).option("--json", "print JSON").action(async (options) => {
-    const services = await deps.open().list();
-    if (options.json) deps.write(`${JSON.stringify(services, null, 2)}
-`);
-    else if (services.length === 0) deps.write("No project MCP services configured.\n");
-    else for (const service of services) {
-      deps.write(`${service.enabled ? "on " : "off"}  ${service.name}  ${service.transport}
-`);
-    }
-  });
-  addConfigCommand(mcp.command("add <name>").description("Add a project MCP service")).action(async (name, options) => {
-    await deps.open().create(name, configFromOptions(options));
-    deps.write(`Added MCP service ${name}.
-`);
-  });
-  addConfigCommand(mcp.command("update <name>").description("Replace a project MCP service configuration")).option("--rename <name>", "rename the service").action(async (name, options) => {
-    await deps.open().update(name, options.rename ?? name, configFromOptions(options));
-    deps.write(`Updated MCP service ${options.rename ?? name}.
-`);
-  });
-  for (const enabled of [true, false]) {
-    const action = enabled ? "enable" : "disable";
-    mcp.command(`${action} <name>`).description(`${enabled ? "Enable" : "Disable"} a project MCP service`).action(async (name) => {
-      await deps.open().setEnabled(name, enabled);
-      deps.write(`${enabled ? "Enabled" : "Disabled"} MCP service ${name}.
-`);
-    });
-  }
-  mcp.command("delete <name>").description("Delete a project MCP service").action(async (name) => {
-    await deps.open().delete(name);
-    deps.write(`Deleted MCP service ${name}.
-`);
-  });
-  mcp.command("path").description("Print the project MCP configuration path").action(() => {
-    deps.write(`${deps.open().path}
-`);
-  });
-}
-function addConfigCommand(command) {
-  return command.option("--command <program>", "stdio executable").option("--url <url>", "Streamable HTTP endpoint").option("--arg <value>", "stdio argument; repeatable", collect, []).option("--env <KEY=VALUE>", "stdio environment entry; repeatable", collect, []).option("--header <KEY=VALUE>", "HTTP header; repeatable", collect, []).option("--cwd <path>", "stdio working directory").option("--timeout <ms>", "request timeout in milliseconds", parseTimeout);
-}
-function configFromOptions(options) {
-  if (options.command === void 0 === (options.url === void 0)) {
-    throw new Error("Specify exactly one transport with --command or --url");
-  }
-  if (options.command !== void 0) {
-    if ((options.header?.length ?? 0) > 0) throw new Error("--header is available only with --url");
-    return {
-      command: options.command,
-      ...options.arg?.length ? { args: options.arg } : {},
-      ...options.env?.length ? { env: keyValueRecord(options.env, "environment") } : {},
-      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
-      ...options.timeout === void 0 ? {} : { timeoutMs: options.timeout }
-    };
-  }
-  if ((options.arg?.length ?? 0) > 0 || (options.env?.length ?? 0) > 0 || options.cwd !== void 0) {
-    throw new Error("--arg, --env, and --cwd are available only with --command");
-  }
-  return {
-    url: options.url,
-    ...options.header?.length ? { headers: keyValueRecord(options.header, "header") } : {},
-    ...options.timeout === void 0 ? {} : { timeoutMs: options.timeout }
-  };
-}
-function collect(value, previous) {
-  return [...previous, value];
-}
-function parseTimeout(value) {
-  const parsed = Number(value);
-  if (!Number.isSafeInteger(parsed) || parsed < 100) throw new Error("--timeout must be an integer of at least 100ms");
-  return parsed;
-}
-function keyValueRecord(entries, label) {
-  return Object.fromEntries(entries.map((entry) => {
-    const separator = entry.indexOf("=");
-    if (separator <= 0) throw new Error(`Invalid ${label} entry "${entry}"; use KEY=VALUE`);
-    return [entry.slice(0, separator), entry.slice(separator + 1)];
-  }));
-}
-
-// src/rpc/write-stream.ts
-import { randomUUID } from "crypto";
-var RpcWriteStreamBridge = class {
-  #output;
-  #pending;
-  constructor(output) {
-    this.#output = output;
-  }
-  get pendingId() {
-    return this.#pending?.id;
-  }
-  async preview(proposal, signal) {
-    if (this.#pending !== void 0) throw new Error("Another streamed write is still awaiting commit");
-    if (signal.aborted) throw signal.reason;
-    const id = randomUUID();
-    this.#output({
-      type: "write-start",
-      id,
-      path: proposal.path,
-      before: proposal.before,
-      totalBytes: Buffer.byteLength(proposal.after)
-    });
-    for (const delta of streamChunks(proposal.after)) this.#output({ type: "write-delta", id, delta });
-    this.#output({ type: "write-ready", id });
-    await new Promise((resolve4, reject) => {
-      const onAbort = () => {
-        this.#output({ type: "write-cancelled", id });
-        this.#clear(id);
-        reject(signal.reason);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-      this.#pending = {
-        id,
-        resolve: resolve4,
-        reject,
-        removeAbort: () => signal.removeEventListener("abort", onAbort)
-      };
-    });
-  }
-  commit(id) {
-    const pending = this.#pending;
-    if (pending === void 0 || pending.id !== id) throw new Error("Streamed write is no longer awaiting commit");
-    pending.removeAbort();
-    this.#pending = void 0;
-    pending.resolve();
-  }
-  dispose() {
-    const pending = this.#pending;
-    if (pending === void 0) return;
-    pending.removeAbort();
-    this.#pending = void 0;
-    pending.reject(new Error("Streamed write bridge disposed"));
-  }
-  #clear(id) {
-    if (this.#pending?.id !== id) return;
-    this.#pending.removeAbort();
-    this.#pending = void 0;
-  }
-};
-function streamChunks(content, maxChars = 2048) {
-  if (!content) return [];
-  const chunks = [];
-  for (const line of content.match(/[^\n]*\n|[^\n]+$/g) ?? []) {
-    for (let offset = 0; offset < line.length; offset += maxChars) {
-      chunks.push(line.slice(offset, offset + maxChars));
-    }
-  }
-  return chunks;
-}
-
-// src/eval/cli.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { dirname, resolve as resolve2 } from "path";
-
-// src/execution/local.ts
-var LocalExecutionEnvironment = class {
-  kind = "local";
-  exec(request, signal) {
-    const cancellation = signal ?? new AbortController().signal;
-    return executeShell(request.cwd, {
-      command: request.command,
-      args: [...request.args],
-      cwd: request.cwd,
-      ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs }
-    }, cancellation, DEFAULT_MAX_OUTPUT_BYTES);
-  }
-  async dispose() {
-  }
-};
-
-// src/eval/schema.ts
-import { z } from "zod";
-var EvaluationSpecSchema = z.object({
-  name: z.string().trim().min(1).max(256),
-  workspace: z.string().trim().min(1).max(32768),
-  prompt: z.string().trim().min(1).max(1e6),
-  verification: z.array(z.object({
-    command: z.string().trim().min(1).max(32768),
-    args: z.array(z.string()).max(1e3),
-    timeoutMs: z.number().int().positive().max(864e5).optional()
-  }).strict()).min(1).max(100),
-  maxTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
-}).strict();
-
-// src/eval/runner.ts
-var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
-async function runEvaluation(spec, dependencies) {
-  const now = dependencies.now ?? Date.now;
-  const started = now();
-  let input = 0;
-  let output = 0;
-  const runtime = await dependencies.createRuntime({
-    workspace: spec.workspace,
-    output: (event) => {
-      if (event.type === "usage") {
-        input = event.totalInputTokens;
-        output = event.totalOutputTokens;
-      } else if (event.type === "done" && input === 0 && output === 0) {
-        input = event.usage.inputTokens;
-        output = event.usage.outputTokens;
-      }
-    }
-  });
-  try {
-    await runtime.session.start();
-    await runtime.session.submit(spec.prompt);
-  } finally {
-    await runtime.session.close();
-    await runtime.dispose();
-  }
-  const verification = [];
-  for (const check of spec.verification) {
-    const result = await dependencies.executionEnvironment.exec({
-      command: check.command,
-      args: check.args,
-      cwd: spec.workspace,
-      timeoutMs: check.timeoutMs ?? DEFAULT_VERIFICATION_TIMEOUT_MS
-    });
-    verification.push({
-      command: [check.command, ...check.args].join(" "),
-      exitCode: result.exitCode,
-      passed: result.exitCode === 0,
-      stdout: result.stdout,
-      stderr: result.stderr
-    });
-  }
-  const total = input + output;
-  const withinBudget = spec.maxTokens === void 0 || total <= spec.maxTokens;
-  return {
-    name: spec.name,
-    workspace: spec.workspace,
-    passed: withinBudget && verification.every((item) => item.passed),
-    durationMs: Math.max(0, now() - started),
-    tokens: { input, output, total, withinBudget },
-    verification
-  };
-}
-
-// src/eval/cli.ts
-async function runEvaluationFile(path, outputPath) {
-  const specPath = resolve2(path);
-  const parsed = EvaluationSpecSchema.parse(JSON.parse(await readFile2(specPath, "utf8")));
-  const workspace = resolve2(dirname(specPath), parsed.workspace);
-  const spec = {
-    name: parsed.name,
-    prompt: parsed.prompt,
-    workspace,
-    verification: parsed.verification.map((step) => ({
-      command: step.command,
-      args: step.args,
-      ...step.timeoutMs === void 0 ? {} : { timeoutMs: step.timeoutMs }
-    })),
-    ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
-  };
-  const configured = await import("./load-LTTKVPJZ.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 {
-    report = await runEvaluation(spec, {
-      createRuntime: (options) => createProductionRuntime({
-        ...options,
-        home: process.env.USERPROFILE ?? process.env.HOME ?? workspace,
-        approvalPolicy: "deny"
-      }),
-      executionEnvironment: environment
-    });
-  } finally {
-    await environment.dispose();
-  }
-  const body = `${JSON.stringify(report, null, 2)}
-`;
-  if (outputPath === void 0) process.stdout.write(body);
-  else await writeFile2(resolve2(outputPath), body, "utf8");
-  return report.passed ? 0 : 1;
-}
-
-// 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());
-  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 {
-      const result = await initializeFlavor(cwd);
-      process.stdout.write(`${result.created ? "Created" : "Updated"} ${result.path}
-`);
-    } catch (error) {
-      process.stderr.write(`init: ${safeError(error)}
-`);
-      process.exitCode = 1;
-    }
-  });
-  const skills = program.command("skills").description("List and enable or disable project skills");
-  skills.command("list", { isDefault: true }).description("List skills visible in the current project").action(async () => {
-    try {
-      const entries = await new SkillManager({ workspace: process.cwd(), home: homedir3() }).list();
-      if (entries.length === 0) process.stdout.write("No skills found.\n");
-      else for (const skill of entries) {
-        process.stdout.write(`${skill.enabled ? "on " : "off"}  ${skill.name}  [${skill.source}]  ${skill.description}
-`);
-      }
-    } catch (error) {
-      process.stderr.write(`skills: ${safeError(error)}
-`);
-      process.exitCode = 1;
-    }
-  });
-  for (const enabled of [true, false]) {
-    const action = enabled ? "enable" : "disable";
-    skills.command(`${action} <name>`).description(`${enabled ? "Enable" : "Disable"} a skill for this project`).action(async (name) => {
-      try {
-        await new SkillManager({ workspace: process.cwd(), home: homedir3() }).setEnabled(name, enabled);
-        process.stdout.write(`${enabled ? "Enabled" : "Disabled"} ${name}.
-`);
-      } catch (error) {
-        process.stderr.write(`skills: ${safeError(error)}
-`);
-        process.exitCode = 1;
-      }
-    });
-  }
-  registerMemoryCommands(program);
-  registerMcpCommands(program);
-  program.command("eval <spec>").option("--output <path>", "write the JSON report to a file").description("run a repeatable coding-agent evaluation").action(async (spec, command) => {
-    process.exitCode = await runEvaluationFile(spec, command.output);
-  });
-  program.action(async (options) => {
-    if (options.palsBroker !== void 0) {
-      if (!isLocalPalBrokerAddress(options.palsBroker, process.platform)) {
-        throw new Error("Invalid local pals broker address");
-      }
-      const broker = await (dependencies.runBroker ?? runPalBroker)({ address: options.palsBroker });
-      await broker.closed;
-      return;
-    }
-    const resumeSession = options.resume === true ? true : typeof options.resume === "string" ? options.resume : void 0;
-    if (options.mode === "rpc") {
-      process.exitCode = await runRpcMode({
-        workspace: resolve3(options.workspace ?? process.cwd()),
-        ...resumeSession === void 0 ? {} : { resumeSession },
-        ...options.trace === void 0 ? {} : { trace: resolve3(options.trace) },
-        interactiveApprovals: options.rpcApprovals === true,
-        streamedWrites: options.rpcStreamedWrites === true
-      });
-      return;
-    }
-    if (options.mode !== void 0 && options.mode !== "interactive") {
-      process.stderr.write(`Unsupported mode: ${options.mode}
-`);
-      process.exitCode = 2;
-      return;
-    }
-    if (options.print !== void 0) {
-      process.exitCode = await runPrint(options.print, {}, resumeSession);
-      return;
-    }
-    if (!(dependencies.isTTY?.() ?? process.stdin.isTTY)) {
-      process.stderr.write("Interactive mode needs a TTY. Use --print <prompt> for scripts.\n");
-      process.exitCode = 2;
-      return;
-    }
-    const palAlias = options.palName === void 0 ? void 0 : parsePalAlias(options.palName);
-    setInteractiveProcessTitle();
-    const props = {
-      workspace: process.cwd(),
-      home: homedir3(),
-      ...resumeSession === void 0 ? {} : { resumeSession },
-      instanceId: (dependencies.randomUUID ?? randomUUID2)(),
-      ...palAlias === void 0 ? {} : { palAlias }
-    };
-    if (dependencies.runInteractive !== void 0) {
-      await dependencies.runInteractive(props);
-      return;
-    }
-    await runInteractiveCli(props);
-  });
-  return program;
-}
-async function runInteractiveCli(props) {
-  const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
-    import("./claude-ink-ORUA7GWG.js"),
-    import("react"),
-    import("./app-Z7D7XPVE.js")
-  ]);
-  const instance = await render(createElement(
-    AlternateScreen,
-    { mouseTracking: true },
-    createElement(App, props)
-  ), { exitOnCtrlC: false });
-  await instance.waitUntilExit();
-}
-function parsePalAlias(value) {
-  const alias = value.trim();
-  if (alias.length < 1 || alias.length > MAX_ALIAS_LENGTH) {
-    throw new Error(`Pal name must be between 1 and ${MAX_ALIAS_LENGTH} characters`);
-  }
-  return alias;
-}
-function isLocalPalBrokerAddress(address, platform) {
-  if (platform === "win32") {
-    const prefix = "\\\\.\\pipe\\flavor-code-pals-u-";
-    if (!address.startsWith(prefix) || !address.endsWith("-v1")) return false;
-    return /^[a-f0-9]{16}$/u.test(address.slice(prefix.length, -3));
-  }
-  if (!address.startsWith("/") || address.startsWith("//") || address.includes("\0")) return false;
-  return posix.normalize(address) === address && posix.basename(address) === "pals-v1.sock" && posix.dirname(address) !== "/";
-}
-async function runRpcMode(options) {
-  let recorder;
-  try {
-    const server = new FlavorRpcServer({
-      input: process.stdin,
-      output: process.stdout,
-      workspace: options.workspace,
-      createRuntime: async ({ workspace, output }) => {
-        let activeRuntime;
-        const streamedWrites = options.streamedWrites ? new RpcWriteStreamBridge(output) : void 0;
-        const onApprovalChange = () => {
-          if (!options.interactiveApprovals) return;
-          const approval = activeRuntime?.approvals.pending;
-          output(approval === void 0 ? { type: "approval-cleared" } : { type: "approval-request", request: approval });
-        };
-        const runtime = await createProductionRuntime({
-          workspace,
-          home: homedir3(),
-          approvalPolicy: "deny",
-          rpcToolApprovals: options.interactiveApprovals === true,
-          ...streamedWrites === void 0 ? {} : { beforeFileCommit: streamedWrites.preview.bind(streamedWrites) },
-          ...options.interactiveApprovals ? { onApprovalChange } : {},
-          ...options.resumeSession === void 0 ? {} : { resumeSession: options.resumeSession },
-          output
-        });
-        activeRuntime = runtime;
-        Object.defineProperty(runtime, "rpcApprovals", { value: options.interactiveApprovals === true, enumerable: true });
-        if (streamedWrites !== void 0) Object.defineProperty(runtime, "rpcWrites", { value: streamedWrites, enumerable: true });
-        if (options.trace !== void 0) recorder = new TraceRecorder({
-          path: options.trace,
-          sessionId: runtime.sessionId
-        });
-        return runtime;
-      },
-      onRecord: (kind, payload) => recorder?.record(kind, payload)
-    });
-    await server.start();
-    await recorder?.close();
-    return 0;
-  } catch (error) {
-    await recorder?.close().catch(() => void 0);
-    process.stderr.write(`rpc: ${safeError(error)}
-`);
-    return 1;
-  }
-}
-function setInteractiveProcessTitle(target = process) {
-  target.title = "Flavor Code";
-}
-async function runPrint(prompt, dependencies = {}, resumeSession) {
-  let code = 0;
-  let runtime;
-  const stdout = dependencies.stdout ?? ((text) => process.stdout.write(text));
-  const stderr = dependencies.stderr ?? ((text) => process.stderr.write(text));
-  try {
-    runtime = await (dependencies.createRuntime ?? createProductionRuntime)({
-      workspace: process.cwd(),
-      home: homedir3(),
-      approvalPolicy: "deny",
-      ...resumeSession === void 0 ? {} : { resumeSession },
-      output(event) {
-        if (event.type === "text") stdout(event.text);
-        else if (event.type === "notice") stdout(`${event.message}
-`);
-        else if (event.type === "tasks") {
-          for (const line of staticTaskLines(event.snapshot)) stdout(`${line}
-`);
-        } else if (event.type === "error") {
-          stderr(`${event.error.code}: ${event.error.message}
-`);
-          code = 1;
-        }
-      }
-    });
-  } catch (error) {
-    stderr(`startup: ${safeError(error)}
-`);
-    return 2;
-  }
-  try {
-    await runtime.session.start();
-    await runtime.session.submit(prompt);
-  } catch (error) {
-    stderr(`runtime: ${safeError(error)}
-`);
-    code = 1;
+    process.exitCode = code;
   } finally {
-    try {
-      await runtime.session.close();
-    } catch (error) {
-      stderr(`runtime: ${safeError(error)}
-`);
-      code = 1;
-    }
-    try {
-      await runtime.dispose();
-    } catch (error) {
-      stderr(`runtime: ${safeError(error)}
-`);
-      code = 1;
-    }
+    process.off("SIGINT", ignoreSignal);
+    process.off("SIGBREAK", ignoreSignal);
   }
-  if (code === 0) stdout("\n");
-  return code;
-}
-function safeError(error) {
-  return redactErrorText(message(error));
 }
 if (process.argv[1]) {
   const scriptPath = fileURLToPath(import.meta.url);
   if (realpathSync(scriptPath) === realpathSync(process.argv[1])) {
-    installCrashGuard();
     try {
-      await createProgram().parseAsync(process.argv);
+      await launchCli();
     } catch (error) {
-      process.stderr.write(`flavor: ${safeError(error)}
+      process.stderr.write(`flavor launcher: ${error instanceof Error ? error.message : String(error)}
 `);
       process.exitCode = 1;
     }
   }
 }
 export {
-  createProgram,
-  isLocalPalBrokerAddress,
-  runPrint,
-  runRpcMode,
-  setInteractiveProcessTitle
+  cliMainArguments,
+  launchCli,
+  needsWindowsMaglevWorkaround
 };