clawvault 2.6.0 → 3.0.0

package/dist/commands/rebuild.cjs

@@ -0,0 +1,3136 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/rebuild.ts
+var rebuild_exports = {};
+__export(rebuild_exports, {
+  rebuildCommand: () => rebuildCommand,
+  registerRebuildCommand: () => registerRebuildCommand
+});
+module.exports = __toCommonJS(rebuild_exports);
+var fs9 = __toESM(require("fs"), 1);
+
+// src/lib/config.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path.resolve(startPath);
+  while (true) {
+    if (fs.existsSync(path.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path.resolve(options.explicitPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path.resolve(process.env.CLAWVAULT_PATH);
+  }
+  const discovered = findNearestVaultPath(options.cwd ?? process.cwd());
+  if (discovered) {
+    return discovered;
+  }
+  throw new Error("No vault path found. Set CLAWVAULT_PATH, use --vault, or run inside a vault.");
+}
+
+// src/lib/ledger.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var YEAR_RE = /^\d{4}$/;
+var MONTH_RE = /^(0[1-9]|1[0-2])$/;
+var DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.md$/;
+var RAW_DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.jsonl$/;
+function normalizeDateKey(date) {
+  if (typeof date === "string") {
+    if (!DATE_RE.test(date)) {
+      throw new Error(`Invalid date key: ${date}`);
+    }
+    return date;
+  }
+  return date.toISOString().slice(0, 10);
+}
+function ensureDir(dirPath) {
+  fs2.mkdirSync(dirPath, { recursive: true });
+}
+function walkThreeLevelDateTree(rootPath, extension) {
+  if (!fs2.existsSync(rootPath)) {
+    return [];
+  }
+  const results = [];
+  for (const yearEntry of fs2.readdirSync(rootPath, { withFileTypes: true })) {
+    if (!yearEntry.isDirectory() || !YEAR_RE.test(yearEntry.name)) continue;
+    const yearDir = path2.join(rootPath, yearEntry.name);
+    for (const monthEntry of fs2.readdirSync(yearDir, { withFileTypes: true })) {
+      if (!monthEntry.isDirectory() || !MONTH_RE.test(monthEntry.name)) continue;
+      const monthDir = path2.join(yearDir, monthEntry.name);
+      for (const dayEntry of fs2.readdirSync(monthDir, { withFileTypes: true })) {
+        if (!dayEntry.isFile()) continue;
+        const matches = extension === ".md" ? DAY_FILE_RE.test(dayEntry.name) : RAW_DAY_FILE_RE.test(dayEntry.name);
+        if (!matches) continue;
+        const day = dayEntry.name.slice(0, extension.length * -1);
+        const date = `${yearEntry.name}-${monthEntry.name}-${day}`;
+        if (!DATE_RE.test(date)) continue;
+        results.push({
+          date,
+          absolutePath: path2.join(monthDir, dayEntry.name)
+        });
+      }
+    }
+  }
+  return results;
+}
+function inDateRange(date, fromDate, toDate) {
+  if (fromDate && date < fromDate) {
+    return false;
+  }
+  if (toDate && date > toDate) {
+    return false;
+  }
+  return true;
+}
+function toDateKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function getLedgerRoot(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "ledger");
+}
+function getRawRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "raw");
+}
+function getRawSourceDir(vaultPath, source) {
+  return path2.join(getRawRoot(vaultPath), source);
+}
+function getObservationsRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "observations");
+}
+function getReflectionsRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "reflections");
+}
+function getArchiveObservationsRoot(vaultPath) {
+  return path2.join(getLedgerRoot(vaultPath), "archive", "observations");
+}
+function getLegacyObservationsRoot(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "observations");
+}
+function getObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path2.join(getObservationsRoot(vaultPath), year, month, `${day}.md`);
+}
+function getLegacyObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  return path2.join(getLegacyObservationsRoot(vaultPath), `${dateKey}.md`);
+}
+function getRawTranscriptPath(vaultPath, source, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path2.join(getRawSourceDir(vaultPath, source), year, month, `${day}.jsonl`);
+}
+function ensureLedgerStructure(vaultPath) {
+  const root = getLedgerRoot(vaultPath);
+  const rawRoot = getRawRoot(vaultPath);
+  ensureDir(root);
+  ensureDir(rawRoot);
+  for (const source of ["openclaw", "chatgpt", "claude", "opencode"]) {
+    ensureDir(path2.join(rawRoot, source));
+  }
+  ensureDir(getObservationsRoot(vaultPath));
+  ensureDir(getReflectionsRoot(vaultPath));
+  ensureDir(getArchiveObservationsRoot(vaultPath));
+}
+function listRawTranscriptFiles(vaultPath, options = {}) {
+  const rawRoot = getRawRoot(vaultPath);
+  if (!fs2.existsSync(rawRoot)) {
+    return [];
+  }
+  const sources = options.source ? [options.source] : fs2.readdirSync(rawRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const files = [];
+  for (const source of sources) {
+    const sourceRoot = path2.join(rawRoot, source);
+    const datedFiles = walkThreeLevelDateTree(sourceRoot, ".jsonl");
+    for (const entry of datedFiles) {
+      if (!inDateRange(entry.date, options.fromDate, options.toDate)) {
+        continue;
+      }
+      files.push({
+        source,
+        date: entry.date,
+        path: entry.absolutePath
+      });
+    }
+  }
+  return files.sort(
+    (left, right) => left.date === right.date ? left.path.localeCompare(right.path) : left.date.localeCompare(right.date)
+  );
+}
+function ensureParentDir(filePath) {
+  ensureDir(path2.dirname(filePath));
+}
+
+// src/observer/observer.ts
+var fs8 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+
+// src/lib/observation-format.ts
+var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
+var SCORED_LINE_RE = /^(?:-\s*)?\[(decision|preference|fact|commitment|task|todo|commitment-unresolved|milestone|lesson|relationship|project)\|c=(0(?:\.\d+)?|1(?:\.0+)?)\|i=(0(?:\.\d+)?|1(?:\.0+)?)\]\s+(.+)$/i;
+var EMOJI_LINE_RE = /^(?:-\s*)?(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
+var DECISION_RE = /\b(decis(?:ion|ions)?|decid(?:e|ed|ing)|chose|selected|opted|went with|picked)\b/i;
+var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use|enjoys?|loves?|favou?rite|fan of|interested in|go-to|tend(?:s)? to use|passionate about|hobby|hobbies|(?:I|my|our)\s+(?:own|have|use|got|bought|drive|wear|eat|drink|cook|play|watch|read|listen)|(?:I(?:'m| am))\s+(?:a |an |into |allergic|vegetarian|vegan|gluten|lactose|trying to|learning)|usually|every (?:morning|evening|night|day|week)|routine)\b/i;
+var COMMITMENT_RE = /\b(commit(?:ment|ted)?|promised|deadline|due|scheduled|will deliver|agreed to)\b/i;
+var TODO_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
+var COMMITMENT_TASK_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
+var UNRESOLVED_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
+var DEADLINE_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
+var MILESTONE_RE = /\b(released?|shipped|launched|merged|published|milestone|v\d+\.\d+)\b/i;
+var LESSON_RE = /\b(learn(?:ed|ing|t)|lesson|insight|realized|discovered|never again)\b/i;
+var RELATIONSHIP_RE = /\b(talked to|met with|spoke with|asked|client|partner|teammate|colleague)\b/i;
+var PROJECT_RE = /\b(project|feature|service|repo|api|roadmap|sprint)\b/i;
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}
+function scoreFromLegacyPriority(priority) {
+  if (priority === "\u{1F534}") return 0.9;
+  if (priority === "\u{1F7E1}") return 0.6;
+  return 0.2;
+}
+function confidenceFromLegacyPriority(priority) {
+  if (priority === "\u{1F534}") return 0.9;
+  if (priority === "\u{1F7E1}") return 0.8;
+  return 0.7;
+}
+function inferObservationType(content) {
+  if (DECISION_RE.test(content)) return "decision";
+  if (UNRESOLVED_RE.test(content)) return "commitment-unresolved";
+  if (TODO_RE.test(content)) return "todo";
+  if (PREFERENCE_RE.test(content)) return "preference";
+  if (COMMITMENT_TASK_RE.test(content) || DEADLINE_RE.test(content)) return "task";
+  if (COMMITMENT_RE.test(content)) return "commitment";
+  if (MILESTONE_RE.test(content)) return "milestone";
+  if (LESSON_RE.test(content)) return "lesson";
+  if (RELATIONSHIP_RE.test(content)) return "relationship";
+  if (PROJECT_RE.test(content)) return "project";
+  return "fact";
+}
+function formatScore(value) {
+  return clamp01(value).toFixed(2);
+}
+function normalizeObservationContent(content) {
+  return content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function parseObservationLine(line, date) {
+  const scored = line.match(SCORED_LINE_RE);
+  if (scored) {
+    return {
+      date,
+      type: scored[1].toLowerCase(),
+      confidence: clamp01(Number.parseFloat(scored[2])),
+      importance: clamp01(Number.parseFloat(scored[3])),
+      content: scored[4].trim(),
+      format: "scored",
+      rawLine: line
+    };
+  }
+  const emoji = line.match(EMOJI_LINE_RE);
+  if (!emoji) {
+    return null;
+  }
+  const priority = emoji[1];
+  const time = emoji[2]?.trim();
+  const text = emoji[3].trim();
+  const content = time ? `${time} ${text}` : text;
+  return {
+    date,
+    type: inferObservationType(content),
+    confidence: confidenceFromLegacyPriority(priority),
+    importance: scoreFromLegacyPriority(priority),
+    content,
+    format: "emoji",
+    priority,
+    time,
+    rawLine: line
+  };
+}
+function parseObservationMarkdown(markdown) {
+  const parsed = [];
+  let currentDate = "";
+  for (const line of markdown.split(/\r?\n/)) {
+    const heading = line.match(DATE_HEADING_RE);
+    if (heading) {
+      currentDate = heading[1];
+      continue;
+    }
+    if (!currentDate) {
+      continue;
+    }
+    const record = parseObservationLine(line.trim(), currentDate);
+    if (record) {
+      parsed.push(record);
+    }
+  }
+  return parsed;
+}
+function renderScoredObservationLine(record) {
+  return `- [${record.type}|c=${formatScore(record.confidence)}|i=${formatScore(record.importance)}] ${record.content.trim()}`;
+}
+function renderObservationMarkdown(sections) {
+  const chunks = [];
+  const dates = [...sections.keys()].sort((left, right) => left.localeCompare(right));
+  for (const date of dates) {
+    const lines = sections.get(date) ?? [];
+    if (lines.length === 0) continue;
+    chunks.push(`## ${date}`);
+    chunks.push("");
+    for (const line of lines) {
+      chunks.push(renderScoredObservationLine(line));
+    }
+    chunks.push("");
+  }
+  return chunks.join("\n").trim();
+}
+
+// src/lib/claude-credentials.ts
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var CLAUDE_CODE_SERVICE = "Claude Code-credentials";
+var CLAUDE_CODE_ACCOUNT = "Claude Code";
+var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var TOKEN_REFRESH_URL = "https://console.anthropic.com/v1/oauth/token";
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+function readClaudeCliCredentials(opts) {
+  if (process.platform === "darwin") {
+    try {
+      const raw = (0, import_child_process.execFileSync)(
+        "security",
+        ["find-generic-password", "-s", CLAUDE_CODE_SERVICE, "-w"],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim();
+      const parsed = parseCredentialsJson(raw);
+      if (parsed) return parsed;
+    } catch {
+    }
+  }
+  const home = opts?.homeDir ?? (0, import_os.homedir)();
+  const credFile = (0, import_path.join)(home, ".claude", ".credentials.json");
+  if (!(0, import_fs.existsSync)(credFile)) {
+    return null;
+  }
+  try {
+    const raw = (0, import_fs.readFileSync)(credFile, "utf8");
+    return parseCredentialsJson(raw);
+  } catch {
+    return null;
+  }
+}
+function parseCredentialsJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const oauth = parsed.claudeAiOauth;
+    if (oauth && typeof oauth.accessToken === "string" && typeof oauth.refreshToken === "string" && typeof oauth.expiresAt === "number") {
+      return {
+        accessToken: oauth.accessToken,
+        refreshToken: oauth.refreshToken,
+        expiresAt: oauth.expiresAt
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function refreshClaudeOAuthToken(refreshToken, fetchImpl) {
+  const f = fetchImpl ?? fetch;
+  const response = await f(TOKEN_REFRESH_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      client_id: OAUTH_CLIENT_ID,
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OAuth token refresh failed (${response.status})`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+function writeClaudeCliCredentials(cred, opts) {
+  const payload = JSON.stringify({ claudeAiOauth: cred });
+  if (process.platform === "darwin") {
+    try {
+      (0, import_child_process.execFileSync)(
+        "security",
+        ["add-generic-password", "-U", "-s", CLAUDE_CODE_SERVICE, "-a", CLAUDE_CODE_ACCOUNT, "-w", payload],
+        { stdio: "ignore" }
+      );
+      return;
+    } catch {
+    }
+  }
+  const home = opts?.homeDir ?? (0, import_os.homedir)();
+  const credFile = (0, import_path.join)(home, ".claude", ".credentials.json");
+  (0, import_fs.writeFileSync)(credFile, payload, "utf8");
+}
+async function resolveClaudeOAuthToken(opts) {
+  const cred = readClaudeCliCredentials(opts);
+  if (!cred) {
+    return null;
+  }
+  if (cred.expiresAt < Date.now() + EXPIRY_BUFFER_MS) {
+    try {
+      const refreshed = await refreshClaudeOAuthToken(cred.refreshToken, opts?.fetchImpl);
+      writeClaudeCliCredentials(refreshed, opts);
+      return refreshed.accessToken;
+    } catch {
+      return cred.accessToken;
+    }
+  }
+  return cred.accessToken;
+}
+
+// src/observer/compressor.ts
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+var OLLAMA_BASE_URL = "http://localhost:11434/v1";
+var DEFAULT_PROVIDER_MODELS = {
+  anthropic: "claude-haiku-4-5",
+  openai: "gpt-4o-mini",
+  gemini: "gemini-2.0-flash",
+  "openai-compatible": "gpt-4o-mini",
+  ollama: "llama3.2"
+};
+var CRITICAL_RE = /(?:\b(?:decision|decided|chose|chosen|selected|picked|opted|switched to)\s*:?|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure|ing)?\b|\bblock(?:ed|er)?\b|\bbreaking(?:\s+change)?s?\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b|\bpublish(?:ed)?\b.*@?\d+\.\d+|\bmerge[d]?\s+(?:PR|pull\s+request)\b|\bshipped\b|\breleased?\b.*v?\d+\.\d+|\bsigned\b.*\b(?:contract|agreement|deal)\b|\bpricing\b.*\$|\bdemo\b.*\b(?:completed?|done|finished)\b|\bmeeting\b.*\b(?:completed?|done|finished)\b|\bstrategy\b.*\b(?:pivot|change|shift)\b)/i;
+var DEADLINE_WITH_DATE_RE = /(?:(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b).*(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2})|(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2}).*(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b))/i;
+var NOTABLE_RE = /\b(prefer(?:ence|s)?|likes?|dislikes?|context|pattern|architecture|approach|trade[- ]?off|milestone|stakeholder|teammate|collaborat(?:e|ed|ion)|discussion|notable|deadline|due|timeline|deploy(?:ed|ment)?|built|configured|launched|proposal|pitch|onboard(?:ed|ing)?|migrat(?:e|ed|ion)|domain|DNS|infra(?:structure)?)\b/i;
+var TODO_SIGNAL_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
+var COMMITMENT_TASK_SIGNAL_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
+var UNRESOLVED_COMMITMENT_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
+var DEADLINE_SIGNAL_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
+var Compressor = class {
+  provider;
+  model;
+  baseUrl;
+  apiKey;
+  now;
+  fetchImpl;
+  constructor(options = {}) {
+    this.provider = options.provider;
+    this.model = options.model;
+    this.baseUrl = options.baseUrl;
+    this.apiKey = options.apiKey;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async compress(messages, existingObservations) {
+    const cleanedMessages = messages.map((message) => message.trim()).filter(Boolean);
+    if (cleanedMessages.length === 0) {
+      return existingObservations.trim();
+    }
+    const prompt = this.buildPrompt(cleanedMessages, existingObservations);
+    const backend = await this.resolveProvider();
+    if (backend) {
+      try {
+        const llmOutput = backend.provider === "anthropic" ? await this.callAnthropic(prompt, backend) : backend.provider === "gemini" ? await this.callGemini(prompt, backend) : backend.provider === "openai" ? await this.callOpenAI(prompt, backend) : await this.callOpenAICompatible(prompt, backend);
+        const normalized = this.normalizeLlmOutput(llmOutput);
+        if (normalized) {
+          return this.mergeObservations(existingObservations, normalized);
+        }
+      } catch {
+      }
+    }
+    const fallback = this.fallbackCompression(cleanedMessages);
+    return this.mergeObservations(existingObservations, fallback);
+  }
+  async resolveProvider() {
+    if (process.env.CLAWVAULT_NO_LLM) return null;
+    if (this.provider) {
+      const configured = this.resolveConfiguredProvider(this.provider);
+      if (configured) {
+        return configured;
+      }
+      return await this.resolveProviderFromEnv(false);
+    }
+    return await this.resolveProviderFromEnv(true);
+  }
+  resolveConfiguredProvider(provider) {
+    const model = this.resolveModel(provider);
+    if (provider === "anthropic") {
+      const apiKey2 = this.resolveApiKey(provider);
+      if (!apiKey2) {
+        return null;
+      }
+      return {
+        provider,
+        model,
+        apiKey: apiKey2
+      };
+    }
+    if (provider === "gemini") {
+      const apiKey2 = this.resolveApiKey(provider);
+      if (!apiKey2) {
+        return null;
+      }
+      return {
+        provider,
+        model,
+        apiKey: apiKey2
+      };
+    }
+    if (provider === "openai") {
+      const apiKey2 = this.resolveApiKey(provider);
+      if (!apiKey2) {
+        return null;
+      }
+      return {
+        provider,
+        model,
+        apiKey: apiKey2,
+        baseUrl: this.resolveBaseUrl(provider)
+      };
+    }
+    const apiKey = this.resolveApiKey(provider) ?? void 0;
+    return {
+      provider,
+      model,
+      apiKey,
+      baseUrl: this.resolveBaseUrl(provider)
+    };
+  }
+  async resolveProviderFromEnv(allowConfiguredModel) {
+    const anthropicModel = allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic;
+    const oauthEnvToken = this.readEnvValue("ANTHROPIC_OAUTH_TOKEN");
+    if (oauthEnvToken) {
+      return { provider: "anthropic", model: anthropicModel, apiKey: oauthEnvToken, isOAuth: true };
+    }
+    const anthropicApiKey = this.readEnvValue("ANTHROPIC_API_KEY");
+    if (anthropicApiKey) {
+      return { provider: "anthropic", model: anthropicModel, apiKey: anthropicApiKey };
+    }
+    if (this.readEnvValue("CLAWVAULT_CLAUDE_AUTH")) {
+      const oauthToken = await resolveClaudeOAuthToken();
+      if (oauthToken) {
+        return { provider: "anthropic", model: anthropicModel, apiKey: oauthToken, isOAuth: true };
+      }
+    }
+    const openAiApiKey = this.readEnvValue("OPENAI_API_KEY");
+    if (openAiApiKey) {
+      return {
+        provider: "openai",
+        model: allowConfiguredModel ? this.resolveModel("openai") : DEFAULT_PROVIDER_MODELS.openai,
+        apiKey: openAiApiKey,
+        baseUrl: OPENAI_BASE_URL
+      };
+    }
+    const geminiApiKey = this.readEnvValue("GEMINI_API_KEY");
+    if (geminiApiKey) {
+      return {
+        provider: "gemini",
+        model: allowConfiguredModel ? this.resolveModel("gemini") : DEFAULT_PROVIDER_MODELS.gemini,
+        apiKey: geminiApiKey
+      };
+    }
+    return null;
+  }
+  resolveModel(provider) {
+    const configuredModel = this.model?.trim();
+    if (configuredModel) {
+      return configuredModel;
+    }
+    return DEFAULT_PROVIDER_MODELS[provider];
+  }
+  resolveApiKey(provider) {
+    const configuredApiKey = this.apiKey?.trim();
+    if (configuredApiKey) {
+      return configuredApiKey;
+    }
+    if (provider === "anthropic") {
+      return this.readEnvValue("ANTHROPIC_API_KEY");
+    }
+    if (provider === "gemini") {
+      return this.readEnvValue("GEMINI_API_KEY");
+    }
+    return this.readEnvValue("OPENAI_API_KEY");
+  }
+  resolveBaseUrl(provider) {
+    const configuredBaseUrl = this.baseUrl?.trim();
+    if (configuredBaseUrl) {
+      return configuredBaseUrl.replace(/\/+$/, "");
+    }
+    if (provider === "ollama") {
+      return OLLAMA_BASE_URL;
+    }
+    return OPENAI_BASE_URL;
+  }
+  readEnvValue(name) {
+    const value = process.env[name]?.trim();
+    return value ? value : null;
+  }
+  buildPrompt(messages, existingObservations) {
+    return [
+      "You are an observer that compresses raw AI session messages into durable, human-meaningful observations.",
+      "",
+      "Rules:",
+      "- Output markdown only.",
+      "- Group observations by date heading: ## YYYY-MM-DD",
+      "- Each observation line MUST follow: - [type|c=<0.00-1.00>|i=<0.00-1.00>] <observation>",
+      "- Allowed type tags: decision, preference, fact, commitment, task, todo, commitment-unresolved, milestone, lesson, relationship, project",
+      "- i >= 0.80 for structural/persistent observations (major decisions, blockers, releases, commitments)",
+      "- i 0.40-0.79 for potentially important observations (notable context, preferences, milestones)",
+      "- i < 0.40 for contextual/routine observations",
+      "- Confidence c reflects extraction certainty, not importance.",
+      "- Preserve source tags when present (e.g., [main], [telegram-dm], [discord], [telegram-group]).",
+      "",
+      "PREFERENCE & PERSONAL CONTEXT EXTRACTION (critical for personalization):",
+      "- Emit [preference] for ANY personal detail that reveals tastes, habits, equipment, or context:",
+      '  * Explicit: "I prefer X", "I like Y", "I always use Z"',
+      '  * Ownership: "my Sony A7R IV", "I have a...", "I use...", "I own..."',
+      '  * Habits/routines: "I usually...", "every morning I...", "I tend to..."',
+      "  * Interests: topics the user is enthusiastic about, hobbies mentioned in passing",
+      "  * Constraints: dietary restrictions, allergies, phobias, limitations",
+      `  * Goals: "I'm trying to...", "I want to learn..."`,
+      "- These are HIGH VALUE observations (i >= 0.60) \u2014 they enable personalized responses.",
+      "- When in doubt between [preference] and [task], choose [preference] if it describes a lasting trait.",
+      "",
+      "TASK EXTRACTION (required):",
+      `- Emit [todo] for explicit TODO phrasing: "TODO:", "we need to", "don't forget", "remember to", "make sure to".`,
+      `- Emit [task] for commitments/action intent: "I'll", "I will", "let me", "going to", "plan to", "should".`,
+      '- Emit [commitment-unresolved] for unresolved commitments/questions: "need to figure out", "TBD", "to be determined".',
+      '- Deadline language ("by Friday", "before the demo", "deadline is") should increase importance and usually map to [task] unless unresolved.',
+      "",
+      "QUALITY FILTERS (important):",
+      "- DO NOT observe: CLI errors, command failures, tool output parsing issues, retry attempts, debug logs.",
+      "  These are transient noise, not memories. Only observe errors if they represent a BLOCKER or an unresolved problem.",
+      '- DO NOT observe: "acknowledged the conversation", "said okay", routine confirmations.',
+      '- MERGE related events into single observations. If 5 images were generated, say "Generated 5 images for X" not 5 separate lines.',
+      '- MERGE retry sequences: "Tried X, failed, tried Y, succeeded" \u2192 "Resolved X using Y (after initial failure)"',
+      '- Prefer OUTCOMES over PROCESSES: "Deployed v1.2 to Railway" not "Started deploy... build finished... deploy succeeded"',
+      "",
+      "AGENT ATTRIBUTION:",
+      '- If the transcript shows multiple speakers/agents, prefix observations with who did it: "Pedro asked...", "Clawdious deployed...", "Zeca generated..."',
+      "- If only one agent is acting, attribution is optional.",
+      "",
+      "PROJECT MILESTONES (critical \u2014 these are the most valuable observations):",
+      "Projects are NOT just code. Milestones include business, strategy, client, and operational events.",
+      "- Use milestone/decision/commitment types for strategic events with high importance.",
+      "- Use preference/lesson/relationship/project/fact when appropriate.",
+      "- Examples:",
+      '  "- [decision|c=0.95|i=0.90] 14:00 Pricing decision: $33K one-time + $3K/mo for Artemisa"',
+      '  "- [milestone|c=0.93|i=0.88] 14:00 Published clawvault@2.1.0 to npm"',
+      '  "- [project|c=0.84|i=0.58] 14:00 Deployed pitch deck to artemisa-pitch-deck.vercel.app"',
+      "- Do NOT collapse multiple milestones into one line \u2014 each matters for history.",
+      "",
+      "COMMITMENT FORMAT (when someone promises/agrees to something):",
+      '- Prefer: "- [commitment|c=...|i=...] HH:MM [COMMITMENT] <who> committed to <what> by <when>"',
+      "",
+      "Keep observations concise and factual. Aim for signal, not completeness.",
+      "",
+      "Existing observations (may be empty):",
+      existingObservations.trim() || "(none)",
+      "",
+      "Raw messages:",
+      ...messages.map((message, index) => `[${index + 1}] ${message}`),
+      "",
+      "Return only the updated observation markdown."
+    ].join("\n");
+  }
+  buildOpenAICompatibleUrl(baseUrl) {
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+    return `${normalizedBaseUrl}/chat/completions`;
+  }
+  buildOpenAICompatibleHeaders(apiKey) {
+    const headers = {
+      "content-type": "application/json"
+    };
+    if (apiKey) {
+      headers.authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+  }
+  extractOpenAIContent(content) {
+    if (typeof content === "string") {
+      return content.trim();
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    const parts = content.map((part) => {
+      if (typeof part === "string") {
+        return part;
+      }
+      if (!part || typeof part !== "object") {
+        return "";
+      }
+      const candidate = part;
+      return typeof candidate.text === "string" ? candidate.text : "";
+    }).filter((part) => part.trim().length > 0);
+    return parts.join("\n").trim();
+  }
+  async callAnthropic(prompt, backend) {
+    if (!backend.apiKey) {
+      return "";
+    }
+    const isOAuth = backend.isOAuth || backend.apiKey.includes("sk-ant-oat");
+    const headers = isOAuth ? {
+      "content-type": "application/json",
+      "authorization": `Bearer ${backend.apiKey}`,
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
+      "x-app": "cli",
+      "user-agent": "claude-cli/1.0.0 (external, cli)"
+    } : {
+      "content-type": "application/json",
+      "x-api-key": backend.apiKey,
+      "anthropic-version": "2023-06-01"
+    };
+    const body = isOAuth ? {
+      model: backend.model,
+      temperature: 0.1,
+      max_tokens: 1400,
+      system: [{ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }],
+      messages: [{ role: "user", content: prompt }]
+    } : {
+      model: backend.model,
+      temperature: 0.1,
+      max_tokens: 1400,
+      messages: [{ role: "user", content: prompt }]
+    };
+    const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Anthropic request failed (${response.status})`);
+    }
+    const payload = await response.json();
+    return payload.content?.filter((part) => part.type === "text" && part.text).map((part) => part.text).join("\n").trim() ?? "";
+  }
+  async callOpenAI(prompt, backend) {
+    return this.callOpenAICompatible(prompt, backend);
+  }
+  async callOpenAICompatible(prompt, backend) {
+    const baseUrl = backend.baseUrl ?? this.resolveBaseUrl(backend.provider);
+    const response = await this.fetchImpl(this.buildOpenAICompatibleUrl(baseUrl), {
+      method: "POST",
+      headers: this.buildOpenAICompatibleHeaders(backend.apiKey),
+      body: JSON.stringify({
+        model: backend.model,
+        temperature: 0.1,
+        messages: [
+          { role: "system", content: "You transform session logs into concise observations." },
+          { role: "user", content: prompt }
+        ]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI-compatible request failed (${response.status})`);
+    }
+    const payload = await response.json();
+    return this.extractOpenAIContent(payload.choices?.[0]?.message?.content);
+  }
+  async callGemini(prompt, backend) {
+    if (!backend.apiKey) {
+      return "";
+    }
+    const model = encodeURIComponent(backend.model);
+    const response = await this.fetchImpl(
+      `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${backend.apiKey}`,
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: prompt }] }],
+          generationConfig: { temperature: 0.1, maxOutputTokens: 1400 }
+        })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Gemini request failed (${response.status})`);
+    }
+    const payload = await response.json();
+    return payload.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
+  }
+  normalizeLlmOutput(output) {
+    if (!output.trim()) {
+      return "";
+    }
+    const cleaned = output.replace(/^```(?:markdown)?\s*/i, "").replace(/\s*```$/, "").trim();
+    const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const hasObservationLine = lines.some((line) => line.startsWith("- [") || /^(?:-\s*)?(🔴|🟡|🟢)\s+/.test(line));
+    if (!hasObservationLine) {
+      return "";
+    }
+    const hasDateHeading = lines.some((line) => DATE_HEADING_RE.test(line));
+    const result = hasDateHeading ? cleaned : `## ${this.formatDate(this.now())}
+
+${cleaned}`;
+    const sanitized = this.sanitizeWikiLinks(result);
+    return this.enforceImportanceRules(sanitized);
+  }
+  /**
+   * Fix wiki-link corruption from LLM compression.
+   * LLMs often fuse preceding word fragments into wiki-links during rewriting:
+   *   "reque[[people/pedro]]" → "[[people/pedro]]"
+   *   "Linke[[agents/zeca]]" → "[[agents/zeca]]"
+   *   "taske[[people/pedro]]a" → "[[people/pedro]]"
+   * Also fixes trailing word fragments fused after closing brackets.
+   */
+  sanitizeWikiLinks(markdown) {
+    let result = markdown.replace(/\w+\[\[/g, " [[");
+    result = result.replace(/\]\]\w+/g, "]]");
+    result = result.replace(/ {2,}/g, " ");
+    return result;
+  }
+  enforceImportanceRules(markdown) {
+    const parsed = parseObservationMarkdown(markdown);
+    if (parsed.length === 0) {
+      return "";
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const record of parsed) {
+      const adjusted = this.enforceImportanceForRecord(record);
+      const bucket = grouped.get(record.date) ?? [];
+      bucket.push(adjusted);
+      grouped.set(record.date, bucket);
+    }
+    return renderObservationMarkdown(grouped);
+  }
+  enforceImportanceForRecord(record) {
+    let importance = record.importance;
+    let confidence = record.confidence;
+    let type = record.type;
+    const inferredTaskType = this.inferTaskType(record.content);
+    if (this.isCriticalContent(record.content)) {
+      importance = Math.max(importance, 0.85);
+      confidence = Math.max(confidence, 0.85);
+      if (type === "fact") {
+        type = inferObservationType(record.content);
+      }
+    } else if (this.isNotableContent(record.content)) {
+      importance = Math.max(importance, 0.5);
+      confidence = Math.max(confidence, 0.75);
+    }
+    if (inferredTaskType) {
+      type = type === "fact" || type === "commitment" ? inferredTaskType : type;
+      importance = Math.max(importance, inferredTaskType === "commitment-unresolved" ? 0.72 : 0.65);
+      confidence = Math.max(confidence, 0.8);
+    }
+    if (type === "decision" || type === "commitment" || type === "milestone") {
+      importance = Math.max(importance, 0.6);
+    }
+    return {
+      type,
+      confidence: this.clamp01(confidence),
+      importance: this.clamp01(importance),
+      content: record.content
+    };
+  }
+  fallbackCompression(messages) {
+    const sections = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    for (const message of messages) {
+      const normalized = this.normalizeText(message);
+      if (!normalized) continue;
+      const date = this.extractDate(message) ?? this.formatDate(this.now());
+      const time = this.extractTime(message) ?? this.formatTime(this.now());
+      const line = `${time} ${normalized}`;
+      const type = inferObservationType(line);
+      const importance = this.inferImportance(line, type);
+      const confidence = this.inferConfidence(line, type, importance);
+      const dedupeKey = `${date}|${type}|${normalizeObservationContent(line)}`;
+      if (seen.has(dedupeKey)) continue;
+      seen.add(dedupeKey);
+      const bucket = sections.get(date) ?? [];
+      bucket.push({ type, confidence, importance, content: line });
+      sections.set(date, bucket);
+    }
+    if (sections.size === 0) {
+      const date = this.formatDate(this.now());
+      sections.set(date, [{
+        type: "fact",
+        confidence: 0.7,
+        importance: 0.2,
+        content: `${this.formatTime(this.now())} Processed session updates.`
+      }]);
+    }
+    return this.renderSections(sections);
+  }
+  mergeObservations(existing, incoming) {
+    const existingRecords = parseObservationMarkdown(existing);
+    const incomingRecords = parseObservationMarkdown(incoming);
+    if (incomingRecords.length === 0) {
+      return existing.trim();
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const record of existingRecords) {
+      this.mergeRecord(merged, {
+        date: record.date,
+        type: record.type,
+        confidence: record.confidence,
+        importance: record.importance,
+        content: record.content
+      });
+    }
+    for (const record of incomingRecords) {
+      this.mergeRecord(merged, {
+        date: record.date,
+        type: record.type,
+        confidence: record.confidence,
+        importance: record.importance,
+        content: record.content
+      });
+    }
+    return this.renderSections(merged);
+  }
+  mergeRecord(sections, input) {
+    const bucket = sections.get(input.date) ?? [];
+    const key = normalizeObservationContent(input.content);
+    const index = bucket.findIndex((line) => normalizeObservationContent(line.content) === key);
+    if (index === -1) {
+      bucket.push({
+        type: input.type,
+        confidence: this.clamp01(input.confidence),
+        importance: this.clamp01(input.importance),
+        content: input.content.trim()
+      });
+      sections.set(input.date, bucket);
+      return;
+    }
+    const existing = bucket[index];
+    bucket[index] = {
+      type: input.importance >= existing.importance ? input.type : existing.type,
+      confidence: this.clamp01(Math.max(existing.confidence, input.confidence)),
+      importance: this.clamp01(Math.max(existing.importance, input.importance)),
+      content: existing.content.length >= input.content.length ? existing.content : input.content
+    };
+    sections.set(input.date, bucket);
+  }
+  renderSections(sections) {
+    return renderObservationMarkdown(sections);
+  }
+  inferImportance(text, type) {
+    const inferredTaskType = this.inferTaskType(text);
+    if (this.isCriticalContent(text)) return 0.9;
+    if (inferredTaskType === "commitment-unresolved") return 0.72;
+    if (inferredTaskType === "task" || inferredTaskType === "todo") return 0.65;
+    if (this.isNotableContent(text)) return 0.6;
+    if (type === "decision" || type === "commitment" || type === "milestone") return 0.55;
+    if (type === "preference" || type === "lesson" || type === "relationship" || type === "project") return 0.45;
+    return 0.2;
+  }
+  inferConfidence(text, type, importance) {
+    const inferredTaskType = this.inferTaskType(text);
+    let confidence = 0.72;
+    if (importance >= 0.8) confidence += 0.12;
+    if (type === "decision" || type === "commitment" || type === "milestone") confidence += 0.06;
+    if (inferredTaskType) confidence += 0.06;
+    if (/\b(?:decided|chose|committed|deadline|released|merged)\b/i.test(text)) {
+      confidence += 0.05;
+    }
+    return this.clamp01(confidence);
+  }
+  isCriticalContent(text) {
+    return CRITICAL_RE.test(text) || DEADLINE_WITH_DATE_RE.test(text);
+  }
+  isNotableContent(text) {
+    return NOTABLE_RE.test(text);
+  }
+  inferTaskType(text) {
+    if (UNRESOLVED_COMMITMENT_RE.test(text)) {
+      return "commitment-unresolved";
+    }
+    if (TODO_SIGNAL_RE.test(text)) {
+      return "todo";
+    }
+    if (COMMITMENT_TASK_SIGNAL_RE.test(text) || DEADLINE_SIGNAL_RE.test(text)) {
+      return "task";
+    }
+    return null;
+  }
+  normalizeText(text) {
+    return text.replace(/\s+/g, " ").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim().slice(0, 280);
+  }
+  extractDate(text) {
+    const match = text.match(/\b(\d{4}-\d{2}-\d{2})\b/);
+    return match?.[1] ?? null;
+  }
+  extractTime(text) {
+    const match = text.match(/\b([01]\d|2[0-3]):([0-5]\d)\b/);
+    if (!match) {
+      return null;
+    }
+    return `${match[1]}:${match[2]}`;
+  }
+  formatDate(date) {
+    return date.toISOString().split("T")[0];
+  }
+  formatTime(date) {
+    return date.toISOString().slice(11, 16);
+  }
+  clamp01(value) {
+    if (!Number.isFinite(value)) return 0;
+    if (value < 0) return 0;
+    if (value > 1) return 1;
+    return value;
+  }
+};
+
+// src/observer/reflector.ts
+var DATE_HEADING_RE2 = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
+var OBSERVATION_LINE_RE = /^(🔴|🟡|🟢)\s+(.+)$/u;
+var Reflector = class {
+  now;
+  constructor(options = {}) {
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  reflect(observations) {
+    const sections = this.parseSections(observations);
+    if (sections.size === 0) {
+      return observations.trim();
+    }
+    const cutoff = this.buildCutoffDate();
+    const dedupeKeys = [];
+    const reflected = /* @__PURE__ */ new Map();
+    const dates = [...sections.keys()].sort((a, b) => b.localeCompare(a));
+    for (const date of dates) {
+      const sectionDate = this.parseDate(date);
+      const olderThanCutoff = sectionDate ? sectionDate.getTime() < cutoff.getTime() : false;
+      const lines = sections.get(date) ?? [];
+      const kept = [];
+      for (const line of lines) {
+        if (line.priority === "\u{1F534}") {
+          kept.push(line);
+          continue;
+        }
+        if (line.priority === "\u{1F7E2}" && olderThanCutoff) {
+          continue;
+        }
+        const key = this.normalizeText(line.content);
+        const isDuplicate = dedupeKeys.some((existing) => this.isSimilar(existing, key));
+        if (isDuplicate) {
+          continue;
+        }
+        dedupeKeys.push(key);
+        kept.push(line);
+      }
+      if (kept.length > 0) {
+        reflected.set(date, kept);
+      }
+    }
+    return this.renderSections(reflected);
+  }
+  buildCutoffDate() {
+    const cutoff = new Date(this.now());
+    cutoff.setHours(0, 0, 0, 0);
+    cutoff.setDate(cutoff.getDate() - 7);
+    return cutoff;
+  }
+  parseDate(date) {
+    const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+    if (Number.isNaN(parsed.getTime())) {
+      return null;
+    }
+    return parsed;
+  }
+  parseSections(markdown) {
+    const sections = /* @__PURE__ */ new Map();
+    let currentDate = null;
+    for (const rawLine of markdown.split(/\r?\n/)) {
+      const dateMatch = rawLine.match(DATE_HEADING_RE2);
+      if (dateMatch) {
+        currentDate = dateMatch[1];
+        if (!sections.has(currentDate)) {
+          sections.set(currentDate, []);
+        }
+        continue;
+      }
+      if (!currentDate) continue;
+      const lineMatch = rawLine.match(OBSERVATION_LINE_RE);
+      if (!lineMatch) continue;
+      const bucket = sections.get(currentDate) ?? [];
+      bucket.push({
+        priority: lineMatch[1],
+        content: lineMatch[2].trim()
+      });
+      sections.set(currentDate, bucket);
+    }
+    return sections;
+  }
+  renderSections(sections) {
+    const chunks = [];
+    const dates = [...sections.keys()].sort((a, b) => a.localeCompare(b));
+    for (const date of dates) {
+      const lines = sections.get(date) ?? [];
+      if (lines.length === 0) continue;
+      chunks.push(`## ${date}`);
+      chunks.push("");
+      for (const line of lines) {
+        chunks.push(`${line.priority} ${line.content}`);
+      }
+      chunks.push("");
+    }
+    return chunks.join("\n").trim();
+  }
+  normalizeText(text) {
+    return text.toLowerCase().replace(/\s+/g, " ").replace(/[^\w\s:.-]/g, "").trim();
+  }
+  isSimilar(a, b) {
+    if (a === b) return true;
+    if (a.length >= 24 && (a.includes(b) || b.includes(a))) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/observer/router.ts
+var fs7 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+
+// src/lib/task-utils.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/lib/transition-ledger.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var REGRESSION_PAIRS = [
+  ["done", "open"],
+  ["done", "blocked"],
+  ["in-progress", "blocked"]
+];
+function isRegression(from, to) {
+  return REGRESSION_PAIRS.some(([f, t]) => f === from && t === to);
+}
+function getLedgerDir(vaultPath) {
+  return path3.join(path3.resolve(vaultPath), "ledger", "transitions");
+}
+function getTodayLedgerPath(vaultPath) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return path3.join(getLedgerDir(vaultPath), `${date}.jsonl`);
+}
+var RETRYABLE_APPEND_CODES = /* @__PURE__ */ new Set(["ENOENT", "EAGAIN", "EBUSY"]);
+var MAX_APPEND_RETRIES = 2;
+function asErrno(error) {
+  if (!error || typeof error !== "object") {
+    return null;
+  }
+  return error;
+}
+function formatLedgerWriteError(filePath, error) {
+  const errno = asErrno(error);
+  const message = error instanceof Error ? error.message : String(error);
+  if (errno?.code === "ENOSPC") {
+    return new Error(`Failed to write transition ledger at ${filePath}: no space left on device.`);
+  }
+  if (errno?.code === "EACCES" || errno?.code === "EPERM") {
+    return new Error(`Failed to write transition ledger at ${filePath}: permission denied.`);
+  }
+  return new Error(`Failed to write transition ledger at ${filePath}: ${message}`);
+}
+function appendTransition(vaultPath, event) {
+  const ledgerDir = getLedgerDir(vaultPath);
+  try {
+    fs3.mkdirSync(ledgerDir, { recursive: true });
+  } catch (error) {
+    throw formatLedgerWriteError(ledgerDir, error);
+  }
+  const filePath = getTodayLedgerPath(vaultPath);
+  const payload = JSON.stringify(event) + "\n";
+  for (let attempt = 0; attempt <= MAX_APPEND_RETRIES; attempt += 1) {
+    try {
+      fs3.appendFileSync(filePath, payload);
+      return;
+    } catch (error) {
+      const errno = asErrno(error);
+      const code = errno?.code;
+      if (code === "ENOENT") {
+        try {
+          fs3.mkdirSync(ledgerDir, { recursive: true });
+        } catch (mkdirError) {
+          throw formatLedgerWriteError(filePath, mkdirError);
+        }
+      }
+      if (code && RETRYABLE_APPEND_CODES.has(code) && attempt < MAX_APPEND_RETRIES) {
+        continue;
+      }
+      throw formatLedgerWriteError(filePath, error);
+    }
+  }
+}
+function buildTransitionEvent(taskId, fromStatus, toStatus, options = {}) {
+  const agentId = process.env.OPENCLAW_AGENT_ID || "manual";
+  const costTokensRaw = process.env.OPENCLAW_TOKEN_ESTIMATE;
+  const costTokens = costTokensRaw ? parseInt(costTokensRaw, 10) : null;
+  return {
+    task_id: taskId,
+    agent_id: agentId,
+    from_status: fromStatus,
+    to_status: toStatus,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    confidence: options.confidence ?? (agentId === "manual" ? 1 : 1),
+    cost_tokens: costTokens !== null && !isNaN(costTokens) ? costTokens : null,
+    reason: options.reason || null
+  };
+}
+function readAllTransitions(vaultPath) {
+  const ledgerDir = getLedgerDir(vaultPath);
+  if (!fs3.existsSync(ledgerDir)) return [];
+  let files = [];
+  try {
+    files = fs3.readdirSync(ledgerDir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const file of files) {
+    let lines = [];
+    try {
+      lines = fs3.readFileSync(path3.join(ledgerDir, file), "utf-8").split("\n").filter((l) => l.trim());
+    } catch {
+      continue;
+    }
+    for (const line of lines) {
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+  }
+  return events;
+}
+function countBlockedTransitions(vaultPath, taskId) {
+  const events = readAllTransitions(vaultPath);
+  return events.filter((e) => e.task_id === taskId && e.to_status === "blocked").length;
+}
+
+// src/lib/primitive-templates.ts
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+
+// src/lib/task-utils.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+}
+function getTasksDir(vaultPath) {
+  return path4.join(path4.resolve(vaultPath), "tasks");
+}
+function getBacklogDir(vaultPath) {
+  return path4.join(path4.resolve(vaultPath), "backlog");
+}
+function ensureBacklogDir(vaultPath) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs4.existsSync(backlogDir)) {
+    fs4.mkdirSync(backlogDir, { recursive: true });
+  }
+}
+function getTaskPath(vaultPath, slug) {
+  return path4.join(getTasksDir(vaultPath), `${slug}.md`);
+}
+function getBacklogPath(vaultPath, slug) {
+  return path4.join(getBacklogDir(vaultPath), `${slug}.md`);
+}
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function parseDueDate(value) {
+  if (!value) return null;
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return null;
+  return timestamp;
+}
+function startOfToday() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}
+var VALID_TASK_STATUSES = /* @__PURE__ */ new Set([
+  "open",
+  "in-progress",
+  "blocked",
+  "done"
+]);
+function isTaskStatus(value) {
+  return typeof value === "string" && VALID_TASK_STATUSES.has(value);
+}
+function persistTaskFrontmatter(task, frontmatter) {
+  fs4.writeFileSync(task.path, import_gray_matter2.default.stringify(task.content, frontmatter));
+}
+function resolveStatusTransition(previousStatus, nextStatus) {
+  if (!isTaskStatus(previousStatus) || !isTaskStatus(nextStatus)) {
+    return null;
+  }
+  if (previousStatus === nextStatus) {
+    return null;
+  }
+  return { fromStatus: previousStatus, toStatus: nextStatus };
+}
+function logStatusTransition({
+  vaultPath,
+  task,
+  fromStatus,
+  toStatus,
+  frontmatter,
+  options
+}) {
+  const normalizedReason = typeof options.reason === "string" ? options.reason.trim() : "";
+  const reason = normalizedReason || (isRegression(fromStatus, toStatus) ? `regression: ${fromStatus} -> ${toStatus}` : void 0);
+  const event = buildTransitionEvent(task.slug, fromStatus, toStatus, {
+    confidence: options.confidence,
+    reason
+  });
+  try {
+    appendTransition(vaultPath, event);
+  } catch {
+    return frontmatter;
+  }
+  if (toStatus !== "blocked" || frontmatter.escalation) {
+    return frontmatter;
+  }
+  let blockedCount = 0;
+  try {
+    blockedCount = countBlockedTransitions(vaultPath, task.slug);
+  } catch {
+    return frontmatter;
+  }
+  if (blockedCount < 3) {
+    return frontmatter;
+  }
+  const escalatedFrontmatter = {
+    ...frontmatter,
+    escalation: true
+  };
+  try {
+    persistTaskFrontmatter(task, escalatedFrontmatter);
+    return escalatedFrontmatter;
+  } catch {
+    return frontmatter;
+  }
+}
+function readTask(vaultPath, slug) {
+  const taskPath = getTaskPath(vaultPath, slug);
+  if (!fs4.existsSync(taskPath)) {
+    return null;
+  }
+  try {
+    const raw = fs4.readFileSync(taskPath, "utf-8");
+    const { data, content } = (0, import_gray_matter2.default)(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: taskPath
+    };
+  } catch {
+    return null;
+  }
+}
+function readBacklogItem(vaultPath, slug) {
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (!fs4.existsSync(backlogPath)) {
+    return null;
+  }
+  try {
+    const raw = fs4.readFileSync(backlogPath, "utf-8");
+    const { data, content } = (0, import_gray_matter2.default)(raw);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter: data,
+      path: backlogPath
+    };
+  } catch {
+    return null;
+  }
+}
+function listTasks(vaultPath, filters) {
+  const tasksDir = getTasksDir(vaultPath);
+  if (!fs4.existsSync(tasksDir)) {
+    return [];
+  }
+  const tasks = [];
+  const entries = fs4.readdirSync(tasksDir, { withFileTypes: true });
+  const today = startOfToday();
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const task = readTask(vaultPath, slug);
+    if (!task) continue;
+    if (filters) {
+      if (filters.status && task.frontmatter.status !== filters.status) continue;
+      if (filters.owner && task.frontmatter.owner !== filters.owner) continue;
+      if (filters.project && task.frontmatter.project !== filters.project) continue;
+      if (filters.priority && task.frontmatter.priority !== filters.priority) continue;
+      if (filters.due && !task.frontmatter.due) continue;
+      if (filters.tag) {
+        const tags = task.frontmatter.tags || [];
+        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
+        if (!hasTag) continue;
+      }
+      if (filters.overdue) {
+        const dueTime = parseDueDate(task.frontmatter.due);
+        if (task.frontmatter.status === "done" || dueTime === null || dueTime >= today) continue;
+      }
+    }
+    tasks.push(task);
+  }
+  const priorityOrder = {
+    critical: 0,
+    high: 1,
+    medium: 2,
+    low: 3
+  };
+  if (filters?.due || filters?.overdue) {
+    return tasks.sort((a, b) => {
+      const aDue = parseDueDate(a.frontmatter.due);
+      const bDue = parseDueDate(b.frontmatter.due);
+      if (aDue !== null && bDue !== null && aDue !== bDue) {
+        return aDue - bDue;
+      }
+      if (aDue !== null && bDue === null) return -1;
+      if (aDue === null && bDue !== null) return 1;
+      return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+    });
+  }
+  return tasks.sort((a, b) => {
+    const aPriority = priorityOrder[a.frontmatter.priority || "low"];
+    const bPriority = priorityOrder[b.frontmatter.priority || "low"];
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function listBacklogItems(vaultPath, filters) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs4.existsSync(backlogDir)) {
+    return [];
+  }
+  const items = [];
+  const entries = fs4.readdirSync(backlogDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    const item = readBacklogItem(vaultPath, slug);
+    if (!item) continue;
+    if (filters) {
+      if (filters.project && item.frontmatter.project !== filters.project) continue;
+      if (filters.source && item.frontmatter.source !== filters.source) continue;
+    }
+    items.push(item);
+  }
+  return items.sort((a, b) => {
+    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
+  });
+}
+function updateTask(vaultPath, slug, updates, options = {}) {
+  const task = readTask(vaultPath, slug);
+  if (!task) {
+    throw new Error(`Task not found: ${slug}`);
+  }
+  if (updates.status !== void 0 && !isTaskStatus(updates.status)) {
+    throw new Error(`Invalid task status: ${String(updates.status)}`);
+  }
+  const previousStatus = task.frontmatter.status;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let newFrontmatter = {
+    ...task.frontmatter,
+    updated: now
+  };
+  if (updates.status !== void 0) {
+    newFrontmatter.status = updates.status;
+    if (updates.status === "done" && !newFrontmatter.completed) {
+      newFrontmatter.completed = now;
+    }
+    if (updates.status !== "done") {
+      delete newFrontmatter.completed;
+    }
+  }
+  if (updates.source !== void 0) {
+    if (updates.source === null || updates.source.trim() === "") {
+      delete newFrontmatter.source;
+    } else {
+      newFrontmatter.source = updates.source;
+    }
+  }
+  if (updates.owner !== void 0) {
+    if (updates.owner === null || updates.owner.trim() === "") {
+      delete newFrontmatter.owner;
+    } else {
+      newFrontmatter.owner = updates.owner;
+    }
+  }
+  if (updates.project !== void 0) {
+    if (updates.project === null || updates.project.trim() === "") {
+      delete newFrontmatter.project;
+    } else {
+      newFrontmatter.project = updates.project;
+    }
+  }
+  if (updates.priority !== void 0) {
+    if (updates.priority === null) {
+      delete newFrontmatter.priority;
+    } else {
+      newFrontmatter.priority = updates.priority;
+    }
+  }
+  if (updates.due !== void 0) {
+    if (updates.due === null || updates.due.trim() === "") {
+      delete newFrontmatter.due;
+    } else {
+      newFrontmatter.due = updates.due;
+    }
+  }
+  if (updates.tags !== void 0) {
+    if (updates.tags === null) {
+      delete newFrontmatter.tags;
+    } else {
+      const normalizedTags = updates.tags.map((tag) => tag.trim()).filter(Boolean);
+      if (normalizedTags.length === 0) {
+        delete newFrontmatter.tags;
+      } else {
+        newFrontmatter.tags = normalizedTags;
+      }
+    }
+  }
+  if (updates.completed !== void 0) {
+    if (updates.completed === null || updates.completed.trim() === "") {
+      delete newFrontmatter.completed;
+    } else {
+      newFrontmatter.completed = updates.completed;
+    }
+  }
+  if (updates.escalation !== void 0) {
+    if (updates.escalation === null) {
+      delete newFrontmatter.escalation;
+    } else {
+      newFrontmatter.escalation = updates.escalation;
+    }
+  }
+  if (updates.confidence !== void 0) {
+    if (updates.confidence === null) {
+      delete newFrontmatter.confidence;
+    } else {
+      newFrontmatter.confidence = updates.confidence;
+    }
+  }
+  if (updates.reason !== void 0) {
+    if (updates.reason === null || updates.reason.trim() === "") {
+      delete newFrontmatter.reason;
+    } else {
+      newFrontmatter.reason = updates.reason;
+    }
+  }
+  if (updates.description !== void 0) {
+    if (updates.description === null || updates.description.trim() === "") {
+      delete newFrontmatter.description;
+    } else {
+      newFrontmatter.description = updates.description;
+    }
+  }
+  if (updates.estimate !== void 0) {
+    if (updates.estimate === null || updates.estimate.trim() === "") {
+      delete newFrontmatter.estimate;
+    } else {
+      newFrontmatter.estimate = updates.estimate;
+    }
+  }
+  if (updates.parent !== void 0) {
+    if (updates.parent === null || updates.parent.trim() === "") {
+      delete newFrontmatter.parent;
+    } else {
+      newFrontmatter.parent = updates.parent;
+    }
+  }
+  if (updates.depends_on !== void 0) {
+    if (updates.depends_on === null) {
+      delete newFrontmatter.depends_on;
+    } else {
+      const normalizedDeps = updates.depends_on.map((dep) => dep.trim()).filter(Boolean);
+      if (normalizedDeps.length === 0) {
+        delete newFrontmatter.depends_on;
+      } else {
+        newFrontmatter.depends_on = normalizedDeps;
+      }
+    }
+  }
+  if (updates.blocked_by !== void 0) {
+    if (updates.blocked_by === null || updates.blocked_by.trim() === "") {
+      delete newFrontmatter.blocked_by;
+    } else {
+      newFrontmatter.blocked_by = updates.blocked_by;
+    }
+  } else if (updates.status !== void 0 && updates.status !== "blocked") {
+    delete newFrontmatter.blocked_by;
+  }
+  persistTaskFrontmatter(task, newFrontmatter);
+  const transition = options.skipTransition ? null : resolveStatusTransition(previousStatus, newFrontmatter.status);
+  if (transition) {
+    const confidence = options.confidence ?? (typeof updates.confidence === "number" ? updates.confidence : void 0);
+    const reason = options.reason ?? updates.reason ?? null;
+    newFrontmatter = logStatusTransition({
+      vaultPath,
+      task,
+      fromStatus: transition.fromStatus,
+      toStatus: transition.toStatus,
+      frontmatter: newFrontmatter,
+      options: {
+        confidence,
+        reason
+      }
+    });
+  }
+  return {
+    ...task,
+    frontmatter: newFrontmatter
+  };
+}
+function createBacklogItem(vaultPath, title, options = {}) {
+  ensureBacklogDir(vaultPath);
+  const slug = slugify(title);
+  const backlogPath = getBacklogPath(vaultPath, slug);
+  if (fs4.existsSync(backlogPath)) {
+    throw new Error(`Backlog item already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    created: now
+  };
+  if (options.source) frontmatter.source = options.source;
+  if (options.project) frontmatter.project = options.project;
+  if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
+  let content = `# ${title}
+`;
+  const links = [];
+  if (options.source) links.push(`[[${options.source}]]`);
+  if (options.project) links.push(`[[${options.project}]]`);
+  if (links.length > 0) {
+    content += `
+${links.join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = import_gray_matter2.default.stringify(content, frontmatter);
+  fs4.writeFileSync(backlogPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter,
+    path: backlogPath
+  };
+}
+function updateBacklogItem(vaultPath, slug, updates) {
+  const backlogItem = readBacklogItem(vaultPath, slug);
+  if (!backlogItem) {
+    throw new Error(`Backlog item not found: ${slug}`);
+  }
+  const newFrontmatter = {
+    ...backlogItem.frontmatter
+  };
+  if (updates.source !== void 0) newFrontmatter.source = updates.source;
+  if (updates.project !== void 0) newFrontmatter.project = updates.project;
+  if (updates.tags !== void 0) newFrontmatter.tags = updates.tags;
+  if (updates.lastSeen !== void 0) newFrontmatter.lastSeen = updates.lastSeen;
+  const fileContent = import_gray_matter2.default.stringify(backlogItem.content, newFrontmatter);
+  fs4.writeFileSync(backlogItem.path, fileContent);
+  return {
+    ...backlogItem,
+    frontmatter: newFrontmatter
+  };
+}
+
+// src/lib/project-utils.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+function extractTitle2(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : "";
+}
+function isDateSlug(slug) {
+  return /^\d{4}-\d{2}-\d{2}$/.test(slug);
+}
+function normalizeStringArray(value) {
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+function getProjectsDir(vaultPath) {
+  return path5.join(path5.resolve(vaultPath), "projects");
+}
+function getProjectPath(vaultPath, slug) {
+  return path5.join(getProjectsDir(vaultPath), `${slug}.md`);
+}
+function parseSortableTimestamp(value) {
+  if (!value) return 0;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
+function normalizeProjectStatus(value) {
+  if (value === "active" || value === "paused" || value === "completed" || value === "archived") {
+    return value;
+  }
+  return "active";
+}
+function normalizeProjectFrontmatter(frontmatter) {
+  const normalizedCreated = typeof frontmatter.created === "string" && frontmatter.created ? frontmatter.created : (/* @__PURE__ */ new Date(0)).toISOString();
+  const normalizedUpdated = typeof frontmatter.updated === "string" && frontmatter.updated ? frontmatter.updated : normalizedCreated;
+  const normalized = {
+    ...frontmatter,
+    type: "project",
+    status: normalizeProjectStatus(frontmatter.status),
+    created: normalizedCreated,
+    updated: normalizedUpdated
+  };
+  if (normalized.team) {
+    const team = normalizeStringArray(normalized.team);
+    if (team.length === 0) {
+      delete normalized.team;
+    } else {
+      normalized.team = team;
+    }
+  }
+  if (normalized.tags) {
+    const tags = normalizeStringArray(normalized.tags);
+    if (tags.length === 0) {
+      delete normalized.tags;
+    } else {
+      normalized.tags = tags;
+    }
+  }
+  return normalized;
+}
+function listProjects(vaultPath, filters) {
+  const projectsDir = getProjectsDir(vaultPath);
+  if (!fs5.existsSync(projectsDir)) {
+    return [];
+  }
+  const projects = [];
+  const entries = fs5.readdirSync(projectsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) {
+      continue;
+    }
+    const slug = entry.name.replace(/\.md$/, "");
+    if (isDateSlug(slug)) {
+      continue;
+    }
+    const project = readProject(vaultPath, slug);
+    if (!project) continue;
+    if (filters) {
+      if (filters.status && project.frontmatter.status !== filters.status) continue;
+      if (filters.owner && project.frontmatter.owner !== filters.owner) continue;
+      if (filters.client && project.frontmatter.client !== filters.client) continue;
+      if (filters.tag) {
+        const tags = project.frontmatter.tags || [];
+        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
+        if (!hasTag) continue;
+      }
+    }
+    projects.push(project);
+  }
+  return projects.sort((left, right) => {
+    const rightTime = parseSortableTimestamp(right.frontmatter.updated || right.frontmatter.created);
+    const leftTime = parseSortableTimestamp(left.frontmatter.updated || left.frontmatter.created);
+    return rightTime - leftTime;
+  });
+}
+function readProject(vaultPath, slug) {
+  if (!slug || isDateSlug(slug) || slug.includes(path5.sep)) {
+    return null;
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (!fs5.existsSync(projectPath)) {
+    return null;
+  }
+  try {
+    const raw = fs5.readFileSync(projectPath, "utf-8");
+    const { data, content } = (0, import_gray_matter3.default)(raw);
+    if (data.type !== "project") {
+      return null;
+    }
+    const frontmatter = normalizeProjectFrontmatter(data);
+    const title = extractTitle2(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/config-manager.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+
+// src/types.ts
+var DEFAULT_CATEGORIES = [
+  "rules",
+  "preferences",
+  "decisions",
+  "patterns",
+  "people",
+  "projects",
+  "goals",
+  "transcripts",
+  "inbox",
+  "templates",
+  "lessons",
+  "agents",
+  "commitments",
+  "handoffs",
+  "research",
+  "tasks",
+  "backlog"
+];
+
+// src/lib/config-manager.ts
+var CONFIG_FILE = ".clawvault.json";
+var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini"];
+var OBSERVER_COMPRESSION_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "openai-compatible",
+  "ollama"
+];
+var THEMES = ["neural", "minimal", "none"];
+var CONTEXT_PROFILES = ["default", "planning", "incident", "handoff", "auto"];
+var DEFAULT_THEME = "none";
+var DEFAULT_OBSERVE_MODEL = "gemini-2.0-flash";
+var DEFAULT_OBSERVE_PROVIDER = "gemini";
+var DEFAULT_CONTEXT_MAX_RESULTS = 5;
+var DEFAULT_CONTEXT_PROFILE = "default";
+var DEFAULT_GRAPH_MAX_HOPS = 2;
+var DEFAULT_INJECT_MAX_RESULTS = 8;
+var DEFAULT_INJECT_USE_LLM = true;
+var DEFAULT_INJECT_SCOPE = ["global"];
+function configPathFor(vaultPath) {
+  return path6.join(path6.resolve(vaultPath), CONFIG_FILE);
+}
+function readConfigDocument(vaultPath) {
+  const configPath = configPathFor(vaultPath);
+  if (!fs6.existsSync(configPath)) {
+    throw new Error(`No ClawVault config found at ${configPath}`);
+  }
+  try {
+    const parsed = JSON.parse(fs6.readFileSync(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Config root must be a JSON object.");
+    }
+    return { ...parsed };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to parse ${CONFIG_FILE}: ${error.message}`);
+    }
+    throw new Error(`Failed to parse ${CONFIG_FILE}.`);
+  }
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const output = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter(Boolean);
+  return output.length > 0 ? output : null;
+}
+function asPositiveInteger(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return null;
+}
+function asBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["true", "1", "yes", "on"].includes(normalized)) {
+      return true;
+    }
+    if (["false", "0", "no", "off"].includes(normalized)) {
+      return false;
+    }
+  }
+  return null;
+}
+function isObserveProvider(value) {
+  return typeof value === "string" && OBSERVE_PROVIDERS.includes(value);
+}
+function isObserverCompressionProvider(value) {
+  return typeof value === "string" && OBSERVER_COMPRESSION_PROVIDERS.includes(value);
+}
+function isTheme(value) {
+  return typeof value === "string" && THEMES.includes(value);
+}
+function isContextProfile(value) {
+  return typeof value === "string" && CONTEXT_PROFILES.includes(value);
+}
+function normalizeRouteTarget(target) {
+  const trimmed = target.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!trimmed) {
+    throw new Error("Route target cannot be empty.");
+  }
+  const segments = trimmed.split("/").map((segment) => segment.trim()).filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error("Route target cannot be empty.");
+  }
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error(`Route target cannot contain relative path segments: ${target}`);
+  }
+  return segments.join("/");
+}
+function normalizeRouteRule(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const record = raw;
+  const pattern = typeof record.pattern === "string" ? record.pattern.trim() : "";
+  const target = typeof record.target === "string" ? record.target.trim() : "";
+  const priority = asPositiveInteger(record.priority);
+  if (!pattern || !target || priority === null) {
+    return null;
+  }
+  return {
+    pattern,
+    target: normalizeRouteTarget(target),
+    priority
+  };
+}
+function normalizeRoutes(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => normalizeRouteRule(entry)).filter((entry) => entry !== null).sort((left, right) => right.priority - left.priority || left.pattern.localeCompare(right.pattern));
+}
+function parseRegexLiteral(pattern) {
+  const match = pattern.match(/^\/(.+)\/([a-z]*)$/i);
+  if (!match) {
+    return null;
+  }
+  try {
+    return new RegExp(match[1], match[2]);
+  } catch (error) {
+    throw new Error(`Invalid route regex pattern "${pattern}": ${error instanceof Error ? error.message : "parse error"}`);
+  }
+}
+function withDefaults(vaultPath, config) {
+  const resolvedPath = path6.resolve(vaultPath);
+  const defaults = {
+    name: path6.basename(resolvedPath),
+    categories: [...DEFAULT_CATEGORIES],
+    theme: DEFAULT_THEME,
+    observe: {
+      model: DEFAULT_OBSERVE_MODEL,
+      provider: DEFAULT_OBSERVE_PROVIDER
+    },
+    observer: {
+      compression: {}
+    },
+    context: {
+      maxResults: DEFAULT_CONTEXT_MAX_RESULTS,
+      defaultProfile: DEFAULT_CONTEXT_PROFILE
+    },
+    graph: {
+      maxHops: DEFAULT_GRAPH_MAX_HOPS
+    },
+    inject: {
+      maxResults: DEFAULT_INJECT_MAX_RESULTS,
+      useLlm: DEFAULT_INJECT_USE_LLM,
+      scope: [...DEFAULT_INJECT_SCOPE]
+    },
+    routes: []
+  };
+  const observeRecord = config.observe && typeof config.observe === "object" && !Array.isArray(config.observe) ? config.observe : {};
+  const contextRecord = config.context && typeof config.context === "object" && !Array.isArray(config.context) ? config.context : {};
+  const observerRecord = config.observer && typeof config.observer === "object" && !Array.isArray(config.observer) ? config.observer : {};
+  const compressionRecord = observerRecord.compression && typeof observerRecord.compression === "object" && !Array.isArray(observerRecord.compression) ? observerRecord.compression : {};
+  const graphRecord = config.graph && typeof config.graph === "object" && !Array.isArray(config.graph) ? config.graph : {};
+  const compressionProvider = isObserverCompressionProvider(compressionRecord.provider) ? compressionRecord.provider : void 0;
+  const compressionModel = typeof compressionRecord.model === "string" && compressionRecord.model.trim() ? compressionRecord.model.trim() : void 0;
+  const compressionBaseUrl = typeof compressionRecord.baseUrl === "string" && compressionRecord.baseUrl.trim() ? compressionRecord.baseUrl.trim() : void 0;
+  const compressionApiKey = typeof compressionRecord.apiKey === "string" && compressionRecord.apiKey.trim() ? compressionRecord.apiKey.trim() : void 0;
+  const normalizedCompression = {};
+  if (compressionProvider) {
+    normalizedCompression.provider = compressionProvider;
+  }
+  if (compressionModel) {
+    normalizedCompression.model = compressionModel;
+  }
+  if (compressionBaseUrl) {
+    normalizedCompression.baseUrl = compressionBaseUrl;
+  }
+  if (compressionApiKey) {
+    normalizedCompression.apiKey = compressionApiKey;
+  }
+  const injectRecord = config.inject && typeof config.inject === "object" && !Array.isArray(config.inject) ? config.inject : {};
+  return {
+    ...config,
+    name: typeof config.name === "string" && config.name.trim() ? config.name.trim() : defaults.name,
+    categories: asStringArray(config.categories) ?? defaults.categories,
+    theme: isTheme(config.theme) ? config.theme : defaults.theme,
+    observe: {
+      ...observeRecord,
+      model: typeof observeRecord.model === "string" && observeRecord.model.trim() ? observeRecord.model.trim() : defaults.observe.model,
+      provider: isObserveProvider(observeRecord.provider) ? observeRecord.provider : defaults.observe.provider
+    },
+    observer: {
+      ...observerRecord,
+      compression: normalizedCompression
+    },
+    context: {
+      ...contextRecord,
+      maxResults: asPositiveInteger(contextRecord.maxResults) ?? defaults.context.maxResults,
+      defaultProfile: isContextProfile(contextRecord.defaultProfile) ? contextRecord.defaultProfile : defaults.context.defaultProfile
+    },
+    graph: {
+      ...graphRecord,
+      maxHops: asPositiveInteger(graphRecord.maxHops) ?? defaults.graph.maxHops
+    },
+    inject: {
+      ...injectRecord,
+      maxResults: asPositiveInteger(injectRecord.maxResults) ?? defaults.inject.maxResults,
+      useLlm: asBoolean(injectRecord.useLlm) ?? defaults.inject.useLlm,
+      scope: asStringArray(injectRecord.scope) ?? (typeof injectRecord.scope === "string" ? injectRecord.scope.split(",").map((entry) => entry.trim()).filter(Boolean) : null) ?? [...defaults.inject.scope]
+    },
+    routes: normalizeRoutes(config.routes)
+  };
+}
+function listConfig(vaultPath) {
+  const config = readConfigDocument(vaultPath);
+  return withDefaults(vaultPath, config);
+}
+function listRouteRules(vaultPath) {
+  const config = listConfig(vaultPath);
+  return normalizeRoutes(config.routes);
+}
+function matchRouteRule(text, routes) {
+  for (const route of routes) {
+    const regex = parseRegexLiteral(route.pattern);
+    if (regex) {
+      if (regex.test(text)) {
+        return route;
+      }
+      continue;
+    }
+    if (text.toLowerCase().includes(route.pattern.toLowerCase())) {
+      return route;
+    }
+  }
+  return null;
+}
+
+// src/observer/router.ts
+var CATEGORY_PATTERNS = [
+  {
+    category: "decisions",
+    patterns: [
+      /\b(decid(?:e|ed|ing|ion)|chose|picked|went with|selected|opted)\b/i,
+      /\b(decision|trade[- ]?off|alternative|rationale)\b/i
+    ]
+  },
+  {
+    category: "lessons",
+    patterns: [
+      /\b(learn(?:ed|ing|t)|lesson|mistake|insight|realized|discovered)\b/i,
+      /\b(note to self|remember|important|don'?t forget|never again)\b/i
+    ]
+  },
+  {
+    category: "people",
+    patterns: [
+      /\b(said|asked|told|mentioned|emailed|called|messaged|met with)\b/i,
+      /\b(client|partner|team|colleague|contact)\b/i,
+      /\b(?:Pedro|Justin|Maria|Sarah|[A-Z][a-z]+ (?:said|asked|told|mentioned))\b/,
+      /\b(?:talked to|met with|spoke with|chatted with|discussed with)\s+[A-Z][a-z]+\b/i,
+      /\b[A-Z][a-z]+\s+(?:from|at)\s+[A-Z]/,
+      /\b[A-Z][a-z]+\s+from\b/
+    ]
+  },
+  {
+    category: "preferences",
+    patterns: [
+      /\b(prefer(?:s|red|ence)?|like(?:s|d)?|want(?:s|ed)?|style|convention)\b/i,
+      /\b(always use|never use|default to)\b/i
+    ]
+  },
+  {
+    category: "commitments",
+    patterns: [
+      /\b(promised|committed|deadline|due|scheduled|will do|agreed to)\b/i,
+      /\b(todo|task|action item|follow[- ]?up)\b/i
+    ]
+  },
+  {
+    category: "projects",
+    patterns: [
+      /\b(deployed|shipped|launched|released|merged|built|created)\b/i,
+      /\b(project|repo|service|api|feature|bug fix)\b/i
+    ]
+  }
+];
+var TYPE_TO_CATEGORY = {
+  decision: "decisions",
+  preference: "preferences",
+  fact: "facts",
+  commitment: "commitments",
+  task: "commitments",
+  todo: "commitments",
+  "commitment-unresolved": "commitments",
+  milestone: "projects",
+  lesson: "lessons",
+  relationship: "people",
+  project: "projects"
+};
+var PAST_TENSE_TASK_HINT_RE = /\b(completed|shipped|deployed|fixed|merged|finished|resolved|closed)\b/i;
+var FUTURE_TASK_HINT_RE = /\b(need to|should|todo|must|plan to)\b/i;
+var Router = class {
+  vaultPath;
+  extractTasks;
+  now;
+  customRoutes;
+  constructor(vaultPath, options = {}) {
+    this.vaultPath = path7.resolve(vaultPath);
+    this.extractTasks = options.extractTasks ?? true;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.customRoutes = this.loadCustomRoutes();
+  }
+  /**
+   * Takes observation markdown and routes items to appropriate vault categories.
+   * Routes only items with importance >= 0.4.
+   * Returns a summary of what was routed where.
+   */
+  route(observationMarkdown, context = {}) {
+    this.customRoutes = this.loadCustomRoutes();
+    const items = this.parseObservations(observationMarkdown);
+    const routed = [];
+    const knownWorkItems = this.extractTasks ? this.loadExistingWorkItems() : [];
+    const knownProjectDefinitions = this.loadKnownProjectDefinitions();
+    let dedupHits = 0;
+    for (const item of items) {
+      if (item.importance < 0.4) continue;
+      if (this.extractTasks && this.isTaskObservation(item.type)) {
+        const taskResult = this.routeTaskObservation(item, context, knownWorkItems);
+        if (taskResult.routedItem) {
+          routed.push(taskResult.routedItem);
+        }
+        if (taskResult.dedupHit) {
+          dedupHits += 1;
+        }
+        continue;
+      }
+      const category = this.categorize(item.type, item.content);
+      if (!category) continue;
+      const routedItem = {
+        category,
+        title: item.title,
+        content: item.content,
+        type: item.type,
+        confidence: item.confidence,
+        importance: item.importance,
+        date: item.date
+      };
+      routed.push(routedItem);
+      this.appendToCategory(category, routedItem, knownProjectDefinitions);
+    }
+    const summary = this.buildSummary(routed, dedupHits);
+    return { routed, summary };
+  }
+  isTaskObservation(type) {
+    return type === "task" || type === "todo" || type === "commitment-unresolved";
+  }
+  routeTaskObservation(item, context, knownWorkItems) {
+    if (this.shouldSkipCompletedTaskCandidate(item.content)) {
+      console.log("[observer] skipped likely-completed task candidate");
+      return { routedItem: null, dedupHit: false };
+    }
+    const title = this.deriveTaskTitle(item.content, item.type);
+    if (!title) {
+      return { routedItem: null, dedupHit: false };
+    }
+    const duplicate = this.findDuplicateWorkItem(title, knownWorkItems);
+    if (duplicate) {
+      if (item.type === "commitment-unresolved" && this.isOpenWorkItem(duplicate)) {
+        this.touchExistingWorkItem(duplicate);
+      }
+      console.log(`[observer] dedup hit for task candidate: "${title}"`);
+      return { routedItem: null, dedupHit: true };
+    }
+    const tags = this.mergeTags(
+      ["open", "observer"],
+      item.type === "task" ? ["task"] : [],
+      item.type === "todo" ? ["todo"] : [],
+      item.type === "commitment-unresolved" ? ["commitment"] : []
+    );
+    const content = this.buildTaskContextContent(item, context);
+    let backlogItem;
+    try {
+      backlogItem = createBacklogItem(this.vaultPath, title, {
+        source: "observer",
+        content,
+        tags
+      });
+    } catch (error) {
+      if (error instanceof Error && /already exists/i.test(error.message)) {
+        console.log(`[observer] dedup hit for task candidate: "${title}"`);
+        return { routedItem: null, dedupHit: true };
+      }
+      throw error;
+    }
+    knownWorkItems.push({
+      kind: "backlog",
+      slug: backlogItem.slug,
+      title: backlogItem.title,
+      status: "open",
+      source: backlogItem.frontmatter.source,
+      tags: backlogItem.frontmatter.tags ?? []
+    });
+    return {
+      dedupHit: false,
+      routedItem: {
+        category: "backlog",
+        title: backlogItem.title,
+        content: item.content,
+        type: item.type,
+        confidence: item.confidence,
+        importance: item.importance,
+        date: item.date
+      }
+    };
+  }
+  loadExistingWorkItems() {
+    const taskItems = listTasks(this.vaultPath).map((task) => ({
+      kind: "task",
+      slug: task.slug,
+      title: task.title,
+      status: task.frontmatter.status,
+      source: task.frontmatter.source,
+      tags: task.frontmatter.tags ?? []
+    }));
+    const backlogItems = listBacklogItems(this.vaultPath).map((item) => ({
+      kind: "backlog",
+      slug: item.slug,
+      title: item.title,
+      status: item.frontmatter.tags?.includes("done") ? "done" : "open",
+      source: item.frontmatter.source,
+      tags: item.frontmatter.tags ?? []
+    }));
+    return [...taskItems, ...backlogItems];
+  }
+  findDuplicateWorkItem(title, knownWorkItems) {
+    const normalizedTitle = this.normalizeTaskTitle(title);
+    if (!normalizedTitle) {
+      return null;
+    }
+    for (const item of knownWorkItems) {
+      const normalizedExisting = this.normalizeTaskTitle(item.title);
+      if (!normalizedExisting) {
+        continue;
+      }
+      if (normalizedExisting === normalizedTitle) {
+        return item;
+      }
+      if (this.jaccardWordSimilarity(normalizedTitle, normalizedExisting) > 0.8) {
+        return item;
+      }
+    }
+    return null;
+  }
+  normalizeTaskTitle(title) {
+    return title.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().slice(0, 50);
+  }
+  jaccardWordSimilarity(a, b) {
+    const aWords = new Set(a.split(" ").filter(Boolean));
+    const bWords = new Set(b.split(" ").filter(Boolean));
+    if (aWords.size === 0 || bWords.size === 0) {
+      return 0;
+    }
+    let intersection = 0;
+    for (const word of aWords) {
+      if (bWords.has(word)) {
+        intersection += 1;
+      }
+    }
+    const unionSize = aWords.size + bWords.size - intersection;
+    return unionSize === 0 ? 0 : intersection / unionSize;
+  }
+  deriveTaskTitle(content, type) {
+    let title = content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\[[^\]]+\]\s*/g, "").trim();
+    if (type === "todo") {
+      title = title.replace(
+        /^(?:todo:\s*|we need to\s+|don't forget(?: to)?\s+|remember to\s+|make sure to\s+)/i,
+        ""
+      );
+    } else if (type === "task") {
+      title = title.replace(
+        /^(?:i'?ll\s+|i will\s+|let me\s+|(?:i'?m\s+)?going to\s+|plan to\s+|should\s+)/i,
+        ""
+      );
+    } else if (type === "commitment-unresolved") {
+      title = title.replace(/^(?:need to figure out\s+|tbd[:\s-]*|to be determined[:\s-]*)/i, "");
+    }
+    title = title.replace(/\s+/g, " ").replace(/^[^a-zA-Z0-9]+/, "").replace(/[.?!:;,]+$/, "").trim();
+    return title.slice(0, 120);
+  }
+  shouldSkipCompletedTaskCandidate(content) {
+    if (!PAST_TENSE_TASK_HINT_RE.test(content)) {
+      return false;
+    }
+    return !FUTURE_TASK_HINT_RE.test(content);
+  }
+  buildTaskContextContent(item, context) {
+    const lines = ["Auto-extracted by observer from session transcript."];
+    if (context.sessionKey) {
+      lines.push(`Session: ${context.sessionKey}`);
+    }
+    if (context.transcriptId) {
+      lines.push(`Transcript: ${context.transcriptId}`);
+    }
+    if (context.source) {
+      lines.push(`Source: ${context.source}`);
+    }
+    const approximateTimestamp = this.extractApproximateTimestamp(item.date, item.content, context.timestamp);
+    lines.push(`Approximate timestamp: ${approximateTimestamp}`);
+    lines.push(`Observation type: ${item.type}`);
+    lines.push(`Original observation: ${item.content}`);
+    return lines.join("\n");
+  }
+  extractApproximateTimestamp(date, content, timestamp) {
+    if (timestamp) {
+      return timestamp.toISOString();
+    }
+    const timeMatch = content.match(/\b([01]\d|2[0-3]):([0-5]\d)\b/);
+    if (timeMatch) {
+      return `${date} ${timeMatch[0]}`;
+    }
+    return date;
+  }
+  isOpenWorkItem(item) {
+    if (item.kind === "task") {
+      return item.status !== "done";
+    }
+    return item.status !== "done";
+  }
+  touchExistingWorkItem(item) {
+    if (item.kind === "task") {
+      if (!this.isOpenWorkItem(item)) {
+        return;
+      }
+      updateTask(this.vaultPath, item.slug, {});
+      return;
+    }
+    const nextTags = this.mergeTags(item.tags, ["commitment"]);
+    updateBacklogItem(this.vaultPath, item.slug, {
+      source: item.source ?? "observer",
+      tags: nextTags,
+      lastSeen: this.now().toISOString()
+    });
+    item.tags = nextTags;
+  }
+  mergeTags(...groups) {
+    const merged = /* @__PURE__ */ new Set();
+    for (const group of groups) {
+      for (const tag of group) {
+        const normalized = tag.trim().toLowerCase();
+        if (normalized) {
+          merged.add(normalized);
+        }
+      }
+    }
+    return [...merged];
+  }
+  parseObservations(markdown) {
+    const records = parseObservationMarkdown(markdown);
+    return records.map((record) => ({
+      type: record.type,
+      confidence: record.confidence,
+      importance: record.importance,
+      content: record.content,
+      date: record.date,
+      title: record.content.slice(0, 80).replace(/[^a-zA-Z0-9\s-]/g, "").trim()
+    }));
+  }
+  categorize(type, content) {
+    const typedCategory = TYPE_TO_CATEGORY[type];
+    if (typedCategory) {
+      return typedCategory;
+    }
+    for (const { category, patterns } of CATEGORY_PATTERNS) {
+      if (patterns.some((p) => p.test(content))) {
+        return category;
+      }
+    }
+    return null;
+  }
+  normalizeForDedup(content) {
+    return normalizeObservationContent(
+      content.replace(/\[\[[^\]]*\]\]/g, (match) => match.replace(/\[\[|\]\]/g, ""))
+    );
+  }
+  /**
+   * Extract entity slug from observation content for people/projects routing.
+   * Returns null if no entity can be identified.
+   */
+  extractEntitySlug(content, category) {
+    if (category !== "people" && category !== "projects") return null;
+    if (category === "people") {
+      const patterns = [
+        /(?:talked to|met with|spoke with|chatted with|discussed with|emailed|called|messaged)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/,
+        /([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\s+(?:said|asked|told|mentioned|from|at)\b/,
+        /\b(?:client|partner|colleague|contact)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/i
+      ];
+      for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match?.[1]) return this.toSlug(match[1]);
+      }
+    }
+    if (category === "projects") {
+      const patterns = [
+        /(?:deployed|shipped|launched|released|built|created|working on)\s+([A-Z][a-zA-Z0-9-]+)/,
+        /"([^"]+)"\s+(?:project|repo|service)/i
+      ];
+      for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match?.[1]) return this.toSlug(match[1]);
+      }
+    }
+    return null;
+  }
+  toSlug(name) {
+    return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+  normalizeProjectReference(value) {
+    return value.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
+  }
+  escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  extractWikiTargets(content) {
+    const targets = [];
+    for (const match of content.matchAll(/\[\[([^\]]+)\]\]/g)) {
+      const candidate = match[1];
+      if (!candidate) continue;
+      const target = candidate.split("|")[0].split("#")[0].trim();
+      if (target) targets.push(target);
+    }
+    return targets;
+  }
+  loadKnownProjectDefinitions() {
+    try {
+      return listProjects(this.vaultPath).map((project) => ({
+        slug: project.slug,
+        normalizedSlug: this.normalizeProjectReference(project.slug),
+        title: project.title,
+        normalizedTitle: project.title.toLowerCase()
+      }));
+    } catch {
+      return [];
+    }
+  }
+  matchKnownProjectSlug(content, knownProjects) {
+    if (knownProjects.length === 0) {
+      return null;
+    }
+    const normalizedContent = content.toLowerCase();
+    const wikiTargets = this.extractWikiTargets(content).map((target) => this.normalizeProjectReference(target));
+    for (const project of knownProjects) {
+      if (wikiTargets.includes(project.normalizedSlug)) {
+        return project.slug;
+      }
+      if (project.normalizedTitle && normalizedContent.includes(project.normalizedTitle)) {
+        return project.slug;
+      }
+      const slugPattern = new RegExp(`\\b${this.escapeRegExp(project.normalizedSlug)}\\b`, "i");
+      if (slugPattern.test(content)) {
+        return project.slug;
+      }
+    }
+    return null;
+  }
+  loadCustomRoutes() {
+    try {
+      return listRouteRules(this.vaultPath);
+    } catch {
+      return [];
+    }
+  }
+  resolveCustomEntityPath(content, category) {
+    if (category !== "people" && category !== "projects" || this.customRoutes.length === 0) {
+      return null;
+    }
+    const matchedRule = matchRouteRule(content, this.customRoutes);
+    if (!matchedRule) {
+      return null;
+    }
+    const targetParts = matchedRule.target.split("/").map((segment) => segment.trim()).filter(Boolean);
+    if (targetParts.length < 2 || targetParts[0] !== category) {
+      return null;
+    }
+    return targetParts.slice(1).join("/");
+  }
+  /**
+   * Resolve the file path for a routed item.
+   * For people/projects: entity-slug subfolder with date file (e.g., people/pedro/2026-02-12.md)
+   * For other categories: category/date.md
+   */
+  resolveFilePath(category, item, knownProjectDefinitions) {
+    const customEntityPath = this.resolveCustomEntityPath(item.content, category);
+    if (customEntityPath) {
+      const customEntityDir = path7.join(this.vaultPath, category, customEntityPath);
+      fs7.mkdirSync(customEntityDir, { recursive: true });
+      return {
+        filePath: path7.join(customEntityDir, `${item.date}.md`),
+        headerLabel: `${category}/${customEntityPath}`
+      };
+    }
+    if (category === "projects") {
+      const matchedProjectSlug = this.matchKnownProjectSlug(item.content, knownProjectDefinitions);
+      if (matchedProjectSlug) {
+        const projectDir = path7.join(this.vaultPath, category, matchedProjectSlug);
+        fs7.mkdirSync(projectDir, { recursive: true });
+        return {
+          filePath: path7.join(projectDir, `${item.date}.md`),
+          headerLabel: `${category}/${matchedProjectSlug}`
+        };
+      }
+    } else {
+      const entitySlug = this.extractEntitySlug(item.content, category);
+      if (entitySlug) {
+        const entityDir = path7.join(this.vaultPath, category, entitySlug);
+        fs7.mkdirSync(entityDir, { recursive: true });
+        return {
+          filePath: path7.join(entityDir, `${item.date}.md`),
+          headerLabel: `${category}/${entitySlug}`
+        };
+      }
+    }
+    const categoryDir = path7.join(this.vaultPath, category);
+    fs7.mkdirSync(categoryDir, { recursive: true });
+    return {
+      filePath: path7.join(categoryDir, `${item.date}.md`),
+      headerLabel: category
+    };
+  }
+  appendToCategory(category, item, knownProjectDefinitions) {
+    const destination = this.resolveFilePath(category, item, knownProjectDefinitions);
+    const filePath = destination.filePath;
+    fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+    const existing = fs7.existsSync(filePath) ? fs7.readFileSync(filePath, "utf-8").trim() : "";
+    const normalizedNew = this.normalizeForDedup(item.content);
+    const existingLines = existing.split(/\r?\n/);
+    for (const line of existingLines) {
+      const lineContent = line.replace(/^-\s*/, "").trim();
+      const parsed = parseObservationLine(lineContent, item.date);
+      const candidate = parsed ? parsed.content : lineContent;
+      if (this.normalizeForDedup(candidate) === normalizedNew) return;
+    }
+    for (const line of existingLines) {
+      const lineContent = line.replace(/^-\s*/, "").trim();
+      const parsed = parseObservationLine(lineContent, item.date);
+      const normalizedExisting = this.normalizeForDedup(parsed ? parsed.content : lineContent);
+      if (normalizedExisting.length > 10 && normalizedNew.length > 10) {
+        const shorter = normalizedNew.length < normalizedExisting.length ? normalizedNew : normalizedExisting;
+        const longer = normalizedNew.length >= normalizedExisting.length ? normalizedNew : normalizedExisting;
+        if (longer.includes(shorter) || this.similarity(normalizedNew, normalizedExisting) > 0.8) return;
+      }
+    }
+    const linkedContent = this.addWikiLinks(item.content);
+    const entry = renderScoredObservationLine({
+      type: item.type,
+      confidence: item.confidence,
+      importance: item.importance,
+      content: linkedContent
+    });
+    const headerLabel = destination.headerLabel;
+    const header = existing ? "" : `# ${headerLabel} \u2014 ${item.date}
+`;
+    const newContent = existing ? `${existing}
+${entry}
+` : `${header}
+${entry}
+`;
+    fs7.writeFileSync(filePath, newContent, "utf-8");
+  }
+  /**
+   * Auto-link proper nouns and known entities with [[wiki-links]].
+   * Scans for capitalized names, project names, and tool names.
+   * Skips content already inside [[brackets]].
+   */
+  addWikiLinks(content) {
+    if (content.includes("[[")) return content;
+    const namePattern = /\b([A-Z][a-z]{2,}(?:\s+[A-Z][a-z]{2,})?)\b/g;
+    const skipWords = /* @__PURE__ */ new Set([
+      "The",
+      "This",
+      "That",
+      "These",
+      "Those",
+      "There",
+      "Then",
+      "Than",
+      "When",
+      "Where",
+      "What",
+      "Which",
+      "While",
+      "With",
+      "Would",
+      "Will",
+      "Should",
+      "Could",
+      "About",
+      "After",
+      "Before",
+      "Between",
+      "Because",
+      "Also",
+      "Always",
+      "Already",
+      "Another",
+      "Any",
+      "Each",
+      "Every",
+      "From",
+      "Have",
+      "Has",
+      "Had",
+      "Into",
+      "Just",
+      "Keep",
+      "Like",
+      "Made",
+      "Make",
+      "Many",
+      "More",
+      "Most",
+      "Much",
+      "Must",
+      "Need",
+      "Never",
+      "Next",
+      "None",
+      "Not",
+      "Now",
+      "Only",
+      "Other",
+      "Over",
+      "Same",
+      "Some",
+      "Such",
+      "Sure",
+      "Take",
+      "Them",
+      "They",
+      "Too",
+      "Under",
+      "Until",
+      "Upon",
+      "Very",
+      "Want",
+      "Were",
+      "Work",
+      "Yet",
+      "Decision",
+      "Error",
+      "Deadline",
+      "Friday",
+      "Monday",
+      "Tuesday",
+      "Wednesday",
+      "Thursday",
+      "Saturday",
+      "Sunday",
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December",
+      "Today",
+      "Tomorrow",
+      "Yesterday",
+      "Message",
+      "Feature",
+      "Session",
+      "Update",
+      "System",
+      "User",
+      "Processed",
+      "Working",
+      "Built",
+      "Deployed",
+      "Discussed",
+      "Talked",
+      "Mentioned",
+      "Requested",
+      "Asked",
+      "Said"
+    ]);
+    const knownEntities = /* @__PURE__ */ new Set([
+      "PostgreSQL",
+      "MongoDB",
+      "Railway",
+      "Vercel",
+      "React",
+      "Vue",
+      "Svelte",
+      "Express",
+      "NestJS",
+      "Prisma",
+      "Docker",
+      "Kubernetes",
+      "Redis",
+      "GraphQL",
+      "Stripe",
+      "ClawVault",
+      "OpenClaw",
+      "GitHub",
+      "Obsidian"
+    ]);
+    return content.replace(namePattern, (match) => {
+      if (skipWords.has(match)) return match;
+      if (knownEntities.has(match)) return `[[${match}]]`;
+      if (/^[A-Z][a-z]+$/.test(match) && match.length >= 3) {
+        return `[[${match}]]`;
+      }
+      if (/^[A-Z][a-z]+ [A-Z][a-z]+$/.test(match)) {
+        return `[[${match}]]`;
+      }
+      return match;
+    });
+  }
+  /**
+   * Jaccard similarity on word bigrams — cheap approximation.
+   */
+  similarity(a, b) {
+    const bigrams = (s) => {
+      const words = s.split(" ");
+      const bg = /* @__PURE__ */ new Set();
+      for (let i = 0; i < words.length - 1; i++) bg.add(`${words[i]} ${words[i + 1]}`);
+      return bg;
+    };
+    const setA = bigrams(a);
+    const setB = bigrams(b);
+    if (setA.size === 0 || setB.size === 0) return 0;
+    let intersection = 0;
+    for (const bg of setA) if (setB.has(bg)) intersection++;
+    return intersection / (setA.size + setB.size - intersection);
+  }
+  buildSummary(routed, dedupHits) {
+    if (routed.length === 0) {
+      if (dedupHits > 0) {
+        return `No items routed to vault categories (dedup hits: ${dedupHits}).`;
+      }
+      return "No items routed to vault categories.";
+    }
+    const byCat = /* @__PURE__ */ new Map();
+    for (const item of routed) {
+      byCat.set(item.category, (byCat.get(item.category) ?? 0) + 1);
+    }
+    const parts = [...byCat.entries()].map(([cat, count]) => `${cat}: ${count}`);
+    const suffix = dedupHits > 0 ? ` (dedup hits: ${dedupHits})` : "";
+    return `Routed ${routed.length} observations \u2192 ${parts.join(", ")}${suffix}`;
+  }
+};
+
+// src/observer/observer.ts
+var COMPRESSION_PROVIDERS = /* @__PURE__ */ new Set([
+  "anthropic",
+  "openai",
+  "gemini",
+  "openai-compatible",
+  "ollama"
+]);
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function asCompressionProvider(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return COMPRESSION_PROVIDERS.has(normalized) ? normalized : void 0;
+}
+function readCompressionConfig(vaultPath) {
+  try {
+    const config = listConfig(vaultPath);
+    const root = asRecord(config);
+    const observer = asRecord(root?.observer);
+    const compression = asRecord(observer?.compression);
+    if (!compression) {
+      return {};
+    }
+    return {
+      provider: asCompressionProvider(compression.provider),
+      model: asNonEmptyString(compression.model),
+      baseUrl: asNonEmptyString(compression.baseUrl),
+      apiKey: asNonEmptyString(compression.apiKey)
+    };
+  } catch {
+    return {};
+  }
+}
+var Observer = class {
+  vaultPath;
+  tokenThreshold;
+  // Kept for backwards API compatibility with callers that still pass this.
+  // Reflection now runs explicitly via clawvault reflect.
+  reflectThreshold;
+  compressor;
+  reflector;
+  now;
+  rawCapture;
+  router;
+  pendingMessages = [];
+  pendingRouteContext = {};
+  observationsCache = "";
+  lastRoutingSummary = "";
+  constructor(vaultPath, options = {}) {
+    this.vaultPath = path8.resolve(vaultPath);
+    this.tokenThreshold = options.tokenThreshold ?? 3e4;
+    this.reflectThreshold = options.reflectThreshold ?? 4e4;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    const compressionConfig = readCompressionConfig(this.vaultPath);
+    this.compressor = options.compressor ?? new Compressor({
+      provider: options.compressionProvider ?? compressionConfig.provider,
+      model: options.model ?? compressionConfig.model,
+      baseUrl: options.compressionBaseUrl ?? compressionConfig.baseUrl,
+      apiKey: options.compressionApiKey ?? compressionConfig.apiKey,
+      now: this.now
+    });
+    this.reflector = options.reflector ?? new Reflector({ now: this.now });
+    this.rawCapture = options.rawCapture ?? true;
+    this.router = new Router(vaultPath, {
+      extractTasks: options.extractTasks,
+      now: this.now
+    });
+    ensureLedgerStructure(this.vaultPath);
+    this.observationsCache = this.readTodayObservations();
+  }
+  async processMessages(messages, options = {}) {
+    const incoming = messages.map((message) => message.trim()).filter(Boolean);
+    if (incoming.length === 0) {
+      return;
+    }
+    if (this.rawCapture) {
+      this.persistRawMessages(incoming, options);
+    }
+    this.pendingMessages.push(...incoming);
+    this.pendingRouteContext = this.mergeRouteContext(this.pendingRouteContext, options);
+    const buffered = this.pendingMessages.join("\n");
+    if (this.estimateTokens(buffered) < this.tokenThreshold) {
+      return;
+    }
+    const today = this.now();
+    const todayPath = getObservationPath(this.vaultPath, today);
+    const existingRaw = this.readObservationForDate(today);
+    const existing = this.deduplicateObservationMarkdown(existingRaw);
+    if (existingRaw.trim() !== existing) {
+      this.writeObservationFile(todayPath, existing);
+    }
+    const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const routeContext = this.pendingRouteContext;
+    this.pendingMessages = [];
+    this.pendingRouteContext = {};
+    const compressed = this.deduplicateObservationMarkdown(compressedRaw);
+    if (!compressed) {
+      return;
+    }
+    this.writeObservationFile(todayPath, compressed);
+    this.observationsCache = compressed;
+    const { summary } = this.router.route(compressed, routeContext);
+    if (summary) {
+      this.lastRoutingSummary = summary;
+    }
+  }
+  /**
+   * Force-flush pending messages regardless of threshold.
+   * Call this on session end to capture everything.
+   */
+  async flush() {
+    if (this.pendingMessages.length === 0) {
+      return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
+    }
+    const today = this.now();
+    const todayPath = getObservationPath(this.vaultPath, today);
+    const existingRaw = this.readObservationForDate(today);
+    const existing = this.deduplicateObservationMarkdown(existingRaw);
+    if (existingRaw.trim() !== existing) {
+      this.writeObservationFile(todayPath, existing);
+    }
+    const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const routeContext = this.pendingRouteContext;
+    this.pendingMessages = [];
+    this.pendingRouteContext = {};
+    const compressed = this.deduplicateObservationMarkdown(compressedRaw);
+    if (compressed) {
+      this.writeObservationFile(todayPath, compressed);
+      this.observationsCache = compressed;
+      const { summary } = this.router.route(compressed, routeContext);
+      this.lastRoutingSummary = summary;
+    }
+    return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
+  }
+  getObservations() {
+    this.observationsCache = this.readTodayObservations();
+    return this.observationsCache;
+  }
+  estimateTokens(input) {
+    return Math.ceil(input.length / 4);
+  }
+  readTodayObservations() {
+    return this.readObservationForDate(this.now());
+  }
+  readObservationForDate(date) {
+    const ledgerPath = getObservationPath(this.vaultPath, date);
+    const ledgerValue = this.readObservationFile(ledgerPath);
+    if (ledgerValue) {
+      return ledgerValue;
+    }
+    return this.readObservationFile(getLegacyObservationPath(this.vaultPath, toDateKey(date)));
+  }
+  readObservationFile(filePath) {
+    if (!fs8.existsSync(filePath)) {
+      return "";
+    }
+    return fs8.readFileSync(filePath, "utf-8").trim();
+  }
+  writeObservationFile(filePath, content) {
+    ensureParentDir(filePath);
+    fs8.writeFileSync(filePath, `${content.trim()}
+`, "utf-8");
+  }
+  deduplicateObservationMarkdown(markdown) {
+    const parsed = parseObservationMarkdown(markdown);
+    if (parsed.length === 0) {
+      return markdown.trim();
+    }
+    const grouped = /* @__PURE__ */ new Map();
+    for (const record of parsed) {
+      const bucket = grouped.get(record.date) ?? [];
+      const normalized = normalizeObservationContent(record.content);
+      const existingIndex = bucket.findIndex(
+        (line) => normalizeObservationContent(line.content) === normalized
+      );
+      if (existingIndex === -1) {
+        bucket.push({
+          type: record.type,
+          confidence: record.confidence,
+          importance: record.importance,
+          content: record.content
+        });
+      } else {
+        const existing = bucket[existingIndex];
+        bucket[existingIndex] = {
+          type: record.importance >= existing.importance ? record.type : existing.type,
+          confidence: Math.max(existing.confidence, record.confidence),
+          importance: Math.max(existing.importance, record.importance),
+          content: existing.content.length >= record.content.length ? existing.content : record.content
+        };
+      }
+      grouped.set(record.date, bucket);
+    }
+    return renderObservationMarkdown(grouped);
+  }
+  persistRawMessages(messages, options) {
+    const source = this.sanitizeSource(options.source ?? "openclaw");
+    const messageTimestamp = options.timestamp ?? this.now();
+    const rawPath = getRawTranscriptPath(this.vaultPath, source, messageTimestamp);
+    ensureParentDir(rawPath);
+    const records = messages.map((message) => JSON.stringify({
+      recordedAt: this.now().toISOString(),
+      timestamp: messageTimestamp.toISOString(),
+      source,
+      sessionKey: options.sessionKey ?? null,
+      transcriptId: options.transcriptId ?? null,
+      message
+    }));
+    fs8.appendFileSync(rawPath, `${records.join("\n")}
+`, "utf-8");
+  }
+  sanitizeSource(source) {
+    const normalized = source.trim().toLowerCase();
+    if (/^[a-z0-9_-]{1,64}$/.test(normalized)) {
+      return normalized;
+    }
+    return "openclaw";
+  }
+  mergeRouteContext(existing, incoming) {
+    const merged = { ...existing };
+    if (incoming.source) merged.source = incoming.source;
+    if (incoming.sessionKey) merged.sessionKey = incoming.sessionKey;
+    if (incoming.transcriptId) merged.transcriptId = incoming.transcriptId;
+    if (incoming.timestamp) merged.timestamp = incoming.timestamp;
+    return merged;
+  }
+};
+
+// src/commands/rebuild.ts
+var DATE_RE2 = /^\d{4}-\d{2}-\d{2}$/;
+function parseDateFlag(raw, label) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!DATE_RE2.test(trimmed)) {
+    throw new Error(`Invalid ${label} date. Expected YYYY-MM-DD: ${raw}`);
+  }
+  return trimmed;
+}
+function loadRawMessages(rawFilePath) {
+  const lines = fs9.readFileSync(rawFilePath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const messages = [];
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed.message === "string" && parsed.message.trim()) {
+        messages.push(parsed.message.trim());
+      }
+    } catch {
+      messages.push(line);
+    }
+  }
+  return messages;
+}
+async function rebuildCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const fromDate = parseDateFlag(options.from, "from");
+  const toDate = parseDateFlag(options.to, "to");
+  if (fromDate && toDate && fromDate > toDate) {
+    throw new Error(`Invalid range: --from ${fromDate} is after --to ${toDate}.`);
+  }
+  const rawFiles = listRawTranscriptFiles(vaultPath, {
+    fromDate,
+    toDate
+  });
+  if (rawFiles.length === 0) {
+    console.log("No raw transcripts found for rebuild range.");
+    return;
+  }
+  const filesByDate = /* @__PURE__ */ new Map();
+  for (const file of rawFiles) {
+    const bucket = filesByDate.get(file.date) ?? [];
+    bucket.push({ source: file.source, path: file.path });
+    filesByDate.set(file.date, bucket);
+  }
+  const dates = [...filesByDate.keys()].sort((left, right) => left.localeCompare(right));
+  let rebuiltDates = 0;
+  let processedFiles = 0;
+  for (const date of dates) {
+    const ledgerObservationPath = getObservationPath(vaultPath, date);
+    const legacyObservationPath = getLegacyObservationPath(vaultPath, date);
+    fs9.rmSync(ledgerObservationPath, { force: true });
+    fs9.rmSync(legacyObservationPath, { force: true });
+    const fixedNow = () => /* @__PURE__ */ new Date(`${date}T12:00:00.000Z`);
+    const observer = new Observer(vaultPath, {
+      tokenThreshold: 1,
+      reflectThreshold: Number.MAX_SAFE_INTEGER,
+      now: fixedNow,
+      rawCapture: false
+    });
+    for (const file of filesByDate.get(date) ?? []) {
+      const messages = loadRawMessages(file.path);
+      if (messages.length === 0) {
+        continue;
+      }
+      await observer.processMessages(messages, {
+        source: file.source,
+        timestamp: fixedNow()
+      });
+      processedFiles += 1;
+    }
+    await observer.flush();
+    rebuiltDates += 1;
+  }
+  console.log(`Rebuild complete: ${rebuiltDates} day(s), ${processedFiles} raw file(s) replayed.`);
+}
+function registerRebuildCommand(program) {
+  program.command("rebuild").description("Rebuild compiled observations from raw ledger transcripts").option("--from <date>", "Start date (YYYY-MM-DD)").option("--to <date>", "End date (YYYY-MM-DD)").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await rebuildCommand({
+      vaultPath: rawOptions.vault,
+      from: rawOptions.from,
+      to: rawOptions.to
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rebuildCommand,
+  registerRebuildCommand
+});