clawvault 3.0.0 → 3.2.0

package/dist/commands/task.cjs

@@ -1,1236 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/commands/task.ts
-var task_exports = {};
-__export(task_exports, {
-  formatTaskDetails: () => formatTaskDetails,
-  formatTaskList: () => formatTaskList,
-  taskAdd: () => taskAdd,
-  taskCommand: () => taskCommand,
-  taskDone: () => taskDone,
-  taskList: () => taskList,
-  taskShow: () => taskShow,
-  taskTransitions: () => taskTransitions,
-  taskUpdate: () => taskUpdate
-});
-module.exports = __toCommonJS(task_exports);
-
-// src/lib/task-utils.ts
-var fs3 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-
-// src/lib/transition-ledger.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var REGRESSION_PAIRS = [
-  ["done", "open"],
-  ["done", "blocked"],
-  ["in-progress", "blocked"]
-];
-function isRegression(from, to) {
-  return REGRESSION_PAIRS.some(([f, t]) => f === from && t === to);
-}
-function getLedgerDir(vaultPath) {
-  return path.join(path.resolve(vaultPath), "ledger", "transitions");
-}
-function getTodayLedgerPath(vaultPath) {
-  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return path.join(getLedgerDir(vaultPath), `${date}.jsonl`);
-}
-var RETRYABLE_APPEND_CODES = /* @__PURE__ */ new Set(["ENOENT", "EAGAIN", "EBUSY"]);
-var MAX_APPEND_RETRIES = 2;
-function asErrno(error) {
-  if (!error || typeof error !== "object") {
-    return null;
-  }
-  return error;
-}
-function formatLedgerWriteError(filePath, error) {
-  const errno = asErrno(error);
-  const message = error instanceof Error ? error.message : String(error);
-  if (errno?.code === "ENOSPC") {
-    return new Error(`Failed to write transition ledger at ${filePath}: no space left on device.`);
-  }
-  if (errno?.code === "EACCES" || errno?.code === "EPERM") {
-    return new Error(`Failed to write transition ledger at ${filePath}: permission denied.`);
-  }
-  return new Error(`Failed to write transition ledger at ${filePath}: ${message}`);
-}
-function appendTransition(vaultPath, event) {
-  const ledgerDir = getLedgerDir(vaultPath);
-  try {
-    fs.mkdirSync(ledgerDir, { recursive: true });
-  } catch (error) {
-    throw formatLedgerWriteError(ledgerDir, error);
-  }
-  const filePath = getTodayLedgerPath(vaultPath);
-  const payload = JSON.stringify(event) + "\n";
-  for (let attempt = 0; attempt <= MAX_APPEND_RETRIES; attempt += 1) {
-    try {
-      fs.appendFileSync(filePath, payload);
-      return;
-    } catch (error) {
-      const errno = asErrno(error);
-      const code = errno?.code;
-      if (code === "ENOENT") {
-        try {
-          fs.mkdirSync(ledgerDir, { recursive: true });
-        } catch (mkdirError) {
-          throw formatLedgerWriteError(filePath, mkdirError);
-        }
-      }
-      if (code && RETRYABLE_APPEND_CODES.has(code) && attempt < MAX_APPEND_RETRIES) {
-        continue;
-      }
-      throw formatLedgerWriteError(filePath, error);
-    }
-  }
-}
-function buildTransitionEvent(taskId, fromStatus, toStatus, options = {}) {
-  const agentId = process.env.OPENCLAW_AGENT_ID || "manual";
-  const costTokensRaw = process.env.OPENCLAW_TOKEN_ESTIMATE;
-  const costTokens = costTokensRaw ? parseInt(costTokensRaw, 10) : null;
-  return {
-    task_id: taskId,
-    agent_id: agentId,
-    from_status: fromStatus,
-    to_status: toStatus,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    confidence: options.confidence ?? (agentId === "manual" ? 1 : 1),
-    cost_tokens: costTokens !== null && !isNaN(costTokens) ? costTokens : null,
-    reason: options.reason || null
-  };
-}
-function readAllTransitions(vaultPath) {
-  const ledgerDir = getLedgerDir(vaultPath);
-  if (!fs.existsSync(ledgerDir)) return [];
-  let files = [];
-  try {
-    files = fs.readdirSync(ledgerDir).filter((f) => f.endsWith(".jsonl")).sort();
-  } catch {
-    return [];
-  }
-  const events = [];
-  for (const file of files) {
-    let lines = [];
-    try {
-      lines = fs.readFileSync(path.join(ledgerDir, file), "utf-8").split("\n").filter((l) => l.trim());
-    } catch {
-      continue;
-    }
-    for (const line of lines) {
-      try {
-        events.push(JSON.parse(line));
-      } catch {
-      }
-    }
-  }
-  return events;
-}
-function queryTransitions(vaultPath, filters = {}) {
-  let events = readAllTransitions(vaultPath);
-  if (filters.taskId) {
-    events = events.filter((e) => e.task_id === filters.taskId);
-  }
-  if (filters.agent) {
-    events = events.filter((e) => e.agent_id === filters.agent);
-  }
-  if (filters.failed) {
-    events = events.filter((e) => isRegression(e.from_status, e.to_status));
-  }
-  return events;
-}
-function countBlockedTransitions(vaultPath, taskId) {
-  const events = readAllTransitions(vaultPath);
-  return events.filter((e) => e.task_id === taskId && e.to_status === "blocked").length;
-}
-function formatTransitionsTable(events) {
-  if (events.length === 0) return "No transitions found.\n";
-  const headers = ["TIMESTAMP", "TASK", "FROM\u2192TO", "AGENT", "REASON"];
-  const widths = [20, 20, 24, 16, 30];
-  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
-  output += "-".repeat(widths.reduce((a, b) => a + b + 2, 0)) + "\n";
-  for (const e of events) {
-    const ts = e.timestamp.replace("T", " ").slice(0, 19);
-    const taskId = e.task_id.length > widths[1] ? e.task_id.slice(0, widths[1] - 3) + "..." : e.task_id;
-    const transition = `${e.from_status} \u2192 ${e.to_status}`;
-    const reason = e.reason ? e.reason.length > widths[4] ? e.reason.slice(0, widths[4] - 3) + "..." : e.reason : "-";
-    output += [
-      ts.padEnd(widths[0]),
-      taskId.padEnd(widths[1]),
-      transition.padEnd(widths[2]),
-      e.agent_id.padEnd(widths[3]),
-      reason
-    ].join("  ") + "\n";
-  }
-  return output;
-}
-
-// src/lib/primitive-templates.ts
-var fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-var import_url = require("url");
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-
-// src/lib/template-engine.ts
-function buildTemplateVariables(input = {}, now = /* @__PURE__ */ new Date()) {
-  const datetime = input.datetime ?? now.toISOString();
-  const date = input.date ?? datetime.split("T")[0];
-  return {
-    title: input.title ?? "",
-    type: input.type ?? "",
-    date,
-    datetime
-  };
-}
-function renderTemplate(template, variables) {
-  return template.replace(/\{\{\s*([a-zA-Z0-9_-]+)\s*\}\}/g, (match, key) => {
-    const value = variables[key];
-    return value !== void 0 ? String(value) : match;
-  });
-}
-
-// src/lib/primitive-templates.ts
-var import_meta = {};
-var TEMPLATE_EXTENSION = ".md";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeTemplateName(name) {
-  const base = path2.basename(name, path2.extname(name));
-  return base.trim();
-}
-function resolveBuiltinTemplatesDir(override) {
-  if (override) {
-    const resolved = path2.resolve(override);
-    return fs2.existsSync(resolved) && fs2.statSync(resolved).isDirectory() ? resolved : null;
-  }
-  const moduleDir = path2.dirname((0, import_url.fileURLToPath)(import_meta.url));
-  const candidates = [
-    path2.resolve(moduleDir, "../templates"),
-    path2.resolve(moduleDir, "../../templates")
-  ];
-  for (const candidate of candidates) {
-    if (fs2.existsSync(candidate) && fs2.statSync(candidate).isDirectory()) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function listTemplateFiles(dir, ignore) {
-  const entries = /* @__PURE__ */ new Map();
-  if (!fs2.existsSync(dir)) return entries;
-  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isFile() || !entry.name.endsWith(TEMPLATE_EXTENSION)) continue;
-    const name = normalizeTemplateName(entry.name);
-    if (!name) continue;
-    if (ignore?.has(name)) continue;
-    entries.set(name, path2.join(dir, entry.name));
-  }
-  return entries;
-}
-function buildTemplateIndex(options = {}) {
-  const index = /* @__PURE__ */ new Map();
-  const builtinDir = resolveBuiltinTemplatesDir(options.builtinDir);
-  if (builtinDir) {
-    for (const [name, filePath] of listTemplateFiles(builtinDir, options.ignoreBuiltinNames)) {
-      index.set(name, filePath);
-    }
-  }
-  if (options.vaultPath) {
-    const vaultTemplatesDir = path2.join(path2.resolve(options.vaultPath), "templates");
-    for (const [name, filePath] of listTemplateFiles(vaultTemplatesDir)) {
-      index.set(name, filePath);
-    }
-  }
-  return index;
-}
-function inferFieldType(defaultValue) {
-  if (Array.isArray(defaultValue)) {
-    const uniqueItemTypes = [...new Set(defaultValue.map((value) => typeof value))];
-    if (uniqueItemTypes.length === 1 && uniqueItemTypes[0] === "string") {
-      return "string[]";
-    }
-    return "array";
-  }
-  switch (typeof defaultValue) {
-    case "string":
-      return "string";
-    case "number":
-      return "number";
-    case "boolean":
-      return "boolean";
-    case "object":
-      if (defaultValue === null) return "string";
-      return "object";
-    default:
-      return "string";
-  }
-}
-function normalizeFieldDefinition(rawField) {
-  if (!isRecord(rawField)) {
-    return {
-      type: inferFieldType(rawField),
-      default: rawField
-    };
-  }
-  const rawType = typeof rawField.type === "string" ? rawField.type.trim() : "";
-  const normalized = {
-    type: rawType || inferFieldType(rawField.default)
-  };
-  if (typeof rawField.description === "string" && rawField.description.trim()) {
-    normalized.description = rawField.description.trim();
-  }
-  if (typeof rawField.required === "boolean") {
-    normalized.required = rawField.required;
-  }
-  if (Object.prototype.hasOwnProperty.call(rawField, "default")) {
-    normalized.default = rawField.default;
-  }
-  if (Array.isArray(rawField.enum)) {
-    normalized.enum = rawField.enum;
-  }
-  return normalized;
-}
-function normalizeFieldDefinitions(rawFields) {
-  const normalized = {};
-  for (const [fieldName, rawField] of Object.entries(rawFields)) {
-    const normalizedName = String(fieldName).trim();
-    if (!normalizedName) continue;
-    normalized[normalizedName] = normalizeFieldDefinition(rawField);
-  }
-  return normalized;
-}
-function extractSchemaDefinition(frontmatter) {
-  const primitive = typeof frontmatter.primitive === "string" ? frontmatter.primitive.trim() : "";
-  const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0;
-  if (primitive && isRecord(frontmatter.fields)) {
-    return {
-      primitive,
-      description,
-      fields: frontmatter.fields
-    };
-  }
-  const containerCandidates = [frontmatter.schema, frontmatter.template];
-  for (const candidate of containerCandidates) {
-    if (!isRecord(candidate)) continue;
-    const nestedPrimitive = typeof candidate.primitive === "string" ? candidate.primitive.trim() : primitive;
-    if (!nestedPrimitive || !isRecord(candidate.fields)) continue;
-    const nestedDescription = typeof candidate.description === "string" ? candidate.description.trim() : description;
-    return {
-      primitive: nestedPrimitive,
-      description: nestedDescription,
-      fields: candidate.fields
-    };
-  }
-  return null;
-}
-function inferLegacyFieldDefinitions(frontmatter) {
-  const normalized = {};
-  const ignoredKeys = /* @__PURE__ */ new Set(["primitive", "fields", "schema", "template"]);
-  for (const [key, value] of Object.entries(frontmatter)) {
-    if (ignoredKeys.has(key)) continue;
-    normalized[key] = {
-      type: inferFieldType(value),
-      default: value
-    };
-  }
-  return normalized;
-}
-function parseTemplateDefinition(rawTemplate, templateName, sourcePath) {
-  const normalizedName = normalizeTemplateName(templateName);
-  const { data, content } = (0, import_gray_matter.default)(rawTemplate);
-  const frontmatter = isRecord(data) ? data : {};
-  const extractedSchema = extractSchemaDefinition(frontmatter);
-  if (extractedSchema) {
-    return {
-      name: normalizedName,
-      primitive: extractedSchema.primitive,
-      description: extractedSchema.description,
-      fields: normalizeFieldDefinitions(extractedSchema.fields),
-      body: content,
-      format: "schema",
-      sourcePath
-    };
-  }
-  return {
-    name: normalizedName,
-    primitive: normalizedName,
-    description: typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0,
-    fields: inferLegacyFieldDefinitions(frontmatter),
-    body: content,
-    format: "legacy",
-    sourcePath
-  };
-}
-function readTemplateDefinitionFromPath(filePath, templateName) {
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    return parseTemplateDefinition(raw, templateName, filePath);
-  } catch {
-    return null;
-  }
-}
-function loadTemplateDefinition(templateName, options = {}) {
-  const normalizedName = normalizeTemplateName(templateName);
-  if (!normalizedName) return null;
-  const index = buildTemplateIndex(options);
-  const filePath = index.get(normalizedName);
-  if (!filePath) return null;
-  return readTemplateDefinitionFromPath(filePath, normalizedName);
-}
-function loadSchemaTemplateDefinition(templateName, options = {}) {
-  const definition = loadTemplateDefinition(templateName, options);
-  if (!definition || definition.format !== "schema") {
-    return null;
-  }
-  return definition;
-}
-function resolveInterpolatedValue(value, variables) {
-  if (typeof value === "string") {
-    return renderTemplate(value, variables);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => resolveInterpolatedValue(item, variables));
-  }
-  if (isRecord(value)) {
-    const resolved = {};
-    for (const [key, nested] of Object.entries(value)) {
-      resolved[key] = resolveInterpolatedValue(nested, variables);
-    }
-    return resolved;
-  }
-  return value;
-}
-function pruneFrontmatter(frontmatter, options) {
-  const dropEmptyStrings = options.dropEmptyStrings ?? true;
-  const dropEmptyArrays = options.dropEmptyArrays ?? true;
-  const pruned = {};
-  for (const [key, value] of Object.entries(frontmatter)) {
-    if (value === void 0 || value === null) continue;
-    if (dropEmptyStrings && typeof value === "string" && value.trim() === "") continue;
-    if (dropEmptyArrays && Array.isArray(value) && value.length === 0) continue;
-    pruned[key] = value;
-  }
-  return pruned;
-}
-function buildFrontmatterFromTemplate(definition, variables, overrides = {}, options = {}) {
-  const frontmatter = {};
-  for (const [fieldName, schema] of Object.entries(definition.fields)) {
-    if (!Object.prototype.hasOwnProperty.call(schema, "default")) continue;
-    frontmatter[fieldName] = resolveInterpolatedValue(schema.default, variables);
-  }
-  for (const [fieldName, value] of Object.entries(overrides)) {
-    if (value === void 0) continue;
-    if (value === null) {
-      delete frontmatter[fieldName];
-      continue;
-    }
-    frontmatter[fieldName] = value;
-  }
-  if (!options.pruneEmpty) {
-    return frontmatter;
-  }
-  return pruneFrontmatter(frontmatter, options);
-}
-function renderDocumentFromTemplate(definition, options = {}) {
-  const now = options.now ?? /* @__PURE__ */ new Date();
-  const variables = {
-    ...buildTemplateVariables(
-      {
-        title: options.title ?? "",
-        type: options.type ?? definition.primitive
-      },
-      now
-    ),
-    ...options.variables ?? {}
-  };
-  const frontmatter = buildFrontmatterFromTemplate(
-    definition,
-    variables,
-    options.overrides,
-    options.frontmatter
-  );
-  const content = renderTemplate(definition.body, variables);
-  const markdown = import_gray_matter.default.stringify(content, frontmatter);
-  return {
-    frontmatter,
-    content,
-    markdown,
-    variables
-  };
-}
-
-// src/lib/task-utils.ts
-function slugify(text) {
-  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").trim();
-}
-function getTasksDir(vaultPath) {
-  return path3.join(path3.resolve(vaultPath), "tasks");
-}
-function ensureTasksDir(vaultPath) {
-  const tasksDir = getTasksDir(vaultPath);
-  if (!fs3.existsSync(tasksDir)) {
-    fs3.mkdirSync(tasksDir, { recursive: true });
-  }
-}
-function getTaskPath(vaultPath, slug) {
-  return path3.join(getTasksDir(vaultPath), `${slug}.md`);
-}
-function extractTitle(content) {
-  const match = content.match(/^#\s+(.+)$/m);
-  return match ? match[1].trim() : "";
-}
-function parseDueDate(value) {
-  if (!value) return null;
-  const timestamp = Date.parse(value);
-  if (Number.isNaN(timestamp)) return null;
-  return timestamp;
-}
-function startOfToday() {
-  const now = /* @__PURE__ */ new Date();
-  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
-}
-function buildTaskFrontmatterFallback(now, options) {
-  const frontmatter = {
-    status: "open",
-    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;
-  if (options.due) frontmatter.due = options.due;
-  if (options.tags && options.tags.length > 0) frontmatter.tags = options.tags;
-  if (options.description) frontmatter.description = options.description;
-  if (options.estimate) frontmatter.estimate = options.estimate;
-  if (options.parent) frontmatter.parent = options.parent;
-  if (options.depends_on && options.depends_on.length > 0) frontmatter.depends_on = options.depends_on;
-  return frontmatter;
-}
-function buildTaskContentFallback(title, options) {
-  let content = `# ${title}
-`;
-  const links = [];
-  if (options.owner) links.push(`[[${options.owner}]]`);
-  if (options.project) links.push(`[[${options.project}]]`);
-  if (links.length > 0) {
-    content += `
-${links.join(" | ")}
-`;
-  }
-  if (options.content) {
-    content += `
-${options.content}
-`;
-  }
-  return content;
-}
-function buildTaskTemplateOverrides(options) {
-  const overrides = {};
-  if (options.source) overrides.source = options.source;
-  if (options.owner) overrides.owner = options.owner;
-  if (options.project) overrides.project = options.project;
-  if (options.priority) overrides.priority = options.priority;
-  if (options.due) overrides.due = options.due;
-  if (options.tags && options.tags.length > 0) overrides.tags = options.tags;
-  if (options.description) overrides.description = options.description;
-  if (options.estimate) overrides.estimate = options.estimate;
-  if (options.parent) overrides.parent = options.parent;
-  if (options.depends_on && options.depends_on.length > 0) overrides.depends_on = options.depends_on;
-  return overrides;
-}
-function buildTaskTemplateVariables(title, slug, options) {
-  const ownerLink = options.owner ? `[[${options.owner}]]` : "";
-  const projectLink = options.project ? `[[${options.project}]]` : "";
-  const linksLine = [ownerLink, projectLink].filter(Boolean).join(" | ");
-  return {
-    title,
-    slug,
-    source: options.source ?? "",
-    owner: options.owner ?? "",
-    project: options.project ?? "",
-    priority: options.priority ?? "",
-    due: options.due ?? "",
-    tags_csv: (options.tags || []).join(", "),
-    description: options.description ?? "",
-    estimate: options.estimate ?? "",
-    parent: options.parent ?? "",
-    depends_on_csv: (options.depends_on || []).join(", "),
-    content: options.content ?? "",
-    owner_link: ownerLink,
-    project_link: projectLink,
-    links_line: linksLine
-  };
-}
-var VALID_TASK_STATUSES = /* @__PURE__ */ new Set([
-  "open",
-  "in-progress",
-  "blocked",
-  "done"
-]);
-function isTaskStatus(value) {
-  return typeof value === "string" && VALID_TASK_STATUSES.has(value);
-}
-function persistTaskFrontmatter(task, frontmatter) {
-  fs3.writeFileSync(task.path, import_gray_matter2.default.stringify(task.content, frontmatter));
-}
-function resolveStatusTransition(previousStatus, nextStatus) {
-  if (!isTaskStatus(previousStatus) || !isTaskStatus(nextStatus)) {
-    return null;
-  }
-  if (previousStatus === nextStatus) {
-    return null;
-  }
-  return { fromStatus: previousStatus, toStatus: nextStatus };
-}
-function logStatusTransition({
-  vaultPath,
-  task,
-  fromStatus,
-  toStatus,
-  frontmatter,
-  options
-}) {
-  const normalizedReason = typeof options.reason === "string" ? options.reason.trim() : "";
-  const reason = normalizedReason || (isRegression(fromStatus, toStatus) ? `regression: ${fromStatus} -> ${toStatus}` : void 0);
-  const event = buildTransitionEvent(task.slug, fromStatus, toStatus, {
-    confidence: options.confidence,
-    reason
-  });
-  try {
-    appendTransition(vaultPath, event);
-  } catch {
-    return frontmatter;
-  }
-  if (toStatus !== "blocked" || frontmatter.escalation) {
-    return frontmatter;
-  }
-  let blockedCount = 0;
-  try {
-    blockedCount = countBlockedTransitions(vaultPath, task.slug);
-  } catch {
-    return frontmatter;
-  }
-  if (blockedCount < 3) {
-    return frontmatter;
-  }
-  const escalatedFrontmatter = {
-    ...frontmatter,
-    escalation: true
-  };
-  try {
-    persistTaskFrontmatter(task, escalatedFrontmatter);
-    return escalatedFrontmatter;
-  } catch {
-    return frontmatter;
-  }
-}
-function readTask(vaultPath, slug) {
-  const taskPath = getTaskPath(vaultPath, slug);
-  if (!fs3.existsSync(taskPath)) {
-    return null;
-  }
-  try {
-    const raw = fs3.readFileSync(taskPath, "utf-8");
-    const { data, content } = (0, import_gray_matter2.default)(raw);
-    const title = extractTitle(content) || slug;
-    return {
-      slug,
-      title,
-      content,
-      frontmatter: data,
-      path: taskPath
-    };
-  } catch {
-    return null;
-  }
-}
-function listTasks(vaultPath, filters) {
-  const tasksDir = getTasksDir(vaultPath);
-  if (!fs3.existsSync(tasksDir)) {
-    return [];
-  }
-  const tasks = [];
-  const entries = fs3.readdirSync(tasksDir, { withFileTypes: true });
-  const today = startOfToday();
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) {
-      continue;
-    }
-    const slug = entry.name.replace(/\.md$/, "");
-    const task = readTask(vaultPath, slug);
-    if (!task) continue;
-    if (filters) {
-      if (filters.status && task.frontmatter.status !== filters.status) continue;
-      if (filters.owner && task.frontmatter.owner !== filters.owner) continue;
-      if (filters.project && task.frontmatter.project !== filters.project) continue;
-      if (filters.priority && task.frontmatter.priority !== filters.priority) continue;
-      if (filters.due && !task.frontmatter.due) continue;
-      if (filters.tag) {
-        const tags = task.frontmatter.tags || [];
-        const hasTag = tags.some((tag) => tag.toLowerCase() === filters.tag?.toLowerCase());
-        if (!hasTag) continue;
-      }
-      if (filters.overdue) {
-        const dueTime = parseDueDate(task.frontmatter.due);
-        if (task.frontmatter.status === "done" || dueTime === null || dueTime >= today) continue;
-      }
-    }
-    tasks.push(task);
-  }
-  const priorityOrder = {
-    critical: 0,
-    high: 1,
-    medium: 2,
-    low: 3
-  };
-  if (filters?.due || filters?.overdue) {
-    return tasks.sort((a, b) => {
-      const aDue = parseDueDate(a.frontmatter.due);
-      const bDue = parseDueDate(b.frontmatter.due);
-      if (aDue !== null && bDue !== null && aDue !== bDue) {
-        return aDue - bDue;
-      }
-      if (aDue !== null && bDue === null) return -1;
-      if (aDue === null && bDue !== null) return 1;
-      return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
-    });
-  }
-  return tasks.sort((a, b) => {
-    const aPriority = priorityOrder[a.frontmatter.priority || "low"];
-    const bPriority = priorityOrder[b.frontmatter.priority || "low"];
-    if (aPriority !== bPriority) {
-      return aPriority - bPriority;
-    }
-    return new Date(b.frontmatter.created).getTime() - new Date(a.frontmatter.created).getTime();
-  });
-}
-function createTask(vaultPath, title, options = {}) {
-  ensureTasksDir(vaultPath);
-  const slug = slugify(title);
-  const taskPath = getTaskPath(vaultPath, slug);
-  if (fs3.existsSync(taskPath)) {
-    throw new Error(`Task already exists: ${slug}`);
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const template = loadSchemaTemplateDefinition("task", {
-    vaultPath: path3.resolve(vaultPath)
-  });
-  let frontmatter;
-  let content;
-  if (template) {
-    const rendered = renderDocumentFromTemplate(template, {
-      title,
-      type: "task",
-      now: new Date(now),
-      variables: buildTaskTemplateVariables(title, slug, options),
-      overrides: buildTaskTemplateOverrides(options),
-      frontmatter: { pruneEmpty: true }
-    });
-    const templateFrontmatter = rendered.frontmatter;
-    frontmatter = {
-      ...templateFrontmatter,
-      status: isTaskStatus(templateFrontmatter.status) ? templateFrontmatter.status : "open",
-      created: typeof templateFrontmatter.created === "string" && templateFrontmatter.created ? templateFrontmatter.created : now,
-      updated: typeof templateFrontmatter.updated === "string" && templateFrontmatter.updated ? templateFrontmatter.updated : now
-    };
-    content = rendered.content;
-  } else {
-    frontmatter = buildTaskFrontmatterFallback(now, options);
-    content = buildTaskContentFallback(title, options);
-  }
-  const fileContent = import_gray_matter2.default.stringify(content, frontmatter);
-  fs3.writeFileSync(taskPath, fileContent);
-  return {
-    slug,
-    title,
-    content,
-    frontmatter,
-    path: taskPath
-  };
-}
-function updateTask(vaultPath, slug, updates, options = {}) {
-  const task = readTask(vaultPath, slug);
-  if (!task) {
-    throw new Error(`Task not found: ${slug}`);
-  }
-  if (updates.status !== void 0 && !isTaskStatus(updates.status)) {
-    throw new Error(`Invalid task status: ${String(updates.status)}`);
-  }
-  const previousStatus = task.frontmatter.status;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let newFrontmatter = {
-    ...task.frontmatter,
-    updated: now
-  };
-  if (updates.status !== void 0) {
-    newFrontmatter.status = updates.status;
-    if (updates.status === "done" && !newFrontmatter.completed) {
-      newFrontmatter.completed = now;
-    }
-    if (updates.status !== "done") {
-      delete newFrontmatter.completed;
-    }
-  }
-  if (updates.source !== void 0) {
-    if (updates.source === null || updates.source.trim() === "") {
-      delete newFrontmatter.source;
-    } else {
-      newFrontmatter.source = updates.source;
-    }
-  }
-  if (updates.owner !== void 0) {
-    if (updates.owner === null || updates.owner.trim() === "") {
-      delete newFrontmatter.owner;
-    } else {
-      newFrontmatter.owner = updates.owner;
-    }
-  }
-  if (updates.project !== void 0) {
-    if (updates.project === null || updates.project.trim() === "") {
-      delete newFrontmatter.project;
-    } else {
-      newFrontmatter.project = updates.project;
-    }
-  }
-  if (updates.priority !== void 0) {
-    if (updates.priority === null) {
-      delete newFrontmatter.priority;
-    } else {
-      newFrontmatter.priority = updates.priority;
-    }
-  }
-  if (updates.due !== void 0) {
-    if (updates.due === null || updates.due.trim() === "") {
-      delete newFrontmatter.due;
-    } else {
-      newFrontmatter.due = updates.due;
-    }
-  }
-  if (updates.tags !== void 0) {
-    if (updates.tags === null) {
-      delete newFrontmatter.tags;
-    } else {
-      const normalizedTags = updates.tags.map((tag) => tag.trim()).filter(Boolean);
-      if (normalizedTags.length === 0) {
-        delete newFrontmatter.tags;
-      } else {
-        newFrontmatter.tags = normalizedTags;
-      }
-    }
-  }
-  if (updates.completed !== void 0) {
-    if (updates.completed === null || updates.completed.trim() === "") {
-      delete newFrontmatter.completed;
-    } else {
-      newFrontmatter.completed = updates.completed;
-    }
-  }
-  if (updates.escalation !== void 0) {
-    if (updates.escalation === null) {
-      delete newFrontmatter.escalation;
-    } else {
-      newFrontmatter.escalation = updates.escalation;
-    }
-  }
-  if (updates.confidence !== void 0) {
-    if (updates.confidence === null) {
-      delete newFrontmatter.confidence;
-    } else {
-      newFrontmatter.confidence = updates.confidence;
-    }
-  }
-  if (updates.reason !== void 0) {
-    if (updates.reason === null || updates.reason.trim() === "") {
-      delete newFrontmatter.reason;
-    } else {
-      newFrontmatter.reason = updates.reason;
-    }
-  }
-  if (updates.description !== void 0) {
-    if (updates.description === null || updates.description.trim() === "") {
-      delete newFrontmatter.description;
-    } else {
-      newFrontmatter.description = updates.description;
-    }
-  }
-  if (updates.estimate !== void 0) {
-    if (updates.estimate === null || updates.estimate.trim() === "") {
-      delete newFrontmatter.estimate;
-    } else {
-      newFrontmatter.estimate = updates.estimate;
-    }
-  }
-  if (updates.parent !== void 0) {
-    if (updates.parent === null || updates.parent.trim() === "") {
-      delete newFrontmatter.parent;
-    } else {
-      newFrontmatter.parent = updates.parent;
-    }
-  }
-  if (updates.depends_on !== void 0) {
-    if (updates.depends_on === null) {
-      delete newFrontmatter.depends_on;
-    } else {
-      const normalizedDeps = updates.depends_on.map((dep) => dep.trim()).filter(Boolean);
-      if (normalizedDeps.length === 0) {
-        delete newFrontmatter.depends_on;
-      } else {
-        newFrontmatter.depends_on = normalizedDeps;
-      }
-    }
-  }
-  if (updates.blocked_by !== void 0) {
-    if (updates.blocked_by === null || updates.blocked_by.trim() === "") {
-      delete newFrontmatter.blocked_by;
-    } else {
-      newFrontmatter.blocked_by = updates.blocked_by;
-    }
-  } else if (updates.status !== void 0 && updates.status !== "blocked") {
-    delete newFrontmatter.blocked_by;
-  }
-  persistTaskFrontmatter(task, newFrontmatter);
-  const transition = options.skipTransition ? null : resolveStatusTransition(previousStatus, newFrontmatter.status);
-  if (transition) {
-    const confidence = options.confidence ?? (typeof updates.confidence === "number" ? updates.confidence : void 0);
-    const reason = options.reason ?? updates.reason ?? null;
-    newFrontmatter = logStatusTransition({
-      vaultPath,
-      task,
-      fromStatus: transition.fromStatus,
-      toStatus: transition.toStatus,
-      frontmatter: newFrontmatter,
-      options: {
-        confidence,
-        reason
-      }
-    });
-  }
-  return {
-    ...task,
-    frontmatter: newFrontmatter
-  };
-}
-function completeTask(vaultPath, slug, options = {}) {
-  return updateTask(vaultPath, slug, { status: "done" }, options);
-}
-function getStatusIcon(status) {
-  switch (status) {
-    case "in-progress":
-      return "\u25CF";
-    case "blocked":
-      return "\u25A0";
-    case "open":
-      return "\u25CB";
-    case "done":
-      return "\u2713";
-    default:
-      return "\u25CB";
-  }
-}
-function getStatusDisplay(status) {
-  switch (status) {
-    case "in-progress":
-      return "active";
-    case "blocked":
-      return "blocked";
-    case "open":
-      return "open";
-    case "done":
-      return "done";
-    default:
-      return status;
-  }
-}
-
-// src/commands/task.ts
-function taskAdd(vaultPath, title, options = {}) {
-  return createTask(vaultPath, title, {
-    owner: options.owner,
-    project: options.project,
-    priority: options.priority,
-    due: options.due,
-    content: options.content,
-    tags: options.tags,
-    description: options.description,
-    estimate: options.estimate,
-    parent: options.parent,
-    depends_on: options.dependsOn
-  });
-}
-function taskList(vaultPath, options = {}) {
-  const filters = {};
-  if (options.status) filters.status = options.status;
-  if (options.owner) filters.owner = options.owner;
-  if (options.project) filters.project = options.project;
-  if (options.priority) filters.priority = options.priority;
-  if (options.due) filters.due = true;
-  if (options.tag) filters.tag = options.tag;
-  if (options.overdue) filters.overdue = true;
-  const listed = listTasks(vaultPath, filters);
-  if (!options.status && !options.overdue) {
-    return listed.filter((t) => t.frontmatter.status !== "done");
-  }
-  return listed;
-}
-function taskUpdate(vaultPath, slug, options) {
-  return updateTask(vaultPath, slug, {
-    status: options.status,
-    owner: options.owner,
-    project: options.project,
-    priority: options.priority,
-    blocked_by: options.blockedBy,
-    due: options.due,
-    tags: options.tags,
-    description: options.description,
-    estimate: options.estimate,
-    parent: options.parent,
-    depends_on: options.dependsOn,
-    confidence: options.confidence,
-    reason: options.reason
-  });
-}
-function taskDone(vaultPath, slug, options = {}) {
-  return completeTask(vaultPath, slug, {
-    confidence: options.confidence,
-    reason: options.reason ?? void 0
-  });
-}
-function taskTransitions(vaultPath, taskId, options = {}) {
-  const events = queryTransitions(vaultPath, {
-    taskId,
-    agent: options.agent,
-    failed: options.failed
-  });
-  if (options.json) {
-    return JSON.stringify(events, null, 2);
-  }
-  return formatTransitionsTable(events);
-}
-function taskShow(vaultPath, slug) {
-  return readTask(vaultPath, slug);
-}
-function formatTaskList(tasks) {
-  if (tasks.length === 0) {
-    return "No tasks found.\n";
-  }
-  const headers = ["STATUS", "OWNER", "PRIORITY", "PROJECT", "META", "TITLE"];
-  const widths = [10, 12, 8, 14, 64, 32];
-  const truncate = (value, width) => {
-    if (value.length <= width) return value;
-    return value.slice(0, width - 3) + "...";
-  };
-  let output = headers.map((h, i) => h.padEnd(widths[i])).join("  ") + "\n";
-  for (const task of tasks) {
-    const icon = getStatusIcon(task.frontmatter.status);
-    const statusDisplay = getStatusDisplay(task.frontmatter.status);
-    const status = `${icon} ${statusDisplay}`;
-    const owner = task.frontmatter.owner || "-";
-    const priority = task.frontmatter.priority || "low";
-    const project = task.frontmatter.project || "-";
-    const metaParts = [];
-    if (task.frontmatter.due) metaParts.push(`due:${task.frontmatter.due.split("T")[0]}`);
-    if (task.frontmatter.tags?.length) metaParts.push(task.frontmatter.tags.map((tag) => `#${tag}`).join(","));
-    if (task.frontmatter.parent) metaParts.push(`parent:${task.frontmatter.parent}`);
-    if (task.frontmatter.depends_on?.length) {
-      metaParts.push(`deps:${task.frontmatter.depends_on.join("|")}`);
-    }
-    const meta = metaParts.length > 0 ? metaParts.join(" ") : "-";
-    const title = truncate(task.title, widths[5]);
-    const row = [
-      status.padEnd(widths[0]),
-      owner.padEnd(widths[1]),
-      priority.padEnd(widths[2]),
-      project.padEnd(widths[3]),
-      truncate(meta, widths[4]).padEnd(widths[4]),
-      title
-    ];
-    output += row.join("  ") + "\n";
-  }
-  return output;
-}
-function formatTaskDetails(task) {
-  let output = "";
-  output += `# ${task.title}
-`;
-  output += "-".repeat(40) + "\n";
-  output += `Status: ${getStatusIcon(task.frontmatter.status)} ${getStatusDisplay(task.frontmatter.status)}
-`;
-  if (task.frontmatter.owner) {
-    output += `Owner: ${task.frontmatter.owner}
-`;
-  }
-  if (task.frontmatter.project) {
-    output += `Project: ${task.frontmatter.project}
-`;
-  }
-  if (task.frontmatter.priority) {
-    output += `Priority: ${task.frontmatter.priority}
-`;
-  }
-  if (task.frontmatter.description) {
-    output += `Description: ${task.frontmatter.description}
-`;
-  }
-  if (task.frontmatter.estimate) {
-    output += `Estimate: ${task.frontmatter.estimate}
-`;
-  }
-  if (task.frontmatter.parent) {
-    output += `Parent: ${task.frontmatter.parent}
-`;
-  }
-  if (task.frontmatter.depends_on && task.frontmatter.depends_on.length > 0) {
-    output += `Depends on: ${task.frontmatter.depends_on.join(", ")}
-`;
-  }
-  if (task.frontmatter.due) {
-    output += `Due: ${task.frontmatter.due}
-`;
-  }
-  if (task.frontmatter.blocked_by) {
-    output += `Blocked by: ${task.frontmatter.blocked_by}
-`;
-  }
-  if (task.frontmatter.tags && task.frontmatter.tags.length > 0) {
-    output += `Tags: ${task.frontmatter.tags.join(", ")}
-`;
-  }
-  if (task.frontmatter.escalation) {
-    output += "Escalation: true\n";
-  }
-  if (task.frontmatter.confidence !== void 0) {
-    output += `Confidence: ${task.frontmatter.confidence}
-`;
-  }
-  if (task.frontmatter.reason) {
-    output += `Reason: ${task.frontmatter.reason}
-`;
-  }
-  output += `Created: ${task.frontmatter.created}
-`;
-  output += `Updated: ${task.frontmatter.updated}
-`;
-  if (task.frontmatter.completed) {
-    output += `Completed: ${task.frontmatter.completed}
-`;
-  }
-  output += `File: ${task.path}
-`;
-  output += "-".repeat(40) + "\n";
-  const contentWithoutTitle = task.content.replace(/^#\s+.+\n/, "").trim();
-  if (contentWithoutTitle) {
-    output += "\n" + contentWithoutTitle + "\n";
-  }
-  return output;
-}
-async function taskCommand(vaultPath, action, args) {
-  const options = args.options || {};
-  switch (action) {
-    case "add": {
-      if (!args.title) {
-        throw new Error("Title is required for task add");
-      }
-      const task = taskAdd(vaultPath, args.title, options);
-      console.log(`\u2713 Created task: ${task.slug}`);
-      console.log(`  Path: ${task.path}`);
-      break;
-    }
-    case "list": {
-      const tasks = taskList(vaultPath, options);
-      if (options.json) {
-        console.log(JSON.stringify(tasks, null, 2));
-      } else {
-        console.log(formatTaskList(tasks));
-      }
-      break;
-    }
-    case "update": {
-      if (!args.slug) {
-        throw new Error("Task slug is required for update");
-      }
-      const task = taskUpdate(vaultPath, args.slug, options);
-      console.log(`\u2713 Updated task: ${task.slug}`);
-      break;
-    }
-    case "done": {
-      if (!args.slug) {
-        throw new Error("Task slug is required for done");
-      }
-      const task = taskDone(vaultPath, args.slug, {
-        confidence: options.confidence,
-        reason: options.reason ?? void 0
-      });
-      console.log(`\u2713 Completed task: ${task.slug}`);
-      break;
-    }
-    case "transitions": {
-      const output = taskTransitions(vaultPath, args.slug, {
-        agent: options.agent,
-        failed: options.failed,
-        json: options.json
-      });
-      console.log(output);
-      break;
-    }
-    case "show": {
-      if (!args.slug) {
-        throw new Error("Task slug is required for show");
-      }
-      const task = taskShow(vaultPath, args.slug);
-      if (!task) {
-        throw new Error(`Task not found: ${args.slug}`);
-      }
-      if (options.json) {
-        console.log(JSON.stringify(task, null, 2));
-      } else {
-        console.log(formatTaskDetails(task));
-      }
-      break;
-    }
-    default:
-      throw new Error(`Unknown task action: ${action}`);
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatTaskDetails,
-  formatTaskList,
-  taskAdd,
-  taskCommand,
-  taskDone,
-  taskList,
-  taskShow,
-  taskTransitions,
-  taskUpdate
-});