clawvault 3.0.0 → 3.2.0

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

@@ -24,19 +24,6 @@ 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);
@@ -45,20 +32,6 @@ 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() {
@@ -90,18 +63,7 @@ function checkOpenClawCli() {
   return { label: "openclaw CLI available", status: "ok" };
 }
 function checkPackageHookRegistration(options) {
-  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 {
-    }
-  }
+  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
   if (!packageRaw) {
     return {
       label: "package hook registration",
@@ -233,6 +195,55 @@ function checkHookHandlerSafety(options) {
   }
   return { label: "hook handler safety", status: "ok" };
 }
+function checkPluginManifest(options) {
+  const manifestRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/openclaw.plugin.json", options.baseDir));
+  if (!manifestRaw) {
+    return {
+      label: "plugin manifest",
+      status: "error",
+      detail: "hooks/clawvault/openclaw.plugin.json not found",
+      hint: "Add openclaw.plugin.json to hooks/clawvault/ for config schema registration."
+    };
+  }
+  try {
+    const parsed = JSON.parse(manifestRaw);
+    if (!parsed.id || parsed.id !== "clawvault") {
+      return {
+        label: "plugin manifest",
+        status: "error",
+        detail: `Invalid plugin id: expected "clawvault", got "${parsed.id || "(missing)"}"`
+      };
+    }
+    if (!parsed.configSchema || typeof parsed.configSchema !== "object") {
+      return {
+        label: "plugin manifest",
+        status: "error",
+        detail: "Missing configSchema in plugin manifest",
+        hint: "Add configSchema to openclaw.plugin.json for config validation."
+      };
+    }
+    const hasVaultPath = Boolean(parsed.configSchema.properties?.vaultPath);
+    if (!hasVaultPath) {
+      return {
+        label: "plugin manifest",
+        status: "warn",
+        detail: "configSchema missing vaultPath property",
+        hint: "Add vaultPath to configSchema.properties for vault path configuration."
+      };
+    }
+    return {
+      label: "plugin manifest",
+      status: "ok",
+      detail: `id: ${parsed.id}, configSchema defined`
+    };
+  } catch (err) {
+    return {
+      label: "plugin manifest",
+      status: "error",
+      detail: err?.message || "Unable to parse openclaw.plugin.json"
+    };
+  }
+}
 function checkSkillMetadata(options) {
   const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
   if (!skillRaw) {
@@ -274,6 +285,7 @@ function checkOpenClawCompatibility(options = {}) {
   const checks = [
     checkOpenClawCli(),
     checkPackageHookRegistration(options),
+    checkPluginManifest(options),
     checkHookManifest(options),
     checkHookManifestRequirements(options),
     checkHookHandlerSafety(options),

package/dist/{chunk-THRJVD4L.js → chunk-Y6VJKXGL.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-TIGW564L.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/tailscale.ts
 import * as path from "path";

package/dist/{chunk-ZVVFWOLW.js → chunk-ZN54U2OZ.js}

@@ -1,12 +1,15 @@
 import {
   ClawVault
-} from "./chunk-WGRQ6HDV.js";
+} from "./chunk-CLJTREDS.js";
 import {
-  getMemoryGraph
-} from "./chunk-ZZA73MFY.js";
+  FactStore
+} from "./chunk-BSJ6RIT7.js";
 import {
   parseObservationMarkdown
-} from "./chunk-QK3UCXWL.js";
+} from "./chunk-FHFUXL6G.js";
+import {
+  getMemoryGraph
+} from "./chunk-33DOSHTA.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";
@@ -141,7 +144,56 @@ var STOP_WORDS = /* @__PURE__ */ new Set([
   "why",
   "with",
   "you",
-  "your"
+  "your",
+  "\u0438",
+  "\u0432",
+  "\u0432\u043E",
+  "\u043D\u0430",
+  "\u043F\u043E",
+  "\u0441",
+  "\u0441\u043E",
+  "\u043A",
+  "\u043A\u043E",
+  "\u0443",
+  "\u043E",
+  "\u043E\u0431",
+  "\u043E\u0442",
+  "\u0434\u043E",
+  "\u0437\u0430",
+  "\u0438\u0437",
+  "\u043F\u043E\u0434",
+  "\u043D\u0430\u0434",
+  "\u043D\u0435",
+  "\u043D\u043E",
+  "\u0430",
+  "\u0438\u043B\u0438",
+  "\u0447\u0442\u043E",
+  "\u043A\u0430\u043A",
+  "\u044D\u0442\u043E",
+  "\u0442\u043E",
+  "\u0436\u0435",
+  "\u043B\u0438",
+  "\u0434\u043B\u044F",
+  "\u043F\u0440\u0438",
+  "\u043F\u0440\u043E",
+  "\u043C\u044B",
+  "\u0432\u044B",
+  "\u043E\u043D\u0438",
+  "\u043E\u043D",
+  "\u043E\u043D\u0430",
+  "\u043E\u043D\u043E",
+  "\u044F",
+  "\u0442\u044B",
+  "\u043C\u043E\u0439",
+  "\u043C\u043E\u044F",
+  "\u043C\u043E\u0451",
+  "\u043C\u043E\u0438",
+  "\u0442\u0432\u043E\u0439",
+  "\u0442\u0432\u043E\u044F",
+  "\u0442\u0432\u043E\u0438",
+  "\u043D\u0430\u0448",
+  "\u043D\u0430\u0448\u0430",
+  "\u0438\u0445"
 ]);
 function formatRelativeAge(date, now = Date.now()) {
   const ageMs = Math.max(0, now - date.getTime());
@@ -179,24 +231,24 @@ function formatContextMarkdown(task, entries) {
 }
 var PROFILE_ORDERING = {
   default: {
-    order: ["structural", "daily", "search", "graph", "potential", "contextual"],
+    order: ["structural", "fact", "daily", "search", "graph", "potential", "contextual"],
     caps: {}
   },
   planning: {
-    order: ["search", "graph", "structural", "potential", "daily", "contextual"],
+    order: ["fact", "search", "graph", "structural", "potential", "daily", "contextual"],
     caps: { observation: 12, graph: 12 }
   },
   incident: {
-    order: ["structural", "search", "potential", "daily", "graph", "contextual"],
+    order: ["structural", "fact", "search", "potential", "daily", "graph", "contextual"],
     caps: { observation: 20, graph: 8 }
   },
   handoff: {
-    order: ["daily", "structural", "potential", "search", "graph", "contextual"],
+    order: ["daily", "structural", "fact", "potential", "search", "graph", "contextual"],
     caps: { "daily-note": 2, observation: 15 }
   }
 };
 function extractKeywords(text) {
-  const raw = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+  const raw = text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
   const seen = /* @__PURE__ */ new Set();
   const keywords = [];
   for (const token of raw) {
@@ -369,6 +421,64 @@ function buildObservationContextItems(vaultPath, queryKeywords) {
   }
   return items;
 }
+var PREFERENCE_PATTERNS = /\b(prefer|like|favorite|favourit|enjoy|habit|allergy|allergic|diet|dislike|want|love|hate|routine)\b/i;
+var TEMPORAL_PATTERNS = /\b(yesterday|today|last\s+(?:week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)|in\s+\d{4}|on\s+\w+\s+\d{1,2}|\d{4}-\d{2}-\d{2}|january|february|march|april|may|june|july|august|september|october|november|december)\b/i;
+function isPreferenceQuery(query) {
+  return PREFERENCE_PATTERNS.test(query);
+}
+function isTemporalQuery(query) {
+  return TEMPORAL_PATTERNS.test(query);
+}
+function buildFactContextItems(vaultPath, query, _queryKeywords) {
+  const factStore = new FactStore(vaultPath);
+  try {
+    factStore.load();
+  } catch {
+    return [];
+  }
+  const stats = factStore.stats();
+  if (stats.activeFacts === 0) return [];
+  const items = [];
+  const preferenceQuery = isPreferenceQuery(query);
+  const temporalQuery = isTemporalQuery(query);
+  const matchingFacts = factStore.searchFacts(query);
+  if (preferenceQuery) {
+    const prefs = factStore.getPreferences();
+    for (const pref of prefs) {
+      if (!matchingFacts.find((f) => f.id === pref.id)) {
+        matchingFacts.push(pref);
+      }
+    }
+  }
+  for (const fact of matchingFacts.slice(0, 10)) {
+    const factText = `${fact.entity} ${fact.relation} ${fact.value}`;
+    let score = fact.confidence * 0.8;
+    if (preferenceQuery && fact.category === "preference") {
+      score *= 1.5;
+    }
+    if (temporalQuery && (fact.relation.includes("_on") || fact.relation.includes("date") || fact.relation.includes("time"))) {
+      score *= 1.3;
+    }
+    const entry = {
+      title: `Fact: ${fact.entity} \u2192 ${fact.relation}`,
+      path: fact.source,
+      category: fact.category,
+      score: Math.min(1, score),
+      snippet: factText,
+      modified: fact.validFrom,
+      age: formatRelativeAge(new Date(fact.validFrom)),
+      source: "observation",
+      // Use 'observation' since ContextSource doesn't include 'fact'
+      signals: ["fact_store", fact.category],
+      rationale: `Extracted fact (${fact.category}, confidence: ${fact.confidence.toFixed(2)})`
+    };
+    items.push({
+      priority: preferenceQuery && fact.category === "preference" ? 1 : 2,
+      entry
+    });
+  }
+  return items;
+}
 function buildSearchContextItems(vault, results) {
   return results.map((result) => {
     const relativePath = path.relative(vault.getPath(), result.document.path).split(path.sep).join("/");
@@ -592,6 +702,7 @@ async function buildContext(task, options) {
   });
   const searchItems = buildSearchContextItems(vault, searchResults);
   const dailyItems = buildDailyContextItems(vault.getPath(), allDocuments);
+  const factItems = buildFactContextItems(vault.getPath(), normalizedTask, queryKeywords);
   const observationItems = includeObservations ? buildObservationContextItems(vault.getPath(), queryKeywords) : [];
   const graph = await getMemoryGraph(vault.getPath());
   const graphItems = buildGraphContextItems({
@@ -608,11 +719,13 @@ async function buildContext(task, options) {
   const contextualObservations = observationItems.filter((item) => item.priority === 5).sort(byScoreDesc);
   const sortedDailyItems = [...dailyItems].sort(byScoreDesc);
   const sortedSearchItems = [...searchItems].sort(byScoreDesc);
+  const sortedFactItems = [...factItems].sort(byScoreDesc);
   const sortedGraphItems = [...graphItems].sort(byScoreDesc);
   const grouped = {
     structural: structuralObservations,
     daily: sortedDailyItems,
     search: sortedSearchItems,
+    fact: sortedFactItems,
     graph: sortedGraphItems,
     potential: potentialObservations,
     contextual: contextualObservations

package/dist/cli/index.js

@@ -1,35 +1,42 @@
 import {
   registerCliCommands
-} from "../chunk-GAJV4IGR.js";
-import "../chunk-THRJVD4L.js";
+} from "../chunk-33VSQP4J.js";
+import "../chunk-Y6VJKXGL.js";
 import "../chunk-TIGW564L.js";
 import "../chunk-IVRIKYFE.js";
-import "../chunk-F2JEUD4J.js";
-import "../chunk-P5EPF6MB.js";
-import "../chunk-SJSFRIYS.js";
-import "../chunk-H34S76MB.js";
-import "../chunk-LNJA2UGL.js";
-import "../chunk-3NSBOUT3.js";
-import "../chunk-62YTUT6J.js";
+import "../chunk-GGA32J2R.js";
+import "../chunk-VSL7KY3M.js";
+import "../chunk-QVEERJSP.js";
+import "../chunk-4BQTQMJP.js";
+import "../chunk-MM6QGW3P.js";
+import "../chunk-WMGIIABP.js";
+import "../chunk-23YDQ3QU.js";
+import "../chunk-MW5C6ZQA.js";
+import "../chunk-SLXOR3CC.js";
+import "../chunk-ESVS6K2B.js";
+import "../chunk-ZN54U2OZ.js";
+import "../chunk-ESFLMDRB.js";
 import "../chunk-HRLWZGMA.js";
-import "../chunk-7R7O6STJ.js";
-import "../chunk-U55BGUAU.js";
-import "../chunk-E7MFQB6D.js";
-import "../chunk-ITPEXLHA.js";
-import "../chunk-PAH27GSN.js";
-import "../chunk-MQUJNOHK.js";
-import "../chunk-MXSSG3QU.js";
-import "../chunk-N2AXRYLC.js";
-import "../chunk-LYHGEHXG.js";
-import "../chunk-7766SIJP.js";
-import "../chunk-ZVVFWOLW.js";
-import "../chunk-WGRQ6HDV.js";
-import "../chunk-K234IDRJ.js";
+import "../chunk-77Q5CSPJ.js";
+import "../chunk-4PY655YM.js";
+import "../chunk-CLJTREDS.js";
+import "../chunk-BSJ6RIT7.js";
+import "../chunk-FHFUXL6G.js";
+import "../chunk-PBACDKKP.js";
+import "../chunk-6FH3IULF.js";
+import "../chunk-EK6S23ZB.js";
+import "../chunk-W4SPAEE7.js";
+import "../chunk-URXDAUVH.js";
+import "../chunk-NCKFNBHJ.js";
 import "../chunk-2CDEETQN.js";
-import "../chunk-ZZA73MFY.js";
-import "../chunk-QK3UCXWL.js";
+import "../chunk-MQUJNOHK.js";
+import "../chunk-GNJL4YGR.js";
+import "../chunk-33DOSHTA.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
+import "../chunk-7766SIJP.js";
+import "../chunk-2ZDO52B4.js";
 export {
   registerCliCommands
 };

package/dist/commands/archive.js

@@ -1,11 +1,11 @@
 import {
   archiveCommand,
   registerArchiveCommand
-} from "../chunk-VR5NE7PZ.js";
+} from "../chunk-2RAZ4ZFE.js";
 import "../chunk-MQUJNOHK.js";
-import "../chunk-MXSSG3QU.js";
+import "../chunk-GNJL4YGR.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   archiveCommand,
   registerArchiveCommand

package/dist/commands/backlog.js

@@ -2,10 +2,10 @@ import {
   createBacklogItem,
   listBacklogItems,
   promoteBacklogItem
-} from "../chunk-N2AXRYLC.js";
-import "../chunk-LYHGEHXG.js";
+} from "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 
 // src/commands/backlog.ts
 function toDateStr(val) {

package/dist/commands/blocked.js

@@ -1,9 +1,9 @@
 import {
   getBlockedTasks
-} from "../chunk-N2AXRYLC.js";
-import "../chunk-LYHGEHXG.js";
+} from "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 
 // src/commands/blocked.ts
 function toDateStr(val) {

package/dist/commands/canvas.d.ts

@@ -0,0 +1,15 @@
+import { Canvas } from '../lib/canvas-layout.js';
+
+interface CanvasOptions {
+    output?: string;
+}
+/**
+ * Generate the vault status canvas.
+ */
+declare function generateCanvas(vaultPath: string): Canvas;
+/**
+ * Canvas command handler for CLI.
+ */
+declare function canvasCommand(vaultPath: string, options?: CanvasOptions): Promise<void>;
+
+export { type CanvasOptions, canvasCommand, generateCanvas };

package/dist/commands/canvas.js

@@ -0,0 +1,200 @@
+import {
+  CANVAS_COLORS,
+  LAYOUT,
+  createGroupWithNodes,
+  createTextNode,
+  flattenGroups,
+  positionGroupsVertically,
+  truncateText
+} from "../chunk-MDIH26GC.js";
+import {
+  loadMemoryGraphIndex
+} from "../chunk-33DOSHTA.js";
+import {
+  listObservationFiles
+} from "../chunk-Z2XBWN7A.js";
+import {
+  listTasks
+} from "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
+import "../chunk-7766SIJP.js";
+import "../chunk-2ZDO52B4.js";
+
+// src/commands/canvas.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/lib/canvas-default-template.ts
+import * as fs from "fs";
+import * as path from "path";
+var STATUS_ORDER = ["in-progress", "open", "blocked", "done"];
+var STATUS_LABELS = {
+  "in-progress": "In Progress",
+  open: "Open",
+  blocked: "Blocked",
+  done: "Done"
+};
+var STATUS_COLORS = {
+  "in-progress": CANVAS_COLORS.ORANGE,
+  open: void 0,
+  blocked: CANVAS_COLORS.RED,
+  done: CANVAS_COLORS.GREEN
+};
+function groupTasksByStatus(tasks) {
+  const grouped = {
+    open: [],
+    "in-progress": [],
+    blocked: [],
+    done: []
+  };
+  for (const task of tasks) {
+    grouped[task.frontmatter.status].push(task);
+  }
+  return grouped;
+}
+function readObservationTitle(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const headingMatch = content.match(/^#\s+(.+)$/m);
+    if (headingMatch?.[1]) {
+      return truncateText(headingMatch[1].trim(), 44);
+    }
+    const firstBodyLine = content.split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0 && line !== "---" && !line.includes(":"));
+    return firstBodyLine ? truncateText(firstBodyLine, 44) : null;
+  } catch {
+    return null;
+  }
+}
+function buildTaskStatusGroup(tasks) {
+  const grouped = groupTasksByStatus(tasks);
+  const summaryLines = STATUS_ORDER.map((status) => `${STATUS_LABELS[status]}: ${grouped[status].length}`);
+  const childNodes = [
+    createTextNode(
+      0,
+      0,
+      LAYOUT.DEFAULT_NODE_WIDTH,
+      LAYOUT.SMALL_NODE_HEIGHT + 24,
+      `**Tasks by Status**
+
+Total: ${tasks.length}
+${summaryLines.join("\n")}`
+    )
+  ];
+  for (const status of STATUS_ORDER) {
+    const bucket = grouped[status];
+    const lines = bucket.length === 0 ? ["- none"] : bucket.slice(0, 6).map((task) => `- ${truncateText(task.title, 42)}`);
+    if (bucket.length > 6) {
+      lines.push(`- ... and ${bucket.length - 6} more`);
+    }
+    childNodes.push(
+      createTextNode(
+        0,
+        0,
+        LAYOUT.DEFAULT_NODE_WIDTH,
+        LAYOUT.SMALL_NODE_HEIGHT + lines.length * 18,
+        `**${STATUS_LABELS[status]} (${bucket.length})**
+
+${lines.join("\n")}`,
+        STATUS_COLORS[status]
+      )
+    );
+  }
+  return createGroupWithNodes(
+    LAYOUT.LEFT_COLUMN_X,
+    0,
+    LAYOUT.LEFT_COLUMN_WIDTH,
+    "Vault Status",
+    childNodes,
+    CANVAS_COLORS.CYAN
+  );
+}
+function buildRecentObservationsGroup(vaultPath) {
+  const observations = listObservationFiles(vaultPath, { includeLegacy: true, includeArchive: false });
+  const recent = observations.slice(-8).reverse();
+  const lines = recent.length === 0 ? ["- none"] : recent.map((entry) => {
+    const title = readObservationTitle(entry.path);
+    return title ? `- ${entry.date}: ${title}` : `- ${entry.date}`;
+  });
+  const text = [
+    "**Recent Observations**",
+    "",
+    `Total days: ${observations.length}`,
+    "",
+    ...lines
+  ].join("\n");
+  return createGroupWithNodes(
+    LAYOUT.LEFT_COLUMN_X,
+    0,
+    LAYOUT.LEFT_COLUMN_WIDTH,
+    "Recent Observations",
+    [createTextNode(0, 0, LAYOUT.DEFAULT_NODE_WIDTH, LAYOUT.DEFAULT_NODE_HEIGHT + lines.length * 18, text)],
+    CANVAS_COLORS.CYAN
+  );
+}
+function buildGraphStatsGroup(vaultPath) {
+  const graph = loadMemoryGraphIndex(vaultPath)?.graph;
+  const textLines = ["**Graph Stats**", ""];
+  if (!graph) {
+    textLines.push("Graph index not found.");
+    textLines.push("Run `clawvault graph --build` to populate it.");
+  } else {
+    textLines.push(`Nodes: ${graph.stats.nodeCount}`);
+    textLines.push(`Edges: ${graph.stats.edgeCount}`);
+    textLines.push("");
+    textLines.push("Node types:");
+    const nodeTypeLines = Object.entries(graph.stats.nodeTypeCounts).sort((left, right) => right[1] - left[1]).slice(0, 6).map(([type, count]) => `- ${type}: ${count}`);
+    textLines.push(...nodeTypeLines.length > 0 ? nodeTypeLines : ["- none"]);
+  }
+  return createGroupWithNodes(
+    LAYOUT.LEFT_COLUMN_X,
+    0,
+    LAYOUT.LEFT_COLUMN_WIDTH,
+    "Graph Stats",
+    [
+      createTextNode(
+        0,
+        0,
+        LAYOUT.DEFAULT_NODE_WIDTH,
+        LAYOUT.DEFAULT_NODE_HEIGHT + (textLines.length - 1) * 16,
+        textLines.join("\n")
+      )
+    ],
+    CANVAS_COLORS.PURPLE
+  );
+}
+function generateDefaultCanvas(vaultPath) {
+  const resolvedPath = path.resolve(vaultPath);
+  const tasks = listTasks(resolvedPath);
+  const groups = positionGroupsVertically([
+    buildTaskStatusGroup(tasks),
+    buildRecentObservationsGroup(resolvedPath),
+    buildGraphStatsGroup(resolvedPath)
+  ]);
+  return {
+    nodes: flattenGroups(groups),
+    edges: []
+  };
+}
+
+// src/lib/canvas-templates.ts
+function generateCanvas(vaultPath) {
+  return generateDefaultCanvas(vaultPath);
+}
+
+// src/commands/canvas.ts
+function generateCanvas2(vaultPath) {
+  return generateCanvas(path2.resolve(vaultPath));
+}
+async function canvasCommand(vaultPath, options = {}) {
+  const resolvedPath = path2.resolve(vaultPath);
+  const outputPath = options.output || path2.join(resolvedPath, "dashboard.canvas");
+  const canvas = generateCanvas(resolvedPath);
+  fs2.writeFileSync(outputPath, JSON.stringify(canvas, null, 2));
+  console.log(`\u2713 Generated canvas: ${outputPath}`);
+  console.log(`  Nodes: ${canvas.nodes.length}`);
+  console.log(`  Edges: ${canvas.edges.length}`);
+}
+export {
+  canvasCommand,
+  generateCanvas2 as generateCanvas
+};

package/dist/commands/checkpoint.js

@@ -5,8 +5,8 @@ import {
   clearDirtyFlag,
   flush,
   setSessionState
-} from "../chunk-WAZ3NLWL.js";
-import "../chunk-3RG5ZIWI.js";
+} from "../chunk-F55HGNU4.js";
+import "../chunk-2ZDO52B4.js";
 export {
   checkDirtyDeath,
   checkpoint,

package/dist/commands/compat.js

@@ -2,8 +2,8 @@ import {
   checkOpenClawCompatibility,
   compatCommand,
   compatibilityExitCode
-} from "../chunk-3D6BCTP6.js";
-import "../chunk-3RG5ZIWI.js";
+} from "../chunk-X3SPPUFG.js";
+import "../chunk-2ZDO52B4.js";
 export {
   checkOpenClawCompatibility,
   compatCommand,