openvole 0.1.0

package/dist/cli.js

@@ -0,0 +1,3250 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/index.ts
+var config_exports = {};
+__export(config_exports, {
+  addPawToConfig: () => addPawToConfig,
+  addPawToLock: () => addPawToLock,
+  addSkillToConfig: () => addSkillToConfig,
+  addSkillToLock: () => addSkillToLock,
+  defineConfig: () => defineConfig,
+  loadConfig: () => loadConfig,
+  normalizePawConfig: () => normalizePawConfig,
+  readConfigFile: () => readConfigFile,
+  readLockFile: () => readLockFile,
+  removePawFromConfig: () => removePawFromConfig,
+  removePawFromLock: () => removePawFromLock,
+  removeSkillFromConfig: () => removeSkillFromConfig,
+  removeSkillFromLock: () => removeSkillFromLock,
+  writeConfigFile: () => writeConfigFile,
+  writeLockFile: () => writeLockFile
+});
+import * as fs from "fs/promises";
+import * as path from "path";
+function normalizePawConfig(entry) {
+  if (typeof entry === "string") {
+    return { name: entry };
+  }
+  return entry;
+}
+function defineConfig(config) {
+  return {
+    brain: config.brain,
+    paws: config.paws ?? [],
+    skills: config.skills ?? [],
+    loop: {
+      ...DEFAULT_LOOP_CONFIG,
+      ...config.loop
+    },
+    heartbeat: {
+      ...DEFAULT_HEARTBEAT_CONFIG,
+      ...config.heartbeat
+    },
+    toolProfiles: config.toolProfiles
+  };
+}
+async function loadConfig(configPath) {
+  const userConfig = await loadUserConfig(configPath);
+  const lockPath = path.join(path.dirname(configPath), ".openvole", "vole.lock.json");
+  const lock = await loadLockFile(lockPath);
+  return mergeConfigWithLock(userConfig, lock);
+}
+async function loadUserConfig(configPath) {
+  const dir = path.dirname(configPath);
+  const jsonPath = path.join(dir, "vole.config.json");
+  try {
+    const raw = await fs.readFile(jsonPath, "utf-8");
+    const config = JSON.parse(raw);
+    return {
+      brain: config.brain,
+      paws: config.paws ?? [],
+      skills: config.skills ?? [],
+      loop: {
+        ...DEFAULT_LOOP_CONFIG,
+        ...config.loop
+      },
+      heartbeat: {
+        ...DEFAULT_HEARTBEAT_CONFIG,
+        ...config.heartbeat
+      },
+      toolProfiles: config.toolProfiles
+    };
+  } catch {
+  }
+  const candidates = [configPath];
+  if (configPath.endsWith(".ts")) {
+    candidates.push(configPath.replace(/\.ts$/, ".mjs"));
+    candidates.push(configPath.replace(/\.ts$/, ".js"));
+  }
+  for (const candidate of candidates) {
+    try {
+      const module = await import(candidate);
+      const config = module.default ?? module;
+      return {
+        brain: config.brain,
+        paws: config.paws ?? [],
+        skills: config.skills ?? [],
+        loop: {
+          ...DEFAULT_LOOP_CONFIG,
+          ...config.loop
+        },
+        heartbeat: {
+          ...DEFAULT_HEARTBEAT_CONFIG,
+          ...config.heartbeat
+        },
+        toolProfiles: config.toolProfiles
+      };
+    } catch {
+      continue;
+    }
+  }
+  console.warn(`[config] No config found (tried: ${jsonPath}, ${candidates.join(", ")}), using defaults`);
+  return defineConfig({});
+}
+async function loadLockFile(lockPath) {
+  try {
+    const raw = await fs.readFile(lockPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { paws: [], skills: [] };
+  }
+}
+function mergeConfigWithLock(userConfig, lock) {
+  const userPawNames = new Set(
+    userConfig.paws.map((p) => typeof p === "string" ? p : p.name)
+  );
+  const userSkillNames = new Set(userConfig.skills);
+  const mergedPaws = [...userConfig.paws];
+  for (const lockPaw of lock.paws) {
+    if (!userPawNames.has(lockPaw.name)) {
+      mergedPaws.push(
+        lockPaw.allow ? { name: lockPaw.name, allow: lockPaw.allow } : lockPaw.name
+      );
+    }
+  }
+  const mergedSkills = [...userConfig.skills];
+  for (const lockSkill of lock.skills) {
+    if (!userSkillNames.has(lockSkill.name)) {
+      mergedSkills.push(lockSkill.name);
+    }
+  }
+  return {
+    ...userConfig,
+    paws: mergedPaws,
+    skills: mergedSkills
+  };
+}
+async function readLockFile(projectRoot) {
+  const lockPath = path.join(projectRoot, ".openvole", "vole.lock.json");
+  try {
+    const raw = await fs.readFile(lockPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { paws: [], skills: [] };
+  }
+}
+async function writeLockFile(projectRoot, lock) {
+  const openvoleDir = path.join(projectRoot, ".openvole");
+  await fs.mkdir(openvoleDir, { recursive: true });
+  const lockPath = path.join(openvoleDir, "vole.lock.json");
+  await fs.writeFile(lockPath, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+}
+async function addPawToLock(projectRoot, name, version, allow) {
+  const lock = await readLockFile(projectRoot);
+  const existing = lock.paws.findIndex((p) => p.name === name);
+  const entry = { name, version, allow };
+  if (existing >= 0) {
+    lock.paws[existing] = entry;
+  } else {
+    lock.paws.push(entry);
+  }
+  await writeLockFile(projectRoot, lock);
+}
+async function removePawFromLock(projectRoot, name) {
+  const lock = await readLockFile(projectRoot);
+  lock.paws = lock.paws.filter((p) => p.name !== name);
+  await writeLockFile(projectRoot, lock);
+}
+async function addSkillToLock(projectRoot, name, version) {
+  const lock = await readLockFile(projectRoot);
+  const existing = lock.skills.findIndex((s) => s.name === name);
+  const entry = { name, version };
+  if (existing >= 0) {
+    lock.skills[existing] = entry;
+  } else {
+    lock.skills.push(entry);
+  }
+  await writeLockFile(projectRoot, lock);
+}
+async function removeSkillFromLock(projectRoot, name) {
+  const lock = await readLockFile(projectRoot);
+  lock.skills = lock.skills.filter((s) => s.name !== name);
+  await writeLockFile(projectRoot, lock);
+}
+async function readConfigFile(projectRoot) {
+  const configPath = path.join(projectRoot, "vole.config.json");
+  try {
+    const raw = await fs.readFile(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+async function writeConfigFile(projectRoot, config) {
+  const configPath = path.join(projectRoot, "vole.config.json");
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+async function addPawToConfig(projectRoot, name, allow) {
+  const config = await readConfigFile(projectRoot);
+  const paws = config.paws ?? [];
+  const existing = paws.find(
+    (p) => typeof p === "string" ? p === name : p.name === name
+  );
+  if (existing) return;
+  paws.push(allow ? { name, allow } : name);
+  config.paws = paws;
+  await writeConfigFile(projectRoot, config);
+}
+async function removePawFromConfig(projectRoot, name) {
+  const config = await readConfigFile(projectRoot);
+  const paws = config.paws ?? [];
+  config.paws = paws.filter(
+    (p) => typeof p === "string" ? p !== name : p.name !== name
+  );
+  await writeConfigFile(projectRoot, config);
+}
+async function addSkillToConfig(projectRoot, name) {
+  const config = await readConfigFile(projectRoot);
+  const skills = config.skills ?? [];
+  if (skills.includes(name)) return;
+  skills.push(name);
+  config.skills = skills;
+  await writeConfigFile(projectRoot, config);
+}
+async function removeSkillFromConfig(projectRoot, name) {
+  const config = await readConfigFile(projectRoot);
+  const skills = config.skills ?? [];
+  config.skills = skills.filter((s) => s !== name);
+  await writeConfigFile(projectRoot, config);
+}
+var DEFAULT_LOOP_CONFIG, DEFAULT_HEARTBEAT_CONFIG;
+var init_config = __esm({
+  "src/config/index.ts"() {
+    "use strict";
+    DEFAULT_LOOP_CONFIG = {
+      maxIterations: 10,
+      confirmBeforeAct: true,
+      taskConcurrency: 1,
+      compactThreshold: 50,
+      logLevel: "info",
+      rateLimits: void 0
+    };
+    DEFAULT_HEARTBEAT_CONFIG = {
+      enabled: false,
+      intervalMinutes: 30
+    };
+  }
+});
+
+// src/core/bus.ts
+var bus_exports = {};
+__export(bus_exports, {
+  createMessageBus: () => createMessageBus
+});
+import mitt from "mitt";
+function createMessageBus() {
+  return mitt();
+}
+var init_bus = __esm({
+  "src/core/bus.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/logger.ts
+function currentLevel() {
+  const env = (process.env.VOLE_LOG_LEVEL ?? "info").toLowerCase();
+  return LEVELS[env] ?? LEVELS.info;
+}
+function createLogger(tag) {
+  const prefix = `[${tag}]`;
+  return {
+    error: (msg, ...args) => currentLevel() >= LEVELS.error && console.error(prefix, msg, ...args),
+    warn: (msg, ...args) => currentLevel() >= LEVELS.warn && console.warn(prefix, msg, ...args),
+    info: (msg, ...args) => currentLevel() >= LEVELS.info && console.info(prefix, msg, ...args),
+    debug: (msg, ...args) => currentLevel() >= LEVELS.debug && console.debug(prefix, msg, ...args),
+    trace: (msg, ...args) => currentLevel() >= LEVELS.trace && console.debug(prefix, msg, ...args)
+  };
+}
+var LEVELS;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    LEVELS = { error: 0, warn: 1, info: 2, debug: 3, trace: 4 };
+  }
+});
+
+// src/skill/resolver.ts
+import { execFileSync } from "child_process";
+function resolveSkills(skills, toolRegistry) {
+  for (const skill of skills) {
+    const missing = [];
+    for (const toolName of skill.definition.requiredTools) {
+      if (!toolRegistry.has(toolName)) {
+        missing.push(`tool:${toolName}`);
+      }
+    }
+    const requires = skill.definition.requires;
+    if (requires) {
+      for (const envVar of requires.env) {
+        if (!process.env[envVar]) {
+          missing.push(`env:${envVar}`);
+        }
+      }
+      for (const bin of requires.bins) {
+        if (!isBinaryAvailable(bin)) {
+          missing.push(`bin:${bin}`);
+        }
+      }
+      if (requires.anyBins.length > 0) {
+        const hasAny = requires.anyBins.some(isBinaryAvailable);
+        if (!hasAny) {
+          missing.push(`anyBin:${requires.anyBins.join("|")}`);
+        }
+      }
+    }
+    const wasActive = skill.active;
+    skill.active = missing.length === 0;
+    skill.missingTools = missing;
+    if (skill.active && !wasActive) {
+      const providers = skill.definition.requiredTools.map((t) => toolRegistry.get(t)?.pawName).filter(Boolean);
+      const providerInfo = providers.length > 0 ? ` (tools provided by: ${[...new Set(providers)].join(", ")})` : "";
+      logger.info(`Skill "${skill.name}" activated${providerInfo}`);
+    } else if (!skill.active && wasActive) {
+      logger.warn(
+        `Skill "${skill.name}" deactivated (missing: ${missing.join(", ")})`
+      );
+    } else if (!skill.active) {
+      logger.debug(
+        `Skill "${skill.name}" inactive (missing: ${missing.join(", ")})`
+      );
+    }
+  }
+}
+function buildActiveSkills(skills, toolRegistry) {
+  return skills.filter((s) => s.active).map((s) => {
+    const satisfiedBy = s.definition.requiredTools.map((t) => toolRegistry.get(t)?.pawName).filter((name) => name != null);
+    return {
+      name: s.name,
+      description: s.definition.description,
+      satisfiedBy: [...new Set(satisfiedBy)]
+    };
+  });
+}
+function isBinaryAvailable(name) {
+  try {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    execFileSync(cmd, [name], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var logger;
+var init_resolver = __esm({
+  "src/skill/resolver.ts"() {
+    "use strict";
+    init_logger();
+    logger = createLogger("skill-resolver");
+  }
+});
+
+// src/core/task.ts
+var task_exports = {};
+__export(task_exports, {
+  TaskQueue: () => TaskQueue
+});
+import * as crypto from "crypto";
+var logger3, TaskQueue;
+var init_task = __esm({
+  "src/core/task.ts"() {
+    "use strict";
+    init_logger();
+    logger3 = createLogger("task-queue");
+    TaskQueue = class {
+      constructor(bus, concurrency = 1, rateLimiter, rateLimits) {
+        this.bus = bus;
+        this.concurrency = concurrency;
+        this.rateLimiter = rateLimiter;
+        this.rateLimits = rateLimits;
+      }
+      queue = [];
+      running = /* @__PURE__ */ new Map();
+      completed = [];
+      runner;
+      draining = false;
+      /** Set the task runner function (called by the agent loop) */
+      setRunner(runner) {
+        this.runner = runner;
+      }
+      /** Enqueue a new task */
+      enqueue(input, source = "user", options) {
+        const task = {
+          id: crypto.randomUUID(),
+          source,
+          input,
+          status: "queued",
+          createdAt: Date.now(),
+          sessionId: options?.sessionId,
+          metadata: options?.metadata
+        };
+        if (this.rateLimiter && this.rateLimits?.tasksPerHour) {
+          const limit = this.rateLimits.tasksPerHour[source];
+          if (limit != null) {
+            const bucket = `tasks:per-hour:${source}`;
+            if (!this.rateLimiter.tryConsume(bucket, limit, 36e5)) {
+              logger3.warn(
+                `Rate limit warning: tasksPerHour for source "${source}" exceeded (limit: ${limit}). Task will still be enqueued.`
+              );
+              this.bus.emit("rate:limited", { bucket, source });
+            }
+          }
+        }
+        this.queue.push(task);
+        logger3.info(`Task ${task.id} queued (source: ${source})`);
+        this.bus.emit("task:queued", { taskId: task.id });
+        this.drain();
+        return task;
+      }
+      /** Cancel a task by ID */
+      cancel(taskId) {
+        const queueIdx = this.queue.findIndex((t) => t.id === taskId);
+        if (queueIdx !== -1) {
+          const task = this.queue.splice(queueIdx, 1)[0];
+          task.status = "cancelled";
+          task.completedAt = Date.now();
+          this.completed.push(task);
+          logger3.info(`Task ${taskId} cancelled (was queued)`);
+          this.bus.emit("task:cancelled", { taskId });
+          return true;
+        }
+        const running = this.running.get(taskId);
+        if (running) {
+          running.status = "cancelled";
+          logger3.info(`Task ${taskId} marked for cancellation (running)`);
+          return true;
+        }
+        return false;
+      }
+      /** Get all tasks (queued + running + completed) */
+      list() {
+        return [
+          ...this.queue,
+          ...Array.from(this.running.values()),
+          ...this.completed.slice(-50)
+          // keep last 50 completed
+        ];
+      }
+      /** Get a task by ID */
+      get(taskId) {
+        return this.queue.find((t) => t.id === taskId) ?? this.running.get(taskId) ?? this.completed.find((t) => t.id === taskId);
+      }
+      /** Check if a task has been cancelled */
+      isCancelled(taskId) {
+        const task = this.running.get(taskId);
+        return task?.status === "cancelled";
+      }
+      async drain() {
+        if (this.draining) return;
+        this.draining = true;
+        try {
+          while (this.queue.length > 0 && this.running.size < this.concurrency) {
+            if (!this.runner) {
+              logger3.error("No task runner configured");
+              break;
+            }
+            const task = this.queue.shift();
+            task.status = "running";
+            task.startedAt = Date.now();
+            this.running.set(task.id, task);
+            logger3.info(`Task ${task.id} started`);
+            this.bus.emit("task:started", { taskId: task.id });
+            this.runTask(task);
+          }
+        } finally {
+          this.draining = false;
+        }
+      }
+      async runTask(task) {
+        try {
+          await this.runner(task);
+          if (task.status !== "cancelled") {
+            task.status = "completed";
+          }
+          task.completedAt = Date.now();
+          logger3.info(`Task ${task.id} ${task.status}`);
+          this.bus.emit("task:completed", { taskId: task.id, result: task.result });
+        } catch (err) {
+          task.status = "failed";
+          task.completedAt = Date.now();
+          task.error = err instanceof Error ? err.message : String(err);
+          logger3.error(`Task ${task.id} failed: ${task.error}`);
+          this.bus.emit("task:failed", { taskId: task.id, error: err });
+        } finally {
+          this.running.delete(task.id);
+          this.completed.push(task);
+          this.drain();
+        }
+      }
+    };
+  }
+});
+
+// src/core/scheduler.ts
+var scheduler_exports = {};
+__export(scheduler_exports, {
+  SchedulerStore: () => SchedulerStore
+});
+var logger4, SchedulerStore;
+var init_scheduler = __esm({
+  "src/core/scheduler.ts"() {
+    "use strict";
+    init_logger();
+    logger4 = createLogger("scheduler");
+    SchedulerStore = class {
+      schedules = /* @__PURE__ */ new Map();
+      /** Create or replace a recurring schedule */
+      add(id, input, intervalMinutes, onTick) {
+        if (this.schedules.has(id)) {
+          this.cancel(id);
+        }
+        const intervalMs = intervalMinutes * 6e4;
+        const timer = setInterval(onTick, intervalMs);
+        this.schedules.set(id, {
+          id,
+          input,
+          intervalMinutes,
+          timer,
+          createdAt: Date.now()
+        });
+        logger4.info(`Schedule "${id}" created \u2014 every ${intervalMinutes}m: "${input.substring(0, 80)}"`);
+      }
+      /** Cancel a schedule by ID */
+      cancel(id) {
+        const entry = this.schedules.get(id);
+        if (!entry) return false;
+        clearInterval(entry.timer);
+        this.schedules.delete(id);
+        logger4.info(`Schedule "${id}" cancelled`);
+        return true;
+      }
+      /** List all active schedules */
+      list() {
+        return Array.from(this.schedules.values()).map(({ id, input, intervalMinutes, createdAt }) => ({
+          id,
+          input,
+          intervalMinutes,
+          createdAt
+        }));
+      }
+      /** Clear all schedules (for shutdown) */
+      clearAll() {
+        for (const entry of this.schedules.values()) {
+          clearInterval(entry.timer);
+        }
+        this.schedules.clear();
+        logger4.info("All schedules cleared");
+      }
+    };
+  }
+});
+
+// src/tool/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ToolRegistry: () => ToolRegistry
+});
+var logger6, ToolRegistry;
+var init_registry = __esm({
+  "src/tool/registry.ts"() {
+    "use strict";
+    init_logger();
+    logger6 = createLogger("tool-registry");
+    ToolRegistry = class {
+      constructor(bus) {
+        this.bus = bus;
+      }
+      tools = /* @__PURE__ */ new Map();
+      /** Register tools from a Paw. Skips tools with conflicting names. */
+      register(pawName, tools, inProcess) {
+        for (const tool of tools) {
+          if (this.tools.has(tool.name)) {
+            const existing = this.tools.get(tool.name);
+            logger6.warn(
+              `Tool name conflict: "${tool.name}" already registered by "${existing.pawName}", ignoring registration from "${pawName}"`
+            );
+            continue;
+          }
+          this.tools.set(tool.name, {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            pawName,
+            inProcess,
+            execute: tool.execute
+          });
+          logger6.info(`Registered tool "${tool.name}" from "${pawName}"`);
+          this.bus.emit("tool:registered", { toolName: tool.name, pawName });
+        }
+      }
+      /** Remove all tools owned by a specific Paw */
+      unregister(pawName) {
+        const toRemove = [];
+        for (const [name, entry] of this.tools) {
+          if (entry.pawName === pawName) {
+            toRemove.push(name);
+          }
+        }
+        for (const name of toRemove) {
+          this.tools.delete(name);
+          logger6.info(`Unregistered tool "${name}" from "${pawName}"`);
+          this.bus.emit("tool:unregistered", { toolName: name, pawName });
+        }
+      }
+      /** Get a tool entry by name */
+      get(toolName) {
+        return this.tools.get(toolName);
+      }
+      /** List all registered tools */
+      list() {
+        return Array.from(this.tools.values());
+      }
+      /** Check if a tool exists */
+      has(toolName) {
+        return this.tools.has(toolName);
+      }
+      /** Get tool summaries for AgentContext */
+      summaries() {
+        return this.list().map((t) => ({
+          name: t.name,
+          description: t.description,
+          pawName: t.pawName
+        }));
+      }
+      /** Get all tool names owned by a specific Paw */
+      toolsForPaw(pawName) {
+        return this.list().filter((t) => t.pawName === pawName).map((t) => t.name);
+      }
+      /** Clear all tools (for shutdown) */
+      clear() {
+        this.tools.clear();
+      }
+    };
+  }
+});
+
+// src/paw/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  readPawManifest: () => readPawManifest,
+  resolvePawPath: () => resolvePawPath
+});
+import * as fs2 from "fs/promises";
+import { accessSync } from "fs";
+import * as path2 from "path";
+import { z } from "zod";
+function resolvePawPath(name, projectRoot) {
+  if (name.startsWith(".") || name.startsWith("/")) {
+    return path2.resolve(projectRoot, name);
+  }
+  const openvoleDir = path2.resolve(projectRoot, ".openvole", "paws", name);
+  try {
+    accessSync(path2.join(openvoleDir, "vole-paw.json"));
+    return openvoleDir;
+  } catch {
+  }
+  return path2.resolve(projectRoot, "node_modules", name);
+}
+async function readPawManifest(pawPath) {
+  const manifestPath = path2.join(pawPath, "vole-paw.json");
+  try {
+    const raw = await fs2.readFile(manifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = pawManifestSchema.safeParse(parsed);
+    if (!result.success) {
+      logger7.error(
+        "Invalid manifest at %s: %s",
+        manifestPath,
+        result.error.message
+      );
+      return null;
+    }
+    return result.data;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      logger7.error("Manifest not found: %s", manifestPath);
+    } else {
+      logger7.error("Failed to read manifest %s: %s", manifestPath, err);
+    }
+    return null;
+  }
+}
+var logger7, pawManifestSchema;
+var init_manifest = __esm({
+  "src/paw/manifest.ts"() {
+    "use strict";
+    init_logger();
+    logger7 = createLogger("paw-manifest");
+    pawManifestSchema = z.object({
+      name: z.string().min(1),
+      version: z.string().min(1),
+      description: z.string(),
+      entry: z.string().min(1),
+      brain: z.boolean().default(false),
+      inProcess: z.boolean().optional().default(false),
+      transport: z.enum(["ipc", "stdio"]).optional().default("ipc"),
+      tools: z.array(
+        z.object({
+          name: z.string().min(1),
+          description: z.string()
+        })
+      ).default([]),
+      permissions: z.object({
+        network: z.array(z.string()).optional().default([]),
+        listen: z.array(z.number().int().positive()).optional().default([]),
+        filesystem: z.array(z.string()).optional().default([]),
+        env: z.array(z.string()).optional().default([])
+      }).optional().default({})
+    });
+  }
+});
+
+// src/skill/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  loadSkillFromDirectory: () => loadSkillFromDirectory
+});
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+import { parse as parseYaml } from "yaml";
+async function loadSkillFromDirectory(skillDir) {
+  const skillMdPath = path4.join(skillDir, "SKILL.md");
+  try {
+    const raw = await fs3.readFile(skillMdPath, "utf-8");
+    return parseSkillMd(raw, skillMdPath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      logger12.error("SKILL.md not found: %s", skillMdPath);
+    } else {
+      logger12.error("Failed to read SKILL.md at %s: %s", skillMdPath, err);
+    }
+    return null;
+  }
+}
+function parseSkillMd(content, filePath) {
+  const { frontmatter, body } = extractFrontmatter(content);
+  if (!frontmatter) {
+    logger12.error("No YAML frontmatter found in %s", filePath);
+    return null;
+  }
+  let meta;
+  try {
+    meta = parseYaml(frontmatter);
+  } catch (err) {
+    logger12.error("Invalid YAML frontmatter in %s: %s", filePath, err);
+    return null;
+  }
+  if (!meta.name || typeof meta.name !== "string") {
+    logger12.error('SKILL.md missing "name" in frontmatter: %s', filePath);
+    return null;
+  }
+  if (!meta.description || typeof meta.description !== "string") {
+    logger12.error('SKILL.md missing "description" in frontmatter: %s', filePath);
+    return null;
+  }
+  const instructions = body.trim();
+  if (!instructions) {
+    logger12.error("SKILL.md has no instructions (empty body): %s", filePath);
+    return null;
+  }
+  const openclaw = extractOpenClawMetadata(meta);
+  return {
+    name: meta.name,
+    description: meta.description,
+    version: typeof meta.version === "string" ? meta.version : typeof meta.version === "number" ? String(meta.version) : void 0,
+    requiredTools: toStringArray(meta.requiredTools),
+    optionalTools: toStringArray(meta.optionalTools),
+    instructions,
+    tags: toStringArray(meta.tags),
+    // OpenClaw compatibility fields
+    requires: openclaw.requires
+  };
+}
+function extractOpenClawMetadata(meta) {
+  const metadata = meta.metadata;
+  if (!metadata) return { requires: void 0 };
+  const oc = metadata.openclaw ?? metadata.clawdbot;
+  if (!oc) return { requires: void 0 };
+  const req = oc.requires;
+  if (!req) return { requires: void 0 };
+  return {
+    requires: {
+      env: toStringArray(req.env),
+      bins: toStringArray(req.bins),
+      anyBins: toStringArray(req.anyBins)
+    }
+  };
+}
+function extractFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: null, body: content };
+  }
+  return { frontmatter: match[1], body: match[2] };
+}
+function toStringArray(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
+}
+var logger12;
+var init_loader = __esm({
+  "src/skill/loader.ts"() {
+    "use strict";
+    init_logger();
+    logger12 = createLogger("skill-loader");
+  }
+});
+
+// src/skill/registry.ts
+var registry_exports2 = {};
+__export(registry_exports2, {
+  SkillRegistry: () => SkillRegistry
+});
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+async function resolveSkillPath(name, projectRoot) {
+  if (name.startsWith(".") || name.startsWith("/")) {
+    return path5.resolve(projectRoot, name);
+  }
+  if (name.startsWith("clawhub/")) {
+    return path5.resolve(projectRoot, ".openvole", "skills", name);
+  }
+  const localPath = path5.resolve(projectRoot, ".openvole", "skills", name);
+  if (await exists(path5.join(localPath, "SKILL.md"))) return localPath;
+  const clawHubPath = path5.resolve(projectRoot, ".openvole", "skills", "clawhub", name);
+  if (await exists(path5.join(clawHubPath, "SKILL.md"))) return clawHubPath;
+  return path5.resolve(projectRoot, "node_modules", name);
+}
+async function exists(filePath) {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var logger13, SkillRegistry;
+var init_registry2 = __esm({
+  "src/skill/registry.ts"() {
+    "use strict";
+    init_loader();
+    init_resolver();
+    init_logger();
+    logger13 = createLogger("skill-registry");
+    SkillRegistry = class {
+      constructor(bus, toolRegistry, projectRoot) {
+        this.bus = bus;
+        this.toolRegistry = toolRegistry;
+        this.projectRoot = projectRoot;
+        this.bus.on("tool:registered", () => this.resolve());
+        this.bus.on("tool:unregistered", () => this.resolve());
+      }
+      skills = /* @__PURE__ */ new Map();
+      /** Load a Skill from a directory containing SKILL.md */
+      async load(nameOrPath) {
+        const skillDir = await resolveSkillPath(nameOrPath, this.projectRoot);
+        const definition = await loadSkillFromDirectory(skillDir);
+        if (!definition) {
+          return false;
+        }
+        const registryKey = nameOrPath.startsWith(".") || nameOrPath.startsWith("/") ? definition.name : nameOrPath;
+        if (this.skills.has(registryKey)) {
+          logger13.warn(`Skill "${registryKey}" is already loaded`);
+          return false;
+        }
+        const instance = {
+          name: registryKey,
+          definition,
+          path: skillDir,
+          active: false,
+          missingTools: [...definition.requiredTools]
+        };
+        this.skills.set(registryKey, instance);
+        logger13.info(`Skill "${registryKey}" loaded from ${skillDir}`);
+        this.resolve();
+        return true;
+      }
+      /** Unload a Skill */
+      unload(name) {
+        if (!this.skills.has(name)) {
+          return false;
+        }
+        this.skills.delete(name);
+        logger13.info(`Skill "${name}" unloaded`);
+        return true;
+      }
+      /** Re-run the resolver against the current tool registry */
+      resolve() {
+        resolveSkills(Array.from(this.skills.values()), this.toolRegistry);
+      }
+      /** Get all Skill instances */
+      list() {
+        return Array.from(this.skills.values());
+      }
+      /** Get active Skills only */
+      active() {
+        return this.list().filter((s) => s.active);
+      }
+      /** Get a Skill by name */
+      get(name) {
+        return this.skills.get(name);
+      }
+    };
+  }
+});
+
+// src/tool/core-tools.ts
+var core_tools_exports = {};
+__export(core_tools_exports, {
+  createCoreTools: () => createCoreTools
+});
+import * as fs5 from "fs/promises";
+import * as path6 from "path";
+import { z as z2 } from "zod";
+function createCoreTools(scheduler, taskQueue, projectRoot, skillRegistry) {
+  const heartbeatPath = path6.resolve(projectRoot, "HEARTBEAT.md");
+  return [
+    // === Scheduling tools ===
+    {
+      name: "schedule_task",
+      description: "Create a recurring scheduled task that runs at a fixed interval",
+      parameters: z2.object({
+        id: z2.string().describe("Unique schedule ID (for cancellation)"),
+        input: z2.string().describe("The task input to enqueue each time"),
+        intervalMinutes: z2.number().describe("How often to run (in minutes)")
+      }),
+      async execute(params) {
+        const { id, input, intervalMinutes } = params;
+        scheduler.add(id, input, intervalMinutes, () => {
+          taskQueue.enqueue(input, "schedule");
+        });
+        return { ok: true, id, intervalMinutes };
+      }
+    },
+    {
+      name: "cancel_schedule",
+      description: "Cancel a previously created scheduled task",
+      parameters: z2.object({
+        id: z2.string().describe("Schedule ID to cancel")
+      }),
+      async execute(params) {
+        const { id } = params;
+        const cancelled = scheduler.cancel(id);
+        return { ok: cancelled, id };
+      }
+    },
+    {
+      name: "list_schedules",
+      description: "List all active scheduled tasks",
+      parameters: z2.object({}),
+      async execute() {
+        return scheduler.list();
+      }
+    },
+    // === Heartbeat tools ===
+    {
+      name: "heartbeat_read",
+      description: "Read the HEARTBEAT.md file containing recurring job definitions",
+      parameters: z2.object({}),
+      async execute() {
+        try {
+          const content = await fs5.readFile(heartbeatPath, "utf-8");
+          return { ok: true, content };
+        } catch {
+          return { ok: true, content: "" };
+        }
+      }
+    },
+    {
+      name: "heartbeat_write",
+      description: "Update the HEARTBEAT.md file with new recurring job definitions",
+      parameters: z2.object({
+        content: z2.string().describe("The full content to write to HEARTBEAT.md")
+      }),
+      async execute(params) {
+        const { content } = params;
+        await fs5.writeFile(heartbeatPath, content, "utf-8");
+        return { ok: true };
+      }
+    },
+    // === Skill tools (on-demand loading) ===
+    {
+      name: "skill_read",
+      description: "Read the full SKILL.md instructions for a skill by name. Use this when a skill is relevant to the current task.",
+      parameters: z2.object({
+        name: z2.string().describe("Skill name to read")
+      }),
+      async execute(params) {
+        const { name } = params;
+        const skill = skillRegistry.get(name);
+        if (!skill) {
+          return { ok: false, error: `Skill "${name}" not found` };
+        }
+        try {
+          const content = await fs5.readFile(
+            path6.join(skill.path, "SKILL.md"),
+            "utf-8"
+          );
+          return { ok: true, name, content };
+        } catch {
+          return { ok: false, error: `Failed to read SKILL.md for "${name}"` };
+        }
+      }
+    },
+    {
+      name: "skill_read_reference",
+      description: "Read a reference file from a skill's references/ directory. Use this for API docs, schemas, or detailed guides.",
+      parameters: z2.object({
+        name: z2.string().describe("Skill name"),
+        file: z2.string().describe("File path relative to the skill's references/ directory")
+      }),
+      async execute(params) {
+        const { name, file } = params;
+        const skill = skillRegistry.get(name);
+        if (!skill) {
+          return { ok: false, error: `Skill "${name}" not found` };
+        }
+        const resolved = path6.resolve(skill.path, "references", file);
+        if (!resolved.startsWith(path6.resolve(skill.path, "references"))) {
+          return { ok: false, error: "Invalid file path" };
+        }
+        try {
+          const content = await fs5.readFile(resolved, "utf-8");
+          return { ok: true, name, file, content };
+        } catch {
+          return { ok: false, error: `File not found: references/${file}` };
+        }
+      }
+    },
+    {
+      name: "skill_list_files",
+      description: "List all files in a skill's directory including scripts, references, and assets.",
+      parameters: z2.object({
+        name: z2.string().describe("Skill name")
+      }),
+      async execute(params) {
+        const { name } = params;
+        const skill = skillRegistry.get(name);
+        if (!skill) {
+          return { ok: false, error: `Skill "${name}" not found` };
+        }
+        try {
+          const files = await listFilesRecursive(skill.path);
+          return { ok: true, name, files };
+        } catch {
+          return { ok: false, error: `Failed to list files for "${name}"` };
+        }
+      }
+    }
+  ];
+}
+async function listFilesRecursive(dir, prefix = "") {
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursive(path6.join(dir, entry.name), rel));
+    } else {
+      files.push(rel);
+    }
+  }
+  return files;
+}
+var init_core_tools = __esm({
+  "src/tool/core-tools.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli.ts
+import "dotenv/config";
+import * as path8 from "path";
+
+// src/index.ts
+init_config();
+init_bus();
+
+// src/context/types.ts
+function createAgentContext(taskId, maxIterations) {
+  return {
+    taskId,
+    messages: [],
+    availableTools: [],
+    activeSkills: [],
+    metadata: {},
+    iteration: 0,
+    maxIterations
+  };
+}
+
+// src/core/errors.ts
+function createActionError(code, message, opts) {
+  return {
+    code,
+    message,
+    toolName: opts?.toolName,
+    pawName: opts?.pawName,
+    details: opts?.details
+  };
+}
+function successResult(toolName, pawName, output, durationMs) {
+  return { toolName, pawName, success: true, output, durationMs };
+}
+function failureResult(toolName, pawName, error, durationMs) {
+  return { toolName, pawName, success: false, error, durationMs };
+}
+
+// src/core/loop.ts
+init_resolver();
+
+// src/core/hooks.ts
+var PHASE_ORDER = [
+  "perceive",
+  "think",
+  "act",
+  "observe"
+];
+
+// src/core/loop.ts
+init_logger();
+var logger2 = createLogger("loop");
+var MAX_BRAIN_FAILURES = 3;
+async function runAgentLoop(task, deps) {
+  const { bus, toolRegistry, pawRegistry, skillRegistry, io, config, toolProfiles, rateLimiter } = deps;
+  const rateLimits = config.rateLimits;
+  let toolExecutionCount = 0;
+  logger2.info(`Agent loop started for task ${task.id}: "${task.input}"`);
+  let context = createAgentContext(task.id, config.maxIterations);
+  context.metadata.taskSource = task.source;
+  context.metadata.sessionId = task.sessionId;
+  if (task.metadata) {
+    Object.assign(context.metadata, task.metadata);
+  }
+  if (task.source === "heartbeat") {
+    context.metadata.heartbeat = true;
+  }
+  context.messages.push({
+    role: "user",
+    content: task.input,
+    timestamp: Date.now()
+  });
+  logger2.debug("Phase: bootstrap");
+  context = await pawRegistry.runBootstrapHooks(context);
+  let consecutiveBrainFailures = 0;
+  for (context.iteration = 0; context.iteration < config.maxIterations; context.iteration++) {
+    if (task.status === "cancelled") {
+      logger2.info(`Task ${task.id} cancelled at iteration ${context.iteration}`);
+      return;
+    }
+    if (config.compactThreshold > 0 && context.messages.length > config.compactThreshold) {
+      logger2.info(
+        `Context has ${context.messages.length} messages (threshold: ${config.compactThreshold}), running compact`
+      );
+      context = await pawRegistry.runCompactHooks(context);
+    }
+    logger2.info(
+      `Loop running \u2014 iteration ${context.iteration + 1}/${config.maxIterations}`
+    );
+    logger2.debug(`Phase: ${PHASE_ORDER[0]}`);
+    const enrichedContext = await runPerceive(context, pawRegistry, toolRegistry, skillRegistry);
+    if (rateLimiter && rateLimits) {
+      if (rateLimits.llmCallsPerMinute != null) {
+        if (!rateLimiter.tryConsume("llm:per-minute", rateLimits.llmCallsPerMinute, 6e4)) {
+          logger2.warn(`Rate limit hit: llmCallsPerMinute (${rateLimits.llmCallsPerMinute})`);
+          bus.emit("rate:limited", { bucket: "llm:per-minute", source: task.source });
+          enrichedContext.messages.push({
+            role: "error",
+            content: `Rate limit exceeded: LLM calls per minute (limit: ${rateLimits.llmCallsPerMinute}). Retrying next iteration.`,
+            timestamp: Date.now()
+          });
+          continue;
+        }
+      }
+      if (rateLimits.llmCallsPerHour != null) {
+        if (!rateLimiter.tryConsume("llm:per-hour", rateLimits.llmCallsPerHour, 36e5)) {
+          logger2.warn(`Rate limit hit: llmCallsPerHour (${rateLimits.llmCallsPerHour})`);
+          bus.emit("rate:limited", { bucket: "llm:per-hour", source: task.source });
+          enrichedContext.messages.push({
+            role: "error",
+            content: `Rate limit exceeded: LLM calls per hour (limit: ${rateLimits.llmCallsPerHour}). Retrying next iteration.`,
+            timestamp: Date.now()
+          });
+          continue;
+        }
+      }
+    }
+    logger2.debug(`Phase: ${PHASE_ORDER[1]}`);
+    const plan = await runThink(enrichedContext, pawRegistry);
+    if (!plan) {
+      logger2.debug("Think phase returned null (no Brain Paw)");
+      break;
+    }
+    if (plan === "BRAIN_ERROR") {
+      consecutiveBrainFailures++;
+      if (consecutiveBrainFailures >= MAX_BRAIN_FAILURES) {
+        io.notify(
+          `Brain Paw failed ${MAX_BRAIN_FAILURES} consecutive times. Halting task ${task.id}.`
+        );
+        task.error = `Brain failed ${MAX_BRAIN_FAILURES} consecutive times`;
+        return;
+      }
+      continue;
+    }
+    consecutiveBrainFailures = 0;
+    if (plan.done) {
+      if (plan.response) {
+        task.result = plan.response;
+        io.notify(plan.response);
+        enrichedContext.messages.push({
+          role: "brain",
+          content: plan.response,
+          timestamp: Date.now()
+        });
+      }
+      logger2.info(`Task ${task.id} completed by Brain at iteration ${context.iteration + 1}`);
+      return;
+    }
+    if (plan.response) {
+      io.notify(plan.response);
+      enrichedContext.messages.push({
+        role: "brain",
+        content: plan.response,
+        timestamp: Date.now()
+      });
+    }
+    logger2.debug(`Phase: ${PHASE_ORDER[2]}`);
+    if (plan.actions.length > 0) {
+      if (rateLimiter && rateLimits?.toolExecutionsPerTask != null) {
+        const incoming = plan.actions.length;
+        if (toolExecutionCount + incoming > rateLimits.toolExecutionsPerTask) {
+          logger2.warn(
+            `Rate limit hit: toolExecutionsPerTask (${toolExecutionCount + incoming}/${rateLimits.toolExecutionsPerTask})`
+          );
+          bus.emit("rate:limited", { bucket: "tools:per-task", source: task.source });
+          enrichedContext.messages.push({
+            role: "error",
+            content: `Rate limit exceeded: tool executions per task (limit: ${rateLimits.toolExecutionsPerTask}, used: ${toolExecutionCount}). Stopping task.`,
+            timestamp: Date.now()
+          });
+          break;
+        }
+      }
+      const profile = toolProfiles?.[task.source];
+      if (profile) {
+        const blocked = [];
+        plan.actions = plan.actions.filter((a) => {
+          if (profile.allow && !profile.allow.includes(a.tool)) {
+            blocked.push(a.tool);
+            return false;
+          }
+          if (profile.deny?.includes(a.tool)) {
+            blocked.push(a.tool);
+            return false;
+          }
+          return true;
+        });
+        if (blocked.length > 0) {
+          logger2.warn(`Blocked tools for source "${task.source}": ${blocked.join(", ")}`);
+          enrichedContext.messages.push({
+            role: "error",
+            content: `Tools blocked by security profile for "${task.source}" source: ${blocked.join(", ")}`,
+            timestamp: Date.now()
+          });
+        }
+        if (plan.actions.length === 0) continue;
+      }
+      for (const action of plan.actions) {
+        logger2.info(`Tool call: ${action.tool}(${JSON.stringify(action.params)})`);
+      }
+      if (config.confirmBeforeAct) {
+        const toolNames = plan.actions.map((a) => a.tool).join(", ");
+        const confirmed = await io.confirm(
+          `Execute tools: ${toolNames}?`
+        );
+        if (!confirmed) {
+          enrichedContext.messages.push({
+            role: "error",
+            content: "User declined to execute planned actions",
+            timestamp: Date.now()
+          });
+          continue;
+        }
+      }
+      const results = await runAct(
+        plan.actions,
+        plan.execution ?? "sequential",
+        enrichedContext,
+        toolRegistry,
+        pawRegistry
+      );
+      toolExecutionCount += results.length;
+      logger2.debug(`Phase: ${PHASE_ORDER[3]}`);
+      for (const result of results) {
+        if (result.success) {
+          enrichedContext.messages.push({
+            role: "tool_result",
+            content: typeof result.output === "string" ? result.output : JSON.stringify(result.output),
+            toolCall: {
+              name: result.toolName,
+              params: null
+            },
+            timestamp: Date.now()
+          });
+        } else {
+          enrichedContext.messages.push({
+            role: "error",
+            content: result.error?.message ?? "Unknown tool error",
+            toolCall: {
+              name: result.toolName,
+              params: null
+            },
+            timestamp: Date.now()
+          });
+        }
+        pawRegistry.runObserveHooks(result);
+      }
+    }
+    Object.assign(context, enrichedContext);
+  }
+  if (context.iteration >= config.maxIterations) {
+    logger2.warn(
+      `Task ${task.id} reached max iterations (${config.maxIterations})`
+    );
+    io.notify(
+      `Task reached maximum iterations (${config.maxIterations}). Stopping.`
+    );
+  }
+}
+async function runPerceive(context, pawRegistry, toolRegistry, skillRegistry) {
+  const enriched = { ...context };
+  enriched.availableTools = toolRegistry.summaries();
+  enriched.activeSkills = buildActiveSkills(
+    skillRegistry.list(),
+    toolRegistry
+  );
+  return pawRegistry.runGlobalPerceiveHooks(enriched);
+}
+async function runThink(context, pawRegistry) {
+  try {
+    return await pawRegistry.think(context);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger2.error(`Brain error: ${message}`);
+    context.messages.push({
+      role: "error",
+      content: `Brain error: ${message}`,
+      timestamp: Date.now()
+    });
+    return "BRAIN_ERROR";
+  }
+}
+async function runAct(actions, execution, context, toolRegistry, pawRegistry) {
+  const pawNames = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    const tool = toolRegistry.get(action.tool);
+    if (tool) pawNames.add(tool.pawName);
+  }
+  for (const pawName of pawNames) {
+    await pawRegistry.runLazyPerceive(pawName, context);
+  }
+  if (execution === "parallel") {
+    return Promise.all(
+      actions.map(
+        (action) => executeSingleAction(action, toolRegistry, pawRegistry)
+      )
+    );
+  }
+  const results = [];
+  for (const action of actions) {
+    const result = await executeSingleAction(action, toolRegistry, pawRegistry);
+    results.push(result);
+  }
+  return results;
+}
+async function executeSingleAction(action, toolRegistry, pawRegistry) {
+  const startTime = Date.now();
+  const tool = toolRegistry.get(action.tool);
+  if (!tool) {
+    return failureResult(
+      action.tool,
+      "unknown",
+      createActionError("TOOL_NOT_FOUND", `Tool "${action.tool}" not found`, {
+        toolName: action.tool
+      }),
+      Date.now() - startTime
+    );
+  }
+  if (!tool.inProcess && !pawRegistry.isHealthy(tool.pawName)) {
+    return failureResult(
+      action.tool,
+      tool.pawName,
+      createActionError("PAW_CRASHED", `Paw "${tool.pawName}" is not healthy`, {
+        toolName: action.tool,
+        pawName: tool.pawName
+      }),
+      Date.now() - startTime
+    );
+  }
+  try {
+    if (tool.parameters && typeof tool.parameters.parse === "function") {
+      tool.parameters.parse(action.params);
+    }
+    const output = await tool.execute(action.params);
+    return successResult(action.tool, tool.pawName, output, Date.now() - startTime);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const isTimeout = message.toLowerCase().includes("timeout");
+    const isPermission = message.toLowerCase().includes("permission");
+    const code = isTimeout ? "TOOL_TIMEOUT" : isPermission ? "PERMISSION_DENIED" : "TOOL_EXCEPTION";
+    return failureResult(
+      action.tool,
+      tool.pawName,
+      createActionError(code, message, {
+        toolName: action.tool,
+        pawName: tool.pawName,
+        details: err instanceof Error ? err.stack : void 0
+      }),
+      Date.now() - startTime
+    );
+  }
+}
+
+// src/index.ts
+init_task();
+init_scheduler();
+
+// src/core/rate-limiter.ts
+init_logger();
+var logger5 = createLogger("rate-limiter");
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  /**
+   * Try to consume one token from the bucket.
+   * Returns true if the request is under the limit, false if rate-limited.
+   */
+  tryConsume(bucket, limit, windowMs) {
+    const now = Date.now();
+    this.cleanup(bucket, now, windowMs);
+    const timestamps = this.buckets.get(bucket) ?? [];
+    if (timestamps.length >= limit) {
+      logger5.debug(`Bucket "${bucket}" rate-limited: ${timestamps.length}/${limit} in ${windowMs}ms window`);
+      return false;
+    }
+    timestamps.push(now);
+    this.buckets.set(bucket, timestamps);
+    return true;
+  }
+  /**
+   * Returns the number of remaining tokens in the bucket for the current window.
+   */
+  remaining(bucket, limit, windowMs) {
+    const now = Date.now();
+    this.cleanup(bucket, now, windowMs);
+    const timestamps = this.buckets.get(bucket) ?? [];
+    return Math.max(0, limit - timestamps.length);
+  }
+  /**
+   * Remove expired timestamps from a bucket.
+   */
+  cleanup(bucket, now, windowMs) {
+    const timestamps = this.buckets.get(bucket);
+    if (!timestamps) return;
+    const cutoff = now - windowMs;
+    const filtered = timestamps.filter((t) => t > cutoff);
+    if (filtered.length === 0) {
+      this.buckets.delete(bucket);
+    } else {
+      this.buckets.set(bucket, filtered);
+    }
+  }
+};
+
+// src/index.ts
+init_registry();
+
+// src/paw/registry.ts
+init_manifest();
+
+// src/paw/loader.ts
+import * as path3 from "path";
+import { execa } from "execa";
+
+// src/core/ipc.ts
+init_logger();
+import * as crypto2 from "crypto";
+var logger8 = createLogger("ipc");
+var DEFAULT_TIMEOUT_MS = 3e4;
+var IpcTransport = class {
+  constructor(type, childProcess, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    this.type = type;
+    this.childProcess = childProcess;
+    this.timeoutMs = timeoutMs;
+    if (type === "ipc") {
+      this.setupIpcListeners();
+    } else {
+      this.setupStdioListeners();
+    }
+  }
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  disposed = false;
+  /** Register a handler for incoming requests from the Paw */
+  onRequest(method, handler) {
+    this.handlers.set(method, handler);
+  }
+  /** Send a request to the Paw and wait for a response */
+  async request(method, params) {
+    if (this.disposed) {
+      throw new Error("Transport has been disposed");
+    }
+    const id = crypto2.randomUUID();
+    const message = { jsonrpc: "2.0", id, method, params };
+    logger8.trace("Sending request: %s %s", method, JSON.stringify(params ?? "", null, 2));
+    return new Promise((resolve7, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`IPC request "${method}" timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve: resolve7, reject, timer });
+      this.send(message);
+    });
+  }
+  /** Send a notification (no response expected) */
+  notify(method, params) {
+    if (this.disposed) return;
+    const message = { jsonrpc: "2.0", method, params };
+    this.send(message);
+  }
+  /** Clean up resources */
+  dispose() {
+    this.disposed = true;
+    for (const [, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Transport disposed"));
+    }
+    this.pending.clear();
+    this.handlers.clear();
+  }
+  send(message) {
+    if (this.type === "ipc") {
+      this.childProcess.send?.(message);
+    } else {
+      const json = JSON.stringify(message);
+      const header = `Content-Length: ${Buffer.byteLength(json)}\r
+\r
+`;
+      const stdin = this.childProcess.stdin;
+      if (stdin?.writable) {
+        stdin.write(header + json);
+      }
+    }
+  }
+  handleMessage(msg) {
+    logger8.trace("Received message: %s %s", msg.method ?? msg.id ?? "unknown", JSON.stringify(msg.params ?? msg.result ?? "", null, 2));
+    if (msg.id && this.pending.has(msg.id)) {
+      const pending = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      if (msg.error) {
+        pending.reject(new Error(`${msg.error.message} (code: ${msg.error.code})`));
+      } else {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.method && this.handlers.has(msg.method)) {
+      const handler = this.handlers.get(msg.method);
+      handler(msg.params).then((result) => {
+        if (msg.id) {
+          this.send({ jsonrpc: "2.0", id: msg.id, result });
+        }
+      }).catch((err) => {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        logger8.error('Handler error for "%s": %s', msg.method, errorMessage);
+        if (msg.id) {
+          this.send({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: { code: -32603, message: errorMessage }
+          });
+        }
+      });
+    }
+  }
+  setupIpcListeners() {
+    this.childProcess.on("message", (msg) => {
+      this.handleMessage(msg);
+    });
+  }
+  setupStdioListeners() {
+    const stdout = this.childProcess.stdout;
+    if (!stdout) {
+      logger8.error("No stdout stream available for stdio transport");
+      return;
+    }
+    let buffer = "";
+    stdout.setEncoding("utf-8");
+    stdout.on("data", (chunk) => {
+      buffer += chunk;
+      while (buffer.length > 0) {
+        const headerEnd = buffer.indexOf("\r\n\r\n");
+        if (headerEnd === -1) break;
+        const header = buffer.substring(0, headerEnd);
+        const match = header.match(/Content-Length:\s*(\d+)/i);
+        if (!match) {
+          logger8.error("Invalid header in stdio transport: %s", header);
+          buffer = buffer.substring(headerEnd + 4);
+          continue;
+        }
+        const contentLength = Number.parseInt(match[1], 10);
+        const bodyStart = headerEnd + 4;
+        if (buffer.length < bodyStart + contentLength) break;
+        const body = buffer.substring(bodyStart, bodyStart + contentLength);
+        buffer = buffer.substring(bodyStart + contentLength);
+        try {
+          const msg = JSON.parse(body);
+          this.handleMessage(msg);
+        } catch (err) {
+          logger8.error("Failed to parse stdio JSON-RPC message: %s", err);
+        }
+      }
+    });
+  }
+};
+function createTransport(type, childProcess, timeoutMs) {
+  return new IpcTransport(type, childProcess, timeoutMs);
+}
+
+// src/paw/sandbox.ts
+init_logger();
+var logger9 = createLogger("paw-sandbox");
+function computeEffectivePermissions(manifest, config) {
+  const requested = manifest.permissions ?? { network: [], listen: [], filesystem: [], env: [] };
+  const granted = config.allow;
+  if (!granted) {
+    return {
+      network: requested.network ?? [],
+      listen: requested.listen ?? [],
+      filesystem: requested.filesystem ?? [],
+      env: requested.env ?? []
+    };
+  }
+  return {
+    network: intersectStrings(requested.network ?? [], granted.network ?? []),
+    listen: intersectNumbers(requested.listen ?? [], granted.listen ?? []),
+    filesystem: intersectStrings(requested.filesystem ?? [], granted.filesystem ?? []),
+    env: intersectStrings(requested.env ?? [], granted.env ?? [])
+  };
+}
+function intersectStrings(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => setB.has(item));
+}
+function intersectNumbers(a, b) {
+  const setB = new Set(b);
+  return a.filter((item) => setB.has(item));
+}
+function buildSandboxEnv(permissions) {
+  const env = {
+    // Always pass NODE_ENV and PATH
+    NODE_ENV: process.env.NODE_ENV,
+    PATH: process.env.PATH,
+    // Debug flag
+    VOLE_LOG_LEVEL: process.env.VOLE_LOG_LEVEL
+  };
+  if (permissions.listen.length > 0) {
+    env.VOLE_LISTEN_PORTS = permissions.listen.join(",");
+  }
+  for (const key of permissions.env) {
+    if (process.env[key] !== void 0) {
+      env[key] = process.env[key];
+    } else {
+      logger9.warn(`Env var "${key}" is permitted but not set in environment`);
+    }
+  }
+  return env;
+}
+function validatePermissions(manifest, config) {
+  const warnings = [];
+  const effective = computeEffectivePermissions(manifest, config);
+  const requested = manifest.permissions ?? {};
+  for (const domain of requested.network ?? []) {
+    if (!effective.network.includes(domain)) {
+      warnings.push(
+        `Network access to "${domain}" requested by ${manifest.name} but not granted in config`
+      );
+    }
+  }
+  for (const port of requested.listen ?? []) {
+    if (!effective.listen.includes(port)) {
+      warnings.push(
+        `Listen on port ${port} requested by ${manifest.name} but not granted in config`
+      );
+    }
+  }
+  for (const fspath of requested.filesystem ?? []) {
+    if (!effective.filesystem.includes(fspath)) {
+      warnings.push(
+        `Filesystem access to "${fspath}" requested by ${manifest.name} but not granted in config`
+      );
+    }
+  }
+  for (const envVar of requested.env ?? []) {
+    if (!effective.env.includes(envVar)) {
+      warnings.push(
+        `Env var "${envVar}" requested by ${manifest.name} but not granted in config`
+      );
+    }
+  }
+  if (warnings.length > 0) {
+    for (const w of warnings) {
+      logger9.info(w);
+    }
+  }
+  return warnings;
+}
+
+// src/paw/loader.ts
+init_logger();
+var logger10 = createLogger("paw-loader");
+async function loadInProcessPaw(pawPath, manifest, config) {
+  const entryPath = path3.resolve(pawPath, manifest.entry);
+  logger10.info(`Loading in-process Paw "${manifest.name}" from ${entryPath}`);
+  const module = await import(entryPath);
+  const definition = module.default ?? module;
+  if (definition.onLoad) {
+    await definition.onLoad(config);
+  }
+  return {
+    name: manifest.name,
+    manifest,
+    config,
+    healthy: true,
+    transport: "ipc",
+    inProcess: true,
+    definition
+  };
+}
+async function loadSubprocessPaw(pawPath, manifest, config) {
+  const entryPath = path3.resolve(pawPath, manifest.entry);
+  const transport = manifest.transport ?? "ipc";
+  const permissions = computeEffectivePermissions(manifest, config);
+  const env = buildSandboxEnv(permissions);
+  logger10.info(
+    `Spawning subprocess Paw "${manifest.name}" (transport: ${transport}) from ${entryPath}`
+  );
+  const stdioConfig = transport === "ipc" ? ["pipe", "pipe", "pipe", "ipc"] : ["pipe", "pipe", "pipe"];
+  const child = execa("node", [entryPath], {
+    env,
+    stdio: stdioConfig,
+    reject: false,
+    cleanup: true
+  });
+  child.stderr?.on("data", (data) => {
+    logger10.warn(`[${manifest.name}] ${data.toString().trimEnd()}`);
+  });
+  const ipcTransport = createTransport(transport, child);
+  const instance = {
+    name: manifest.name,
+    manifest,
+    config,
+    healthy: true,
+    transport,
+    inProcess: false,
+    process: {
+      kill: () => child.kill(),
+      pid: child.pid
+    },
+    sendRequest: (method, params) => ipcTransport.request(method, params)
+  };
+  child.then?.((result) => {
+    if (instance.healthy) {
+      instance.healthy = false;
+      logger10.error(
+        `Paw "${manifest.name}" exited unexpectedly (code: ${result.exitCode})`
+      );
+    }
+  }).catch?.(() => {
+    instance.healthy = false;
+  });
+  return { instance, transport: ipcTransport };
+}
+async function shutdownPaw(instance) {
+  if (instance.inProcess) {
+    if (instance.definition?.onUnload) {
+      await instance.definition.onUnload();
+    }
+    return;
+  }
+  if (instance.sendRequest) {
+    try {
+      await Promise.race([
+        instance.sendRequest("shutdown"),
+        new Promise((resolve7) => setTimeout(resolve7, 5e3))
+      ]);
+    } catch {
+      logger10.warn(`Shutdown request to "${instance.name}" failed, killing process`);
+    }
+  }
+  instance.process?.kill();
+  instance.healthy = false;
+}
+
+// src/paw/registry.ts
+init_logger();
+var logger11 = createLogger("paw-registry");
+var PawRegistry = class {
+  constructor(bus, toolRegistry, projectRoot) {
+    this.bus = bus;
+    this.toolRegistry = toolRegistry;
+    this.projectRoot = projectRoot;
+    this.bus.on("paw:crashed", ({ pawName }) => {
+      const instance = this.paws.get(pawName);
+      if (instance) {
+        instance.healthy = false;
+        this.toolRegistry.unregister(pawName);
+      }
+    });
+  }
+  paws = /* @__PURE__ */ new Map();
+  transports = /* @__PURE__ */ new Map();
+  perceiveHooks = [];
+  observeHookPaws = [];
+  bootstrapPaws = [];
+  compactPaws = [];
+  brainPawName;
+  /** Maps config path → manifest name (e.g. "./paws/paw-ollama" → "@openvole/paw-ollama") */
+  configToManifest = /* @__PURE__ */ new Map();
+  skillRegistry;
+  taskQueue;
+  scheduler;
+  /** Inject queryable registries (called after construction to avoid circular deps) */
+  setQuerySources(skills, tasks, scheduler) {
+    this.skillRegistry = skills;
+    this.taskQueue = tasks;
+    this.scheduler = scheduler;
+  }
+  /** Load and register a Paw */
+  async load(config) {
+    const pawPath = resolvePawPath(config.name, this.projectRoot);
+    const manifest = await readPawManifest(pawPath);
+    if (!manifest) {
+      logger11.error(`Failed to read manifest for "${config.name}"`);
+      return false;
+    }
+    const pawName = manifest.name;
+    if (this.paws.has(pawName)) {
+      logger11.warn(`Paw "${pawName}" is already loaded`);
+      return false;
+    }
+    this.configToManifest.set(config.name, pawName);
+    validatePermissions(manifest, config);
+    try {
+      let instance;
+      if (manifest.inProcess) {
+        instance = await loadInProcessPaw(pawPath, manifest, config);
+        this.registerInProcessTools(instance);
+      } else {
+        const result = await loadSubprocessPaw(pawPath, manifest, config);
+        instance = result.instance;
+        this.transports.set(pawName, result.transport);
+        this.setupTransportHandlers(pawName, result.transport);
+        await this.waitForRegistration(pawName, result.transport);
+      }
+      this.paws.set(pawName, instance);
+      if (instance.definition?.hooks?.onPerceive) {
+        const hookConfig = config.hooks?.perceive;
+        const hasTools = (instance.definition?.tools?.length ?? 0) > 0 || manifest.tools.length > 0;
+        this.perceiveHooks.push({
+          pawName,
+          order: hookConfig?.order ?? 100,
+          pipeline: hookConfig?.pipeline ?? true,
+          hasTools
+        });
+        this.perceiveHooks.sort((a, b) => a.order - b.order);
+      }
+      if (instance.definition?.hooks?.onObserve) {
+        this.observeHookPaws.push(pawName);
+      }
+      if (instance.definition?.hooks?.onBootstrap) {
+        this.bootstrapPaws.push(pawName);
+      }
+      if (instance.definition?.hooks?.onCompact) {
+        this.compactPaws.push(pawName);
+      }
+      logger11.info(`Paw "${pawName}" loaded successfully`);
+      this.bus.emit("paw:registered", { pawName });
+      return true;
+    } catch (err) {
+      logger11.error(`Failed to load Paw "${pawName}": ${err}`);
+      return false;
+    }
+  }
+  /** Unload a Paw (accepts config path or manifest name) */
+  async unload(name) {
+    const pawName = this.configToManifest.get(name) ?? name;
+    const instance = this.paws.get(pawName);
+    if (!instance) {
+      logger11.warn(`Paw "${pawName}" is not loaded`);
+      return false;
+    }
+    name = pawName;
+    await shutdownPaw(instance);
+    const transport = this.transports.get(name);
+    if (transport) {
+      transport.dispose();
+      this.transports.delete(name);
+    }
+    this.toolRegistry.unregister(name);
+    this.perceiveHooks = this.perceiveHooks.filter((h) => h.pawName !== name);
+    this.observeHookPaws = this.observeHookPaws.filter((n) => n !== name);
+    this.bootstrapPaws = this.bootstrapPaws.filter((n) => n !== name);
+    this.compactPaws = this.compactPaws.filter((n) => n !== name);
+    this.paws.delete(name);
+    for (const [configName, manifestName] of this.configToManifest) {
+      if (manifestName === name) {
+        this.configToManifest.delete(configName);
+        break;
+      }
+    }
+    logger11.info(`Paw "${name}" unloaded`);
+    this.bus.emit("paw:unregistered", { pawName: name });
+    return true;
+  }
+  /** Resolve a config name to its manifest name */
+  resolveManifestName(configName) {
+    return this.configToManifest.get(configName) ?? configName;
+  }
+  /** Set the Brain Paw name (accepts config path or manifest name) */
+  setBrain(name) {
+    this.brainPawName = this.configToManifest.get(name) ?? name;
+  }
+  /** Get the Brain Paw name */
+  getBrainName() {
+    return this.brainPawName;
+  }
+  /** Get a Paw instance */
+  get(name) {
+    return this.paws.get(name);
+  }
+  /** List all loaded Paws */
+  list() {
+    return Array.from(this.paws.values());
+  }
+  /** Check if a Paw is healthy */
+  isHealthy(name) {
+    return this.paws.get(name)?.healthy ?? false;
+  }
+  /**
+   * Run GLOBAL perceive hooks — only Paws without tools.
+   * Paws with tools use lazy perceive (called just before their tool executes).
+   */
+  async runGlobalPerceiveHooks(context) {
+    let chainedContext = { ...context };
+    const globalChained = this.perceiveHooks.filter((h) => h.pipeline && !h.hasTools);
+    const globalUnchained = this.perceiveHooks.filter((h) => !h.pipeline && !h.hasTools);
+    for (const hook of globalChained) {
+      const instance = this.paws.get(hook.pawName);
+      if (!instance?.healthy) continue;
+      try {
+        chainedContext = await this.callPerceive(hook.pawName, chainedContext);
+      } catch (err) {
+        logger11.error(`Perceive hook error from "${hook.pawName}": ${err}`);
+      }
+    }
+    if (globalUnchained.length > 0) {
+      const results = await Promise.allSettled(
+        globalUnchained.map(async (hook) => {
+          const instance = this.paws.get(hook.pawName);
+          if (!instance?.healthy) return null;
+          try {
+            return await this.callPerceive(hook.pawName, context);
+          } catch (err) {
+            logger11.error(`Unchained perceive error from "${hook.pawName}": ${err}`);
+            return null;
+          }
+        })
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled" && result.value) {
+          Object.assign(chainedContext.metadata, result.value.metadata);
+        }
+      }
+    }
+    return chainedContext;
+  }
+  /**
+   * Run LAZY perceive for a specific Paw — called just before its tool executes.
+   * Only runs if the Paw has an onPerceive hook registered.
+   */
+  async runLazyPerceive(pawName, context) {
+    const hook = this.perceiveHooks.find((h) => h.pawName === pawName && h.hasTools);
+    if (!hook) return context;
+    const instance = this.paws.get(pawName);
+    if (!instance?.healthy) return context;
+    try {
+      logger11.debug(`Lazy perceive for "${pawName}" before tool execution`);
+      return await this.callPerceive(pawName, context);
+    } catch (err) {
+      logger11.error(`Lazy perceive error from "${pawName}": ${err}`);
+      return context;
+    }
+  }
+  /** Run all Observe hooks concurrently (fire-and-forget) */
+  runObserveHooks(result) {
+    for (const pawName of this.observeHookPaws) {
+      const instance = this.paws.get(pawName);
+      if (!instance?.healthy) continue;
+      this.callObserve(pawName, result).catch((err) => {
+        logger11.error(`Observe hook error from "${pawName}": ${err}`);
+      });
+    }
+  }
+  /** Run bootstrap hooks — called once at the start of a task */
+  async runBootstrapHooks(context) {
+    let ctx = { ...context };
+    for (const pawName of this.bootstrapPaws) {
+      const instance = this.paws.get(pawName);
+      if (!instance?.healthy) continue;
+      try {
+        if (instance.inProcess && instance.definition?.hooks?.onBootstrap) {
+          ctx = await instance.definition.hooks.onBootstrap(ctx);
+        } else {
+          const transport = this.transports.get(pawName);
+          if (transport) {
+            ctx = await transport.request("bootstrap", ctx);
+          }
+        }
+      } catch (err) {
+        logger11.error(`Bootstrap hook error from "${pawName}": ${err}`);
+      }
+    }
+    return ctx;
+  }
+  /**
+   * Run compact hooks — called when context exceeds size threshold.
+   * Paws can compress/summarize messages to free up context window space.
+   */
+  async runCompactHooks(context) {
+    let ctx = { ...context };
+    for (const pawName of this.compactPaws) {
+      const instance = this.paws.get(pawName);
+      if (!instance?.healthy) continue;
+      try {
+        if (instance.inProcess && instance.definition?.hooks?.onCompact) {
+          ctx = await instance.definition.hooks.onCompact(ctx);
+        } else {
+          const transport = this.transports.get(pawName);
+          if (transport) {
+            ctx = await transport.request("compact", ctx);
+          }
+        }
+        logger11.info(`Compact hook from "${pawName}" reduced messages from ${context.messages.length} to ${ctx.messages.length}`);
+      } catch (err) {
+        logger11.error(`Compact hook error from "${pawName}": ${err}`);
+      }
+    }
+    return ctx;
+  }
+  /** Call the Brain Paw's think function */
+  async think(context) {
+    if (!this.brainPawName) return null;
+    const instance = this.paws.get(this.brainPawName);
+    if (!instance?.healthy) {
+      logger11.error(`Brain Paw "${this.brainPawName}" is not healthy`);
+      return null;
+    }
+    if (instance.inProcess && instance.definition?.think) {
+      return instance.definition.think(context);
+    }
+    const transport = this.transports.get(this.brainPawName);
+    if (!transport) {
+      logger11.error(`No transport for Brain Paw "${this.brainPawName}"`);
+      return null;
+    }
+    return await transport.request("think", context);
+  }
+  /** Execute a tool on a subprocess Paw */
+  async executeRemoteTool(pawName, toolName, params) {
+    const transport = this.transports.get(pawName);
+    if (!transport) {
+      throw new Error(`No transport for Paw "${pawName}"`);
+    }
+    return transport.request("execute_tool", { toolName, params });
+  }
+  async callPerceive(pawName, context) {
+    const instance = this.paws.get(pawName);
+    if (instance.inProcess && instance.definition?.hooks?.onPerceive) {
+      return instance.definition.hooks.onPerceive(context);
+    }
+    const transport = this.transports.get(pawName);
+    if (transport) {
+      return await transport.request("perceive", context);
+    }
+    return context;
+  }
+  async callObserve(pawName, result) {
+    const instance = this.paws.get(pawName);
+    if (instance.inProcess && instance.definition?.hooks?.onObserve) {
+      await instance.definition.hooks.onObserve(result);
+      return;
+    }
+    const transport = this.transports.get(pawName);
+    if (transport) {
+      await transport.request("observe", result);
+    }
+  }
+  registerInProcessTools(instance) {
+    if (instance.definition?.tools) {
+      this.toolRegistry.register(
+        instance.name,
+        instance.definition.tools,
+        true
+      );
+    }
+  }
+  setupTransportHandlers(pawName, transport) {
+    transport.onRequest("log", async (params) => {
+      const { level, message } = params;
+      const prefix = `[${pawName}]`;
+      switch (level) {
+        case "error":
+          console.error(prefix, message);
+          break;
+        case "warn":
+          console.warn(prefix, message);
+          break;
+        case "info":
+          console.info(prefix, message);
+          break;
+        default:
+          console.debug(prefix, message);
+      }
+      return { ok: true };
+    });
+    transport.onRequest("emit", async (params) => {
+      const { event } = params;
+      logger11.info(`Paw "${pawName}" emitted event: ${event}`);
+      return { ok: true };
+    });
+    transport.onRequest("subscribe", async (params) => {
+      const { events } = params;
+      const instance = this.paws.get(pawName);
+      if (instance) {
+        instance.subscriptions = events;
+        this.setupBusForwarding(pawName, events, transport);
+        logger11.info(`Paw "${pawName}" subscribed to events: ${events.join(", ")}`);
+      }
+      return { ok: true };
+    });
+    transport.onRequest("query", async (params) => {
+      const { type } = params;
+      return this.handleQuery(type);
+    });
+    transport.onRequest("create_task", async (params) => {
+      const { input, source, sessionId, metadata } = params;
+      if (!this.taskQueue) {
+        return { error: "Task queue not available" };
+      }
+      const task = this.taskQueue.enqueue(input, source ?? "paw", { sessionId, metadata });
+      logger11.info(`Paw "${pawName}" created task ${task.id}: "${input.substring(0, 50)}"`);
+      return { taskId: task.id };
+    });
+  }
+  /** Forward bus events to a Paw that subscribed */
+  setupBusForwarding(pawName, events, transport) {
+    for (const eventName of events) {
+      this.bus.on(eventName, (data) => {
+        const instance = this.paws.get(pawName);
+        if (!instance?.healthy) return;
+        transport.notify("bus_event", { event: eventName, data });
+      });
+    }
+  }
+  /** Handle state queries from Paws */
+  handleQuery(type) {
+    switch (type) {
+      case "tools":
+        return this.toolRegistry.list().map((t) => ({
+          name: t.name,
+          description: t.description,
+          pawName: t.pawName,
+          inProcess: t.inProcess
+        }));
+      case "paws":
+        return Array.from(this.paws.values()).map((p) => ({
+          name: p.name,
+          healthy: p.healthy,
+          inProcess: p.inProcess,
+          transport: p.transport,
+          toolCount: this.toolRegistry.toolsForPaw(p.name).length
+        }));
+      case "skills":
+        return this.skillRegistry?.list().map((s) => ({
+          name: s.name,
+          active: s.active,
+          missingTools: s.missingTools,
+          description: s.definition.description
+        })) ?? [];
+      case "tasks":
+        return this.taskQueue?.list().map((t) => ({
+          id: t.id,
+          source: t.source,
+          input: t.input,
+          status: t.status,
+          createdAt: t.createdAt,
+          startedAt: t.startedAt,
+          completedAt: t.completedAt
+        })) ?? [];
+      case "schedules":
+        return this.scheduler?.list() ?? [];
+      default:
+        return { error: `Unknown query type: ${type}` };
+    }
+  }
+  async waitForRegistration(pawName, transport) {
+    return new Promise((resolve7, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Paw "${pawName}" did not register within 10 seconds`));
+      }, 1e4);
+      transport.onRequest("register", async (params) => {
+        clearTimeout(timeout);
+        const registration = params;
+        if (registration.tools) {
+          const toolDefs = registration.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: {},
+            // Schema validated on Paw side
+            execute: async (toolParams) => this.executeRemoteTool(pawName, t.name, toolParams)
+          }));
+          this.toolRegistry.register(pawName, toolDefs, false);
+        }
+        logger11.info(`Paw "${pawName}" registered with ${registration.tools?.length ?? 0} tools`);
+        resolve7();
+        return { ok: true };
+      });
+    });
+  }
+};
+
+// src/index.ts
+init_manifest();
+init_registry2();
+init_resolver();
+
+// src/io/tty.ts
+import * as readline from "readline";
+function createTtyIO() {
+  return {
+    async confirm(message) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      try {
+        return await new Promise((resolve7) => {
+          rl.question(`${message} [y/N] `, (answer) => {
+            resolve7(answer.trim().toLowerCase() === "y");
+          });
+        });
+      } finally {
+        rl.close();
+      }
+    },
+    async prompt(message) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      try {
+        return await new Promise((resolve7) => {
+          rl.question(`${message} `, (answer) => {
+            resolve7(answer.trim());
+          });
+        });
+      } finally {
+        rl.close();
+      }
+    },
+    notify(message) {
+      process.stdout.write(`${message}
+`);
+    }
+  };
+}
+
+// src/index.ts
+init_bus();
+init_registry();
+import * as path7 from "path";
+init_registry2();
+init_task();
+init_config();
+init_scheduler();
+init_core_tools();
+import * as fs6 from "fs/promises";
+var engineLogger = {
+  info: (msg, ...args) => console.info(`[openvole] ${msg}`, ...args),
+  error: (msg, ...args) => console.error(`[openvole] ${msg}`, ...args)
+};
+async function createEngine(projectRoot, options) {
+  const configPath = options?.configPath ?? path7.resolve(projectRoot, "vole.config.ts");
+  const config = await loadConfig(configPath);
+  const bus = createMessageBus();
+  const toolRegistry = new ToolRegistry(bus);
+  const pawRegistry = new PawRegistry(bus, toolRegistry, projectRoot);
+  const skillRegistry = new SkillRegistry(bus, toolRegistry, projectRoot);
+  const io = options?.io ?? createTtyIO();
+  const rateLimiter = new RateLimiter();
+  const taskQueue = new TaskQueue(bus, config.loop.taskConcurrency, rateLimiter, config.loop.rateLimits);
+  const scheduler = new SchedulerStore();
+  const coreTools = createCoreTools(scheduler, taskQueue, projectRoot, skillRegistry);
+  toolRegistry.register("__core__", coreTools, true);
+  pawRegistry.setQuerySources(skillRegistry, taskQueue, scheduler);
+  taskQueue.setRunner(async (task) => {
+    await runAgentLoop(task, {
+      bus,
+      toolRegistry,
+      pawRegistry,
+      skillRegistry,
+      io,
+      config: config.loop,
+      toolProfiles: config.toolProfiles,
+      rateLimiter
+    });
+  });
+  const engine = {
+    bus,
+    toolRegistry,
+    pawRegistry,
+    skillRegistry,
+    taskQueue,
+    io,
+    config,
+    async start() {
+      engineLogger.info("Starting OpenVole...");
+      if (config.brain) {
+      } else {
+        engineLogger.info("No Brain Paw configured \u2014 Think step will be a no-op");
+      }
+      const pawConfigs = config.paws.map(normalizePawConfig);
+      const brainConfig = pawConfigs.find((p) => p.name === config.brain);
+      const subprocessPaws = pawConfigs.filter(
+        (p) => p.name !== config.brain
+      );
+      if (brainConfig) {
+        const ok = await pawRegistry.load(brainConfig);
+        if (ok) {
+          pawRegistry.setBrain(config.brain);
+          engineLogger.info(`Brain Paw: ${pawRegistry.resolveManifestName(config.brain)}`);
+        } else {
+          engineLogger.error(
+            `Brain Paw "${brainConfig.name}" failed to load \u2014 running in no-op Think mode`
+          );
+          pawRegistry.setBrain("");
+        }
+      }
+      for (const pawConfig of subprocessPaws) {
+        await pawRegistry.load(pawConfig);
+      }
+      for (const skillName of config.skills) {
+        await skillRegistry.load(skillName);
+      }
+      skillRegistry.resolve();
+      if (config.heartbeat.enabled) {
+        const heartbeatMdPath = path7.resolve(projectRoot, "HEARTBEAT.md");
+        scheduler.add(
+          "__heartbeat__",
+          "Heartbeat wake-up",
+          config.heartbeat.intervalMinutes,
+          async () => {
+            let heartbeatContent = "";
+            try {
+              heartbeatContent = await fs6.readFile(heartbeatMdPath, "utf-8");
+            } catch {
+            }
+            const input = heartbeatContent ? `Heartbeat wake-up. Review your HEARTBEAT.md jobs and act on what is needed:
+
+${heartbeatContent}` : "Heartbeat wake-up. Check active skills and decide if any actions are needed.";
+            taskQueue.enqueue(input, "heartbeat");
+          }
+        );
+        engineLogger.info(`Heartbeat enabled \u2014 interval: ${config.heartbeat.intervalMinutes}m`);
+      }
+      engineLogger.info(
+        `Ready \u2014 ${toolRegistry.list().length} tools, ${pawRegistry.list().length} paws, ${skillRegistry.active().length}/${skillRegistry.list().length} skills active`
+      );
+    },
+    run(input, source = "user", sessionId) {
+      taskQueue.enqueue(input, source, sessionId ? { sessionId } : void 0);
+    },
+    async shutdown() {
+      engineLogger.info("Shutting down...");
+      scheduler.clearAll();
+      for (const paw of pawRegistry.list()) {
+        await pawRegistry.unload(paw.name);
+      }
+      toolRegistry.clear();
+      engineLogger.info("Shutdown complete");
+    }
+  };
+  return engine;
+}
+
+// src/cli.ts
+init_config();
+init_manifest();
+init_logger();
+var logger14 = createLogger("cli");
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const projectRoot = process.cwd();
+  if (command !== "init" && command !== "help" && command !== "--help" && command !== "-h" && command !== "--version" && command !== "-v" && command !== void 0) {
+    const fsCheck = await import("fs/promises");
+    try {
+      await fsCheck.access(path8.join(projectRoot, "vole.config.json"));
+    } catch {
+      logger14.error("vole.config.json not found in current directory");
+      logger14.info('Run "vole init" to create a new project, or cd to your project root');
+      process.exit(1);
+    }
+  }
+  switch (command) {
+    case "start":
+      await startInteractive(projectRoot);
+      break;
+    case "run": {
+      const input = args.slice(1).join(" ");
+      if (!input) {
+        logger14.error('Usage: vole run "<task>"');
+        process.exit(1);
+      }
+      await runSingle(projectRoot, input);
+      break;
+    }
+    case "init":
+      await initProject(projectRoot);
+      break;
+    case "paw":
+      await handlePawCommand(args.slice(1), projectRoot);
+      break;
+    case "skill":
+      await handleSkillCommand(args.slice(1), projectRoot);
+      break;
+    case "tool":
+      await handleToolCommand(args.slice(1), projectRoot);
+      break;
+    case "task":
+      await handleTaskCommand(args.slice(1), projectRoot);
+      break;
+    case "clawhub":
+      await handleClawHubCommand(args.slice(1), projectRoot);
+      break;
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    case "--version":
+    case "-v":
+      logger14.info("openvole v0.1.0");
+      break;
+    default:
+      logger14.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+function printHelp() {
+  logger14.info(`
+OpenVole \u2014 Micro Agent Core
+
+Usage:
+  vole init                              Initialize a new project
+  vole start                             Start the agent loop (interactive)
+  vole run "<task>"                       Run a single task
+
+Paw management:
+  vole paw create <name>                 Scaffold a new Paw in paws/
+  vole paw list                          List loaded Paws and their tools
+  vole paw add <name>                    Install and register a Paw
+  vole paw remove <name>                 Uninstall and deregister a Paw
+
+Skill management:
+  vole skill create <name>               Scaffold a new Skill in skills/
+  vole skill list                        List Skills and activation status
+  vole skill add <name>                  Install and register a Skill
+  vole skill remove <name>              Uninstall and deregister a Skill
+
+Tool management:
+  vole tool list                         List all registered tools
+  vole tool call <name> [json-params]    Call a tool directly (deterministic, no Brain)
+
+ClawHub (OpenClaw skill registry):
+  vole clawhub install <skill>           Install a skill from ClawHub
+  vole clawhub remove <skill>            Remove a ClawHub-installed skill
+  vole clawhub search <query>            Search for skills on ClawHub
+
+Task management:
+  vole task list                         Show task queue
+  vole task cancel <id>                  Cancel a task
+
+Options:
+  -h, --help                             Show this help
+  -v, --version                          Show version
+`);
+}
+async function startInteractive(projectRoot) {
+  const engine = await createEngine(projectRoot);
+  await engine.start();
+  logger14.info('\nOpenVole is running. Type a task or "exit" to quit.\n');
+  const readline2 = await import("readline");
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const promptUser = () => {
+    rl.question("vole> ", (input) => {
+      const trimmed = input.trim();
+      if (trimmed === "exit" || trimmed === "quit") {
+        rl.close();
+        engine.shutdown().then(() => process.exit(0));
+        return;
+      }
+      if (trimmed) {
+        engine.run(trimmed);
+      }
+      promptUser();
+    });
+  };
+  promptUser();
+  const gracefulShutdown = () => {
+    logger14.info("\nShutting down...");
+    rl.close();
+    engine.shutdown().then(() => process.exit(0));
+  };
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
+}
+async function runSingle(projectRoot, input) {
+  const engine = await createEngine(projectRoot);
+  await engine.start();
+  engine.run(input);
+  return new Promise((resolve7) => {
+    engine.bus.on("task:completed", () => {
+      engine.shutdown().then(resolve7);
+    });
+    engine.bus.on("task:failed", () => {
+      engine.shutdown().then(() => {
+        process.exit(1);
+      });
+    });
+  });
+}
+async function initProject(projectRoot) {
+  const fs7 = await import("fs/promises");
+  const configPath = path8.resolve(projectRoot, "vole.config.json");
+  try {
+    await fs7.access(configPath);
+    logger14.error("vole.config.json already exists");
+    return;
+  } catch {
+  }
+  const config = {
+    paws: [],
+    skills: [],
+    loop: {
+      maxIterations: 10,
+      confirmBeforeAct: true,
+      taskConcurrency: 1,
+      logLevel: "info"
+    }
+  };
+  await fs7.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  logger14.info("Created vole.config.json");
+}
+async function handlePawCommand(args, projectRoot) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole paw create <name>");
+        process.exit(1);
+      }
+      await scaffoldPaw(projectRoot, name);
+      break;
+    }
+    case "list": {
+      const engine = await createEngine(projectRoot);
+      await engine.start();
+      const paws = engine.pawRegistry.list();
+      if (paws.length === 0) {
+        logger14.info("No Paws loaded");
+      } else {
+        logger14.info("PAW                     TOOLS    TYPE         HEALTHY");
+        for (const paw of paws) {
+          const tools = engine.toolRegistry.toolsForPaw(paw.name);
+          const type = paw.inProcess ? "in-process" : "subprocess";
+          const healthy = paw.healthy ? "yes" : "NO";
+          logger14.info(
+            `${paw.name.padEnd(24)}${String(tools.length).padEnd(9)}${type.padEnd(13)}${healthy}`
+          );
+        }
+      }
+      await engine.shutdown();
+      break;
+    }
+    case "add": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole paw add <name>");
+        process.exit(1);
+      }
+      logger14.info(`Installing ${name}...`);
+      const { execa: execaFn } = await import("execa");
+      await execaFn("npm", ["install", name], { cwd: projectRoot, stdio: "inherit" });
+      const pawPath = resolvePawPath(name, projectRoot);
+      const manifest = await readPawManifest(pawPath);
+      if (manifest) {
+        const defaultAllow = manifest.permissions ? {
+          network: manifest.permissions.network,
+          listen: manifest.permissions.listen,
+          filesystem: manifest.permissions.filesystem,
+          env: manifest.permissions.env
+        } : void 0;
+        await addPawToLock(projectRoot, name, manifest.version, defaultAllow);
+        await addPawToConfig(projectRoot, name, defaultAllow);
+        logger14.info(`Added ${name}@${manifest.version} to vole.config.json`);
+        if (manifest.permissions?.listen?.length) {
+          logger14.info(`  listen ports: ${manifest.permissions.listen.join(", ")}`);
+        }
+        if (manifest.tools.length > 0) {
+          logger14.info(`  provides ${manifest.tools.length} tools: ${manifest.tools.map((t) => t.name).join(", ")}`);
+        }
+      } else {
+        logger14.error(`Installed ${name} but could not read vole-paw.json \u2014 add it to vole.config.json manually`);
+      }
+      break;
+    }
+    case "remove": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole paw remove <name>");
+        process.exit(1);
+      }
+      const { execa: execaFn } = await import("execa");
+      await execaFn("npm", ["uninstall", name], { cwd: projectRoot, stdio: "inherit" });
+      await removePawFromLock(projectRoot, name);
+      await removePawFromConfig(projectRoot, name);
+      logger14.info(`Removed ${name} from vole.config.json`);
+      break;
+    }
+    default:
+      logger14.error(`Unknown paw command: ${subcommand}`);
+      logger14.info("Available: list, add, remove");
+      process.exit(1);
+  }
+}
+async function handleSkillCommand(args, projectRoot) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole skill create <name>");
+        process.exit(1);
+      }
+      await scaffoldSkill(projectRoot, name);
+      break;
+    }
+    case "list": {
+      const engine = await createEngine(projectRoot);
+      await engine.start();
+      const skills = engine.skillRegistry.list();
+      if (skills.length === 0) {
+        logger14.info("No Skills loaded");
+      } else {
+        logger14.info("SKILL                          STATUS     MISSING TOOLS");
+        for (const skill of skills) {
+          const status = skill.active ? "active" : "inactive";
+          const missing = skill.missingTools.length > 0 ? skill.missingTools.join(", ") : "\u2014";
+          logger14.info(
+            `${skill.name.padEnd(31)}${status.padEnd(11)}${missing}`
+          );
+        }
+      }
+      await engine.shutdown();
+      break;
+    }
+    case "add": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole skill add <path-to-skill>");
+        process.exit(1);
+      }
+      const skillPath = path8.resolve(projectRoot, name);
+      const { loadSkillFromDirectory: loadSkillFromDirectory2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+      const definition = await loadSkillFromDirectory2(skillPath);
+      if (!definition) {
+        logger14.error(`No valid SKILL.md found at ${skillPath}`);
+        process.exit(1);
+      }
+      await addSkillToLock(projectRoot, name, definition.version ?? "0.0.0");
+      await addSkillToConfig(projectRoot, name);
+      logger14.info(`Added "${definition.name}" to vole.config.json`);
+      if (definition.requiredTools.length > 0) {
+        logger14.info(`  requires tools: ${definition.requiredTools.join(", ")}`);
+      }
+      if (definition.requires?.env.length) {
+        logger14.info(`  requires env: ${definition.requires.env.join(", ")}`);
+      }
+      break;
+    }
+    case "remove": {
+      const name = args[1];
+      if (!name) {
+        logger14.error("Usage: vole skill remove <name>");
+        process.exit(1);
+      }
+      await removeSkillFromLock(projectRoot, name);
+      await removeSkillFromConfig(projectRoot, name);
+      const fsModule = await import("fs/promises");
+      const skillPath = name.startsWith(".") || name.startsWith("/") ? path8.resolve(projectRoot, name) : path8.resolve(projectRoot, ".openvole", "skills", name);
+      try {
+        await fsModule.rm(skillPath, { recursive: true });
+        logger14.info(`Deleted ${skillPath}`);
+      } catch {
+      }
+      logger14.info(`Removed "${name}" from vole.config.json`);
+      break;
+    }
+    default:
+      logger14.error(`Unknown skill command: ${subcommand}`);
+      logger14.info("Available: list, add, remove");
+      process.exit(1);
+  }
+}
+async function handleToolCommand(args, projectRoot) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list": {
+      const config = await (await Promise.resolve().then(() => (init_config(), config_exports))).loadConfig(
+        path8.resolve(projectRoot, "vole.config.json")
+      );
+      const tools = [];
+      const { createMessageBus: createMessageBus2 } = await Promise.resolve().then(() => (init_bus(), bus_exports));
+      const { ToolRegistry: ToolRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+      const { SchedulerStore: SchedulerStore2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+      const { TaskQueue: TaskQueue2 } = await Promise.resolve().then(() => (init_task(), task_exports));
+      const { SkillRegistry: SkillRegistry2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
+      const { createCoreTools: createCoreTools2 } = await Promise.resolve().then(() => (init_core_tools(), core_tools_exports));
+      const bus = createMessageBus2();
+      const toolRegistry = new ToolRegistry2(bus);
+      const skillRegistry = new SkillRegistry2(bus, toolRegistry, projectRoot);
+      const taskQueue = new TaskQueue2(bus, 1);
+      const scheduler = new SchedulerStore2();
+      const coreTools = createCoreTools2(scheduler, taskQueue, projectRoot, skillRegistry);
+      toolRegistry.register("__core__", coreTools, true);
+      for (const entry of toolRegistry.list()) {
+        tools.push({ name: entry.name, pawName: entry.pawName, type: "in-process" });
+      }
+      const { normalizePawConfig: normalizePawConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const { readPawManifest: readPawManifest2, resolvePawPath: resolvePawPath2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      for (const pawEntry of config.paws) {
+        const pawConfig = normalizePawConfig2(pawEntry);
+        const pawPath = resolvePawPath2(pawConfig.name, projectRoot);
+        const manifest = await readPawManifest2(pawPath);
+        if (manifest?.tools) {
+          for (const t of manifest.tools) {
+            tools.push({
+              name: t.name,
+              pawName: pawConfig.name,
+              type: manifest.inProcess ? "in-process" : "subprocess"
+            });
+          }
+        }
+      }
+      if (tools.length === 0) {
+        logger14.info("No tools registered");
+      } else {
+        logger14.info("TOOL                 PAW                    TYPE");
+        for (const tool of tools) {
+          logger14.info(
+            `${tool.name.padEnd(21)}${tool.pawName.padEnd(23)}${tool.type}`
+          );
+        }
+      }
+      break;
+    }
+    case "call": {
+      const toolName = args[1];
+      const paramsJson = args[2];
+      if (!toolName) {
+        logger14.error("Usage: vole tool call <tool-name> [json-params]");
+        process.exit(1);
+      }
+      let params = {};
+      if (paramsJson) {
+        try {
+          params = JSON.parse(paramsJson);
+        } catch {
+          logger14.error("Invalid JSON params");
+          process.exit(1);
+        }
+      }
+      const engine = await createEngine(projectRoot);
+      await engine.start();
+      const tool = engine.toolRegistry.get(toolName);
+      if (!tool) {
+        logger14.error(`Tool "${toolName}" not found`);
+        logger14.info('Run "vole tool list" to see available tools');
+        await engine.shutdown();
+        process.exit(1);
+      }
+      try {
+        if (tool.parameters && typeof tool.parameters.parse === "function") {
+          tool.parameters.parse(params);
+        }
+        const result = await tool.execute(params);
+        console.log(JSON.stringify(result, null, 2));
+      } catch (err) {
+        logger14.error(`Tool execution failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+      }
+      await engine.shutdown();
+      break;
+    }
+    default:
+      logger14.error(`Unknown tool command: ${subcommand}`);
+      logger14.info("Available: list, call");
+      process.exit(1);
+  }
+}
+async function handleTaskCommand(args, _projectRoot) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+      logger14.info("Task list requires a running vole instance.");
+      break;
+    case "cancel": {
+      const id = args[1];
+      if (!id) {
+        logger14.error("Usage: vole task cancel <id>");
+        process.exit(1);
+      }
+      logger14.info("Task cancellation requires a running vole instance.");
+      break;
+    }
+    default:
+      logger14.error(`Unknown task command: ${subcommand}`);
+      logger14.info("Available: list, cancel");
+      process.exit(1);
+  }
+}
+async function ask(question) {
+  const rl = (await import("readline")).createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve7) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve7(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const answer = await ask(`${question} [y/N] `);
+  return answer.toLowerCase() === "y";
+}
+async function askList(question) {
+  const answer = await ask(question);
+  if (!answer) return [];
+  return answer.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function scaffoldPaw(projectRoot, name) {
+  const fs7 = await import("fs/promises");
+  const pawName = name.startsWith("paw-") ? name : `paw-${name}`;
+  const pawDir = path8.resolve(projectRoot, "paws", pawName);
+  try {
+    await fs7.access(pawDir);
+    logger14.error(`Directory paws/${pawName} already exists`);
+    process.exit(1);
+  } catch {
+  }
+  logger14.info(`
+Creating Paw: ${pawName}
+`);
+  const description = await ask("Description: ");
+  const tools = [];
+  logger14.info("\nTools are actions the agent can perform (e.g., send_email, search_docs).");
+  if (await confirm("Add tools?")) {
+    let addMore = true;
+    while (addMore) {
+      const toolName = await ask("  Tool name (e.g., send_message): ");
+      if (!toolName) break;
+      const toolDesc = await ask("  Tool description: ");
+      tools.push({ name: toolName, description: toolDesc });
+      addMore = await confirm("  Add another tool?");
+    }
+  }
+  logger14.info("\nHooks let your Paw react to agent activity automatically.");
+  const wantObserve = await confirm("Log every tool execution? (observe hook)");
+  const wantPerceive = await confirm("Inject context before the agent thinks? (perceive hook)");
+  logger14.info("\nPermissions control what this Paw can access.");
+  const networkDomains = await askList("Network domains (comma-separated, e.g., api.telegram.org): ");
+  const listenPorts = (await askList("Ports to listen on (comma-separated, e.g., 3000): ")).map(Number).filter((n) => !Number.isNaN(n));
+  const envVars = await askList("Env variables needed (comma-separated, e.g., TELEGRAM_TOKEN): ");
+  logger14.info("");
+  await fs7.mkdir(path8.join(pawDir, "src"), { recursive: true });
+  await fs7.writeFile(
+    path8.join(pawDir, "vole-paw.json"),
+    JSON.stringify(
+      {
+        name: pawName,
+        version: "0.1.0",
+        description,
+        entry: "./dist/index.js",
+        brain: false,
+        inProcess: false,
+        transport: "ipc",
+        tools: tools.map((t) => ({ name: t.name, description: t.description })),
+        permissions: {
+          network: networkDomains,
+          listen: listenPorts,
+          filesystem: [],
+          env: envVars
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await fs7.writeFile(
+    path8.join(pawDir, "package.json"),
+    JSON.stringify(
+      {
+        name: pawName,
+        version: "0.1.0",
+        description,
+        type: "module",
+        main: "./dist/index.js",
+        scripts: {
+          build: "tsup",
+          typecheck: "tsc --noEmit"
+        },
+        dependencies: {
+          "@openvole/paw-sdk": "workspace:*"
+        },
+        devDependencies: {
+          "@types/node": "^22.0.0",
+          tsup: "^8.3.0",
+          typescript: "^5.6.0"
+        }
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await fs7.writeFile(
+    path8.join(pawDir, "tsconfig.json"),
+    JSON.stringify(
+      {
+        extends: "../../tsconfig.base.json",
+        compilerOptions: { outDir: "./dist", rootDir: "./src" },
+        include: ["src/**/*.ts"]
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  await fs7.writeFile(
+    path8.join(pawDir, "tsup.config.ts"),
+    `import { defineConfig } from 'tsup'
+
+export default defineConfig({
+	entry: ['src/index.ts'],
+	format: ['esm'],
+	dts: true,
+	clean: true,
+	sourcemap: true,
+	target: 'node20',
+	splitting: false,
+})
+`
+  );
+  await fs7.writeFile(
+    path8.join(pawDir, "src", "index.ts"),
+    `import { definePaw } from '@openvole/paw-sdk'
+import { paw } from './paw.js'
+
+export default definePaw(paw)
+`
+  );
+  const toolsCode = tools.length > 0 ? tools.map((t) => `		{
+			name: '${t.name}',
+			description: '${t.description.replace(/'/g, "\\'")}',
+			parameters: z.object({
+				// Define your parameters here
+			}),
+			async execute(params) {
+				// TODO: implement ${t.name}
+				throw new Error('Not implemented')
+			},
+		},`).join("\n") : "";
+  let hooksCode = "";
+  if (wantObserve || wantPerceive) {
+    const hookParts = [];
+    if (wantObserve) {
+      hookParts.push(`		onObserve: async (result) => {
+			const status = result.success ? 'OK' : 'FAIL'
+			console.log(\`[${pawName}] \${result.toolName} \u2192 \${status} (\${result.durationMs}ms)\`)
+		},`);
+    }
+    if (wantPerceive) {
+      hookParts.push(`		onPerceive: async (context) => {
+			// Add data to context.metadata before the agent thinks
+			// context.metadata.myData = { ... }
+			return context
+		},`);
+    }
+    hooksCode = `
+	hooks: {
+${hookParts.join("\n")}
+	},
+`;
+  }
+  await fs7.writeFile(
+    path8.join(pawDir, "src", "paw.ts"),
+    `import { z, type PawDefinition } from '@openvole/paw-sdk'
+
+export const paw: PawDefinition = {
+	name: '${pawName}',
+	version: '0.1.0',
+	description: '${description.replace(/'/g, "\\'")}',
+
+	tools: [
+${toolsCode}
+	],
+${hooksCode}
+	async onLoad() {
+		console.log('[${pawName}] loaded')
+	},
+
+	async onUnload() {
+		console.log('[${pawName}] unloaded')
+	},
+}
+`
+  );
+  const allow = {};
+  if (networkDomains.length > 0) allow.network = networkDomains;
+  if (listenPorts.length > 0) allow.listen = listenPorts;
+  if (envVars.length > 0) allow.env = envVars;
+  await addPawToLock(
+    projectRoot,
+    `./paws/${pawName}`,
+    "0.1.0",
+    Object.keys(allow).length > 0 ? allow : void 0
+  );
+  logger14.info(`Created paws/${pawName}/`);
+  logger14.info(`Registered in vole.lock.json`);
+  if (tools.length > 0) {
+    logger14.info(`Generated ${tools.length} tool${tools.length > 1 ? "s" : ""}: ${tools.map((t) => t.name).join(", ")}`);
+  }
+  logger14.info("");
+  logger14.info("Next: implement your tool logic in src/paw.ts, then build:");
+  logger14.info("  pnpm install && pnpm build");
+}
+async function scaffoldSkill(projectRoot, name) {
+  const fs7 = await import("fs/promises");
+  const skillName = name.startsWith("skill-") ? name : `skill-${name}`;
+  const skillDir = path8.resolve(projectRoot, ".openvole", "skills", skillName);
+  try {
+    await fs7.access(skillDir);
+    logger14.error(`Skill "${skillName}" already exists`);
+    process.exit(1);
+  } catch {
+  }
+  logger14.info(`
+Creating Skill: ${skillName}
+`);
+  const description = await ask("Description: ");
+  logger14.info("\nSkills describe behavior \u2014 what the agent should do, using tools provided by Paws.");
+  const requiredTools = await askList("Required tools (comma-separated, e.g., email_search, email_send): ");
+  const optionalTools = await askList("Optional tools (comma-separated, or empty): ");
+  const tags = await askList("Tags (comma-separated, e.g., email, productivity): ");
+  logger14.info("");
+  const instructions = await ask("Instructions (what should the agent do?): ");
+  logger14.info("");
+  await fs7.mkdir(skillDir, { recursive: true });
+  const frontmatterLines = [
+    `name: ${skillName}`,
+    `description: "${description.replace(/"/g, '\\"')}"`
+  ];
+  if (requiredTools.length > 0) {
+    frontmatterLines.push("requiredTools:");
+    for (const t of requiredTools) {
+      frontmatterLines.push(`  - ${t}`);
+    }
+  }
+  if (optionalTools.length > 0) {
+    frontmatterLines.push("optionalTools:");
+    for (const t of optionalTools) {
+      frontmatterLines.push(`  - ${t}`);
+    }
+  }
+  if (tags.length > 0) {
+    frontmatterLines.push("tags:");
+    for (const t of tags) {
+      frontmatterLines.push(`  - ${t}`);
+    }
+  }
+  const skillMd = `---
+${frontmatterLines.join("\n")}
+---
+
+# ${skillName}
+
+${instructions}
+`;
+  await fs7.writeFile(path8.join(skillDir, "SKILL.md"), skillMd);
+  await addSkillToLock(projectRoot, skillName, "0.1.0");
+  await addSkillToConfig(projectRoot, skillName);
+  logger14.info(`Created .openvole/skills/${skillName}/`);
+  logger14.info(`  SKILL.md \u2014 edit to refine instructions`);
+  logger14.info(`Added to vole.config.json`);
+  if (requiredTools.length > 0) {
+    logger14.info(`Requires tools: ${requiredTools.join(", ")}`);
+  }
+}
+async function handleClawHubCommand(args, projectRoot) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "install": {
+      const skillName = args[1];
+      if (!skillName) {
+        logger14.error("Usage: vole clawhub install <skill-name>");
+        process.exit(1);
+      }
+      const fsModule = await import("fs/promises");
+      const clawHubDir = path8.resolve(projectRoot, ".openvole", "skills", "clawhub");
+      await fsModule.mkdir(clawHubDir, { recursive: true });
+      logger14.info(`Installing "${skillName}" from ClawHub...`);
+      const { execa: execaFn } = await import("execa");
+      try {
+        await execaFn("npx", ["clawhub", "install", skillName, "--dir", clawHubDir], {
+          cwd: projectRoot,
+          stdio: "inherit"
+        });
+      } catch {
+        logger14.error(`Failed to install "${skillName}" from ClawHub`);
+        process.exit(1);
+      }
+      const installed = await fsModule.readdir(clawHubDir).catch(() => []);
+      const skillDir = installed.find((d) => d === skillName || d.includes(skillName));
+      if (!skillDir) {
+        logger14.error(`Skill installed but directory not found in .openvole/skills/clawhub/`);
+        process.exit(1);
+      }
+      const localPath = `clawhub/${skillDir}`;
+      const { loadSkillFromDirectory: loadSkillFromDirectory2 } = await Promise.resolve().then(() => (init_loader(), loader_exports));
+      const definition = await loadSkillFromDirectory2(path8.resolve(projectRoot, ".openvole", "skills", "clawhub", skillDir));
+      if (definition) {
+        await addSkillToLock(projectRoot, localPath, definition.version ?? "0.0.0");
+        await addSkillToConfig(projectRoot, localPath);
+        logger14.info(`Added "${definition.name}" to vole.config.json`);
+        if (definition.requiredTools.length > 0) {
+          logger14.info(`  requires tools: ${definition.requiredTools.join(", ")}`);
+        }
+        if (definition.requires?.env.length) {
+          logger14.info(`  requires env: ${definition.requires.env.join(", ")}`);
+        }
+      } else {
+        logger14.warn(`Installed "${skillName}" but could not parse SKILL.md \u2014 add to vole.config.json manually`);
+      }
+      break;
+    }
+    case "search": {
+      const query = args.slice(1).join(" ");
+      if (!query) {
+        logger14.error("Usage: vole clawhub search <query>");
+        process.exit(1);
+      }
+      const { execa: execaFn } = await import("execa");
+      try {
+        await execaFn("npx", ["clawhub", "search", query], {
+          cwd: projectRoot,
+          stdio: "inherit"
+        });
+      } catch {
+        logger14.error("Search failed \u2014 make sure clawhub is available (npx clawhub)");
+      }
+      break;
+    }
+    case "remove": {
+      const skillName = args[1];
+      if (!skillName) {
+        logger14.error("Usage: vole clawhub remove <skill-name>");
+        process.exit(1);
+      }
+      const fsModule = await import("fs/promises");
+      const skillPath = path8.resolve(projectRoot, ".openvole", "skills", "clawhub", skillName);
+      try {
+        await fsModule.rm(skillPath, { recursive: true });
+        logger14.info(`Deleted .openvole/skills/clawhub/${skillName}`);
+      } catch {
+        logger14.error(`Skill directory not found: .openvole/skills/clawhub/${skillName}`);
+        process.exit(1);
+      }
+      await removeSkillFromLock(projectRoot, `clawhub/${skillName}`);
+      await removeSkillFromConfig(projectRoot, `clawhub/${skillName}`);
+      logger14.info(`Removed "${skillName}" from vole.config.json`);
+      break;
+    }
+    default:
+      logger14.error(`Unknown clawhub command: ${subcommand}`);
+      logger14.info("Available: install, remove, search");
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map