clawvault 2.6.0 → 3.0.0-beta.1

package/bin/command-registration.test.js

@@ -83,8 +83,7 @@ describe('CLI command registration modules', () => {
       'sync',
       'reindex',
       'remember',
-      'shell-init',
-      'dashboard'
+      'shell-init'
     ]));
   });
 
@@ -130,7 +129,6 @@ describe('CLI command registration modules', () => {
       'archive',
       'migrate-observations',
       'replay',
-      'sync-bd',
       'checkpoint',
       'recover',
       'status',

package/bin/register-core-commands.js

@@ -19,7 +19,6 @@ export function registerCoreCommands(
     .option('--no-tasks', 'Skip tasks/ and backlog/ directories')
     .option('--no-graph', 'Skip initial graph build')
     .option('--categories <list>', 'Comma-separated list of custom categories to create')
-    .option('--canvas', 'Generate a vault status canvas dashboard on init')
     .option('--theme <style>', 'Graph color theme to apply (neural, minimal, none) (default: none)', 'none')
     .option('--minimal', 'Create minimal vault (memory categories only, no tasks/bases/graph)')
     .action(async (vaultPath, options) => {
@@ -81,8 +80,14 @@ export function registerCoreCommands(
             '**/*.md'
           ]);
           console.log(chalk.green('✓ qmd collection created'));
-        } catch {
-          console.log(chalk.yellow('⚠ qmd collection may already exist'));
+        } catch (err) {
+          if (err instanceof QmdUnavailableError || err?.message?.includes('ENOENT') || err?.message?.includes('ERR_MODULE_NOT_FOUND')) {
+            console.log(chalk.yellow('⚠ qmd not available — skipping semantic search setup'));
+            console.log(chalk.dim('  Install qmd for semantic search: npm install -g github:tobi/qmd'));
+            console.log(chalk.dim('  Vault initialized successfully without qmd.'));
+          } else {
+            console.log(chalk.yellow('⚠ qmd collection may already exist'));
+          }
         }
 
         // Apply theme if requested
@@ -92,7 +97,6 @@ export function registerCoreCommands(
             await setupCommand({
               graphColors: true,
               bases: false,
-              canvas: false,
               theme: options.theme,
               vault: resolvedPath
             });
@@ -101,22 +105,6 @@ export function registerCoreCommands(
           }
         }
 
-        // Generate canvas if requested
-        if (options.canvas) {
-          try {
-            const { setupCommand } = await import('../dist/commands/setup.js');
-            await setupCommand({
-              graphColors: false,
-              bases: false,
-              canvas: true,
-              theme: 'none',
-              vault: resolvedPath
-            });
-          } catch {
-            console.log(chalk.yellow(`⚠ Could not generate canvas`));
-          }
-        }
-
         console.log(chalk.green('\n✅ ClawVault ready!\n'));
         console.log('  ' + chalk.bold('Try these:'));
         console.log(chalk.dim('  clawvault capture "my first thought"     # quick capture'));
@@ -140,9 +128,8 @@ export function registerCoreCommands(
     .option('--no-graph-colors', 'Skip graph color configuration')
     .option('--bases', 'Generate Obsidian Bases views for task management')
     .option('--no-bases', 'Skip Bases file generation')
-    .option('--canvas', 'Generate vault status canvas dashboard')
-    .option('--no-canvas', 'Skip canvas generation')
     .option('--theme <style>', 'Graph color theme (neural, minimal, none) (default: neural)', 'neural')
+    .option('--from <path>', 'Import from existing agent memory directory (MEMORY.md, memory/*.md, etc)')
     .option('--force', 'Overwrite existing configuration files')
     .option('-v, --vault <path>', 'Vault path')
     .action(async (options) => {
@@ -151,8 +138,8 @@ export function registerCoreCommands(
         await setupCommand({
           graphColors: options.graphColors,
           bases: options.bases,
-          canvas: options.canvas,
           theme: options.theme,
+          from: options.from,
           force: options.force,
           vault: options.vault
         });

package/bin/register-maintenance-commands.js

@@ -26,8 +26,8 @@ export function registerMaintenanceCommands(program, { chalk }) {
 
         console.log(chalk.cyan('\n🩺 ClawVault Health Check\n'));
         console.log(chalk.dim(`Vault: ${report.vaultPath}`));
-        console.log(chalk.dim(`qmd collection: ${report.qmdCollection}`));
-        console.log(chalk.dim(`qmd root: ${report.qmdRoot}`));
+        if (report.qmdCollection) console.log(chalk.dim(`qmd collection: ${report.qmdCollection}`));
+        if (report.qmdRoot) console.log(chalk.dim(`qmd root: ${report.qmdRoot}`));
         console.log();
 
         for (const check of report.checks) {
@@ -36,7 +36,7 @@ export function registerMaintenanceCommands(program, { chalk }) {
             : check.status === 'warn'
               ? chalk.yellow('⚠')
               : chalk.red('✗');
-          const line = `${check.label}: ${check.detail}`;
+          const line = check.detail ? `${check.label}: ${check.detail}` : check.label;
           const renderedLine = check.status === 'ok'
             ? chalk.green(line)
             : check.status === 'warn'
@@ -262,21 +262,4 @@ export function registerMaintenanceCommands(program, { chalk }) {
     });
 
   // === SYNC-BD ===
-  program
-    .command('sync-bd')
-    .description('Sync active Beads tasks into views/now.md (optional)')
-    .option('--dry-run', 'Show sync output without writing')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (options) => {
-      try {
-        const { syncBdCommand } = await import('../dist/commands/sync-bd.js');
-        await syncBdCommand({
-          vaultPath: options.vault,
-          dryRun: options.dryRun
-        });
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
 }

package/bin/register-query-commands.js

@@ -292,6 +292,29 @@ export function registerQueryCommands(
       }
     });
 
+  // === REWEAVE ===
+  program
+    .command('reweave')
+    .description('Backward memory consolidation — detect and mark superseded observations')
+    .option('--since <date>', 'Only check observations since this date (YYYY-MM-DD)')
+    .option('--dry-run', 'Show what would be superseded without writing')
+    .option('--threshold <n>', 'Entity similarity threshold (0-1, default 0.3)', '0.3')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
+      try {
+        const { reweaveCommand } = await import('../dist/commands/reweave.js');
+        await reweaveCommand({
+          vaultPath: resolveVaultPath(options.vault),
+          since: options.since,
+          dryRun: options.dryRun,
+          threshold: parseFloat(options.threshold),
+        });
+      } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exit(1);
+      }
+    });
+
   // === SESSION-RECAP ===
   program
     .command('session-recap <sessionKey>')

package/bin/register-task-commands.js

@@ -1,6 +1,6 @@
 /**
  * Task tracking command registrations for ClawVault
- * Registers task, backlog, blocked, and canvas commands
+ * Registers task, backlog, and blocked commands
  */
 
 function parseCsvList(value) {
@@ -328,21 +328,4 @@ export function registerTaskCommands(
     });
 
   // === CANVAS ===
-  program
-    .command('canvas')
-    .description('Generate an Obsidian canvas dashboard file')
-    .option('-v, --vault <path>', 'Vault path (default: find nearest)')
-    .option('--output <path>', 'Output file path (default: dashboard.canvas)')
-    .action(async (options) => {
-      try {
-        const vaultPath = resolveVaultPath(options.vault);
-        const { canvasCommand } = await import('../dist/commands/canvas.js');
-        await canvasCommand(vaultPath, {
-          output: options.output
-        });
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
 }

package/bin/register-task-commands.test.js

@@ -50,20 +50,4 @@ describe('register-task-commands', () => {
     ]));
   });
 
-  it('adds simplified canvas flags', () => {
-    const program = new Command();
-    registerTaskCommands(program, {
-      chalk: chalkStub,
-      resolveVaultPath: stubResolveVaultPath
-    });
-
-    const canvasCommand = program.commands.find((command) => command.name() === 'canvas');
-    expect(canvasCommand).toBeDefined();
-
-    const optionFlags = canvasCommand?.options.map((option) => option.flags) ?? [];
-    expect(optionFlags).toEqual(expect.arrayContaining([
-      '-v, --vault <path>',
-      '--output <path>'
-    ]));
-  });
 });

package/bin/register-vault-operations-commands.js

@@ -1,5 +1,5 @@
 /**
- * Vault operation command registrations (browse/sync/reindex/remember/shell-init/dashboard).
+ * Vault operation command registrations (browse/sync/reindex/remember/shell-init).
  */
 
 import { validatePathWithinBase } from './command-runtime.js';
@@ -269,32 +269,4 @@ export function registerVaultOperationsCommands(
       }
     });
 
-  // === DASHBOARD ===
-  program
-    .command('dashboard')
-    .description('Run the local vault graph dashboard server')
-    .option('-p, --port <port>', 'Dashboard port (default: 3377)', '3377')
-    .option('-v, --vault <path>', 'Vault path')
-    .action(async (options) => {
-      try {
-        const parsedPort = Number.parseInt(options.port, 10);
-        if (Number.isNaN(parsedPort)) {
-          console.error(chalk.red(`Error: Invalid port: ${options.port}`));
-          process.exit(1);
-        }
-
-        const vaultPath = options.vault
-          ? path.resolve(options.vault)
-          : resolveVaultPath(undefined);
-
-        const { startDashboard } = await import('../dashboard/server.js');
-        await startDashboard({
-          port: parsedPort,
-          vaultPath
-        });
-      } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-        process.exit(1);
-      }
-    });
 }

package/dist/{chunk-QVMXF7FY.js → chunk-3D6BCTP6.js}

@@ -24,6 +24,19 @@ function findPackageRoot() {
   }
   return path.dirname(fileURLToPath(import.meta.url));
 }
+function resolveOpenClawHooksDir() {
+  const candidates = [
+    path.join(process.env.HOME || "", ".openclaw", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_HOME || "", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_STATE_DIR || "", "hooks", "clawvault")
+  ].filter((p) => p && !p.startsWith(path.sep + "hooks"));
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 function resolveProjectFile(relativePath, baseDir) {
   if (baseDir) {
     return path.resolve(baseDir, relativePath);
@@ -32,6 +45,20 @@ function resolveProjectFile(relativePath, baseDir) {
   if (fs.existsSync(fromCwd)) {
     return fromCwd;
   }
+  if (relativePath.startsWith("hooks/clawvault/")) {
+    const hooksDir = resolveOpenClawHooksDir();
+    if (hooksDir) {
+      const hookRelative = relativePath.replace("hooks/clawvault/", "");
+      const fromHooks = path.resolve(hooksDir, hookRelative);
+      if (fs.existsSync(fromHooks)) {
+        return fromHooks;
+      }
+      const fromNestedHooks = path.resolve(hooksDir, "hooks", "clawvault", hookRelative);
+      if (fs.existsSync(fromNestedHooks)) {
+        return fromNestedHooks;
+      }
+    }
+  }
   return path.resolve(findPackageRoot(), relativePath);
 }
 function checkOpenClawCli() {
@@ -63,7 +90,18 @@ function checkOpenClawCli() {
   return { label: "openclaw CLI available", status: "ok" };
 }
 function checkPackageHookRegistration(options) {
-  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  let packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (packageRaw && !options.baseDir) {
+    try {
+      const parsed = JSON.parse(packageRaw);
+      if (!parsed.openclaw?.hooks) {
+        const fallbackPath = path.resolve(findPackageRoot(), "package.json");
+        const fallbackRaw = readOptionalFile(fallbackPath);
+        if (fallbackRaw) packageRaw = fallbackRaw;
+      }
+    } catch {
+    }
+  }
   if (!packageRaw) {
     return {
       label: "package hook registration",

package/dist/{chunk-R2MIW5G7.js → chunk-3DHXQHYG.js}

@@ -8,7 +8,7 @@ import {
   queryTransitions,
   readTask,
   updateTask
-} from "./chunk-QWQ3TIKS.js";
+} from "./chunk-N2AXRYLC.js";
 
 // src/commands/task.ts
 function taskAdd(vaultPath, title, options = {}) {

package/dist/{chunk-Q2J5YTUF.js → chunk-3NSBOUT3.js}

@@ -1,6 +1,21 @@
 import {
   listProjects
-} from "./chunk-AZYOKJYC.js";
+} from "./chunk-62YTUT6J.js";
+import {
+  listConfig,
+  listRouteRules,
+  matchRouteRule
+} from "./chunk-ITPEXLHA.js";
+import {
+  resolveClaudeOAuthToken
+} from "./chunk-PAH27GSN.js";
+import {
+  createBacklogItem,
+  listBacklogItems,
+  listTasks,
+  updateBacklogItem,
+  updateTask
+} from "./chunk-N2AXRYLC.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -9,12 +24,7 @@ import {
   parseObservationMarkdown,
   renderObservationMarkdown,
   renderScoredObservationLine
-} from "./chunk-FHFUXL6G.js";
-import {
-  listConfig,
-  listRouteRules,
-  matchRouteRule
-} from "./chunk-ITPEXLHA.js";
+} from "./chunk-QK3UCXWL.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -23,19 +33,12 @@ import {
   getRawTranscriptPath,
   toDateKey
 } from "./chunk-Z2XBWN7A.js";
-import {
-  createBacklogItem,
-  listBacklogItems,
-  listTasks,
-  updateBacklogItem,
-  updateTask
-} from "./chunk-QWQ3TIKS.js";
 
 // 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-3-5-haiku-latest",
+  anthropic: "claude-haiku-4-5",
   openai: "gpt-4o-mini",
   gemini: "gemini-2.0-flash",
   "openai-compatible": "gpt-4o-mini",
@@ -69,7 +72,7 @@ var Compressor = class {
       return existingObservations.trim();
     }
     const prompt = this.buildPrompt(cleanedMessages, existingObservations);
-    const backend = this.resolveProvider();
+    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);
@@ -83,16 +86,16 @@ var Compressor = class {
     const fallback = this.fallbackCompression(cleanedMessages);
     return this.mergeObservations(existingObservations, fallback);
   }
-  resolveProvider() {
+  async resolveProvider() {
     if (process.env.CLAWVAULT_NO_LLM) return null;
     if (this.provider) {
       const configured = this.resolveConfiguredProvider(this.provider);
       if (configured) {
         return configured;
       }
-      return this.resolveProviderFromEnv(false);
+      return await this.resolveProviderFromEnv(false);
     }
-    return this.resolveProviderFromEnv(true);
+    return await this.resolveProviderFromEnv(true);
   }
   resolveConfiguredProvider(provider) {
     const model = this.resolveModel(provider);
@@ -138,14 +141,21 @@ var Compressor = class {
       baseUrl: this.resolveBaseUrl(provider)
     };
   }
-  resolveProviderFromEnv(allowConfiguredModel) {
+  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: allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic,
-        apiKey: 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) {
@@ -215,6 +225,17 @@ var Compressor = class {
       "- 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".`,
@@ -293,19 +314,35 @@ var Compressor = class {
     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: {
-        "content-type": "application/json",
-        "x-api-key": backend.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model: backend.model,
-        temperature: 0.1,
-        max_tokens: 1400,
-        messages: [{ role: "user", content: prompt }]
-      })
+      headers,
+      body: JSON.stringify(body)
     });
     if (!response.ok) {
       throw new Error(`Anthropic request failed (${response.status})`);

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/{chunk-AZYOKJYC.js → chunk-62YTUT6J.js}

@@ -1,11 +1,11 @@
 import {
   listTasks,
   slugify
-} from "./chunk-QWQ3TIKS.js";
+} from "./chunk-N2AXRYLC.js";
 import {
   loadSchemaTemplateDefinition,
   renderDocumentFromTemplate
-} from "./chunk-MFAWT5O5.js";
+} from "./chunk-LYHGEHXG.js";
 
 // src/lib/project-utils.ts
 import * as fs from "fs";