vole-agent 0.1.0

package/dist/chunk-RPVF2IWG.js

@@ -0,0 +1,4580 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+import { Command } from "commander";
+import { createInterface } from "readline";
+import { readdir as readdir4, readFile as readFile6, stat } from "fs/promises";
+import { spawn } from "child_process";
+import { dirname as dirname4, join as join7 } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/config/dist/index.js
+import { join } from "path";
+var openRouterDefaults = {
+  baseURL: "https://openrouter.ai/api/v1"
+};
+var anthropicDefaults = {
+  model: "claude-haiku-4-5-20251001"
+};
+var ConfigValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigValidationError";
+  }
+};
+var defaultConfig = {
+  model: {
+    provider: "openai-compatible",
+    baseURL: "https://api.openai.com/v1",
+    model: "gpt-4.1-mini",
+    temperature: 0.2,
+    maxTokens: 4096
+  },
+  workspace: {
+    root: "."
+  },
+  runtime: {
+    defaultMode: "confirm",
+    maxSteps: 12
+  },
+  trace: {
+    verbosity: "explainable"
+  },
+  tools: {
+    fileSystem: true,
+    shell: true,
+    web: false
+  },
+  permissions: {
+    allowLowRisk: true
+  },
+  sessions: {
+    directory: "~/.vole/sessions"
+  },
+  memory: {
+    longTermFiles: "disabled",
+    writes: "disabled"
+  },
+  secrets: {
+    apiKey: void 0
+  }
+};
+function loadConfig(input = {}) {
+  const config = cloneConfig(defaultConfig);
+  applyConfig(config, input.userConfig);
+  applyConfig(config, input.projectConfig);
+  applyEnv(config, input.env ?? {});
+  validateConfig(config);
+  return config;
+}
+function redactedConfig(config) {
+  return {
+    ...config,
+    model: { ...config.model },
+    workspace: { ...config.workspace },
+    runtime: { ...config.runtime },
+    trace: { ...config.trace },
+    tools: { ...config.tools },
+    permissions: { ...config.permissions },
+    sessions: { ...config.sessions },
+    memory: { ...config.memory },
+    secrets: {
+      apiKey: config.secrets.apiKey === void 0 ? "missing" : "configured"
+    }
+  };
+}
+function cloneConfig(config) {
+  return {
+    model: { ...config.model },
+    workspace: { ...config.workspace },
+    runtime: { ...config.runtime },
+    trace: { ...config.trace },
+    tools: { ...config.tools },
+    permissions: { ...config.permissions },
+    sessions: { ...config.sessions },
+    memory: { ...config.memory },
+    secrets: { ...config.secrets }
+  };
+}
+function applyConfig(config, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    throw new ConfigValidationError("Configuration must be an object.");
+  }
+  applyObject(config.model, value.model);
+  applyObject(config.workspace, value.workspace);
+  applyObject(config.runtime, value.runtime);
+  applyObject(config.trace, value.trace);
+  applyObject(config.tools, value.tools);
+  applyObject(config.permissions, value.permissions);
+  applyObject(config.sessions, value.sessions);
+  applyObject(config.memory, value.memory);
+}
+function applyObject(target, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (!isRecord(value)) {
+    throw new ConfigValidationError("Configuration sections must be objects.");
+  }
+  for (const [key, sectionValue] of Object.entries(value)) {
+    if (key in target) {
+      target[key] = sectionValue;
+    }
+  }
+}
+function applyEnv(config, env) {
+  if (env.OPENROUTER_API_KEY !== void 0) {
+    config.model.provider = "openai-compatible";
+    config.model.baseURL = openRouterDefaults.baseURL;
+    config.model.model = "";
+    config.secrets.apiKey = env.OPENROUTER_API_KEY;
+  }
+  if (env.ANTHROPIC_API_KEY !== void 0) {
+    config.model.provider = "anthropic";
+    config.model.model = anthropicDefaults.model;
+    config.secrets.apiKey = env.ANTHROPIC_API_KEY;
+  }
+  if (env.VOLE_BASE_URL !== void 0) {
+    config.model.baseURL = env.VOLE_BASE_URL;
+  }
+  if (env.VOLE_MODEL !== void 0) {
+    config.model.model = env.VOLE_MODEL;
+  }
+  if (env.VOLE_DEFAULT_MODE !== void 0) {
+    config.runtime.defaultMode = env.VOLE_DEFAULT_MODE;
+  }
+  if (env.VOLE_WORKSPACE_ROOT !== void 0) {
+    config.workspace.root = env.VOLE_WORKSPACE_ROOT;
+  }
+  if (env.VOLE_LONG_TERM_MEMORY !== void 0) {
+    config.memory.longTermFiles = env.VOLE_LONG_TERM_MEMORY;
+  }
+  if (env.VOLE_API_KEY !== void 0) {
+    config.secrets.apiKey = env.VOLE_API_KEY;
+  }
+  if (env.VOLE_PROMPT_MODE !== void 0) {
+    config.runtime.promptMode = env.VOLE_PROMPT_MODE;
+  }
+  if (env.VOLE_EXECUTION_CONTRACT !== void 0) {
+    config.runtime.executionContract = env.VOLE_EXECUTION_CONTRACT;
+  }
+  if (env.VOLE_TOOL_PROFILE !== void 0) {
+    config.runtime.toolProfile = env.VOLE_TOOL_PROFILE;
+  }
+  if (env.VOLE_SANDBOX !== void 0) {
+    config.runtime.sandboxed = env.VOLE_SANDBOX === "true";
+  }
+  if (env.VOLE_THINKING_BUDGET !== void 0) {
+    config.model.thinkingBudget = env.VOLE_THINKING_BUDGET;
+  }
+}
+function validateConfig(config) {
+  if (config.model.provider !== "openai-compatible" && config.model.provider !== "anthropic") {
+    throw new ConfigValidationError(`Invalid model.provider "${String(config.model.provider)}". Expected openai-compatible or anthropic.`);
+  }
+  if (config.model.model.trim().length === 0) {
+    throw new ConfigValidationError("No model configured. Set VOLE_MODEL=<model-name> (e.g. VOLE_MODEL=openai/gpt-4o for OpenRouter).");
+  }
+  if (!isAutonomyMode(config.runtime.defaultMode)) {
+    throw new ConfigValidationError(`Invalid runtime.defaultMode "${String(config.runtime.defaultMode)}". Expected observe, confirm, or auto.`);
+  }
+  if (!isTraceVerbosity(config.trace.verbosity)) {
+    throw new ConfigValidationError(`Invalid trace.verbosity "${String(config.trace.verbosity)}". Expected explainable or debug.`);
+  }
+  if (!isLongTermMemoryFilePolicy(config.memory.longTermFiles)) {
+    throw new ConfigValidationError(`Invalid memory.longTermFiles "${String(config.memory.longTermFiles)}". Expected disabled or read-only.`);
+  }
+  if (config.memory.writes !== "disabled") {
+    throw new ConfigValidationError(`Invalid memory.writes "${String(config.memory.writes)}". Only disabled is supported.`);
+  }
+  if (config.runtime.promptMode !== void 0 && !isPromptMode(config.runtime.promptMode)) {
+    throw new ConfigValidationError(`Invalid runtime.promptMode "${String(config.runtime.promptMode)}". Expected full, minimal, or none.`);
+  }
+  if (config.runtime.executionContract !== void 0 && !isExecutionContract(config.runtime.executionContract)) {
+    throw new ConfigValidationError(`Invalid runtime.executionContract "${String(config.runtime.executionContract)}". Expected default or strict-agentic.`);
+  }
+  if (config.runtime.toolProfile !== void 0 && !isToolProfileConfig(config.runtime.toolProfile)) {
+    throw new ConfigValidationError(`Invalid runtime.toolProfile "${String(config.runtime.toolProfile)}". Expected coding, full, messaging, or background.`);
+  }
+  if (config.model.thinkingBudget !== void 0 && !isThinkingBudget(config.model.thinkingBudget)) {
+    throw new ConfigValidationError(`Invalid model.thinkingBudget "${String(config.model.thinkingBudget)}". Expected off, minimal, low, medium, high, max, or adaptive.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAutonomyMode(value) {
+  return value === "observe" || value === "confirm" || value === "auto";
+}
+function isTraceVerbosity(value) {
+  return value === "explainable" || value === "debug";
+}
+function isLongTermMemoryFilePolicy(value) {
+  return value === "disabled" || value === "read-only" || value === "write";
+}
+function isPromptMode(value) {
+  return value === "full" || value === "minimal" || value === "none";
+}
+function isExecutionContract(value) {
+  return value === "default" || value === "strict-agentic";
+}
+function isToolProfileConfig(value) {
+  return value === "coding" || value === "full" || value === "messaging" || value === "background";
+}
+function isThinkingBudget(value) {
+  return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "max" || value === "adaptive";
+}
+function resolveSessionsDirectory(config, env) {
+  const directory = config.sessions.directory;
+  if (!directory.startsWith("~/")) {
+    return directory;
+  }
+  const home = env?.HOME ?? process.env.HOME;
+  return home === void 0 ? directory : join(home, directory.slice(2));
+}
+
+// ../../packages/context/dist/index.js
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+var MinimalContextAssembler = class {
+  async assemble(input) {
+    const messages = [];
+    if (input.systemInstruction) {
+      messages.push({ role: "system", content: input.systemInstruction });
+    }
+    if (input.recentMessages) {
+      messages.push(...input.recentMessages);
+    }
+    messages.push({ role: "user", content: input.userMessage });
+    return {
+      modelInput: { messages },
+      report: {
+        includedSections: input.systemInstruction ? ["identity"] : [],
+        omittedSections: ["runtime", "tooling", "safety", "skills", "workspace"],
+        sections: []
+      }
+    };
+  }
+};
+var DefaultContextAssembler = class {
+  #workspacePromptFiles;
+  #readWorkspaceFile;
+  constructor(dependencies = {}) {
+    this.#workspacePromptFiles = dependencies.workspacePromptFiles ?? [];
+    this.#readWorkspaceFile = dependencies.readWorkspaceFile ?? ((path) => readFile(path, "utf8"));
+  }
+  async assemble(input) {
+    const mode = input.promptMode ?? "full";
+    const sectionReports = [];
+    const systemParts = [];
+    if (mode === "none") {
+      const recentMessages2 = input.recentMessages ?? [];
+      if (recentMessages2.length > 0) {
+        sectionReports.push({ name: "conversation_history", included: true });
+      }
+      sectionReports.push({ name: "user_message", included: true });
+      const includedSections2 = sectionReports.filter((s) => s.included).map((s) => s.name);
+      const omittedSections2 = sectionReports.filter((s) => !s.included).map((s) => s.name);
+      return {
+        modelInput: {
+          messages: [
+            ...recentMessages2.map((message) => ({ ...message })),
+            { role: "user", content: input.userMessage }
+          ]
+        },
+        report: { includedSections: includedSections2, omittedSections: omittedSections2, sections: sectionReports }
+      };
+    }
+    systemParts.push(`<identity>
+${input.systemInstruction}
+</identity>`);
+    sectionReports.push({ name: "identity", included: true });
+    if (mode === "full") {
+      if (input.runtime) {
+        systemParts.push("", `<runtime>
+- Mode: ${input.runtime.mode}
+- Workspace: ${input.runtime.workspace}
+- Date: ${input.runtime.currentDate}
+</runtime>`);
+        sectionReports.push({ name: "runtime", included: true });
+      } else {
+        sectionReports.push({ name: "runtime", included: false, reason: "No runtime metadata provided." });
+      }
+      if (input.tools !== void 0 && input.tools.length > 0) {
+        const toolLines = input.tools.map((t) => `- ${t.name} [${t.risk}]: ${t.description}`).join("\n");
+        systemParts.push("", `<tooling>
+${toolLines}
+</tooling>`);
+        sectionReports.push({ name: "tooling", included: true });
+      } else {
+        sectionReports.push({ name: "tooling", included: false, reason: "No tools registered." });
+      }
+      if (input.permissionGuidance !== void 0 && input.permissionGuidance.length > 0) {
+        systemParts.push("", `<safety>
+${input.permissionGuidance}
+</safety>`);
+        sectionReports.push({ name: "safety", included: true });
+      } else {
+        sectionReports.push({ name: "safety", included: false, reason: "No permission guidance provided." });
+      }
+      if (input.skillIndex !== void 0 && input.skillIndex.length > 0) {
+        const skillLines = input.skillIndex.map((s) => `- ${s.name}: ${s.description}`).join("\n");
+        systemParts.push("", `<skills>
+${skillLines}
+</skills>`);
+        sectionReports.push({ name: "skills", included: true });
+      } else {
+        sectionReports.push({ name: "skills", included: false, reason: "No skills loaded." });
+      }
+      const workspaceContent = await this.#loadWorkspacePromptSections(input.runtime?.workspace);
+      if (workspaceContent.length > 0) {
+        systemParts.push("", `<workspace>${workspaceContent.join("\n")}
+</workspace>`);
+        sectionReports.push({ name: "workspace", included: true });
+      } else if (this.#workspacePromptFiles.length > 0) {
+        sectionReports.push({ name: "workspace", included: false, reason: "No workspace prompt files found." });
+      }
+    }
+    const recentMessages = input.recentMessages ?? [];
+    if (recentMessages.length > 0) {
+      sectionReports.push({ name: "conversation_history", included: true });
+    }
+    sectionReports.push({ name: "user_message", included: true });
+    const includedSections = sectionReports.filter((s) => s.included).map((s) => s.name);
+    const omittedSections = sectionReports.filter((s) => !s.included).map((s) => s.name);
+    return {
+      modelInput: {
+        messages: [
+          { role: "system", content: systemParts.join("\n") },
+          ...recentMessages.map((message) => ({ ...message })),
+          { role: "user", content: input.userMessage }
+        ]
+      },
+      report: { includedSections, omittedSections, sections: sectionReports }
+    };
+  }
+  async #loadWorkspacePromptSections(workspace) {
+    if (workspace === void 0 || this.#workspacePromptFiles.length === 0) {
+      return [];
+    }
+    const sections = [];
+    for (const fileName of this.#workspacePromptFiles) {
+      try {
+        const content = await this.#readWorkspaceFile(join2(workspace, fileName));
+        const trimmedContent = content.trim();
+        if (trimmedContent.length > 0) {
+          sections.push("", `### ${fileName}`, trimmedContent);
+        }
+      } catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+    }
+    return sections;
+  }
+};
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+var DEFAULT_COMPACTION_OPTIONS = {
+  maxTokens: 6e4,
+  maxMessages: 400,
+  keepRecent: 12,
+  summarySystemPrompt: "You are a context distiller for an AI agent. The conversation history has grown too long and must be reduced. Extract only what the agent needs to continue working: tools called and their key outcomes, decisions reached, important facts discovered, files created or modified, errors encountered, and the current task state. Discard pleasantries, repetition, and details that no longer affect the agent's ability to proceed. Output concise factual statements only."
+};
+function estimateMessageTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string")
+      chars += msg.content.length;
+    if (msg.toolCalls !== void 0)
+      chars += JSON.stringify(msg.toolCalls).length;
+    if (msg.toolCallId !== void 0)
+      chars += msg.toolCallId.length;
+  }
+  return Math.ceil(chars / 4);
+}
+async function compactMessages(messages, modelProvider, options) {
+  const opts = { ...DEFAULT_COMPACTION_OPTIONS, ...options };
+  const shouldCompact = estimateMessageTokens(messages) > opts.maxTokens || messages.length > opts.maxMessages;
+  if (!shouldCompact) {
+    return messages;
+  }
+  const leadingSystem = messages[0]?.role === "system" ? messages[0] : void 0;
+  const conversation = leadingSystem !== void 0 ? messages.slice(1) : messages;
+  const old = conversation.slice(0, conversation.length - opts.keepRecent);
+  const recent = conversation.slice(-opts.keepRecent);
+  if (old.length === 0) {
+    return messages;
+  }
+  const thinnedOld = old.map(thinToolMessage);
+  const thinnedMessages = [
+    ...leadingSystem !== void 0 ? [leadingSystem] : [],
+    ...thinnedOld,
+    ...recent
+  ];
+  const transcript = thinnedOld.map((m) => `${m.role.toUpperCase()}: ${m.content ?? "(tool call)"}`).join("\n");
+  try {
+    const output = await modelProvider.generate({
+      messages: [
+        { role: "system", content: opts.summarySystemPrompt },
+        { role: "user", content: `Conversation to distil:
+
+${transcript}` }
+      ]
+    });
+    if (output.type !== "message" || !output.content) {
+      return thinnedMessages;
+    }
+    return [
+      ...leadingSystem !== void 0 ? [leadingSystem] : [],
+      { role: "system", content: `Conversation summary:
+${output.content}` },
+      ...recent
+    ];
+  } catch {
+    return thinnedMessages;
+  }
+}
+function thinToolMessage(message) {
+  if (message.role !== "tool" || message.content === null) {
+    return message;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(message.content);
+  } catch {
+    return message.content.length > 400 ? { ...message, content: `${message.content.slice(0, 400)}
+[${message.content.length - 400} chars omitted]` } : message;
+  }
+  const slim = {};
+  if ("ok" in parsed)
+    slim["ok"] = parsed["ok"];
+  if ("summary" in parsed && typeof parsed["summary"] === "string")
+    slim["summary"] = parsed["summary"];
+  if ("exitCode" in parsed)
+    slim["exitCode"] = parsed["exitCode"];
+  if ("error" in parsed)
+    slim["error"] = parsed["error"];
+  if ("type" in parsed)
+    slim["type"] = parsed["type"];
+  if ("result" in parsed && typeof parsed["result"] === "string" && parsed["result"].length <= 200) {
+    slim["result"] = parsed["result"];
+  }
+  return { ...message, content: JSON.stringify(slim) };
+}
+
+// ../../packages/models/dist/index.js
+import Anthropic from "@anthropic-ai/sdk";
+function isStreamingProvider(provider) {
+  return "generateStream" in provider && typeof provider.generateStream === "function";
+}
+var OpenAICompatibleProvider = class {
+  #baseURL;
+  #apiKey;
+  #model;
+  #temperature;
+  #maxTokens;
+  #fetch;
+  constructor(config) {
+    this.#baseURL = config.baseURL.replace(/\/+$/, "");
+    this.#apiKey = config.apiKey;
+    this.#model = config.model;
+    this.#temperature = config.temperature;
+    this.#maxTokens = config.maxTokens;
+    this.#fetch = config.fetch ?? fetch;
+  }
+  async generate(input) {
+    try {
+      const response = await this.#fetch(`${this.#baseURL}/chat/completions`, {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify(this.#body(input))
+      });
+      if (!response.ok) {
+        return {
+          type: "error",
+          category: this.#errorCategory(response.status),
+          message: `Provider request failed with status ${response.status}.`,
+          recoverable: response.status === 408 || response.status === 409 || response.status === 429 || response.status >= 500
+        };
+      }
+      const data = await response.json();
+      const choice = data.choices?.[0];
+      const finishReason = choice?.finish_reason;
+      const message = choice?.message;
+      const rawToolCalls = message?.tool_calls;
+      if (finishReason === "tool_calls" && rawToolCalls !== void 0 && rawToolCalls.length > 0) {
+        return {
+          type: "tool_calls",
+          calls: rawToolCalls.map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            input: parseToolCallArguments(tc.function.arguments)
+          })),
+          ...data.usage ? { usage: this.#usage(data.usage) } : {}
+        };
+      }
+      return {
+        type: "message",
+        content: message?.content ?? "",
+        ...data.usage ? { usage: this.#usage(data.usage) } : {}
+      };
+    } catch {
+      return {
+        type: "error",
+        category: "network",
+        message: "Provider network request failed.",
+        recoverable: true
+      };
+    }
+  }
+  async *generateStream(input) {
+    try {
+      const response = await this.#fetch(`${this.#baseURL}/chat/completions`, {
+        method: "POST",
+        headers: this.#headers(),
+        body: JSON.stringify({ ...this.#body(input), stream: true })
+      });
+      if (!response.ok) {
+        yield {
+          type: "error",
+          category: this.#errorCategory(response.status),
+          message: `Provider request failed with status ${response.status}.`,
+          recoverable: response.status === 408 || response.status === 409 || response.status === 429 || response.status >= 500
+        };
+        return;
+      }
+      if (response.body === null) {
+        yield { type: "error", category: "network", message: "No response body for streaming request.", recoverable: true };
+        return;
+      }
+      const toolAccumulators = /* @__PURE__ */ new Map();
+      let textContent = "";
+      let usage;
+      let finishReason = null;
+      for await (const data of parseSSEStream(response.body)) {
+        if (data === "[DONE]")
+          break;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const choice = chunk.choices?.[0];
+        if (choice !== void 0) {
+          if (choice.finish_reason !== null && choice.finish_reason !== void 0) {
+            finishReason = choice.finish_reason;
+          }
+          const delta = choice.delta;
+          if (delta !== void 0) {
+            if (delta.content) {
+              textContent += delta.content;
+              yield { type: "token_delta", delta: delta.content };
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (!toolAccumulators.has(tc.index)) {
+                  toolAccumulators.set(tc.index, { id: "", name: "", arguments: "" });
+                }
+                const acc = toolAccumulators.get(tc.index);
+                if (tc.id)
+                  acc.id = tc.id;
+                if (tc.function?.name)
+                  acc.name = tc.function.name;
+                if (tc.function?.arguments)
+                  acc.arguments += tc.function.arguments;
+              }
+            }
+          }
+        }
+        if (chunk.usage) {
+          usage = this.#usage(chunk.usage);
+        }
+      }
+      if (finishReason === "tool_calls" && toolAccumulators.size > 0) {
+        const calls = Array.from(toolAccumulators.entries()).sort(([a], [b]) => a - b).map(([, acc]) => ({
+          id: acc.id,
+          name: acc.name,
+          input: parseToolCallArguments(acc.arguments)
+        }));
+        yield { type: "tool_calls", calls, ...usage !== void 0 ? { usage } : {} };
+      } else {
+        yield { type: "message_done", content: textContent, ...usage !== void 0 ? { usage } : {} };
+      }
+    } catch {
+      yield { type: "error", category: "network", message: "Provider network request failed.", recoverable: true };
+    }
+  }
+  #headers() {
+    return {
+      "content-type": "application/json",
+      ...this.#apiKey ? { authorization: `Bearer ${this.#apiKey}` } : {}
+    };
+  }
+  #body(input) {
+    return {
+      model: this.#model,
+      messages: input.messages.map((m) => this.#formatMessage(m)),
+      ...input.tools !== void 0 && input.tools.length > 0 ? { tools: input.tools } : {},
+      ...this.#temperature === void 0 ? {} : { temperature: this.#temperature },
+      ...this.#maxTokens === void 0 ? {} : { max_tokens: this.#maxTokens }
+    };
+  }
+  #formatMessage(message) {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        tool_call_id: message.toolCallId ?? "",
+        content: message.content ?? ""
+      };
+    }
+    if (message.role === "assistant" && message.toolCalls !== void 0 && message.toolCalls.length > 0) {
+      return {
+        role: "assistant",
+        content: message.content,
+        tool_calls: message.toolCalls.map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input)
+          }
+        }))
+      };
+    }
+    return { role: message.role, content: message.content };
+  }
+  #errorCategory(status) {
+    if (status === 401 || status === 403) {
+      return "authentication";
+    }
+    if (status === 429) {
+      return "rate_limit";
+    }
+    if (status === 400 || status === 422) {
+      return "invalid_request";
+    }
+    if (status === 404 || status === 503) {
+      return "model_unavailable";
+    }
+    return "unknown";
+  }
+  #usage(usage) {
+    return {
+      ...usage.prompt_tokens === void 0 ? {} : { inputTokens: usage.prompt_tokens },
+      ...usage.completion_tokens === void 0 ? {} : { outputTokens: usage.completion_tokens },
+      ...usage.total_tokens === void 0 ? {} : { totalTokens: usage.total_tokens }
+    };
+  }
+};
+async function* parseSSEStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("data: ")) {
+          yield trimmed.slice(6);
+        }
+      }
+    }
+    buffer += decoder.decode();
+    for (const line of buffer.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("data: ")) {
+        yield trimmed.slice(6);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseToolCallArguments(args) {
+  try {
+    return JSON.parse(args);
+  } catch {
+    return args;
+  }
+}
+var FakeModelProvider = class {
+  requests = [];
+  #outputs;
+  constructor(outputs) {
+    this.#outputs = [...outputs];
+  }
+  async generate(input) {
+    this.requests.push(input);
+    const output = this.#outputs.shift();
+    return output ?? {
+      type: "error",
+      category: "unknown",
+      message: "FakeModelProvider has no queued output.",
+      recoverable: false
+    };
+  }
+};
+var THINKING_BUDGET_TOKENS = {
+  minimal: 1024,
+  low: 2048,
+  medium: 4096,
+  high: 8192,
+  max: 16384
+};
+var AnthropicProvider = class {
+  #client;
+  #streamClient;
+  #model;
+  #maxTokens;
+  #temperature;
+  #thinkingBudget;
+  constructor(config) {
+    this.#model = config.model;
+    this.#maxTokens = config.maxTokens ?? 4096;
+    this.#temperature = config.temperature;
+    this.#thinkingBudget = config.thinkingBudget;
+    if (config.client !== void 0 || config.streamClient !== void 0) {
+      this.#client = config.client ?? { messages: { create: async () => {
+        throw new Error("No client provided.");
+      } } };
+      this.#streamClient = config.streamClient;
+    } else {
+      const sdk = new Anthropic({ apiKey: config.apiKey });
+      this.#client = sdk;
+      this.#streamClient = {
+        messages: {
+          stream: (params) => sdk.messages.create({ ...params, stream: true })
+        }
+      };
+    }
+  }
+  #buildThinkingParam() {
+    const budget = this.#thinkingBudget;
+    if (budget === void 0 || budget === "off")
+      return void 0;
+    if (budget === "adaptive")
+      return { type: "adaptive" };
+    const tokens = THINKING_BUDGET_TOKENS[budget];
+    return { type: "enabled", budget_tokens: tokens };
+  }
+  async generate(input) {
+    try {
+      const { system, messages } = translateMessagesToAnthropic(input.messages);
+      const systemBlocks = system !== void 0 ? [{ type: "text", text: system, cache_control: { type: "ephemeral" } }] : void 0;
+      const thinkingParam = this.#buildThinkingParam();
+      const response = await this.#client.messages.create({
+        model: this.#model,
+        max_tokens: this.#maxTokens,
+        ...systemBlocks !== void 0 ? { system: systemBlocks } : {},
+        messages,
+        ...input.tools !== void 0 && input.tools.length > 0 ? { tools: translateToolsToAnthropic(input.tools) } : {},
+        ...this.#temperature !== void 0 ? { temperature: this.#temperature } : {},
+        ...thinkingParam !== void 0 ? { thinking: thinkingParam } : {}
+      });
+      const toolUseBlocks = response.content.filter(isToolUseBlock);
+      if (response.stop_reason === "tool_use" && toolUseBlocks.length > 0) {
+        return {
+          type: "tool_calls",
+          calls: toolUseBlocks.map((b) => ({ id: b.id, name: b.name, input: b.input })),
+          usage: { inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens }
+        };
+      }
+      const textBlock = response.content.find(isTextBlock);
+      return {
+        type: "message",
+        content: textBlock?.text ?? "",
+        usage: { inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens }
+      };
+    } catch (error) {
+      return normalizeAnthropicError(error);
+    }
+  }
+  async *generateStream(input) {
+    if (this.#streamClient === void 0) {
+      const output = await this.generate(input);
+      if (output.type === "message") {
+        yield { type: "token_delta", delta: output.content };
+        yield { type: "message_done", content: output.content, ...output.usage ? { usage: output.usage } : {} };
+      } else if (output.type === "tool_calls") {
+        yield { type: "tool_calls", calls: output.calls, ...output.usage ? { usage: output.usage } : {} };
+      } else {
+        yield { type: "error", category: output.category, message: output.message, recoverable: output.recoverable };
+      }
+      return;
+    }
+    try {
+      const { system, messages } = translateMessagesToAnthropic(input.messages);
+      const systemBlocks = system !== void 0 ? [{ type: "text", text: system, cache_control: { type: "ephemeral" } }] : void 0;
+      const thinkingParam = this.#buildThinkingParam();
+      const params = {
+        model: this.#model,
+        max_tokens: this.#maxTokens,
+        ...systemBlocks !== void 0 ? { system: systemBlocks } : {},
+        messages,
+        ...input.tools !== void 0 && input.tools.length > 0 ? { tools: translateToolsToAnthropic(input.tools) } : {},
+        ...this.#temperature !== void 0 ? { temperature: this.#temperature } : {},
+        ...thinkingParam !== void 0 ? { thinking: thinkingParam } : {}
+      };
+      const stream = await this.#streamClient.messages.stream(params);
+      let textContent = "";
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let stopReason = null;
+      const toolBlocks = /* @__PURE__ */ new Map();
+      for await (const event of stream) {
+        if (event.type === "message_start") {
+          inputTokens = event.message.usage.input_tokens;
+        } else if (event.type === "content_block_start") {
+          if (event.content_block.type === "tool_use") {
+            toolBlocks.set(event.index, {
+              id: event.content_block.id ?? "",
+              name: event.content_block.name ?? "",
+              inputJson: ""
+            });
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            textContent += event.delta.text;
+            yield { type: "token_delta", delta: event.delta.text };
+          } else if (event.delta.type === "input_json_delta") {
+            const block = toolBlocks.get(event.index);
+            if (block !== void 0) {
+              block.inputJson += event.delta.partial_json;
+            }
+          }
+        } else if (event.type === "message_delta") {
+          outputTokens = event.usage.output_tokens;
+          stopReason = event.delta.stop_reason;
+        }
+      }
+      const usage = { inputTokens, outputTokens };
+      if (stopReason === "tool_use" && toolBlocks.size > 0) {
+        const calls = Array.from(toolBlocks.entries()).sort(([a], [b]) => a - b).map(([, block]) => ({
+          id: block.id,
+          name: block.name,
+          input: parseToolCallArguments(block.inputJson)
+        }));
+        yield { type: "tool_calls", calls, usage };
+      } else {
+        yield { type: "message_done", content: textContent, usage };
+      }
+    } catch (error) {
+      yield normalizeAnthropicError(error);
+    }
+  }
+};
+function translateMessagesToAnthropic(messages) {
+  let system;
+  const result = [];
+  let i = 0;
+  while (i < messages.length) {
+    const msg = messages[i];
+    if (msg === void 0)
+      break;
+    if (msg.role === "system") {
+      system = msg.content ?? void 0;
+      i++;
+      continue;
+    }
+    if (msg.role === "tool") {
+      const blocks = [];
+      while (i < messages.length) {
+        const tm = messages[i];
+        if (tm === void 0 || tm.role !== "tool")
+          break;
+        blocks.push({ type: "tool_result", tool_use_id: tm.toolCallId ?? "", content: tm.content ?? "" });
+        i++;
+      }
+      result.push({ role: "user", content: blocks });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (msg.toolCalls !== void 0 && msg.toolCalls.length > 0) {
+        const blocks = [
+          ...msg.content ? [{ type: "text", text: msg.content }] : [],
+          ...msg.toolCalls.map((c) => ({ type: "tool_use", id: c.id, name: c.name, input: c.input }))
+        ];
+        result.push({ role: "assistant", content: blocks });
+      } else {
+        result.push({ role: "assistant", content: msg.content ?? "" });
+      }
+      i++;
+      continue;
+    }
+    result.push({ role: "user", content: msg.content ?? "" });
+    i++;
+  }
+  return { system, messages: result };
+}
+function translateToolsToAnthropic(tools) {
+  return tools.map((t) => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: {
+      type: "object",
+      ...t.function.parameters.properties !== void 0 ? { properties: t.function.parameters.properties } : {},
+      ...t.function.parameters.required !== void 0 ? { required: t.function.parameters.required } : {}
+    }
+  }));
+}
+function isToolUseBlock(block) {
+  return block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string";
+}
+function isTextBlock(block) {
+  return block.type === "text" && typeof block.text === "string";
+}
+function normalizeAnthropicError(error) {
+  if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") {
+    const apiError = error;
+    return {
+      type: "error",
+      category: anthropicErrorCategory(apiError.status),
+      message: apiError.message ?? `Anthropic API error ${apiError.status}.`,
+      recoverable: apiError.status === 429 || apiError.status >= 500
+    };
+  }
+  return {
+    type: "error",
+    category: "network",
+    message: "Provider network request failed.",
+    recoverable: true
+  };
+}
+function anthropicErrorCategory(status) {
+  if (status === 401 || status === 403)
+    return "authentication";
+  if (status === 429)
+    return "rate_limit";
+  if (status === 400)
+    return "invalid_request";
+  if (status === 404)
+    return "model_unavailable";
+  if (status === 413 || status === 422)
+    return "context_length";
+  return "unknown";
+}
+
+// ../../packages/permissions/dist/index.js
+var DefaultPermissionPolicy = class {
+  evaluate(input) {
+    const risk = input.action.risk;
+    if (risk === "blocked") {
+      return {
+        decision: "deny",
+        risk,
+        reason: "Blocked actions are denied."
+      };
+    }
+    if (input.mode === "observe") {
+      return {
+        decision: "ask",
+        risk,
+        reason: "Observe mode asks before external actions."
+      };
+    }
+    if (input.mode === "auto") {
+      return risk === "high" ? {
+        decision: "ask",
+        risk,
+        reason: "High-risk action requires approval in auto mode."
+      } : {
+        decision: "allow",
+        risk,
+        reason: "Low and medium-risk actions are allowed in auto mode."
+      };
+    }
+    return risk === "low" ? {
+      decision: "allow",
+      risk,
+      reason: "Low-risk action is allowed in confirm mode."
+    } : {
+      decision: "ask",
+      risk,
+      reason: "Medium and high-risk actions require approval in confirm mode."
+    };
+  }
+};
+
+// ../../packages/tools/dist/index.js
+import { exec } from "child_process";
+import { access, readdir, readFile as readFile2, stat as statFs, writeFile as writeFileFs, mkdir } from "fs/promises";
+import { resolve, relative, basename, extname, dirname, join as join3 } from "path";
+function createReadFileTool() {
+  return {
+    name: "read_file",
+    description: "Read a UTF-8 file inside the workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string"
+        }
+      },
+      required: ["path"]
+    },
+    risk: "low",
+    async execute(input, context) {
+      const path = getPathInput(input);
+      if (path === void 0) {
+        return inputError("Tool input must include a string path.");
+      }
+      const target = resolveWorkspacePath(context.workspaceRoot, path);
+      if (target === void 0) {
+        return outsideWorkspaceError();
+      }
+      if (isSecretLikePath(target.absolutePath)) {
+        return secretFileError();
+      }
+      try {
+        return {
+          ok: true,
+          content: await readFile2(target.absolutePath, "utf8"),
+          summary: `Read file ${target.displayPath}.`
+        };
+      } catch (error) {
+        return fileSystemError(error);
+      }
+    }
+  };
+}
+function createListDirectoryTool() {
+  return {
+    name: "list_directory",
+    description: "List entries in a workspace directory.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string"
+        }
+      },
+      required: ["path"]
+    },
+    risk: "low",
+    async execute(input, context) {
+      const path = getPathInput(input);
+      if (path === void 0) {
+        return inputError("Tool input must include a string path.");
+      }
+      const target = resolveWorkspacePath(context.workspaceRoot, path);
+      if (target === void 0) {
+        return outsideWorkspaceError();
+      }
+      try {
+        const entries = await readdir(target.absolutePath, { withFileTypes: true });
+        return {
+          ok: true,
+          entries: entries.map((entry) => ({
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other"
+          })).sort((left, right) => left.name.localeCompare(right.name)),
+          summary: `Listed directory ${target.displayPath}.`
+        };
+      } catch (error) {
+        return fileSystemError(error);
+      }
+    }
+  };
+}
+function getPathInput(input) {
+  if (typeof input !== "object" || input === null || !("path" in input)) {
+    return void 0;
+  }
+  const path = input.path;
+  return typeof path === "string" ? path : void 0;
+}
+function resolveWorkspacePath(workspaceRoot, path) {
+  const root = resolve(workspaceRoot);
+  const absolutePath = resolve(root, path);
+  const relativePath = relative(root, absolutePath);
+  if (relativePath.startsWith("..") || relativePath === ".." || absolutePath !== root && relativePath === "") {
+    return void 0;
+  }
+  return {
+    absolutePath,
+    displayPath: relativePath === "" ? "." : relativePath
+  };
+}
+function inputError(message) {
+  return {
+    ok: false,
+    error: {
+      code: "invalid_input",
+      message
+    }
+  };
+}
+function outsideWorkspaceError() {
+  return {
+    ok: false,
+    error: {
+      code: "path_outside_workspace",
+      message: "Tool path must stay inside the workspace."
+    }
+  };
+}
+function fileSystemError(error) {
+  const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "fs_error";
+  return {
+    ok: false,
+    error: {
+      code,
+      message: "File system operation failed."
+    }
+  };
+}
+function isSecretLikePath(absolutePath) {
+  const name = basename(absolutePath).toLowerCase();
+  if (name === ".env" || name.startsWith(".env."))
+    return true;
+  if (name === ".netrc")
+    return true;
+  const ext = extname(name);
+  if (ext === ".key" || ext === ".pem" || ext === ".p12" || ext === ".pfx")
+    return true;
+  return name === "id_rsa" || name === "id_ed25519" || name === "id_ecdsa" || name === "id_dsa";
+}
+function secretFileError() {
+  return {
+    ok: false,
+    error: {
+      code: "path_not_permitted",
+      message: "Tool path is not permitted."
+    }
+  };
+}
+function getWriteInput(input) {
+  if (typeof input !== "object" || input === null)
+    return void 0;
+  const path = input.path;
+  const content = input.content;
+  return typeof path === "string" && typeof content === "string" ? { path, content } : void 0;
+}
+var SHELL_DEFAULT_TIMEOUT_MS = 3e4;
+var SHELL_MAX_OUTPUT_CHARS = 4e3;
+var BLOCKED_COMMAND_PATTERNS = [
+  /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*.*\s+\/\s*$/,
+  // rm -r* targeting root /
+  /\brm\b.*-[a-zA-Z]*r[a-zA-Z]*.*\s+~\/?$/,
+  // rm -r* targeting home ~
+  /:\(\)\s*\{/,
+  // fork bomb
+  /[|>]\s*\/dev\/(sd|hd|nvme|vd)[a-z0-9]?/,
+  // write/pipe to block devices
+  /\b(mkfs(\.[a-z0-9]+)?|fdisk|parted|shred)\b/
+  // disk tools
+];
+function isBlockedCommand(command) {
+  return BLOCKED_COMMAND_PATTERNS.some((pattern) => pattern.test(command));
+}
+function truncateShellOutput(output) {
+  if (output.length <= SHELL_MAX_OUTPUT_CHARS)
+    return output;
+  return `${output.slice(0, SHELL_MAX_OUTPUT_CHARS)}
+[truncated ${output.length - SHELL_MAX_OUTPUT_CHARS} characters]`;
+}
+function runShellCommand(command, cwd, timeoutMs) {
+  return new Promise((resolve2) => {
+    const start = Date.now();
+    exec(command, { cwd, timeout: timeoutMs }, (error, stdout, stderr) => {
+      const durationMs = Date.now() - start;
+      if (error?.killed === true) {
+        resolve2({ completed: false });
+        return;
+      }
+      const exitCode = error === null ? 0 : typeof error.code === "number" ? error.code : 1;
+      resolve2({
+        completed: true,
+        exitCode,
+        stdout: truncateShellOutput(stdout),
+        stderr: truncateShellOutput(stderr),
+        durationMs
+      });
+    });
+  });
+}
+function getShellInput(input) {
+  if (typeof input !== "object" || input === null)
+    return void 0;
+  const command = input.command;
+  if (typeof command !== "string")
+    return void 0;
+  const timeoutMs = input.timeoutMs;
+  return { command, ...typeof timeoutMs === "number" ? { timeoutMs } : {} };
+}
+function blockedCommandError() {
+  return {
+    ok: false,
+    error: {
+      code: "command_blocked",
+      message: "Command matches a blocked pattern."
+    }
+  };
+}
+function sandboxRejectionError() {
+  return {
+    ok: false,
+    error: {
+      code: "sandbox_rejected",
+      message: "Command rejected: workspace sandbox prevents execution outside workspace."
+    }
+  };
+}
+var SANDBOX_ESCAPE_PATTERNS = [
+  /\/\.\.\//,
+  // /../ path traversal
+  /\bcd\s+\/(\s|$)/,
+  // cd / or cd /... (absolute root)
+  /\bcd\s+~\/?(\s|$)/
+  // cd ~ or cd ~/...
+];
+function isSandboxEscape(command) {
+  return SANDBOX_ESCAPE_PATTERNS.some((pattern) => pattern.test(command));
+}
+function createShellTool(options) {
+  return {
+    name: "run_shell",
+    description: "Run a shell command in the workspace directory. Requires approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: { type: "string" },
+        timeoutMs: { type: "number" }
+      },
+      required: ["command"]
+    },
+    risk: "high",
+    async execute(input, context) {
+      const parsed = getShellInput(input);
+      if (parsed === void 0) {
+        return inputError("Tool input must include a string command.");
+      }
+      if (isBlockedCommand(parsed.command)) {
+        return blockedCommandError();
+      }
+      if (options?.sandboxed === true && isSandboxEscape(parsed.command)) {
+        return sandboxRejectionError();
+      }
+      const timeoutMs = parsed.timeoutMs ?? SHELL_DEFAULT_TIMEOUT_MS;
+      const result = await runShellCommand(parsed.command, context.workspaceRoot, timeoutMs);
+      if (!result.completed) {
+        return {
+          ok: false,
+          error: {
+            code: "timeout",
+            message: `Command exceeded ${timeoutMs}ms timeout.`
+          }
+        };
+      }
+      return {
+        ok: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        durationMs: result.durationMs,
+        summary: `Ran command in ${result.durationMs}ms with exit code ${result.exitCode}.`
+      };
+    }
+  };
+}
+function createWriteFileTool() {
+  return {
+    name: "write_file",
+    description: "Write or overwrite a UTF-8 file inside the workspace. Requires approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" }
+      },
+      required: ["path", "content"]
+    },
+    risk: "medium",
+    async execute(input, context) {
+      const parsed = getWriteInput(input);
+      if (parsed === void 0) {
+        return inputError("Tool input must include a string path and string content.");
+      }
+      const target = resolveWorkspacePath(context.workspaceRoot, parsed.path);
+      if (target === void 0) {
+        return outsideWorkspaceError();
+      }
+      if (isSecretLikePath(target.absolutePath)) {
+        return secretFileError();
+      }
+      try {
+        await mkdir(dirname(target.absolutePath), { recursive: true });
+        await writeFileFs(target.absolutePath, parsed.content, "utf8");
+        return {
+          ok: true,
+          summary: `Wrote file ${target.displayPath}.`
+        };
+      } catch (error) {
+        return fileSystemError(error);
+      }
+    }
+  };
+}
+function countOccurrences(text, needle) {
+  if (needle.length === 0)
+    return 0;
+  let count = 0;
+  let pos = 0;
+  while ((pos = text.indexOf(needle, pos)) !== -1) {
+    count++;
+    pos += needle.length;
+  }
+  return count;
+}
+function createEditFileTool() {
+  return {
+    name: "edit_file",
+    description: "Make a precise edit to an existing file by replacing an exact string. old_string must appear exactly once in the file unless replace_all is true. Prefer this over write_file when modifying existing content \u2014 it never loses surrounding code.",
+    risk: "medium",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path relative to workspace root." },
+        old_string: { type: "string", description: "The exact string to replace. Must be unique in the file." },
+        new_string: { type: "string", description: "The replacement string." },
+        replace_all: { type: "boolean", description: "Replace every occurrence. Default false (errors on multiple matches)." }
+      },
+      required: ["path", "old_string", "new_string"]
+    },
+    async execute(rawInput, context) {
+      const input = rawInput;
+      if (typeof input["path"] !== "string" || typeof input["old_string"] !== "string" || typeof input["new_string"] !== "string") {
+        return inputError("path, old_string, and new_string must be strings.");
+      }
+      const filePath = input["path"];
+      const oldStr = input["old_string"];
+      const newStr = input["new_string"];
+      const replaceAll = input["replace_all"] === true;
+      if (oldStr.length === 0)
+        return inputError("old_string must not be empty.");
+      const abs = resolve(context.workspaceRoot, filePath);
+      if (!abs.startsWith(resolve(context.workspaceRoot) + "/") && abs !== resolve(context.workspaceRoot)) {
+        return outsideWorkspaceError();
+      }
+      if (isSecretLikePath(abs))
+        return secretFileError();
+      let content;
+      try {
+        content = await readFile2(abs, "utf8");
+      } catch (err) {
+        return fileSystemError(err);
+      }
+      const count = countOccurrences(content, oldStr);
+      if (count === 0) {
+        return { ok: false, error: { code: "string_not_found", message: `old_string not found in ${filePath}.` } };
+      }
+      if (count > 1 && !replaceAll) {
+        return { ok: false, error: { code: "multiple_matches", message: `old_string appears ${count} times in ${filePath}. Use replace_all: true or add more surrounding context to make it unique.` } };
+      }
+      const newContent = content.split(oldStr).join(newStr);
+      try {
+        await writeFileFs(abs, newContent, "utf8");
+      } catch (err) {
+        return fileSystemError(err);
+      }
+      return { ok: true, path: filePath, replacements: count, summary: `Edited ${filePath}: ${count} replacement${count === 1 ? "" : "s"}.` };
+    }
+  };
+}
+function createAppendFileTool() {
+  return {
+    name: "append_file",
+    description: "Append text to the end of a file. Creates the file (and parent directories) if it does not exist. Use this to add new code, tests, or entries without touching existing content.",
+    risk: "medium",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path relative to workspace root." },
+        content: { type: "string", description: "Text to append." }
+      },
+      required: ["path", "content"]
+    },
+    async execute(rawInput, context) {
+      const input = rawInput;
+      if (typeof input["path"] !== "string" || typeof input["content"] !== "string") {
+        return inputError("path and content must be strings.");
+      }
+      const filePath = input["path"];
+      const text = input["content"];
+      const abs = resolve(context.workspaceRoot, filePath);
+      if (!abs.startsWith(resolve(context.workspaceRoot) + "/") && abs !== resolve(context.workspaceRoot)) {
+        return outsideWorkspaceError();
+      }
+      if (isSecretLikePath(abs))
+        return secretFileError();
+      try {
+        await mkdir(dirname(abs), { recursive: true });
+        await writeFileFs(abs, text, { flag: "a" });
+      } catch (err) {
+        return fileSystemError(err);
+      }
+      return { ok: true, path: filePath, summary: `Appended to ${filePath}.` };
+    }
+  };
+}
+var WEB_PAGE_MAX_CHARS = 8e3;
+function parseHttpUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function extractTextFromHtml(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, " ").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
+}
+function truncateWebContent(content) {
+  if (content.length <= WEB_PAGE_MAX_CHARS)
+    return content;
+  return `${content.slice(0, WEB_PAGE_MAX_CHARS)}
+[truncated ${content.length - WEB_PAGE_MAX_CHARS} characters]`;
+}
+function getUrlInput(input) {
+  if (typeof input !== "object" || input === null)
+    return void 0;
+  const url = input.url;
+  return typeof url === "string" ? url : void 0;
+}
+function createReadWebPageTool(fetchFn = fetch) {
+  return {
+    name: "read_web_page",
+    description: "Read a public web page and return its text content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string" }
+      },
+      required: ["url"]
+    },
+    risk: "low",
+    async execute(input, _context) {
+      const url = getUrlInput(input);
+      if (url === void 0) {
+        return inputError("Tool input must include a string url.");
+      }
+      const parsed = parseHttpUrl(url);
+      if (parsed === void 0) {
+        return inputError("Tool url must use http or https.");
+      }
+      try {
+        const response = await fetchFn(url);
+        if (!response.ok) {
+          return {
+            ok: false,
+            error: {
+              code: "http_error",
+              message: `Page request failed with status ${response.status}.`
+            }
+          };
+        }
+        const html = await response.text();
+        const content = truncateWebContent(extractTextFromHtml(html));
+        return {
+          ok: true,
+          url,
+          content,
+          summary: `Read web page ${parsed.hostname}.`
+        };
+      } catch {
+        return {
+          ok: false,
+          error: {
+            code: "network_error",
+            message: "Web page request failed."
+          }
+        };
+      }
+    }
+  };
+}
+function createUpdateTodosTool(onUpdate) {
+  return {
+    name: "update_todos",
+    description: "Update the task list to track progress on multi-step work. Call this when starting a complex task or after completing each step. At most one item may be in_progress at a time.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        todos: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              content: { type: "string" },
+              status: { type: "string", enum: ["pending", "in_progress", "completed"] }
+            },
+            required: ["content", "status"]
+          }
+        }
+      },
+      required: ["todos"]
+    },
+    risk: "low",
+    async execute(input, _context) {
+      const raw = input;
+      if (!Array.isArray(raw.todos)) {
+        return { ok: false, error: { code: "invalid_input", message: "todos must be an array." } };
+      }
+      const todos = [];
+      for (const item of raw.todos) {
+        if (typeof item !== "object" || item === null) {
+          return { ok: false, error: { code: "invalid_input", message: "Each todo must be an object." } };
+        }
+        const { content, status } = item;
+        if (typeof content !== "string" || content.length === 0) {
+          return { ok: false, error: { code: "invalid_input", message: "Each todo must have a non-empty content string." } };
+        }
+        if (status !== "pending" && status !== "in_progress" && status !== "completed") {
+          return { ok: false, error: { code: "invalid_input", message: `Invalid status "${String(status)}". Must be pending, in_progress, or completed.` } };
+        }
+        todos.push({ content, status });
+      }
+      const inProgressCount = todos.filter((t) => t.status === "in_progress").length;
+      if (inProgressCount > 1) {
+        return { ok: false, error: { code: "invalid_input", message: "At most one todo may be in_progress at a time." } };
+      }
+      onUpdate?.(todos);
+      return { ok: true };
+    }
+  };
+}
+function createLoadSkillTool(skillFileMap) {
+  return {
+    name: "load_skill",
+    description: "Load the full instructions for a named skill. Call this when you need to follow a skill's detailed guidance. Available skills are listed in the <skills> section.",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "The exact skill name to load." }
+      },
+      required: ["name"]
+    },
+    async execute(rawInput) {
+      const { name } = rawInput;
+      const filePath = skillFileMap.get(name);
+      if (filePath === void 0) {
+        return { ok: false, error: `Skill "${name}" not found. Check the skills list for available names.` };
+      }
+      try {
+        const { readFile: readFile7 } = await import("fs/promises");
+        const content = await readFile7(filePath, "utf-8");
+        return { ok: true, content };
+      } catch {
+        return { ok: false, error: `Could not read skill file for "${name}".` };
+      }
+    }
+  };
+}
+function createMemorySearchTool(memoryDir) {
+  return {
+    name: "memory_search",
+    description: "Search over memory files (MEMORY.md, USER.md, memory/YYYY-MM-DD.md) for relevant content. Returns matching excerpts.",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        maxResults: { type: "number" }
+      },
+      required: ["query"]
+    },
+    async execute(input) {
+      const raw = input;
+      const query = typeof raw.query === "string" ? raw.query : "";
+      const maxResults = typeof raw.maxResults === "number" ? raw.maxResults : 5;
+      const candidateFiles = [];
+      const rootMemoryMd = join3(memoryDir, "MEMORY.md");
+      const rootUserMd = join3(memoryDir, "USER.md");
+      const memorySubdir = join3(memoryDir, "memory");
+      for (const candidatePath of [rootMemoryMd, rootUserMd]) {
+        try {
+          await access(candidatePath);
+          candidateFiles.push(candidatePath);
+        } catch {
+        }
+      }
+      try {
+        const entries = await readdir(memorySubdir, { recursive: true, withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isFile() && entry.name.endsWith(".md")) {
+            const dir = typeof entry.parentPath === "string" ? entry.parentPath : entry.path;
+            candidateFiles.push(join3(dir, entry.name));
+          }
+        }
+      } catch {
+      }
+      if (candidateFiles.length === 0) {
+        return { ok: true, results: [], total: 0 };
+      }
+      const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+      const matches = [];
+      for (const filePath of candidateFiles) {
+        let content;
+        try {
+          content = await readFile2(filePath, "utf8");
+        } catch {
+          continue;
+        }
+        const paragraphs = content.split(/\n\n+/);
+        const relPath = relative(memoryDir, filePath);
+        for (const paragraph of paragraphs) {
+          const lowerParagraph = paragraph.toLowerCase();
+          if (queryWords.some((word) => lowerParagraph.includes(word))) {
+            matches.push({ file: relPath, excerpt: paragraph.trim() });
+            if (matches.length >= maxResults)
+              break;
+          }
+        }
+        if (matches.length >= maxResults)
+          break;
+      }
+      return { ok: true, results: matches, total: matches.length };
+    }
+  };
+}
+function createMemoryGetTool(memoryDir) {
+  return {
+    name: "memory_get",
+    description: "Read the full contents of a specific memory file. Valid paths: MEMORY.md, USER.md, memory/YYYY-MM-DD.md",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative path within the memory workspace, e.g. MEMORY.md or memory/2026-05-05.md" }
+      },
+      required: ["path"]
+    },
+    async execute(input) {
+      const raw = input;
+      const requestedPath = typeof raw.path === "string" ? raw.path : "";
+      if (requestedPath.includes("..")) {
+        return { ok: true, error: "Path traversal is not permitted." };
+      }
+      if (requestedPath.startsWith("/")) {
+        return { ok: true, error: "Absolute paths are not permitted." };
+      }
+      if (!requestedPath.endsWith(".md")) {
+        return { ok: true, error: "Only .md files are permitted." };
+      }
+      const resolvedMemoryDir = resolve(memoryDir);
+      const resolvedPath = resolve(resolvedMemoryDir, requestedPath);
+      if (!resolvedPath.startsWith(resolvedMemoryDir + "/") && resolvedPath !== resolvedMemoryDir) {
+        return { ok: true, error: "Path traversal is not permitted." };
+      }
+      try {
+        const content = await readFile2(resolvedPath, "utf8");
+        return { ok: true, content };
+      } catch {
+        return { ok: true, error: `File not found: ${requestedPath}` };
+      }
+    }
+  };
+}
+function createAppendDailyMemoryTool(options) {
+  return {
+    name: "append_daily_memory",
+    description: "Append a note to today's daily memory file (memory/YYYY-MM-DD.md) in the workspace. Use this to record facts, decisions, or observations worth remembering across sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string" }
+      },
+      required: ["content"]
+    },
+    risk: "medium",
+    async execute(input, context) {
+      const raw = input;
+      if (typeof raw.content !== "string" || raw.content.trim().length === 0) {
+        return { ok: false, error: { code: "invalid_input", message: "content must be a non-empty string." } };
+      }
+      const today = options?.getCurrentDate?.() ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const memoryDir = resolve(context.workspaceRoot, "memory");
+      const filePath = resolve(memoryDir, `${today}.md`);
+      try {
+        await mkdir(memoryDir, { recursive: true });
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 16);
+        const entry = `
+## ${timestamp}
+
+${raw.content.trim()}
+`;
+        await writeFileFs(filePath, entry, { flag: "a" });
+        return {
+          ok: true,
+          filePath: `memory/${today}.md`,
+          summary: `Appended note to memory/${today}.md.`
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to write daily memory.";
+        return { ok: false, error: { code: "write_error", message } };
+      }
+    }
+  };
+}
+var SEARCH_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".pnpm-store",
+  ".nyc_output",
+  ".turbo",
+  ".cache"
+]);
+var SEARCH_BINARY_EXTS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".avif",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".bin",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".class",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".flac",
+  ".db",
+  ".sqlite",
+  ".sqlite3"
+]);
+var SEARCH_MAX_FILE_BYTES = 512 * 1024;
+var SEARCH_DEFAULT_MAX_RESULTS = 50;
+async function* walkSearchFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SEARCH_SKIP_DIRS.has(entry.name))
+      continue;
+    const full = join3(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkSearchFiles(full);
+    } else if (entry.isFile() && !SEARCH_BINARY_EXTS.has(extname(entry.name).toLowerCase())) {
+      yield full;
+    }
+  }
+}
+function matchesInclude(relPath, pattern) {
+  const base = basename(relPath);
+  const hasPathSep = pattern.includes("/");
+  const target = hasPathSep ? relPath.replace(/\\/g, "/") : base;
+  const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(.*/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${regexStr}$`).test(target);
+}
+function createUpdateHeartbeatTool() {
+  return {
+    name: "update_heartbeat",
+    description: "Write current execution status to HEARTBEAT.md in the workspace. Use during long-running background tasks to signal progress and liveness. Status must be one of: running, completed, failed, idle.",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["running", "completed", "failed", "idle"],
+          description: "Current execution status."
+        },
+        message: {
+          type: "string",
+          description: "Human-readable progress note or status message."
+        }
+      },
+      required: ["status", "message"]
+    },
+    async execute(rawInput, context) {
+      const input = rawInput;
+      const validStatuses = ["running", "completed", "failed", "idle"];
+      const status = validStatuses.find((s) => s === input.status) ?? "running";
+      const message = typeof input.message === "string" ? input.message.trim() : "";
+      const filePath = resolve(context.workspaceRoot, "HEARTBEAT.md");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const lines = [
+        "# Heartbeat",
+        "",
+        `**Status**: ${status}`,
+        `**Last updated**: ${now}`,
+        ...message.length > 0 ? ["", message] : []
+      ];
+      try {
+        await writeFileFs(filePath, lines.join("\n") + "\n");
+        return { ok: true, filePath: "HEARTBEAT.md" };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "Failed to write HEARTBEAT.md.";
+        return { ok: false, error: { code: "write_error", message: msg } };
+      }
+    }
+  };
+}
+function createSearchFilesTool() {
+  return {
+    name: "search_files",
+    description: "Search for a text or regex pattern across files in the workspace. Returns matching file paths, line numbers, and line content. Skips node_modules, .git, dist, and binary files.",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: "Text or regex pattern to search for."
+        },
+        path: {
+          type: "string",
+          description: "Directory to search in, relative to workspace root. Defaults to '.' (workspace root)."
+        },
+        include: {
+          type: "string",
+          description: "Glob pattern to filter files, e.g. '*.ts' or '**/*.md'. Defaults to all non-binary files."
+        },
+        case_sensitive: {
+          type: "boolean",
+          description: "Case-sensitive search. Defaults to false."
+        },
+        max_results: {
+          type: "number",
+          description: `Maximum matching lines to return. Defaults to ${SEARCH_DEFAULT_MAX_RESULTS}.`
+        }
+      },
+      required: ["pattern"]
+    },
+    async execute(rawInput, context) {
+      const input = rawInput;
+      const root = context.workspaceRoot;
+      const searchDir = input.path ? resolve(root, input.path) : root;
+      const maxResults = input.max_results ?? SEARCH_DEFAULT_MAX_RESULTS;
+      const flags = input.case_sensitive === true ? "" : "i";
+      let regex;
+      try {
+        regex = new RegExp(input.pattern, flags);
+      } catch {
+        const escaped = input.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        regex = new RegExp(escaped, flags);
+      }
+      const matches = [];
+      let searchedFiles = 0;
+      let matchedFiles = 0;
+      let truncated = false;
+      outer: for await (const filePath of walkSearchFiles(searchDir)) {
+        const relPath = relative(root, filePath).replace(/\\/g, "/");
+        if (input.include !== void 0 && !matchesInclude(relPath, input.include))
+          continue;
+        let text;
+        try {
+          const s = await statFs(filePath);
+          if (s.size > SEARCH_MAX_FILE_BYTES)
+            continue;
+          text = await readFile2(filePath, "utf8");
+        } catch {
+          continue;
+        }
+        searchedFiles++;
+        const lines = text.split("\n");
+        let hit = false;
+        for (let i = 0; i < lines.length; i++) {
+          if (regex.test(lines[i])) {
+            if (matches.length >= maxResults) {
+              truncated = true;
+              break outer;
+            }
+            matches.push({ file: relPath, line: i + 1, content: lines[i].trimEnd() });
+            hit = true;
+          }
+          regex.lastIndex = 0;
+        }
+        if (hit)
+          matchedFiles++;
+      }
+      return { type: "search_files_result", matches, truncated, matchedFiles, searchedFiles };
+    }
+  };
+}
+
+// ../../packages/core/dist/index.js
+function createRuntimeEvent(event) {
+  return event;
+}
+var InMemoryRuntimeTraceStore = class {
+  #events = [];
+  async append(event) {
+    this.#events.push(event);
+  }
+  async listRecent(query = {}) {
+    const events = query.limit === void 0 ? this.#events : this.#events.slice(-query.limit);
+    return [...events];
+  }
+  async listByRun(runId) {
+    return this.#events.filter((event) => event.runId === runId);
+  }
+};
+var DEFAULT_MAX_STEPS = 12;
+var DEFAULT_MAX_PLANNING_STALL_RETRIES = 2;
+var DEFAULT_PERMISSION_GUIDANCE = "Low-risk actions run automatically. Medium and high-risk actions require approval. Blocked actions are never permitted.";
+var PLANNING_ONLY_RETRY_INSTRUCTION = "Do not restate the plan. Act now: take the first concrete tool action you can.";
+var PLAN_PROMISE_RE = /\b(?:i(?:'ll| will)|let me|i(?:'m| am)\s+going to|first[, ]+i(?:'ll| will)|next[, ]+i(?:'ll| will)|i can do that)\b/i;
+var PLAN_COMPLETION_RE = /\b(?:done|finished|implemented|updated|fixed|changed|ran|verified|found|here(?:'s| is) what|blocked by|the blocker is)\b/i;
+var PLAN_HEADING_RE = /^(?:plan|steps?|next steps?)\s*:/im;
+var PLAN_BULLET_RE = /^(?:[-*•]\s+|\d+[.)]\s+)/u;
+var PLAN_ACTION_VERB_RE = /\b(?:inspect|investigate|check|look(?:\s+into|\s+at)?|read|search|find|debug|fix|patch|update|change|edit|write|implement|run|test|verify|review|analy(?:s|z)e|summari(?:s|z)e|explain|answer|show|share|report|prepare|refactor|deploy)\b/i;
+var PLAN_MAX_CHARS = 700;
+var AgentRuntime = class {
+  #contextAssembler;
+  #modelProvider;
+  #permissionPolicy;
+  #approvalResolver;
+  #tools;
+  #skillIndex;
+  #maxSteps;
+  #maxPlanningStallRetries;
+  #systemInstruction;
+  #runtime;
+  #preferStreaming;
+  #compaction;
+  #promptMode;
+  #hooks;
+  #sessionMutex;
+  #executionContract;
+  #createRunId;
+  #createEventId;
+  #now;
+  #currentTodos = [];
+  constructor(dependencies) {
+    this.#contextAssembler = dependencies.contextAssembler ?? new MinimalContextAssembler();
+    this.#modelProvider = dependencies.modelProvider;
+    this.#permissionPolicy = dependencies.permissionPolicy ?? new DefaultPermissionPolicy();
+    this.#approvalResolver = dependencies.approvalResolver;
+    this.#maxSteps = dependencies.maxSteps ?? DEFAULT_MAX_STEPS;
+    this.#executionContract = dependencies.executionContract ?? "default";
+    this.#maxPlanningStallRetries = dependencies.executionContract === "strict-agentic" ? dependencies.maxPlanningStallRetries ?? 3 : dependencies.maxPlanningStallRetries ?? DEFAULT_MAX_PLANNING_STALL_RETRIES;
+    this.#skillIndex = dependencies.skillIndex ?? [];
+    const baseInstruction = dependencies.systemInstruction ?? "";
+    this.#systemInstruction = dependencies.executionContract === "strict-agentic" ? `${baseInstruction}
+
+Execution contract: strict-agentic. Act immediately. Do not narrate plans. Call tools now.` : baseInstruction;
+    this.#runtime = dependencies.runtime;
+    this.#preferStreaming = dependencies.preferStreaming ?? false;
+    this.#compaction = dependencies.compaction;
+    this.#promptMode = dependencies.promptMode;
+    this.#hooks = dependencies.hooks;
+    this.#sessionMutex = dependencies.sessionMutex;
+    this.#createRunId = dependencies.createRunId ?? randomId("run");
+    this.#createEventId = dependencies.createEventId ?? randomId("evt");
+    this.#now = dependencies.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    const updateTodos = createUpdateTodosTool((todos) => {
+      this.#currentTodos = todos;
+    });
+    const userTools = dependencies.tools ?? [];
+    this.#tools = new Map([updateTodos, ...userTools].map((tool) => [tool.name, tool]));
+  }
+  async *runTurn(input) {
+    const runId = this.#createRunId();
+    const base = input.sessionId ? { runId, sessionId: input.sessionId } : { runId };
+    const collectedEvents = [];
+    const release = this.#sessionMutex ? await this.#sessionMutex.acquire(input.sessionId ?? "global") : void 0;
+    try {
+      if (this.#hooks?.beforeTurn !== void 0) {
+        try {
+          await this.#hooks.beforeTurn(input);
+        } catch (err) {
+          if (typeof process !== "undefined" && process.env["NODE_ENV"] !== "production") {
+            console.warn("[AgentRuntime] beforeTurn hook threw:", err);
+          }
+        }
+      }
+      const emitAndCollect = (event) => {
+        collectedEvents.push(event);
+        return event;
+      };
+      yield emitAndCollect(this.#event({ ...base, type: "run_started", userMessage: input.message }));
+      const contextToolSummaries = this.#buildContextToolSummaries();
+      const assembled = await this.#contextAssembler.assemble({
+        systemInstruction: this.#systemInstruction,
+        ...this.#runtime ? { runtime: this.#runtime } : {},
+        ...contextToolSummaries.length > 0 ? { tools: contextToolSummaries } : {},
+        permissionGuidance: DEFAULT_PERMISSION_GUIDANCE,
+        ...this.#skillIndex.length > 0 ? { skillIndex: this.#skillIndex } : {},
+        ...input.recentMessages ? { recentMessages: input.recentMessages } : {},
+        ...this.#promptMode !== void 0 ? { promptMode: this.#promptMode } : {},
+        userMessage: input.message
+      });
+      yield emitAndCollect(this.#event({
+        ...base,
+        type: "context_assembled",
+        messageCount: assembled.modelInput.messages.length,
+        systemInstructionIncluded: assembled.report.includedSections.includes("identity")
+      }));
+      const toolDefinitions = this.#buildToolDefinitions();
+      let messages = assembled.modelInput.messages;
+      let steps = 0;
+      let stallCount = 0;
+      let hadRealToolCallThisTurn = false;
+      this.#currentTodos = [];
+      const turnNewMessages = [];
+      const userMsg = assembled.modelInput.messages.at(-1);
+      if (userMsg)
+        turnNewMessages.push({ ...userMsg });
+      while (steps < this.#maxSteps) {
+        if (input.signal?.aborted) {
+          yield emitAndCollect(this.#event({ ...base, type: "run_failed", error: { message: "Aborted by user.", recoverable: false } }));
+          await this.#callAfterTurn(collectedEvents);
+          return;
+        }
+        if (this.#compaction !== void 0) {
+          const before = messages.length;
+          messages = await compactMessages(messages, this.#modelProvider, this.#compaction);
+          const after = messages.length;
+          if (after < before) {
+            const summaryMsg = messages.find((m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith("Conversation summary:\n"));
+            const summary = summaryMsg && typeof summaryMsg.content === "string" ? summaryMsg.content.slice("Conversation summary:\n".length) : "";
+            yield emitAndCollect(this.#event({ ...base, type: "compaction_triggered", messagesBefore: before, messagesAfter: after, summary }));
+          }
+          if (this.#hooks?.onCompaction !== void 0) {
+            try {
+              await this.#hooks.onCompaction(before, after);
+            } catch (err) {
+              if (typeof process !== "undefined" && process.env["NODE_ENV"] !== "production") {
+                console.warn("[AgentRuntime] onCompaction hook threw:", err);
+              }
+            }
+          }
+        }
+        yield emitAndCollect(this.#event({ ...base, type: "model_request_started", provider: "configured" }));
+        const modelInput = {
+          messages,
+          ...toolDefinitions.length > 0 ? { tools: toolDefinitions } : {},
+          ...assembled.modelInput.options !== void 0 ? { options: assembled.modelInput.options } : {}
+        };
+        let output;
+        if (this.#preferStreaming && isStreamingProvider(this.#modelProvider)) {
+          let textContent = "";
+          let streamedToolCalls;
+          let streamedUsage;
+          let streamError;
+          for await (const streamEvent of this.#modelProvider.generateStream(modelInput)) {
+            if (input.signal?.aborted)
+              break;
+            if (streamEvent.type === "token_delta") {
+              yield emitAndCollect(this.#event({ ...base, type: "token_delta", delta: streamEvent.delta }));
+            } else if (streamEvent.type === "message_done") {
+              textContent = streamEvent.content;
+              streamedUsage = streamEvent.usage;
+            } else if (streamEvent.type === "tool_calls") {
+              streamedToolCalls = streamEvent.calls;
+              streamedUsage = streamEvent.usage;
+            } else if (streamEvent.type === "error") {
+              streamError = { category: streamEvent.category, message: streamEvent.message, recoverable: streamEvent.recoverable };
+            }
+          }
+          if (streamError !== void 0) {
+            output = { type: "error", category: streamError.category, message: streamError.message, recoverable: streamError.recoverable };
+          } else if (streamedToolCalls !== void 0) {
+            output = { type: "tool_calls", calls: streamedToolCalls, ...streamedUsage !== void 0 ? { usage: streamedUsage } : {} };
+          } else {
+            output = { type: "message", content: textContent, ...streamedUsage !== void 0 ? { usage: streamedUsage } : {} };
+          }
+        } else {
+          output = await this.#modelProvider.generate(modelInput);
+        }
+        yield emitAndCollect(this.#event({ ...base, type: "model_request_completed", provider: "configured" }));
+        steps++;
+        if (output.type === "error") {
+          const ev = emitAndCollect(this.#event({ ...base, type: "run_failed", error: { message: output.message, recoverable: output.recoverable } }));
+          yield ev;
+          await this.#callAfterTurn(collectedEvents);
+          return;
+        }
+        if (output.type === "message") {
+          const hasActionableTools = [...this.#tools.keys()].some((n) => n !== "update_todos");
+          if (hasActionableTools && !hadRealToolCallThisTurn && isPlanningOnly(output.content)) {
+            stallCount++;
+            yield emitAndCollect(this.#event({ ...base, type: "planning_stall_detected", stallCount, maxRetries: this.#maxPlanningStallRetries }));
+            if (stallCount >= this.#maxPlanningStallRetries) {
+              const ev = emitAndCollect(this.#event({ ...base, type: "run_failed", error: { message: "Agent stopped after repeated plan-only turns without taking action.", recoverable: false } }));
+              yield ev;
+              await this.#callAfterTurn(collectedEvents);
+              return;
+            }
+            messages = [
+              ...messages,
+              { role: "assistant", content: output.content },
+              { role: "user", content: PLANNING_ONLY_RETRY_INSTRUCTION }
+            ];
+            continue;
+          }
+          stallCount = 0;
+          turnNewMessages.push({ role: "assistant", content: output.content });
+          yield emitAndCollect(this.#event({ ...base, type: "assistant_message_created", message: { role: "assistant", content: output.content } }));
+          yield emitAndCollect(this.#event({ ...base, type: "turn_complete", messages: [...turnNewMessages] }));
+          const completedEv = emitAndCollect(this.#event({ ...base, type: "run_completed" }));
+          yield completedEv;
+          await this.#callAfterTurn(collectedEvents);
+          return;
+        }
+        stallCount = 0;
+        if (output.calls.some((c) => c.name !== "update_todos")) {
+          hadRealToolCallThisTurn = true;
+        }
+        const assistantToolCallMsg = { role: "assistant", content: null, toolCalls: output.calls };
+        messages = [...messages, assistantToolCallMsg];
+        turnNewMessages.push({ ...assistantToolCallMsg });
+        const toolResultMessages = [];
+        let hardTerminate = false;
+        let terminationError = "";
+        for (const call of output.calls) {
+          yield emitAndCollect(this.#event({ ...base, type: "tool_call_requested", call }));
+          const tool = this.#tools.get(call.name);
+          if (tool === void 0) {
+            const errorMessage = `Tool "${call.name}" is not registered.`;
+            yield emitAndCollect(this.#event({ ...base, type: "tool_failed", callId: call.id, toolName: call.name, error: { message: errorMessage } }));
+            const errResultMsg = { role: "tool", toolCallId: call.id, content: `Error: ${errorMessage}` };
+            toolResultMessages.push(errResultMsg);
+            turnNewMessages.push({ ...errResultMsg });
+            continue;
+          }
+          const decision = this.#permissionPolicy.evaluate({
+            mode: normalizeAutonomyMode(this.#runtime?.mode),
+            action: createToolPermissionAction(call, tool.risk)
+          });
+          yield emitAndCollect(this.#event({ ...base, type: "tool_call_permission_evaluated", callId: call.id, toolName: call.name, decision }));
+          if (decision.decision === "deny") {
+            hardTerminate = true;
+            terminationError = `Tool call ${call.name} was denied.`;
+            break;
+          }
+          if (decision.decision === "ask") {
+            yield emitAndCollect(this.#event({ ...base, type: "approval_requested", callId: call.id, toolName: call.name, decision }));
+            const resolution = this.#approvalResolver === void 0 ? { approved: false, reason: "No approval resolver was configured." } : await this.#approvalResolver.resolve({ call, decision });
+            yield emitAndCollect(this.#event({ ...base, type: "approval_resolved", callId: call.id, toolName: call.name, resolution }));
+            if (!resolution.approved) {
+              hardTerminate = true;
+              terminationError = `Tool call ${call.name} was denied.`;
+              break;
+            }
+          }
+          if (this.#hooks?.beforeToolCall !== void 0) {
+            let hookResult = void 0;
+            try {
+              hookResult = await this.#hooks.beforeToolCall(call);
+            } catch (err) {
+              if (typeof process !== "undefined" && process.env["NODE_ENV"] !== "production") {
+                console.warn("[AgentRuntime] beforeToolCall hook threw:", err);
+              }
+            }
+            if (hookResult === "abort") {
+              const abortMessage = "Tool call aborted by hook.";
+              yield emitAndCollect(this.#event({ ...base, type: "tool_failed", callId: call.id, toolName: call.name, error: { message: abortMessage } }));
+              const abortResultMsg = { role: "tool", toolCallId: call.id, content: `Error: ${abortMessage}` };
+              toolResultMessages.push(abortResultMsg);
+              turnNewMessages.push({ ...abortResultMsg });
+              continue;
+            }
+          }
+          yield emitAndCollect(this.#event({ ...base, type: "tool_started", callId: call.id, toolName: call.name }));
+          let result;
+          try {
+            result = await tool.execute(call.input, {
+              workspaceRoot: this.#runtime?.workspace ?? process.cwd()
+            });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown tool execution error.";
+            yield emitAndCollect(this.#event({ ...base, type: "tool_failed", callId: call.id, toolName: call.name, error: { message: errorMessage } }));
+            const execErrMsg = { role: "tool", toolCallId: call.id, content: `Error: ${errorMessage}` };
+            toolResultMessages.push(execErrMsg);
+            turnNewMessages.push({ ...execErrMsg });
+            continue;
+          }
+          yield emitAndCollect(this.#event({ ...base, type: "tool_completed", callId: call.id, toolName: call.name, result }));
+          const toolSuccessMsg = { role: "tool", toolCallId: call.id, content: JSON.stringify(result) };
+          toolResultMessages.push(toolSuccessMsg);
+          turnNewMessages.push({ ...toolSuccessMsg });
+          if (this.#hooks?.afterToolCall !== void 0) {
+            try {
+              await this.#hooks.afterToolCall(call, result);
+            } catch (err) {
+              if (typeof process !== "undefined" && process.env["NODE_ENV"] !== "production") {
+                console.warn("[AgentRuntime] afterToolCall hook threw:", err);
+              }
+            }
+          }
+        }
+        if (hardTerminate) {
+          const ev = emitAndCollect(this.#event({ ...base, type: "run_failed", error: { message: terminationError, recoverable: false } }));
+          yield ev;
+          await this.#callAfterTurn(collectedEvents);
+          return;
+        }
+        if (output.calls.some((c) => c.name === "update_todos")) {
+          yield emitAndCollect(this.#event({ ...base, type: "todos_updated", todos: [...this.#currentTodos] }));
+        }
+        messages = [...messages, ...toolResultMessages];
+      }
+      const stepLimitEv = emitAndCollect(this.#event({ ...base, type: "run_failed", error: { message: `Agent loop reached the step limit of ${this.#maxSteps}.`, recoverable: false } }));
+      yield stepLimitEv;
+      await this.#callAfterTurn(collectedEvents);
+    } finally {
+      release?.();
+    }
+  }
+  async #callAfterTurn(events) {
+    if (this.#hooks?.afterTurn === void 0)
+      return;
+    try {
+      await this.#hooks.afterTurn(events);
+    } catch (err) {
+      if (typeof process !== "undefined" && process.env["NODE_ENV"] !== "production") {
+        console.warn("[AgentRuntime] afterTurn hook threw:", err);
+      }
+    }
+  }
+  #buildContextToolSummaries() {
+    return [...this.#tools.values()].map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      risk: tool.risk
+    }));
+  }
+  #buildToolDefinitions() {
+    return [...this.#tools.values()].map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  #event(event) {
+    return createRuntimeEvent({
+      ...event,
+      eventId: this.#createEventId(),
+      timestamp: this.#now()
+    });
+  }
+};
+function randomId(prefix) {
+  return () => `${prefix}_${crypto.randomUUID()}`;
+}
+function createToolPermissionAction(call, risk) {
+  return {
+    kind: "tool",
+    name: call.name,
+    summary: `Model requested tool ${call.name}.`,
+    risk
+  };
+}
+function normalizeAutonomyMode(mode) {
+  return mode === "observe" || mode === "auto" ? mode : "confirm";
+}
+function hasStructuredPlanFormat(text) {
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  if (lines.length === 0)
+    return false;
+  const bulletCount = lines.filter((l) => PLAN_BULLET_RE.test(l)).length;
+  const hasPromise = lines.some((l) => PLAN_PROMISE_RE.test(l));
+  const hasHeading = PLAN_HEADING_RE.test(lines[0] ?? "");
+  return hasHeading && hasPromise || bulletCount >= 2 && hasPromise;
+}
+function isPlanningOnly(content) {
+  const text = content.trim();
+  if (!text || text.length > PLAN_MAX_CHARS || text.includes("```"))
+    return false;
+  if (PLAN_COMPLETION_RE.test(text))
+    return false;
+  const hasStructured = hasStructuredPlanFormat(text);
+  if (!PLAN_PROMISE_RE.test(text) && !hasStructured)
+    return false;
+  if (!hasStructured && !PLAN_ACTION_VERB_RE.test(text))
+    return false;
+  return true;
+}
+function createSpawnSubagentAsyncTool(factory, options) {
+  return {
+    name: "spawn_subagent_async",
+    description: "Spawn a sub-agent to handle a subtask asynchronously. Returns a taskId immediately; the sub-agent runs in the background. Use spawn_subagent for synchronous execution.",
+    risk: "medium",
+    inputSchema: {
+      type: "object",
+      properties: {
+        goal: { type: "string", description: "The complete goal for the sub-agent." },
+        context: { type: "string", description: "Optional background context." }
+      },
+      required: ["goal"]
+    },
+    async execute(rawInput) {
+      const input = rawInput;
+      const taskId = `task_${crypto.randomUUID()}`;
+      if (options?.taskStore !== void 0) {
+        await options.taskStore.create({
+          id: taskId,
+          runtime: "subagent",
+          task: input.goal,
+          status: "queued",
+          ...options.parentTaskId !== void 0 ? { parentId: options.parentTaskId } : {}
+        });
+      }
+      const message = input.context !== void 0 ? `${input.goal}
+
+Context:
+${input.context}` : input.goal;
+      void (async () => {
+        if (options?.taskStore !== void 0) {
+          await options.taskStore.update(taskId, { status: "running" });
+        }
+        const subRuntime = factory.create(input.goal);
+        let assistantText = "";
+        let failed = false;
+        for await (const event of subRuntime.runTurn({ message })) {
+          if (event.type === "assistant_message_created")
+            assistantText = event.message.content;
+          if (event.type === "run_failed")
+            failed = true;
+        }
+        if (options?.taskStore !== void 0) {
+          await options.taskStore.update(taskId, {
+            status: failed ? "failed" : "succeeded",
+            ...assistantText.length > 0 ? { terminalSummary: assistantText } : {}
+          });
+        }
+      })();
+      const result = { type: "spawn_subagent_async_result", taskId, status: "queued" };
+      return result;
+    }
+  };
+}
+function createCheckSubagentTool(taskStore) {
+  return {
+    name: "check_subagent",
+    description: "Check the status and result of an async sub-agent by taskId. Returns status (queued/running/succeeded/failed) and result when complete. Use after spawn_subagent_async.",
+    risk: "low",
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskId: { type: "string", description: "The taskId returned by spawn_subagent_async." }
+      },
+      required: ["taskId"]
+    },
+    async execute(rawInput) {
+      const input = rawInput;
+      const taskId = typeof input.taskId === "string" ? input.taskId.trim() : "";
+      if (taskId === "") {
+        return { ok: false, error: { code: "invalid_input", message: "taskId is required." } };
+      }
+      const record = await taskStore.get(taskId);
+      if (record === void 0) {
+        return { ok: false, error: { code: "not_found", message: `No subagent task found with id "${taskId}".` } };
+      }
+      return {
+        type: "check_subagent_result",
+        taskId: record.id,
+        status: record.status,
+        result: record.terminalSummary
+      };
+    }
+  };
+}
+function createSpawnSubagentTool(factory) {
+  return {
+    name: "spawn_subagent",
+    description: "Spawn a focused sub-agent to handle a complex subtask and return its result. Use when the current task requires a separate focused execution context.",
+    risk: "medium",
+    inputSchema: {
+      type: "object",
+      properties: {
+        goal: { type: "string", description: "The complete goal for the sub-agent." },
+        context: { type: "string", description: "Optional background context to share." }
+      },
+      required: ["goal"]
+    },
+    async execute(rawInput, _execContext) {
+      const input = rawInput;
+      const subRuntime = factory.create(input.goal);
+      let assistantText = "";
+      let failed = false;
+      let errorMsg = "";
+      for await (const event of subRuntime.runTurn({ message: input.goal })) {
+        if (event.type === "assistant_message_created") {
+          assistantText = event.message.content;
+        }
+        if (event.type === "run_failed") {
+          failed = true;
+          errorMsg = event.error.message;
+        }
+      }
+      if (failed) {
+        return { type: "spawn_subagent_result", ok: false, error: errorMsg };
+      }
+      return { type: "spawn_subagent_result", ok: true, result: assistantText };
+    }
+  };
+}
+
+// ../../packages/gateway/dist/index.js
+var SessionGateway = class {
+  #sessions = /* @__PURE__ */ new Map();
+  register(session) {
+    this.#sessions.set(session.id, session);
+  }
+  unregister(sessionId) {
+    this.#sessions.delete(sessionId);
+  }
+  touch(sessionId) {
+    const s = this.#sessions.get(sessionId);
+    if (s !== void 0) {
+      this.#sessions.set(sessionId, { ...s, lastActivityAt: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  }
+  get(sessionId) {
+    return this.#sessions.get(sessionId);
+  }
+  list() {
+    return Array.from(this.#sessions.values());
+  }
+  listByAdapter(adapterName) {
+    return this.list().filter((s) => s.adapterName === adapterName);
+  }
+};
+
+// ../../packages/adapters/dist/index.js
+var CLI_CAPABILITIES = {
+  streaming: true,
+  approvalPrompts: true,
+  background: false
+};
+var TOOL_PROFILES = {
+  full: {
+    name: "full",
+    description: "All available tools.",
+    allowedTools: []
+  },
+  coding: {
+    name: "coding",
+    description: "File system, search, and shell tools for coding tasks.",
+    allowedTools: ["read_file", "list_directory", "write_file", "edit_file", "append_file", "run_shell", "search_files", "load_skill", "update_todos", "spawn_subagent", "spawn_subagent_async", "check_subagent"]
+  },
+  messaging: {
+    name: "messaging",
+    description: "Read-only tools for informational tasks without file writes or shell execution.",
+    allowedTools: ["read_file", "list_directory", "read_web_page", "memory_search", "memory_get", "load_skill", "update_todos"]
+  },
+  background: {
+    name: "background",
+    description: "File system tools only for unattended background tasks.",
+    allowedTools: ["read_file", "list_directory", "write_file", "memory_search", "memory_get", "append_daily_memory", "update_todos", "spawn_subagent", "update_heartbeat"]
+  }
+};
+function filterToolsByProfile(tools, profile) {
+  const def = TOOL_PROFILES[profile];
+  if (def.allowedTools.length === 0)
+    return tools;
+  return tools.filter((t) => def.allowedTools.includes(t.name));
+}
+
+// ../../packages/scheduler/dist/index.js
+import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var JsonlTaskStore = class {
+  #filePath;
+  constructor(filePath) {
+    this.#filePath = filePath;
+  }
+  async saveRun(record) {
+    await mkdir2(dirname2(this.#filePath), { recursive: true });
+    await writeFile(this.#filePath, `${JSON.stringify(record)}
+`, { flag: "a" });
+  }
+  async updateRun(id, updates) {
+    const records = await this.#readAll();
+    const updated = records.map((record) => record.id === id ? { ...record, ...updates } : record);
+    await mkdir2(dirname2(this.#filePath), { recursive: true });
+    await writeFile(this.#filePath, updated.map((r) => JSON.stringify(r)).join("\n") + (updated.length > 0 ? "\n" : ""));
+  }
+  async listRuns(query = {}) {
+    const records = await this.#readAll();
+    const filtered = query.taskName === void 0 ? records : records.filter((record) => record.taskName === query.taskName);
+    return query.limit === void 0 ? filtered : filtered.slice(-query.limit);
+  }
+  async #readAll() {
+    let content = "";
+    try {
+      content = await readFile3(this.#filePath, "utf8");
+    } catch (error) {
+      if (isNodeError2(error) && error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    const records = [];
+    for (const line of content.split("\n")) {
+      if (line.trim() === "") {
+        continue;
+      }
+      records.push(JSON.parse(line));
+    }
+    return records;
+  }
+};
+var BackgroundApprovalResolver = class {
+  #mode;
+  constructor(mode = "confirm") {
+    this.#mode = mode;
+  }
+  async resolve(_request) {
+    if (this.#mode === "auto") {
+      return {
+        approved: true,
+        reason: "Auto-approved in background auto mode."
+      };
+    }
+    return {
+      approved: false,
+      reason: `Auto-denied in background ${this.#mode} mode: no user is present to approve.`
+    };
+  }
+};
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+function matchesCronField(field, value) {
+  if (field === "*")
+    return true;
+  const num = parseInt(field, 10);
+  return !isNaN(num) && num === value;
+}
+function matchesCron(expression, date) {
+  const parts = expression.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return false;
+  const [min, hour, dom, month, dow] = parts;
+  return matchesCronField(min, date.getMinutes()) && matchesCronField(hour, date.getHours()) && matchesCronField(dom, date.getDate()) && matchesCronField(month, date.getMonth() + 1) && matchesCronField(dow, date.getDay());
+}
+async function writeHeartbeat(filePath, state) {
+  await mkdir2(dirname2(filePath), { recursive: true });
+  const lines = [
+    "# Heartbeat",
+    "",
+    `**Status**: ${state.status}`,
+    `**Last updated**: ${state.lastUpdatedAt}`,
+    ...state.taskName !== void 0 ? [`**Task**: ${state.taskName}`] : [],
+    ...state.runId !== void 0 ? [`**Run ID**: ${state.runId}`] : [],
+    ...state.message !== void 0 ? ["", state.message] : []
+  ];
+  await writeFile(filePath, lines.join("\n") + "\n");
+}
+var CronScheduler = class {
+  #tasks;
+  #runner;
+  #intervalMs;
+  #getNow;
+  #timer;
+  #lastRun = /* @__PURE__ */ new Map();
+  // task name → last run minute key
+  constructor(tasks, runner, options) {
+    this.#tasks = tasks;
+    this.#runner = runner;
+    this.#intervalMs = options?.checkIntervalMs ?? 3e4;
+    this.#getNow = options?.getNow ?? (() => /* @__PURE__ */ new Date());
+  }
+  start() {
+    if (this.#timer !== void 0)
+      return;
+    this.#timer = setInterval(() => void this.#tick(), this.#intervalMs);
+    void this.#tick();
+  }
+  stop() {
+    if (this.#timer !== void 0) {
+      clearInterval(this.#timer);
+      this.#timer = void 0;
+    }
+  }
+  get isRunning() {
+    return this.#timer !== void 0;
+  }
+  async #tick() {
+    const now = this.#getNow();
+    for (const task of this.#tasks) {
+      if (!task.cron)
+        continue;
+      if (!matchesCron(task.cron, now))
+        continue;
+      const lastRun = this.#lastRun.get(task.name) ?? 0;
+      const minuteKey = Math.floor(now.getTime() / 6e4);
+      if (lastRun === minuteKey)
+        continue;
+      this.#lastRun.set(task.name, minuteKey);
+      try {
+        await this.#runner(task);
+      } catch {
+      }
+    }
+  }
+};
+
+// ../../packages/sessions/dist/index.js
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+var InMemorySessionStore = class {
+  #sessions = /* @__PURE__ */ new Map();
+  #messages = /* @__PURE__ */ new Map();
+  #traceEvents = /* @__PURE__ */ new Map();
+  #createSessionId;
+  #createMessageId;
+  #now;
+  constructor(dependencies = {}) {
+    this.#createSessionId = dependencies.createSessionId ?? randomId2("sess");
+    this.#createMessageId = dependencies.createMessageId ?? randomId2("msg");
+    this.#now = dependencies.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async createSession(input = {}) {
+    const timestamp = this.#now();
+    const session = {
+      id: this.#createSessionId(),
+      ...input.title === void 0 ? {} : { title: input.title },
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    this.#sessions.set(session.id, session);
+    this.#messages.set(session.id, []);
+    this.#traceEvents.set(session.id, []);
+    return { ...session };
+  }
+  async getSession(sessionId) {
+    const session = this.#sessions.get(sessionId);
+    return session === void 0 ? void 0 : { ...session };
+  }
+  async listSessions(query = {}) {
+    const sessions = [...this.#sessions.values()].sort(compareSessionsByRecentUpdate);
+    const selectedSessions = query.limit === void 0 ? sessions : sessions.slice(0, query.limit);
+    return selectedSessions.map((session) => ({ ...session }));
+  }
+  async appendMessage(input) {
+    const session = this.#sessions.get(input.sessionId);
+    if (session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const timestamp = this.#now();
+    const message = {
+      id: this.#createMessageId(),
+      sessionId: input.sessionId,
+      role: input.role,
+      content: input.content,
+      createdAt: timestamp,
+      ...input.toolCalls !== void 0 ? { toolCalls: input.toolCalls } : {},
+      ...input.toolCallId !== void 0 ? { toolCallId: input.toolCallId } : {}
+    };
+    const messages = this.#messages.get(input.sessionId) ?? [];
+    messages.push(message);
+    this.#messages.set(input.sessionId, messages);
+    this.#sessions.set(input.sessionId, {
+      ...session,
+      updatedAt: timestamp
+    });
+    return { ...message };
+  }
+  async listMessages(sessionId, query = {}) {
+    const messages = this.#messages.get(sessionId) ?? [];
+    const selectedMessages = query.limit === void 0 ? messages : messages.slice(-query.limit);
+    return selectedMessages.map((message) => ({ ...message }));
+  }
+  async appendCompactBoundary(input) {
+    const session = this.#sessions.get(input.sessionId);
+    if (session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const messages = [];
+    if (input.summary) {
+      const timestamp = this.#now();
+      messages.push({
+        id: this.#createMessageId(),
+        sessionId: input.sessionId,
+        role: "system",
+        content: input.summary,
+        createdAt: timestamp
+      });
+      this.#sessions.set(input.sessionId, {
+        ...session,
+        updatedAt: timestamp
+      });
+    }
+    this.#messages.set(input.sessionId, messages);
+  }
+  async appendTraceEvent(input) {
+    const session = this.#sessions.get(input.sessionId);
+    if (session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const timestamp = this.#now();
+    const traceEvent = {
+      sessionId: input.sessionId,
+      event: input.event,
+      createdAt: timestamp
+    };
+    const traceEvents = this.#traceEvents.get(input.sessionId) ?? [];
+    traceEvents.push(traceEvent);
+    this.#traceEvents.set(input.sessionId, traceEvents);
+    this.#sessions.set(input.sessionId, {
+      ...session,
+      updatedAt: timestamp
+    });
+    return cloneTraceEventRecord(traceEvent);
+  }
+  async listTraceEvents(sessionId, query = {}) {
+    const traceEvents = this.#traceEvents.get(sessionId) ?? [];
+    const selectedTraceEvents = query.limit === void 0 ? traceEvents : traceEvents.slice(-query.limit);
+    return selectedTraceEvents.map((traceEvent) => cloneTraceEventRecord(traceEvent));
+  }
+};
+var JsonlSessionStore = class {
+  #directory;
+  #createSessionId;
+  #createMessageId;
+  #now;
+  constructor(dependencies) {
+    this.#directory = dependencies.directory;
+    this.#createSessionId = dependencies.createSessionId ?? randomId2("sess");
+    this.#createMessageId = dependencies.createMessageId ?? randomId2("msg");
+    this.#now = dependencies.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async createSession(input = {}) {
+    const timestamp = this.#now();
+    const session = {
+      id: this.#createSessionId(),
+      ...input.title === void 0 ? {} : { title: input.title },
+      createdAt: timestamp,
+      updatedAt: timestamp
+    };
+    await this.#append(session.id, {
+      type: "session",
+      session
+    });
+    return { ...session };
+  }
+  async getSession(sessionId) {
+    const replay = await this.#replay(sessionId);
+    return replay.session === void 0 ? void 0 : { ...replay.session };
+  }
+  async listSessions(query = {}) {
+    const sessionIds = await this.#sessionIds();
+    const sessions = [];
+    for (const sessionId of sessionIds) {
+      const session = await this.getSession(sessionId);
+      if (session !== void 0) {
+        sessions.push(session);
+      }
+    }
+    const sortedSessions = sessions.sort(compareSessionsByRecentUpdate);
+    const selectedSessions = query.limit === void 0 ? sortedSessions : sortedSessions.slice(0, query.limit);
+    return selectedSessions.map((session) => ({ ...session }));
+  }
+  async appendMessage(input) {
+    const replay = await this.#replay(input.sessionId);
+    if (replay.session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const timestamp = this.#now();
+    const message = {
+      id: this.#createMessageId(),
+      sessionId: input.sessionId,
+      role: input.role,
+      content: input.content,
+      createdAt: timestamp,
+      ...input.toolCalls !== void 0 ? { toolCalls: input.toolCalls } : {},
+      ...input.toolCallId !== void 0 ? { toolCallId: input.toolCallId } : {}
+    };
+    await this.#append(input.sessionId, {
+      type: "message",
+      message
+    });
+    return { ...message };
+  }
+  async listMessages(sessionId, query = {}) {
+    const replay = await this.#replay(sessionId);
+    const selectedMessages = query.limit === void 0 ? replay.messages : replay.messages.slice(-query.limit);
+    return selectedMessages.map((message) => ({ ...message }));
+  }
+  async appendTraceEvent(input) {
+    const replay = await this.#replay(input.sessionId);
+    if (replay.session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const traceEvent = {
+      sessionId: input.sessionId,
+      event: input.event,
+      createdAt: this.#now()
+    };
+    await this.#append(input.sessionId, {
+      type: "trace",
+      traceEvent
+    });
+    return cloneTraceEventRecord(traceEvent);
+  }
+  async listTraceEvents(sessionId, query = {}) {
+    const replay = await this.#replay(sessionId);
+    const selectedTraceEvents = query.limit === void 0 ? replay.traceEvents : replay.traceEvents.slice(-query.limit);
+    return selectedTraceEvents.map((traceEvent) => cloneTraceEventRecord(traceEvent));
+  }
+  async appendCompactBoundary(input) {
+    const replay = await this.#replay(input.sessionId);
+    if (replay.session === void 0) {
+      throw new Error(`Unknown session "${input.sessionId}".`);
+    }
+    const timestamp = this.#now();
+    await this.#append(input.sessionId, {
+      type: "compact_boundary",
+      summary: input.summary,
+      messagesBefore: input.messagesBefore,
+      messagesAfter: input.messagesAfter,
+      createdAt: timestamp
+    });
+  }
+  async #append(sessionId, record) {
+    await mkdir3(this.#directory, { recursive: true });
+    await writeFile2(this.#filePath(sessionId), `${JSON.stringify(record)}
+`, { flag: "a" });
+  }
+  async #replay(sessionId) {
+    let content = "";
+    try {
+      content = await readFile4(this.#filePath(sessionId), "utf8");
+    } catch (error) {
+      if (isNodeError3(error) && error.code === "ENOENT") {
+        return { messages: [], traceEvents: [] };
+      }
+      throw error;
+    }
+    let messages = [];
+    const traceEvents = [];
+    let session;
+    for (const line of content.split("\n")) {
+      if (line.trim() === "") {
+        continue;
+      }
+      const record = JSON.parse(line);
+      if (record.type === "session") {
+        session = record.session;
+      } else if (record.type === "compact_boundary") {
+        messages = [];
+        if (record.summary) {
+          messages.push({
+            id: `cmpct_${record.createdAt}`,
+            sessionId: session?.id ?? "",
+            role: "system",
+            content: record.summary,
+            createdAt: record.createdAt
+          });
+        }
+        if (session && record.createdAt > session.updatedAt) {
+          session = {
+            ...session,
+            updatedAt: record.createdAt
+          };
+        }
+      } else if (record.type === "message") {
+        messages.push(record.message);
+        if (session && record.message.createdAt > session.updatedAt) {
+          session = {
+            ...session,
+            updatedAt: record.message.createdAt
+          };
+        }
+      } else {
+        traceEvents.push(record.traceEvent);
+        if (session && record.traceEvent.createdAt > session.updatedAt) {
+          session = {
+            ...session,
+            updatedAt: record.traceEvent.createdAt
+          };
+        }
+      }
+    }
+    return {
+      ...session === void 0 ? {} : { session },
+      messages,
+      traceEvents
+    };
+  }
+  #filePath(sessionId) {
+    assertSafeSessionId(sessionId);
+    return join4(this.#directory, `${sessionId}.jsonl`);
+  }
+  async #sessionIds() {
+    try {
+      const entries = await readdir2(this.#directory);
+      return entries.filter((entry) => entry.endsWith(".jsonl")).map((entry) => entry.slice(0, -".jsonl".length)).filter((sessionId) => /^[A-Za-z0-9_-]+$/.test(sessionId));
+    } catch (error) {
+      if (isNodeError3(error) && error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+  }
+};
+function assertSafeSessionId(sessionId) {
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId)) {
+    throw new Error(`Unsafe session id "${sessionId}".`);
+  }
+}
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
+}
+function compareSessionsByRecentUpdate(left, right) {
+  return right.updatedAt.localeCompare(left.updatedAt);
+}
+function cloneTraceEventRecord(traceEvent) {
+  return {
+    ...traceEvent,
+    event: structuredClone(traceEvent.event)
+  };
+}
+function randomId2(prefix) {
+  return () => `${prefix}_${crypto.randomUUID()}`;
+}
+
+// ../../packages/taskflow/dist/index.js
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { join as join5, dirname as dirname3 } from "path";
+var JsonlTaskFlowStore = class {
+  #filePath;
+  constructor(filePath) {
+    this.#filePath = filePath;
+  }
+  async #readAll() {
+    try {
+      const content = await readFile5(this.#filePath, "utf-8");
+      return content.split("\n").filter((l) => l.trim().length > 0).map((l) => JSON.parse(l));
+    } catch {
+      return [];
+    }
+  }
+  async #writeAll(records) {
+    await mkdir4(dirname3(this.#filePath), { recursive: true });
+    await writeFile3(this.#filePath, records.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf-8");
+  }
+  async create(record) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const full = { ...record, createdAt: now, updatedAt: now };
+    const all = await this.#readAll();
+    all.push(full);
+    await this.#writeAll(all);
+    return full;
+  }
+  async update(id, updates) {
+    const all = await this.#readAll();
+    const idx = all.findIndex((r) => r.id === id);
+    if (idx === -1)
+      return void 0;
+    const updated = { ...all[idx], ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    all[idx] = updated;
+    await this.#writeAll(all);
+    return updated;
+  }
+  async get(id) {
+    const all = await this.#readAll();
+    return all.find((r) => r.id === id);
+  }
+  async list(query) {
+    let records = await this.#readAll();
+    if (query?.status !== void 0)
+      records = records.filter((r) => r.status === query.status);
+    if (query?.parentId !== void 0)
+      records = records.filter((r) => r.parentId === query.parentId);
+    if (query?.limit !== void 0)
+      records = records.slice(-query.limit);
+    return records;
+  }
+};
+
+// ../../packages/skills/dist/index.js
+import { copyFile, mkdir as mkdir5, readFile as fsReadFile, readdir as readdir3, writeFile as writeFile4 } from "fs/promises";
+import { homedir } from "os";
+import { basename as basename2, join as join6 } from "path";
+var BUILTIN_SKILLS = [
+  {
+    name: "research",
+    description: "Use when investigating external information, comparing sources, or summarizing findings. Guides web search, source reading, source comparison, and citation-aware output.",
+    body: "Search for relevant sources, read and compare at least two, and summarize findings with source links. Prefer primary sources. Flag conflicting evidence.",
+    source: "built-in",
+    filePath: ""
+  },
+  {
+    name: "project-inspector",
+    description: "Use when understanding a codebase, identifying technologies, or summarizing module responsibilities. Guides project structure inspection and technology detection.",
+    body: "Read README, list top-level directories, inspect package files, and summarize each module's role. Identify entry points and dependency boundaries.",
+    source: "built-in",
+    filePath: ""
+  },
+  {
+    name: "safe-shell",
+    description: "Use when planning to run shell commands, especially destructive or irreversible ones. Guides shell command risk assessment and command purpose explanation.",
+    body: "State the purpose before running. Prefer read-only commands. Avoid rm -rf, force flags, or piped untrusted input. Confirm intent before destructive operations.",
+    source: "built-in",
+    filePath: ""
+  }
+];
+var SkillLoader = class {
+  async load(options = {}) {
+    const seen = /* @__PURE__ */ new Set();
+    const skills = [];
+    const add = (skill) => {
+      if (!seen.has(skill.name)) {
+        seen.add(skill.name);
+        skills.push(skill);
+      }
+    };
+    if (options.workspaceRoot !== void 0) {
+      const workspaceDir = join6(options.workspaceRoot, "skills");
+      for (const skill of await this.#loadFromDir(workspaceDir, "workspace", options)) {
+        add(skill);
+      }
+    }
+    const userDir = options.userSkillsDir ?? join6(homedir(), ".vole", "skills");
+    const manifest = await loadManifestFromDir(userDir, options.readFile);
+    for (const skill of await this.#loadFromDir(userDir, "user", options, manifest)) {
+      add(skill);
+    }
+    for (const skill of BUILTIN_SKILLS) {
+      add(skill);
+    }
+    return skills;
+  }
+  async #loadFromDir(dirPath, source, options, manifest) {
+    const doReadDir = options.readDir ?? ((p) => readdir3(p));
+    const doReadFile = options.readFile ?? ((p) => fsReadFile(p, "utf8"));
+    let entries;
+    try {
+      entries = await doReadDir(dirPath);
+    } catch (error) {
+      if (isNodeError4(error) && error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+    const skills = [];
+    for (const entry of entries) {
+      if (entry === "skills-index.json")
+        continue;
+      const filePath = join6(dirPath, entry, "SKILL.md");
+      if (source === "user" && manifest !== void 0) {
+        const manifestEntry = manifest.skills.find((e) => e.name === entry);
+        if (manifestEntry !== void 0 && manifestEntry.enabled === false) {
+          continue;
+        }
+      }
+      try {
+        const content = await doReadFile(filePath);
+        const parsed = parseSKILLMd(content);
+        if (parsed !== null) {
+          let trusted;
+          let enabled;
+          if (source === "user") {
+            const manifestEntry = manifest?.skills.find((e) => e.name === entry);
+            trusted = manifestEntry?.trusted ?? false;
+            enabled = manifestEntry?.enabled ?? true;
+          }
+          const def = {
+            ...parsed,
+            source,
+            filePath,
+            ...trusted !== void 0 ? { trusted } : {},
+            ...enabled !== void 0 ? { enabled } : {}
+          };
+          skills.push(def);
+        }
+      } catch {
+      }
+    }
+    return skills;
+  }
+};
+async function loadManifestFromDir(dirPath, readFileFn) {
+  const doReadFile = readFileFn ?? ((p) => fsReadFile(p, "utf8"));
+  const manifestPath = join6(dirPath, "skills-index.json");
+  try {
+    const content = await doReadFile(manifestPath);
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+var SkillManager = class {
+  #skillsDirectory;
+  constructor(skillsDirectory) {
+    this.#skillsDirectory = skillsDirectory;
+  }
+  async loadManifest() {
+    const manifestPath = join6(this.#skillsDirectory, "skills-index.json");
+    try {
+      const content = await fsReadFile(manifestPath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return { skills: [] };
+    }
+  }
+  async saveManifest(manifest) {
+    await mkdir5(this.#skillsDirectory, { recursive: true });
+    const manifestPath = join6(this.#skillsDirectory, "skills-index.json");
+    await writeFile4(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  }
+  async install(sourcePath) {
+    const fileName = basename2(sourcePath);
+    const nameWithoutExt = fileName.endsWith(".md") ? fileName.slice(0, -3) : fileName;
+    const content = await fsReadFile(sourcePath, "utf8");
+    const parsed = parseSKILLMd(content);
+    const name = parsed?.name ?? nameWithoutExt;
+    const skillDir = join6(this.#skillsDirectory, name);
+    await mkdir5(skillDir, { recursive: true });
+    const destPath = join6(skillDir, "SKILL.md");
+    await copyFile(sourcePath, destPath);
+    const manifest = await this.loadManifest();
+    const existingIndex = manifest.skills.findIndex((e) => e.name === name);
+    const entry = {
+      name,
+      filePath: destPath,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...parsed?.origin !== void 0 ? { origin: parsed.origin } : {},
+      trusted: false,
+      enabled: true
+    };
+    if (existingIndex !== -1) {
+      manifest.skills[existingIndex] = entry;
+    } else {
+      manifest.skills.push(entry);
+    }
+    await this.saveManifest(manifest);
+    return entry;
+  }
+  async enable(name) {
+    const manifest = await this.loadManifest();
+    const entry = manifest.skills.find((e) => e.name === name);
+    if (entry === void 0)
+      throw new Error(`Skill "${name}" not found in manifest.`);
+    entry.enabled = true;
+    await this.saveManifest(manifest);
+  }
+  async disable(name) {
+    const manifest = await this.loadManifest();
+    const entry = manifest.skills.find((e) => e.name === name);
+    if (entry === void 0)
+      throw new Error(`Skill "${name}" not found in manifest.`);
+    entry.enabled = false;
+    await this.saveManifest(manifest);
+  }
+  async trust(name) {
+    const manifest = await this.loadManifest();
+    const entry = manifest.skills.find((e) => e.name === name);
+    if (entry === void 0)
+      throw new Error(`Skill "${name}" not found in manifest.`);
+    entry.trusted = true;
+    await this.saveManifest(manifest);
+  }
+  async review(name) {
+    const manifest = await this.loadManifest();
+    const entry = manifest.skills.find((e) => e.name === name);
+    if (entry === void 0)
+      return void 0;
+    try {
+      const content = await fsReadFile(entry.filePath, "utf8");
+      const parsed = parseSKILLMd(content);
+      if (parsed === null)
+        return void 0;
+      return {
+        ...parsed,
+        source: "user",
+        filePath: entry.filePath,
+        trusted: entry.trusted,
+        enabled: entry.enabled
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  async listEntries() {
+    const manifest = await this.loadManifest();
+    return manifest.skills;
+  }
+};
+function parseSKILLMd(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---")
+    return null;
+  const closingIndex = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+  if (closingIndex === -1)
+    return null;
+  const frontmatterLines = lines.slice(1, closingIndex);
+  const body = lines.slice(closingIndex + 1).join("\n").trim();
+  const fields = {};
+  const arrayFields = {};
+  let currentArrayKey = null;
+  for (const line of frontmatterLines) {
+    const arrayItemMatch = /^\s+-\s+(.+)$/.exec(line);
+    if (arrayItemMatch !== null && currentArrayKey !== null) {
+      const value = arrayItemMatch[1]?.trim() ?? "";
+      if (value.length > 0) {
+        arrayFields[currentArrayKey] = [...arrayFields[currentArrayKey] ?? [], value];
+      }
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      currentArrayKey = null;
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const rawValue = line.slice(colonIndex + 1).trim();
+    if (key.length === 0) {
+      currentArrayKey = null;
+      continue;
+    }
+    if (rawValue === "") {
+      currentArrayKey = key;
+    } else {
+      currentArrayKey = null;
+      fields[key] = rawValue;
+    }
+  }
+  const { name, description, version, origin, permissions: permissionsStr } = fields;
+  if (!name || !description)
+    return null;
+  let permissions;
+  if (permissionsStr !== void 0 && permissionsStr.length > 0) {
+    permissions = permissionsStr.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  } else if (arrayFields["permissions"] !== void 0) {
+    permissions = arrayFields["permissions"];
+  }
+  return {
+    name,
+    description,
+    body,
+    ...version !== void 0 ? { version } : {},
+    ...origin !== void 0 ? { origin } : {},
+    ...permissions !== void 0 ? { permissions } : {}
+  };
+}
+function toSkillSummary(skill) {
+  return { name: skill.name, description: skill.description, source: skill.source };
+}
+function isNodeError4(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/index.ts
+var cliPackageName = "@vole/cli";
+var AGENT_SYSTEM_INSTRUCTION = `You are Vole, a capable coding and general-purpose agent.
+
+## Tool Call Style
+Do not narrate routine, low-risk tool calls \u2014 just call the tool.
+Narrate only when it genuinely helps: multi-step work, sensitive actions, or when explaining a non-obvious choice.
+Keep narration brief; avoid restating what tool output already shows.
+
+## Execution Bias
+- Actionable request: act in this turn, do not describe what you plan to do.
+- Non-final turn: use tools to advance, or ask for the one decision that blocks safe progress.
+- Continue until done or genuinely blocked; do not end with a plan or promise when tools can move work forward.
+- Weak or empty tool result: vary the query, path, command, or source before concluding.
+- Mutable facts require live checks: files, git state, versions, running processes, package state.
+- Final answer requires evidence: test output, lint result, file inspection, or a named concrete blocker.
+- Longer work: brief progress note, then keep going.
+
+## File Editing
+- Modify existing code: edit_file (precise string replacement, preserves surrounding content).
+- Add to end of file: append_file.
+- Create new files or intentional full replacement: write_file.`;
+var cliGateway = new SessionGateway();
+async function runCli(args, packageVersion, options = {}) {
+  let capturedOut = "";
+  let actionResult = null;
+  const program = new Command().name("vole").description("A capable coding and general-purpose agent.").version(packageVersion, "-v, --version", "Show version number").exitOverride().configureOutput({
+    writeOut: (str) => {
+      capturedOut += str;
+    },
+    writeErr: (str) => {
+      capturedOut += str;
+    }
+  }).addHelpText("after", "\nRun `vole <command> --help` for command-specific options.");
+  program.command("chat").description("Start an interactive chat session").argument("[extra...]", "Slash commands to run after a --fake turn").option("-s, --session <id>", "Continue a named session").option("-r, --resume", "Continue the most recently updated session").option("--fake <message>", "Run one turn with a fake provider and exit").option("--fake-interactive", "Interactive chat with a fake provider").action(async (extra, opts) => {
+    const slashCmds = extra.filter((a) => a.startsWith("/"));
+    if (opts["fake"] !== void 0) {
+      actionResult = await runFakeChatTurn({ message: opts["fake"], slashCommands: slashCmds }, options);
+      return;
+    }
+    if (opts["fakeInteractive"]) {
+      const sid2 = typeof opts["session"] === "string" ? opts["session"] : void 0;
+      actionResult = await runInteractiveFakeChat(options, {
+        fakeInteractive: true,
+        resume: false,
+        ...sid2 !== void 0 ? { sessionId: sid2 } : {}
+      });
+      return;
+    }
+    const sid = typeof opts["session"] === "string" ? opts["session"] : void 0;
+    actionResult = await runInteractiveConfiguredChat(options, {
+      fakeInteractive: false,
+      resume: opts["resume"] === true,
+      ...sid !== void 0 ? { sessionId: sid } : {}
+    });
+  });
+  program.command("sessions").description("List stored chat sessions").action(async () => {
+    actionResult = await runListSessions(options);
+  });
+  program.command("run").description('Run a one-shot background task  e.g. vole run "fix the tests"').argument("[goal]", "Goal for the task").option("--mode <mode>", "Autonomy mode: auto | confirm | observe", "confirm").option("--dream", "Consolidate daily memory notes into MEMORY.md").action(async (goal, opts) => {
+    if (opts["dream"]) {
+      actionResult = await runMemoryDreaming(options);
+      return;
+    }
+    const g = (goal ?? "").trim();
+    if (g === "") {
+      actionResult = { exitCode: 1, stdout: "", stderr: 'Missing goal. Usage: vole run "<goal>"\n' };
+      return;
+    }
+    const raw = opts["mode"];
+    const mode = raw === "auto" ? "auto" : raw === "observe" ? "observe" : "confirm";
+    actionResult = await runBackgroundTask(g, mode, options);
+  });
+  program.command("tasks").description("List recent background task runs").option("-n, --limit <n>", "Number of runs to show", (v) => parseInt(v, 10)).action(async (opts) => {
+    actionResult = await runListTasks(options, opts["limit"]);
+  });
+  const skillsCmd = program.command("skills").description("Manage agent skills");
+  skillsCmd.action(async () => {
+    actionResult = await runSkillsList(options);
+  });
+  skillsCmd.command("install <path>").description("Install a skill from a local .md file").action(async (p) => {
+    actionResult = await runSkillsInstall(p, options);
+  });
+  skillsCmd.command("enable <name>").description("Enable a disabled skill").action(async (n) => {
+    actionResult = await runSkillsLifecycle("enable", n, options);
+  });
+  skillsCmd.command("disable <name>").description("Disable a skill").action(async (n) => {
+    actionResult = await runSkillsLifecycle("disable", n, options);
+  });
+  skillsCmd.command("trust <name>").description("Mark an installed skill as trusted").action(async (n) => {
+    actionResult = await runSkillsLifecycle("trust", n, options);
+  });
+  skillsCmd.command("review <name>").description("Show full skill metadata and permissions").action(async (n) => {
+    actionResult = await runSkillsReview(n, options);
+  });
+  program.command("daemon").description("Start the task scheduler daemon").option("--once", "Run all due tasks once and exit").action(async (opts) => {
+    actionResult = await runDaemon(options, opts["once"] === true);
+  });
+  program.command("web").description("Start the Vole web dashboard").option("-p, --port <port>", "Port to listen on", "3120").option("--no-open", "Don't open the browser automatically").action(async (opts) => {
+    const port = parseInt(opts["port"], 10) || 3120;
+    const openBrowser = opts["open"] !== false;
+    actionResult = await runWebDashboard(port, openBrowser);
+  });
+  const tfCmd = program.command("taskflow").description("Inspect cross-session task records");
+  tfCmd.action(async () => {
+    actionResult = await runTaskflowList(options, void 0);
+  });
+  tfCmd.command("list").description("List recent task records").option("-n, --limit <n>", "Number of records to show", (v) => parseInt(v, 10)).action(async (opts) => {
+    actionResult = await runTaskflowList(options, opts["limit"]);
+  });
+  tfCmd.command("show <id>").description("Show details of a task").action(async (id) => {
+    actionResult = await runTaskflowShow(id, options);
+  });
+  tfCmd.command("cancel <id>").description("Mark a task as cancelled").action(async (id) => {
+    actionResult = await runTaskflowCancel(id, options);
+  });
+  try {
+    const commanderArgs = args[0] === "--" ? args.slice(1) : args;
+    await program.parseAsync(commanderArgs, { from: "user" });
+  } catch (err) {
+    if (err instanceof Error && "code" in err) {
+      const code = err.code;
+      if (code === "commander.helpDisplayed" || code === "commander.version") {
+        return { exitCode: 0, stdout: capturedOut, stderr: "" };
+      }
+      if (code === "commander.unknownCommand") {
+        const match = err.message.match(/unknown command '(.+)'/);
+        const cmdName = match ? match[1] : args[0] ?? "unknown";
+        return { exitCode: 1, stdout: program.helpInformation(), stderr: `Unknown command "${cmdName}".
+` };
+      }
+      return { exitCode: err.exitCode ?? 1, stdout: capturedOut, stderr: `${err.message}
+` };
+    }
+    throw err;
+  }
+  return actionResult ?? { exitCode: 0, stdout: capturedOut, stderr: "" };
+}
+async function runFakeChatTurn(input, options) {
+  const { message, slashCommands } = input;
+  if (message.trim() === "") {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Missing message for `chat --fake`.\n"
+    };
+  }
+  const session = CliChatSession.createFake(`Fake response to: ${message}`, options);
+  const turn = await session.sendMessage(message);
+  const commandOutput = await renderSlashCommands(session, slashCommands);
+  const assistantText = turn.assistantText;
+  const events = turn.events;
+  const traceLines = renderCompactTrace(events).join("\n");
+  return {
+    exitCode: events.some((event) => event.type === "run_failed") ? 1 : 0,
+    stdout: `Assistant: ${assistantText}
+
+Trace:
+${traceLines}
+${commandOutput}`,
+    stderr: ""
+  };
+}
+async function runInteractiveFakeChat(options, args) {
+  const session = CliChatSession.createFake((message) => `Fake response to: ${message}`, options, {
+    ...args.sessionId === void 0 ? {} : { sessionId: args.sessionId }
+  });
+  return runInteractiveLoop(session, "Vole chat (fake provider)", options);
+}
+async function runInteractiveConfiguredChat(options, args) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  if (config.secrets.apiKey === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Missing VOLE_API_KEY or OPENROUTER_API_KEY. Set one to start `vole chat`, or use `vole chat --fake-interactive` for local learning.\n"
+    };
+  }
+  if (args.resume && args.sessionId !== void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Use either `chat --resume` or `chat --session <id>`, not both.\n"
+    };
+  }
+  const resumedSessionId = args.resume ? await findMostRecentSessionId(config, options) : void 0;
+  if (args.resume && resumedSessionId === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "No stored sessions to resume. Start one with `vole chat` or `vole chat --session <id>`.\n"
+    };
+  }
+  const sessionId = args.sessionId ?? resumedSessionId;
+  return runInteractiveLoop(
+    await CliChatSession.createConfigured(config, options, {
+      ...sessionId === void 0 ? {} : { sessionId }
+    }),
+    resumedSessionId === void 0 ? "Vole chat" : `Vole chat
+Resumed session: ${resumedSessionId}`,
+    options
+  );
+}
+async function runListSessions(options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const store = createConfiguredSessionStore(config, options, createSessionId());
+  const sessions = await store.listSessions();
+  if (sessions.length === 0) {
+    return {
+      exitCode: 0,
+      stdout: "Sessions:\nNo sessions found.\n",
+      stderr: ""
+    };
+  }
+  return {
+    exitCode: 0,
+    stdout: ["Sessions:", ...sessions.map((session) => `${session.id}	${session.updatedAt}${session.title ? `	${session.title}` : ""}`)].join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function runMemoryDreaming(options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  if (config.secrets.apiKey === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Missing VOLE_API_KEY or OPENROUTER_API_KEY. Set one to run memory dreaming.\n"
+    };
+  }
+  if (config.memory.longTermFiles !== "write") {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Memory dreaming requires VOLE_LONG_TERM_MEMORY=write\n"
+    };
+  }
+  const dreamGoal = `You are a memory consolidation agent.
+Review the recent daily memory files and the current MEMORY.md in the workspace.
+Identify key facts, decisions, and patterns worth preserving long-term.
+Append a consolidation summary to MEMORY.md using the write_file tool.
+Be concise and factual. Do not duplicate what is already in MEMORY.md.`;
+  return runBackgroundTask(dreamGoal, "auto", options);
+}
+async function runBackgroundTask(goal, mode, options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  if (config.secrets.apiKey === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Missing VOLE_API_KEY or OPENROUTER_API_KEY. Set one to run background tasks.\n"
+    };
+  }
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const sessionsDir = resolveSessionsDirectory(effectiveConfig, options.env);
+  const sessionId = createSessionId();
+  const taskRunId = `task_${crypto.randomUUID()}`;
+  const taskName = goal.slice(0, 40).replace(/\s+/g, "-").replace(/[^A-Za-z0-9-]/g, "").toLowerCase() || "task";
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionStore = new JsonlSessionStore({
+    directory: sessionsDir,
+    createSessionId: () => sessionId
+  });
+  const taskStore = new JsonlTaskStore(join7(sessionsDir, "task-runs.jsonl"));
+  const initialRecord = {
+    id: taskRunId,
+    taskName,
+    goal,
+    sessionId,
+    startedAt,
+    status: "running",
+    assistantText: ""
+  };
+  await taskStore.saveRun(initialRecord);
+  const configuredProvider = createConfiguredProvider(config, options);
+  const approvalResolver = new BackgroundApprovalResolver(mode);
+  const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const backgroundTools = (() => {
+    const allTools = createCliBuiltInTools(options, config);
+    return config.runtime.toolProfile !== void 0 ? filterToolsByProfile(allTools, config.runtime.toolProfile) : allTools;
+  })();
+  const runtime = new AgentRuntime({
+    contextAssembler: createCliContextAssembler(config, currentDate),
+    modelProvider: configuredProvider,
+    systemInstruction: AGENT_SYSTEM_INSTRUCTION,
+    runtime: {
+      mode,
+      workspace: config.workspace.root,
+      currentDate
+    },
+    tools: backgroundTools,
+    preferStreaming: false,
+    approvalResolver,
+    maxSteps: 20,
+    ...config.runtime.promptMode !== void 0 ? { promptMode: config.runtime.promptMode } : {}
+  });
+  const events = [];
+  await sessionStore.createSession({ title: `task: ${goal.slice(0, 60)}` });
+  for await (const event of runtime.runTurn({ sessionId, message: goal })) {
+    await sessionStore.appendTraceEvent({ sessionId, event });
+    events.push(event);
+  }
+  const traceLines = renderCompactTrace(events);
+  const assistantMessageEvent = events.find((e) => e.type === "assistant_message_created");
+  const assistantText = assistantMessageEvent?.type === "assistant_message_created" ? assistantMessageEvent.message.content : "No assistant message was produced.";
+  const failedEvent = events.find((e) => e.type === "run_failed");
+  const status = failedEvent ? "failed" : "completed";
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const updates = {
+    status,
+    assistantText,
+    completedAt,
+    ...failedEvent?.type === "run_failed" ? { errorMessage: failedEvent.error.message } : {}
+  };
+  await taskStore.updateRun(taskRunId, updates);
+  const traceOutput = traceLines.join("\n");
+  const resultLine = status === "completed" ? `Done: ${assistantText}` : `Failed: ${failedEvent?.type === "run_failed" ? failedEvent.error.message : "Unknown error"}`;
+  return {
+    exitCode: status === "completed" ? 0 : 1,
+    stdout: `Trace:
+${traceOutput}
+
+${resultLine}
+`,
+    stderr: ""
+  };
+}
+async function runListTasks(options, limit) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const sessionsDir = resolveSessionsDirectory(effectiveConfig, options.env);
+  const taskStore = new JsonlTaskStore(join7(sessionsDir, "task-runs.jsonl"));
+  const runs = await taskStore.listRuns(limit !== void 0 ? { limit } : {});
+  if (runs.length === 0) {
+    return {
+      exitCode: 0,
+      stdout: "No task runs found.\n",
+      stderr: ""
+    };
+  }
+  const lines = runs.map((run) => {
+    const idSuffix = run.id.slice(-8);
+    return `${idSuffix}  ${run.taskName}  ${run.status}  ${run.startedAt}`;
+  });
+  return {
+    exitCode: 0,
+    stdout: lines.join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function loadTaskDefinitions(tasksDir) {
+  try {
+    await stat(tasksDir);
+  } catch {
+    return null;
+  }
+  const entries = await readdir4(tasksDir);
+  const taskFiles = entries.filter((e) => e.endsWith(".task.json"));
+  const tasks = [];
+  for (const file of taskFiles) {
+    const content = await readFile6(join7(tasksDir, file), "utf8");
+    tasks.push(JSON.parse(content));
+  }
+  return tasks;
+}
+async function runDaemonTask(task, config, options, taskStore) {
+  const runId = `run_${crypto.randomUUID()}`;
+  const sessionId = createSessionId();
+  const mode = task.mode ?? "auto";
+  const record = {
+    id: runId,
+    taskName: task.name,
+    goal: task.goal,
+    sessionId,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "running",
+    assistantText: ""
+  };
+  await taskStore.saveRun(record);
+  const heartbeatPath = join7(config.workspace.root, "HEARTBEAT.md");
+  const startHeartbeat = {
+    status: "running",
+    taskName: task.name,
+    runId,
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeHeartbeat(heartbeatPath, startHeartbeat);
+  const provider = options.fakeModelOutputs ? new FakeModelProvider(options.fakeModelOutputs) : createConfiguredProvider(config, options);
+  const approvalResolver = new BackgroundApprovalResolver(mode);
+  const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const backgroundTools = (() => {
+    const allTools = createCliBuiltInTools(options, config);
+    return config.runtime.toolProfile !== void 0 ? filterToolsByProfile(allTools, config.runtime.toolProfile) : allTools;
+  })();
+  const runtime = new AgentRuntime({
+    contextAssembler: createCliContextAssembler(config, currentDate),
+    modelProvider: provider,
+    systemInstruction: AGENT_SYSTEM_INSTRUCTION,
+    runtime: {
+      mode,
+      workspace: config.workspace.root,
+      currentDate
+    },
+    tools: backgroundTools,
+    preferStreaming: false,
+    approvalResolver,
+    ...task.maxSteps !== void 0 ? { maxSteps: task.maxSteps } : {},
+    ...config.runtime.promptMode !== void 0 ? { promptMode: config.runtime.promptMode } : {}
+  });
+  const events = [];
+  for await (const event of runtime.runTurn({ sessionId, message: task.goal })) {
+    events.push(event);
+  }
+  const assistantMessageEvent = events.find((e) => e.type === "assistant_message_created");
+  const assistantText = assistantMessageEvent?.type === "assistant_message_created" ? assistantMessageEvent.message.content : "No assistant message was produced.";
+  const failedEvent = events.find((e) => e.type === "run_failed");
+  const status = failedEvent ? "failed" : "completed";
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const updates = {
+    status,
+    assistantText,
+    completedAt,
+    ...failedEvent?.type === "run_failed" ? { errorMessage: failedEvent.error.message } : {}
+  };
+  await taskStore.updateRun(runId, updates);
+  const endHeartbeat = {
+    status,
+    taskName: task.name,
+    runId,
+    lastUpdatedAt: completedAt,
+    ...failedEvent?.type === "run_failed" ? { message: `Error: ${failedEvent.error.message}` } : {}
+  };
+  await writeHeartbeat(heartbeatPath, endHeartbeat);
+}
+async function runDaemon(options, once) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  if (config.secrets.apiKey === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: "Missing VOLE_API_KEY or OPENROUTER_API_KEY. Set one to run the daemon.\n"
+    };
+  }
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const sessionsDir = resolveSessionsDirectory(effectiveConfig, options.env);
+  const tasksDir = join7(dirname4(sessionsDir), "tasks");
+  const taskStore = new JsonlTaskStore(join7(sessionsDir, "task-runs.jsonl"));
+  const tasks = await loadTaskDefinitions(tasksDir);
+  if (tasks === null) {
+    return {
+      exitCode: 0,
+      stdout: `No tasks directory found at ${tasksDir}.
+`,
+      stderr: ""
+    };
+  }
+  const cronTasks = tasks.filter((t) => t.cron !== void 0);
+  if (once) {
+    const now = /* @__PURE__ */ new Date();
+    const output = [];
+    for (const task of cronTasks) {
+      output.push(`Running: ${task.name}`);
+      await runDaemonTask(task, config, options, taskStore);
+    }
+    output.push("Done.");
+    return {
+      exitCode: 0,
+      stdout: output.join("\n") + "\n",
+      stderr: ""
+    };
+  }
+  const runner = async (task) => {
+    await runDaemonTask(task, config, options, taskStore);
+  };
+  const scheduler = new CronScheduler(cronTasks, runner);
+  scheduler.start();
+  return new Promise((resolve2) => {
+    const shutdown = () => {
+      scheduler.stop();
+      resolve2({
+        exitCode: 0,
+        stdout: "Daemon stopped.\n",
+        stderr: ""
+      });
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+  });
+}
+function resolveTaskflowFilePath(options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const sessionsDir = resolveSessionsDirectory(effectiveConfig, options.env);
+  return join7(dirname4(sessionsDir), "taskflow.jsonl");
+}
+async function runTaskflowList(options, limit) {
+  const filePath = resolveTaskflowFilePath(options);
+  const store = new JsonlTaskFlowStore(filePath);
+  const records = await store.list(limit !== void 0 ? { limit } : {});
+  if (records.length === 0) {
+    return {
+      exitCode: 0,
+      stdout: "No task records found.\n",
+      stderr: ""
+    };
+  }
+  const lines = records.map((r) => {
+    const idSuffix = r.id.slice(-8);
+    return `${idSuffix}  ${r.status}  ${r.runtime}  ${r.createdAt}  ${r.task.slice(0, 60)}`;
+  });
+  return {
+    exitCode: 0,
+    stdout: ["Task records:", ...lines].join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function runTaskflowShow(id, options) {
+  const filePath = resolveTaskflowFilePath(options);
+  const store = new JsonlTaskFlowStore(filePath);
+  const record = await store.get(id);
+  if (record === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Task "${id}" not found.
+`
+    };
+  }
+  const lines = [
+    `ID:               ${record.id}`,
+    `Runtime:          ${record.runtime}`,
+    `Status:           ${record.status}`,
+    `Task:             ${record.task}`,
+    `Created:          ${record.createdAt}`,
+    `Updated:          ${record.updatedAt}`,
+    ...record.parentId !== void 0 ? [`Parent:           ${record.parentId}`] : [],
+    ...record.sessionId !== void 0 ? [`Session:          ${record.sessionId}`] : [],
+    ...record.progressSummary !== void 0 ? [`Progress:         ${record.progressSummary}`] : [],
+    ...record.terminalSummary !== void 0 ? [`Terminal summary: ${record.terminalSummary}`] : []
+  ];
+  return {
+    exitCode: 0,
+    stdout: lines.join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function runTaskflowCancel(id, options) {
+  const filePath = resolveTaskflowFilePath(options);
+  const store = new JsonlTaskFlowStore(filePath);
+  const updated = await store.update(id, { status: "cancelled" });
+  if (updated === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Task "${id}" not found.
+`
+    };
+  }
+  return {
+    exitCode: 0,
+    stdout: `Cancelled: ${id}
+`,
+    stderr: ""
+  };
+}
+function resolveSkillsDirectory(config, options) {
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const sessionsDir = resolveSessionsDirectory(effectiveConfig, options.env);
+  return join7(dirname4(sessionsDir), "skills");
+}
+async function runSkillsList(options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const skillsDir = resolveSkillsDirectory(config, options);
+  const loader = new SkillLoader();
+  const skills = await loader.load({
+    workspaceRoot: config.workspace.root,
+    userSkillsDir: skillsDir
+  });
+  const lines = renderSkillIndex(skills);
+  return {
+    exitCode: 0,
+    stdout: ["Skills:", ...lines].join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function runSkillsInstall(sourcePath, options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const skillsDir = resolveSkillsDirectory(config, options);
+  const manager = new SkillManager(skillsDir);
+  try {
+    const entry = await manager.install(sourcePath);
+    return {
+      exitCode: 0,
+      stdout: `Installed: ${entry.name}
+`,
+      stderr: ""
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Failed to install skill: ${error instanceof Error ? error.message : String(error)}
+`
+    };
+  }
+}
+async function runSkillsLifecycle(action, name, options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const skillsDir = resolveSkillsDirectory(config, options);
+  const manager = new SkillManager(skillsDir);
+  try {
+    if (action === "enable") {
+      await manager.enable(name);
+      return { exitCode: 0, stdout: `Enabled: ${name}
+`, stderr: "" };
+    } else if (action === "disable") {
+      await manager.disable(name);
+      return { exitCode: 0, stdout: `Disabled: ${name}
+`, stderr: "" };
+    } else {
+      await manager.trust(name);
+      return { exitCode: 0, stdout: `Trusted: ${name}
+`, stderr: "" };
+    }
+  } catch (error) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Failed to ${action} skill: ${error instanceof Error ? error.message : String(error)}
+`
+    };
+  }
+}
+async function runSkillsReview(name, options) {
+  const config = loadConfig(options.env ? { env: options.env } : {});
+  const skillsDir = resolveSkillsDirectory(config, options);
+  const manager = new SkillManager(skillsDir);
+  const def = await manager.review(name);
+  if (def === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Skill "${name}" not found.
+`
+    };
+  }
+  const entries = await manager.listEntries();
+  const entry = entries.find((e) => e.name === name);
+  const lines = [
+    `Name:         ${def.name}`,
+    `Source:       ${def.source}`,
+    ...def.version !== void 0 ? [`Version:      ${def.version}`] : [],
+    ...def.origin !== void 0 ? [`Origin:       ${def.origin}`] : [],
+    `Permissions:  ${def.permissions !== void 0 && def.permissions.length > 0 ? def.permissions.join(", ") : "(none)"}`,
+    `Trusted:      ${String(def.trusted ?? false)}`,
+    `Enabled:      ${String(def.enabled ?? true)}`,
+    ...entry?.installedAt !== void 0 ? [`Installed:    ${entry.installedAt}`] : [],
+    "",
+    "--- Body ---",
+    def.body
+  ];
+  return {
+    exitCode: 0,
+    stdout: lines.join("\n") + "\n",
+    stderr: ""
+  };
+}
+async function findMostRecentSessionId(config, options) {
+  const store = createConfiguredSessionStore(config, options, createSessionId());
+  const [session] = await store.listSessions({ limit: 1 });
+  return session?.id;
+}
+async function runInteractiveLoop(session, title, options) {
+  const output = [];
+  const emit = (...lines) => {
+    if (options.write) {
+      options.write(`${lines.join("\n")}
+`);
+    } else {
+      output.push(...lines);
+    }
+  };
+  emit(title, "Type /help for commands or /exit to leave.", "");
+  while (true) {
+    const line = await options.readLine?.("> ");
+    if (line === void 0) {
+      break;
+    }
+    const message = line.trim();
+    if (message === "") {
+      continue;
+    }
+    if (message === "/exit") {
+      emit("Goodbye.");
+      break;
+    }
+    if (message === "/help") {
+      emit(...renderInteractiveHelp(), "");
+      continue;
+    }
+    if (message === "/clear") {
+      emit("(conversation display cleared)", "");
+      continue;
+    }
+    if (message.startsWith("/")) {
+      emit(...renderInteractiveSlashCommand(message, await session.runSlashCommand(message)), "");
+      continue;
+    }
+    const turn = await session.sendMessage(message);
+    if (turn.todosLines.length > 0) {
+      emit(...turn.todosLines, "");
+    }
+    if (turn.approvalLines.length > 0) {
+      emit(...turn.approvalLines, "");
+    }
+    emit(`Assistant: ${turn.assistantText}`, "");
+  }
+  return {
+    exitCode: 0,
+    stdout: options.write ? "" : `${output.join("\n")}
+`,
+    stderr: ""
+  };
+}
+var SLASH_COMMAND_LABELS = {
+  "/trace": "Recent Trace:",
+  "/config": "Config:",
+  "/skills": "Skills:",
+  "/help": "Commands:"
+};
+async function renderSlashCommands(session, slashCommands) {
+  const rendered = [];
+  for (const command of slashCommands) {
+    const label = SLASH_COMMAND_LABELS[command];
+    if (label !== void 0) {
+      rendered.push(["", label, ...await session.runSlashCommand(command)].join("\n"));
+    } else {
+      rendered.push(["", `Unknown slash command: ${command}`].join("\n"));
+    }
+  }
+  return rendered.length === 0 ? "" : `${rendered.join("\n")}
+`;
+}
+function renderInteractiveSlashCommand(command, lines) {
+  if (lines[0]?.startsWith("Unknown slash command")) {
+    return lines;
+  }
+  const label = SLASH_COMMAND_LABELS[command];
+  return label !== void 0 ? [label, ...lines] : lines;
+}
+function renderInteractiveHelp() {
+  return [
+    "Commands:",
+    "/help    Show commands",
+    "/trace   Show recent trace events",
+    "/config  Show redacted configuration",
+    "/skills  List loaded skills",
+    "/clear   Clear conversation display",
+    "/exit    Leave chat"
+  ];
+}
+var CliChatSession = class _CliChatSession {
+  #runtime;
+  #traceStore;
+  #sessionStore;
+  #sessionId;
+  #config;
+  #approvalPromptLog;
+  #skillDefinitions;
+  #gateway;
+  constructor(runtime, config = redactedConfig(loadConfig()), traceStore = new InMemoryRuntimeTraceStore(), sessionId = createSessionId(), sessionStore = new InMemorySessionStore({ createSessionId: () => sessionId }), _recentMessageLimit = 12, approvalPromptLog = [], skillDefinitions = [], gateway) {
+    this.#runtime = runtime;
+    this.#config = config;
+    this.#traceStore = traceStore;
+    this.#sessionStore = sessionStore;
+    this.#sessionId = sessionId;
+    this.#approvalPromptLog = approvalPromptLog;
+    this.#skillDefinitions = skillDefinitions;
+    this.#gateway = gateway;
+  }
+  get sessionId() {
+    return this.#sessionId;
+  }
+  async listSessions(query) {
+    return this.#sessionStore.listSessions(query);
+  }
+  async loadMessages() {
+    return this.#sessionStore.listMessages(this.#sessionId);
+  }
+  close() {
+    this.#gateway?.unregister(this.#sessionId);
+  }
+  static createFake(responseContent = "Fake response to: Hello trace", options = {}, sessionOptions = {}) {
+    const config = redactedConfig(loadConfig(options.env ? { env: options.env } : {}));
+    const approvalPromptLog = [];
+    const provider = options.fakeModelOutputs ? new FakeModelProvider(options.fakeModelOutputs) : typeof responseContent === "function" ? new MessageMappedFakeModelProvider(responseContent) : new FakeModelProvider([
+      {
+        type: "message",
+        content: responseContent
+      }
+    ]);
+    return new _CliChatSession(
+      new AgentRuntime({
+        contextAssembler: createCliContextAssembler(config, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)),
+        modelProvider: provider,
+        systemInstruction: AGENT_SYSTEM_INSTRUCTION,
+        runtime: {
+          mode: "confirm",
+          workspace: config.workspace.root,
+          currentDate: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+        },
+        tools: createCliBuiltInTools(options, config),
+        approvalResolver: createCliApprovalResolver(options, approvalPromptLog),
+        maxSteps: 20,
+        compaction: {}
+      }),
+      config,
+      new InMemoryRuntimeTraceStore(),
+      sessionOptions.sessionId ?? createSessionId(),
+      void 0,
+      12,
+      approvalPromptLog
+    );
+  }
+  static async createConfigured(config, options = {}, sessionOptions = {}) {
+    if (config.secrets.apiKey === void 0) {
+      throw new Error("Configured chat requires an API key.");
+    }
+    const sessionId = sessionOptions.sessionId ?? createSessionId();
+    const currentDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const approvalPromptLog = [];
+    const skillDefinitions = await new SkillLoader().load({ workspaceRoot: config.workspace.root });
+    const skillIndex = skillDefinitions.map(toSkillSummary);
+    const skillFileMap = new Map(skillDefinitions.map((s) => [s.name, s.filePath]));
+    const configuredProvider = createConfiguredProvider(config, options);
+    const approvalResolver = sessionOptions.approvalResolver ?? createCliApprovalResolver(options, approvalPromptLog);
+    const builtInTools = createCliBuiltInTools(options, config, skillFileMap);
+    const factory = {
+      create: (goal) => new AgentRuntime({
+        contextAssembler: createCliContextAssembler(redactedConfig(config), currentDate),
+        modelProvider: configuredProvider,
+        systemInstruction: `You are Vole, a sub-agent handling: ${goal}`,
+        runtime: { mode: config.runtime.defaultMode, workspace: config.workspace.root, currentDate },
+        tools: createCliBuiltInTools(options, config),
+        maxSteps: 8
+      })
+    };
+    const taskflowPath = join7(dirname4(resolveSessionsDirectory(config, options.env)), "taskflow.jsonl");
+    const taskFlowStore = new JsonlTaskFlowStore(taskflowPath);
+    const allToolsRaw = [
+      ...builtInTools,
+      createSpawnSubagentTool(factory),
+      createSpawnSubagentAsyncTool(factory, { taskStore: taskFlowStore }),
+      createCheckSubagentTool(taskFlowStore)
+    ];
+    const allTools = config.runtime.toolProfile !== void 0 ? filterToolsByProfile(allToolsRaw, config.runtime.toolProfile) : allToolsRaw;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const gatewaySession = {
+      id: sessionId,
+      adapterName: "cli",
+      capabilities: CLI_CAPABILITIES,
+      registeredAt: now,
+      lastActivityAt: now
+    };
+    cliGateway.register(gatewaySession);
+    return new _CliChatSession(
+      new AgentRuntime({
+        contextAssembler: createCliContextAssembler(config, currentDate),
+        modelProvider: configuredProvider,
+        systemInstruction: AGENT_SYSTEM_INSTRUCTION,
+        runtime: {
+          mode: config.runtime.defaultMode,
+          workspace: config.workspace.root,
+          currentDate
+        },
+        tools: allTools,
+        skillIndex,
+        preferStreaming: sessionOptions.preferStreaming ?? false,
+        approvalResolver,
+        maxSteps: 20,
+        compaction: {},
+        ...config.runtime.promptMode !== void 0 ? { promptMode: config.runtime.promptMode } : {},
+        ...config.runtime.executionContract !== void 0 ? { executionContract: config.runtime.executionContract } : {}
+      }),
+      redactedConfig(config),
+      new InMemoryRuntimeTraceStore(),
+      sessionId,
+      createConfiguredSessionStore(config, options, sessionId),
+      12,
+      approvalPromptLog,
+      skillDefinitions,
+      cliGateway
+    );
+  }
+  async sendMessage(message, opts = {}) {
+    const events = [];
+    const approvalStartIndex = this.#approvalPromptLog.length;
+    await this.#ensureSession();
+    const recentMessages = (await this.#sessionStore.listMessages(this.#sessionId)).map(
+      (sessionMessage) => ({
+        role: sessionMessage.role,
+        content: sessionMessage.content,
+        ...sessionMessage.toolCalls !== void 0 ? { toolCalls: sessionMessage.toolCalls } : {},
+        ...sessionMessage.toolCallId !== void 0 ? { toolCallId: sessionMessage.toolCallId } : {}
+      })
+    );
+    for await (const event of this.#runtime.runTurn({ sessionId: this.#sessionId, recentMessages, message, ...opts.signal !== void 0 ? { signal: opts.signal } : {} })) {
+      await this.#traceStore.append(event);
+      await this.#sessionStore.appendTraceEvent({ sessionId: this.#sessionId, event });
+      events.push(event);
+      opts.onEvent?.(event);
+      if (event.type === "compaction_triggered" && event.summary) {
+        await this.#sessionStore.appendCompactBoundary({
+          sessionId: this.#sessionId,
+          summary: event.summary,
+          messagesBefore: event.messagesBefore,
+          messagesAfter: event.messagesAfter
+        });
+      }
+      if (event.type === "turn_complete") {
+        for (const msg of event.messages) {
+          await this.#sessionStore.appendMessage({
+            sessionId: this.#sessionId,
+            role: msg.role,
+            content: msg.content ?? null,
+            ...msg.toolCalls !== void 0 ? { toolCalls: msg.toolCalls } : {},
+            ...msg.toolCallId !== void 0 ? { toolCallId: msg.toolCallId } : {}
+          });
+        }
+      }
+    }
+    const assistantMessage = events.find((event) => event.type === "assistant_message_created");
+    const assistantText = assistantMessage?.type === "assistant_message_created" ? assistantMessage.message.content : "No assistant message was produced.";
+    return {
+      assistantText,
+      approvalLines: this.#approvalPromptLog.slice(approvalStartIndex),
+      todosLines: renderTodosProgress(events),
+      events
+    };
+  }
+  async runSlashCommand(command) {
+    if (command === "/trace") {
+      const traceEvents = await this.#sessionStore.listTraceEvents(this.#sessionId);
+      return renderCompactTrace(traceEvents.map((traceEvent) => traceEvent.event));
+    }
+    if (command === "/config") {
+      return renderRedactedConfig(this.#config);
+    }
+    if (command === "/skills") {
+      return renderSkillIndex(this.#skillDefinitions);
+    }
+    if (command === "/help") {
+      return renderInteractiveHelp();
+    }
+    return [`Unknown slash command: ${command}`];
+  }
+  async #ensureSession() {
+    if (await this.#sessionStore.getSession(this.#sessionId) !== void 0) {
+      return;
+    }
+    await this.#sessionStore.createSession({ title: this.#sessionId });
+  }
+};
+function createCliApprovalResolver(options, approvalPromptLog) {
+  return {
+    async resolve(request) {
+      approvalPromptLog.push(
+        "Approval required:",
+        `Tool: ${request.call.name}`,
+        `Risk: ${request.decision.risk}`,
+        `Reason: ${request.decision.reason}`
+      );
+      const answer = (await options.readLine?.("Approve once? [y/N/details] "))?.trim().toLowerCase();
+      if (answer === "y" || answer === "yes") {
+        approvalPromptLog.push("Decision: approved once.");
+        return {
+          approved: true,
+          reason: "Approved once from CLI prompt."
+        };
+      }
+      approvalPromptLog.push("Decision: denied");
+      return {
+        approved: false,
+        reason: "Denied from CLI prompt."
+      };
+    }
+  };
+}
+function createCliBuiltInTools(options, config, skillFileMap) {
+  const tools = [
+    createReadFileTool(),
+    createListDirectoryTool(),
+    createWriteFileTool(),
+    createEditFileTool(),
+    createAppendFileTool(),
+    createShellTool(config?.runtime.sandboxed !== void 0 ? { sandboxed: config.runtime.sandboxed } : void 0),
+    createReadWebPageTool(options.fetch),
+    createSearchFilesTool()
+  ];
+  if (config?.memory.longTermFiles === "write") {
+    tools.push(createAppendDailyMemoryTool());
+  }
+  if (config?.memory.longTermFiles === "read-only" || config?.memory.longTermFiles === "write") {
+    const workspaceRoot = config.workspace.root;
+    tools.push(createMemorySearchTool(workspaceRoot));
+    tools.push(createMemoryGetTool(workspaceRoot));
+  }
+  tools.push(createUpdateHeartbeatTool());
+  if (skillFileMap !== void 0 && skillFileMap.size > 0) {
+    tools.push(createLoadSkillTool(skillFileMap));
+  }
+  return tools;
+}
+var MessageMappedFakeModelProvider = class {
+  requests = [];
+  #mapMessage;
+  constructor(mapMessage) {
+    this.#mapMessage = mapMessage;
+  }
+  async generate(input) {
+    this.requests.push(input);
+    const lastUserMessage = [...input.messages].reverse().find((message) => message.role === "user")?.content ?? "";
+    return {
+      type: "message",
+      content: this.#mapMessage(lastUserMessage)
+    };
+  }
+};
+function createConfiguredProvider(config, options) {
+  if (config.model.provider === "anthropic") {
+    return new AnthropicProvider({
+      ...config.secrets.apiKey !== void 0 ? { apiKey: config.secrets.apiKey } : {},
+      model: config.model.model,
+      temperature: config.model.temperature,
+      maxTokens: config.model.maxTokens,
+      ...config.model.thinkingBudget !== void 0 ? { thinkingBudget: config.model.thinkingBudget } : {}
+    });
+  }
+  return new OpenAICompatibleProvider({
+    baseURL: config.model.baseURL,
+    ...config.secrets.apiKey !== void 0 ? { apiKey: config.secrets.apiKey } : {},
+    model: config.model.model,
+    temperature: config.model.temperature,
+    maxTokens: config.model.maxTokens,
+    ...options.fetch ? { fetch: options.fetch } : {}
+  });
+}
+function createConfiguredSessionStore(config, options, sessionId) {
+  const effectiveConfig = options.sessionsDirectory ? { ...config, sessions: { directory: options.sessionsDirectory } } : config;
+  const directory = resolveSessionsDirectory(effectiveConfig, options.env);
+  return new JsonlSessionStore({
+    directory,
+    createSessionId: () => sessionId
+  });
+}
+function createCliContextAssembler(config, currentDate) {
+  const workspacePromptFiles = [
+    "AGENTS.md",
+    "SOUL.md",
+    "TOOLS.md",
+    "IDENTITY.md",
+    "HEARTBEAT.md",
+    "BOOTSTRAP.md"
+  ];
+  if (config.memory.longTermFiles === "read-only") {
+    workspacePromptFiles.push("USER.md", "MEMORY.md", `memory/${currentDate}.md`, `memory/${previousIsoDate(currentDate)}.md`);
+  }
+  return new DefaultContextAssembler({
+    workspacePromptFiles
+  });
+}
+function previousIsoDate(currentDate) {
+  const date = /* @__PURE__ */ new Date(`${currentDate}T00:00:00.000Z`);
+  date.setUTCDate(date.getUTCDate() - 1);
+  return date.toISOString().slice(0, 10);
+}
+function createSessionId() {
+  return `session_${crypto.randomUUID()}`;
+}
+function renderTodosProgress(events) {
+  const todosEvent = [...events].reverse().find((e) => e.type === "todos_updated");
+  if (todosEvent?.type !== "todos_updated" || todosEvent.todos.length === 0) return [];
+  const lines = ["Todo:"];
+  for (const todo of todosEvent.todos) {
+    const icon = todo.status === "completed" ? "\u2713" : todo.status === "in_progress" ? "\u2192" : "\xB7";
+    lines.push(`  ${icon} ${todo.content}`);
+  }
+  return lines;
+}
+function renderSkillIndex(skills) {
+  if (skills.length === 0) return ["No skills loaded."];
+  const lines = [];
+  const untrustedNames = [];
+  for (const s of skills) {
+    const trustBadge = s.source === "user" && s.trusted === false ? " \u26A0 untrusted" : "";
+    const versionBadge = s.version !== void 0 ? ` v${s.version}` : "";
+    const permsBadge = s.permissions !== void 0 && s.permissions.length > 0 ? ` [${s.permissions.join(", ")}]` : "";
+    lines.push(`[${s.source}]${trustBadge}${versionBadge} ${s.name}: ${s.description}${permsBadge}`);
+    if (s.source === "user" && s.trusted === false) {
+      untrustedNames.push(s.name);
+    }
+  }
+  if (untrustedNames.length > 0) {
+    lines.push("");
+    for (const name of untrustedNames) {
+      lines.push(`This skill was installed from an external source and has not been trusted. Run \`vole skills trust ${name}\` to trust it.`);
+    }
+  }
+  return lines;
+}
+function renderRedactedConfig(config) {
+  return [
+    `Provider: ${config.model.provider}`,
+    `Model: ${config.model.model}`,
+    `Base URL: ${config.model.baseURL}`,
+    `Default mode: ${config.runtime.defaultMode}`,
+    `Trace verbosity: ${config.trace.verbosity}`,
+    `Long-term memory files: ${config.memory.longTermFiles}`,
+    `Memory writes: ${config.memory.writes}`,
+    `API key: ${config.secrets.apiKey}`
+  ];
+}
+function renderToolResult(result) {
+  if ("entries" in result && Array.isArray(result.entries)) {
+    return result.entries.map((e) => `  ${e.type === "directory" ? "\u{1F4C1}" : "\u{1F4C4}"} ${e.name}`).join("\n");
+  }
+  if ("content" in result && typeof result.content === "string") {
+    const lines = result.content.split("\n");
+    return lines.length > 30 ? lines.slice(0, 30).join("\n") + `
+  \u2026 (${lines.length - 30} more lines)` : result.content;
+  }
+  if ("stdout" in result) {
+    const out = [result.stdout, result.stderr].filter(Boolean).join("\n");
+    return out || "(no output)";
+  }
+  if ("error" in result) {
+    const err = result.error;
+    return `Error: ${typeof err === "object" && err !== null && "message" in err ? err.message : String(err)}`;
+  }
+  return JSON.stringify(result, null, 2);
+}
+function renderCompactTrace(events) {
+  return events.map((event, index) => `${index + 1}. ${traceEventLabel(event)} (${event.type})`);
+}
+function traceEventLabel(event) {
+  switch (event.type) {
+    case "run_started":
+      return "Received user message";
+    case "context_assembled":
+      return "Assembled context";
+    case "compaction_triggered":
+      return `Compacted context (${event.messagesBefore} \u2192 ${event.messagesAfter} messages)`;
+    case "todos_updated":
+      return `Updated todos (${event.todos.length} items)`;
+    case "planning_stall_detected":
+      return `Planning stall detected (${event.stallCount}/${event.maxRetries})`;
+    case "model_request_started":
+      return "Started model request";
+    case "token_delta":
+      return `Token delta: "${event.delta.slice(0, 20)}${event.delta.length > 20 ? "\u2026" : ""}"`;
+    case "model_request_completed":
+      return "Completed model request";
+    case "tool_call_requested":
+      return "Requested tool call";
+    case "tool_call_permission_evaluated":
+      return "Evaluated tool permission";
+    case "approval_requested":
+      return "Requested approval";
+    case "approval_resolved":
+      return "Resolved approval";
+    case "tool_started":
+      return `Tool: ${event.toolName}`;
+    case "tool_completed":
+      return `Result [${event.toolName}]:
+${renderToolResult(event.result)}`;
+    case "tool_failed":
+      return `Tool failed [${event.toolName}]: ${event.error.message}`;
+    case "assistant_message_created":
+      return "Created assistant message";
+    case "turn_complete":
+      return `Turn complete (${event.messages.length} messages)`;
+    case "run_completed":
+      return "Completed run";
+    case "run_failed":
+      return "Failed run";
+  }
+}
+async function runWebDashboard(port, openBrowser) {
+  const selfDir = dirname4(fileURLToPath(import.meta.url));
+  const candidates = [
+    { server: join7(selfDir, "web", "server.js"), cwd: join7(selfDir, "web") },
+    { server: join7(selfDir, "../../web", "dist", "server.js"), cwd: join7(selfDir, "../../web") }
+  ];
+  let resolved;
+  for (const c of candidates) {
+    try {
+      await stat(c.server);
+      resolved = c;
+      break;
+    } catch {
+    }
+  }
+  if (resolved === void 0) {
+    return {
+      exitCode: 1,
+      stdout: "",
+      stderr: `Web app not built. Run first:
+  pnpm --filter @vole/web build
+`
+    };
+  }
+  const url = `http://localhost:${port}`;
+  const child = spawn("node", [resolved.server], {
+    env: { ...process.env, PORT: String(port) },
+    stdio: "inherit",
+    cwd: resolved.cwd
+  });
+  process.stdout.write(`Vole web dashboard \u2192 ${url}
+`);
+  process.stdout.write("Press Ctrl+C to stop.\n");
+  if (openBrowser) {
+    const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const openerArgs = process.platform === "win32" ? ["/c", "start", url] : [url];
+    setTimeout(() => {
+      spawn(opener, openerArgs, { stdio: "ignore", detached: true }).unref();
+    }, 800);
+  }
+  return new Promise((resolve2) => {
+    const shutdown = () => {
+      child.kill();
+      resolve2({ exitCode: 0, stdout: "Web server stopped.\n", stderr: "" });
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+    child.once("exit", (code) => resolve2({ exitCode: code ?? 0, stdout: "", stderr: "" }));
+  });
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const [command] = args;
+  const effectiveCommand = args.find((a) => a !== "--");
+  if (effectiveCommand === "chat" && !args.includes("--fake") && !args.includes("--fake-interactive")) {
+    const { runInkChat } = await import("./app.js");
+    await runInkChat({ args, env: process.env });
+    return;
+  }
+  const terminal = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const lineIterator = terminal[Symbol.asyncIterator]();
+  const result = await runCli(args, "0.0.0", {
+    env: process.env,
+    readLine: async (prompt) => {
+      process.stdout.write(prompt);
+      const line = await lineIterator.next();
+      return line.done ? void 0 : line.value;
+    },
+    write: (text) => process.stdout.write(text)
+  });
+  terminal.close();
+  process.stdout.write(result.stdout);
+  process.stderr.write(result.stderr);
+  process.exitCode = result.exitCode;
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  void main();
+}
+
+export {
+  loadConfig,
+  cliPackageName,
+  runCli,
+  CliChatSession,
+  renderTodosProgress,
+  renderSkillIndex,
+  renderRedactedConfig,
+  renderToolResult,
+  renderCompactTrace
+};