clawvault 2.3.1 → 2.4.0

package/bin/register-core-commands.js

@@ -13,6 +13,13 @@ export function registerCoreCommands(
     .option('-n, --name <name>', 'Vault name')
     .option('--qmd', 'Set up qmd semantic search collection')
     .option('--qmd-collection <name>', 'qmd collection name (defaults to vault name)')
+    .option('--no-bases', 'Skip Obsidian Bases file generation')
+    .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 <template>', 'Generate a canvas dashboard on init (default, brain, project-board, sprint)')
+    .option('--theme <style>', 'Graph color theme to apply (neural, minimal, none)', 'none')
+    .option('--minimal', 'Create minimal vault (memory categories only, no tasks/bases/graph)')
     .action(async (vaultPath, options) => {
       const targetPath = vaultPath || '.';
       console.log(chalk.cyan(`\n🐘 Initializing ClawVault at ${path.resolve(targetPath)}...\n`));
@@ -67,10 +74,26 @@ export function registerCoreCommands(
   program
     .command('setup')
     .description('Auto-discover and configure a ClawVault')
-    .action(async () => {
+    .option('--graph-colors', 'Set up graph color scheme for Obsidian')
+    .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 [template]', 'Generate canvas dashboard (default, brain, project-board, sprint)')
+    .option('--no-canvas', 'Skip canvas generation')
+    .option('--theme <style>', 'Graph color theme (neural, minimal, none)', 'neural')
+    .option('--force', 'Overwrite existing configuration files')
+    .option('-v, --vault <path>', 'Vault path')
+    .action(async (options) => {
       try {
         const { setupCommand } = await import('../dist/commands/setup.js');
-        await setupCommand();
+        await setupCommand({
+          graphColors: options.graphColors,
+          bases: options.bases,
+          canvas: options.canvas,
+          theme: options.theme,
+          force: options.force,
+          vault: options.vault
+        });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));
         process.exit(1);

package/bin/register-task-commands.js

@@ -242,12 +242,28 @@ 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 = resolveVaultPath(options.vault);
+        const vaultPath = options.listTemplates
+          ? (options.vault || '.')
+          : resolveVaultPath(options.vault);
         const { canvasCommand } = await import('../dist/commands/canvas.js');
         await canvasCommand(vaultPath, {
-          output: options.output
+          output: options.output,
+          template: options.template,
+          project: options.project,
+          owner: options.owner,
+          width: options.width,
+          height: options.height,
+          includeDone: options.includeDone,
+          listTemplates: options.listTemplates
         });
       } catch (err) {
         console.error(chalk.red(`Error: ${err.message}`));

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { Command } from 'commander';
+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', () => {
+    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([
+      '--template <id>',
+      '--list-templates',
+      '--project <project>'
+    ]));
+  });
+});

package/dist/{chunk-TB3BM2PQ.js → chunk-33GW63WK.js}

@@ -1,48 +1,17 @@
 import {
   ClawVault
-} from "./chunk-OTQW3OMC.js";
+} from "./chunk-Q3WBH4P4.js";
 import {
-  parseObservationMarkdown
-} from "./chunk-K6XHCUFL.js";
+  parseObservationLines,
+  readObservations
+} from "./chunk-L3DJ36BZ.js";
 import {
   getMemoryGraph
 } from "./chunk-ZZA73MFY.js";
-import {
-  listObservationFiles
-} from "./chunk-NAMFB7ZA.js";
 
 // src/commands/context.ts
 import * as path from "path";
 
-// src/lib/observation-reader.ts
-import * as fs from "fs";
-function readObservations(vaultPath, days = 7) {
-  const normalizedDays = Number.isFinite(days) ? Math.max(0, Math.floor(days)) : 0;
-  if (normalizedDays === 0) {
-    return "";
-  }
-  const files = listObservationFiles(vaultPath, {
-    includeLegacy: true,
-    includeArchive: false,
-    dedupeByDate: true
-  }).sort((left, right) => right.date.localeCompare(left.date)).slice(0, normalizedDays);
-  if (files.length === 0) {
-    return "";
-  }
-  return files.map((entry) => fs.readFileSync(entry.path, "utf-8").trim()).filter(Boolean).join("\n\n").trim();
-}
-function parseObservationLines(markdown) {
-  return parseObservationMarkdown(markdown).map((record) => ({
-    type: record.type,
-    confidence: record.confidence,
-    importance: record.importance,
-    content: record.content,
-    date: record.date,
-    format: record.format,
-    priority: record.priority
-  }));
-}
-
 // src/lib/token-counter.ts
 function estimateTokens(text) {
   if (!text) {

package/dist/{chunk-JVAWKNIZ.js → chunk-AHGUJG76.js}

@@ -4,7 +4,7 @@ import {
 import {
   normalizeObservationContent,
   parseObservationMarkdown
-} from "./chunk-K6XHCUFL.js";
+} from "./chunk-FHFUXL6G.js";
 import {
   formatIsoWeekKey,
   getIsoWeek,

package/dist/{chunk-TT3FXYCN.js → chunk-BI6SGGZP.js}

@@ -1,6 +1,6 @@
 import {
   runReflection
-} from "./chunk-JVAWKNIZ.js";
+} from "./chunk-AHGUJG76.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-NGVAEFT2.js → chunk-DEFBIVQ3.js}

@@ -147,6 +147,7 @@ function createTask(vaultPath, title, options = {}) {
     created: now,
     updated: now
   };
+  if (options.source) frontmatter.source = options.source;
   if (options.owner) frontmatter.owner = options.owner;
   if (options.project) frontmatter.project = options.project;
   if (options.priority) frontmatter.priority = options.priority;
@@ -264,6 +265,25 @@ ${options.content}
     path: backlogPath
   };
 }
+function updateBacklogItem(vaultPath, slug, updates) {
+  const backlogItem = readBacklogItem(vaultPath, slug);
+  if (!backlogItem) {
+    throw new Error(`Backlog item not found: ${slug}`);
+  }
+  const newFrontmatter = {
+    ...backlogItem.frontmatter
+  };
+  if (updates.source !== void 0) newFrontmatter.source = updates.source;
+  if (updates.project !== void 0) newFrontmatter.project = updates.project;
+  if (updates.tags !== void 0) newFrontmatter.tags = updates.tags;
+  if (updates.lastSeen !== void 0) newFrontmatter.lastSeen = updates.lastSeen;
+  const fileContent = matter.stringify(backlogItem.content, newFrontmatter);
+  fs.writeFileSync(backlogItem.path, fileContent);
+  return {
+    ...backlogItem,
+    frontmatter: newFrontmatter
+  };
+}
 function promoteBacklogItem(vaultPath, slug, options = {}) {
   const backlogItem = readBacklogItem(vaultPath, slug);
   if (!backlogItem) {
@@ -343,6 +363,7 @@ export {
   updateTask,
   completeTask,
   createBacklogItem,
+  updateBacklogItem,
   promoteBacklogItem,
   getBlockedTasks,
   getActiveTasks,

package/dist/{chunk-USZU5CBB.js → chunk-DHJPXGC7.js}

@@ -1,6 +1,6 @@
 import {
   Observer
-} from "./chunk-2AYPFUGX.js";
+} from "./chunk-FEFPBHH4.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";

package/dist/{chunk-2AYPFUGX.js → chunk-FEFPBHH4.js}

@@ -1,3 +1,10 @@
+import {
+  createBacklogItem,
+  listBacklogItems,
+  listTasks,
+  updateBacklogItem,
+  updateTask
+} from "./chunk-DEFBIVQ3.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -6,7 +13,7 @@ import {
   parseObservationMarkdown,
   renderObservationMarkdown,
   renderScoredObservationLine
-} from "./chunk-K6XHCUFL.js";
+} from "./chunk-FHFUXL6G.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -20,6 +27,10 @@ import {
 var CRITICAL_RE = /(?:\b(?:decision|decided|chose|chosen|selected|picked|opted|switched to)\s*:?|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure|ing)?\b|\bblock(?:ed|er)?\b|\bbreaking(?:\s+change)?s?\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b|\bpublish(?:ed)?\b.*@?\d+\.\d+|\bmerge[d]?\s+(?:PR|pull\s+request)\b|\bshipped\b|\breleased?\b.*v?\d+\.\d+|\bsigned\b.*\b(?:contract|agreement|deal)\b|\bpricing\b.*\$|\bdemo\b.*\b(?:completed?|done|finished)\b|\bmeeting\b.*\b(?:completed?|done|finished)\b|\bstrategy\b.*\b(?:pivot|change|shift)\b)/i;
 var DEADLINE_WITH_DATE_RE = /(?:(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b).*(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2})|(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2}).*(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b))/i;
 var NOTABLE_RE = /\b(prefer(?:ence|s)?|likes?|dislikes?|context|pattern|architecture|approach|trade[- ]?off|milestone|stakeholder|teammate|collaborat(?:e|ed|ion)|discussion|notable|deadline|due|timeline|deploy(?:ed|ment)?|built|configured|launched|proposal|pitch|onboard(?:ed|ing)?|migrat(?:e|ed|ion)|domain|DNS|infra(?:structure)?)\b/i;
+var TODO_SIGNAL_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
+var COMMITMENT_TASK_SIGNAL_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
+var UNRESOLVED_COMMITMENT_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
+var DEADLINE_SIGNAL_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
 var Compressor = class {
   model;
   now;
@@ -70,13 +81,19 @@ var Compressor = class {
       "- Output markdown only.",
       "- Group observations by date heading: ## YYYY-MM-DD",
       "- Each observation line MUST follow: - [type|c=<0.00-1.00>|i=<0.00-1.00>] <observation>",
-      "- Allowed type tags: decision, preference, fact, commitment, milestone, lesson, relationship, project",
+      "- Allowed type tags: decision, preference, fact, commitment, task, todo, commitment-unresolved, milestone, lesson, relationship, project",
       "- i >= 0.80 for structural/persistent observations (major decisions, blockers, releases, commitments)",
       "- i 0.40-0.79 for potentially important observations (notable context, preferences, milestones)",
       "- i < 0.40 for contextual/routine observations",
       "- Confidence c reflects extraction certainty, not importance.",
       "- Preserve source tags when present (e.g., [main], [telegram-dm], [discord], [telegram-group]).",
       "",
+      "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".`,
+      '- Emit [commitment-unresolved] for unresolved commitments/questions: "need to figure out", "TBD", "to be determined".',
+      '- Deadline language ("by Friday", "before the demo", "deadline is") should increase importance and usually map to [task] unless unresolved.',
+      "",
       "QUALITY FILTERS (important):",
       "- DO NOT observe: CLI errors, command failures, tool output parsing issues, retry attempts, debug logs.",
       "  These are transient noise, not memories. Only observe errors if they represent a BLOCKER or an unresolved problem.",
@@ -236,6 +253,7 @@ ${cleaned}`;
     let importance = record.importance;
     let confidence = record.confidence;
     let type = record.type;
+    const inferredTaskType = this.inferTaskType(record.content);
     if (this.isCriticalContent(record.content)) {
       importance = Math.max(importance, 0.85);
       confidence = Math.max(confidence, 0.85);
@@ -246,6 +264,11 @@ ${cleaned}`;
       importance = Math.max(importance, 0.5);
       confidence = Math.max(confidence, 0.75);
     }
+    if (inferredTaskType) {
+      type = type === "fact" || type === "commitment" ? inferredTaskType : type;
+      importance = Math.max(importance, inferredTaskType === "commitment-unresolved" ? 0.72 : 0.65);
+      confidence = Math.max(confidence, 0.8);
+    }
     if (type === "decision" || type === "commitment" || type === "milestone") {
       importance = Math.max(importance, 0.6);
     }
@@ -340,16 +363,21 @@ ${cleaned}`;
     return renderObservationMarkdown(sections);
   }
   inferImportance(text, type) {
+    const inferredTaskType = this.inferTaskType(text);
     if (this.isCriticalContent(text)) return 0.9;
+    if (inferredTaskType === "commitment-unresolved") return 0.72;
+    if (inferredTaskType === "task" || inferredTaskType === "todo") return 0.65;
     if (this.isNotableContent(text)) return 0.6;
     if (type === "decision" || type === "commitment" || type === "milestone") return 0.55;
     if (type === "preference" || type === "lesson" || type === "relationship" || type === "project") return 0.45;
     return 0.2;
   }
   inferConfidence(text, type, importance) {
+    const inferredTaskType = this.inferTaskType(text);
     let confidence = 0.72;
     if (importance >= 0.8) confidence += 0.12;
     if (type === "decision" || type === "commitment" || type === "milestone") confidence += 0.06;
+    if (inferredTaskType) confidence += 0.06;
     if (/\b(?:decided|chose|committed|deadline|released|merged)\b/i.test(text)) {
       confidence += 0.05;
     }
@@ -361,6 +389,18 @@ ${cleaned}`;
   isNotableContent(text) {
     return NOTABLE_RE.test(text);
   }
+  inferTaskType(text) {
+    if (UNRESOLVED_COMMITMENT_RE.test(text)) {
+      return "commitment-unresolved";
+    }
+    if (TODO_SIGNAL_RE.test(text)) {
+      return "todo";
+    }
+    if (COMMITMENT_TASK_SIGNAL_RE.test(text) || DEADLINE_SIGNAL_RE.test(text)) {
+      return "task";
+    }
+    return null;
+  }
   normalizeText(text) {
     return text.replace(/\s+/g, " ").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").trim().slice(0, 280);
   }
@@ -557,6 +597,9 @@ var TYPE_TO_CATEGORY = {
   preference: "preferences",
   fact: "facts",
   commitment: "commitments",
+  task: "commitments",
+  todo: "commitments",
+  "commitment-unresolved": "commitments",
   milestone: "projects",
   lesson: "lessons",
   relationship: "people",
@@ -564,19 +607,35 @@ var TYPE_TO_CATEGORY = {
 };
 var Router = class {
   vaultPath;
-  constructor(vaultPath) {
+  extractTasks;
+  now;
+  constructor(vaultPath, options = {}) {
     this.vaultPath = path.resolve(vaultPath);
+    this.extractTasks = options.extractTasks ?? true;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
   }
   /**
    * Takes observation markdown and routes items to appropriate vault categories.
    * Routes only items with importance >= 0.4.
    * Returns a summary of what was routed where.
    */
-  route(observationMarkdown) {
+  route(observationMarkdown, context = {}) {
     const items = this.parseObservations(observationMarkdown);
     const routed = [];
+    const knownWorkItems = this.extractTasks ? this.loadExistingWorkItems() : [];
+    let dedupHits = 0;
     for (const item of items) {
       if (item.importance < 0.4) continue;
+      if (this.extractTasks && this.isTaskObservation(item.type)) {
+        const taskResult = this.routeTaskObservation(item, context, knownWorkItems);
+        if (taskResult.routedItem) {
+          routed.push(taskResult.routedItem);
+        }
+        if (taskResult.dedupHit) {
+          dedupHits += 1;
+        }
+        continue;
+      }
       const category = this.categorize(item.type, item.content);
       if (!category) continue;
       const routedItem = {
@@ -591,9 +650,202 @@ var Router = class {
       routed.push(routedItem);
       this.appendToCategory(category, routedItem);
     }
-    const summary = this.buildSummary(routed);
+    const summary = this.buildSummary(routed, dedupHits);
     return { routed, summary };
   }
+  isTaskObservation(type) {
+    return type === "task" || type === "todo" || type === "commitment-unresolved";
+  }
+  routeTaskObservation(item, context, knownWorkItems) {
+    const title = this.deriveTaskTitle(item.content, item.type);
+    if (!title) {
+      return { routedItem: null, dedupHit: false };
+    }
+    const duplicate = this.findDuplicateWorkItem(title, knownWorkItems);
+    if (duplicate) {
+      if (item.type === "commitment-unresolved" && this.isOpenWorkItem(duplicate)) {
+        this.touchExistingWorkItem(duplicate);
+      }
+      console.log(`[observer] dedup hit for task candidate: "${title}"`);
+      return { routedItem: null, dedupHit: true };
+    }
+    const tags = this.mergeTags(
+      ["open", "observer"],
+      item.type === "task" ? ["task"] : [],
+      item.type === "todo" ? ["todo"] : [],
+      item.type === "commitment-unresolved" ? ["commitment"] : []
+    );
+    const content = this.buildTaskContextContent(item, context);
+    let backlogItem;
+    try {
+      backlogItem = createBacklogItem(this.vaultPath, title, {
+        source: "observer",
+        content,
+        tags
+      });
+    } catch (error) {
+      if (error instanceof Error && /already exists/i.test(error.message)) {
+        console.log(`[observer] dedup hit for task candidate: "${title}"`);
+        return { routedItem: null, dedupHit: true };
+      }
+      throw error;
+    }
+    knownWorkItems.push({
+      kind: "backlog",
+      slug: backlogItem.slug,
+      title: backlogItem.title,
+      status: "open",
+      source: backlogItem.frontmatter.source,
+      tags: backlogItem.frontmatter.tags ?? []
+    });
+    return {
+      dedupHit: false,
+      routedItem: {
+        category: "backlog",
+        title: backlogItem.title,
+        content: item.content,
+        type: item.type,
+        confidence: item.confidence,
+        importance: item.importance,
+        date: item.date
+      }
+    };
+  }
+  loadExistingWorkItems() {
+    const taskItems = listTasks(this.vaultPath).map((task) => ({
+      kind: "task",
+      slug: task.slug,
+      title: task.title,
+      status: task.frontmatter.status,
+      source: task.frontmatter.source,
+      tags: task.frontmatter.tags ?? []
+    }));
+    const backlogItems = listBacklogItems(this.vaultPath).map((item) => ({
+      kind: "backlog",
+      slug: item.slug,
+      title: item.title,
+      status: item.frontmatter.tags?.includes("done") ? "done" : "open",
+      source: item.frontmatter.source,
+      tags: item.frontmatter.tags ?? []
+    }));
+    return [...taskItems, ...backlogItems];
+  }
+  findDuplicateWorkItem(title, knownWorkItems) {
+    const normalizedTitle = this.normalizeTaskTitle(title);
+    if (!normalizedTitle) {
+      return null;
+    }
+    for (const item of knownWorkItems) {
+      const normalizedExisting = this.normalizeTaskTitle(item.title);
+      if (!normalizedExisting) {
+        continue;
+      }
+      if (normalizedExisting === normalizedTitle) {
+        return item;
+      }
+      if (this.jaccardWordSimilarity(normalizedTitle, normalizedExisting) > 0.8) {
+        return item;
+      }
+    }
+    return null;
+  }
+  normalizeTaskTitle(title) {
+    return title.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().slice(0, 50);
+  }
+  jaccardWordSimilarity(a, b) {
+    const aWords = new Set(a.split(" ").filter(Boolean));
+    const bWords = new Set(b.split(" ").filter(Boolean));
+    if (aWords.size === 0 || bWords.size === 0) {
+      return 0;
+    }
+    let intersection = 0;
+    for (const word of aWords) {
+      if (bWords.has(word)) {
+        intersection += 1;
+      }
+    }
+    const unionSize = aWords.size + bWords.size - intersection;
+    return unionSize === 0 ? 0 : intersection / unionSize;
+  }
+  deriveTaskTitle(content, type) {
+    let title = content.replace(/^\d{2}:\d{2}\s+/, "").replace(/\[[^\]]+\]\s*/g, "").trim();
+    if (type === "todo") {
+      title = title.replace(
+        /^(?:todo:\s*|we need to\s+|don't forget(?: to)?\s+|remember to\s+|make sure to\s+)/i,
+        ""
+      );
+    } else if (type === "task") {
+      title = title.replace(
+        /^(?:i'?ll\s+|i will\s+|let me\s+|(?:i'?m\s+)?going to\s+|plan to\s+|should\s+)/i,
+        ""
+      );
+    } else if (type === "commitment-unresolved") {
+      title = title.replace(/^(?:need to figure out\s+|tbd[:\s-]*|to be determined[:\s-]*)/i, "");
+    }
+    title = title.replace(/\s+/g, " ").replace(/^[^a-zA-Z0-9]+/, "").replace(/[.?!:;,]+$/, "").trim();
+    return title.slice(0, 120);
+  }
+  buildTaskContextContent(item, context) {
+    const lines = ["Auto-extracted by observer from session transcript."];
+    if (context.sessionKey) {
+      lines.push(`Session: ${context.sessionKey}`);
+    }
+    if (context.transcriptId) {
+      lines.push(`Transcript: ${context.transcriptId}`);
+    }
+    if (context.source) {
+      lines.push(`Source: ${context.source}`);
+    }
+    const approximateTimestamp = this.extractApproximateTimestamp(item.date, item.content, context.timestamp);
+    lines.push(`Approximate timestamp: ${approximateTimestamp}`);
+    lines.push(`Observation type: ${item.type}`);
+    lines.push(`Original observation: ${item.content}`);
+    return lines.join("\n");
+  }
+  extractApproximateTimestamp(date, content, timestamp) {
+    if (timestamp) {
+      return timestamp.toISOString();
+    }
+    const timeMatch = content.match(/\b([01]\d|2[0-3]):([0-5]\d)\b/);
+    if (timeMatch) {
+      return `${date} ${timeMatch[0]}`;
+    }
+    return date;
+  }
+  isOpenWorkItem(item) {
+    if (item.kind === "task") {
+      return item.status !== "done";
+    }
+    return item.status !== "done";
+  }
+  touchExistingWorkItem(item) {
+    if (item.kind === "task") {
+      if (!this.isOpenWorkItem(item)) {
+        return;
+      }
+      updateTask(this.vaultPath, item.slug, {});
+      return;
+    }
+    const nextTags = this.mergeTags(item.tags, ["commitment"]);
+    updateBacklogItem(this.vaultPath, item.slug, {
+      source: item.source ?? "observer",
+      tags: nextTags,
+      lastSeen: this.now().toISOString()
+    });
+    item.tags = nextTags;
+  }
+  mergeTags(...groups) {
+    const merged = /* @__PURE__ */ new Set();
+    for (const group of groups) {
+      for (const tag of group) {
+        const normalized = tag.trim().toLowerCase();
+        if (normalized) {
+          merged.add(normalized);
+        }
+      }
+    }
+    return [...merged];
+  }
   parseObservations(markdown) {
     const records = parseObservationMarkdown(markdown);
     return records.map((record) => ({
@@ -881,14 +1133,20 @@ ${entry}
     for (const bg of setA) if (setB.has(bg)) intersection++;
     return intersection / (setA.size + setB.size - intersection);
   }
-  buildSummary(routed) {
-    if (routed.length === 0) return "No items routed to vault categories.";
+  buildSummary(routed, dedupHits) {
+    if (routed.length === 0) {
+      if (dedupHits > 0) {
+        return `No items routed to vault categories (dedup hits: ${dedupHits}).`;
+      }
+      return "No items routed to vault categories.";
+    }
     const byCat = /* @__PURE__ */ new Map();
     for (const item of routed) {
       byCat.set(item.category, (byCat.get(item.category) ?? 0) + 1);
     }
     const parts = [...byCat.entries()].map(([cat, count]) => `${cat}: ${count}`);
-    return `Routed ${routed.length} observations \u2192 ${parts.join(", ")}`;
+    const suffix = dedupHits > 0 ? ` (dedup hits: ${dedupHits})` : "";
+    return `Routed ${routed.length} observations \u2192 ${parts.join(", ")}${suffix}`;
   }
 };
 
@@ -905,6 +1163,7 @@ var Observer = class {
   rawCapture;
   router;
   pendingMessages = [];
+  pendingRouteContext = {};
   observationsCache = "";
   lastRoutingSummary = "";
   constructor(vaultPath, options = {}) {
@@ -915,7 +1174,10 @@ var Observer = class {
     this.compressor = options.compressor ?? new Compressor({ model: options.model, now: this.now });
     this.reflector = options.reflector ?? new Reflector({ now: this.now });
     this.rawCapture = options.rawCapture ?? true;
-    this.router = new Router(vaultPath);
+    this.router = new Router(vaultPath, {
+      extractTasks: options.extractTasks,
+      now: this.now
+    });
     ensureLedgerStructure(this.vaultPath);
     this.observationsCache = this.readTodayObservations();
   }
@@ -928,6 +1190,7 @@ var Observer = class {
       this.persistRawMessages(incoming, options);
     }
     this.pendingMessages.push(...incoming);
+    this.pendingRouteContext = this.mergeRouteContext(this.pendingRouteContext, options);
     const buffered = this.pendingMessages.join("\n");
     if (this.estimateTokens(buffered) < this.tokenThreshold) {
       return;
@@ -940,14 +1203,16 @@ var Observer = class {
       this.writeObservationFile(todayPath, existing);
     }
     const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const routeContext = this.pendingRouteContext;
     this.pendingMessages = [];
+    this.pendingRouteContext = {};
     const compressed = this.deduplicateObservationMarkdown(compressedRaw);
     if (!compressed) {
       return;
     }
     this.writeObservationFile(todayPath, compressed);
     this.observationsCache = compressed;
-    const { summary } = this.router.route(compressed);
+    const { summary } = this.router.route(compressed, routeContext);
     if (summary) {
       this.lastRoutingSummary = summary;
     }
@@ -968,12 +1233,14 @@ var Observer = class {
       this.writeObservationFile(todayPath, existing);
     }
     const compressedRaw = (await this.compressor.compress(this.pendingMessages, existing)).trim();
+    const routeContext = this.pendingRouteContext;
     this.pendingMessages = [];
+    this.pendingRouteContext = {};
     const compressed = this.deduplicateObservationMarkdown(compressedRaw);
     if (compressed) {
       this.writeObservationFile(todayPath, compressed);
       this.observationsCache = compressed;
-      const { summary } = this.router.route(compressed);
+      const { summary } = this.router.route(compressed, routeContext);
       this.lastRoutingSummary = summary;
     }
     return { observations: this.observationsCache, routingSummary: this.lastRoutingSummary };
@@ -1062,6 +1329,14 @@ var Observer = class {
     }
     return "openclaw";
   }
+  mergeRouteContext(existing, incoming) {
+    const merged = { ...existing };
+    if (incoming.source) merged.source = incoming.source;
+    if (incoming.sessionKey) merged.sessionKey = incoming.sessionKey;
+    if (incoming.transcriptId) merged.transcriptId = incoming.transcriptId;
+    if (incoming.timestamp) merged.timestamp = incoming.timestamp;
+    return merged;
+  }
 };
 
 export {