clawvault 2.4.5 → 2.4.7

package/bin/register-task-commands.js

@@ -3,6 +3,20 @@
  * Registers task, backlog, blocked, and canvas commands
  */
 
+function parseCsvList(value) {
+  if (!value) return undefined;
+  const items = String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
+function clearableValue(value, shouldClear) {
+  if (shouldClear) return null;
+  return value;
+}
+
 export function registerTaskCommands(
   program,
   { chalk, resolveVaultPath }
@@ -21,6 +35,11 @@ export function registerTaskCommands(
     .option('--project <project>', 'Project name')
     .option('--priority <priority>', 'Priority (critical, high, medium, low)')
     .option('--due <date>', 'Due date (YYYY-MM-DD)')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--description <description>', 'One-line task summary')
+    .option('--estimate <estimate>', 'Estimate (for example: 2h, 1d, 1w)')
+    .option('--parent <slug>', 'Parent task slug')
+    .option('--depends-on <slugs>', 'Comma-separated dependency slugs')
     .action(async (title, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
@@ -31,7 +50,12 @@ export function registerTaskCommands(
             owner: options.owner,
             project: options.project,
             priority: options.priority,
-            due: options.due
+            due: options.due,
+            tags: parseCsvList(options.tags),
+            description: options.description,
+            estimate: options.estimate,
+            parent: options.parent,
+            dependsOn: parseCsvList(options.dependsOn)
           }
         });
       } catch (err) {
@@ -49,6 +73,9 @@ export function registerTaskCommands(
     .option('--project <project>', 'Filter by project')
     .option('--status <status>', 'Filter by status (open, in-progress, blocked, done)')
     .option('--priority <priority>', 'Filter by priority')
+    .option('--due', 'Show only tasks with due dates (sorted by due date)')
+    .option('--tag <tag>', 'Filter by tag')
+    .option('--overdue', 'Show overdue tasks that are not done')
     .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
@@ -60,6 +87,9 @@ export function registerTaskCommands(
             project: options.project,
             status: options.status,
             priority: options.priority,
+            due: options.due,
+            tag: options.tag,
+            overdue: options.overdue,
             json: options.json
           }
         });
@@ -76,12 +106,28 @@ export function registerTaskCommands(
     .option('-v, --vault <path>', 'Vault path')
     .option('--status <status>', 'New status')
     .option('--owner <owner>', 'New owner')
+    .option('--clear-owner', 'Clear owner')
     .option('--project <project>', 'New project')
+    .option('--clear-project', 'Clear project')
     .option('--priority <priority>', 'New priority')
+    .option('--clear-priority', 'Clear priority')
     .option('--blocked-by <blocker>', 'What is blocking this task')
+    .option('--clear-blocked-by', 'Clear blocked-by field')
     .option('--due <date>', 'New due date')
+    .option('--clear-due', 'Clear due date')
+    .option('--tags <tags>', 'Comma-separated tags')
+    .option('--clear-tags', 'Clear tags')
+    .option('--description <description>', 'One-line task summary')
+    .option('--clear-description', 'Clear description')
+    .option('--estimate <estimate>', 'Estimate (for example: 2h, 1d, 1w)')
+    .option('--clear-estimate', 'Clear estimate')
+    .option('--parent <slug>', 'Parent task slug')
+    .option('--clear-parent', 'Clear parent task')
+    .option('--depends-on <slugs>', 'Comma-separated dependency slugs')
+    .option('--clear-depends-on', 'Clear dependencies')
     .option('--confidence <value>', 'Transition confidence (0-1)', parseFloat)
     .option('--reason <reason>', 'Reason for status change')
+    .option('--clear-reason', 'Clear reason')
     .action(async (slug, options) => {
       try {
         const vaultPath = resolveVaultPath(options.vault);
@@ -90,13 +136,18 @@ export function registerTaskCommands(
           slug,
           options: {
             status: options.status,
-            owner: options.owner,
-            project: options.project,
-            priority: options.priority,
-            blockedBy: options.blockedBy,
-            due: options.due,
+            owner: clearableValue(options.owner, options.clearOwner),
+            project: clearableValue(options.project, options.clearProject),
+            priority: clearableValue(options.priority, options.clearPriority),
+            blockedBy: clearableValue(options.blockedBy, options.clearBlockedBy),
+            due: clearableValue(options.due, options.clearDue),
+            tags: options.clearTags ? null : parseCsvList(options.tags),
+            description: clearableValue(options.description, options.clearDescription),
+            estimate: clearableValue(options.estimate, options.clearEstimate),
+            parent: clearableValue(options.parent, options.clearParent),
+            dependsOn: options.clearDependsOn ? null : parseCsvList(options.dependsOn),
             confidence: options.confidence,
-            reason: options.reason
+            reason: clearableValue(options.reason, options.clearReason)
           }
         });
       } catch (err) {
@@ -282,28 +333,12 @@ export function registerTaskCommands(
     .description('Generate Obsidian canvas dashboard')
     .option('-v, --vault <path>', 'Vault path')
     .option('--output <path>', 'Output file path (default: dashboard.canvas)')
-    .option('--template <id>', 'Canvas template ID (default, project-board, brain, sprint)')
-    .option('--project <project>', 'Project filter for template-aware canvases')
-    .option('--owner <owner>', 'Filter tasks by owner (agent name or human)')
-    .option('--width <pixels>', 'Canvas width in pixels', parseInt)
-    .option('--height <pixels>', 'Canvas height in pixels', parseInt)
-    .option('--include-done', 'Include completed tasks (default: limited)')
-    .option('--list-templates', 'List available canvas templates and exit')
     .action(async (options) => {
       try {
-        const vaultPath = options.listTemplates
-          ? (options.vault || '.')
-          : resolveVaultPath(options.vault);
+        const vaultPath = resolveVaultPath(options.vault);
         const { canvasCommand } = await import('../dist/commands/canvas.js');
         await canvasCommand(vaultPath, {
-          output: options.output,
-          template: options.template,
-          project: options.project,
-          owner: options.owner,
-          width: options.width,
-          height: options.height,
-          includeDone: options.includeDone,
-          listTemplates: options.listTemplates
+          output: options.output
         });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));

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

@@ -4,7 +4,53 @@ import { registerTaskCommands } from './register-task-commands.js';
 import { chalkStub, stubResolveVaultPath } from './test-helpers/cli-command-fixtures.js';
 
 describe('register-task-commands', () => {
-  it('adds canvas template and listing flags', () => {
+  it('adds enriched task add/list/update options', () => {
+    const program = new Command();
+    registerTaskCommands(program, {
+      chalk: chalkStub,
+      resolveVaultPath: stubResolveVaultPath
+    });
+
+    const taskCommand = program.commands.find((command) => command.name() === 'task');
+    expect(taskCommand).toBeDefined();
+
+    const addCommand = taskCommand?.commands.find((command) => command.name() === 'add');
+    const addFlags = addCommand?.options.map((option) => option.flags) ?? [];
+    expect(addFlags).toEqual(expect.arrayContaining([
+      '--due <date>',
+      '--tags <tags>',
+      '--description <description>',
+      '--estimate <estimate>',
+      '--parent <slug>',
+      '--depends-on <slugs>'
+    ]));
+
+    const listCommand = taskCommand?.commands.find((command) => command.name() === 'list');
+    const listFlags = listCommand?.options.map((option) => option.flags) ?? [];
+    expect(listFlags).toEqual(expect.arrayContaining([
+      '--due',
+      '--tag <tag>',
+      '--overdue'
+    ]));
+
+    const updateCommand = taskCommand?.commands.find((command) => command.name() === 'update');
+    const updateFlags = updateCommand?.options.map((option) => option.flags) ?? [];
+    expect(updateFlags).toEqual(expect.arrayContaining([
+      '--tags <tags>',
+      '--description <description>',
+      '--estimate <estimate>',
+      '--parent <slug>',
+      '--depends-on <slugs>',
+      '--clear-due',
+      '--clear-tags',
+      '--clear-description',
+      '--clear-estimate',
+      '--clear-parent',
+      '--clear-depends-on'
+    ]));
+  });
+
+  it('adds simplified canvas flags', () => {
     const program = new Command();
     registerTaskCommands(program, {
       chalk: chalkStub,
@@ -16,9 +62,8 @@ describe('register-task-commands', () => {
 
     const optionFlags = canvasCommand?.options.map((option) => option.flags) ?? [];
     expect(optionFlags).toEqual(expect.arrayContaining([
-      '--template <id>',
-      '--list-templates',
-      '--project <project>'
+      '-v, --vault <path>',
+      '--output <path>'
     ]));
   });
 });

package/bin/test-helpers/cli-command-fixtures.js

@@ -10,6 +10,9 @@ import { registerTemplateCommands } from '../register-template-commands.js';
 import { registerVaultOperationsCommands } from '../register-vault-operations-commands.js';
 import { registerConfigCommands } from '../register-config-commands.js';
 import { registerRouteCommands } from '../register-route-commands.js';
+import { registerTaskCommands } from '../register-task-commands.js';
+import { registerKanbanCommands } from '../register-kanban-commands.js';
+import { registerProjectCommands } from '../register-project-commands.js';
 
 export const chalkStub = {
   cyan: (value) => value,
@@ -99,6 +102,18 @@ export function registerAllCommandModules(program = new Command()) {
     chalk: chalkStub,
     resolveVaultPath: stubResolveVaultPath
   });
+  registerTaskCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerKanbanCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
+  registerProjectCommands(program, {
+    chalk: chalkStub,
+    resolveVaultPath: stubResolveVaultPath
+  });
 
   return program;
 }

package/dist/{chunk-3PJIGGWV.js → chunk-2CDEETQN.js}

@@ -1,5 +1,6 @@
 // src/types.ts
 var DEFAULT_CATEGORIES = [
+  "rules",
   "preferences",
   "decisions",
   "patterns",

package/dist/{chunk-B3SMJZIZ.js → chunk-2RK2AG32.js}

@@ -1,18 +1,18 @@
-import {
-  getSessionsDir
-} from "./chunk-HRLWZGMA.js";
 import {
   parseSessionFile
 } from "./chunk-P5EPF6MB.js";
 import {
   Observer
-} from "./chunk-RXEIQ3KQ.js";
+} from "./chunk-TMZMN7OS.js";
+import {
+  getSessionsDir
+} from "./chunk-HRLWZGMA.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";
 import {
   getObservationPath
-} from "./chunk-NAMFB7ZA.js";
+} from "./chunk-Z2XBWN7A.js";
 
 // src/commands/observe.ts
 import * as fs3 from "fs";

package/dist/chunk-5GZFTAL7.js

@@ -0,0 +1,340 @@
+import {
+  listTasks,
+  slugify
+} from "./chunk-IOALNTAN.js";
+
+// src/lib/project-utils.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+function extractTitle(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 path.join(path.resolve(vaultPath), "projects");
+}
+function ensureProjectsDir(vaultPath) {
+  const projectsDir = getProjectsDir(vaultPath);
+  if (!fs.existsSync(projectsDir)) {
+    fs.mkdirSync(projectsDir, { recursive: true });
+  }
+}
+function getProjectPath(vaultPath, slug) {
+  return path.join(getProjectsDir(vaultPath), `${slug}.md`);
+}
+function parseProjectDateValue(filePath) {
+  const filename = path.basename(filePath, ".md");
+  if (/^\d{4}-\d{2}-\d{2}$/.test(filename)) {
+    const dateTs = Date.parse(`${filename}T00:00:00.000Z`);
+    if (!Number.isNaN(dateTs)) {
+      return dateTs;
+    }
+  }
+  return fs.statSync(filePath).mtime.getTime();
+}
+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 (!fs.existsSync(projectsDir)) {
+    return [];
+  }
+  const projects = [];
+  const entries = fs.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(path.sep)) {
+    return null;
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (!fs.existsSync(projectPath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(projectPath, "utf-8");
+    const { data, content } = matter(raw);
+    if (data.type !== "project") {
+      return null;
+    }
+    const frontmatter = normalizeProjectFrontmatter(data);
+    const title = extractTitle(content) || slug;
+    return {
+      slug,
+      title,
+      content,
+      frontmatter
+    };
+  } catch {
+    return null;
+  }
+}
+function createProject(vaultPath, title, options = {}) {
+  ensureProjectsDir(vaultPath);
+  const slug = slugify(title);
+  const projectPath = getProjectPath(vaultPath, slug);
+  if (fs.existsSync(projectPath)) {
+    throw new Error(`Project already exists: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    type: "project",
+    status: options.status ?? "active",
+    created: now,
+    updated: now
+  };
+  if (options.owner) frontmatter.owner = options.owner;
+  if (options.team && options.team.length > 0) {
+    const team = normalizeStringArray(options.team);
+    if (team.length > 0) frontmatter.team = team;
+  }
+  if (options.client) frontmatter.client = options.client;
+  if (options.tags && options.tags.length > 0) {
+    const tags = normalizeStringArray(options.tags);
+    if (tags.length > 0) frontmatter.tags = tags;
+  }
+  if (options.description) frontmatter.description = options.description;
+  if (options.started) frontmatter.started = options.started;
+  if (options.deadline) frontmatter.deadline = options.deadline;
+  if (options.repo) frontmatter.repo = options.repo;
+  if (options.url) frontmatter.url = options.url;
+  if (options.completed) frontmatter.completed = options.completed;
+  if (options.reason) frontmatter.reason = options.reason;
+  let content = `# ${title}
+`;
+  const wikiLinks = /* @__PURE__ */ new Set();
+  if (options.owner) wikiLinks.add(options.owner);
+  if (options.client) wikiLinks.add(options.client);
+  for (const member of options.team || []) {
+    const trimmed = member.trim();
+    if (trimmed) wikiLinks.add(trimmed);
+  }
+  if (wikiLinks.size > 0) {
+    content += `
+${Array.from(wikiLinks).map((link) => `[[${link}]]`).join(" | ")}
+`;
+  }
+  if (options.content) {
+    content += `
+${options.content}
+`;
+  }
+  const fileContent = matter.stringify(content, frontmatter);
+  fs.writeFileSync(projectPath, fileContent);
+  return {
+    slug,
+    title,
+    content,
+    frontmatter
+  };
+}
+function updateProject(vaultPath, slug, updates) {
+  const project = readProject(vaultPath, slug);
+  if (!project) {
+    throw new Error(`Project not found: ${slug}`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const nextFrontmatter = {
+    ...project.frontmatter,
+    type: "project",
+    updated: now
+  };
+  if (updates.status !== void 0) {
+    nextFrontmatter.status = updates.status;
+    if (updates.status === "completed" && !updates.completed && !nextFrontmatter.completed) {
+      nextFrontmatter.completed = now;
+    }
+  }
+  if (updates.owner !== void 0) {
+    if (updates.owner === null || updates.owner.trim() === "") {
+      delete nextFrontmatter.owner;
+    } else {
+      nextFrontmatter.owner = updates.owner;
+    }
+  }
+  if (updates.team !== void 0) {
+    if (updates.team === null) {
+      delete nextFrontmatter.team;
+    } else {
+      const team = normalizeStringArray(updates.team);
+      if (team.length === 0) {
+        delete nextFrontmatter.team;
+      } else {
+        nextFrontmatter.team = team;
+      }
+    }
+  }
+  if (updates.client !== void 0) {
+    if (updates.client === null || updates.client.trim() === "") {
+      delete nextFrontmatter.client;
+    } else {
+      nextFrontmatter.client = updates.client;
+    }
+  }
+  if (updates.tags !== void 0) {
+    if (updates.tags === null) {
+      delete nextFrontmatter.tags;
+    } else {
+      const tags = normalizeStringArray(updates.tags);
+      if (tags.length === 0) {
+        delete nextFrontmatter.tags;
+      } else {
+        nextFrontmatter.tags = tags;
+      }
+    }
+  }
+  if (updates.description !== void 0) {
+    if (updates.description === null || updates.description.trim() === "") {
+      delete nextFrontmatter.description;
+    } else {
+      nextFrontmatter.description = updates.description;
+    }
+  }
+  if (updates.started !== void 0) {
+    if (updates.started === null || updates.started.trim() === "") {
+      delete nextFrontmatter.started;
+    } else {
+      nextFrontmatter.started = updates.started;
+    }
+  }
+  if (updates.deadline !== void 0) {
+    if (updates.deadline === null || updates.deadline.trim() === "") {
+      delete nextFrontmatter.deadline;
+    } else {
+      nextFrontmatter.deadline = updates.deadline;
+    }
+  }
+  if (updates.repo !== void 0) {
+    if (updates.repo === null || updates.repo.trim() === "") {
+      delete nextFrontmatter.repo;
+    } else {
+      nextFrontmatter.repo = updates.repo;
+    }
+  }
+  if (updates.url !== void 0) {
+    if (updates.url === null || updates.url.trim() === "") {
+      delete nextFrontmatter.url;
+    } else {
+      nextFrontmatter.url = updates.url;
+    }
+  }
+  if (updates.completed !== void 0) {
+    if (updates.completed === null || updates.completed.trim() === "") {
+      delete nextFrontmatter.completed;
+    } else {
+      nextFrontmatter.completed = updates.completed;
+    }
+  }
+  if (updates.reason !== void 0) {
+    if (updates.reason === null || updates.reason.trim() === "") {
+      delete nextFrontmatter.reason;
+    } else {
+      nextFrontmatter.reason = updates.reason;
+    }
+  }
+  const projectPath = getProjectPath(vaultPath, slug);
+  fs.writeFileSync(projectPath, matter.stringify(project.content, nextFrontmatter));
+  return {
+    ...project,
+    frontmatter: nextFrontmatter
+  };
+}
+function archiveProject(vaultPath, slug, reason) {
+  return updateProject(vaultPath, slug, {
+    status: "archived",
+    reason: reason ?? null,
+    completed: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function getProjectTasks(vaultPath, slug) {
+  return listTasks(vaultPath, { project: slug });
+}
+function getProjectActivity(vaultPath, slug) {
+  const projectActivityDir = path.join(getProjectsDir(vaultPath), slug);
+  if (!fs.existsSync(projectActivityDir) || !fs.statSync(projectActivityDir).isDirectory()) {
+    return [];
+  }
+  const entries = fs.readdirSync(projectActivityDir, { withFileTypes: true });
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => path.join(projectActivityDir, entry.name));
+  return files.sort((left, right) => parseProjectDateValue(right) - parseProjectDateValue(left));
+}
+
+export {
+  listProjects,
+  readProject,
+  createProject,
+  updateProject,
+  archiveProject,
+  getProjectTasks,
+  getProjectActivity
+};

package/dist/{chunk-YIRWDQKA.js → chunk-6RQPD7X6.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6B3JWM7J.js";
 import {
   DEFAULT_CATEGORIES
-} from "./chunk-3PJIGGWV.js";
+} from "./chunk-2CDEETQN.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";
@@ -327,10 +327,9 @@ async function setupCommand(options = {}) {
     }
   }
   if (doCanvas) {
-    const templateId = typeof options.canvas === "string" ? options.canvas : "default";
     try {
       const { canvasCommand } = await import("./commands/canvas.js");
-      await canvasCommand(target.vaultPath, { template: templateId });
+      await canvasCommand(target.vaultPath);
     } catch (err) {
       console.log(`\u26A0 Canvas generation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -353,7 +352,7 @@ async function setupCommand(options = {}) {
   console.log("\nCustomize further:");
   console.log("  clawvault setup --theme neural     # Neural neural graph colors");
   console.log("  clawvault setup --theme minimal        # Subtle category colors");
-  console.log("  clawvault setup --canvas brain          # Generate brain architecture canvas");
+  console.log("  clawvault setup --canvas                # Generate vault status canvas");
   console.log("  clawvault setup --no-bases --no-graph-colors  # Structure only");
   console.log("  clawvault setup --force                 # Overwrite existing configs");
 }

package/dist/{chunk-HNMFXFYP.js → chunk-7OHQFMJK.js}

@@ -10,7 +10,7 @@ import {
 import {
   DEFAULT_CATEGORIES,
   TYPE_TO_CATEGORY
-} from "./chunk-3PJIGGWV.js";
+} from "./chunk-2CDEETQN.js";
 import {
   buildOrUpdateMemoryGraphIndex
 } from "./chunk-ZZA73MFY.js";
@@ -851,6 +851,7 @@ clawvault wake                        # restore context on startup
       facts: "Raw information, data points, things that are true",
       feelings: "Emotional states, reactions, energy levels",
       decisions: "Choices made with context and reasoning",
+      rules: "Injectable operational constraints, guardrails, and runbooks",
       lessons: "What I learned, insights, patterns observed",
       commitments: "Promises, goals, obligations to fulfill",
       preferences: "Likes, dislikes, how I want things",

package/dist/{chunk-4JJL47IJ.js → chunk-C3PF7WBA.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-AHGUJG76.js";
+} from "./chunk-KCCHROBR.js";
 import {
   Observer
-} from "./chunk-RXEIQ3KQ.js";
+} from "./chunk-TMZMN7OS.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-JXY6T5R7.js → chunk-FW465EEA.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-FHFUXL6G.js";
 import {
   listObservationFiles
-} from "./chunk-NAMFB7ZA.js";
+} from "./chunk-Z2XBWN7A.js";
 
 // src/commands/migrate-observations.ts
 import * as fs from "fs";