openvole 0.1.0

package/dist/index.js

@@ -0,0 +1,2242 @@
+// src/config/index.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var DEFAULT_LOOP_CONFIG = {
+  maxIterations: 10,
+  confirmBeforeAct: true,
+  taskConcurrency: 1,
+  compactThreshold: 50,
+  logLevel: "info",
+  rateLimits: void 0
+};
+var DEFAULT_HEARTBEAT_CONFIG = {
+  enabled: false,
+  intervalMinutes: 30
+};
+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);
+}
+
+// src/core/bus.ts
+import mitt from "mitt";
+function createMessageBus() {
+  return mitt();
+}
+
+// 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/skill/resolver.ts
+import { execFileSync } from "child_process";
+
+// src/core/logger.ts
+var LEVELS = { error: 0, warn: 1, info: 2, debug: 3, trace: 4 };
+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)
+  };
+}
+
+// src/skill/resolver.ts
+var logger = createLogger("skill-resolver");
+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;
+  }
+}
+
+// src/core/hooks.ts
+var PHASE_ORDER = [
+  "perceive",
+  "think",
+  "act",
+  "observe"
+];
+
+// src/core/loop.ts
+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/core/task.ts
+import * as crypto from "crypto";
+var logger3 = createLogger("task-queue");
+var 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 logger4 = createLogger("scheduler");
+var 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/core/rate-limiter.ts
+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/tool/registry.ts
+var logger6 = createLogger("tool-registry");
+var 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
+import * as fs2 from "fs/promises";
+import { accessSync } from "fs";
+import * as path2 from "path";
+import { z } from "zod";
+var logger7 = createLogger("paw-manifest");
+var 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({})
+});
+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;
+  }
+}
+
+// src/paw/loader.ts
+import * as path3 from "path";
+import { execa } from "execa";
+
+// src/core/ipc.ts
+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((resolve6, 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: resolve6, 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
+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
+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((resolve6) => setTimeout(resolve6, 5e3))
+      ]);
+    } catch {
+      logger10.warn(`Shutdown request to "${instance.name}" failed, killing process`);
+    }
+  }
+  instance.process?.kill();
+  instance.healthy = false;
+}
+
+// src/paw/registry.ts
+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((resolve6, 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`);
+        resolve6();
+        return { ok: true };
+      });
+    });
+  }
+};
+
+// src/skill/registry.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+
+// src/skill/loader.ts
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
+import { parse as parseYaml } from "yaml";
+var logger12 = createLogger("skill-loader");
+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 [];
+}
+
+// src/skill/registry.ts
+var logger13 = createLogger("skill-registry");
+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 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/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((resolve6) => {
+          rl.question(`${message} [y/N] `, (answer) => {
+            resolve6(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((resolve6) => {
+          rl.question(`${message} `, (answer) => {
+            resolve6(answer.trim());
+          });
+        });
+      } finally {
+        rl.close();
+      }
+    },
+    notify(message) {
+      process.stdout.write(`${message}
+`);
+    }
+  };
+}
+
+// src/index.ts
+import * as path7 from "path";
+import * as fs6 from "fs/promises";
+
+// src/tool/core-tools.ts
+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;
+}
+
+// src/index.ts
+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;
+}
+export {
+  PHASE_ORDER,
+  PawRegistry,
+  RateLimiter,
+  SchedulerStore,
+  SkillRegistry,
+  TaskQueue,
+  ToolRegistry,
+  addPawToLock,
+  addSkillToLock,
+  buildActiveSkills,
+  computeEffectivePermissions,
+  createActionError,
+  createAgentContext,
+  createEngine,
+  createMessageBus,
+  createTtyIO,
+  defineConfig,
+  failureResult,
+  loadConfig,
+  readLockFile,
+  readPawManifest,
+  removePawFromLock,
+  removeSkillFromLock,
+  resolvePawPath,
+  resolveSkills,
+  runAgentLoop,
+  successResult,
+  validatePermissions,
+  writeLockFile
+};
+//# sourceMappingURL=index.js.map