clawvault 2.4.4 → 2.4.6

package/dist/chunk-LLN5SPGL.js

@@ -0,0 +1,399 @@
+import {
+  listTasks,
+  readTask,
+  updateTask
+} from "./chunk-6QLRSPLZ.js";
+
+// src/commands/kanban.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+var STATUS_LANES = [
+  { status: "open", name: "Open" },
+  { status: "in-progress", name: "In Progress" },
+  { status: "blocked", name: "Blocked" },
+  { status: "done", name: "Done" }
+];
+var PRIORITY_LANES = [
+  { priority: "critical", name: "\u{1F525} Critical" },
+  { priority: "high", name: "\u{1F534} High" },
+  { priority: "medium", name: "\u{1F7E1} Medium" },
+  { priority: "low", name: "\u{1F7E2} Low" },
+  { priority: null, name: "\u26AA Unset" }
+];
+var PRIORITY_EMOJI = {
+  critical: "\u{1F525}",
+  high: "\u{1F534}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F7E2}"
+};
+function normalizeGroupBy(value) {
+  const normalized = String(value || "status").trim().toLowerCase();
+  if (normalized === "status" || normalized === "priority" || normalized === "project" || normalized === "owner") {
+    return normalized;
+  }
+  throw new Error(`Unsupported kanban group field: ${normalized}`);
+}
+function resolveBoardPath(vaultPath, output) {
+  const resolvedVaultPath = path.resolve(vaultPath);
+  if (!output) {
+    return path.join(resolvedVaultPath, "Board.md");
+  }
+  if (path.isAbsolute(output)) {
+    return output;
+  }
+  return path.join(resolvedVaultPath, output);
+}
+function toHashTag(value) {
+  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9/_-]/g, "");
+}
+function toMention(value) {
+  return value.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9._-]/g, "");
+}
+function dateOnly(value) {
+  return value.includes("T") ? value.split("T")[0] : value;
+}
+function dueTimestamp(task) {
+  if (!task.frontmatter.due) return Number.POSITIVE_INFINITY;
+  const timestamp = Date.parse(task.frontmatter.due);
+  return Number.isNaN(timestamp) ? Number.POSITIVE_INFINITY : timestamp;
+}
+function sortTasksForCards(tasks) {
+  return [...tasks].sort((left, right) => {
+    const dueDiff = dueTimestamp(left) - dueTimestamp(right);
+    if (dueDiff !== 0) return dueDiff;
+    return new Date(right.frontmatter.created).getTime() - new Date(left.frontmatter.created).getTime();
+  });
+}
+function statusLaneName(status) {
+  const lane = STATUS_LANES.find((entry) => entry.status === status);
+  return lane ? lane.name : "Open";
+}
+function priorityLaneName(priority) {
+  const lane = PRIORITY_LANES.find((entry) => entry.priority === (priority ?? null));
+  return lane ? lane.name : "\u26AA Unset";
+}
+function laneNameForTask(task, groupBy) {
+  switch (groupBy) {
+    case "status":
+      return statusLaneName(task.frontmatter.status);
+    case "priority":
+      return priorityLaneName(task.frontmatter.priority);
+    case "project":
+      return task.frontmatter.project?.trim() || "No Project";
+    case "owner":
+      return task.frontmatter.owner?.trim() || "Unassigned";
+    default:
+      return statusLaneName(task.frontmatter.status);
+  }
+}
+function defaultLaneOrder(groupBy, tasks) {
+  if (groupBy === "status") {
+    return STATUS_LANES.map((entry) => entry.name);
+  }
+  if (groupBy === "priority") {
+    return PRIORITY_LANES.map((entry) => entry.name);
+  }
+  const fallback = groupBy === "project" ? "No Project" : "Unassigned";
+  const values = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    values.add(laneNameForTask(task, groupBy));
+  }
+  if (values.size === 0) {
+    return [fallback];
+  }
+  const sorted = Array.from(values).sort((left, right) => left.localeCompare(right));
+  if (sorted.includes(fallback)) {
+    return [...sorted.filter((value) => value !== fallback), fallback];
+  }
+  return sorted;
+}
+function formatKanbanCard(task) {
+  const checkbox = task.frontmatter.status === "done" ? "x" : " ";
+  const parts = [];
+  if (task.frontmatter.priority) {
+    parts.push(PRIORITY_EMOJI[task.frontmatter.priority]);
+  }
+  parts.push(`[[${task.slug}|${task.title}]]`);
+  if (task.frontmatter.project) {
+    const projectTag = toHashTag(task.frontmatter.project);
+    if (projectTag) parts.push(`#${projectTag}`);
+  }
+  if (task.frontmatter.owner) {
+    const mention = toMention(task.frontmatter.owner);
+    if (mention) parts.push(`@${mention}`);
+  }
+  if (task.frontmatter.tags && task.frontmatter.tags.length > 0) {
+    for (const tag of task.frontmatter.tags) {
+      const normalizedTag = toHashTag(tag);
+      if (normalizedTag) parts.push(`#${normalizedTag}`);
+    }
+  }
+  if (task.frontmatter.due) {
+    parts.push(`\u{1F4C5} ${dateOnly(task.frontmatter.due)}`);
+  }
+  if (task.frontmatter.status === "blocked" || task.frontmatter.blocked_by) {
+    parts.push("\u26D4");
+  }
+  return `- [${checkbox}] ${parts.join(" ")}`;
+}
+function buildKanbanLanes(tasks, groupBy) {
+  const laneOrder = defaultLaneOrder(groupBy, tasks);
+  const lanes = /* @__PURE__ */ new Map();
+  for (const laneName of laneOrder) {
+    lanes.set(laneName, []);
+  }
+  for (const task of sortTasksForCards(tasks)) {
+    const laneName = laneNameForTask(task, groupBy);
+    if (!lanes.has(laneName)) {
+      lanes.set(laneName, []);
+    }
+    lanes.get(laneName)?.push(formatKanbanCard(task));
+  }
+  return Array.from(lanes.entries()).map(([name, cards]) => ({ name, cards }));
+}
+function generateKanbanMarkdown(tasks, options = {}) {
+  const groupBy = normalizeGroupBy(options.groupBy);
+  const syncedAt = (options.now || /* @__PURE__ */ new Date()).toISOString();
+  const lanes = buildKanbanLanes(tasks, groupBy);
+  const sections = lanes.map((lane) => {
+    const cardsBlock = lane.cards.length > 0 ? lane.cards.join("\n") : "";
+    return `## ${lane.name}
+
+${cardsBlock}`.trimEnd();
+  }).join("\n\n");
+  return [
+    "---",
+    "kanban-plugin: basic",
+    `clawvault-group-by: ${groupBy}`,
+    `clawvault-last-sync: '${syncedAt}'`,
+    "---",
+    "",
+    sections,
+    "",
+    "%% kanban:settings",
+    '{"kanban-plugin":"basic","list-collapse":["Done"],"show-checkboxes":true}',
+    "%%",
+    ""
+  ].join("\n");
+}
+function syncKanbanBoard(vaultPath, options = {}) {
+  const groupBy = normalizeGroupBy(options.groupBy);
+  const outputPath = resolveBoardPath(vaultPath, options.output);
+  let tasks = listTasks(vaultPath);
+  if (options.filterProject) {
+    tasks = tasks.filter((task) => task.frontmatter.project === options.filterProject);
+  }
+  if (options.filterOwner) {
+    tasks = tasks.filter((task) => task.frontmatter.owner === options.filterOwner);
+  }
+  if (!options.includeDone) {
+    tasks = tasks.filter((task) => task.frontmatter.status !== "done");
+  }
+  const markdown = generateKanbanMarkdown(tasks, {
+    groupBy,
+    now: options.now
+  });
+  fs.writeFileSync(outputPath, markdown);
+  return {
+    outputPath,
+    groupBy,
+    markdown,
+    lanes: buildKanbanLanes(tasks, groupBy),
+    taskCount: tasks.length
+  };
+}
+function normalizeLaneKey(laneName) {
+  return laneName.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").replace(/\s+/g, " ").trim();
+}
+function statusFromLaneName(laneName) {
+  const key = normalizeLaneKey(laneName);
+  if (key.includes("in progress") || key.includes("in-progress") || key === "active") return "in-progress";
+  if (key.includes("blocked")) return "blocked";
+  if (key.includes("done") || key.includes("complete")) return "done";
+  if (key.includes("open")) return "open";
+  return null;
+}
+function priorityFromLaneName(laneName) {
+  const key = normalizeLaneKey(laneName);
+  if (key.includes("critical")) return "critical";
+  if (key.includes("high")) return "high";
+  if (key.includes("medium")) return "medium";
+  if (key.includes("low")) return "low";
+  if (key.includes("unset") || key.includes("none") || key.includes("no priority")) return null;
+  return void 0;
+}
+function isProjectFallbackLane(laneName) {
+  const key = normalizeLaneKey(laneName);
+  return key === "no project" || key === "none";
+}
+function isOwnerFallbackLane(laneName) {
+  const key = normalizeLaneKey(laneName);
+  return key === "unassigned" || key === "none";
+}
+function extractCardSlug(line) {
+  const wikiMatch = line.match(/\[\[([^\]]+)\]\]/);
+  if (!wikiMatch) return null;
+  let target = wikiMatch[1].split("|")[0].trim();
+  if (!target) return null;
+  target = target.split("#")[0].trim();
+  const filePart = target.split("/").pop() || target;
+  const slug = filePart.replace(/\.md$/i, "").trim();
+  return slug || null;
+}
+function parseKanbanMarkdown(markdown) {
+  const parsed = matter(markdown);
+  const groupBy = normalizeGroupBy(
+    typeof parsed.data["clawvault-group-by"] === "string" ? parsed.data["clawvault-group-by"] : void 0
+  );
+  const lanes = [];
+  const laneByName = /* @__PURE__ */ new Map();
+  let currentLane = null;
+  const lines = parsed.content.split(/\r?\n/);
+  for (const line of lines) {
+    const headerMatch = line.match(/^##\s+(.+?)\s*$/);
+    if (headerMatch) {
+      const laneName = headerMatch[1].trim();
+      if (!laneByName.has(laneName)) {
+        const lane = { name: laneName, slugs: [] };
+        laneByName.set(laneName, lane);
+        lanes.push(lane);
+      }
+      currentLane = laneByName.get(laneName) || null;
+      continue;
+    }
+    if (!currentLane || !/^\s*-\s*\[[ xX]\]\s+/.test(line)) {
+      continue;
+    }
+    const slug = extractCardSlug(line);
+    if (slug) {
+      currentLane.slugs.push(slug);
+    }
+  }
+  return { groupBy, lanes };
+}
+function hasUpdates(updates) {
+  return Object.keys(updates).length > 0;
+}
+function importKanbanBoard(vaultPath, options = {}) {
+  const outputPath = resolveBoardPath(vaultPath, options.output);
+  if (!fs.existsSync(outputPath)) {
+    throw new Error(`Kanban board not found: ${outputPath}`);
+  }
+  const markdown = fs.readFileSync(outputPath, "utf-8");
+  const parsed = parseKanbanMarkdown(markdown);
+  const changes = [];
+  const missingSlugs = [];
+  const seenSlugs = /* @__PURE__ */ new Set();
+  for (const lane of parsed.lanes) {
+    for (const slug of lane.slugs) {
+      if (seenSlugs.has(slug)) continue;
+      seenSlugs.add(slug);
+      const task = readTask(vaultPath, slug);
+      if (!task) {
+        missingSlugs.push(slug);
+        continue;
+      }
+      const updates = {};
+      if (parsed.groupBy === "status") {
+        const desiredStatus = statusFromLaneName(lane.name);
+        if (desiredStatus && task.frontmatter.status !== desiredStatus) {
+          updates.status = desiredStatus;
+          changes.push({
+            slug,
+            field: "status",
+            from: task.frontmatter.status,
+            to: desiredStatus
+          });
+        }
+      } else if (parsed.groupBy === "priority") {
+        const desiredPriority = priorityFromLaneName(lane.name);
+        if (desiredPriority !== void 0) {
+          const currentPriority = task.frontmatter.priority ?? null;
+          if (currentPriority !== desiredPriority) {
+            updates.priority = desiredPriority;
+            changes.push({
+              slug,
+              field: "priority",
+              from: currentPriority,
+              to: desiredPriority
+            });
+          }
+        }
+      } else if (parsed.groupBy === "project") {
+        const desiredProject = isProjectFallbackLane(lane.name) ? null : lane.name.trim();
+        const currentProject = task.frontmatter.project ?? null;
+        if (currentProject !== desiredProject) {
+          updates.project = desiredProject;
+          changes.push({
+            slug,
+            field: "project",
+            from: currentProject,
+            to: desiredProject
+          });
+        }
+      } else if (parsed.groupBy === "owner") {
+        const desiredOwner = isOwnerFallbackLane(lane.name) ? null : lane.name.trim();
+        const currentOwner = task.frontmatter.owner ?? null;
+        if (currentOwner !== desiredOwner) {
+          updates.owner = desiredOwner;
+          changes.push({
+            slug,
+            field: "owner",
+            from: currentOwner,
+            to: desiredOwner
+          });
+        }
+      }
+      if (hasUpdates(updates)) {
+        updateTask(vaultPath, slug, updates);
+      }
+    }
+  }
+  return {
+    outputPath,
+    groupBy: parsed.groupBy,
+    changes,
+    missingSlugs
+  };
+}
+async function kanbanCommand(vaultPath, action, options = {}) {
+  if (action === "sync") {
+    const result = syncKanbanBoard(vaultPath, options);
+    console.log(`\u2713 Synced kanban board: ${result.outputPath}`);
+    console.log(`  Grouped by: ${result.groupBy}`);
+    console.log(`  Tasks included: ${result.taskCount}`);
+    return;
+  }
+  if (action === "import") {
+    const result = importKanbanBoard(vaultPath, options);
+    console.log(`\u2713 Imported kanban board: ${result.outputPath}`);
+    console.log(`  Grouped by: ${result.groupBy}`);
+    if (result.changes.length === 0) {
+      console.log("  No task updates required.");
+    } else {
+      console.log(`  Updated ${result.changes.length} task field(s):`);
+      for (const change of result.changes) {
+        const from = change.from ?? "(unset)";
+        const to = change.to ?? "(unset)";
+        console.log(`  - ${change.slug}: ${change.field} ${from} -> ${to}`);
+      }
+    }
+    if (result.missingSlugs.length > 0) {
+      console.log(`  Missing tasks (${result.missingSlugs.length}): ${result.missingSlugs.join(", ")}`);
+    }
+    return;
+  }
+  throw new Error(`Unknown kanban action: ${action}`);
+}
+
+export {
+  formatKanbanCard,
+  buildKanbanLanes,
+  generateKanbanMarkdown,
+  syncKanbanBoard,
+  extractCardSlug,
+  parseKanbanMarkdown,
+  importKanbanBoard,
+  kanbanCommand
+};

package/dist/chunk-OIWVQYQF.js

@@ -0,0 +1,284 @@
+import {
+  formatAge
+} from "./chunk-7ZRP733D.js";
+import {
+  checkDirtyDeath,
+  clearDirtyFlag
+} from "./chunk-F55HGNU4.js";
+
+// src/commands/recover.ts
+import * as fs from "fs";
+import * as path from "path";
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var CHECKPOINT_HISTORY_DIR = "checkpoints";
+function parseCheckpointFile(filePath) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const record = parsed;
+    const timestamp = typeof record.timestamp === "string" ? record.timestamp.trim() : "";
+    if (!timestamp) {
+      return null;
+    }
+    const checkpoint = {
+      timestamp,
+      workingOn: typeof record.workingOn === "string" ? record.workingOn : null,
+      focus: typeof record.focus === "string" ? record.focus : null,
+      blocked: typeof record.blocked === "string" ? record.blocked : null
+    };
+    if (typeof record.sessionId === "string") {
+      checkpoint.sessionId = record.sessionId;
+    }
+    if (typeof record.sessionKey === "string") {
+      checkpoint.sessionKey = record.sessionKey;
+    }
+    if (typeof record.model === "string") {
+      checkpoint.model = record.model;
+    }
+    if (typeof record.tokenEstimate === "number" && Number.isFinite(record.tokenEstimate)) {
+      checkpoint.tokenEstimate = record.tokenEstimate;
+    }
+    if (typeof record.sessionStartedAt === "string") {
+      checkpoint.sessionStartedAt = record.sessionStartedAt;
+    }
+    if (typeof record.urgent === "boolean") {
+      checkpoint.urgent = record.urgent;
+    }
+    return checkpoint;
+  } catch {
+    return null;
+  }
+}
+function compareByTimestampDesc(left, right) {
+  const leftTime = Date.parse(left.timestamp);
+  const rightTime = Date.parse(right.timestamp);
+  if (!Number.isNaN(leftTime) && !Number.isNaN(rightTime)) {
+    return rightTime - leftTime;
+  }
+  return right.timestamp.localeCompare(left.timestamp);
+}
+async function checkRecoveryStatus(vaultPath) {
+  const { died, checkpoint, deathTime } = await checkDirtyDeath(vaultPath);
+  return { died, checkpoint, deathTime };
+}
+function listCheckpoints(vaultPath) {
+  const resolvedVaultPath = path.resolve(vaultPath);
+  const clawvaultDir = path.join(resolvedVaultPath, CLAWVAULT_DIR);
+  const historyDir = path.join(clawvaultDir, CHECKPOINT_HISTORY_DIR);
+  const checkpoints = [];
+  if (fs.existsSync(historyDir)) {
+    const files = fs.readdirSync(historyDir).filter((entry) => entry.endsWith(".json")).sort().reverse();
+    for (const fileName of files) {
+      const absolutePath = path.join(historyDir, fileName);
+      const parsed = parseCheckpointFile(absolutePath);
+      if (!parsed) {
+        continue;
+      }
+      checkpoints.push({
+        ...parsed,
+        filePath: absolutePath
+      });
+    }
+  }
+  if (checkpoints.length === 0) {
+    const latestCheckpointPath = path.join(clawvaultDir, CHECKPOINT_FILE);
+    if (fs.existsSync(latestCheckpointPath)) {
+      const fallback = parseCheckpointFile(latestCheckpointPath);
+      if (fallback) {
+        checkpoints.push({
+          ...fallback,
+          filePath: latestCheckpointPath
+        });
+      }
+    }
+  }
+  return checkpoints.sort(compareByTimestampDesc);
+}
+async function recover(vaultPath, options = {}) {
+  const { clearFlag = false } = options;
+  const { died, checkpoint, deathTime } = await checkRecoveryStatus(vaultPath);
+  if (!died) {
+    return {
+      died: false,
+      deathTime: null,
+      checkpoint: null,
+      handoffPath: null,
+      handoffContent: null,
+      recoveryMessage: "No context death detected. Clean startup."
+    };
+  }
+  const handoffsDir = path.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs.existsSync(handoffsDir)) {
+    const files = fs.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path.join(handoffsDir, files[0]);
+      handoffContent = fs.readFileSync(handoffPath, "utf-8");
+    }
+  }
+  let message = "\u26A0\uFE0F **CONTEXT DEATH DETECTED**\n\n";
+  message += `Your previous session died at ${deathTime}.
+
+`;
+  if (checkpoint) {
+    message += "**Last known state:**\n";
+    if (checkpoint.workingOn) {
+      message += `- Working on: ${checkpoint.workingOn}
+`;
+    }
+    if (checkpoint.focus) {
+      message += `- Focus: ${checkpoint.focus}
+`;
+    }
+    if (checkpoint.blocked) {
+      message += `- Blocked: ${checkpoint.blocked}
+`;
+    }
+    message += "\n";
+  }
+  if (handoffPath) {
+    message += `**Last handoff:** ${path.basename(handoffPath)}
+`;
+    message += "Review and resume from where you left off.\n";
+  } else {
+    message += "**No handoff found.** You may have lost context.\n";
+  }
+  if (clearFlag) {
+    await clearDirtyFlag(vaultPath);
+  }
+  return {
+    died: true,
+    deathTime,
+    checkpoint,
+    handoffPath,
+    handoffContent,
+    recoveryMessage: message
+  };
+}
+function formatRecoveryCheckStatus(info) {
+  if (!info.died) {
+    return "\u2713 Dirty death flag is clear.";
+  }
+  let output = "\u26A0\uFE0F Dirty death flag is set.\n";
+  output += `Death time: ${info.deathTime}
+`;
+  if (info.checkpoint?.timestamp) {
+    const age = formatAge(Date.now() - new Date(info.checkpoint.timestamp).getTime());
+    output += `Last checkpoint: ${info.checkpoint.timestamp} (${age} ago)
+`;
+  } else {
+    output += "Last checkpoint: unavailable\n";
+  }
+  output += "Use `clawvault recover --clear` after reviewing recovery details.";
+  return output;
+}
+function formatCheckpointList(checkpoints) {
+  if (checkpoints.length === 0) {
+    return "No checkpoints found.";
+  }
+  const headers = ["TIMESTAMP", "WORKING_ON", "FOCUS", "FILE"];
+  const rows = checkpoints.map((checkpoint) => ({
+    timestamp: checkpoint.timestamp,
+    workingOn: checkpoint.workingOn ?? "-",
+    focus: checkpoint.focus ?? "-",
+    file: path.basename(checkpoint.filePath)
+  }));
+  const timestampWidth = Math.max(headers[0].length, ...rows.map((row) => row.timestamp.length));
+  const workingOnWidth = Math.max(headers[1].length, ...rows.map((row) => row.workingOn.length));
+  const focusWidth = Math.max(headers[2].length, ...rows.map((row) => row.focus.length));
+  const fileWidth = Math.max(headers[3].length, ...rows.map((row) => row.file.length));
+  const lines = [];
+  lines.push(
+    `${headers[0].padEnd(timestampWidth)}  ${headers[1].padEnd(workingOnWidth)}  ${headers[2].padEnd(focusWidth)}  ${headers[3].padEnd(fileWidth)}`
+  );
+  lines.push(
+    `${"-".repeat(timestampWidth)}  ${"-".repeat(workingOnWidth)}  ${"-".repeat(focusWidth)}  ${"-".repeat(fileWidth)}`
+  );
+  for (const row of rows) {
+    lines.push(
+      `${row.timestamp.padEnd(timestampWidth)}  ${row.workingOn.padEnd(workingOnWidth)}  ${row.focus.padEnd(focusWidth)}  ${row.file}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatRecoveryInfo(info, options = {}) {
+  const { verbose = false } = options;
+  if (!info.died) {
+    return "\u2713 Clean startup - no context death detected.";
+  }
+  let output = "\n\u26A0\uFE0F  CONTEXT DEATH DETECTED\n";
+  output += "\u2550".repeat(40) + "\n\n";
+  output += `Death time: ${info.deathTime}
+`;
+  if (info.checkpoint?.timestamp) {
+    const age = formatAge(Date.now() - new Date(info.checkpoint.timestamp).getTime());
+    output += `Checkpoint: ${info.checkpoint.timestamp} (${age} ago)
+`;
+  }
+  output += "\n";
+  if (info.checkpoint) {
+    output += "Last checkpoint:\n";
+    if (info.checkpoint.workingOn) {
+      output += `  \u2022 Working on: ${info.checkpoint.workingOn}
+`;
+    }
+    if (info.checkpoint.focus) {
+      output += `  \u2022 Focus: ${info.checkpoint.focus}
+`;
+    }
+    if (info.checkpoint.blocked) {
+      output += `  \u2022 Blocked: ${info.checkpoint.blocked}
+`;
+    }
+    if (info.checkpoint.sessionKey || info.checkpoint.model || info.checkpoint.tokenEstimate !== void 0) {
+      output += "  \u2022 Session:\n";
+      if (info.checkpoint.sessionKey) {
+        output += `    - Key: ${info.checkpoint.sessionKey}
+`;
+      }
+      if (info.checkpoint.model) {
+        output += `    - Model: ${info.checkpoint.model}
+`;
+      }
+      if (info.checkpoint.tokenEstimate !== void 0) {
+        output += `    - Token estimate: ${info.checkpoint.tokenEstimate}
+`;
+      }
+    }
+    output += "\n";
+  } else {
+    output += "No checkpoint data found.\n\n";
+  }
+  if (info.handoffPath) {
+    output += `Last handoff: ${path.basename(info.handoffPath)}
+`;
+  } else {
+    output += "No handoff found - context may be lost.\n";
+  }
+  if (verbose) {
+    if (info.checkpoint) {
+      output += "\nCheckpoint JSON:\n";
+      output += JSON.stringify(info.checkpoint, null, 2) + "\n";
+    }
+    if (info.handoffContent) {
+      output += "\nHandoff content:\n";
+      output += info.handoffContent.trim() + "\n";
+    }
+  }
+  output += "\n" + "\u2550".repeat(40) + "\n";
+  output += "Run `clawvault recap` to see full context.\n";
+  return output;
+}
+
+export {
+  checkRecoveryStatus,
+  listCheckpoints,
+  recover,
+  formatRecoveryCheckStatus,
+  formatCheckpointList,
+  formatRecoveryInfo
+};

package/dist/{chunk-IFTEGE4D.js → chunk-P2ZH6AN5.js}

@@ -1,7 +1,9 @@
 import {
-  DEFAULT_CATEGORIES,
   hasQmd
-} from "./chunk-FDJIZKCW.js";
+} from "./chunk-6B3JWM7J.js";
+import {
+  DEFAULT_CATEGORIES
+} from "./chunk-3PJIGGWV.js";
 
 // src/commands/setup.ts
 import * as fs from "fs";

package/dist/commands/backlog.js

@@ -2,7 +2,7 @@ import {
   createBacklogItem,
   listBacklogItems,
   promoteBacklogItem
-} from "../chunk-DEFBIVQ3.js";
+} from "../chunk-6QLRSPLZ.js";
 
 // src/commands/backlog.ts
 function toDateStr(val) {