clawvault 3.0.0 → 3.2.0

package/dist/chunk-GGA32J2R.js

@@ -0,0 +1,784 @@
+import {
+  block,
+  claim,
+  createThread,
+  decompose,
+  done,
+  release
+} from "./chunk-VSL7KY3M.js";
+import {
+  create,
+  list,
+  read
+} from "./chunk-QVEERJSP.js";
+import {
+  allClaims,
+  readAll,
+  recent
+} from "./chunk-4BQTQMJP.js";
+import {
+  defineType,
+  listTypes
+} from "./chunk-MM6QGW3P.js";
+
+// src/commands/workgraph.ts
+import os from "os";
+import path from "path";
+import chalk from "chalk";
+var BOX = {
+  topLeft: "\u256D",
+  topRight: "\u256E",
+  bottomLeft: "\u2570",
+  bottomRight: "\u256F",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  teeRight: "\u251C",
+  teeLeft: "\u2524",
+  teeDown: "\u252C",
+  teeUp: "\u2534",
+  cross: "\u253C"
+};
+var PRIORITY_CONFIG = {
+  urgent: { color: chalk.red, symbol: "\u{1F534}", label: "URGENT" },
+  high: { color: chalk.yellow, symbol: "\u{1F7E0}", label: "HIGH" },
+  medium: { color: chalk.blue, symbol: "\u{1F535}", label: "MEDIUM" },
+  low: { color: chalk.gray, symbol: "\u26AA", label: "LOW" }
+};
+var STATUS_CONFIG = {
+  open: { color: chalk.cyan, symbol: "\u25CB", label: "Open" },
+  active: { color: chalk.green, symbol: "\u25CF", label: "Active" },
+  blocked: { color: chalk.red, symbol: "\u2298", label: "Blocked" },
+  done: { color: chalk.gray, symbol: "\u2713", label: "Done" },
+  cancelled: { color: chalk.dim, symbol: "\u2717", label: "Cancelled" }
+};
+var OP_COLORS = {
+  create: chalk.green,
+  update: chalk.blue,
+  delete: chalk.red,
+  claim: chalk.yellow,
+  release: chalk.cyan,
+  block: chalk.red,
+  unblock: chalk.green,
+  done: chalk.greenBright,
+  cancel: chalk.gray,
+  define: chalk.magenta,
+  decompose: chalk.cyan
+};
+function getAgentName() {
+  return process.env.CLAWVAULT_AGENT ?? os.hostname();
+}
+function resolveVaultPath(optionPath) {
+  return path.resolve(optionPath ?? process.env.CLAWVAULT_PATH ?? process.cwd());
+}
+function formatRelativeTime(isoTimestamp) {
+  const now = Date.now();
+  const then = new Date(isoTimestamp).getTime();
+  const diffMs = now - then;
+  if (diffMs < 0) return "just now";
+  const seconds = Math.floor(diffMs / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  if (weeks > 0) return `${weeks}w ago`;
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  if (seconds > 0) return `${seconds}s ago`;
+  return "just now";
+}
+function drawLine(width, title) {
+  if (!title) {
+    return BOX.horizontal.repeat(width);
+  }
+  const titlePadded = ` ${title} `;
+  const remaining = width - titlePadded.length - 2;
+  const left = Math.floor(remaining / 2);
+  const right = remaining - left;
+  return BOX.horizontal.repeat(left) + chalk.bold(titlePadded) + BOX.horizontal.repeat(right);
+}
+function drawBox(title, lines, width = 60) {
+  const innerWidth = width - 2;
+  const output = [];
+  output.push(BOX.topLeft + drawLine(innerWidth, title) + BOX.topRight);
+  for (const line of lines) {
+    const stripped = stripAnsi(line);
+    const padding = innerWidth - stripped.length;
+    output.push(BOX.vertical + line + " ".repeat(Math.max(0, padding)) + BOX.vertical);
+  }
+  output.push(BOX.bottomLeft + BOX.horizontal.repeat(innerWidth) + BOX.bottomRight);
+  return output.join("\n");
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 1) + "\u2026";
+}
+function formatThreadLine(inst, showOwner = true) {
+  const status = inst.fields.status;
+  const priority = inst.fields.priority ?? "medium";
+  const title = truncate(String(inst.fields.title ?? inst.path), 40);
+  const owner = inst.fields.owner;
+  const statusCfg = STATUS_CONFIG[status] ?? STATUS_CONFIG.open;
+  const priorityCfg = PRIORITY_CONFIG[priority] ?? PRIORITY_CONFIG.medium;
+  let line = `${statusCfg.color(statusCfg.symbol)} ${priorityCfg.symbol} ${chalk.white(title)}`;
+  if (showOwner && owner) {
+    line += chalk.dim(` @${owner}`);
+  }
+  return line;
+}
+function parseList(value) {
+  if (!value) return [];
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function formatError(what, why, fix) {
+  return [
+    "",
+    chalk.red.bold("\u2717 Error: ") + chalk.red(what),
+    "",
+    chalk.dim("Why: ") + why,
+    chalk.dim("Fix: ") + chalk.cyan(fix),
+    ""
+  ].join("\n");
+}
+async function statusCommand(vaultPath) {
+  const agentName = getAgentName();
+  const now = /* @__PURE__ */ new Date();
+  const greeting = getGreeting(now.getHours());
+  console.log("");
+  console.log(chalk.bold.cyan(`${greeting}, ${agentName}!`));
+  console.log(chalk.dim(`${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })}`));
+  console.log("");
+  const allThreads = list(vaultPath, "thread");
+  const activeThreads = allThreads.filter((t) => t.fields.status === "active");
+  const openThreads = allThreads.filter((t) => t.fields.status === "open");
+  const blockedThreads = allThreads.filter((t) => t.fields.status === "blocked");
+  const myActiveThreads = activeThreads.filter((t) => t.fields.owner === agentName);
+  if (myActiveThreads.length > 0) {
+    const activeLines = myActiveThreads.map((t) => formatThreadLine(t, false));
+    console.log(drawBox("\u{1F525} Your Active Work", activeLines, 65));
+    console.log("");
+  }
+  if (openThreads.length > 0) {
+    const sorted = sortByPriority(openThreads);
+    const availableLines = sorted.slice(0, 5).map((t) => formatThreadLine(t, false));
+    if (sorted.length > 5) {
+      availableLines.push(chalk.dim(`  ... and ${sorted.length - 5} more`));
+    }
+    console.log(drawBox("\u{1F4CB} Available Work", availableLines, 65));
+    console.log("");
+  }
+  if (blockedThreads.length > 0) {
+    const blockedLines = blockedThreads.slice(0, 3).map((t) => {
+      const title = truncate(String(t.fields.title ?? t.path), 35);
+      const deps = t.fields.deps ?? [];
+      const depStr = deps.length > 0 ? chalk.dim(` \u2192 ${deps[0]}`) : "";
+      return `${STATUS_CONFIG.blocked.color(STATUS_CONFIG.blocked.symbol)} ${title}${depStr}`;
+    });
+    console.log(drawBox("\u26D4 Blocked", blockedLines, 65));
+    console.log("");
+  }
+  const recentEntries = recent(vaultPath, 8);
+  if (recentEntries.length > 0) {
+    const activityLines = recentEntries.reverse().map((e) => {
+      const opColor = OP_COLORS[e.op] ?? chalk.white;
+      const target = truncate(path.basename(e.target, ".md"), 25);
+      const time = formatRelativeTime(e.ts);
+      return `${opColor(e.op.padEnd(8))} ${chalk.white(target)} ${chalk.dim(time)}`;
+    });
+    console.log(drawBox("\u{1F4DC} Recent Activity", activityLines, 65));
+    console.log("");
+  }
+  const claims = allClaims(vaultPath);
+  const teamMembers = /* @__PURE__ */ new Map();
+  for (const [target, owner] of claims) {
+    const current = teamMembers.get(owner) ?? [];
+    current.push(target);
+    teamMembers.set(owner, current);
+  }
+  if (teamMembers.size > 0) {
+    const teamLines = [];
+    for (const [member, threads] of teamMembers) {
+      const isYou = member === agentName;
+      const name = isYou ? chalk.green(`${member} (you)`) : chalk.white(member);
+      teamLines.push(`${chalk.cyan("\u25CF")} ${name}: ${chalk.dim(`${threads.length} active`)}`);
+    }
+    console.log(drawBox("\u{1F465} Team Status", teamLines, 65));
+    console.log("");
+  }
+  const summaryParts = [
+    chalk.green(`${activeThreads.length} active`),
+    chalk.cyan(`${openThreads.length} open`),
+    chalk.red(`${blockedThreads.length} blocked`)
+  ];
+  console.log(chalk.dim("Summary: ") + summaryParts.join(chalk.dim(" \xB7 ")));
+  console.log("");
+}
+function getGreeting(hour) {
+  if (hour < 12) return "\u2600\uFE0F  Good morning";
+  if (hour < 17) return "\u{1F324}\uFE0F  Good afternoon";
+  return "\u{1F319} Good evening";
+}
+function sortByPriority(threads) {
+  const priorityOrder = { urgent: 0, high: 1, medium: 2, low: 3 };
+  return [...threads].sort((a, b) => {
+    const priorityA = String(a.fields.priority ?? "medium");
+    const priorityB = String(b.fields.priority ?? "medium");
+    const pa = priorityOrder[priorityA] ?? 2;
+    const pb = priorityOrder[priorityB] ?? 2;
+    return pa - pb;
+  });
+}
+async function threadCreateCommand(vaultPath, title, options) {
+  const agentName = getAgentName();
+  const goal = options.goal ?? `Complete: ${title}`;
+  const priority = options.priority ?? "medium";
+  const deps = parseList(options.deps);
+  const tags = parseList(options.tags);
+  try {
+    const inst = createThread(vaultPath, title, goal, agentName, {
+      priority,
+      deps,
+      tags
+    });
+    console.log("");
+    console.log(chalk.green.bold("\u2713 Thread created"));
+    console.log("");
+    console.log(chalk.dim("  Path:     ") + chalk.white(inst.path));
+    console.log(chalk.dim("  Title:    ") + chalk.white(inst.fields.title));
+    console.log(chalk.dim("  Goal:     ") + chalk.white(inst.fields.goal));
+    console.log(chalk.dim("  Priority: ") + formatPriority(priority));
+    if (deps.length > 0) {
+      console.log(chalk.dim("  Deps:     ") + chalk.cyan(deps.join(", ")));
+    }
+    if (tags.length > 0) {
+      console.log(chalk.dim("  Tags:     ") + chalk.magenta(tags.join(", ")));
+    }
+    console.log("");
+    console.log(chalk.dim(`Claim it: ${chalk.cyan(`clawvault wg thread claim ${inst.path}`)}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to create thread",
+      message,
+      "Check the title is unique and vault path is correct"
+    ));
+    process.exitCode = 1;
+  }
+}
+function formatPriority(priority) {
+  const cfg = PRIORITY_CONFIG[priority] ?? PRIORITY_CONFIG.medium;
+  return cfg.color(`${cfg.symbol} ${cfg.label}`);
+}
+async function threadListCommand(vaultPath, options) {
+  let threads = list(vaultPath, "thread");
+  if (options.status) {
+    threads = threads.filter((t) => t.fields.status === options.status);
+  }
+  if (options.owner) {
+    const ownerFilter = options.owner === "me" ? getAgentName() : options.owner;
+    threads = threads.filter((t) => t.fields.owner === ownerFilter);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(threads, null, 2));
+    return;
+  }
+  if (threads.length === 0) {
+    console.log("");
+    console.log(chalk.dim("No threads found matching filters."));
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(chalk.bold(`Threads (${threads.length})`));
+  console.log(chalk.dim("\u2500".repeat(70)));
+  const sorted = sortByPriority(threads);
+  for (const t of sorted) {
+    const status = t.fields.status;
+    const priority = t.fields.priority ?? "medium";
+    const title = truncate(String(t.fields.title ?? t.path), 35);
+    const owner = t.fields.owner;
+    const updated = formatRelativeTime(String(t.fields.updated));
+    const statusCfg = STATUS_CONFIG[status] ?? STATUS_CONFIG.open;
+    const priorityCfg = PRIORITY_CONFIG[priority] ?? PRIORITY_CONFIG.medium;
+    let line = `${statusCfg.color(statusCfg.symbol.padEnd(2))}`;
+    line += `${priorityCfg.symbol} `;
+    line += chalk.white(title.padEnd(37));
+    line += owner ? chalk.cyan(`@${owner}`.padEnd(15)) : " ".repeat(15);
+    line += chalk.dim(updated);
+    console.log(line);
+  }
+  console.log(chalk.dim("\u2500".repeat(70)));
+  console.log("");
+}
+async function threadClaimCommand(vaultPath, threadPath) {
+  const agentName = getAgentName();
+  const normalizedPath = normalizeThreadPath(threadPath);
+  try {
+    const inst = claim(vaultPath, normalizedPath, agentName);
+    console.log("");
+    console.log(chalk.green.bold("\u2713 Thread claimed"));
+    console.log("");
+    const briefLines = [
+      chalk.dim("Title:    ") + chalk.white.bold(inst.fields.title),
+      chalk.dim("Goal:     ") + chalk.white(inst.fields.goal),
+      chalk.dim("Priority: ") + formatPriority(String(inst.fields.priority ?? "medium"))
+    ];
+    const deps = inst.fields.deps ?? [];
+    if (deps.length > 0) {
+      briefLines.push(chalk.dim("Deps:     ") + chalk.cyan(deps.join(", ")));
+    }
+    const contextRefs = inst.fields.context_refs ?? [];
+    if (contextRefs.length > 0) {
+      briefLines.push(chalk.dim("Context:  ") + chalk.magenta(contextRefs.join(", ")));
+    }
+    console.log(drawBox("\u{1F4CB} Work Brief", briefLines, 65));
+    console.log("");
+    if (inst.body && inst.body.trim()) {
+      console.log(chalk.dim("\u2500".repeat(65)));
+      console.log(chalk.dim("Notes:"));
+      console.log(inst.body.trim().split("\n").slice(0, 10).join("\n"));
+      console.log(chalk.dim("\u2500".repeat(65)));
+      console.log("");
+    }
+    console.log(chalk.dim(`When done: ${chalk.cyan(`clawvault wg thread done ${normalizedPath}`)}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to claim thread",
+      message,
+      'Ensure the thread exists and is in "open" status'
+    ));
+    process.exitCode = 1;
+  }
+}
+function normalizeThreadPath(input) {
+  if (input.startsWith("threads/")) return input;
+  if (input.endsWith(".md")) return `threads/${input}`;
+  return `threads/${input}.md`;
+}
+async function threadDoneCommand(vaultPath, threadPath, options) {
+  const agentName = getAgentName();
+  const normalizedPath = normalizeThreadPath(threadPath);
+  try {
+    const inst = done(vaultPath, normalizedPath, agentName, options.output);
+    console.log("");
+    console.log(chalk.green.bold("\u2713 Thread completed!"));
+    console.log("");
+    console.log(chalk.dim("  Title:  ") + chalk.white(inst.fields.title));
+    console.log(chalk.dim("  Status: ") + chalk.green("done"));
+    if (options.output) {
+      console.log(chalk.dim("  Output: ") + chalk.white(truncate(options.output, 50)));
+    }
+    console.log("");
+    console.log(chalk.dim("Great work! \u{1F389}"));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to complete thread",
+      message,
+      'Ensure you own the thread and it is in "active" status'
+    ));
+    process.exitCode = 1;
+  }
+}
+async function threadBlockCommand(vaultPath, threadPath, options) {
+  const agentName = getAgentName();
+  const normalizedPath = normalizeThreadPath(threadPath);
+  if (!options.by) {
+    console.error(formatError(
+      "Missing --by option",
+      "You must specify what is blocking this thread",
+      'clawvault wg thread block <path> --by "reason or dependency"'
+    ));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const inst = block(vaultPath, normalizedPath, agentName, options.by, options.reason);
+    console.log("");
+    console.log(chalk.yellow.bold("\u2298 Thread blocked"));
+    console.log("");
+    console.log(chalk.dim("  Title:      ") + chalk.white(inst.fields.title));
+    console.log(chalk.dim("  Blocked by: ") + chalk.red(options.by));
+    if (options.reason) {
+      console.log(chalk.dim("  Reason:     ") + chalk.white(options.reason));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to block thread",
+      message,
+      'Ensure the thread exists and is in "active" status'
+    ));
+    process.exitCode = 1;
+  }
+}
+async function threadReleaseCommand(vaultPath, threadPath, options) {
+  const agentName = getAgentName();
+  const normalizedPath = normalizeThreadPath(threadPath);
+  try {
+    const inst = release(vaultPath, normalizedPath, agentName, options.reason);
+    console.log("");
+    console.log(chalk.cyan.bold("\u21A9 Thread released"));
+    console.log("");
+    console.log(chalk.dim("  Title:  ") + chalk.white(inst.fields.title));
+    console.log(chalk.dim("  Status: ") + chalk.cyan("open"));
+    if (options.reason) {
+      console.log(chalk.dim("  Reason: ") + chalk.white(options.reason));
+    }
+    console.log("");
+    console.log(chalk.dim("Thread is now available for others to claim."));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to release thread",
+      message,
+      "Ensure you own the thread"
+    ));
+    process.exitCode = 1;
+  }
+}
+async function threadDecomposeCommand(vaultPath, threadPath, options) {
+  const agentName = getAgentName();
+  const normalizedPath = normalizeThreadPath(threadPath);
+  if (!options.into || options.into.length === 0) {
+    console.error(formatError(
+      "Missing --into option",
+      "You must specify sub-thread titles",
+      'clawvault wg thread decompose <path> --into "sub1" --into "sub2"'
+    ));
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const parent = read(vaultPath, normalizedPath);
+    if (!parent) {
+      throw new Error(`Thread not found: ${normalizedPath}`);
+    }
+    const subthreads = options.into.map((title) => ({
+      title,
+      goal: `Sub-task of: ${parent.fields.title}`
+    }));
+    const created = decompose(vaultPath, normalizedPath, subthreads, agentName);
+    console.log("");
+    console.log(chalk.green.bold("\u2713 Thread decomposed"));
+    console.log("");
+    console.log(chalk.dim("  Parent: ") + chalk.white(parent.fields.title));
+    console.log(chalk.dim("  Created sub-threads:"));
+    for (const sub of created) {
+      console.log(chalk.cyan(`    \u2192 ${sub.fields.title}`));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to decompose thread",
+      message,
+      "Ensure the thread exists"
+    ));
+    process.exitCode = 1;
+  }
+}
+async function ledgerCommand(vaultPath, options) {
+  let entries = readAll(vaultPath);
+  if (options.actor) {
+    const actorFilter = options.actor === "me" ? getAgentName() : options.actor;
+    entries = entries.filter((e) => e.actor === actorFilter);
+  }
+  if (options.target) {
+    entries = entries.filter((e) => e.target.includes(options.target));
+  }
+  const limit = options.last ?? 20;
+  entries = entries.slice(-limit);
+  if (options.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log("");
+    console.log(chalk.dim("No ledger entries found."));
+    console.log("");
+    return;
+  }
+  console.log("");
+  console.log(chalk.bold(`Ledger (last ${entries.length} entries)`));
+  console.log(chalk.dim("\u2500".repeat(80)));
+  for (const entry of entries.reverse()) {
+    const opColor = OP_COLORS[entry.op] ?? chalk.white;
+    const time = formatRelativeTime(entry.ts);
+    const target = truncate(entry.target, 30);
+    const actor = entry.actor;
+    let line = chalk.dim(time.padEnd(10));
+    line += opColor(entry.op.toUpperCase().padEnd(10));
+    line += chalk.white(target.padEnd(32));
+    line += chalk.cyan(`@${actor}`);
+    console.log(line);
+    if (entry.data && Object.keys(entry.data).length > 0) {
+      const dataStr = JSON.stringify(entry.data);
+      console.log(chalk.dim(`           ${truncate(dataStr, 68)}`));
+    }
+  }
+  console.log(chalk.dim("\u2500".repeat(80)));
+  console.log("");
+}
+async function defineCommand(vaultPath, typeName, options) {
+  const agentName = getAgentName();
+  const description = options.description ?? `Custom type: ${typeName}`;
+  const fields = {};
+  if (options.fields) {
+    const fieldPairs = options.fields.split(",");
+    for (const pair of fieldPairs) {
+      const [name, type] = pair.split(":").map((s) => s.trim());
+      if (name && type) {
+        fields[name] = { type };
+      }
+    }
+  }
+  try {
+    const typeDef = defineType(
+      vaultPath,
+      typeName,
+      description,
+      fields,
+      agentName,
+      options.dir
+    );
+    console.log("");
+    console.log(chalk.green.bold("\u2713 Type defined"));
+    console.log("");
+    console.log(chalk.dim("  Name:      ") + chalk.magenta(typeDef.name));
+    console.log(chalk.dim("  Directory: ") + chalk.white(typeDef.directory));
+    console.log(chalk.dim("  Fields:"));
+    for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {
+      const required = fieldDef.required ? chalk.red("*") : " ";
+      console.log(chalk.dim(`    ${required} ${fieldName}: ${fieldDef.type}`));
+    }
+    console.log("");
+    console.log(chalk.dim(`Create instances: ${chalk.cyan(`clawvault wg create ${typeDef.name} "title"`)}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      "Failed to define type",
+      message,
+      "Ensure the type name is unique and not a built-in type"
+    ));
+    process.exitCode = 1;
+  }
+}
+async function typesCommand(vaultPath, options) {
+  const types = listTypes(vaultPath);
+  if (options.json) {
+    console.log(JSON.stringify(types, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(chalk.bold(`Primitive Types (${types.length})`));
+  console.log(chalk.dim("\u2500".repeat(70)));
+  for (const typeDef of types) {
+    const builtInBadge = typeDef.builtIn ? chalk.cyan(" [built-in]") : chalk.magenta(" [custom]");
+    console.log("");
+    console.log(chalk.white.bold(typeDef.name) + builtInBadge);
+    console.log(chalk.dim(`  ${typeDef.description}`));
+    console.log(chalk.dim(`  Directory: ${typeDef.directory}/`));
+    console.log(chalk.dim("  Fields:"));
+    const fieldEntries = Object.entries(typeDef.fields);
+    for (const [fieldName, fieldDef] of fieldEntries) {
+      const required = fieldDef.required ? chalk.red("*") : " ";
+      const defaultVal = fieldDef.default !== void 0 ? chalk.dim(` = ${JSON.stringify(fieldDef.default)}`) : "";
+      const desc = fieldDef.description ? chalk.dim(` \u2014 ${fieldDef.description}`) : "";
+      console.log(`    ${required} ${chalk.cyan(fieldName)}: ${fieldDef.type}${defaultVal}${desc}`);
+    }
+  }
+  console.log("");
+  console.log(chalk.dim("\u2500".repeat(70)));
+  console.log("");
+}
+async function createCommand(vaultPath, typeName, title, options) {
+  const agentName = getAgentName();
+  const body = options.body ?? "";
+  const fields = { title };
+  const knownOptions = /* @__PURE__ */ new Set(["body", "vault"]);
+  for (const [key, value] of Object.entries(options)) {
+    if (!knownOptions.has(key) && value !== void 0) {
+      fields[key] = value;
+    }
+  }
+  try {
+    const inst = create(vaultPath, typeName, fields, body, agentName);
+    console.log("");
+    console.log(chalk.green.bold(`\u2713 ${typeName} created`));
+    console.log("");
+    console.log(chalk.dim("  Path:  ") + chalk.white(inst.path));
+    console.log(chalk.dim("  Title: ") + chalk.white(inst.fields.title));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(formatError(
+      `Failed to create ${typeName}`,
+      message,
+      `Ensure the type "${typeName}" exists. Run: clawvault wg types`
+    ));
+    process.exitCode = 1;
+  }
+}
+async function boardCommand(vaultPath, options) {
+  const threads = list(vaultPath, "thread");
+  const termWidth = options.width ?? process.stdout.columns ?? 120;
+  const columns = {
+    open: [],
+    active: [],
+    blocked: [],
+    done: [],
+    cancelled: []
+  };
+  for (const t of threads) {
+    const status = t.fields.status;
+    if (columns[status]) {
+      columns[status].push(t);
+    }
+  }
+  for (const status of Object.keys(columns)) {
+    columns[status] = sortByPriority(columns[status]);
+  }
+  const visibleStatuses = ["open", "active", "blocked", "done"];
+  const colWidth = Math.floor((termWidth - visibleStatuses.length - 1) / visibleStatuses.length);
+  const cardWidth = colWidth - 4;
+  console.log("");
+  console.log(chalk.bold.cyan("\u2554" + "\u2550".repeat(termWidth - 2) + "\u2557"));
+  console.log(chalk.bold.cyan("\u2551") + chalk.bold(" WORKGRAPH BOARD").padEnd(termWidth - 2) + chalk.bold.cyan("\u2551"));
+  console.log(chalk.bold.cyan("\u255A" + "\u2550".repeat(termWidth - 2) + "\u255D"));
+  console.log("");
+  let headerLine = "";
+  for (const status of visibleStatuses) {
+    const cfg = STATUS_CONFIG[status];
+    const header = `${cfg.symbol} ${cfg.label} (${columns[status].length})`;
+    const padded = header.padEnd(colWidth);
+    headerLine += cfg.color(padded);
+  }
+  console.log(headerLine);
+  console.log(chalk.dim("\u2500".repeat(termWidth)));
+  const maxRows = Math.max(...visibleStatuses.map((s) => columns[s].length), 1);
+  for (let row = 0; row < Math.min(maxRows, 15); row++) {
+    let line = "";
+    for (const status of visibleStatuses) {
+      const t = columns[status][row];
+      if (t) {
+        const card = formatBoardCard(t, cardWidth);
+        line += card.padEnd(colWidth);
+      } else {
+        line += " ".repeat(colWidth);
+      }
+    }
+    console.log(line);
+  }
+  if (maxRows > 15) {
+    console.log(chalk.dim(`... and ${maxRows - 15} more rows`));
+  }
+  console.log("");
+  console.log(chalk.dim("\u2500".repeat(termWidth)));
+  const legendParts = Object.entries(PRIORITY_CONFIG).map(
+    ([, cfg]) => `${cfg.symbol} ${cfg.label}`
+  );
+  console.log(chalk.dim("Priority: ") + legendParts.join(chalk.dim(" \xB7 ")));
+  console.log("");
+}
+function formatBoardCard(t, width) {
+  const priority = t.fields.priority ?? "medium";
+  const title = truncate(String(t.fields.title ?? t.path), width - 4);
+  const owner = t.fields.owner;
+  const priorityCfg = PRIORITY_CONFIG[priority] ?? PRIORITY_CONFIG.medium;
+  let card = `${priorityCfg.symbol} ${title}`;
+  if (owner) {
+    card += chalk.dim(` @${truncate(owner, 8)}`);
+  }
+  return card;
+}
+function registerWorkgraphCommands(program) {
+  const wg = program.command("wg").description("Workgraph \u2014 multi-agent coordination primitives");
+  wg.command("status").description("Agent morning briefing with active work, available tasks, and team status").option("-v, --vault <path>", "Vault path").action(async (options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await statusCommand(vaultPath);
+  });
+  const threadCmd = wg.command("thread").description("Thread lifecycle operations");
+  threadCmd.command("create <title>").description("Create a new thread").option("--goal <goal>", "What success looks like").option("--priority <priority>", "urgent | high | medium | low", "medium").option("--deps <deps>", "Comma-separated dependency paths").option("--tags <tags>", "Comma-separated tags").option("-v, --vault <path>", "Vault path").action(async (title, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadCreateCommand(vaultPath, title, options);
+  });
+  threadCmd.command("list").description("List threads with optional filters").option("--status <status>", "Filter by status: open | active | blocked | done | cancelled").option("--owner <owner>", 'Filter by owner (use "me" for current agent)').option("--json", "Output as JSON").option("-v, --vault <path>", "Vault path").action(async (options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadListCommand(vaultPath, options);
+  });
+  threadCmd.command("claim <path>").description("Claim a thread and show work brief").option("-v, --vault <path>", "Vault path").action(async (threadPath, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadClaimCommand(vaultPath, threadPath);
+  });
+  threadCmd.command("done <path>").description("Mark thread as complete").option("--output <output>", "Completion summary or output").option("-v, --vault <path>", "Vault path").action(async (threadPath, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadDoneCommand(vaultPath, threadPath, options);
+  });
+  threadCmd.command("block <path>").description("Block thread on a dependency").requiredOption("--by <blocker>", "What is blocking this thread").option("--reason <reason>", "Additional context").option("-v, --vault <path>", "Vault path").action(async (threadPath, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadBlockCommand(vaultPath, threadPath, options);
+  });
+  threadCmd.command("release <path>").description("Release thread back to the pool").option("--reason <reason>", "Why releasing").option("-v, --vault <path>", "Vault path").action(async (threadPath, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadReleaseCommand(vaultPath, threadPath, options);
+  });
+  threadCmd.command("decompose <path>").description("Break thread into sub-threads").option("--into <titles...>", "Sub-thread titles").option("-v, --vault <path>", "Vault path").action(async (threadPath, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await threadDecomposeCommand(vaultPath, threadPath, { into: options.into ?? [] });
+  });
+  wg.command("ledger").description("View coordination history").option("--last <n>", "Number of entries to show", "20").option("--actor <actor>", 'Filter by actor (use "me" for current agent)').option("--target <target>", "Filter by target path substring").option("--json", "Output as JSON").option("-v, --vault <path>", "Vault path").action(async (options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await ledgerCommand(vaultPath, {
+      last: options.last ? parseInt(options.last, 10) : 20,
+      actor: options.actor,
+      target: options.target,
+      json: options.json
+    });
+  });
+  wg.command("define <type>").description("Define a new primitive type").option("--fields <fields>", "Comma-separated field definitions (name:type)").option("--dir <directory>", "Custom directory for instances").option("--description <desc>", "Type description").option("-v, --vault <path>", "Vault path").action(async (typeName, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await defineCommand(vaultPath, typeName, options);
+  });
+  wg.command("types").description("List all primitive types with their fields").option("--json", "Output as JSON").option("-v, --vault <path>", "Vault path").action(async (options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await typesCommand(vaultPath, options);
+  });
+  wg.command("create <type> <title>").description("Create any primitive instance").option("--body <body>", "Markdown body content").option("-v, --vault <path>", "Vault path").allowUnknownOption(true).action(async (typeName, title, options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await createCommand(vaultPath, typeName, title, options);
+  });
+  wg.command("board").description("Terminal kanban board view").option("--width <width>", "Terminal width override").option("-v, --vault <path>", "Vault path").action(async (options) => {
+    const vaultPath = resolveVaultPath(options.vault);
+    await boardCommand(vaultPath, {
+      width: options.width ? parseInt(options.width, 10) : void 0
+    });
+  });
+}
+
+export {
+  statusCommand,
+  threadCreateCommand,
+  threadListCommand,
+  threadClaimCommand,
+  threadDoneCommand,
+  threadBlockCommand,
+  threadReleaseCommand,
+  threadDecomposeCommand,
+  ledgerCommand,
+  defineCommand,
+  typesCommand,
+  createCommand,
+  boardCommand,
+  registerWorkgraphCommands
+};