clawvault 2.5.1 → 2.5.3

package/dist/chunk-OSMS7QIG.js

@@ -0,0 +1,406 @@
+import {
+  parseSessionFile
+} from "./chunk-P5EPF6MB.js";
+import {
+  observeActiveSessions
+} from "./chunk-IZEY5S74.js";
+import {
+  Observer
+} from "./chunk-S2IG7VNM.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+import {
+  getObservationPath
+} from "./chunk-Z2XBWN7A.js";
+
+// src/commands/observe.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { spawn } from "child_process";
+
+// src/observer/watcher.ts
+import * as fs from "fs";
+import * as path from "path";
+import chokidar from "chokidar";
+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 = path.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 (!fs.existsSync(this.watchPath)) {
+      throw new Error(`Watch path does not exist: ${this.watchPath}`);
+    }
+    this.watcher = chokidar.watch(this.watchPath, {
+      persistent: true,
+      ignoreInitial: this.ignoreInitial,
+      awaitWriteFinish: {
+        stabilityThreshold: 120,
+        pollInterval: 30
+      }
+    });
+    const enqueue = (changedPath) => {
+      this.pendingPaths.add(path.resolve(changedPath));
+      this.scheduleDrain();
+    };
+    this.watcher.on("add", enqueue);
+    this.watcher.on("change", enqueue);
+    this.watcher.on("unlink", (deletedPath) => {
+      const resolved = path.resolve(deletedPath);
+      this.fileOffsets.delete(resolved);
+      this.pendingPaths.delete(resolved);
+    });
+    await new Promise((resolve3, reject) => {
+      this.watcher?.once("ready", () => resolve3());
+      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 = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+      return;
+    }
+    const stats = fs.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 = fs.openSync(resolved, "r");
+    try {
+      fs.readSync(fd, buffer, 0, bytesToRead, startOffset);
+    } finally {
+      fs.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 = fs.statSync(filePath);
+        if (stats.isFile()) {
+          this.fileOffsets.set(filePath, stats.size);
+        }
+      } catch {
+      }
+    }
+  }
+  collectFiles(targetPath) {
+    if (!fs.existsSync(targetPath)) {
+      return [];
+    }
+    const resolved = path.resolve(targetPath);
+    const stats = fs.statSync(resolved);
+    if (stats.isFile()) {
+      return [resolved];
+    }
+    if (!stats.isDirectory()) {
+      return [];
+    }
+    const collected = [];
+    for (const entry of fs.readdirSync(resolved, { withFileTypes: true })) {
+      const childPath = path.join(resolved, entry.name);
+      if (entry.isDirectory()) {
+        collected.push(...this.collectFiles(childPath));
+      } else if (entry.isFile()) {
+        collected.push(path.resolve(childPath));
+      }
+    }
+    return collected;
+  }
+};
+
+// src/commands/observe.ts
+var ONE_KIB = 1024;
+var ONE_MIB = ONE_KIB * ONE_KIB;
+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_MIB) {
+    return `${(normalized / ONE_MIB).toFixed(1)}MB`;
+  }
+  return `${Math.max(1, Math.round(normalized / ONE_KIB))}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 = path2.resolve(sourceFile);
+  if (!fs2.existsSync(resolved) || !fs2.statSync(resolved).isFile()) {
+    throw new Error(`Conversation file not found: ${resolved}`);
+  }
+  const messages = parseSessionFile(resolved);
+  const transcriptStat = fs2.statSync(resolved);
+  await observer.processMessages(messages, {
+    source: "openclaw",
+    transcriptId: path2.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((resolve3) => {
+    const shutdown = async () => {
+      process.off("SIGINT", onSigInt);
+      process.off("SIGTERM", onSigTerm);
+      await watcher.stop();
+      resolve3();
+    };
+    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
+    });
+    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 ? path2.resolve(options.watch) : "";
+  if (!watchPath && options.daemon) {
+    watchPath = path2.join(vaultPath, "sessions");
+  }
+  if (!watchPath) {
+    throw new Error("Either --watch or --compress must be provided.");
+  }
+  if (!fs2.existsSync(watchPath)) {
+    if (options.daemon && !options.watch) {
+      fs2.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 = 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("--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,
+      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
+    });
+  });
+}
+
+export {
+  SessionWatcher,
+  observeCommand,
+  registerObserveCommand
+};

package/dist/{chunk-PAYUH64O.js → chunk-QVMXF7FY.js}

@@ -14,6 +14,16 @@ function readOptionalFile(filePath) {
     return null;
   }
 }
+function findPackageRoot() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return path.dirname(fileURLToPath(import.meta.url));
+}
 function resolveProjectFile(relativePath, baseDir) {
   if (baseDir) {
     return path.resolve(baseDir, relativePath);
@@ -22,7 +32,7 @@ function resolveProjectFile(relativePath, baseDir) {
   if (fs.existsSync(fromCwd)) {
     return fromCwd;
   }
-  return fileURLToPath(new URL(`../../${relativePath}`, import.meta.url));
+  return path.resolve(findPackageRoot(), relativePath);
 }
 function checkOpenClawCli() {
   const result = spawnSync("openclaw", ["--version"], { stdio: "ignore" });

package/dist/{chunk-TMZMN7OS.js → chunk-S2IG7VNM.js}

@@ -1,18 +1,6 @@
 import {
   listProjects
 } from "./chunk-5GZFTAL7.js";
-import {
-  listConfig,
-  listRouteRules,
-  matchRouteRule
-} from "./chunk-ITPEXLHA.js";
-import {
-  createBacklogItem,
-  listBacklogItems,
-  listTasks,
-  updateBacklogItem,
-  updateTask
-} from "./chunk-IOALNTAN.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -22,6 +10,11 @@ import {
   renderObservationMarkdown,
   renderScoredObservationLine
 } from "./chunk-FHFUXL6G.js";
+import {
+  listConfig,
+  listRouteRules,
+  matchRouteRule
+} from "./chunk-ITPEXLHA.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -30,6 +23,13 @@ import {
   getRawTranscriptPath,
   toDateKey
 } from "./chunk-Z2XBWN7A.js";
+import {
+  createBacklogItem,
+  listBacklogItems,
+  listTasks,
+  updateBacklogItem,
+  updateTask
+} from "./chunk-IOALNTAN.js";
 
 // src/observer/compressor.ts
 var OPENAI_BASE_URL = "https://api.openai.com/v1";
@@ -759,6 +759,8 @@ var TYPE_TO_CATEGORY = {
   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;
@@ -815,6 +817,10 @@ var Router = class {
     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 };
@@ -943,6 +949,12 @@ var Router = class {
     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) {

package/dist/{chunk-LMCC5OC7.js → chunk-TPDH3JPP.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-TMZMN7OS.js";
+} from "./chunk-S2IG7VNM.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+
+declare function registerCliCommands(program: Command): Command;
+
+export { registerCliCommands };

package/dist/cli/index.js

@@ -0,0 +1,31 @@
+import {
+  registerCliCommands
+} from "../chunk-FG6RJMCN.js";
+import "../chunk-NZ4ZZNSR.js";
+import "../chunk-4GBPTBFJ.js";
+import "../chunk-CLE2HHNT.js";
+import "../chunk-OSMS7QIG.js";
+import "../chunk-P5EPF6MB.js";
+import "../chunk-2YDBJS7M.js";
+import "../chunk-YOSEUUNB.js";
+import "../chunk-GFJ3LIIB.js";
+import "../chunk-IZEY5S74.js";
+import "../chunk-HRLWZGMA.js";
+import "../chunk-S2IG7VNM.js";
+import "../chunk-5GZFTAL7.js";
+import "../chunk-AY4PGUVL.js";
+import "../chunk-FHFUXL6G.js";
+import "../chunk-3FP5BJ42.js";
+import "../chunk-O7XHXF7F.js";
+import "../chunk-GSD4ALSI.js";
+import "../chunk-K3CDT7IH.js";
+import "../chunk-ITPEXLHA.js";
+import "../chunk-2CDEETQN.js";
+import "../chunk-MQUJNOHK.js";
+import "../chunk-MXSSG3QU.js";
+import "../chunk-ZZA73MFY.js";
+import "../chunk-Z2XBWN7A.js";
+import "../chunk-IOALNTAN.js";
+export {
+  registerCliCommands
+};

package/dist/commands/canvas.js

@@ -7,15 +7,15 @@ import {
   positionGroupsVertically,
   truncateText
 } from "../chunk-MDIH26GC.js";
-import {
-  listTasks
-} from "../chunk-IOALNTAN.js";
 import {
   loadMemoryGraphIndex
 } from "../chunk-ZZA73MFY.js";
 import {
   listObservationFiles
 } from "../chunk-Z2XBWN7A.js";
+import {
+  listTasks
+} from "../chunk-IOALNTAN.js";
 
 // src/commands/canvas.ts
 import * as fs2 from "fs";

package/dist/commands/compat.js

@@ -2,7 +2,7 @@ import {
   checkOpenClawCompatibility,
   compatCommand,
   compatibilityExitCode
-} from "../chunk-PAYUH64O.js";
+} from "../chunk-QVMXF7FY.js";
 export {
   checkOpenClawCompatibility,
   compatCommand,

package/dist/commands/context.js

@@ -3,11 +3,11 @@ import {
   contextCommand,
   formatContextMarkdown,
   registerContextCommand
-} from "../chunk-WIICLBNF.js";
-import "../chunk-7OHQFMJK.js";
-import "../chunk-6B3JWM7J.js";
-import "../chunk-2CDEETQN.js";
+} from "../chunk-GFJ3LIIB.js";
+import "../chunk-AY4PGUVL.js";
 import "../chunk-FHFUXL6G.js";
+import "../chunk-O7XHXF7F.js";
+import "../chunk-2CDEETQN.js";
 import "../chunk-ZZA73MFY.js";
 import "../chunk-Z2XBWN7A.js";
 export {