clawvault 2.6.0 → 3.0.0

package/dist/commands/observe.cjs

@@ -0,0 +1,4099 @@
+"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/observe.ts
+var observe_exports = {};
+__export(observe_exports, {
+  observeCommand: () => observeCommand,
+  registerObserveCommand: () => registerObserveCommand
+});
+module.exports = __toCommonJS(observe_exports);
+var fs12 = __toESM(require("fs"), 1);
+var path13 = __toESM(require("path"), 1);
+var import_child_process2 = require("child_process");
+
+// src/observer/observer.ts
+var fs7 = __toESM(require("fs"), 1);
+var path7 = __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 fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// src/lib/task-utils.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/lib/transition-ledger.ts
+var fs = __toESM(require("fs"), 1);
+var path = __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 path.join(path.resolve(vaultPath), "ledger", "transitions");
+}
+function getTodayLedgerPath(vaultPath) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return path.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 {
+    fs.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 {
+      fs.appendFileSync(filePath, payload);
+      return;
+    } catch (error) {
+      const errno = asErrno(error);
+      const code = errno?.code;
+      if (code === "ENOENT") {
+        try {
+          fs.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 (!fs.existsSync(ledgerDir)) return [];
+  let files = [];
+  try {
+    files = fs.readdirSync(ledgerDir).filter((f) => f.endsWith(".jsonl")).sort();
+  } catch {
+    return [];
+  }
+  const events = [];
+  for (const file of files) {
+    let lines = [];
+    try {
+      lines = fs.readFileSync(path.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 path2.join(path2.resolve(vaultPath), "tasks");
+}
+function getBacklogDir(vaultPath) {
+  return path2.join(path2.resolve(vaultPath), "backlog");
+}
+function ensureBacklogDir(vaultPath) {
+  const backlogDir = getBacklogDir(vaultPath);
+  if (!fs2.existsSync(backlogDir)) {
+    fs2.mkdirSync(backlogDir, { recursive: true });
+  }
+}
+function getTaskPath(vaultPath, slug) {
+  return path2.join(getTasksDir(vaultPath), `${slug}.md`);
+}
+function getBacklogPath(vaultPath, slug) {
+  return path2.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) {
+  fs2.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 (!fs2.existsSync(taskPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.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 (!fs2.existsSync(backlogPath)) {
+    return null;
+  }
+  try {
+    const raw = fs2.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 (!fs2.existsSync(tasksDir)) {
+    return [];
+  }
+  const tasks = [];
+  const entries = fs2.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 (!fs2.existsSync(backlogDir)) {
+    return [];
+  }
+  const items = [];
+  const entries = fs2.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 (fs2.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);
+  fs2.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);
+  fs2.writeFileSync(backlogItem.path, fileContent);
+  return {
+    ...backlogItem,
+    frontmatter: newFrontmatter
+  };
+}
+
+// src/lib/project-utils.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __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 path3.join(path3.resolve(vaultPath), "projects");
+}
+function getProjectPath(vaultPath, slug) {
+  return path3.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 (!fs3.existsSync(projectsDir)) {
+    return [];
+  }
+  const projects = [];
+  const entries = fs3.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(path3.sep)) {
+    return null;
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (!fs3.existsSync(projectPath)) {
+    return null;
+  }
+  try {
+    const raw = fs3.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 fs4 = __toESM(require("fs"), 1);
+var path4 = __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 path4.join(path4.resolve(vaultPath), CONFIG_FILE);
+}
+function readConfigDocument(vaultPath) {
+  const configPath = configPathFor(vaultPath);
+  if (!fs4.existsSync(configPath)) {
+    throw new Error(`No ClawVault config found at ${configPath}`);
+  }
+  try {
+    const parsed = JSON.parse(fs4.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 = path4.resolve(vaultPath);
+  const defaults = {
+    name: path4.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 = path5.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 = path5.join(this.vaultPath, category, customEntityPath);
+      fs5.mkdirSync(customEntityDir, { recursive: true });
+      return {
+        filePath: path5.join(customEntityDir, `${item.date}.md`),
+        headerLabel: `${category}/${customEntityPath}`
+      };
+    }
+    if (category === "projects") {
+      const matchedProjectSlug = this.matchKnownProjectSlug(item.content, knownProjectDefinitions);
+      if (matchedProjectSlug) {
+        const projectDir = path5.join(this.vaultPath, category, matchedProjectSlug);
+        fs5.mkdirSync(projectDir, { recursive: true });
+        return {
+          filePath: path5.join(projectDir, `${item.date}.md`),
+          headerLabel: `${category}/${matchedProjectSlug}`
+        };
+      }
+    } else {
+      const entitySlug = this.extractEntitySlug(item.content, category);
+      if (entitySlug) {
+        const entityDir = path5.join(this.vaultPath, category, entitySlug);
+        fs5.mkdirSync(entityDir, { recursive: true });
+        return {
+          filePath: path5.join(entityDir, `${item.date}.md`),
+          headerLabel: `${category}/${entitySlug}`
+        };
+      }
+    }
+    const categoryDir = path5.join(this.vaultPath, category);
+    fs5.mkdirSync(categoryDir, { recursive: true });
+    return {
+      filePath: path5.join(categoryDir, `${item.date}.md`),
+      headerLabel: category
+    };
+  }
+  appendToCategory(category, item, knownProjectDefinitions) {
+    const destination = this.resolveFilePath(category, item, knownProjectDefinitions);
+    const filePath = destination.filePath;
+    fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+    const existing = fs5.existsSync(filePath) ? fs5.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}
+`;
+    fs5.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/lib/ledger.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+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) {
+  fs6.mkdirSync(dirPath, { recursive: true });
+}
+function toDateKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function getLedgerRoot(vaultPath) {
+  return path6.join(path6.resolve(vaultPath), "ledger");
+}
+function getRawRoot(vaultPath) {
+  return path6.join(getLedgerRoot(vaultPath), "raw");
+}
+function getRawSourceDir(vaultPath, source) {
+  return path6.join(getRawRoot(vaultPath), source);
+}
+function getObservationsRoot(vaultPath) {
+  return path6.join(getLedgerRoot(vaultPath), "observations");
+}
+function getReflectionsRoot(vaultPath) {
+  return path6.join(getLedgerRoot(vaultPath), "reflections");
+}
+function getArchiveObservationsRoot(vaultPath) {
+  return path6.join(getLedgerRoot(vaultPath), "archive", "observations");
+}
+function getLegacyObservationsRoot(vaultPath) {
+  return path6.join(path6.resolve(vaultPath), "observations");
+}
+function getObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path6.join(getObservationsRoot(vaultPath), year, month, `${day}.md`);
+}
+function getLegacyObservationPath(vaultPath, date) {
+  const dateKey = normalizeDateKey(date);
+  return path6.join(getLegacyObservationsRoot(vaultPath), `${dateKey}.md`);
+}
+function getRawTranscriptPath(vaultPath, source, date) {
+  const dateKey = normalizeDateKey(date);
+  const [year, month, day] = dateKey.split("-");
+  return path6.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(path6.join(rawRoot, source));
+  }
+  ensureDir(getObservationsRoot(vaultPath));
+  ensureDir(getReflectionsRoot(vaultPath));
+  ensureDir(getArchiveObservationsRoot(vaultPath));
+}
+function ensureParentDir(filePath) {
+  ensureDir(path6.dirname(filePath));
+}
+
+// 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 = path7.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 (!fs7.existsSync(filePath)) {
+      return "";
+    }
+    return fs7.readFileSync(filePath, "utf-8").trim();
+  }
+  writeObservationFile(filePath, content) {
+    ensureParentDir(filePath);
+    fs7.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
+    }));
+    fs7.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/observer/session-parser.ts
+var fs8 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+var JSONL_SAMPLE_LIMIT = 20;
+var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
+var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
+function normalizeText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractText(value) {
+  if (typeof value === "string") {
+    return normalizeText(value);
+  }
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const part of value) {
+      const extracted = extractText(part);
+      if (extracted) {
+        parts.push(extracted);
+      }
+    }
+    return normalizeText(parts.join(" "));
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const record = value;
+  if (typeof record.text === "string") {
+    return normalizeText(record.text);
+  }
+  if (typeof record.content === "string") {
+    return normalizeText(record.content);
+  }
+  return "";
+}
+function normalizeRole(role) {
+  if (typeof role !== "string") {
+    return "";
+  }
+  const normalized = role.trim().toLowerCase();
+  if (!normalized) {
+    return "";
+  }
+  return normalized;
+}
+function isLikelyJsonMessage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if ("role" in record && "content" in record) {
+    return true;
+  }
+  if (record.type === "message" && record.message && typeof record.message === "object") {
+    return true;
+  }
+  return false;
+}
+function parseJsonLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return "";
+  }
+  const entry = parsed;
+  if ("role" in entry && "content" in entry) {
+    const role = normalizeRole(entry.role);
+    const content = extractText(entry.content);
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+    const message = entry.message;
+    const role = normalizeRole(message.role);
+    const content = extractText(message.content);
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  return "";
+}
+function parseJsonLines(raw) {
+  const messages = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parsed = parseJsonLine(trimmed);
+    if (parsed) {
+      messages.push(parsed);
+    }
+  }
+  return messages;
+}
+function stripMarkdownSyntax(text) {
+  return normalizeText(
+    text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_`~]/g, "").replace(/<[^>]+>/g, "")
+  );
+}
+function normalizeMarkdownLine(line) {
+  return stripMarkdownSyntax(
+    line.replace(/^>\s*/, "").replace(/^[-*+]\s+/, "").replace(/^#{1,6}\s+/, "")
+  );
+}
+function parseMarkdown(raw) {
+  const withoutCodeBlocks = raw.replace(/```[\s\S]*?```/g, " ");
+  const blocks = withoutCodeBlocks.split(/\r?\n\s*\r?\n/).map((block) => block.trim()).filter(Boolean);
+  const messages = [];
+  for (const block of blocks) {
+    const lines = block.split(/\r?\n/).map((line) => normalizeMarkdownLine(line)).filter(Boolean);
+    if (lines.length === 0) {
+      continue;
+    }
+    const joined = stripMarkdownSyntax(lines.join(" "));
+    if (!joined) continue;
+    const roleMatch = /^(user|assistant|system|tool)\s*:?\s*(.+)$/i.exec(joined);
+    if (roleMatch) {
+      const role = normalizeRole(roleMatch[1]);
+      const content = normalizeText(roleMatch[2]);
+      if (content) {
+        messages.push(`${role}: ${content}`);
+      }
+      continue;
+    }
+    messages.push(joined);
+  }
+  return messages;
+}
+function parsePlainText(raw) {
+  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
+}
+function detectSessionFormat(raw, filePath) {
+  const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (nonEmptyLines.length === 0) {
+    return "plain";
+  }
+  const sample = nonEmptyLines.slice(0, JSONL_SAMPLE_LIMIT);
+  const jsonHits = sample.filter((line) => {
+    try {
+      const parsed = JSON.parse(line);
+      return isLikelyJsonMessage(parsed);
+    } catch {
+      return false;
+    }
+  }).length;
+  if (jsonHits >= Math.max(1, Math.ceil(sample.length * 0.6))) {
+    return "jsonl";
+  }
+  const ext = path8.extname(filePath).toLowerCase();
+  if (ext === ".md" || ext === ".markdown") {
+    return "markdown";
+  }
+  const markdownSignals = sample.filter((line) => MARKDOWN_SIGNAL_RE.test(line) || MARKDOWN_INLINE_RE.test(line)).length;
+  if (markdownSignals >= Math.max(2, Math.ceil(sample.length * 0.4))) {
+    return "markdown";
+  }
+  return "plain";
+}
+function parseSessionFile(filePath) {
+  const resolved = path8.resolve(filePath);
+  const raw = fs8.readFileSync(resolved, "utf-8");
+  const format = detectSessionFormat(raw, resolved);
+  if (format === "jsonl") {
+    const parsed = parseJsonLines(raw);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
+  if (format === "markdown") {
+    const parsed = parseMarkdown(raw);
+    if (parsed.length > 0) {
+      return parsed;
+    }
+  }
+  return parsePlainText(raw);
+}
+
+// src/observer/watcher.ts
+var fs9 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+var import_chokidar = __toESM(require("chokidar"), 1);
+var DEFAULT_FLUSH_THRESHOLD_CHARS = 500;
+var SessionWatcher = class {
+  watchPath;
+  observer;
+  ignoreInitial;
+  debounceMs;
+  flushThresholdChars;
+  watcher = null;
+  fileOffsets = /* @__PURE__ */ new Map();
+  pendingPaths = /* @__PURE__ */ new Set();
+  debounceTimer = null;
+  processingQueue = Promise.resolve();
+  bufferedChars = 0;
+  constructor(watchPath, observer, options = {}) {
+    this.watchPath = path9.resolve(watchPath);
+    this.observer = observer;
+    this.ignoreInitial = options.ignoreInitial ?? false;
+    this.debounceMs = options.debounceMs ?? 500;
+    this.flushThresholdChars = Math.max(1, options.flushThresholdChars ?? DEFAULT_FLUSH_THRESHOLD_CHARS);
+  }
+  async start() {
+    if (!fs9.existsSync(this.watchPath)) {
+      throw new Error(`Watch path does not exist: ${this.watchPath}`);
+    }
+    this.watcher = import_chokidar.default.watch(this.watchPath, {
+      persistent: true,
+      ignoreInitial: this.ignoreInitial,
+      awaitWriteFinish: {
+        stabilityThreshold: 120,
+        pollInterval: 30
+      }
+    });
+    const enqueue = (changedPath) => {
+      this.pendingPaths.add(path9.resolve(changedPath));
+      this.scheduleDrain();
+    };
+    this.watcher.on("add", enqueue);
+    this.watcher.on("change", enqueue);
+    this.watcher.on("unlink", (deletedPath) => {
+      const resolved = path9.resolve(deletedPath);
+      this.fileOffsets.delete(resolved);
+      this.pendingPaths.delete(resolved);
+    });
+    await new Promise((resolve14, reject) => {
+      this.watcher?.once("ready", () => resolve14());
+      this.watcher?.once("error", (error) => reject(error));
+    });
+    if (this.ignoreInitial) {
+      this.primeInitialOffsets();
+    }
+  }
+  async stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+      this.drainPendingPaths();
+    }
+    await this.processingQueue.catch(() => void 0);
+    if (this.bufferedChars > 0) {
+      await this.observer.flush();
+      this.bufferedChars = 0;
+    }
+    this.pendingPaths.clear();
+    await this.watcher?.close();
+    this.watcher = null;
+  }
+  scheduleDrain() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null;
+      this.drainPendingPaths();
+    }, this.debounceMs);
+  }
+  drainPendingPaths() {
+    const nextPaths = [...this.pendingPaths];
+    this.pendingPaths.clear();
+    for (const changedPath of nextPaths) {
+      this.processingQueue = this.processingQueue.then(() => this.consumeFile(changedPath)).catch(() => void 0);
+    }
+  }
+  async consumeFile(filePath) {
+    const resolved = path9.resolve(filePath);
+    if (!fs9.existsSync(resolved)) {
+      return;
+    }
+    const stats = fs9.statSync(resolved);
+    if (!stats.isFile()) {
+      return;
+    }
+    const previousOffset = this.fileOffsets.get(resolved) ?? 0;
+    const startOffset = stats.size < previousOffset ? 0 : previousOffset;
+    if (stats.size <= startOffset) {
+      this.fileOffsets.set(resolved, stats.size);
+      return;
+    }
+    const bytesToRead = stats.size - startOffset;
+    const buffer = Buffer.alloc(bytesToRead);
+    const fd = fs9.openSync(resolved, "r");
+    try {
+      fs9.readSync(fd, buffer, 0, bytesToRead, startOffset);
+    } finally {
+      fs9.closeSync(fd);
+    }
+    this.fileOffsets.set(resolved, stats.size);
+    const chunk = buffer.toString("utf-8");
+    const messages = chunk.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (messages.length === 0) {
+      return;
+    }
+    await this.observer.processMessages(messages);
+    this.bufferedChars += chunk.length;
+    if (this.bufferedChars >= this.flushThresholdChars) {
+      await this.observer.flush();
+      this.bufferedChars = 0;
+    }
+  }
+  primeInitialOffsets() {
+    for (const filePath of this.collectFiles(this.watchPath)) {
+      try {
+        const stats = fs9.statSync(filePath);
+        if (stats.isFile()) {
+          this.fileOffsets.set(filePath, stats.size);
+        }
+      } catch {
+      }
+    }
+  }
+  collectFiles(targetPath) {
+    if (!fs9.existsSync(targetPath)) {
+      return [];
+    }
+    const resolved = path9.resolve(targetPath);
+    const stats = fs9.statSync(resolved);
+    if (stats.isFile()) {
+      return [resolved];
+    }
+    if (!stats.isDirectory()) {
+      return [];
+    }
+    const collected = [];
+    for (const entry of fs9.readdirSync(resolved, { withFileTypes: true })) {
+      const childPath = path9.join(resolved, entry.name);
+      if (entry.isDirectory()) {
+        collected.push(...this.collectFiles(childPath));
+      } else if (entry.isFile()) {
+        collected.push(path9.resolve(childPath));
+      }
+    }
+    return collected;
+  }
+};
+
+// src/observer/active-session-observer.ts
+var fs10 = __toESM(require("fs"), 1);
+var path11 = __toESM(require("path"), 1);
+
+// src/lib/session-utils.ts
+var path10 = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function validateEnvPath(envValue) {
+  if (!envValue) return null;
+  const trimmed = envValue.trim();
+  if (!trimmed) return null;
+  const resolved = path10.resolve(trimmed);
+  if (!path10.isAbsolute(resolved)) return null;
+  return resolved;
+}
+function getOpenClawDir() {
+  const customHome = validateEnvPath(process.env.OPENCLAW_HOME);
+  if (customHome) {
+    return customHome;
+  }
+  return path10.join(os.homedir(), ".openclaw");
+}
+function getOpenClawAgentsDir() {
+  const stateDir = validateEnvPath(process.env.OPENCLAW_STATE_DIR);
+  if (stateDir) {
+    return path10.join(stateDir, "agents");
+  }
+  return path10.join(getOpenClawDir(), "agents");
+}
+function getSessionsDir(agentId) {
+  return path10.join(getOpenClawAgentsDir(), agentId, "sessions");
+}
+
+// src/observer/active-session-observer.ts
+var ONE_KIB = 1024;
+var ONE_MIB = ONE_KIB * ONE_KIB;
+var SMALL_SESSION_THRESHOLD_BYTES = 50 * ONE_KIB;
+var MEDIUM_SESSION_THRESHOLD_BYTES = 150 * ONE_KIB;
+var LARGE_SESSION_THRESHOLD_BYTES = 300 * ONE_KIB;
+var DEFAULT_AGENT_ID = "main";
+var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,100}$/;
+var SESSION_ID_RE = /^[a-zA-Z0-9._-]{1,200}$/;
+var CURSOR_FILE_NAME = "observe-cursors.json";
+var STALE_CURSOR_THRESHOLD_MS = 12 * 60 * 60 * 1e3;
+function formatBytes(bytes) {
+  if (bytes >= ONE_MIB) return `${(bytes / ONE_MIB).toFixed(1)}MB`;
+  if (bytes >= ONE_KIB) return `${Math.round(bytes / ONE_KIB)}KB`;
+  return `${bytes}B`;
+}
+function isFiniteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function normalizeAgentId(input) {
+  const raw = (input ?? process.env.OPENCLAW_AGENT_ID ?? DEFAULT_AGENT_ID).trim();
+  if (!AGENT_ID_RE.test(raw)) {
+    return DEFAULT_AGENT_ID;
+  }
+  return raw;
+}
+function resolveSessionsDirectory(agentId, override) {
+  if (override?.trim()) {
+    return path11.resolve(override.trim());
+  }
+  return getSessionsDir(agentId);
+}
+function getCursorPath(vaultPath) {
+  return path11.join(vaultPath, ".clawvault", CURSOR_FILE_NAME);
+}
+function getScaledObservationThresholdBytes(fileSizeBytes) {
+  if (fileSizeBytes < ONE_MIB) {
+    return SMALL_SESSION_THRESHOLD_BYTES;
+  }
+  if (fileSizeBytes <= 5 * ONE_MIB) {
+    return MEDIUM_SESSION_THRESHOLD_BYTES;
+  }
+  return LARGE_SESSION_THRESHOLD_BYTES;
+}
+function parseCursorStore(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return {};
+  }
+  const input = raw;
+  const store = {};
+  for (const [sessionId, value] of Object.entries(input)) {
+    if (!SESSION_ID_RE.test(sessionId)) continue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const entry = value;
+    if (!isFiniteNonNegative(entry.lastObservedOffset)) continue;
+    if (!isFiniteNonNegative(entry.lastFileSize)) continue;
+    if (typeof entry.lastObservedAt !== "string" || !entry.lastObservedAt.trim()) continue;
+    if (typeof entry.sessionKey !== "string" || !entry.sessionKey.trim()) continue;
+    store[sessionId] = {
+      lastObservedOffset: entry.lastObservedOffset,
+      lastObservedAt: entry.lastObservedAt,
+      sessionKey: entry.sessionKey,
+      lastFileSize: entry.lastFileSize
+    };
+  }
+  return store;
+}
+function loadObserveCursorStore(vaultPath) {
+  const cursorPath = getCursorPath(vaultPath);
+  if (!fs10.existsSync(cursorPath)) {
+    return {};
+  }
+  try {
+    const raw = JSON.parse(fs10.readFileSync(cursorPath, "utf-8"));
+    return parseCursorStore(raw);
+  } catch {
+    return {};
+  }
+}
+function saveObserveCursorStore(vaultPath, store) {
+  const cursorPath = getCursorPath(vaultPath);
+  fs10.mkdirSync(path11.dirname(cursorPath), { recursive: true });
+  fs10.writeFileSync(cursorPath, `${JSON.stringify(store, null, 2)}
+`, "utf-8");
+}
+function loadSessionIndex(sessionsDir) {
+  const indexPath = path11.join(sessionsDir, "sessions.json");
+  if (!fs10.existsSync(indexPath)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(fs10.readFileSync(indexPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function findMostRecentResetFile(sessionsDir, sessionId) {
+  const prefix = `${sessionId}.jsonl.reset.`;
+  try {
+    const files = fs10.readdirSync(sessionsDir).filter((f) => f.startsWith(prefix)).sort().reverse();
+    return files.length > 0 ? path11.join(sessionsDir, files[0]) : null;
+  } catch {
+    return null;
+  }
+}
+function resolveTranscriptPath(sessionsDir, sessionId) {
+  const mainPath = path11.join(sessionsDir, `${sessionId}.jsonl`);
+  try {
+    const stat = fs10.statSync(mainPath);
+    if (stat.size < 100) {
+      const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
+      if (resetFile) {
+        return resetFile;
+      }
+    }
+  } catch {
+    const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
+    if (resetFile) {
+      return resetFile;
+    }
+  }
+  return mainPath;
+}
+function discoverSessionDescriptors(sessionsDir, fallbackAgentId) {
+  const descriptors = [];
+  const seen = /* @__PURE__ */ new Set();
+  const index = loadSessionIndex(sessionsDir);
+  const indexedEntries = Object.entries(index).sort((left, right) => {
+    const leftUpdated = Number(left[1]?.updatedAt ?? 0);
+    const rightUpdated = Number(right[1]?.updatedAt ?? 0);
+    return rightUpdated - leftUpdated;
+  });
+  for (const [sessionKey, entry] of indexedEntries) {
+    if (!entry || typeof entry !== "object") continue;
+    const sessionId = typeof entry.sessionId === "string" ? entry.sessionId.trim() : "";
+    if (!SESSION_ID_RE.test(sessionId) || seen.has(sessionId)) continue;
+    const filePath = resolveTranscriptPath(sessionsDir, sessionId);
+    try {
+      const stat = fs10.statSync(filePath);
+      if (!stat.isFile()) continue;
+      seen.add(sessionId);
+      descriptors.push({ sessionId, sessionKey, filePath });
+    } catch {
+      continue;
+    }
+  }
+  const fallbackPrefix = `agent:${fallbackAgentId}:`;
+  for (const fileName of fs10.readdirSync(sessionsDir)) {
+    if (!fileName.endsWith(".jsonl") || fileName.includes(".backup") || fileName.includes(".deleted")) {
+      continue;
+    }
+    const sessionId = fileName.slice(0, -".jsonl".length);
+    if (!SESSION_ID_RE.test(sessionId) || seen.has(sessionId)) continue;
+    const filePath = path11.join(sessionsDir, fileName);
+    try {
+      const stat = fs10.statSync(filePath);
+      if (!stat.isFile()) continue;
+      seen.add(sessionId);
+      descriptors.push({
+        sessionId,
+        sessionKey: `${fallbackPrefix}unknown:${sessionId}`,
+        filePath
+      });
+    } catch {
+      continue;
+    }
+  }
+  return descriptors;
+}
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function extractContentText(value) {
+  if (typeof value === "string") {
+    return normalizeWhitespace(value);
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => extractContentText(item)).filter(Boolean);
+    return normalizeWhitespace(parts.join(" "));
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const input = value;
+  if (typeof input.text === "string") {
+    return normalizeWhitespace(input.text);
+  }
+  if (typeof input.content === "string") {
+    return normalizeWhitespace(input.content);
+  }
+  return "";
+}
+function normalizeRole2(role) {
+  if (typeof role !== "string") {
+    return "";
+  }
+  return role.trim().toLowerCase();
+}
+function summarizeContentArray(content) {
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      const text = normalizeWhitespace(b.text);
+      if (text) parts.push(text);
+    } else if (b.type === "toolCall") {
+      const toolName = typeof b.name === "string" ? b.name : "tool";
+      parts.push(`[tool: ${toolName}]`);
+    }
+  }
+  return parts.join(" ");
+}
+function parseOpenClawJsonLine(line) {
+  if (!line.trim()) {
+    return "";
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return "";
+  }
+  const entry = parsed;
+  if ("role" in entry && "content" in entry) {
+    const role = normalizeRole2(entry.role);
+    if (role === "system") return "";
+    if (role === "toolresult") {
+      const output = extractContentText(entry.content);
+      const preview = output.slice(0, 80) || "ok";
+      return `[tool_result \u2192 ${preview}]`;
+    }
+    const raw = entry.content;
+    let content;
+    if (Array.isArray(raw)) {
+      content = summarizeContentArray(raw);
+    } else {
+      content = extractContentText(raw);
+    }
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+    const message = entry.message;
+    const role = normalizeRole2(message.role);
+    if (role === "system") return "";
+    if (role === "toolresult") {
+      const output = extractContentText(message.content);
+      const preview = output.slice(0, 80) || "ok";
+      return `[tool_result \u2192 ${preview}]`;
+    }
+    const raw = message.content;
+    let content;
+    if (Array.isArray(raw)) {
+      content = summarizeContentArray(raw);
+    } else {
+      content = extractContentText(raw);
+    }
+    if (!content) return "";
+    return role ? `${role}: ${content}` : content;
+  }
+  return "";
+}
+function decodeLineBuffer(lineBuffer) {
+  if (lineBuffer.length === 0) {
+    return "";
+  }
+  const normalized = lineBuffer[lineBuffer.length - 1] === 13 ? lineBuffer.subarray(0, lineBuffer.length - 1) : lineBuffer;
+  return normalized.toString("utf-8").trim();
+}
+async function readIncrementalMessages(filePath, startOffset) {
+  const messages = [];
+  let nextOffset = startOffset;
+  let remainder = Buffer.alloc(0);
+  const stream = fs10.createReadStream(filePath, {
+    start: startOffset
+  });
+  for await (const chunk of stream) {
+    const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const combined = remainder.length > 0 ? Buffer.concat([remainder, chunkBuffer]) : chunkBuffer;
+    let lineStart = 0;
+    for (let index = 0; index < combined.length; index += 1) {
+      if (combined[index] !== 10) continue;
+      const lineBuffer = combined.subarray(lineStart, index);
+      const line = decodeLineBuffer(lineBuffer);
+      const parsed = parseOpenClawJsonLine(line);
+      if (parsed) {
+        messages.push(parsed);
+      }
+      nextOffset += index - lineStart + 1;
+      lineStart = index + 1;
+    }
+    remainder = combined.subarray(lineStart);
+  }
+  if (remainder.length > 0) {
+    const trailing = decodeLineBuffer(remainder);
+    if (trailing) {
+      const parsed = parseOpenClawJsonLine(trailing);
+      if (parsed) {
+        messages.push(parsed);
+        nextOffset += remainder.length;
+      }
+    }
+  }
+  return { messages, nextOffset };
+}
+function parseSessionSourceLabel(sessionKey) {
+  const parts = sessionKey.split(":");
+  if (parts.length < 3 || parts[0] !== "agent") {
+    return "session";
+  }
+  const scope = parts.slice(2);
+  if (scope[0] === "main") {
+    return "main";
+  }
+  if (scope[0] === "telegram" && scope[1] === "dm") {
+    return "telegram-dm";
+  }
+  if (scope[0] === "telegram" && scope[1] === "group") {
+    return "telegram-group";
+  }
+  if (scope[0] === "discord") {
+    return "discord";
+  }
+  if (scope[0] === "telegram") {
+    return "telegram";
+  }
+  if (scope[0] === "slack") {
+    return "slack";
+  }
+  return scope[0] || "session";
+}
+function createDefaultObserver(vaultPath, options) {
+  return new Observer(vaultPath, options);
+}
+function parseRoutingCounts(routingSummary) {
+  const counts = {};
+  const [, categorySection = ""] = routingSummary.split("\u2192");
+  const summaryCategories = categorySection.split("(")[0] ?? "";
+  if (!summaryCategories) {
+    return counts;
+  }
+  for (const match of summaryCategories.matchAll(/\b([a-z][a-z0-9-]*):\s*(\d+)\b/gi)) {
+    const category = match[1].toLowerCase();
+    const count = Number.parseInt(match[2], 10);
+    if (!Number.isFinite(count) || count <= 0) {
+      continue;
+    }
+    counts[category] = (counts[category] ?? 0) + count;
+  }
+  return counts;
+}
+function mergeRoutingCounts(target, incoming) {
+  for (const [category, count] of Object.entries(incoming)) {
+    target[category] = (target[category] ?? 0) + count;
+  }
+}
+function stringifyError(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+function selectCandidates(descriptors, cursors, minNewBytes) {
+  const candidates = [];
+  for (const descriptor of descriptors) {
+    let stat;
+    try {
+      stat = fs10.statSync(descriptor.filePath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    const fileSize = stat.size;
+    const cursor = cursors[descriptor.sessionId];
+    const previousOffset = cursor && isFiniteNonNegative(cursor.lastObservedOffset) ? cursor.lastObservedOffset : 0;
+    const startOffset = previousOffset <= fileSize ? previousOffset : 0;
+    const newBytes = Math.max(0, fileSize - startOffset);
+    const thresholdBytes = minNewBytes ?? getScaledObservationThresholdBytes(fileSize);
+    if (newBytes < thresholdBytes) {
+      continue;
+    }
+    candidates.push({
+      sessionId: descriptor.sessionId,
+      sessionKey: descriptor.sessionKey,
+      sourceLabel: parseSessionSourceLabel(descriptor.sessionKey),
+      filePath: descriptor.filePath,
+      fileSize,
+      startOffset,
+      newBytes,
+      thresholdBytes
+    });
+  }
+  return candidates;
+}
+async function observeActiveSessions(options, dependencies = {}) {
+  const vaultPath = path11.resolve(options.vaultPath);
+  const agentId = normalizeAgentId(options.agentId);
+  const sessionsDir = resolveSessionsDirectory(agentId, options.sessionsDir);
+  const dryRun = Boolean(options.dryRun);
+  if (!fs10.existsSync(sessionsDir) || !fs10.statSync(sessionsDir).isDirectory()) {
+    return {
+      agentId,
+      sessionsDir,
+      checkedSessions: 0,
+      candidateSessions: 0,
+      observedSessions: 0,
+      cursorUpdates: 0,
+      dryRun,
+      totalNewBytes: 0,
+      observedNewBytes: 0,
+      routedCounts: {},
+      failedSessionCount: 0,
+      failedSessions: [],
+      candidates: []
+    };
+  }
+  const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+  const cursors = loadObserveCursorStore(vaultPath);
+  const descriptors = discoverSessionDescriptors(sessionsDir, agentId);
+  const allCandidates = selectCandidates(descriptors, cursors, options.minNewBytes);
+  allCandidates.sort((a, b) => b.newBytes - a.newBytes);
+  const candidates = options.maxSessions != null && options.maxSessions > 0 ? allCandidates.slice(0, options.maxSessions) : allCandidates;
+  if (dryRun || candidates.length === 0) {
+    return {
+      agentId,
+      sessionsDir,
+      checkedSessions: descriptors.length,
+      candidateSessions: candidates.length,
+      observedSessions: 0,
+      cursorUpdates: 0,
+      dryRun,
+      totalNewBytes: candidates.reduce((sum, candidate) => sum + candidate.newBytes, 0),
+      observedNewBytes: 0,
+      routedCounts: {},
+      failedSessionCount: 0,
+      failedSessions: [],
+      candidates
+    };
+  }
+  const observerFactory = dependencies.createObserver ?? createDefaultObserver;
+  const observerOptions = {
+    tokenThreshold: options.threshold,
+    reflectThreshold: options.reflectThreshold,
+    model: options.model,
+    extractTasks: options.extractTasks
+  };
+  let observedSessions = 0;
+  let cursorUpdates = 0;
+  let observedNewBytes = 0;
+  const routedCounts = {};
+  const failedSessions = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const candidate = candidates[i];
+    console.log(`[observer] processing session ${i + 1}/${candidates.length}: ${candidate.sessionKey} (${formatBytes(candidate.newBytes)} new)`);
+    try {
+      const observer = observerFactory(vaultPath, observerOptions);
+      const { messages, nextOffset } = await readIncrementalMessages(candidate.filePath, candidate.startOffset);
+      const taggedMessages = messages.map((message) => `[${candidate.sourceLabel}] ${message}`);
+      if (taggedMessages.length > 0) {
+        await observer.processMessages(taggedMessages, {
+          source: "openclaw",
+          sessionKey: candidate.sessionKey,
+          transcriptId: candidate.sessionId
+        });
+        const flushResult = await observer.flush();
+        mergeRoutingCounts(routedCounts, parseRoutingCounts(flushResult.routingSummary));
+        observedSessions += 1;
+        observedNewBytes += candidate.newBytes;
+      }
+      if (nextOffset > candidate.startOffset) {
+        cursors[candidate.sessionId] = {
+          lastObservedOffset: nextOffset,
+          lastObservedAt: now().toISOString(),
+          sessionKey: candidate.sessionKey,
+          lastFileSize: candidate.fileSize
+        };
+        cursorUpdates += 1;
+      }
+    } catch (error) {
+      const reason = stringifyError(error);
+      failedSessions.push({
+        sessionId: candidate.sessionId,
+        sessionKey: candidate.sessionKey,
+        sourceLabel: candidate.sourceLabel,
+        error: reason
+      });
+      console.error(
+        `[observer] failed to observe session ${candidate.sessionKey} (${candidate.sessionId}): ${reason}`
+      );
+    }
+  }
+  if (cursorUpdates > 0) {
+    saveObserveCursorStore(vaultPath, cursors);
+  }
+  return {
+    agentId,
+    sessionsDir,
+    checkedSessions: descriptors.length,
+    candidateSessions: candidates.length,
+    observedSessions,
+    cursorUpdates,
+    dryRun,
+    totalNewBytes: candidates.reduce((sum, candidate) => sum + candidate.newBytes, 0),
+    observedNewBytes,
+    routedCounts,
+    failedSessionCount: failedSessions.length,
+    failedSessions,
+    candidates
+  };
+}
+
+// src/lib/config.ts
+var fs11 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
+function findNearestVaultPath(startPath = process.cwd()) {
+  let current = path12.resolve(startPath);
+  while (true) {
+    if (fs11.existsSync(path12.join(current, ".clawvault.json"))) {
+      return current;
+    }
+    const parent = path12.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveVaultPath(options = {}) {
+  if (options.explicitPath) {
+    return path12.resolve(options.explicitPath);
+  }
+  if (process.env.CLAWVAULT_PATH) {
+    return path12.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/commands/observe.ts
+var ONE_KIB2 = 1024;
+var ONE_MIB2 = ONE_KIB2 * ONE_KIB2;
+function parsePositiveInteger(raw, optionName) {
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${optionName}: ${raw}`);
+  }
+  return parsed;
+}
+function buildDaemonArgs(options) {
+  const cliPath = process.argv[1];
+  if (!cliPath) {
+    throw new Error("Unable to resolve CLI script path for daemon mode.");
+  }
+  const args = [cliPath, "observe"];
+  if (options.watch) {
+    args.push("--watch", options.watch);
+  }
+  if (options.threshold) {
+    args.push("--threshold", String(options.threshold));
+  }
+  if (options.reflectThreshold) {
+    args.push("--reflect-threshold", String(options.reflectThreshold));
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.extractTasks === false) {
+    args.push("--no-extract-tasks");
+  }
+  if (options.vaultPath) {
+    args.push("--vault", options.vaultPath);
+  }
+  return args;
+}
+function formatByteSummary(bytes) {
+  const normalized = Number.isFinite(bytes) ? Math.max(0, bytes) : 0;
+  if (normalized === 0) {
+    return "0KB";
+  }
+  if (normalized >= ONE_MIB2) {
+    return `${(normalized / ONE_MIB2).toFixed(1)}MB`;
+  }
+  return `${Math.max(1, Math.round(normalized / ONE_KIB2))}KB`;
+}
+function formatCronSummary(result) {
+  const decisionCount = result.routedCounts.decisions ?? 0;
+  return `observed ${result.observedSessions} sessions, ${formatByteSummary(result.observedNewBytes)} new content, ${decisionCount} decision${decisionCount === 1 ? "" : "s"} extracted`;
+}
+async function runOneShotCompression(observer, sourceFile, vaultPath) {
+  const resolved = path13.resolve(sourceFile);
+  if (!fs12.existsSync(resolved) || !fs12.statSync(resolved).isFile()) {
+    throw new Error(`Conversation file not found: ${resolved}`);
+  }
+  const messages = parseSessionFile(resolved);
+  const transcriptStat = fs12.statSync(resolved);
+  await observer.processMessages(messages, {
+    source: "openclaw",
+    transcriptId: path13.basename(resolved),
+    timestamp: transcriptStat.mtime
+  });
+  const { observations, routingSummary } = await observer.flush();
+  const outputPath = getObservationPath(vaultPath, /* @__PURE__ */ new Date());
+  console.log(`Observations updated: ${outputPath}`);
+  if (routingSummary) {
+    console.log(routingSummary);
+  }
+}
+async function watchSessions(observer, watchPath) {
+  const watcher = new SessionWatcher(watchPath, observer);
+  await watcher.start();
+  console.log(`Watching session updates: ${watchPath}`);
+  await new Promise((resolve14) => {
+    const shutdown = async () => {
+      process.off("SIGINT", onSigInt);
+      process.off("SIGTERM", onSigTerm);
+      await watcher.stop();
+      resolve14();
+    };
+    const onSigInt = () => {
+      void shutdown();
+    };
+    const onSigTerm = () => {
+      void shutdown();
+    };
+    process.once("SIGINT", onSigInt);
+    process.once("SIGTERM", onSigTerm);
+  });
+}
+async function observeCommand(options) {
+  if (options.cron && (options.active || options.watch || options.compress || options.daemon)) {
+    throw new Error("--cron cannot be combined with --active, --watch, --compress, or --daemon.");
+  }
+  if (options.cron && options.dryRun) {
+    throw new Error("--cron cannot be combined with --dry-run.");
+  }
+  if (options.active && (options.watch || options.compress || options.daemon)) {
+    throw new Error("--active cannot be combined with --watch, --compress, or --daemon.");
+  }
+  if (options.compress && options.daemon) {
+    throw new Error("--compress cannot be combined with --daemon.");
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  if (options.active || options.cron) {
+    const result = await observeActiveSessions({
+      vaultPath,
+      agentId: options.agent,
+      minNewBytes: options.minNew,
+      sessionsDir: options.sessionsDir,
+      dryRun: options.dryRun,
+      threshold: options.threshold,
+      reflectThreshold: options.reflectThreshold,
+      model: options.model,
+      extractTasks: options.extractTasks,
+      maxSessions: options.maxSessions
+    });
+    const failedSessionCount = result.failedSessionCount ?? 0;
+    if (options.cron) {
+      if (failedSessionCount > 0) {
+        const firstFailure = result.failedSessions[0];
+        if (firstFailure) {
+          throw new Error(
+            `observer failed for ${failedSessionCount} session(s); first error: ${firstFailure.sessionKey} - ${firstFailure.error}`
+          );
+        }
+        throw new Error(`observer failed for ${failedSessionCount} session(s).`);
+      }
+      if (result.candidateSessions === 0) {
+        console.log("nothing new");
+        return;
+      }
+      console.log(formatCronSummary({
+        observedSessions: result.observedSessions,
+        observedNewBytes: result.observedNewBytes ?? result.totalNewBytes,
+        routedCounts: result.routedCounts ?? {}
+      }));
+      return;
+    }
+    if (result.candidateSessions === 0) {
+      console.log(`No active sessions crossed threshold (${result.checkedSessions} checked).`);
+      return;
+    }
+    if (result.dryRun) {
+      console.log(
+        `Dry run: ${result.candidateSessions} session(s) would be observed (${result.totalNewBytes} new bytes).`
+      );
+      for (const candidate of result.candidates) {
+        console.log(
+          `- ${candidate.sessionKey} [${candidate.sourceLabel}] \u0394${candidate.newBytes}B (threshold ${candidate.thresholdBytes}B)`
+        );
+      }
+      return;
+    }
+    console.log(
+      `Active observation complete: ${result.observedSessions}/${result.candidateSessions} session(s) observed.${failedSessionCount > 0 ? ` ${failedSessionCount} failed.` : ""}`
+    );
+    if (failedSessionCount > 0) {
+      for (const failure of result.failedSessions) {
+        console.error(
+          `[observer] session failed ${failure.sessionKey} (${failure.sessionId}): ${failure.error}`
+        );
+      }
+    }
+    return;
+  }
+  const observer = new Observer(vaultPath, {
+    tokenThreshold: options.threshold,
+    reflectThreshold: options.reflectThreshold,
+    model: options.model,
+    extractTasks: options.extractTasks
+  });
+  if (options.compress) {
+    await runOneShotCompression(observer, options.compress, vaultPath);
+    return;
+  }
+  let watchPath = options.watch ? path13.resolve(options.watch) : "";
+  if (!watchPath && options.daemon) {
+    watchPath = path13.join(vaultPath, "sessions");
+  }
+  if (!watchPath) {
+    throw new Error("Either --watch or --compress must be provided.");
+  }
+  if (!fs12.existsSync(watchPath)) {
+    if (options.daemon && !options.watch) {
+      fs12.mkdirSync(watchPath, { recursive: true });
+    } else {
+      throw new Error(`Watch path does not exist: ${watchPath}`);
+    }
+  }
+  if (options.daemon) {
+    const daemonArgs = buildDaemonArgs({ ...options, watch: watchPath, vaultPath });
+    const child = (0, import_child_process2.spawn)(process.execPath, daemonArgs, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    console.log(`Observer daemon started (pid: ${child.pid})`);
+    return;
+  }
+  await watchSessions(observer, watchPath);
+}
+function registerObserveCommand(program) {
+  program.command("observe").description("Observe session files and build observational memory").option("--watch <path>", "Watch session file or directory").option("--active", "Observe active OpenClaw sessions incrementally").option("--cron", "Run one-shot active observation for cron hooks").option("--agent <id>", "OpenClaw agent ID (default: OPENCLAW_AGENT_ID or clawdious)").option("--min-new <bytes>", "Override minimum new-content threshold in bytes").option("--sessions-dir <path>", "Override OpenClaw sessions directory").option("--dry-run", "Show active observation candidates without compressing").option("--max-sessions <n>", "Limit number of sessions to observe (recommended: 10)").option("--threshold <n>", "Compression token threshold", "30000").option("--reflect-threshold <n>", "Reflection token threshold", "40000").option("--model <model>", "LLM model override").option("--extract-tasks", "Extract task-like observations into backlog", true).option("--no-extract-tasks", "Disable task extraction from observations").option("--compress <file>", "One-shot compression for a conversation file").option("--daemon", "Run in detached background mode").option("-v, --vault <path>", "Vault path").action(async (rawOptions) => {
+    await observeCommand({
+      watch: rawOptions.watch,
+      active: rawOptions.active,
+      cron: rawOptions.cron,
+      agent: rawOptions.agent,
+      minNew: rawOptions.minNew ? parsePositiveInteger(rawOptions.minNew, "min-new") : void 0,
+      sessionsDir: rawOptions.sessionsDir,
+      dryRun: rawOptions.dryRun,
+      maxSessions: rawOptions.maxSessions ? parsePositiveInteger(rawOptions.maxSessions, "max-sessions") : void 0,
+      threshold: parsePositiveInteger(rawOptions.threshold, "threshold"),
+      reflectThreshold: parsePositiveInteger(rawOptions.reflectThreshold, "reflect-threshold"),
+      model: rawOptions.model,
+      extractTasks: rawOptions.extractTasks,
+      compress: rawOptions.compress,
+      daemon: rawOptions.daemon,
+      vaultPath: rawOptions.vault
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  observeCommand,
+  registerObserveCommand
+});