clawvault 2.3.0 → 2.4.0

package/dist/chunk-NZ4ZZNSR.js

@@ -0,0 +1,373 @@
+import {
+  DEFAULT_SERVE_PORT,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  findPeer,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+} from "./chunk-4GBPTBFJ.js";
+import {
+  resolveVaultPath
+} from "./chunk-MXSSG3QU.js";
+
+// src/commands/tailscale.ts
+import * as path from "path";
+async function tailscaleStatusCommand(options = {}) {
+  const status = getTailscaleStatus();
+  if (options.json) {
+    console.log(JSON.stringify(status, null, 2));
+    return status;
+  }
+  if (!status.installed) {
+    console.log("Tailscale: Not installed");
+    console.log("  Install from: https://tailscale.com/download");
+    return status;
+  }
+  const version = getTailscaleVersion();
+  console.log(`Tailscale: ${version || "installed"}`);
+  if (!status.running) {
+    console.log("  Status: Daemon not running");
+    if (status.error) {
+      console.log(`  Error: ${status.error}`);
+    }
+    return status;
+  }
+  console.log(`  Status: ${status.backendState}`);
+  if (status.connected) {
+    console.log(`  Tailnet: ${status.tailnetName || "unknown"}`);
+    console.log(`  Self IP: ${status.selfIP || "unknown"}`);
+    console.log(`  Hostname: ${status.selfHostname || "unknown"}`);
+    if (status.selfDNSName) {
+      console.log(`  DNS Name: ${status.selfDNSName}`);
+    }
+    if (options.peers || status.peers.length > 0) {
+      const onlinePeers = status.peers.filter((p) => p.online);
+      const offlinePeers = status.peers.filter((p) => !p.online);
+      console.log(`
+Peers (${onlinePeers.length} online, ${offlinePeers.length} offline):`);
+      for (const peer of onlinePeers) {
+        const ip = peer.tailscaleIPs[0] || "no-ip";
+        const os = peer.os ? ` (${peer.os})` : "";
+        const clawvault = peer.clawvaultServing ? " [ClawVault]" : "";
+        console.log(`  \u25CF ${peer.hostname}${os} - ${ip}${clawvault}`);
+      }
+      if (options.peers) {
+        for (const peer of offlinePeers) {
+          const ip = peer.tailscaleIPs[0] || "no-ip";
+          const os = peer.os ? ` (${peer.os})` : "";
+          console.log(`  \u25CB ${peer.hostname}${os} - ${ip} [offline]`);
+        }
+      }
+    }
+  } else {
+    console.log("  Status: Not connected to tailnet");
+    if (status.error) {
+      console.log(`  Error: ${status.error}`);
+    }
+  }
+  return status;
+}
+function registerTailscaleStatusCommand(program) {
+  program.command("tailscale-status").alias("ts-status").description("Show Tailscale connection status and peers").option("--json", "Output as JSON").option("--peers", "Show all peers including offline").action(async (rawOptions) => {
+    await tailscaleStatusCommand({
+      json: rawOptions.json,
+      peers: rawOptions.peers
+    });
+  });
+}
+async function tailscaleSyncCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const status = getTailscaleStatus();
+  if (!status.installed) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: ["Tailscale not installed. Install from https://tailscale.com/download"],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error("Error: Tailscale not installed");
+    }
+    return error;
+  }
+  if (!status.connected) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: ["Not connected to Tailscale. Run `tailscale up` to connect."],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error("Error: Not connected to Tailscale");
+    }
+    return error;
+  }
+  const peer = findPeer(options.peer);
+  if (!peer) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: [`Peer not found: ${options.peer}`],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error(`Error: Peer not found: ${options.peer}`);
+      console.log("\nAvailable online peers:");
+      for (const p of getOnlinePeers()) {
+        console.log(`  - ${p.hostname} (${p.tailscaleIPs[0]})`);
+      }
+    }
+    return error;
+  }
+  if (!peer.online) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: [`Peer is offline: ${peer.hostname}`],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error(`Error: Peer is offline: ${peer.hostname}`);
+    }
+    return error;
+  }
+  const syncOptions = {
+    peer: peer.tailscaleIPs[0],
+    port: options.port || DEFAULT_SERVE_PORT,
+    direction: options.direction || "bidirectional",
+    dryRun: options.dryRun,
+    deleteOrphans: options.deleteOrphans,
+    categories: options.categories,
+    https: options.https
+  };
+  if (!options.json && !options.dryRun) {
+    console.log(`Syncing with ${peer.hostname} (${peer.tailscaleIPs[0]})...`);
+  }
+  const result = await syncWithPeer(vaultPath, syncOptions);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const prefix = options.dryRun ? "[dry-run] " : "";
+    if (result.pushed.length > 0) {
+      console.log(`
+${prefix}Pushed ${result.pushed.length} file(s):`);
+      for (const file of result.pushed.slice(0, 10)) {
+        console.log(`  \u2192 ${file}`);
+      }
+      if (result.pushed.length > 10) {
+        console.log(`  ... and ${result.pushed.length - 10} more`);
+      }
+    }
+    if (result.pulled.length > 0) {
+      console.log(`
+${prefix}Pulled ${result.pulled.length} file(s):`);
+      for (const file of result.pulled.slice(0, 10)) {
+        console.log(`  \u2190 ${file}`);
+      }
+      if (result.pulled.length > 10) {
+        console.log(`  ... and ${result.pulled.length - 10} more`);
+      }
+    }
+    if (result.deleted.length > 0) {
+      console.log(`
+${prefix}Deleted ${result.deleted.length} file(s):`);
+      for (const file of result.deleted.slice(0, 10)) {
+        console.log(`  \u2717 ${file}`);
+      }
+      if (result.deleted.length > 10) {
+        console.log(`  ... and ${result.deleted.length - 10} more`);
+      }
+    }
+    if (result.errors.length > 0) {
+      console.log(`
+Errors (${result.errors.length}):`);
+      for (const error of result.errors) {
+        console.log(`  ! ${error}`);
+      }
+    }
+    console.log(`
+Summary:`);
+    console.log(`  Pushed: ${result.pushed.length}`);
+    console.log(`  Pulled: ${result.pulled.length}`);
+    console.log(`  Deleted: ${result.deleted.length}`);
+    console.log(`  Unchanged: ${result.unchanged.length}`);
+    console.log(`  Errors: ${result.errors.length}`);
+    console.log(`  Duration: ${result.stats.duration}ms`);
+    console.log(`  Transferred: ${formatBytes(result.stats.bytesTransferred)}`);
+  }
+  return result;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function registerTailscaleSyncCommand(program) {
+  program.command("tailscale-sync").alias("ts-sync").description("Sync vault with a peer on the Tailscale network").requiredOption("--peer <hostname>", "Peer hostname or IP to sync with").option("-v, --vault <path>", "Vault path").option("--port <number>", "Port on the peer", parseInt).option("--direction <dir>", "Sync direction: push, pull, or bidirectional", "bidirectional").option("--dry-run", "Show what would be synced without making changes").option("--delete-orphans", "Delete files that exist locally but not on peer (pull only)").option("--categories <list>", "Comma-separated list of categories to sync").option("--https", "Use HTTPS for connection").option("--json", "Output as JSON").action(async (rawOptions) => {
+    await tailscaleSyncCommand({
+      peer: rawOptions.peer,
+      vaultPath: rawOptions.vault,
+      port: rawOptions.port,
+      direction: rawOptions.direction,
+      dryRun: rawOptions.dryRun,
+      deleteOrphans: rawOptions.deleteOrphans,
+      categories: rawOptions.categories?.split(",").map((c) => c.trim()),
+      https: rawOptions.https,
+      json: rawOptions.json
+    });
+  });
+}
+var activeServeInstance = null;
+async function tailscaleServeCommand(options) {
+  if (options.stop) {
+    if (activeServeInstance) {
+      await activeServeInstance.stop();
+      activeServeInstance = null;
+      console.log("ClawVault serve stopped.");
+    }
+    stopTailscaleServe();
+    return;
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const port = options.port || DEFAULT_SERVE_PORT;
+  const status = getTailscaleStatus();
+  console.log(`Starting ClawVault serve...`);
+  console.log(`  Vault: ${path.basename(vaultPath)}`);
+  console.log(`  Port: ${port}`);
+  activeServeInstance = serveVault(vaultPath, { port });
+  console.log(`  Local URL: http://localhost:${port}/.clawvault`);
+  if (status.connected) {
+    console.log(`  Tailscale URL: http://${status.selfIP}:${port}/.clawvault`);
+    if (status.selfDNSName) {
+      const dnsHost = status.selfDNSName.replace(/\.$/, "");
+      console.log(`  MagicDNS URL: http://${dnsHost}:${port}/.clawvault`);
+    }
+    if (options.funnel || options.background) {
+      console.log("\nConfiguring Tailscale serve...");
+      configureTailscaleServe(port, {
+        funnel: options.funnel,
+        background: options.background
+      });
+      if (options.funnel) {
+        console.log("  Funnel enabled - vault is accessible from the public internet");
+      }
+    }
+  } else {
+    console.log("\n  Note: Not connected to Tailscale. Only local access available.");
+  }
+  console.log("\nEndpoints:");
+  console.log(`  Health: /.clawvault/health`);
+  console.log(`  Manifest: /.clawvault/manifest`);
+  console.log(`  Files: /.clawvault/files/<path>`);
+  if (!options.background) {
+    console.log("\nPress Ctrl+C to stop serving.");
+    process.on("SIGINT", async () => {
+      console.log("\nStopping ClawVault serve...");
+      if (activeServeInstance) {
+        await activeServeInstance.stop();
+        activeServeInstance = null;
+      }
+      stopTailscaleServe();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+}
+function registerTailscaleServeCommand(program) {
+  program.command("tailscale-serve").alias("ts-serve").description("Serve vault for sync over Tailscale").option("-v, --vault <path>", "Vault path").option("--port <number>", `Port to serve on (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--funnel", "Expose via Tailscale Funnel (public internet)").option("--background", "Run in background").option("--stop", "Stop serving").action(async (rawOptions) => {
+    await tailscaleServeCommand({
+      vaultPath: rawOptions.vault,
+      port: rawOptions.port,
+      funnel: rawOptions.funnel,
+      background: rawOptions.background,
+      stop: rawOptions.stop
+    });
+  });
+}
+async function tailscaleDiscoverCommand(options = {}) {
+  const port = options.port || DEFAULT_SERVE_PORT;
+  const status = getTailscaleStatus();
+  if (!status.connected) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not connected to Tailscale", peers: [] }));
+    } else {
+      console.error("Error: Not connected to Tailscale");
+    }
+    return [];
+  }
+  if (!options.json) {
+    console.log("Discovering ClawVault peers on tailnet...");
+  }
+  const peers = await discoverClawVaultPeers(port);
+  if (options.json) {
+    console.log(JSON.stringify({ peers }, null, 2));
+  } else {
+    if (peers.length === 0) {
+      console.log("\nNo ClawVault peers found.");
+      console.log("  Run `clawvault tailscale-serve` on other devices to enable sync.");
+    } else {
+      console.log(`
+Found ${peers.length} ClawVault peer(s):`);
+      for (const peer of peers) {
+        const ip = peer.tailscaleIPs[0] || "no-ip";
+        const os = peer.os ? ` (${peer.os})` : "";
+        console.log(`  \u25CF ${peer.hostname}${os}`);
+        console.log(`    IP: ${ip}`);
+        console.log(`    Port: ${peer.clawvaultPort}`);
+        if (peer.dnsName) {
+          console.log(`    DNS: ${peer.dnsName.replace(/\.$/, "")}`);
+        }
+      }
+    }
+  }
+  return peers;
+}
+function registerTailscaleDiscoverCommand(program) {
+  program.command("tailscale-discover").alias("ts-discover").description("Discover ClawVault peers on the Tailscale network").option("--port <number>", `Port to check (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--json", "Output as JSON").action(async (rawOptions) => {
+    await tailscaleDiscoverCommand({
+      port: rawOptions.port,
+      json: rawOptions.json
+    });
+  });
+}
+function registerTailscaleCommands(program) {
+  registerTailscaleStatusCommand(program);
+  registerTailscaleSyncCommand(program);
+  registerTailscaleServeCommand(program);
+  registerTailscaleDiscoverCommand(program);
+}
+
+export {
+  tailscaleStatusCommand,
+  registerTailscaleStatusCommand,
+  tailscaleSyncCommand,
+  registerTailscaleSyncCommand,
+  tailscaleServeCommand,
+  registerTailscaleServeCommand,
+  tailscaleDiscoverCommand,
+  registerTailscaleDiscoverCommand,
+  registerTailscaleCommands
+};

package/dist/{chunk-OTQW3OMC.js → chunk-Q3WBH4P4.js}

@@ -83,9 +83,106 @@ var ClawVault = class {
       qmdRoot: this.getQmdRoot()
     };
     fs.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+    this.createBasesFiles();
     await this.syncMemoryGraphIndex({ forceFull: true });
     this.initialized = true;
   }
+  createBasesFiles() {
+    const vaultPath = this.config.path;
+    const basesFiles = {
+      "all-tasks.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status != "done"',
+        "formulas:",
+        "  age: (now() - file.ctime).days",
+        '  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", if(status == "open", "\u26AA", "\u2705")))',
+        "views:",
+        "  - type: table",
+        "    name: All Active Tasks",
+        "    groupBy:",
+        "      property: status",
+        "      direction: ASC",
+        "    order:",
+        "      - formula.status_icon",
+        "      - file.name",
+        "      - status",
+        "      - owner",
+        "      - project",
+        "      - priority",
+        "      - blocked_by",
+        "      - formula.age",
+        "  - type: cards",
+        "    name: Task Board",
+        "    groupBy:",
+        "      property: status",
+        "      direction: ASC",
+        "    order:",
+        "      - file.name",
+        "      - owner",
+        "      - project",
+        "      - priority"
+      ].join("\n"),
+      "blocked.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status == "blocked"',
+        "formulas:",
+        "  days_blocked: (now() - file.ctime).days",
+        "views:",
+        "  - type: table",
+        "    name: Blocked Tasks",
+        "    order:",
+        "      - file.name",
+        "      - owner",
+        "      - project",
+        "      - blocked_by",
+        "      - formula.days_blocked",
+        "      - priority"
+      ].join("\n"),
+      "by-project.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status != "done"',
+        "formulas:",
+        '  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", "\u26AA"))',
+        "views:",
+        "  - type: table",
+        "    name: By Project",
+        "    groupBy:",
+        "      property: project",
+        "      direction: ASC",
+        "    order:",
+        "      - formula.status_icon",
+        "      - file.name",
+        "      - status",
+        "      - owner",
+        "      - priority"
+      ].join("\n"),
+      "backlog.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("backlog")',
+        "views:",
+        "  - type: table",
+        "    name: Backlog",
+        "    order:",
+        "      - file.name",
+        "      - source",
+        "      - project",
+        "      - file.ctime"
+      ].join("\n")
+    };
+    for (const [filename, content] of Object.entries(basesFiles)) {
+      const filePath = path.join(vaultPath, filename);
+      if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, content);
+      }
+    }
+  }
   /**
    * Load an existing vault
    */

package/dist/{chunk-MQUJNOHK.js → chunk-QALB2V3E.js}

@@ -2,7 +2,7 @@ import {
   ensureParentDir,
   getArchiveObservationPath,
   listObservationFiles
-} from "./chunk-Z2XBWN7A.js";
+} from "./chunk-NAMFB7ZA.js";
 
 // src/observer/archive.ts
 import * as fs from "fs";

package/dist/{chunk-PTSEIWXZ.js → chunk-SNEMCQP7.js}

@@ -6,13 +6,13 @@ import {
 } from "./chunk-P5EPF6MB.js";
 import {
   Observer
-} from "./chunk-2HM7ZI4X.js";
+} from "./chunk-FEFPBHH4.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";
 import {
   getObservationPath
-} from "./chunk-Z2XBWN7A.js";
+} from "./chunk-NAMFB7ZA.js";
 
 // src/commands/observe.ts
 import * as fs3 from "fs";
@@ -523,7 +523,8 @@ async function observeActiveSessions(options, dependencies = {}) {
   const observer = observerFactory(vaultPath, {
     tokenThreshold: options.threshold,
     reflectThreshold: options.reflectThreshold,
-    model: options.model
+    model: options.model,
+    extractTasks: options.extractTasks
   });
   let observedSessions = 0;
   let cursorUpdates = 0;
@@ -591,6 +592,9 @@ function buildDaemonArgs(options) {
   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);
   }
@@ -653,7 +657,8 @@ async function observeCommand(options) {
       dryRun: options.dryRun,
       threshold: options.threshold,
       reflectThreshold: options.reflectThreshold,
-      model: options.model
+      model: options.model,
+      extractTasks: options.extractTasks
     });
     if (result.candidateSessions === 0) {
       console.log(`No active sessions crossed threshold (${result.checkedSessions} checked).`);
@@ -678,7 +683,8 @@ async function observeCommand(options) {
   const observer = new Observer(vaultPath, {
     tokenThreshold: options.threshold,
     reflectThreshold: options.reflectThreshold,
-    model: options.model
+    model: options.model,
+    extractTasks: options.extractTasks
   });
   if (options.compress) {
     await runOneShotCompression(observer, options.compress, vaultPath);
@@ -711,7 +717,7 @@ async function observeCommand(options) {
   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("--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("--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) => {
+  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("--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,
@@ -722,6 +728,7 @@ function registerObserveCommand(program) {
       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

package/dist/commands/archive.js

@@ -1,10 +1,10 @@
 import {
   archiveCommand,
   registerArchiveCommand
-} from "../chunk-VR5NE7PZ.js";
-import "../chunk-MQUJNOHK.js";
+} from "../chunk-HVTTYDCJ.js";
+import "../chunk-QALB2V3E.js";
 import "../chunk-MXSSG3QU.js";
-import "../chunk-Z2XBWN7A.js";
+import "../chunk-NAMFB7ZA.js";
 export {
   archiveCommand,
   registerArchiveCommand

package/dist/commands/backlog.js

@@ -2,9 +2,16 @@ import {
   createBacklogItem,
   listBacklogItems,
   promoteBacklogItem
-} from "../chunk-NGVAEFT2.js";
+} from "../chunk-DEFBIVQ3.js";
 
 // src/commands/backlog.ts
+function toDateStr(val) {
+  if (!val) return "unknown";
+  if (val instanceof Date) return val.toISOString().split("T")[0];
+  const s = String(val);
+  if (s.includes("T")) return s.split("T")[0];
+  return s;
+}
 function backlogAdd(vaultPath, title, options = {}) {
   return createBacklogItem(vaultPath, title, {
     source: options.source,
@@ -35,7 +42,7 @@ function formatBacklogList(items) {
   for (const item of items) {
     const source = item.frontmatter.source || "-";
     const project = item.frontmatter.project || "-";
-    const created = item.frontmatter.created.split("T")[0];
+    const created = toDateStr(item.frontmatter.created);
     const title = item.title.length > widths[3] ? item.title.slice(0, widths[3] - 3) + "..." : item.title;
     const row = [
       source.padEnd(widths[0]),

package/dist/commands/blocked.js

@@ -1,8 +1,15 @@
 import {
   getBlockedTasks
-} from "../chunk-NGVAEFT2.js";
+} from "../chunk-DEFBIVQ3.js";
 
 // src/commands/blocked.ts
+function toDateStr(val) {
+  if (!val) return "unknown";
+  if (val instanceof Date) return val.toISOString().split("T")[0];
+  const s = String(val);
+  if (s.includes("T")) return s.split("T")[0];
+  return s;
+}
 function blockedList(vaultPath, options = {}) {
   return getBlockedTasks(vaultPath, options.project);
 }
@@ -17,7 +24,7 @@ function formatBlockedList(tasks) {
     const owner = task.frontmatter.owner || "unassigned";
     const project = task.frontmatter.project || "no project";
     const blockedBy = task.frontmatter.blocked_by || "unknown";
-    const updatedDate = task.frontmatter.updated.split("T")[0];
+    const updatedDate = toDateStr(task.frontmatter.updated);
     output += `\u25A0 ${task.title} (${owner}, ${project})
 `;
     output += `  Blocked by: ${blockedBy}

package/dist/commands/canvas.d.ts

@@ -2,18 +2,26 @@ import { Canvas } from '../lib/canvas-layout.js';
 
 /**
  * Canvas command for ClawVault
- * Generates an Obsidian JSON Canvas dashboard
+ * Generates Obsidian JSON Canvas dashboards using registered templates.
  */
 
 interface CanvasOptions {
     output?: string;
+    template?: string;
+    listTemplates?: boolean;
+    project?: string;
+    owner?: string;
+    width?: number;
+    height?: number;
+    includeDone?: boolean;
 }
 /**
- * Generate the canvas dashboard
+ * Generate the default dashboard canvas.
+ * Kept for compatibility with existing tests and callers.
  */
 declare function generateCanvas(vaultPath: string): Canvas;
 /**
- * Canvas command handler for CLI
+ * Canvas command handler for CLI.
  */
 declare function canvasCommand(vaultPath: string, options?: CanvasOptions): Promise<void>;