va-claw 0.1.0 → 0.1.2

package/dist/va-claw-bundle.mjs

@@ -0,0 +1,2816 @@
+#!/usr/bin/env node
+
+// packages/cli/dist/deps.js
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { readFile as readFile4 } from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline/promises";
+
+// packages/identity/dist/path.js
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+var DEFAULT_CONFIG_PATH = resolve(homedir(), ".va-claw", "config.json");
+function resolveConfigPath(configPath) {
+  if (!configPath || configPath.trim() === "") {
+    return DEFAULT_CONFIG_PATH;
+  }
+  if (configPath === "~") {
+    return homedir();
+  }
+  if (configPath.startsWith("~/")) {
+    return resolve(homedir(), configPath.slice(2));
+  }
+  return resolve(configPath);
+}
+
+// packages/identity/dist/storage.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// packages/identity/dist/defaults.js
+var DEFAULT_LOOP_INTERVAL = "0 * * * *";
+var DEFAULT_CONFIG = {
+  name: "va-claw",
+  persona: "A pragmatic CLI identity that values clarity, rigor, and continuity.",
+  systemPrompt: "You are va-claw. Be direct, honest about uncertainty, and keep actions aligned with the saved identity.",
+  wakePrompt: "Wake up, load the saved identity, and continue from the most recent remembered state.",
+  loopInterval: DEFAULT_LOOP_INTERVAL,
+  channels: {
+    discord: {
+      token: "",
+      clientId: "",
+      cliCommand: "",
+      autoStart: false
+    },
+    telegram: {
+      token: "",
+      cliCommand: ""
+    },
+    slack: {
+      botToken: "",
+      appToken: "",
+      cliCommand: ""
+    }
+  }
+};
+function pickString(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function pickBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function getDefaultIdentity() {
+  return { ...DEFAULT_CONFIG };
+}
+function normalizeConfig(input) {
+  const base = getDefaultIdentity();
+  const data = input && typeof input === "object" ? input : {};
+  const channels = readObject(Reflect.get(data, "channels"));
+  const discord = readObject(Reflect.get(channels, "discord"));
+  const telegram = readObject(Reflect.get(channels, "telegram"));
+  const slack = readObject(Reflect.get(channels, "slack"));
+  return {
+    name: pickString(Reflect.get(data, "name"), base.name),
+    persona: pickString(Reflect.get(data, "persona"), base.persona),
+    systemPrompt: pickString(Reflect.get(data, "systemPrompt"), base.systemPrompt),
+    wakePrompt: pickString(Reflect.get(data, "wakePrompt"), base.wakePrompt),
+    loopInterval: pickString(Reflect.get(data, "loopInterval"), base.loopInterval),
+    channels: {
+      discord: {
+        token: pickString(Reflect.get(discord, "token"), base.channels.discord.token),
+        clientId: pickString(Reflect.get(discord, "clientId"), base.channels.discord.clientId),
+        cliCommand: pickString(Reflect.get(discord, "cliCommand"), base.channels.discord.cliCommand),
+        autoStart: pickBoolean(Reflect.get(discord, "autoStart"), base.channels.discord.autoStart)
+      },
+      telegram: {
+        token: pickString(Reflect.get(telegram, "token"), base.channels.telegram.token),
+        cliCommand: pickString(Reflect.get(telegram, "cliCommand"), base.channels.telegram.cliCommand)
+      },
+      slack: {
+        botToken: pickString(Reflect.get(slack, "botToken"), base.channels.slack.botToken),
+        appToken: pickString(Reflect.get(slack, "appToken"), base.channels.slack.appToken),
+        cliCommand: pickString(Reflect.get(slack, "cliCommand"), base.channels.slack.cliCommand)
+      }
+    }
+  };
+}
+function readObject(value) {
+  return value && typeof value === "object" ? value : {};
+}
+
+// packages/identity/dist/storage.js
+async function loadIdentity(configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  try {
+    const raw = await readFile(resolvedPath, "utf8");
+    return normalizeConfig(JSON.parse(raw));
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return getDefaultIdentity();
+    }
+    throw error;
+  }
+}
+async function saveIdentity(config, configPath) {
+  const resolvedPath = resolveConfigPath(configPath);
+  const normalized = normalizeConfig(config);
+  await mkdir(dirname(resolvedPath), { recursive: true });
+  await writeFile(resolvedPath, `${JSON.stringify(normalized, null, 2)}
+`, "utf8");
+}
+function isMissingFileError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// packages/identity/dist/render.js
+function textBlock(label, value) {
+  return [label, "~~~text", value || "(empty)", "~~~"].join("\n");
+}
+function toClaudeMdSnippet(config) {
+  const normalized = normalizeConfig(config);
+  return [
+    "<!-- va-claw:identity:start -->",
+    "## VaClaw Identity",
+    `- Name: ${normalized.name}`,
+    "",
+    "Persona:",
+    normalized.persona,
+    "",
+    textBlock("System Prompt:", normalized.systemPrompt),
+    "<!-- va-claw:identity:end -->"
+  ].join("\n");
+}
+function toCodexSystemPrompt(config) {
+  const normalized = normalizeConfig(config);
+  return [
+    `Identity name: ${normalized.name}`,
+    `Persona: ${normalized.persona}`,
+    "",
+    "System prompt:",
+    normalized.systemPrompt,
+    "",
+    "Wake prompt:",
+    normalized.wakePrompt,
+    "",
+    `Loop interval: ${normalized.loopInterval}`
+  ].join("\n");
+}
+
+// node_modules/.pnpm/@clack+prompts@file+packages+identity+vendor+clack-prompts/node_modules/@clack/prompts/index.js
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+var CANCEL = /* @__PURE__ */ Symbol("clack-cancel");
+function intro(title = "") {
+  if (title) {
+    stdout.write(`
+${title}
+`);
+  }
+}
+function note(message = "", title = "") {
+  const prefix = title ? `${title}: ` : "";
+  stdout.write(`${prefix}${message}
+`);
+}
+function outro(message = "") {
+  if (message) {
+    stdout.write(`${message}
+`);
+  }
+}
+function cancel(message = "") {
+  if (message) {
+    stdout.write(`${message}
+`);
+  }
+}
+function isCancel(value) {
+  return value === CANCEL;
+}
+async function text({ message, initialValue = "", validate }) {
+  const rl = createInterface({ input: stdin, output: stdout });
+  while (true) {
+    const suffix = initialValue ? ` [${initialValue}]` : "";
+    const answer = await rl.question(`${message}${suffix}: `);
+    const value = answer === "" ? initialValue : answer;
+    if (value.toLowerCase() === ":cancel") {
+      rl.close();
+      return CANCEL;
+    }
+    const error = validate?.(value);
+    if (!error) {
+      rl.close();
+      return value;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    stdout.write(`${detail}
+`);
+  }
+}
+
+// packages/identity/dist/wizard.js
+async function runInstallWizard() {
+  const current = normalizeConfig(await loadIdentity());
+  intro("va-claw identity setup");
+  note(DEFAULT_CONFIG_PATH, "Config path");
+  const config = normalizeConfig({
+    name: await ask("Name", current.name, true),
+    persona: await ask("Persona", current.persona, true),
+    systemPrompt: await ask("System prompt", current.systemPrompt, false),
+    wakePrompt: await ask("Wake prompt", current.wakePrompt, false),
+    loopInterval: await ask("Loop interval (cron)", current.loopInterval, true)
+  });
+  await saveIdentity(config);
+  outro(`Saved identity to ${DEFAULT_CONFIG_PATH}`);
+  return config;
+}
+async function ask(message, initialValue, required) {
+  const value = await text({
+    message,
+    initialValue,
+    validate(input) {
+      if (!required || input.trim() !== "") {
+        return void 0;
+      }
+      return `${message} is required.`;
+    }
+  });
+  if (isCancel(value)) {
+    cancel("Identity setup cancelled.");
+    throw new Error("Identity setup cancelled.");
+  }
+  return value;
+}
+
+// packages/daemon/dist/cli-adapter.js
+import { spawnSync } from "node:child_process";
+var DEFAULT_WARN = (message) => console.warn(message);
+var CLI_CANDIDATES = ["claude-copilot", "claude", "codex"];
+async function detectCliAdapter(deps = {}) {
+  const runWhich = deps.runWhich ?? whichCommandExists;
+  const configuredCommand = readEnv(deps.env).VA_CLAW_CLI?.trim();
+  if (configuredCommand) {
+    return toCliAdapter(configuredCommand, configuredCommand);
+  }
+  for (const name of CLI_CANDIDATES) {
+    const command = runWhich(name);
+    if (command) {
+      return toCliAdapter(name, command);
+    }
+  }
+  (deps.warn ?? DEFAULT_WARN)("[va-claw/daemon] no supported CLI is available in PATH; skipping wake.");
+  return null;
+}
+function whichCommandExists(command) {
+  const result = spawnSync("which", [command], { encoding: "utf8" });
+  const resolved = typeof result.stdout === "string" ? result.stdout.trim() : "";
+  return result.status === 0 && resolved !== "" ? resolved : null;
+}
+function toCliAdapter(name, command) {
+  return { name, command, args: name === "codex" ? ["exec", "--full-auto"] : ["-p"] };
+}
+function readEnv(env) {
+  return env ?? (process.env ?? {});
+}
+
+// node_modules/.pnpm/croner@file+vendor+croner/node_modules/croner/dist/croner.js
+function T(s2) {
+  return Date.UTC(s2.y, s2.m - 1, s2.d, s2.h, s2.i, s2.s);
+}
+function D(s2, e) {
+  return s2.y === e.y && s2.m === e.m && s2.d === e.d && s2.h === e.h && s2.i === e.i && s2.s === e.s;
+}
+function A(s2, e) {
+  let t = new Date(Date.parse(s2));
+  if (isNaN(t)) throw new Error("Invalid ISO8601 passed to timezone parser.");
+  let r = s2.substring(9);
+  return r.includes("Z") || r.includes("+") || r.includes("-") ? b(t.getUTCFullYear(), t.getUTCMonth() + 1, t.getUTCDate(), t.getUTCHours(), t.getUTCMinutes(), t.getUTCSeconds(), "Etc/UTC") : b(t.getFullYear(), t.getMonth() + 1, t.getDate(), t.getHours(), t.getMinutes(), t.getSeconds(), e);
+}
+function v(s2, e, t) {
+  return k(A(s2, e), t);
+}
+function k(s2, e) {
+  let t = new Date(T(s2)), r = g(t, s2.tz), n = T(s2), i = T(r), a = n - i, o = new Date(t.getTime() + a), h = g(o, s2.tz);
+  if (D(h, s2)) {
+    let u = new Date(o.getTime() - 36e5), d = g(u, s2.tz);
+    return D(d, s2) ? u : o;
+  }
+  let l = new Date(o.getTime() + T(s2) - T(h)), y = g(l, s2.tz);
+  if (D(y, s2)) return l;
+  if (e) throw new Error("Invalid date passed to fromTZ()");
+  return o.getTime() > l.getTime() ? o : l;
+}
+function g(s2, e) {
+  let t, r;
+  try {
+    t = new Intl.DateTimeFormat("en-US", { timeZone: e, year: "numeric", month: "numeric", day: "numeric", hour: "numeric", minute: "numeric", second: "numeric", hour12: false }), r = t.formatToParts(s2);
+  } catch (i) {
+    let a = i instanceof Error ? i.message : String(i);
+    throw new RangeError(`toTZ: Invalid timezone '${e}' or date. Please provide a valid IANA timezone (e.g., 'America/New_York', 'Europe/Stockholm'). Original error: ${a}`);
+  }
+  let n = { year: 0, month: 0, day: 0, hour: 0, minute: 0, second: 0 };
+  for (let i of r) (i.type === "year" || i.type === "month" || i.type === "day" || i.type === "hour" || i.type === "minute" || i.type === "second") && (n[i.type] = parseInt(i.value, 10));
+  if (isNaN(n.year) || isNaN(n.month) || isNaN(n.day) || isNaN(n.hour) || isNaN(n.minute) || isNaN(n.second)) throw new Error(`toTZ: Failed to parse all date components from timezone '${e}'. This may indicate an invalid date or timezone configuration. Parsed components: ${JSON.stringify(n)}`);
+  return n.hour === 24 && (n.hour = 0), { y: n.year, m: n.month, d: n.day, h: n.hour, i: n.minute, s: n.second, tz: e };
+}
+function b(s2, e, t, r, n, i, a) {
+  return { y: s2, m: e, d: t, h: r, i: n, s: i, tz: a };
+}
+var O = [1, 2, 4, 8, 16];
+var C = class {
+  pattern;
+  timezone;
+  mode;
+  alternativeWeekdays;
+  sloppyRanges;
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  dayOfWeek;
+  year;
+  lastDayOfMonth;
+  lastWeekday;
+  nearestWeekdays;
+  starDOM;
+  starDOW;
+  starYear;
+  useAndLogic;
+  constructor(e, t, r) {
+    this.pattern = e, this.timezone = t, this.mode = r?.mode ?? "auto", this.alternativeWeekdays = r?.alternativeWeekdays ?? false, this.sloppyRanges = r?.sloppyRanges ?? false, this.second = Array(60).fill(0), this.minute = Array(60).fill(0), this.hour = Array(24).fill(0), this.day = Array(31).fill(0), this.month = Array(12).fill(0), this.dayOfWeek = Array(7).fill(0), this.year = Array(1e4).fill(0), this.lastDayOfMonth = false, this.lastWeekday = false, this.nearestWeekdays = Array(31).fill(0), this.starDOM = false, this.starDOW = false, this.starYear = false, this.useAndLogic = false, this.parse();
+  }
+  parse() {
+    if (!(typeof this.pattern == "string" || this.pattern instanceof String)) throw new TypeError("CronPattern: Pattern has to be of type string.");
+    this.pattern.indexOf("@") >= 0 && (this.pattern = this.handleNicknames(this.pattern).trim());
+    let e = this.pattern.match(/\S+/g) || [""], t = e.length;
+    if (e.length < 5 || e.length > 7) throw new TypeError("CronPattern: invalid configuration format ('" + this.pattern + "'), exactly five, six, or seven space separated parts are required.");
+    if (this.mode !== "auto") {
+      let n;
+      switch (this.mode) {
+        case "5-part":
+          n = 5;
+          break;
+        case "6-part":
+          n = 6;
+          break;
+        case "7-part":
+          n = 7;
+          break;
+        case "5-or-6-parts":
+          n = [5, 6];
+          break;
+        case "6-or-7-parts":
+          n = [6, 7];
+          break;
+        default:
+          n = 0;
+      }
+      if (!(Array.isArray(n) ? n.includes(t) : t === n)) {
+        let a = Array.isArray(n) ? n.join(" or ") : n.toString();
+        throw new TypeError(`CronPattern: mode '${this.mode}' requires exactly ${a} parts, but pattern '${this.pattern}' has ${t} parts.`);
+      }
+    }
+    if (e.length === 5 && e.unshift("0"), e.length === 6 && e.push("*"), e[3].toUpperCase() === "LW" ? (this.lastWeekday = true, e[3] = "") : e[3].toUpperCase().indexOf("L") >= 0 && (e[3] = e[3].replace(/L/gi, ""), this.lastDayOfMonth = true), e[3] == "*" && (this.starDOM = true), e[6] == "*" && (this.starYear = true), e[4].length >= 3 && (e[4] = this.replaceAlphaMonths(e[4])), e[5].length >= 3 && (e[5] = this.alternativeWeekdays ? this.replaceAlphaDaysQuartz(e[5]) : this.replaceAlphaDays(e[5])), e[5].startsWith("+") && (this.useAndLogic = true, e[5] = e[5].substring(1), e[5] === "")) throw new TypeError("CronPattern: Day-of-week field cannot be empty after '+' modifier.");
+    switch (e[5] == "*" && (this.starDOW = true), this.pattern.indexOf("?") >= 0 && (e[0] = e[0].replace(/\?/g, "*"), e[1] = e[1].replace(/\?/g, "*"), e[2] = e[2].replace(/\?/g, "*"), e[3] = e[3].replace(/\?/g, "*"), e[4] = e[4].replace(/\?/g, "*"), e[5] = e[5].replace(/\?/g, "*"), e[6] && (e[6] = e[6].replace(/\?/g, "*"))), this.mode) {
+      case "5-part":
+        e[0] = "0", e[6] = "*";
+        break;
+      case "6-part":
+        e[6] = "*";
+        break;
+      case "5-or-6-parts":
+        e[6] = "*";
+        break;
+      case "6-or-7-parts":
+        break;
+      case "7-part":
+      case "auto":
+        break;
+    }
+    this.throwAtIllegalCharacters(e), this.partToArray("second", e[0], 0, 1), this.partToArray("minute", e[1], 0, 1), this.partToArray("hour", e[2], 0, 1), this.partToArray("day", e[3], -1, 1), this.partToArray("month", e[4], -1, 1);
+    let r = this.alternativeWeekdays ? -1 : 0;
+    this.partToArray("dayOfWeek", e[5], r, 63), this.partToArray("year", e[6], 0, 1), !this.alternativeWeekdays && this.dayOfWeek[7] && (this.dayOfWeek[0] = this.dayOfWeek[7]);
+  }
+  partToArray(e, t, r, n) {
+    let i = this[e], a = e === "day" && this.lastDayOfMonth, o = e === "day" && this.lastWeekday;
+    if (t === "" && !a && !o) throw new TypeError("CronPattern: configuration entry " + e + " (" + t + ") is empty, check for trailing spaces.");
+    if (t === "*") return i.fill(n);
+    let h = t.split(",");
+    if (h.length > 1) for (let l = 0; l < h.length; l++) this.partToArray(e, h[l], r, n);
+    else t.indexOf("-") !== -1 && t.indexOf("/") !== -1 ? this.handleRangeWithStepping(t, e, r, n) : t.indexOf("-") !== -1 ? this.handleRange(t, e, r, n) : t.indexOf("/") !== -1 ? this.handleStepping(t, e, r, n) : t !== "" && this.handleNumber(t, e, r, n);
+  }
+  throwAtIllegalCharacters(e) {
+    for (let t = 0; t < e.length; t++) if ((t === 3 ? /[^/*0-9,\-WwLl]+/ : t === 5 ? /[^/*0-9,\-#Ll]+/ : /[^/*0-9,\-]+/).test(e[t])) throw new TypeError("CronPattern: configuration entry " + t + " (" + e[t] + ") contains illegal characters.");
+  }
+  handleNumber(e, t, r, n) {
+    let i = this.extractNth(e, t), a = e.toUpperCase().includes("W");
+    if (t !== "day" && a) throw new TypeError("CronPattern: Nearest weekday modifier (W) only allowed in day-of-month.");
+    a && (t = "nearestWeekdays");
+    let o = parseInt(i[0], 10) + r;
+    if (isNaN(o)) throw new TypeError("CronPattern: " + t + " is not a number: '" + e + "'");
+    this.setPart(t, o, i[1] || n);
+  }
+  setPart(e, t, r) {
+    if (!Object.prototype.hasOwnProperty.call(this, e)) throw new TypeError("CronPattern: Invalid part specified: " + e);
+    if (e === "dayOfWeek") {
+      if (t === 7 && (t = 0), t < 0 || t > 6) throw new RangeError("CronPattern: Invalid value for dayOfWeek: " + t);
+      this.setNthWeekdayOfMonth(t, r);
+      return;
+    }
+    if (e === "second" || e === "minute") {
+      if (t < 0 || t >= 60) throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "hour") {
+      if (t < 0 || t >= 24) throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "day" || e === "nearestWeekdays") {
+      if (t < 0 || t >= 31) throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "month") {
+      if (t < 0 || t >= 12) throw new RangeError("CronPattern: Invalid value for " + e + ": " + t);
+    } else if (e === "year" && (t < 1 || t >= 1e4)) throw new RangeError("CronPattern: Invalid value for " + e + ": " + t + " (supported range: 1-9999)");
+    this[e][t] = r;
+  }
+  validateNotNaN(e, t) {
+    if (isNaN(e)) throw new TypeError(t);
+  }
+  validateRange(e, t, r, n, i) {
+    if (e > t) throw new TypeError("CronPattern: From value is larger than to value: '" + i + "'");
+    if (r !== void 0) {
+      if (r === 0) throw new TypeError("CronPattern: Syntax error, illegal stepping: 0");
+      if (r > this[n].length) throw new TypeError("CronPattern: Syntax error, steps cannot be greater than maximum value of part (" + this[n].length + ")");
+    }
+  }
+  handleRangeWithStepping(e, t, r, n) {
+    if (e.toUpperCase().includes("W")) throw new TypeError("CronPattern: Syntax error, W is not allowed in ranges with stepping.");
+    let i = this.extractNth(e, t), a = i[0].match(/^(\d+)-(\d+)\/(\d+)$/);
+    if (a === null) throw new TypeError("CronPattern: Syntax error, illegal range with stepping: '" + e + "'");
+    let [, o, h, l] = a, y = parseInt(o, 10) + r, u = parseInt(h, 10) + r, d = parseInt(l, 10);
+    this.validateNotNaN(y, "CronPattern: Syntax error, illegal lower range (NaN)"), this.validateNotNaN(u, "CronPattern: Syntax error, illegal upper range (NaN)"), this.validateNotNaN(d, "CronPattern: Syntax error, illegal stepping: (NaN)"), this.validateRange(y, u, d, t, e);
+    for (let c = y; c <= u; c += d) this.setPart(t, c, i[1] || n);
+  }
+  extractNth(e, t) {
+    let r = e, n;
+    if (r.includes("#")) {
+      if (t !== "dayOfWeek") throw new Error("CronPattern: nth (#) only allowed in day-of-week field");
+      n = r.split("#")[1], r = r.split("#")[0];
+    } else if (r.toUpperCase().endsWith("L")) {
+      if (t !== "dayOfWeek") throw new Error("CronPattern: L modifier only allowed in day-of-week field (use L alone for day-of-month)");
+      n = "L", r = r.slice(0, -1);
+    }
+    return [r, n];
+  }
+  handleRange(e, t, r, n) {
+    if (e.toUpperCase().includes("W")) throw new TypeError("CronPattern: Syntax error, W is not allowed in a range.");
+    let i = this.extractNth(e, t), a = i[0].split("-");
+    if (a.length !== 2) throw new TypeError("CronPattern: Syntax error, illegal range: '" + e + "'");
+    let o = parseInt(a[0], 10) + r, h = parseInt(a[1], 10) + r;
+    this.validateNotNaN(o, "CronPattern: Syntax error, illegal lower range (NaN)"), this.validateNotNaN(h, "CronPattern: Syntax error, illegal upper range (NaN)"), this.validateRange(o, h, void 0, t, e);
+    for (let l = o; l <= h; l++) this.setPart(t, l, i[1] || n);
+  }
+  handleStepping(e, t, r, n) {
+    if (e.toUpperCase().includes("W")) throw new TypeError("CronPattern: Syntax error, W is not allowed in parts with stepping.");
+    let i = this.extractNth(e, t), a = i[0].split("/");
+    if (a.length !== 2) throw new TypeError("CronPattern: Syntax error, illegal stepping: '" + e + "'");
+    if (this.sloppyRanges) a[0] === "" && (a[0] = "*");
+    else {
+      if (a[0] === "") throw new TypeError("CronPattern: Syntax error, stepping with missing prefix ('" + e + "') is not allowed. Use wildcard (*/step) or range (min-max/step) instead.");
+      if (a[0] !== "*") throw new TypeError("CronPattern: Syntax error, stepping with numeric prefix ('" + e + "') is not allowed. Use wildcard (*/step) or range (min-max/step) instead.");
+    }
+    let o = 0;
+    a[0] !== "*" && (o = parseInt(a[0], 10) + r);
+    let h = parseInt(a[1], 10);
+    this.validateNotNaN(h, "CronPattern: Syntax error, illegal stepping: (NaN)"), this.validateRange(0, this[t].length - 1, h, t, e);
+    for (let l = o; l < this[t].length; l += h) this.setPart(t, l, i[1] || n);
+  }
+  replaceAlphaDays(e) {
+    return e.replace(/-sun/gi, "-7").replace(/sun/gi, "0").replace(/mon/gi, "1").replace(/tue/gi, "2").replace(/wed/gi, "3").replace(/thu/gi, "4").replace(/fri/gi, "5").replace(/sat/gi, "6");
+  }
+  replaceAlphaDaysQuartz(e) {
+    return e.replace(/sun/gi, "1").replace(/mon/gi, "2").replace(/tue/gi, "3").replace(/wed/gi, "4").replace(/thu/gi, "5").replace(/fri/gi, "6").replace(/sat/gi, "7");
+  }
+  replaceAlphaMonths(e) {
+    return e.replace(/jan/gi, "1").replace(/feb/gi, "2").replace(/mar/gi, "3").replace(/apr/gi, "4").replace(/may/gi, "5").replace(/jun/gi, "6").replace(/jul/gi, "7").replace(/aug/gi, "8").replace(/sep/gi, "9").replace(/oct/gi, "10").replace(/nov/gi, "11").replace(/dec/gi, "12");
+  }
+  handleNicknames(e) {
+    let t = e.trim().toLowerCase();
+    if (t === "@yearly" || t === "@annually") return "0 0 1 1 *";
+    if (t === "@monthly") return "0 0 1 * *";
+    if (t === "@weekly") return "0 0 * * 0";
+    if (t === "@daily" || t === "@midnight") return "0 0 * * *";
+    if (t === "@hourly") return "0 * * * *";
+    if (t === "@reboot") throw new TypeError("CronPattern: @reboot is not supported in this environment. This is an event-based trigger that requires system startup detection.");
+    return e;
+  }
+  setNthWeekdayOfMonth(e, t) {
+    if (typeof t != "number" && t.toUpperCase() === "L") this.dayOfWeek[e] = this.dayOfWeek[e] | 32;
+    else if (t === 63) this.dayOfWeek[e] = 63;
+    else if (t < 6 && t > 0) this.dayOfWeek[e] = this.dayOfWeek[e] | O[t - 1];
+    else throw new TypeError(`CronPattern: nth weekday out of range, should be 1-5 or L. Value: ${t}, Type: ${typeof t}`);
+  }
+};
+var P = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var f = [["month", "year", 0], ["day", "month", -1], ["hour", "day", 0], ["minute", "hour", 0], ["second", "minute", 0]];
+var m = class s {
+  tz;
+  ms;
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  year;
+  constructor(e, t) {
+    if (this.tz = t, e && e instanceof Date) if (!isNaN(e)) this.fromDate(e);
+    else throw new TypeError("CronDate: Invalid date passed to CronDate constructor");
+    else if (e == null) this.fromDate(/* @__PURE__ */ new Date());
+    else if (e && typeof e == "string") this.fromString(e);
+    else if (e instanceof s) this.fromCronDate(e);
+    else throw new TypeError("CronDate: Invalid type (" + typeof e + ") passed to CronDate constructor");
+  }
+  getLastDayOfMonth(e, t) {
+    return t !== 1 ? P[t] : new Date(Date.UTC(e, t + 1, 0)).getUTCDate();
+  }
+  getLastWeekday(e, t) {
+    let r = this.getLastDayOfMonth(e, t), i = new Date(Date.UTC(e, t, r)).getUTCDay();
+    return i === 0 ? r - 2 : i === 6 ? r - 1 : r;
+  }
+  getNearestWeekday(e, t, r) {
+    let n = this.getLastDayOfMonth(e, t);
+    if (r > n) return -1;
+    let a = new Date(Date.UTC(e, t, r)).getUTCDay();
+    return a === 0 ? r === n ? r - 2 : r + 1 : a === 6 ? r === 1 ? r + 2 : r - 1 : r;
+  }
+  isNthWeekdayOfMonth(e, t, r, n) {
+    let a = new Date(Date.UTC(e, t, r)).getUTCDay(), o = 0;
+    for (let h = 1; h <= r; h++) new Date(Date.UTC(e, t, h)).getUTCDay() === a && o++;
+    if (n & 63 && O[o - 1] & n) return true;
+    if (n & 32) {
+      let h = this.getLastDayOfMonth(e, t);
+      for (let l = r + 1; l <= h; l++) if (new Date(Date.UTC(e, t, l)).getUTCDay() === a) return false;
+      return true;
+    }
+    return false;
+  }
+  fromDate(e) {
+    if (this.tz !== void 0) if (typeof this.tz == "number") this.ms = e.getUTCMilliseconds(), this.second = e.getUTCSeconds(), this.minute = e.getUTCMinutes() + this.tz, this.hour = e.getUTCHours(), this.day = e.getUTCDate(), this.month = e.getUTCMonth(), this.year = e.getUTCFullYear(), this.apply();
+    else try {
+      let t = g(e, this.tz);
+      this.ms = e.getMilliseconds(), this.second = t.s, this.minute = t.i, this.hour = t.h, this.day = t.d, this.month = t.m - 1, this.year = t.y;
+    } catch (t) {
+      let r = t instanceof Error ? t.message : String(t);
+      throw new TypeError(`CronDate: Failed to convert date to timezone '${this.tz}'. This may happen with invalid timezone names or dates. Original error: ${r}`);
+    }
+    else this.ms = e.getMilliseconds(), this.second = e.getSeconds(), this.minute = e.getMinutes(), this.hour = e.getHours(), this.day = e.getDate(), this.month = e.getMonth(), this.year = e.getFullYear();
+  }
+  fromCronDate(e) {
+    this.tz = e.tz, this.year = e.year, this.month = e.month, this.day = e.day, this.hour = e.hour, this.minute = e.minute, this.second = e.second, this.ms = e.ms;
+  }
+  apply() {
+    if (this.month > 11 || this.month < 0 || this.day > P[this.month] || this.day < 1 || this.hour > 59 || this.minute > 59 || this.second > 59 || this.hour < 0 || this.minute < 0 || this.second < 0) {
+      let e = new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms));
+      return this.ms = e.getUTCMilliseconds(), this.second = e.getUTCSeconds(), this.minute = e.getUTCMinutes(), this.hour = e.getUTCHours(), this.day = e.getUTCDate(), this.month = e.getUTCMonth(), this.year = e.getUTCFullYear(), true;
+    } else return false;
+  }
+  fromString(e) {
+    if (typeof this.tz == "number") {
+      let t = v(e);
+      this.ms = t.getUTCMilliseconds(), this.second = t.getUTCSeconds(), this.minute = t.getUTCMinutes(), this.hour = t.getUTCHours(), this.day = t.getUTCDate(), this.month = t.getUTCMonth(), this.year = t.getUTCFullYear(), this.apply();
+    } else return this.fromDate(v(e, this.tz));
+  }
+  findNext(e, t, r, n) {
+    return this._findMatch(e, t, r, n, 1);
+  }
+  _findMatch(e, t, r, n, i) {
+    let a = this[t], o;
+    r.lastDayOfMonth && (o = this.getLastDayOfMonth(this.year, this.month));
+    let h = !r.starDOW && t == "day" ? new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay() : void 0, l = this[t] + n, y = i === 1 ? (u) => u < r[t].length : (u) => u >= 0;
+    for (let u = l; y(u); u += i) {
+      let d = r[t][u];
+      if (t === "day" && !d) {
+        for (let c = 0; c < r.nearestWeekdays.length; c++) if (r.nearestWeekdays[c]) {
+          let M = this.getNearestWeekday(this.year, this.month, c - n);
+          if (M === -1) continue;
+          if (M === u - n) {
+            d = 1;
+            break;
+          }
+        }
+      }
+      if (t === "day" && r.lastWeekday) {
+        let c = this.getLastWeekday(this.year, this.month);
+        u - n === c && (d = 1);
+      }
+      if (t === "day" && r.lastDayOfMonth && u - n == o && (d = 1), t === "day" && !r.starDOW) {
+        let c = r.dayOfWeek[(h + (u - n - 1)) % 7];
+        if (c && c & 63) c = this.isNthWeekdayOfMonth(this.year, this.month, u - n, c) ? 1 : 0;
+        else if (c) throw new Error(`CronDate: Invalid value for dayOfWeek encountered. ${c}`);
+        r.useAndLogic ? d = d && c : !e.domAndDow && !r.starDOM ? d = d || c : d = d && c;
+      }
+      if (d) return this[t] = u - n, a !== this[t] ? 2 : 1;
+    }
+    return 3;
+  }
+  recurse(e, t, r) {
+    if (r === 0 && !e.starYear) {
+      if (this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0) {
+        let i = -1;
+        for (let a = this.year + 1; a < e.year.length && a < 1e4; a++) if (e.year[a] === 1) {
+          i = a;
+          break;
+        }
+        if (i === -1) return null;
+        this.year = i, this.month = 0, this.day = 1, this.hour = 0, this.minute = 0, this.second = 0, this.ms = 0;
+      }
+      if (this.year >= 1e4) return null;
+    }
+    let n = this.findNext(t, f[r][0], e, f[r][2]);
+    if (n > 1) {
+      let i = r + 1;
+      for (; i < f.length; ) this[f[i][0]] = -f[i][2], i++;
+      if (n === 3) {
+        if (this[f[r][1]]++, this[f[r][0]] = -f[r][2], this.apply(), r === 0 && !e.starYear) {
+          for (; this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0 && this.year < 1e4; ) this.year++;
+          if (this.year >= 1e4 || this.year >= e.year.length) return null;
+        }
+        return this.recurse(e, t, 0);
+      } else if (this.apply()) return this.recurse(e, t, r - 1);
+    }
+    return r += 1, r >= f.length ? this : (e.starYear ? this.year >= 3e3 : this.year >= 1e4) ? null : this.recurse(e, t, r);
+  }
+  increment(e, t, r) {
+    return this.second += t.interval !== void 0 && t.interval > 1 && r ? t.interval : 1, this.ms = 0, this.apply(), this.recurse(e, t, 0);
+  }
+  decrement(e, t) {
+    return this.second -= t.interval !== void 0 && t.interval > 1 ? t.interval : 1, this.ms = 0, this.apply(), this.recurseBackward(e, t, 0, 0);
+  }
+  recurseBackward(e, t, r, n = 0) {
+    if (n > 1e4) return null;
+    if (r === 0 && !e.starYear) {
+      if (this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0) {
+        let a = -1;
+        for (let o = this.year - 1; o >= 0; o--) if (e.year[o] === 1) {
+          a = o;
+          break;
+        }
+        if (a === -1) return null;
+        this.year = a, this.month = 11, this.day = 31, this.hour = 23, this.minute = 59, this.second = 59, this.ms = 0;
+      }
+      if (this.year < 0) return null;
+    }
+    let i = this.findPrevious(t, f[r][0], e, f[r][2]);
+    if (i > 1) {
+      let a = r + 1;
+      for (; a < f.length; ) {
+        let o = f[a][0], h = f[a][2], l = this.getMaxPatternValue(o, e, h);
+        this[o] = l, a++;
+      }
+      if (i === 3) {
+        if (this[f[r][1]]--, r === 0) {
+          let y = this.getLastDayOfMonth(this.year, this.month);
+          this.day > y && (this.day = y);
+        }
+        if (r === 1) if (this.day <= 0) this.day = 1;
+        else {
+          let y = this.year, u = this.month;
+          for (; u < 0; ) u += 12, y--;
+          for (; u > 11; ) u -= 12, y++;
+          let d = u !== 1 ? P[u] : new Date(Date.UTC(y, u + 1, 0)).getUTCDate();
+          this.day > d && (this.day = d);
+        }
+        this.apply();
+        let o = f[r][0], h = f[r][2], l = this.getMaxPatternValue(o, e, h);
+        if (o === "day") {
+          let y = this.getLastDayOfMonth(this.year, this.month);
+          this[o] = Math.min(l, y);
+        } else this[o] = l;
+        if (this.apply(), r === 0) {
+          let y = f[1][2], u = this.getMaxPatternValue("day", e, y), d = this.getLastDayOfMonth(this.year, this.month), c = Math.min(u, d);
+          c !== this.day && (this.day = c, this.hour = this.getMaxPatternValue("hour", e, f[2][2]), this.minute = this.getMaxPatternValue("minute", e, f[3][2]), this.second = this.getMaxPatternValue("second", e, f[4][2]));
+        }
+        if (r === 0 && !e.starYear) {
+          for (; this.year >= 0 && this.year < e.year.length && e.year[this.year] === 0; ) this.year--;
+          if (this.year < 0) return null;
+        }
+        return this.recurseBackward(e, t, 0, n + 1);
+      } else if (this.apply()) return this.recurseBackward(e, t, r - 1, n + 1);
+    }
+    return r += 1, r >= f.length ? this : this.year < 0 ? null : this.recurseBackward(e, t, r, n + 1);
+  }
+  getMaxPatternValue(e, t, r) {
+    if (e === "day" && t.lastDayOfMonth) return this.getLastDayOfMonth(this.year, this.month);
+    if (e === "day" && !t.starDOW) return this.getLastDayOfMonth(this.year, this.month);
+    for (let n = t[e].length - 1; n >= 0; n--) if (t[e][n]) return n - r;
+    return t[e].length - 1 - r;
+  }
+  findPrevious(e, t, r, n) {
+    return this._findMatch(e, t, r, n, -1);
+  }
+  getDate(e) {
+    return e || this.tz === void 0 ? new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms) : typeof this.tz == "number" ? new Date(Date.UTC(this.year, this.month, this.day, this.hour, this.minute - this.tz, this.second, this.ms)) : k(b(this.year, this.month + 1, this.day, this.hour, this.minute, this.second, this.tz), false);
+  }
+  getTime() {
+    return this.getDate(false).getTime();
+  }
+  match(e, t) {
+    if (!e.starYear && (this.year < 0 || this.year >= e.year.length || e.year[this.year] === 0)) return false;
+    for (let r = 0; r < f.length; r++) {
+      let n = f[r][0], i = f[r][2], a = this[n];
+      if (a + i < 0 || a + i >= e[n].length) return false;
+      let o = e[n][a + i];
+      if (n === "day") {
+        if (!o) {
+          for (let h = 0; h < e.nearestWeekdays.length; h++) if (e.nearestWeekdays[h]) {
+            let l = this.getNearestWeekday(this.year, this.month, h - i);
+            if (l !== -1 && l === a) {
+              o = 1;
+              break;
+            }
+          }
+        }
+        if (e.lastWeekday) {
+          let h = this.getLastWeekday(this.year, this.month);
+          a === h && (o = 1);
+        }
+        if (e.lastDayOfMonth) {
+          let h = this.getLastDayOfMonth(this.year, this.month);
+          a === h && (o = 1);
+        }
+        if (!e.starDOW) {
+          let h = new Date(Date.UTC(this.year, this.month, 1, 0, 0, 0, 0)).getUTCDay(), l = e.dayOfWeek[(h + (a - 1)) % 7];
+          l && l & 63 && (l = this.isNthWeekdayOfMonth(this.year, this.month, a, l) ? 1 : 0), e.useAndLogic ? o = o && l : !t.domAndDow && !e.starDOM ? o = o || l : o = o && l;
+        }
+      }
+      if (!o) return false;
+    }
+    return true;
+  }
+};
+function R(s2) {
+  if (s2 === void 0 && (s2 = {}), delete s2.name, s2.legacyMode !== void 0 && s2.domAndDow === void 0 ? s2.domAndDow = !s2.legacyMode : s2.domAndDow === void 0 && (s2.domAndDow = false), s2.legacyMode = !s2.domAndDow, s2.paused = s2.paused === void 0 ? false : s2.paused, s2.maxRuns = s2.maxRuns === void 0 ? 1 / 0 : s2.maxRuns, s2.catch = s2.catch === void 0 ? false : s2.catch, s2.interval = s2.interval === void 0 ? 0 : parseInt(s2.interval.toString(), 10), s2.utcOffset = s2.utcOffset === void 0 ? void 0 : parseInt(s2.utcOffset.toString(), 10), s2.dayOffset = s2.dayOffset === void 0 ? 0 : parseInt(s2.dayOffset.toString(), 10), s2.unref = s2.unref === void 0 ? false : s2.unref, s2.mode = s2.mode === void 0 ? "auto" : s2.mode, s2.alternativeWeekdays = s2.alternativeWeekdays === void 0 ? false : s2.alternativeWeekdays, s2.sloppyRanges = s2.sloppyRanges === void 0 ? false : s2.sloppyRanges, !["auto", "5-part", "6-part", "7-part", "5-or-6-parts", "6-or-7-parts"].includes(s2.mode)) throw new Error("CronOptions: mode must be one of 'auto', '5-part', '6-part', '7-part', '5-or-6-parts', or '6-or-7-parts'.");
+  if (s2.startAt && (s2.startAt = new m(s2.startAt, s2.timezone)), s2.stopAt && (s2.stopAt = new m(s2.stopAt, s2.timezone)), s2.interval !== null) {
+    if (isNaN(s2.interval)) throw new Error("CronOptions: Supplied value for interval is not a number");
+    if (s2.interval < 0) throw new Error("CronOptions: Supplied value for interval can not be negative");
+  }
+  if (s2.utcOffset !== void 0) {
+    if (isNaN(s2.utcOffset)) throw new Error("CronOptions: Invalid value passed for utcOffset, should be number representing minutes offset from UTC.");
+    if (s2.utcOffset < -870 || s2.utcOffset > 870) throw new Error("CronOptions: utcOffset out of bounds.");
+    if (s2.utcOffset !== void 0 && s2.timezone) throw new Error("CronOptions: Combining 'utcOffset' with 'timezone' is not allowed.");
+  }
+  if (s2.unref !== true && s2.unref !== false) throw new Error("CronOptions: Unref should be either true, false or undefined(false).");
+  if (s2.dayOffset !== void 0 && s2.dayOffset !== 0 && isNaN(s2.dayOffset)) throw new Error("CronOptions: Invalid value passed for dayOffset, should be a number representing days to offset.");
+  return s2;
+}
+function p(s2) {
+  return Object.prototype.toString.call(s2) === "[object Function]" || typeof s2 == "function" || s2 instanceof Function;
+}
+function _(s2) {
+  return p(s2);
+}
+function x(s2) {
+  typeof Deno < "u" && typeof Deno.unrefTimer < "u" ? Deno.unrefTimer(s2) : s2 && typeof s2.unref < "u" && s2.unref();
+}
+var W = 30 * 1e3;
+var w = [];
+var E = class {
+  name;
+  options;
+  _states;
+  fn;
+  getTz() {
+    return this.options.timezone || this.options.utcOffset;
+  }
+  applyDayOffset(e) {
+    if (this.options.dayOffset !== void 0 && this.options.dayOffset !== 0) {
+      let t = this.options.dayOffset * 24 * 60 * 60 * 1e3;
+      return new Date(e.getTime() + t);
+    }
+    return e;
+  }
+  constructor(e, t, r) {
+    let n, i;
+    if (p(t)) i = t;
+    else if (typeof t == "object") n = t;
+    else if (t !== void 0) throw new Error("Cron: Invalid argument passed for optionsIn. Should be one of function, or object (options).");
+    if (p(r)) i = r;
+    else if (typeof r == "object") n = r;
+    else if (r !== void 0) throw new Error("Cron: Invalid argument passed for funcIn. Should be one of function, or object (options).");
+    if (this.name = n?.name, this.options = R(n), this._states = { kill: false, blocking: false, previousRun: void 0, currentRun: void 0, once: void 0, currentTimeout: void 0, maxRuns: n ? n.maxRuns : void 0, paused: n ? n.paused : false, pattern: new C("* * * * *", void 0, { mode: "auto" }) }, e && (e instanceof Date || typeof e == "string" && e.indexOf(":") > 0) ? this._states.once = new m(e, this.getTz()) : this._states.pattern = new C(e, this.options.timezone, { mode: this.options.mode, alternativeWeekdays: this.options.alternativeWeekdays, sloppyRanges: this.options.sloppyRanges }), this.name) {
+      if (w.find((o) => o.name === this.name)) throw new Error("Cron: Tried to initialize new named job '" + this.name + "', but name already taken.");
+      w.push(this);
+    }
+    return i !== void 0 && _(i) && (this.fn = i, this.schedule()), this;
+  }
+  nextRun(e) {
+    let t = this._next(e);
+    return t ? this.applyDayOffset(t.getDate(false)) : null;
+  }
+  nextRuns(e, t) {
+    this._states.maxRuns !== void 0 && e > this._states.maxRuns && (e = this._states.maxRuns);
+    let r = t || this._states.currentRun || void 0;
+    return this._enumerateRuns(e, r, "next");
+  }
+  previousRuns(e, t) {
+    return this._enumerateRuns(e, t || void 0, "previous");
+  }
+  _enumerateRuns(e, t, r) {
+    let n = [], i = t ? new m(t, this.getTz()) : null, a = r === "next" ? this._next : this._previous;
+    for (; e--; ) {
+      let o = a.call(this, i);
+      if (!o) break;
+      let h = o.getDate(false);
+      n.push(this.applyDayOffset(h)), i = o;
+    }
+    return n;
+  }
+  match(e) {
+    if (this._states.once) {
+      let r = new m(e, this.getTz());
+      r.ms = 0;
+      let n = new m(this._states.once, this.getTz());
+      return n.ms = 0, r.getTime() === n.getTime();
+    }
+    let t = new m(e, this.getTz());
+    return t.ms = 0, t.match(this._states.pattern, this.options);
+  }
+  getPattern() {
+    if (!this._states.once) return this._states.pattern ? this._states.pattern.pattern : void 0;
+  }
+  getOnce() {
+    return this._states.once ? this._states.once.getDate() : null;
+  }
+  isRunning() {
+    let e = this.nextRun(this._states.currentRun), t = !this._states.paused, r = this.fn !== void 0, n = !this._states.kill;
+    return t && r && n && e !== null;
+  }
+  isStopped() {
+    return this._states.kill;
+  }
+  isBusy() {
+    return this._states.blocking;
+  }
+  currentRun() {
+    return this._states.currentRun ? this._states.currentRun.getDate() : null;
+  }
+  previousRun() {
+    return this._states.previousRun ? this._states.previousRun.getDate() : null;
+  }
+  msToNext(e) {
+    let t = this._next(e);
+    return t ? e instanceof m || e instanceof Date ? t.getTime() - e.getTime() : t.getTime() - new m(e).getTime() : null;
+  }
+  stop() {
+    this._states.kill = true, this._states.currentTimeout && clearTimeout(this._states.currentTimeout);
+    let e = w.indexOf(this);
+    e >= 0 && w.splice(e, 1);
+  }
+  pause() {
+    return this._states.paused = true, !this._states.kill;
+  }
+  resume() {
+    return this._states.paused = false, !this._states.kill;
+  }
+  schedule(e) {
+    if (e && this.fn) throw new Error("Cron: It is not allowed to schedule two functions using the same Croner instance.");
+    e && (this.fn = e);
+    let t = this.msToNext(), r = this.nextRun(this._states.currentRun);
+    return t == null || isNaN(t) || r === null ? this : (t > W && (t = W), this._states.currentTimeout = setTimeout(() => this._checkTrigger(r), t), this._states.currentTimeout && this.options.unref && x(this._states.currentTimeout), this);
+  }
+  async _trigger(e) {
+    this._states.blocking = true, this._states.currentRun = new m(void 0, this.getTz());
+    try {
+      if (this.options.catch) try {
+        this.fn !== void 0 && await this.fn(this, this.options.context);
+      } catch (t) {
+        if (p(this.options.catch)) try {
+          this.options.catch(t, this);
+        } catch {
+        }
+      }
+      else this.fn !== void 0 && await this.fn(this, this.options.context);
+    } finally {
+      this._states.previousRun = new m(e, this.getTz()), this._states.blocking = false;
+    }
+  }
+  async trigger() {
+    await this._trigger();
+  }
+  runsLeft() {
+    return this._states.maxRuns;
+  }
+  _checkTrigger(e) {
+    let t = /* @__PURE__ */ new Date(), r = !this._states.paused && t.getTime() >= e.getTime(), n = this._states.blocking && this.options.protect;
+    r && !n ? (this._states.maxRuns !== void 0 && this._states.maxRuns--, this._trigger()) : r && n && p(this.options.protect) && setTimeout(() => this.options.protect(this), 0), this.schedule();
+  }
+  _next(e) {
+    let t = !!(e || this._states.currentRun), r = false;
+    !e && this.options.startAt && this.options.interval && ([e, t] = this._calculatePreviousRun(e, t), r = !e), e = new m(e, this.getTz()), this.options.startAt && e && e.getTime() < this.options.startAt.getTime() && (e = this.options.startAt);
+    let n = this._states.once || new m(e, this.getTz());
+    return !r && n !== this._states.once && (n = n.increment(this._states.pattern, this.options, t)), this._states.once && this._states.once.getTime() <= e.getTime() || n === null || this._states.maxRuns !== void 0 && this._states.maxRuns <= 0 || this._states.kill || this.options.stopAt && n.getTime() >= this.options.stopAt.getTime() ? null : n;
+  }
+  _previous(e) {
+    let t = new m(e, this.getTz());
+    this.options.stopAt && t.getTime() > this.options.stopAt.getTime() && (t = this.options.stopAt);
+    let r = new m(t, this.getTz());
+    return this._states.once ? this._states.once.getTime() < t.getTime() ? this._states.once : null : (r = r.decrement(this._states.pattern, this.options), r === null || this.options.startAt && r.getTime() < this.options.startAt.getTime() ? null : r);
+  }
+  _calculatePreviousRun(e, t) {
+    let r = new m(void 0, this.getTz()), n = e;
+    if (this.options.startAt.getTime() <= r.getTime()) {
+      n = this.options.startAt;
+      let i = n.getTime() + this.options.interval * 1e3;
+      for (; i <= r.getTime(); ) n = new m(n, this.getTz()).increment(this._states.pattern, this.options, true), i = n.getTime() + this.options.interval * 1e3;
+      t = true;
+    }
+    return n === null && (n = void 0), [n, t];
+  }
+};
+
+// packages/daemon/dist/wake-cycle.js
+import { spawnSync as spawnSync2 } from "node:child_process";
+
+// packages/memory/dist/default-store.js
+import { homedir as homedir2 } from "node:os";
+import { join } from "node:path";
+
+// packages/memory/dist/memory-store.js
+import { randomUUID } from "node:crypto";
+
+// packages/memory/dist/embedding.js
+var EMBEDDING_DIMENSIONS = 32;
+function buildSearchText(text2, metadata) {
+  const metadataText = metadata ? flattenMetadata(metadata).join(" ") : "";
+  return `${text2} ${metadataText}`.trim().toLowerCase();
+}
+function createEmbedding(input) {
+  const vector = Array.from({ length: EMBEDDING_DIMENSIONS }, () => 0);
+  for (const token of tokenize(input)) {
+    const hash = hashToken(token);
+    const index = Math.abs(hash) % EMBEDDING_DIMENSIONS;
+    vector[index] += hash < 0 ? -1 : 1;
+  }
+  const magnitude = Math.hypot(...vector) || 1;
+  return vector.map((value) => value / magnitude);
+}
+function cosineSimilarity(left, right) {
+  const size = Math.min(left.length, right.length);
+  let score = 0;
+  for (let index = 0; index < size; index += 1) {
+    score += left[index] * right[index];
+  }
+  return score;
+}
+function keywordTokens(query) {
+  return Array.from(new Set(tokenize(query)));
+}
+function tokenize(input) {
+  return input.toLowerCase().split(/[^a-z0-9\u4e00-\u9fff]+/).filter(Boolean);
+}
+function flattenMetadata(value) {
+  if (value == null) {
+    return [];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => flattenMetadata(item));
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).flatMap(([key, item]) => [
+      key,
+      ...flattenMetadata(item)
+    ]);
+  }
+  return [];
+}
+function hashToken(token) {
+  let hash = 2166136261;
+  for (let index = 0; index < token.length; index += 1) {
+    hash ^= token.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash | 0;
+}
+
+// packages/memory/dist/forgetting-curve.js
+var DAY_IN_MS = 864e5;
+function computeRetention(strength, lastAccessedAt, decayTau, importance, accessCount) {
+  const normalizedStrength = clamp(Number(strength), 0, 1);
+  const normalizedImportance = clamp(Number(importance), 0, 1);
+  const normalizedDecayTau = Number.isFinite(decayTau) && decayTau > 0 ? decayTau : DAY_IN_MS;
+  const now = Date.now();
+  const lastAccess = Date.parse(lastAccessedAt ?? "");
+  const elapsed = Number.isFinite(lastAccess) ? Math.max(0, now - lastAccess) : 0;
+  const dynamicTau = normalizedDecayTau * (1 + normalizedImportance * 2) * 1.2 ** Math.min(Math.max(0, Math.round(accessCount)), 10);
+  return clamp(normalizedStrength * Math.exp(-elapsed / dynamicTau), 0, 1);
+}
+function reinforceOnAccess(current, importance) {
+  return clamp(Number(current) + 0.1 * (1 + clamp(Number(importance), 0, 1)), 0, 1);
+}
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.max(min, Math.min(max, value));
+}
+
+// packages/memory/dist/sqlite.js
+import { mkdirSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var SqliteMemoryDb = class {
+  vectorAvailable;
+  db;
+  constructor(options = {}) {
+    const dbPath = options.dbPath ?? ":memory:";
+    if (dbPath !== ":memory:") {
+      mkdirSync(dirname2(dbPath), { recursive: true });
+    }
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        text TEXT NOT NULL,
+        essence TEXT,
+        details TEXT,
+        tags TEXT,
+        trigger_conditions TEXT,
+        importance REAL DEFAULT 0.5,
+        strength REAL DEFAULT 1.0,
+        decay_tau INTEGER DEFAULT 86400000,
+        last_accessed_at TEXT,
+        access_count INTEGER DEFAULT 0,
+        metadata TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        search_text TEXT NOT NULL,
+        embedding TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at DESC);
+    `);
+    this.ensureColumn('"key" TEXT');
+    try {
+      this.db.exec('CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_key_unique ON memories("key")');
+    } catch {
+    }
+    this.ensureColumn("essence TEXT");
+    this.ensureColumn("details TEXT");
+    this.ensureColumn("tags TEXT");
+    this.ensureColumn("trigger_conditions TEXT");
+    this.ensureColumn("importance REAL DEFAULT 0.5");
+    this.ensureColumn("strength REAL DEFAULT 1.0");
+    this.ensureColumn("decay_tau INTEGER DEFAULT 86400000");
+    this.ensureColumn("last_accessed_at TEXT");
+    this.ensureColumn("access_count INTEGER DEFAULT 0");
+    this.ensureColumn("updated_at TEXT");
+    this.vectorAvailable = options.enableVectorSearch === false ? false : tryLoadVectorExtension(this.db, options.vectorExtensionPath);
+    try {
+      try {
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_key ON memories("key")');
+      } catch {
+      }
+    } catch {
+    }
+    this.backfillMissingKeys();
+  }
+  insert(row) {
+    this.db.prepare(`INSERT INTO memories
+         (id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, "key", search_text, embedding)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.text, row.essence, row.details, row.tags, row.trigger_conditions, row.importance, row.strength, row.decay_tau, row.last_accessed_at, row.access_count, row.metadata, row.created_at, row.updated_at, row.key, row.search_text, row.embedding);
+  }
+  upsertByKey(row) {
+    this.db.prepare(`INSERT INTO memories
+         (id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, "key", search_text, embedding)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT("key") DO UPDATE SET
+           text = excluded.text,
+           essence = excluded.essence,
+           details = excluded.details,
+           tags = excluded.tags,
+           trigger_conditions = excluded.trigger_conditions,
+           importance = excluded.importance,
+           strength = excluded.strength,
+           decay_tau = excluded.decay_tau,
+           last_accessed_at = excluded.last_accessed_at,
+           access_count = excluded.access_count,
+           metadata = excluded.metadata,
+           updated_at = excluded.updated_at,
+           search_text = excluded.search_text,
+           embedding = excluded.embedding`).run(row.id, row.text, row.essence, row.details, row.tags, row.trigger_conditions, row.importance, row.strength, row.decay_tau, row.last_accessed_at, row.access_count, row.metadata, row.created_at, row.updated_at, row.key, row.search_text, row.embedding);
+  }
+  getByKey(key) {
+    return this.db.prepare(`SELECT
+           id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, search_text, embedding, "key"
+         FROM memories
+         WHERE "key" = ?`).get(key);
+  }
+  deleteByKey(key) {
+    const result = this.db.prepare('DELETE FROM memories WHERE "key" = ?').run(key);
+    return Number(result.changes) > 0;
+  }
+  listAll() {
+    return this.db.prepare(`SELECT id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, search_text, embedding, "key"
+         FROM memories
+         ORDER BY created_at DESC, id DESC`).all();
+  }
+  list(limit) {
+    return this.db.prepare(`SELECT id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, search_text, embedding, "key"
+         FROM memories
+         ORDER BY created_at DESC, id DESC
+         LIMIT ?`).all(limit);
+  }
+  listWithEmbeddings() {
+    return this.db.prepare(`SELECT id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, search_text, embedding, "key"
+         FROM memories
+         WHERE embedding IS NOT NULL`).all();
+  }
+  searchByKeywords(query, topK) {
+    const tokens = keywordTokens(query);
+    if (tokens.length === 0) {
+      return this.list(topK);
+    }
+    const predicates = tokens.map(() => "search_text LIKE ?").join(" OR ");
+    const params = tokens.map((token) => `%${token}%`);
+    const rows = this.db.prepare(`SELECT id, text, essence, details, tags, trigger_conditions, importance, strength, decay_tau, last_accessed_at, access_count, metadata, created_at, updated_at, search_text, embedding, "key"
+         FROM memories
+         WHERE ${predicates}
+         ORDER BY created_at DESC`).all(...params);
+    return rows.map((row) => ({ ...row, score: scoreKeywordMatch(row.search_text, tokens) })).sort(compareRankedRows).slice(0, topK);
+  }
+  clear() {
+    this.db.prepare("DELETE FROM memories").run();
+  }
+  close() {
+    this.db.close();
+  }
+  ensureColumn(definition) {
+    try {
+      this.db.exec(`ALTER TABLE memories ADD COLUMN ${definition}`);
+    } catch {
+    }
+  }
+  backfillMissingKeys() {
+    try {
+      this.db.exec('UPDATE memories SET "key" = id WHERE "key" IS NULL');
+    } catch {
+    }
+  }
+};
+function tryLoadVectorExtension(db, extensionPath) {
+  if (!extensionPath) {
+    return false;
+  }
+  try {
+    db.enableLoadExtension(true);
+    db.loadExtension(extensionPath);
+    return true;
+  } catch {
+    return false;
+  } finally {
+    db.enableLoadExtension(false);
+  }
+}
+function scoreKeywordMatch(searchText, tokens) {
+  return tokens.reduce((score, token) => score + Number(searchText.includes(token)), 0);
+}
+function compareRankedRows(left, right) {
+  return right.score - left.score || right.created_at.localeCompare(left.created_at);
+}
+
+// packages/memory/dist/memory-store.js
+var DAY_IN_MS2 = 864e5;
+var ONE_WEEK_IN_MS = 7 * DAY_IN_MS2;
+var DEFAULT_IMPORTANCE = 0.5;
+var DEFAULT_STRENGTH = 1;
+var DEFAULT_DECAY_TAU = DAY_IN_MS2;
+var KEYWORD_WEIGHTS = {
+  tag: 1,
+  trigger: 0.9,
+  essence: 0.8,
+  details: 0.4
+};
+var MemoryStore = class {
+  db;
+  constructor(options = {}) {
+    this.db = new SqliteMemoryDb(options);
+  }
+  async memorize(key, essence, options = {}) {
+    const existing = this.db.getByKey(key);
+    const now = nowString();
+    const existingEntry = existing ? toMemoryEntry(existing) : void 0;
+    const normalizedImportance = clamp01(options.importance ?? existingEntry?.importance ?? DEFAULT_IMPORTANCE);
+    const tags = normalizeStringArray(options.tags ?? existingEntry?.tags ?? []);
+    const triggerConditions = normalizeStringArray(options.triggerConditions ?? existingEntry?.triggerConditions ?? []);
+    const details = options.details === void 0 ? existingEntry?.details : options.details;
+    const searchText = buildSearchTextFromParts(essence, {
+      details,
+      tags,
+      triggerConditions,
+      metadata: existingEntry?.metadata
+    });
+    const row = {
+      id: existingEntry?.id ?? randomUUID(),
+      text: essence,
+      essence,
+      details: details ?? null,
+      metadata: existingEntry?.metadata ? JSON.stringify(existingEntry.metadata) : null,
+      created_at: existingEntry?.createdAt ?? now,
+      search_text: searchText,
+      embedding: this.db.vectorAvailable ? JSON.stringify(createEmbedding(searchText)) : null,
+      key,
+      tags: JSON.stringify(tags),
+      trigger_conditions: JSON.stringify(triggerConditions),
+      importance: normalizedImportance,
+      strength: existingEntry?.strength ?? DEFAULT_STRENGTH,
+      decay_tau: existingEntry?.decayTau ?? DEFAULT_DECAY_TAU,
+      last_accessed_at: existingEntry?.lastAccessedAt ?? now,
+      access_count: existingEntry?.accessCount ?? 0,
+      updated_at: now
+    };
+    this.db.upsertByKey(row);
+    return toMemoryEntry(this.db.getByKey(key) ?? row);
+  }
+  async get(key) {
+    const row = this.db.getByKey(key);
+    return row ? toMemoryEntry(row) : void 0;
+  }
+  async update(key, changes) {
+    const row = this.db.getByKey(key);
+    if (!row) {
+      return void 0;
+    }
+    const entry = toMemoryEntry(row);
+    const nextEssence = changes.essence ?? entry.essence;
+    const nextDetails = changes.details === void 0 ? entry.details : changes.details;
+    const nextTags = changes.tags ?? entry.tags;
+    const nextTriggerConditions = changes.triggerConditions ?? entry.triggerConditions;
+    const nextImportance = clamp01(changes.importance ?? entry.importance);
+    const searchText = buildSearchTextFromParts(nextEssence, {
+      details: nextDetails,
+      tags: nextTags,
+      triggerConditions: nextTriggerConditions,
+      metadata: entry.metadata
+    });
+    const updated = {
+      ...row,
+      text: nextEssence,
+      essence: nextEssence,
+      details: nextDetails ?? null,
+      tags: JSON.stringify(normalizeStringArray(nextTags)),
+      trigger_conditions: JSON.stringify(normalizeStringArray(nextTriggerConditions)),
+      importance: nextImportance,
+      search_text: searchText,
+      embedding: this.db.vectorAvailable ? JSON.stringify(createEmbedding(searchText)) : row.embedding,
+      updated_at: nowString()
+    };
+    this.db.upsertByKey(updated);
+    return toMemoryEntry(updated);
+  }
+  async forget(key) {
+    return this.db.deleteByKey(key);
+  }
+  async recall(query, limit = 5) {
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 5;
+    const tokens = keywordTokens(query);
+    if (tokens.length === 0) {
+      return [];
+    }
+    const now = nowString();
+    const candidates = this.db.listAll().map((row) => toMemoryEntry(row));
+    const scored = candidates.map((entry) => {
+      const keywordScore = computeKeywordScore(entry, tokens);
+      if (keywordScore <= 0) {
+        return void 0;
+      }
+      const retention = computeRetention(entry.strength, entry.lastAccessedAt ?? entry.updatedAt, entry.decayTau, entry.importance, entry.accessCount);
+      return {
+        entry,
+        keywordScore,
+        retention
+      };
+    }).filter((candidate) => candidate !== void 0).map((candidate) => {
+      const finalScore = candidate.keywordScore * 0.7 + candidate.retention * 0.3;
+      return { ...candidate, finalScore };
+    }).sort((left, right) => right.finalScore - left.finalScore || right.retention - left.retention);
+    const results = [];
+    for (const selected of scored.slice(0, safeLimit)) {
+      const strengthenedStrength = reinforceOnAccess(selected.entry.strength, selected.entry.importance);
+      const strengthenedCount = selected.entry.accessCount + 1;
+      const row = this.db.getByKey(selected.entry.key);
+      if (row) {
+        this.db.upsertByKey({
+          ...row,
+          strength: strengthenedStrength,
+          access_count: strengthenedCount,
+          last_accessed_at: now,
+          updated_at: now
+        });
+        results.push({
+          ...selected.entry,
+          strength: strengthenedStrength,
+          accessCount: strengthenedCount,
+          lastAccessedAt: now,
+          updatedAt: now
+        });
+      } else {
+        results.push({
+          ...selected.entry,
+          strength: strengthenedStrength,
+          accessCount: strengthenedCount,
+          lastAccessedAt: now,
+          updatedAt: now
+        });
+      }
+    }
+    return results;
+  }
+  async consolidate() {
+    const now = Date.now();
+    const nowIso = toISOString(now);
+    const weekAgo = now - ONE_WEEK_IN_MS;
+    const rows = this.db.listAll();
+    const entries = rows.map((row) => toMemoryEntry(row));
+    const potentialDuplicates = [];
+    for (let index = 0; index < entries.length; index += 1) {
+      for (let inner = index + 1; inner < entries.length; inner += 1) {
+        const left = entries[index];
+        const right = entries[inner];
+        if (computeEssenceSimilarity(left.essence, right.essence) > 0.8) {
+          potentialDuplicates.push([left.key, right.key]);
+        }
+      }
+    }
+    let forgotten = 0;
+    let strengthened = 0;
+    const survivors = [];
+    for (const row of rows) {
+      const entry = toMemoryEntry(row);
+      const retention = computeRetention(entry.strength, entry.lastAccessedAt ?? entry.updatedAt, entry.decayTau, entry.importance, entry.accessCount);
+      if (retention < 0.1) {
+        if (this.db.deleteByKey(entry.key)) {
+          forgotten += 1;
+        }
+        continue;
+      }
+      const accessedRecently = entry.lastAccessedAt ? Date.parse(entry.lastAccessedAt) >= weekAgo : false;
+      if (accessedRecently) {
+        const nextStrength = reinforceOnAccess(entry.strength, entry.importance);
+        const nextCount = entry.accessCount + 1;
+        const searchText = buildSearchTextFromParts(entry.essence, {
+          details: entry.details,
+          tags: entry.tags,
+          triggerConditions: entry.triggerConditions,
+          metadata: entry.metadata
+        });
+        const updated = {
+          ...row,
+          strength: nextStrength,
+          access_count: nextCount,
+          last_accessed_at: nowIso,
+          updated_at: nowIso,
+          search_text: searchText,
+          embedding: this.db.vectorAvailable ? JSON.stringify(createEmbedding(searchText)) : row.embedding
+        };
+        this.db.upsertByKey(updated);
+        survivors.push(toMemoryEntry(updated));
+        strengthened += 1;
+      } else {
+        survivors.push(entry);
+      }
+    }
+    return {
+      forgotten,
+      strengthened,
+      total: this.db.listAll().length,
+      potentialDuplicates
+    };
+  }
+  async reflect() {
+    const rows = this.db.listAll();
+    if (rows.length === 0) {
+      return "## No memories yet.";
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of rows.map(toMemoryEntry)) {
+      const tag = entry.tags[0] ?? "untagged";
+      const bucket = groups.get(tag) ?? [];
+      bucket.push(entry);
+      groups.set(tag, bucket);
+    }
+    const lines = [];
+    for (const [tag, memories] of [...groups.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+      lines.push(`## ${tag}`);
+      for (const memory of memories) {
+        lines.push(`- **${memory.key}**: ${memory.essence}`);
+      }
+      lines.push("");
+    }
+    return lines.join("\n").trim();
+  }
+  async count() {
+    return this.db.listAll().length;
+  }
+  async search(query, topK = 5) {
+    const safeTopK = Number.isFinite(topK) ? Math.max(0, Math.floor(topK)) : 5;
+    if (safeTopK <= 0) {
+      return [];
+    }
+    if (this.db.vectorAvailable) {
+      const queryEmbedding = createEmbedding(query);
+      return this.db.listWithEmbeddings().map((row) => ({ row, score: cosineSimilarity(queryEmbedding, parseEmbedding(row.embedding)) })).sort((left, right) => right.score - left.score || compareRows(left.row, right.row)).slice(0, safeTopK).map(({ row }) => toMemoryEntry(row));
+    }
+    return this.db.searchByKeywords(query, safeTopK).map((row) => toMemoryEntry(row));
+  }
+  async list(limit = 50) {
+    const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 50;
+    if (safeLimit === 0) {
+      return [];
+    }
+    return this.db.list(safeLimit).map((row) => toMemoryEntry(row));
+  }
+  async store(text2, metadata = null) {
+    const key = randomUUID();
+    const entry = await this.memorize(key, text2, { tags: ["auto"] });
+    const row = this.db.getByKey(key);
+    if (row) {
+      const serializedMetadata = metadata ? JSON.stringify(metadata) : null;
+      if (row.metadata !== serializedMetadata) {
+        const searchText = buildSearchTextFromParts(entry.essence, {
+          details: entry.details,
+          tags: entry.tags,
+          triggerConditions: entry.triggerConditions,
+          metadata
+        });
+        this.db.upsertByKey({
+          ...row,
+          metadata: serializedMetadata,
+          search_text: searchText,
+          embedding: this.db.vectorAvailable ? JSON.stringify(createEmbedding(searchText)) : row.embedding
+        });
+      }
+    }
+    return entry.id;
+  }
+  async clear() {
+    this.db.clear();
+  }
+  close() {
+    this.db.close();
+  }
+};
+function buildSearchTextFromParts(essence, context) {
+  const searchMetadata = {
+    tags: context.tags,
+    triggerConditions: context.triggerConditions,
+    details: context.details,
+    ...context.metadata ?? {}
+  };
+  return buildSearchText(essence, searchMetadata);
+}
+function computeEssenceSimilarity(left, right) {
+  const leftTokens = new Set(keywordTokens(left));
+  const rightTokens = new Set(keywordTokens(right));
+  const union = /* @__PURE__ */ new Set([...leftTokens, ...rightTokens]);
+  if (union.size === 0) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const token of leftTokens) {
+    if (rightTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap / union.size;
+}
+function computeKeywordScore(entry, tokens) {
+  const normalizedTokens = new Set(tokens);
+  return Number(matchTokens(entry.tags, normalizedTokens)) * KEYWORD_WEIGHTS.tag + Number(matchText(entry.triggerConditions, normalizedTokens)) * KEYWORD_WEIGHTS.trigger + Number(matchText([entry.essence], normalizedTokens)) * KEYWORD_WEIGHTS.essence + Number(matchText(entry.details ? [entry.details] : [], normalizedTokens)) * KEYWORD_WEIGHTS.details;
+}
+function compareRows(left, right) {
+  return right.updated_at.localeCompare(left.updated_at) || right.created_at.localeCompare(left.created_at) || right.id.localeCompare(left.id);
+}
+function parseEmbedding(embedding) {
+  if (!embedding) {
+    return [];
+  }
+  const value = JSON.parse(embedding);
+  return Array.isArray(value) ? value.filter((item) => typeof item === "number") : [];
+}
+function parseMetadata(metadata) {
+  if (!metadata) {
+    return null;
+  }
+  const value = JSON.parse(metadata);
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseStringArray(raw) {
+  if (!raw) {
+    return [];
+  }
+  const value = JSON.parse(raw);
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => typeof item === "string" ? [item.trim()] : []).filter(Boolean);
+}
+function matchText(values, tokens) {
+  return values.flatMap((value) => keywordTokens(value)).some((token) => tokens.has(token));
+}
+function matchTokens(values, tokens) {
+  const normalizedValues = values.map((value) => value.toLowerCase());
+  return normalizedValues.some((value) => {
+    if (tokens.has(value)) {
+      return true;
+    }
+    return [...tokens].some((token) => value.includes(token));
+  });
+}
+function normalizeStringArray(values) {
+  return values.map((value) => value.toLowerCase().trim()).filter((value, index, array) => value.length > 0 && !array.slice(0, index).includes(value));
+}
+function toMemoryEntry(row) {
+  const tags = normalizeStringArray(parseStringArray(row.tags));
+  const triggerConditions = normalizeStringArray(parseStringArray(row.trigger_conditions));
+  const essence = row.essence || row.text;
+  return {
+    id: row.id,
+    key: row.key ?? row.id,
+    essence,
+    text: essence,
+    details: row.details ?? void 0,
+    tags,
+    triggerConditions,
+    importance: clamp01(row.importance),
+    strength: clamp01(row.strength),
+    decayTau: clampPositiveNumber(row.decay_tau, DEFAULT_DECAY_TAU),
+    lastAccessedAt: row.last_accessed_at ?? void 0,
+    accessCount: Math.max(0, Number.isFinite(row.access_count) ? row.access_count : 0),
+    metadata: parseMetadata(row.metadata),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at || row.created_at
+  };
+}
+function clamp01(value) {
+  return clamp2(value, 0, 1);
+}
+function clamp2(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return min;
+  }
+  return Math.max(min, Math.min(max, value));
+}
+function clampPositiveNumber(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function nowString() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toISOString(time) {
+  return new Date(time).toISOString();
+}
+
+// packages/memory/dist/default-store.js
+var defaultStore = null;
+function createMemoryStore(options = {}) {
+  return new MemoryStore({
+    dbPath: options.dbPath ?? join(homedir2(), ".va-claw", "memory.db"),
+    enableVectorSearch: options.enableVectorSearch,
+    vectorExtensionPath: options.vectorExtensionPath
+  });
+}
+async function store(text2, metadata) {
+  return getDefaultStore().store(text2, metadata ?? null);
+}
+async function memorize(key, essence, options) {
+  return getDefaultStore().memorize(key, essence, options);
+}
+async function get(key) {
+  return getDefaultStore().get(key);
+}
+async function update(key, changes) {
+  return getDefaultStore().update(key, changes);
+}
+async function forget(key) {
+  return getDefaultStore().forget(key);
+}
+async function recall(query, limit = 5) {
+  return getDefaultStore().recall(query, limit);
+}
+async function consolidate() {
+  return getDefaultStore().consolidate();
+}
+async function reflect() {
+  return getDefaultStore().reflect();
+}
+async function count() {
+  return getDefaultStore().count();
+}
+async function search(query, topK) {
+  return getDefaultStore().search(query, topK);
+}
+async function list(limit) {
+  return getDefaultStore().list(limit);
+}
+async function clear() {
+  return getDefaultStore().clear();
+}
+function getDefaultStore() {
+  defaultStore ??= createMemoryStore();
+  return defaultStore;
+}
+
+// packages/skills/dist/frontmatter.js
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseSkillMarkdown(source, path) {
+  const match = FRONTMATTER_RE.exec(source);
+  if (!match) {
+    throw new Error(`Skill "${path}" is missing YAML frontmatter.`);
+  }
+  const frontmatter = parseFrontmatterBlock(match[1]);
+  return {
+    ...frontmatter,
+    content: match[2].trim(),
+    path
+  };
+}
+function parseFrontmatterBlock(block) {
+  const values = /* @__PURE__ */ new Map();
+  const lines = block.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index];
+    const line = rawLine.trim();
+    if (line === "") {
+      continue;
+    }
+    const separator = line.indexOf(":");
+    if (separator === -1) {
+      throw new Error(`Invalid frontmatter line: ${rawLine}`);
+    }
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim();
+    if (value !== "") {
+      values.set(key, value);
+      continue;
+    }
+    const baseIndent = rawLine.length - rawLine.trimStart().length;
+    const items = [];
+    while (index + 1 < lines.length) {
+      const nextRawLine = lines[index + 1];
+      const nextLine = nextRawLine.trim();
+      if (nextLine === "") {
+        index += 1;
+        continue;
+      }
+      const nextIndent = nextRawLine.length - nextRawLine.trimStart().length;
+      if (nextIndent <= baseIndent) {
+        break;
+      }
+      if (!nextLine.startsWith("-")) {
+        throw new Error(`Invalid frontmatter line: ${nextRawLine}`);
+      }
+      items.push(nextLine.slice(1).trim());
+      index += 1;
+    }
+    values.set(key, items);
+  }
+  const name = parseScalar(values.get("name"), "name");
+  const description = parseScalar(values.get("description"), "description");
+  const version = parseScalar(values.get("version"), "version");
+  const triggers = parseArray(values.get("triggers"), "triggers");
+  return { name, description, version, triggers };
+}
+function parseScalar(rawValue, field) {
+  if (!rawValue) {
+    throw new Error(`Skill frontmatter is missing "${field}".`);
+  }
+  if (Array.isArray(rawValue)) {
+    throw new Error(`Skill frontmatter field "${field}" must be a scalar.`);
+  }
+  if (rawValue.startsWith("'") && rawValue.endsWith("'") || rawValue.startsWith('"') && rawValue.endsWith('"')) {
+    return rawValue.slice(1, -1);
+  }
+  return rawValue;
+}
+function parseArray(rawValue, field) {
+  if (!rawValue) {
+    throw new Error(`Skill frontmatter is missing "${field}".`);
+  }
+  if (Array.isArray(rawValue)) {
+    return rawValue.map((item) => parseScalar(item.trim(), field));
+  }
+  if (!rawValue.startsWith("[") || !rawValue.endsWith("]")) {
+    throw new Error(`Skill frontmatter field "${field}" must be an array.`);
+  }
+  const body = rawValue.slice(1, -1).trim();
+  if (body === "") {
+    return [];
+  }
+  return splitInlineArray(body).map((item) => parseScalar(item.trim(), field));
+}
+function splitInlineArray(value) {
+  const items = [];
+  let current = "";
+  let quote = null;
+  for (const character of value) {
+    if ((character === "'" || character === '"') && quote === null) {
+      quote = character;
+      current += character;
+      continue;
+    }
+    if (quote !== null && character === quote) {
+      quote = null;
+      current += character;
+      continue;
+    }
+    if (character === "," && quote === null) {
+      items.push(current);
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current !== "") {
+    items.push(current);
+  }
+  return items;
+}
+
+// packages/skills/dist/paths.js
+import { homedir as homedir3 } from "node:os";
+import { isAbsolute, join as join2, resolve as resolve2 } from "node:path";
+var overrides = {};
+function resolveInstalledSkillsDir() {
+  const baseDir = overrides.homeDir ? resolve2(overrides.homeDir) : resolve2(homedir3(), ".va-claw");
+  return join2(baseDir, "skills");
+}
+function resolveProjectSkillsDir() {
+  const baseDir = overrides.projectDir ? resolve2(overrides.projectDir) : process.cwd();
+  return join2(baseDir, "skills");
+}
+function resolveSkillLookupDirs(dir) {
+  if (dir) {
+    return [resolvePathInput(dir)];
+  }
+  return [resolveProjectSkillsDir(), resolveInstalledSkillsDir()];
+}
+function resolvePathInput(value) {
+  if (value === "~") {
+    return homedir3();
+  }
+  if (value.startsWith("~/")) {
+    return resolve2(homedir3(), value.slice(2));
+  }
+  return isAbsolute(value) ? value : resolve2(value);
+}
+function toSkillFileName(name) {
+  const normalized = name.trim().replace(/\.md$/i, "");
+  if (normalized === "") {
+    throw new Error("Skill name cannot be empty.");
+  }
+  if (!/^[a-z0-9][a-z0-9-_]*$/i.test(normalized)) {
+    throw new Error(`Invalid skill name: ${name}`);
+  }
+  return `${normalized}.md`;
+}
+
+// packages/skills/dist/search.js
+function matchesSkillQuery(skill, query) {
+  const normalizedQuery = normalize(query);
+  if (normalizedQuery === "") {
+    return true;
+  }
+  const haystack = normalize([skill.name, skill.description, ...skill.triggers].join(" "));
+  if (haystack.includes(normalizedQuery)) {
+    return true;
+  }
+  return tokenize2(query).some((token) => token.length > 1 && haystack.includes(token));
+}
+function tokenize2(value) {
+  return normalize(value).split(/[^a-z0-9]+/).filter(Boolean);
+}
+function normalize(value) {
+  return value.trim().toLowerCase();
+}
+
+// packages/skills/dist/store.js
+import { access, mkdir as mkdir2, readFile as readFile2, readdir, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+async function loadSkill(nameOrPath) {
+  const path = await resolveSkillPath(nameOrPath);
+  return readSkillFile(path);
+}
+async function listSkills(dir) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const lookupDir of resolveSkillLookupDirs(dir)) {
+    for (const skill of await readSkillsFromDir(lookupDir)) {
+      if (seen.has(skill.name)) {
+        continue;
+      }
+      seen.add(skill.name);
+      skills.push(skill);
+    }
+  }
+  return skills;
+}
+async function installSkill(content, name) {
+  const skillPath = join3(resolveInstalledSkillsDir(), toSkillFileName(name));
+  parseSkillMarkdown(content, skillPath);
+  await mkdir2(resolveInstalledSkillsDir(), { recursive: true });
+  await writeFile2(skillPath, content, "utf8");
+  return skillPath;
+}
+async function removeSkill(name) {
+  await rm(join3(resolveInstalledSkillsDir(), toSkillFileName(name)), { force: true });
+}
+function injectSkillIntoPrompt(skill, basePrompt) {
+  const prompt = basePrompt.trimEnd();
+  const skillBlock = [`[Skill: ${skill.name}@${skill.version}]`, skill.content.trim()].join("\n");
+  return prompt === "" ? skillBlock : `${prompt}
+
+${skillBlock}`;
+}
+async function resolveSkillPath(nameOrPath) {
+  const candidates = looksLikePath(nameOrPath) ? [resolvePathInput(nameOrPath)] : resolveSkillLookupDirs().map((dir) => join3(dir, toSkillFileName(nameOrPath)));
+  for (const candidate of candidates) {
+    if (await exists(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Skill not found: ${nameOrPath}`);
+}
+async function readSkillsFromDir(dir) {
+  if (!await exists(dir)) {
+    return [];
+  }
+  const names = (await readdir(dir)).filter((entry) => entry.toLowerCase().endsWith(".md")).sort();
+  return Promise.all(names.map((name) => readSkillFile(join3(dir, name))));
+}
+async function readSkillFile(path) {
+  return parseSkillMarkdown(await readFile2(path, "utf8"), path);
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function looksLikePath(value) {
+  return /[\\/]/.test(value) || value.startsWith(".") || value.startsWith("~") || value.endsWith(".md");
+}
+
+// packages/daemon/dist/wake-cycle.js
+var DEFAULT_WARN2 = (message) => console.warn(message);
+async function runWakeCycle(config, deps = {}) {
+  const adapter = await (deps.detect ?? detectCliAdapter)({ warn: deps.warn });
+  if (!adapter) {
+    return null;
+  }
+  const prompt = await resolveWakePrompt(config, deps);
+  const spawnOptions = {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    env: {
+      ...readProcessEnv(),
+      CLAUDECODE: void 0,
+      CLAUDE_CODE_SESSION: void 0
+    },
+    maxBuffer: 10 * 1024 * 1024
+  };
+  const result = (deps.spawn ?? spawnSync2)(adapter.command, [...adapter.args, prompt], spawnOptions);
+  if (result.status !== 0) {
+    (deps.warn ?? DEFAULT_WARN2)(`[va-claw/daemon] ${adapter.name} wake failed: ${readStderr(result.stderr)}`);
+    return null;
+  }
+  const wokeAt = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  await (deps.storeMemory ?? store)(result.stdout ?? "", {
+    source: "va-claw-daemon",
+    kind: "wake",
+    cli: adapter.name,
+    identity: config.name,
+    wokeAt: wokeAt.toISOString()
+  });
+  return wokeAt;
+}
+function readStderr(stderr) {
+  if (typeof stderr === "string" && stderr.trim() !== "") {
+    return stderr.trim();
+  }
+  return "unknown error";
+}
+function readProcessEnv() {
+  return process.env ?? {};
+}
+async function resolveWakePrompt(config, deps) {
+  try {
+    const skills = await (deps.listSkills ?? listSkills)();
+    return skills.filter((skill) => matchesSkillQuery(skill, config.wakePrompt)).reduce((prompt, skill) => (deps.injectSkill ?? injectSkillIntoPrompt)(skill, prompt), config.wakePrompt);
+  } catch (error) {
+    (deps.warn ?? DEFAULT_WARN2)(`[va-claw/daemon] skill injection skipped: ${String(error)}`);
+    return config.wakePrompt;
+  }
+}
+
+// packages/daemon/dist/runtime.js
+var runtimeState = {
+  discord: null,
+  job: null,
+  wakeCount: 0
+};
+var runtimeDeps = {
+  createScheduler(pattern, onTick) {
+    const job = new E(pattern, { catch: false }, () => {
+      void onTick().catch((error) => {
+        console.warn(`[va-claw/daemon] wake tick failed: ${String(error)}`);
+      });
+    });
+    return { stop: () => job.stop() };
+  },
+  async startDiscord(config) {
+    const moduleUrl = new URL("../../channels/discord/dist/index.js", import.meta.url);
+    const channelModule = await import(moduleUrl.href);
+    return channelModule.startDiscordChannel(config);
+  },
+  wake: runWakeCycle
+};
+async function startDaemon(config) {
+  await stopDaemon();
+  runtimeState.wakeCount = 0;
+  runtimeState.lastWakeAt = void 0;
+  runtimeState.discord = null;
+  if (config.channels.discord.autoStart) {
+    runtimeState.discord = await runtimeDeps.startDiscord({
+      token: config.channels.discord.token,
+      clientId: config.channels.discord.clientId,
+      cliCommand: config.channels.discord.cliCommand
+    });
+  }
+  runtimeState.job = runtimeDeps.createScheduler(config.loopInterval, async () => {
+    const wokeAt = await runtimeDeps.wake(config);
+    if (!wokeAt) {
+      return;
+    }
+    runtimeState.lastWakeAt = wokeAt;
+    runtimeState.wakeCount += 1;
+  });
+}
+async function stopDaemon() {
+  await runtimeState.discord?.stop();
+  runtimeState.discord = null;
+  runtimeState.job?.stop();
+  runtimeState.job = null;
+}
+async function getDaemonStatus() {
+  return {
+    discord: runtimeState.discord?.status() ?? "disconnected",
+    running: runtimeState.job !== null,
+    lastWakeAt: runtimeState.lastWakeAt ? new Date(runtimeState.lastWakeAt) : void 0,
+    wakeCount: runtimeState.wakeCount
+  };
+}
+
+// packages/daemon/dist/service.js
+import { mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+
+// packages/daemon/dist/service-files.js
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+function createServiceDefinition(type) {
+  const packageRoot = resolve3(dirname3(fileURLToPath(import.meta.url)), "..");
+  const repoRoot = resolve3(packageRoot, "../..");
+  const runnerPath = join4(packageRoot, "dist", "runner.js");
+  const nodePath = process.execPath;
+  if (type === "launchd") {
+    return {
+      path: join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist"),
+      content: renderLaunchdPlist(repoRoot, [nodePath, runnerPath]),
+      command: "launchctl",
+      args: ["load", join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
+    };
+  }
+  return {
+    path: join4(homedir4(), ".config", "systemd", "user", "va-claw.service"),
+    content: renderSystemdUnit(repoRoot, [nodePath, runnerPath]),
+    command: "systemctl",
+    args: ["--user", "enable", "--now", "va-claw.service"]
+  };
+}
+function createUninstallCommand(type) {
+  if (type === "launchd") {
+    return {
+      command: "launchctl",
+      args: ["unload", join4(homedir4(), "Library", "LaunchAgents", "com.va-claw.daemon.plist")]
+    };
+  }
+  return {
+    command: "systemctl",
+    args: ["--user", "disable", "--now", "va-claw.service"]
+  };
+}
+function renderLaunchdPlist(workingDirectory, programArguments) {
+  const argsXml = programArguments.map((arg) => `    <string>${escapeXml(arg)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.va-claw.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(workingDirectory)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+</dict>
+</plist>
+`;
+}
+function renderSystemdUnit(workingDirectory, programArguments) {
+  return `[Unit]
+Description=va-claw daemon
+
+[Service]
+Type=simple
+WorkingDirectory=${workingDirectory}
+ExecStart=${programArguments.map(quoteSystemdArg).join(" ")}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function quoteSystemdArg(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
+// packages/daemon/dist/service.js
+async function installDaemonService(type) {
+  const definition = createServiceDefinition(type);
+  await mkdir3(dirname4(definition.path), { recursive: true });
+  await writeFile3(definition.path, definition.content, "utf8");
+  if (type === "systemd") {
+    runCommand("systemctl", ["--user", "daemon-reload"]);
+  }
+  runCommand(definition.command, definition.args);
+}
+async function uninstallDaemonService(type) {
+  const definition = createServiceDefinition(type);
+  const uninstall = createUninstallCommand(type);
+  runCommand(uninstall.command, uninstall.args, true);
+  await rm2(definition.path, { force: true });
+  if (type === "systemd") {
+    runCommand("systemctl", ["--user", "daemon-reload"], true);
+  }
+}
+function runCommand(command, args, allowFailure = false) {
+  const result = spawnSync3(command, args, { encoding: "utf8" });
+  if (allowFailure || result.status === 0) {
+    return;
+  }
+  const stderr = result.stderr?.trim() || result.stdout?.trim() || "unknown error";
+  throw new Error(`[va-claw/daemon] command failed: ${command} ${args.join(" ")}: ${stderr}`);
+}
+
+// packages/cli/dist/install-files.js
+import { access as access2, mkdir as mkdir4, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, join as join5 } from "node:path";
+var CLAUDE_MARKERS = {
+  start: "<!-- va-claw:identity:start -->",
+  end: "<!-- va-claw:identity:end -->"
+};
+var CODEX_MARKERS = {
+  start: "<!-- va-claw:codex:start -->",
+  end: "<!-- va-claw:codex:end -->"
+};
+function resolveClaudeMdPath(home = homedir5()) {
+  return join5(home, ".claude", "CLAUDE.md");
+}
+function resolveCodexInstructionsPath(home = homedir5()) {
+  return join5(home, ".codex", "instructions.md");
+}
+function resolveMemoryDbPath(home = homedir5()) {
+  return join5(home, ".va-claw", "memory.db");
+}
+async function fileExists(path) {
+  try {
+    await access2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function upsertManagedBlock(path, block, markers) {
+  const current = (await readOptionalFile(path)).trim();
+  const next = appendManagedBlock(current, block, markers);
+  await mkdir4(dirname5(path), { recursive: true });
+  await writeFile4(path, next, "utf8");
+}
+async function removeManagedBlock(path, markers) {
+  const current = await readOptionalFile(path);
+  if (current === "") {
+    return;
+  }
+  const next = stripManagedBlock(current, markers).trim();
+  await mkdir4(dirname5(path), { recursive: true });
+  await writeFile4(path, next === "" ? "" : `${next}
+`, "utf8");
+}
+function wrapCodexPrompt(prompt) {
+  return [CODEX_MARKERS.start, prompt.trim(), CODEX_MARKERS.end].join("\n");
+}
+function appendManagedBlock(source, block, markers) {
+  const stripped = stripManagedBlock(source, markers).trim();
+  const suffix = block.trim();
+  return stripped === "" ? `${suffix}
+` : `${stripped}
+
+${suffix}
+`;
+}
+function stripManagedBlock(source, markers) {
+  const escaped = [markers.start, markers.end].map(escapeRegExp);
+  const pattern = new RegExp(`\\s*${escaped[0]}[\\s\\S]*?${escaped[1]}\\s*`, "g");
+  return source.replace(pattern, "\n");
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile3(path, "utf8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// packages/cli/dist/deps.js
+function createDefaultCliDeps() {
+  return {
+    claudePath: resolveClaudeMdPath(),
+    codexPath: resolveCodexInstructionsPath(),
+    configPath: DEFAULT_CONFIG_PATH,
+    memoryDbPath: resolveMemoryDbPath(),
+    platform: process.platform,
+    spawnSync: spawnSync4,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    fileExists,
+    readTextFile: (path) => readFile4(path, "utf8"),
+    upsertManagedBlock,
+    removeManagedBlock,
+    wrapCodexPrompt,
+    loadIdentity: () => loadIdentity(),
+    saveIdentity: (config) => saveIdentity(config),
+    runInstallWizard,
+    toClaudeMdSnippet,
+    toCodexSystemPrompt,
+    installDaemonService,
+    uninstallDaemonService,
+    startDaemon,
+    stopDaemon,
+    getDaemonStatus,
+    memoryMemorize: (key, essence, options) => memorize(key, essence, options),
+    memoryGet: (key) => get(key),
+    memoryUpdate: (key, changes) => update(key, changes),
+    memoryForget: (key) => forget(key),
+    memoryRecall: (query, limit) => recall(query, limit),
+    memoryConsolidate: () => consolidate(),
+    memoryReflect: () => reflect(),
+    memoryCount: () => count(),
+    memorySearch: (query, limit) => search(query, limit),
+    memoryList: (limit) => list(limit),
+    memoryClear: () => clear(),
+    startTelegramChannel: (config) => loadChannelsModule().then((module) => module.startTelegramChannel(config)),
+    stopTelegramChannel: (channel) => loadChannelsModule().then((module) => module.stopTelegramChannel(channel)),
+    startSlackChannel: (config) => loadChannelsModule().then((module) => module.startSlackChannel(config)),
+    stopSlackChannel: (channel) => loadChannelsModule().then((module) => module.stopSlackChannel(channel)),
+    skillInstall: (content, name) => installSkill(content, name),
+    skillList: (dir) => listSkills(dir),
+    skillLoad: (nameOrPath) => loadSkill(nameOrPath),
+    skillRemove: (name) => removeSkill(name),
+    confirm: (message) => askForConfirmation(message),
+    prompt: (message, initialValue) => askForValue(message, initialValue)
+  };
+}
+async function askForConfirmation(message) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const value = await rl.question(`${message} [y/N] `);
+    return ["y", "yes"].includes(value.trim().toLowerCase());
+  } finally {
+    rl.close();
+  }
+}
+async function askForValue(message, initialValue = "") {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const suffix = initialValue.trim() === "" ? "" : ` [${initialValue}]`;
+  try {
+    const value = await rl.question(`${message}${suffix} `);
+    return value.trim() === "" ? initialValue : value.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function loadChannelsModule() {
+  const moduleUrl = new URL("../../channels/dist/index.js", import.meta.url);
+  return import(moduleUrl.href);
+}
+
+// packages/cli/dist/output.js
+function formatMemoryEntries(entries) {
+  if (entries.length === 0) {
+    return "No memory entries found.";
+  }
+  return entries.map((entry, index) => {
+    const lines = [
+      `${index + 1}. ${entry.text}`,
+      `   id: ${entry.id}`,
+      `   key: ${entry.key}`,
+      `   created: ${entry.createdAt}`,
+      `   updated: ${entry.updatedAt}`,
+      `   tags: ${entry.tags.join(", ") || "(none)"}`
+    ];
+    if (entry.metadata) {
+      lines.push(`   metadata: ${JSON.stringify(entry.metadata)}`);
+    }
+    if (entry.details) {
+      lines.push(`   details: ${entry.details}`);
+    }
+    if (entry.triggerConditions.length > 0) {
+      lines.push(`   trigger_conditions: ${entry.triggerConditions.join(", ")}`);
+    }
+    lines.push(`   importance: ${entry.importance}`, `   strength: ${entry.strength}`, `   access_count: ${entry.accessCount}`);
+    return lines.join("\n");
+  }).join("\n\n");
+}
+function formatSkills(skills) {
+  if (skills.length === 0) {
+    return "No skills found.";
+  }
+  return skills.map((skill) => [
+    `${skill.name} (${skill.version})`,
+    `  description: ${skill.description}`,
+    `  triggers: ${skill.triggers.join(", ") || "(none)"}`,
+    `  path: ${skill.path}`
+  ].join("\n")).join("\n\n");
+}
+function writeLine(stream, message) {
+  stream.write(`${message}
+`);
+}
+
+// packages/cli/dist/wait.js
+async function waitForStopSignal(stop) {
+  await new Promise((resolve4, reject) => {
+    let stopping = false;
+    const cleanup = () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+    };
+    const onSignal = () => {
+      if (stopping) {
+        return;
+      }
+      stopping = true;
+      void stop().then(() => {
+        cleanup();
+        resolve4();
+      }, (error) => {
+        cleanup();
+        reject(error);
+      });
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  });
+}
+
+// packages/cli/dist/channel-handlers.js
+async function runTelegramChannelSetup(token, cliCommand, deps) {
+  const config = await deps.loadIdentity();
+  const next = withChannels(config, {
+    telegram: {
+      ...config.channels.telegram,
+      token: token ?? config.channels.telegram.token,
+      cliCommand: cliCommand ?? config.channels.telegram.cliCommand
+    }
+  });
+  ensureTelegramConfigured(next);
+  await deps.saveIdentity(next);
+  writeLine(deps.stdout, `Saved Telegram config to ${deps.configPath}`);
+}
+async function runTelegramChannelStart(deps) {
+  const config = await deps.loadIdentity();
+  ensureTelegramConfigured(config);
+  const channel = await deps.startTelegramChannel(config.channels.telegram);
+  writeLine(deps.stdout, "Telegram channel started in foreground. Press Ctrl+C to stop.");
+  await waitForStopSignal(async () => {
+    await deps.stopTelegramChannel(channel);
+    writeLine(deps.stdout, "Telegram channel stopped.");
+  });
+}
+async function runTelegramChannelStatus(deps) {
+  const config = await deps.loadIdentity();
+  writeLine(deps.stdout, `Telegram configured: ${config.channels.telegram.token ? "yes" : "no"}`);
+  writeLine(deps.stdout, `Telegram CLI command: ${config.channels.telegram.cliCommand || "va-claw"}`);
+}
+async function runSlackChannelSetup(botToken, appToken, cliCommand, deps) {
+  const config = await deps.loadIdentity();
+  const next = withChannels(config, {
+    slack: {
+      ...config.channels.slack,
+      botToken: botToken ?? config.channels.slack.botToken,
+      appToken: appToken ?? config.channels.slack.appToken,
+      cliCommand: cliCommand ?? config.channels.slack.cliCommand
+    }
+  });
+  ensureSlackConfigured(next);
+  await deps.saveIdentity(next);
+  writeLine(deps.stdout, `Saved Slack config to ${deps.configPath}`);
+}
+async function runSlackChannelStart(deps) {
+  const config = await deps.loadIdentity();
+  ensureSlackConfigured(config);
+  const channel = await deps.startSlackChannel(config.channels.slack);
+  writeLine(deps.stdout, "Slack channel started in foreground. Press Ctrl+C to stop.");
+  await waitForStopSignal(async () => {
+    await deps.stopSlackChannel(channel);
+    writeLine(deps.stdout, "Slack channel stopped.");
+  });
+}
+async function runSlackChannelStatus(deps) {
+  const config = await deps.loadIdentity();
+  const configured = config.channels.slack.botToken !== "" && config.channels.slack.appToken !== "";
+  writeLine(deps.stdout, `Slack configured: ${configured ? "yes" : "no"}`);
+  writeLine(deps.stdout, `Slack CLI command: ${config.channels.slack.cliCommand || "va-claw"}`);
+}
+function ensureTelegramConfigured(config) {
+  if (!config.channels.telegram.token) {
+    throw new Error("Telegram token is required. Use `va-claw channel telegram setup --token <token>`.");
+  }
+}
+function ensureSlackConfigured(config) {
+  if (!config.channels.slack.botToken || !config.channels.slack.appToken) {
+    throw new Error("Slack bot/app tokens are required. Use `va-claw channel slack setup --bot-token <token> --app-token <token>`.");
+  }
+}
+function withChannels(config, patch) {
+  return {
+    ...config,
+    channels: {
+      ...config.channels,
+      ...patch
+    }
+  };
+}
+
+// packages/cli/dist/memory-status.js
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+async function countMemoryEntries(memoryDbPath, fileExists2) {
+  if (!await fileExists2(memoryDbPath)) {
+    return 0;
+  }
+  const db = new DatabaseSync2(memoryDbPath);
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
+    return Number(row?.count ?? 0);
+  } finally {
+    db.close();
+  }
+}
+async function findLastWakeAt(memoryDbPath, fileExists2) {
+  if (!await fileExists2(memoryDbPath)) {
+    return null;
+  }
+  const db = new DatabaseSync2(memoryDbPath);
+  try {
+    const rows = db.prepare("SELECT metadata, created_at FROM memories ORDER BY created_at DESC LIMIT 100").all();
+    for (const row of rows) {
+      const metadata = parseMetadata2(row.metadata);
+      if (metadata?.source === "va-claw-daemon" || metadata?.kind === "wake") {
+        return typeof metadata.wokeAt === "string" ? metadata.wokeAt : row.created_at;
+      }
+    }
+    return null;
+  } finally {
+    db.close();
+  }
+}
+function parseMetadata2(raw) {
+  if (!raw) {
+    return null;
+  }
+  const value = JSON.parse(raw);
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+// packages/cli/dist/platform.js
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+function detectServiceType(platform) {
+  if (platform === "darwin") {
+    return "launchd";
+  }
+  if (platform === "linux") {
+    return "systemd";
+  }
+  throw new Error(`Unsupported platform for va-claw daemon service: ${platform}`);
+}
+function probeServiceRunning(type, spawnSync5) {
+  if (type === "launchd") {
+    return spawnSync5("launchctl", ["list", "com.va-claw.daemon"], { encoding: "utf8" }).status === 0;
+  }
+  const result = spawnSync5("systemctl", ["--user", "is-active", "va-claw.service"], {
+    encoding: "utf8"
+  });
+  return result.status === 0 && result.stdout.trim() === "active";
+}
+function stopInstalledService(type, spawnSync5) {
+  if (type === "launchd") {
+    spawnSync5("launchctl", ["unload", resolveLaunchdPath()], { encoding: "utf8" });
+    return;
+  }
+  spawnSync5("systemctl", ["--user", "stop", "va-claw.service"], { encoding: "utf8" });
+}
+function resolveLaunchdPath() {
+  return join6(homedir6(), "Library", "LaunchAgents", "com.va-claw.daemon.plist");
+}
+
+// packages/cli/dist/handlers.js
+async function runInstall(target, deps) {
+  const installTarget = normalizeInstallTarget(target);
+  const config = await deps.fileExists(deps.configPath) ? await deps.loadIdentity() : await deps.runInstallWizard();
+  const summary = [`Installed va-claw for ${installTarget}.`, `Config: ${deps.configPath}`];
+  if (installTarget === "claude-code" || installTarget === "all") {
+    await deps.upsertManagedBlock(deps.claudePath, deps.toClaudeMdSnippet(config), CLAUDE_MARKERS);
+    summary.push(`CLAUDE.md: ${deps.claudePath}`);
+  }
+  if (installTarget === "codex" || installTarget === "all") {
+    const prompt = deps.wrapCodexPrompt(deps.toCodexSystemPrompt(config));
+    await deps.upsertManagedBlock(deps.codexPath, prompt, CODEX_MARKERS);
+    summary.push(`Codex instructions: ${deps.codexPath}`);
+  }
+  const serviceType = detectServiceType(deps.platform);
+  await deps.installDaemonService(serviceType);
+  summary.push(`Daemon service: ${serviceType}`);
+  for (const line of summary) {
+    writeLine(deps.stdout, line);
+  }
+}
+async function runStart(deps) {
+  const config = await deps.loadIdentity();
+  await deps.startDaemon(config);
+  writeLine(deps.stdout, "va-claw daemon started in foreground. Press Ctrl+C to stop.");
+  await waitForStopSignal(async () => {
+    await deps.stopDaemon();
+    writeLine(deps.stdout, "va-claw daemon stopped.");
+  });
+}
+async function runStop(deps) {
+  await deps.stopDaemon();
+  const serviceType = safeDetectServiceType(deps.platform);
+  if (serviceType) {
+    stopInstalledService(serviceType, deps.spawnSync);
+  }
+  writeLine(deps.stdout, "va-claw stop requested.");
+}
+async function runStatus(deps) {
+  const runtime = await deps.getDaemonStatus();
+  const serviceType = safeDetectServiceType(deps.platform);
+  const serviceRunning = serviceType ? probeServiceRunning(serviceType, deps.spawnSync) : false;
+  const lastWakeAt = runtime.lastWakeAt?.toISOString() ?? await findLastWakeAt(deps.memoryDbPath, deps.fileExists);
+  const memoryCount = await countMemoryEntries(deps.memoryDbPath, deps.fileExists);
+  writeLine(deps.stdout, `Daemon: ${runtime.running || serviceRunning ? "running" : "stopped"}`);
+  writeLine(deps.stdout, `Discord: ${runtime.discord}`);
+  writeLine(deps.stdout, `Last wake: ${lastWakeAt ?? "never"}`);
+  writeLine(deps.stdout, `Memory entries: ${memoryCount}`);
+}
+async function runMemorySearch(query, deps) {
+  writeLine(deps.stdout, formatMemoryEntries(await deps.memorySearch(query, 10)));
+}
+async function runMemoryList(deps) {
+  writeLine(deps.stdout, formatMemoryEntries(await deps.memoryList(20)));
+}
+async function runMemoryMemorize(key, essence, options, deps) {
+  const importance = options.importance === void 0 ? void 0 : Number(options.importance);
+  const entry = await deps.memoryMemorize(key, essence, {
+    tags: options.tags ? splitCommaList(options.tags) : [],
+    details: options.details,
+    importance: Number.isFinite(importance) ? importance : void 0
+  });
+  writeLine(deps.stdout, formatMemoryEntries([entry]));
+}
+async function runMemoryGet(key, deps) {
+  const entry = await deps.memoryGet(key);
+  if (!entry) {
+    writeLine(deps.stdout, `Memory not found: ${key}`);
+    return;
+  }
+  writeLine(deps.stdout, formatMemoryEntries([entry]));
+}
+async function runMemoryUpdate(key, options, deps) {
+  const importance = options.importance === void 0 ? void 0 : Number(options.importance);
+  const entry = await deps.memoryUpdate(key, {
+    essence: options.essence,
+    tags: options.tags ? splitCommaList(options.tags) : void 0,
+    details: options.details,
+    importance: Number.isFinite(importance) ? importance : void 0
+  });
+  if (!entry) {
+    writeLine(deps.stdout, `Memory not found: ${key}`);
+    return;
+  }
+  writeLine(deps.stdout, formatMemoryEntries([entry]));
+}
+async function runMemoryForget(key, deps) {
+  const removed = await deps.memoryForget(key);
+  writeLine(deps.stdout, removed ? `Forgot memory: ${key}` : `Memory not found: ${key}`);
+}
+async function runMemoryRecall(query, limit, deps) {
+  writeLine(deps.stdout, formatMemoryEntries(await deps.memoryRecall(query, limit)));
+}
+async function runMemoryConsolidate(deps) {
+  writeLine(deps.stdout, JSON.stringify(await deps.memoryConsolidate(), null, 2));
+}
+async function runMemoryReflect(deps) {
+  writeLine(deps.stdout, await deps.memoryReflect());
+}
+async function runMemoryClear(deps) {
+  if (!await deps.confirm("Clear all va-claw memory entries?")) {
+    writeLine(deps.stdout, "Memory clear aborted.");
+    return;
+  }
+  await deps.memoryClear();
+  writeLine(deps.stdout, "Memory cleared.");
+}
+async function runDiscordSetup(deps) {
+  const config = await deps.loadIdentity();
+  const token = await deps.prompt("Discord Bot Token", config.channels.discord.token);
+  const clientId = await deps.prompt("Discord Client ID", config.channels.discord.clientId);
+  await deps.saveIdentity({
+    ...config,
+    channels: {
+      ...config.channels,
+      discord: {
+        ...config.channels.discord,
+        token,
+        clientId
+      }
+    }
+  });
+  writeLine(deps.stdout, `Saved Discord config to ${deps.configPath}`);
+}
+async function runDiscordStart(deps) {
+  const config = await deps.loadIdentity();
+  const discord = await loadDiscordChannelModule();
+  const channel = await discord.startDiscordChannel({
+    token: config.channels.discord.token,
+    clientId: config.channels.discord.clientId,
+    cliCommand: config.channels.discord.cliCommand
+  });
+  writeLine(deps.stdout, "Discord channel started in foreground. Press Ctrl+C to stop.");
+  await waitForStopSignal(async () => {
+    await discord.stopDiscordChannel(channel);
+    writeLine(deps.stdout, "Discord channel stopped.");
+  });
+}
+async function runDiscordStatus(deps) {
+  const config = await deps.loadIdentity();
+  const configured = config.channels.discord.token.trim() !== "" && config.channels.discord.clientId.trim() !== "";
+  const runtime = await deps.getDaemonStatus();
+  writeLine(deps.stdout, `Discord: ${configured ? runtime.discord : "disconnected"}`);
+  writeLine(deps.stdout, `Configured: ${configured ? "yes" : "no"}`);
+  writeLine(deps.stdout, `Auto-start: ${config.channels.discord.autoStart ? "enabled" : "disabled"}`);
+}
+async function runSkillList(deps) {
+  writeLine(deps.stdout, formatSkills(await deps.skillList()));
+}
+async function runSkillAdd(pathOrUrl, deps) {
+  if (/^https?:\/\//i.test(pathOrUrl)) {
+    throw new Error("Network installs are not supported. Use a local skill file path.");
+  }
+  const source = await deps.skillLoad(pathOrUrl);
+  const content = await deps.readTextFile(source.path);
+  const installedPath = await deps.skillInstall(content, source.name);
+  writeLine(deps.stdout, `Installed skill ${source.name} -> ${installedPath}`);
+}
+async function runSkillRemove(name, deps) {
+  await deps.skillRemove(name);
+  writeLine(deps.stdout, `Removed skill ${name}.`);
+}
+async function runSkillShow(name, deps) {
+  const skill = await deps.skillLoad(name);
+  writeLine(deps.stdout, await deps.readTextFile(skill.path));
+}
+async function runUninstall(deps) {
+  const serviceType = detectServiceType(deps.platform);
+  await deps.uninstallDaemonService(serviceType);
+  await deps.removeManagedBlock(deps.claudePath, CLAUDE_MARKERS);
+  await deps.removeManagedBlock(deps.codexPath, CODEX_MARKERS);
+  writeLine(deps.stdout, "va-claw uninstalled.");
+}
+function normalizeInstallTarget(target) {
+  if (target === "claude-code" || target === "codex" || target === "all") {
+    return target;
+  }
+  throw new Error(`Invalid --for target: ${target}`);
+}
+function safeDetectServiceType(platform) {
+  try {
+    return detectServiceType(platform);
+  } catch {
+    return null;
+  }
+}
+async function loadDiscordChannelModule() {
+  const moduleUrl = new URL("../../channels/discord/dist/index.js", import.meta.url);
+  return import(moduleUrl.href);
+}
+function splitCommaList(value) {
+  return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+
+// node_modules/.pnpm/commander@file+vendor+commander/node_modules/commander/index.js
+var Command = class _Command {
+  constructor(name = "") {
+    this._name = name;
+    this._description = "";
+    this._action = null;
+    this._arguments = [];
+    this._options = [];
+    this._parsedOptions = {};
+    this.commands = [];
+    this.parent = null;
+  }
+  name(value) {
+    this._name = value;
+    return this;
+  }
+  description(value) {
+    this._description = value;
+    return this;
+  }
+  showHelpAfterError() {
+    return this;
+  }
+  command(spec) {
+    const child = new _Command(spec.trim().split(/\s+/)[0]);
+    child.parent = this;
+    this.commands.push(child);
+    return child;
+  }
+  argument(spec) {
+    this._arguments.push({ required: spec.startsWith("<"), name: spec.slice(1, -1) });
+    return this;
+  }
+  option(flags, _description, defaultValue) {
+    const long = flags.match(/--([a-z0-9-]+)/i)?.[1];
+    if (!long) throw new Error(`Unsupported option flags: ${flags}`);
+    const key = long.replace(/-([a-z])/g, (_2, letter) => letter.toUpperCase());
+    this._options.push({ key, flag: `--${long}`, requiresValue: /<.+>/.test(flags), defaultValue });
+    return this;
+  }
+  action(handler) {
+    this._action = handler;
+    return this;
+  }
+  opts() {
+    return { ...this._parsedOptions };
+  }
+  async parseAsync(argv) {
+    await this._dispatch(argv.slice(2));
+  }
+  async _dispatch(tokens) {
+    if (tokens.includes("--help") || tokens.includes("-h")) {
+      process.stdout.write(`${this.helpInformation()}
+`);
+      return;
+    }
+    const child = tokens[0] ? this.commands.find((command) => command._name === tokens[0]) : null;
+    if (child) {
+      await child._dispatch(tokens.slice(1));
+      return;
+    }
+    const { options, positionals } = this._parseTokens(tokens);
+    this._parsedOptions = options;
+    const required = this._arguments.filter((argument) => argument.required).length;
+    if (positionals.length < required) {
+      throw new Error(`Missing required argument for ${this._commandPath()}.`);
+    }
+    if (!this._action) {
+      process.stdout.write(`${this.helpInformation()}
+`);
+      return;
+    }
+    await this._action(...positionals, options, this);
+  }
+  _parseTokens(tokens) {
+    const options = Object.fromEntries(this._options.map((option) => [option.key, option.defaultValue]));
+    const positionals = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+      const token = tokens[index];
+      const option = this._options.find((entry) => entry.flag === token);
+      if (!option) {
+        positionals.push(token);
+        continue;
+      }
+      options[option.key] = option.requiresValue ? tokens[++index] : true;
+    }
+    return { options, positionals };
+  }
+  helpInformation() {
+    const lines = [`Usage: ${this._commandPath()}${this.commands.length ? " [command]" : ""}`];
+    if (this._description) lines.push("", this._description);
+    const commands = this._flattenCommands();
+    if (commands.length) {
+      lines.push("", "Commands:");
+      for (const entry of commands) lines.push(`  ${entry}`);
+    }
+    return lines.join("\n");
+  }
+  _flattenCommands(prefix = "") {
+    const nextPrefix = prefix ? `${prefix} ${this._name}`.trim() : this._name;
+    return this.commands.flatMap((command) => {
+      const label = `${nextPrefix} ${command._name}`.trim();
+      return [label, ...command._flattenCommands(nextPrefix)];
+    });
+  }
+  _commandPath() {
+    const names = [];
+    for (let current = this; current; current = current.parent) {
+      if (current._name) names.push(current._name);
+    }
+    return names.reverse().join(" ");
+  }
+};
+
+// packages/cli/dist/program.js
+function createCliProgram(deps = createDefaultCliDeps()) {
+  const program = new Command("va-claw");
+  program.description("va-claw CLI");
+  program.showHelpAfterError();
+  program.command("install").description("Install va-claw config, prompt injections, and daemon service.").option("--for <target>", "claude-code | codex | all", "all").action(async (options) => runInstall(options.for ?? "all", deps));
+  program.command("start").description("Start the daemon in the foreground.").action(async () => runStart(deps));
+  program.command("stop").description("Stop the daemon.").action(async () => runStop(deps));
+  program.command("status").description("Show daemon and memory status.").action(async () => runStatus(deps));
+  program.command("uninstall").description("Remove daemon service and injected prompts.").action(async () => runUninstall(deps));
+  const memory = program.command("memory").description("Memory operations.");
+  memory.command("search").description("Search memory.").argument("<query>").action(async (query) => runMemorySearch(query, deps));
+  memory.command("memorize").description("Store or update a memory entry by key.").argument("<key>").argument("<essence>").option("--tags <tags>", "Comma-separated tags.").option("--details <details>", "Details text.").option("--importance <importance>", "Importance from 0 to 1.").action((key, essence, options) => runMemoryMemorize(key, essence, options, deps));
+  memory.command("get").description("Get a memory entry by key.").argument("<key>").action(async (key) => runMemoryGet(key, deps));
+  memory.command("update").description("Update a memory entry by key.").argument("<key>").option("--essence <essence>", "Replace essence text.").option("--tags <tags>", "Comma-separated tags.").option("--importance <importance>", "Importance from 0 to 1.").option("--details <details>", "Replace details text.").action((key, options) => runMemoryUpdate(key, options, deps));
+  memory.command("list").description("List recent memory entries.").action(async () => runMemoryList(deps));
+  memory.command("forget").description("Forget a memory by key.").argument("<key>").action(async (key) => runMemoryForget(key, deps));
+  memory.command("recall").description("Recall memories by query.").argument("<query>").option("--limit <limit>", "Max results.").action((query, options) => runMemoryRecall(query, options.limit ? Number(options.limit) : 5, deps));
+  memory.command("consolidate").description("Consolidate memory store.").action(async () => runMemoryConsolidate(deps));
+  memory.command("reflect").description("Reflect memory map grouped by tags.").action(async () => runMemoryReflect(deps));
+  memory.command("clear").description("Clear all memory entries.").action(async () => runMemoryClear(deps));
+  const skill = program.command("skill").description("Skill operations.");
+  skill.command("list").description("List installed and project skills.").action(async () => runSkillList(deps));
+  skill.command("add").description("Install a skill from a local Markdown file or URL.\n\nTip: vet unknown skills first \u2014 va-claw skill add https://clawhub.ai/spclaudehome/Skill-vetter").argument("<path-or-url>").action(async (pathOrUrl) => runSkillAdd(pathOrUrl, deps));
+  skill.command("remove").description("Remove an installed skill by name.").argument("<name>").action(async (name) => runSkillRemove(name, deps));
+  skill.command("show").description("Show the raw Markdown content for a skill.").argument("<name>").action(async (name) => runSkillShow(name, deps));
+  const channel = program.command("channel").description("Channel operations.");
+  const discord = channel.command("discord").description("Discord channel operations.");
+  discord.command("setup").description("Configure Discord bot credentials.").action(async () => runDiscordSetup(deps));
+  discord.command("start").description("Start the Discord channel in the foreground.").action(async () => runDiscordStart(deps));
+  discord.command("status").description("Show Discord channel status.").action(async () => runDiscordStatus(deps));
+  const telegram = channel.command("telegram").description("Telegram channel operations.");
+  telegram.command("setup").description("Configure Telegram bot credentials.").option("--token <token>", "Telegram bot token").option("--cli-command <command>", "CLI command to invoke for each message").action(async (options) => runTelegramChannelSetup(options.token, options.cliCommand, deps));
+  telegram.command("start").description("Start the Telegram channel in the foreground.").action(async () => runTelegramChannelStart(deps));
+  telegram.command("status").description("Show Telegram channel status.").action(async () => runTelegramChannelStatus(deps));
+  const slack = channel.command("slack").description("Slack channel operations.");
+  slack.command("setup").description("Configure Slack bot credentials.").option("--bot-token <token>", "Slack bot token").option("--app-token <token>", "Slack app token").option("--cli-command <command>", "CLI command to invoke for each message").action(async (options) => runSlackChannelSetup(options.botToken, options.appToken, options.cliCommand, deps));
+  slack.command("start").description("Start the Slack channel in the foreground.").action(async () => runSlackChannelStart(deps));
+  slack.command("status").description("Show Slack channel status.").action(async () => runSlackChannelStatus(deps));
+  return program;
+}
+async function runCli(argv = process.argv, deps) {
+  const program = createCliProgram(deps ?? createDefaultCliDeps());
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    (deps ?? createDefaultCliDeps()).stderr.write(`${message}
+`);
+    process.exitCode = 1;
+  }
+}
+
+// packages/cli/dist/bin/va-claw.mjs
+await runCli();