@versatly/workgraph 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,19 +1,33 @@
 import {
   bases_exports,
+  board_exports,
+  clawdapus_exports,
   command_center_exports,
+  integration_exports,
+  onboard_exports,
+  search_qmd_adapter_exports,
+  skill_exports,
+  trigger_exports,
+  workspace_exports
+} from "./chunk-E3QU5Y53.js";
+import {
+  dispatch_exports,
+  graph_exports,
   ledger_exports,
+  mcp_server_exports,
+  orientation_exports,
+  policy_exports,
+  query_exports,
   registry_exports,
-  skill_exports,
   store_exports,
-  thread_exports,
-  workspace_exports
-} from "./chunk-CRQXDCPR.js";
+  thread_exports
+} from "./chunk-65ZMX2WM.js";
 
 // src/cli.ts
 import fs from "fs";
 import path from "path";
 import { Command } from "commander";
-var DEFAULT_ACTOR = process.env.WORKGRAPH_AGENT || process.env.CLAWVAULT_AGENT || process.env.USER || "anonymous";
+var DEFAULT_ACTOR = process.env.WORKGRAPH_AGENT || process.env.USER || "anonymous";
 var CLI_VERSION = (() => {
   try {
     const pkgUrl = new URL("../package.json", import.meta.url);
@@ -271,7 +285,7 @@ addWorkspaceOption(
 );
 var basesCmd = program.command("bases").description("Generate Obsidian .base files from primitive-registry.yaml");
 addWorkspaceOption(
-  basesCmd.command("sync-registry").description("Sync .clawvault/primitive-registry.yaml from active registry").option("--json", "Emit structured JSON output")
+  basesCmd.command("sync-registry").description("Sync .workgraph/primitive-registry.yaml from active registry").option("--json", "Emit structured JSON output")
 ).action(
   (opts) => runCommand(
     opts,
@@ -280,7 +294,7 @@ addWorkspaceOption(
       const manifest = bases_exports.syncPrimitiveRegistryManifest(workspacePath);
       return {
         primitiveCount: manifest.primitives.length,
-        manifestPath: ".clawvault/primitive-registry.yaml"
+        manifestPath: ".workgraph/primitive-registry.yaml"
       };
     },
     (result) => [
@@ -290,7 +304,7 @@ addWorkspaceOption(
   )
 );
 addWorkspaceOption(
-  basesCmd.command("generate").description("Generate .base files by reading primitive-registry.yaml").option("--all", "Include non-canonical primitives").option("--refresh-registry", "Refresh primitive-registry.yaml before generation").option("--output-dir <path>", "Output directory for .base files (default: .clawvault/bases)").option("--json", "Emit structured JSON output")
+  basesCmd.command("generate").description("Generate .base files by reading primitive-registry.yaml").option("--all", "Include non-canonical primitives").option("--refresh-registry", "Refresh primitive-registry.yaml before generation").option("--output-dir <path>", "Output directory for .base files (default: .workgraph/bases)").option("--json", "Emit structured JSON output")
 ).action(
   (opts) => runCommand(
     opts,
@@ -330,17 +344,7 @@ addWorkspaceOption(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
-      const fields = { title };
-      for (const pair of opts.set ?? []) {
-        const eqIdx = String(pair).indexOf("=");
-        if (eqIdx === -1) continue;
-        const key = String(pair).slice(0, eqIdx).trim();
-        let value = String(pair).slice(eqIdx + 1).trim();
-        if (typeof value === "string" && value.includes(",")) {
-          value = value.split(",").map((v) => v.trim());
-        }
-        fields[key] = value;
-      }
+      const fields = { title, ...parseSetPairs(opts.set ?? []) };
       return {
         instance: store_exports.create(workspacePath, type, fields, opts.body, opts.actor)
       };
@@ -348,9 +352,28 @@ addWorkspaceOption(
     (result) => [`Created ${result.instance.type}: ${result.instance.path}`]
   )
 );
+addWorkspaceOption(
+  primitiveCmd.command("update <path>").description("Update an existing primitive instance").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--set <fields...>", 'Set fields as "key=value"').option("--body <text>", "Replace markdown body content").option("--body-file <path>", "Read markdown body content from file").option("--json", "Emit structured JSON output")
+).action(
+  (targetPath, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const updates = parseSetPairs(opts.set ?? []);
+      let body = opts.body;
+      if (opts.bodyFile) {
+        body = fs.readFileSync(path.resolve(opts.bodyFile), "utf-8");
+      }
+      return {
+        instance: store_exports.update(workspacePath, targetPath, updates, body, opts.actor)
+      };
+    },
+    (result) => [`Updated ${result.instance.type}: ${result.instance.path}`]
+  )
+);
 var skillCmd = program.command("skill").description("Manage native skill primitives in shared workgraph vaults");
 addWorkspaceOption(
-  skillCmd.command("write <title>").description("Create or update a skill primitive").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner").option("--version <semver>", "Skill version").option("--status <status>", "draft | proposed | active | deprecated | archived").option("--distribution <mode>", "Distribution mode", "tailscale-shared-vault").option("--tailscale-path <path>", "Shared Tailscale workspace path").option("--reviewers <list>", "Comma-separated reviewer names").option("--tags <list>", "Comma-separated tags").option("--body <text>", "Skill markdown content").option("--body-file <path>", "Read markdown content from file").option("--json", "Emit structured JSON output")
+  skillCmd.command("write <title>").description("Create or update a skill primitive").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner").option("--skill-version <semver>", "Skill version").option("--status <status>", "draft | proposed | active | deprecated | archived").option("--distribution <mode>", "Distribution mode", "tailscale-shared-vault").option("--tailscale-path <path>", "Shared Tailscale workspace path").option("--reviewers <list>", "Comma-separated reviewer names").option("--depends-on <list>", "Comma-separated skill dependencies (slug/path)").option("--expected-updated-at <iso>", "Optimistic concurrency guard for updates").option("--tags <list>", "Comma-separated tags").option("--body <text>", "Skill markdown content").option("--body-file <path>", "Read markdown content from file").option("--json", "Emit structured JSON output")
 ).action(
   (title, opts) => runCommand(
     opts,
@@ -368,11 +391,13 @@ addWorkspaceOption(
         opts.actor,
         {
           owner: opts.owner,
-          version: opts.version,
+          version: opts.skillVersion,
           status: opts.status,
           distribution: opts.distribution,
           tailscalePath: opts.tailscalePath,
           reviewers: csv(opts.reviewers),
+          dependsOn: csv(opts.dependsOn),
+          expectedUpdatedAt: opts.expectedUpdatedAt,
           tags: csv(opts.tags)
         }
       );
@@ -403,18 +428,54 @@ addWorkspaceOption(
   )
 );
 addWorkspaceOption(
-  skillCmd.command("list").description("List skills").option("--status <status>", "Filter by status").option("--json", "Emit structured JSON output")
+  skillCmd.command("list").description("List skills").option("--status <status>", "Filter by status").option("--updated-since <iso>", "Filter by updated timestamp (ISO-8601)").option("--json", "Emit structured JSON output")
 ).action(
   (opts) => runCommand(
     opts,
     () => {
       const workspacePath = resolveWorkspacePath(opts);
-      const skills = skill_exports.listSkills(workspacePath, { status: opts.status });
+      const skills = skill_exports.listSkills(workspacePath, {
+        status: opts.status,
+        updatedSince: opts.updatedSince
+      });
       return { skills, count: skills.length };
     },
     (result) => result.skills.map((skill) => `${String(skill.fields.title)} [${String(skill.fields.status)}] -> ${skill.path}`)
   )
 );
+addWorkspaceOption(
+  skillCmd.command("history <skillRef>").description("Show ledger history entries for one skill").option("--limit <n>", "Limit number of returned entries").option("--json", "Emit structured JSON output")
+).action(
+  (skillRef, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        entries: skill_exports.skillHistory(workspacePath, skillRef, {
+          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : void 0
+        })
+      };
+    },
+    (result) => result.entries.map((entry) => `${entry.ts} ${entry.op} ${entry.actor}`)
+  )
+);
+addWorkspaceOption(
+  skillCmd.command("diff <skillRef>").description("Show latest field-change summary for one skill").option("--json", "Emit structured JSON output")
+).action(
+  (skillRef, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return skill_exports.skillDiff(workspacePath, skillRef);
+    },
+    (result) => [
+      `Skill: ${result.path}`,
+      `Latest: ${result.latestEntryTs ?? "none"}`,
+      `Previous: ${result.previousEntryTs ?? "none"}`,
+      `Changed fields: ${result.changedFields.join(", ") || "none"}`
+    ]
+  )
+);
 addWorkspaceOption(
   skillCmd.command("propose <skillRef>").description("Move a skill into proposed state and open review thread").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--proposal-thread <path>", "Explicit proposal thread path").option("--no-create-thread", "Do not create a proposal thread automatically").option("--space <spaceRef>", "Space for created proposal thread").option("--reviewers <list>", "Comma-separated reviewers").option("--json", "Emit structured JSON output")
 ).action(
@@ -438,7 +499,7 @@ addWorkspaceOption(
   )
 );
 addWorkspaceOption(
-  skillCmd.command("promote <skillRef>").description("Promote a proposed/draft skill to active").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--version <semver>", "Explicit promoted version").option("--json", "Emit structured JSON output")
+  skillCmd.command("promote <skillRef>").description("Promote a proposed/draft skill to active").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--skill-version <semver>", "Explicit promoted version").option("--json", "Emit structured JSON output")
 ).action(
   (skillRef, opts) => runCommand(
     opts,
@@ -446,7 +507,7 @@ addWorkspaceOption(
       const workspacePath = resolveWorkspacePath(opts);
       return {
         skill: skill_exports.promoteSkill(workspacePath, skillRef, opts.actor, {
-          version: opts.version
+          version: opts.skillVersion
         })
       };
     },
@@ -456,6 +517,40 @@ addWorkspaceOption(
     ]
   )
 );
+var integrationCmd = program.command("integration").description("Manage optional third-party integrations");
+addWorkspaceOption(
+  integrationCmd.command("list").description("List supported optional integrations").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => ({
+      integrations: integration_exports.listIntegrations()
+    }),
+    (result) => result.integrations.map((integration) => `${integration.id} (${integration.defaultTitle}) -> ${integration.defaultSourceUrl}`)
+  )
+);
+addWorkspaceOption(
+  integrationCmd.command("install <integrationName>").description("Install an optional integration into this workspace").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner override").option("--title <title>", "Skill title to store in workgraph").option("--source-url <url>", "Source URL override for integration content").option("--force", "Overwrite an existing imported integration skill").option("--json", "Emit structured JSON output")
+).action(
+  (integrationName, opts) => runCommand(
+    opts,
+    () => installNamedIntegration(resolveWorkspacePath(opts), integrationName, opts),
+    renderInstalledIntegrationResult
+  )
+);
+addWorkspaceOption(
+  integrationCmd.command("clawdapus").description("Import Clawdapus SKILL.md into this workspace").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--owner <name>", "Skill owner override").option("--title <title>", "Skill title to store in workgraph", "clawdapus").option(
+    "--source-url <url>",
+    "Source URL for Clawdapus SKILL.md",
+    clawdapus_exports.DEFAULT_CLAWDAPUS_SKILL_URL
+  ).option("--force", "Overwrite an existing imported Clawdapus skill").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => installNamedIntegration(resolveWorkspacePath(opts), "clawdapus", opts),
+    renderInstalledIntegrationResult
+  )
+);
 var ledgerCmd = program.command("ledger").description("Inspect the append-only workgraph ledger");
 addWorkspaceOption(
   ledgerCmd.command("show").description("Show recent ledger entries").option("-n, --count <n>", "Number of entries", "20").option("--actor <name>", "Filter by actor").option("--json", "Emit structured JSON output")
@@ -601,7 +696,527 @@ addWorkspaceOption(
     ]
   )
 );
-program.parse();
+addWorkspaceOption(
+  program.command("status").description("Show workspace situational status snapshot").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return orientation_exports.statusSnapshot(workspacePath);
+    },
+    (result) => [
+      `Threads: total=${result.threads.total} open=${result.threads.open} active=${result.threads.active} blocked=${result.threads.blocked} done=${result.threads.done}`,
+      `Ready threads: ${result.threads.ready} Active claims: ${result.claims.active}`,
+      `Primitive types: ${Object.keys(result.primitives.byType).length}`
+    ]
+  )
+);
+addWorkspaceOption(
+  program.command("brief").description("Show actor-centric operational brief").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--recent <count>", "Recent activity count", "12").option("--next <count>", "Next ready threads to include", "5").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return orientation_exports.brief(workspacePath, opts.actor, {
+        recentCount: Number.parseInt(String(opts.recent), 10),
+        nextCount: Number.parseInt(String(opts.next), 10)
+      });
+    },
+    (result) => [
+      `Brief for ${result.actor}`,
+      `My claims: ${result.myClaims.length}`,
+      `Blocked threads: ${result.blockedThreads.length}`,
+      `Next ready: ${result.nextReadyThreads.map((item) => item.path).join(", ") || "none"}`
+    ]
+  )
+);
+addWorkspaceOption(
+  program.command("checkpoint <summary>").description("Create a checkpoint primitive for hand-off continuity").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--next <items>", "Comma-separated next actions").option("--blocked <items>", "Comma-separated blockers").option("--tags <items>", "Comma-separated tags").option("--json", "Emit structured JSON output")
+).action(
+  (summary, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        checkpoint: orientation_exports.checkpoint(workspacePath, opts.actor, summary, {
+          next: csv(opts.next),
+          blocked: csv(opts.blocked),
+          tags: csv(opts.tags)
+        })
+      };
+    },
+    (result) => [`Created checkpoint: ${result.checkpoint.path}`]
+  )
+);
+addWorkspaceOption(
+  program.command("intake <observation>").description("Capture intake observation as lightweight checkpoint note").option("-a, --actor <name>", "Agent name", DEFAULT_ACTOR).option("--tags <items>", "Comma-separated tags").option("--json", "Emit structured JSON output")
+).action(
+  (observation, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        intake: orientation_exports.intake(workspacePath, opts.actor, observation, {
+          tags: csv(opts.tags)
+        })
+      };
+    },
+    (result) => [`Captured intake: ${result.intake.path}`]
+  )
+);
+addWorkspaceOption(
+  program.command("query").description("Query primitive instances with multi-field filters").option("--type <type>", "Primitive type").option("--status <status>", "Status value").option("--owner <owner>", "Owner/actor value").option("--tag <tag>", "Tag filter").option("--text <text>", "Full-text contains filter").option("--path-includes <text>", "Path substring filter").option("--updated-after <iso>", "Updated at or after").option("--updated-before <iso>", "Updated at or before").option("--created-after <iso>", "Created at or after").option("--created-before <iso>", "Created at or before").option("--limit <n>", "Result limit").option("--offset <n>", "Result offset").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const results = query_exports.queryPrimitives(workspacePath, {
+        type: opts.type,
+        status: opts.status,
+        owner: opts.owner,
+        tag: opts.tag,
+        text: opts.text,
+        pathIncludes: opts.pathIncludes,
+        updatedAfter: opts.updatedAfter,
+        updatedBefore: opts.updatedBefore,
+        createdAfter: opts.createdAfter,
+        createdBefore: opts.createdBefore,
+        limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : void 0,
+        offset: opts.offset ? Number.parseInt(String(opts.offset), 10) : void 0
+      });
+      return { results, count: results.length };
+    },
+    (result) => result.results.map((item) => `${item.type} ${item.path}`)
+  )
+);
+addWorkspaceOption(
+  program.command("search <text>").description("Keyword search across markdown body/frontmatter with optional QMD-compatible mode").option("--type <type>", "Limit to primitive type").option("--mode <mode>", "auto | core | qmd", "auto").option("--limit <n>", "Result limit").option("--json", "Emit structured JSON output")
+).action(
+  (text, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const result = search_qmd_adapter_exports.search(workspacePath, text, {
+        mode: opts.mode,
+        type: opts.type,
+        limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : void 0
+      });
+      return {
+        ...result,
+        count: result.results.length
+      };
+    },
+    (result) => [
+      `Mode: ${result.mode}`,
+      ...result.fallbackReason ? [`Note: ${result.fallbackReason}`] : [],
+      ...result.results.map((item) => `${item.type} ${item.path}`)
+    ]
+  )
+);
+var boardCmd = program.command("board").description("Generate and sync Obsidian Kanban board views");
+addWorkspaceOption(
+  boardCmd.command("generate").description("Generate Obsidian Kanban board markdown from thread states").option("-o, --output <path>", "Output board path", "ops/Workgraph Board.md").option("--include-cancelled", "Include cancelled lane").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return board_exports.generateKanbanBoard(workspacePath, {
+        outputPath: opts.output,
+        includeCancelled: !!opts.includeCancelled
+      });
+    },
+    (result) => [
+      `Generated board: ${result.outputPath}`,
+      `Backlog=${result.counts.backlog} InProgress=${result.counts.inProgress} Blocked=${result.counts.blocked} Done=${result.counts.done}`
+    ]
+  )
+);
+addWorkspaceOption(
+  boardCmd.command("sync").description("Sync existing board markdown from current thread states").option("-o, --output <path>", "Output board path", "ops/Workgraph Board.md").option("--include-cancelled", "Include cancelled lane").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return board_exports.syncKanbanBoard(workspacePath, {
+        outputPath: opts.output,
+        includeCancelled: !!opts.includeCancelled
+      });
+    },
+    (result) => [
+      `Synced board: ${result.outputPath}`,
+      `Backlog=${result.counts.backlog} InProgress=${result.counts.inProgress} Blocked=${result.counts.blocked} Done=${result.counts.done}`
+    ]
+  )
+);
+var graphCmd = program.command("graph").description("Wiki-link graph indexing and hygiene");
+addWorkspaceOption(
+  graphCmd.command("index").description("Build wiki-link graph index").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return graph_exports.refreshWikiLinkGraphIndex(workspacePath);
+    },
+    (result) => [
+      `Nodes: ${result.nodes.length}`,
+      `Edges: ${result.edges.length}`,
+      `Broken links: ${result.brokenLinks.length}`
+    ]
+  )
+);
+addWorkspaceOption(
+  graphCmd.command("hygiene").description("Generate graph hygiene report (orphans, broken links, hubs)").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return graph_exports.graphHygieneReport(workspacePath);
+    },
+    (result) => [
+      `Nodes=${result.nodeCount} Edges=${result.edgeCount}`,
+      `Orphans=${result.orphanCount} BrokenLinks=${result.brokenLinkCount}`,
+      `Top hub: ${result.hubs[0]?.node ?? "none"}`
+    ]
+  )
+);
+addWorkspaceOption(
+  graphCmd.command("neighbors <nodePath>").description("Query incoming/outgoing wiki-link neighbors for one node").option("--refresh", "Refresh graph index before querying").option("--json", "Emit structured JSON output")
+).action(
+  (nodePath, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return graph_exports.graphNeighborhood(workspacePath, nodePath, {
+        refresh: !!opts.refresh
+      });
+    },
+    (result) => [
+      `Node: ${result.node} (${result.exists ? "exists" : "missing"})`,
+      `Outgoing: ${result.outgoing.length}`,
+      `Incoming: ${result.incoming.length}`
+    ]
+  )
+);
+var policyCmd = program.command("policy").description("Manage policy parties and capabilities");
+var policyPartyCmd = policyCmd.command("party").description("Manage registered policy parties");
+addWorkspaceOption(
+  policyPartyCmd.command("upsert <id>").description("Create or update a policy party").option("--roles <roles>", "Comma-separated roles").option("--capabilities <caps>", "Comma-separated capabilities").option("--json", "Emit structured JSON output")
+).action(
+  (id, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        party: policy_exports.upsertParty(workspacePath, id, {
+          roles: csv(opts.roles),
+          capabilities: csv(opts.capabilities)
+        })
+      };
+    },
+    (result) => [`Upserted policy party: ${result.party.id}`]
+  )
+);
+addWorkspaceOption(
+  policyPartyCmd.command("get <id>").description("Get one policy party").option("--json", "Emit structured JSON output")
+).action(
+  (id, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const party = policy_exports.getParty(workspacePath, id);
+      if (!party) throw new Error(`Policy party not found: ${id}`);
+      return { party };
+    },
+    (result) => [`${result.party.id} roles=${result.party.roles.join(",")}`]
+  )
+);
+addWorkspaceOption(
+  policyPartyCmd.command("list").description("List policy parties").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const registry = policy_exports.loadPolicyRegistry(workspacePath);
+      return {
+        parties: Object.values(registry.parties)
+      };
+    },
+    (result) => result.parties.map((party) => `${party.id} [${party.roles.join(", ")}]`)
+  )
+);
+var dispatchCmd = program.command("dispatch").description("Programmatic runtime dispatch contract");
+addWorkspaceOption(
+  dispatchCmd.command("create <objective>").description("Create a new run dispatch request").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--adapter <name>", "Adapter name", "cursor-cloud").option("--idempotency-key <key>", "Idempotency key").option("--json", "Emit structured JSON output")
+).action(
+  (objective, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: dispatch_exports.createRun(workspacePath, {
+          actor: opts.actor,
+          adapter: opts.adapter,
+          objective,
+          idempotencyKey: opts.idempotencyKey
+        })
+      };
+    },
+    (result) => [`Run created: ${result.run.id} [${result.run.status}]`]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("create-execute <objective>").description("Create and execute a run with autonomous multi-agent coordination").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--adapter <name>", "Adapter name", "cursor-cloud").option("--idempotency-key <key>", "Idempotency key").option("--agents <actors>", "Comma-separated agent identities for autonomous execution").option("--max-steps <n>", "Maximum scheduler steps", "200").option("--step-delay-ms <ms>", "Delay between scheduling steps", "25").option("--space <spaceRef>", "Restrict execution to one space").option("--no-checkpoint", "Skip automatic checkpoint generation after execution").option("--json", "Emit structured JSON output")
+).action(
+  (objective, opts) => runCommand(
+    opts,
+    async () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: await dispatch_exports.createAndExecuteRun(
+          workspacePath,
+          {
+            actor: opts.actor,
+            adapter: opts.adapter,
+            objective,
+            idempotencyKey: opts.idempotencyKey
+          },
+          {
+            agents: csv(opts.agents),
+            maxSteps: Number.parseInt(String(opts.maxSteps), 10),
+            stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
+            space: opts.space,
+            createCheckpoint: opts.checkpoint
+          }
+        )
+      };
+    },
+    (result) => [
+      `Run executed: ${result.run.id} [${result.run.status}]`,
+      ...result.run.output ? [`Output: ${result.run.output}`] : [],
+      ...result.run.error ? [`Error: ${result.run.error}`] : []
+    ]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("list").description("List runs").option("--status <status>", "queued|running|succeeded|failed|cancelled").option("--limit <n>", "Result limit").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        runs: dispatch_exports.listRuns(workspacePath, {
+          status: opts.status,
+          limit: opts.limit ? Number.parseInt(String(opts.limit), 10) : void 0
+        })
+      };
+    },
+    (result) => result.runs.map((run) => `${run.id} [${run.status}] ${run.objective}`)
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("status <runId>").description("Get run status by ID").option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: dispatch_exports.status(workspacePath, runId)
+      };
+    },
+    (result) => [`${result.run.id} [${result.run.status}]`]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("execute <runId>").description("Execute a queued/running run via adapter autonomous scheduling").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--agents <actors>", "Comma-separated agent identities").option("--max-steps <n>", "Maximum scheduler steps", "200").option("--step-delay-ms <ms>", "Delay between scheduling steps", "25").option("--space <spaceRef>", "Restrict execution to one space").option("--no-checkpoint", "Skip automatic checkpoint generation after execution").option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    async () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: await dispatch_exports.executeRun(workspacePath, runId, {
+          actor: opts.actor,
+          agents: csv(opts.agents),
+          maxSteps: Number.parseInt(String(opts.maxSteps), 10),
+          stepDelayMs: Number.parseInt(String(opts.stepDelayMs), 10),
+          space: opts.space,
+          createCheckpoint: opts.checkpoint
+        })
+      };
+    },
+    (result) => [
+      `Run executed: ${result.run.id} [${result.run.status}]`,
+      ...result.run.output ? [`Output: ${result.run.output}`] : [],
+      ...result.run.error ? [`Error: ${result.run.error}`] : []
+    ]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("followup <runId> <input>").description("Send follow-up input to a run").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
+).action(
+  (runId, input, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: dispatch_exports.followup(workspacePath, runId, opts.actor, input)
+      };
+    },
+    (result) => [`Follow-up recorded: ${result.run.id} [${result.run.status}]`]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("stop <runId>").description("Cancel a run").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        run: dispatch_exports.stop(workspacePath, runId, opts.actor)
+      };
+    },
+    (result) => [`Stopped run: ${result.run.id} [${result.run.status}]`]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("mark <runId>").description("Set run status transition explicitly").requiredOption("--status <status>", "running|succeeded|failed|cancelled").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--output <text>", "Optional output payload").option("--error <text>", "Optional error payload").option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const status = normalizeRunStatus(opts.status);
+      return {
+        run: dispatch_exports.markRun(workspacePath, runId, opts.actor, status, {
+          output: opts.output,
+          error: opts.error
+        })
+      };
+    },
+    (result) => [`Marked run: ${result.run.id} [${result.run.status}]`]
+  )
+);
+addWorkspaceOption(
+  dispatchCmd.command("logs <runId>").description("Read logs from a run").option("--json", "Emit structured JSON output")
+).action(
+  (runId, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        runId,
+        logs: dispatch_exports.logs(workspacePath, runId)
+      };
+    },
+    (result) => result.logs.map((entry) => `${entry.ts} [${entry.level}] ${entry.message}`)
+  )
+);
+var triggerCmd = program.command("trigger").description("Trigger primitives and run dispatch lifecycle");
+addWorkspaceOption(
+  triggerCmd.command("fire <triggerPath>").description("Fire an approved/active trigger and dispatch a run").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--event-key <key>", "Deterministic event key for idempotency").option("--objective <text>", "Override run objective").option("--json", "Emit structured JSON output")
+).action(
+  (triggerPath, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return trigger_exports.fireTrigger(workspacePath, triggerPath, {
+        actor: opts.actor,
+        eventKey: opts.eventKey,
+        objective: opts.objective
+      });
+    },
+    (result) => [
+      `Fired trigger: ${result.triggerPath}`,
+      `Run: ${result.run.id} [${result.run.status}]`
+    ]
+  )
+);
+addWorkspaceOption(
+  program.command("onboard").description("Guided agent-first workspace setup and starter artifacts").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--spaces <list>", "Comma-separated space names").option("--no-demo-threads", "Skip starter onboarding threads").option("--json", "Emit structured JSON output")
+).action(
+  (opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return onboard_exports.onboardWorkspace(workspacePath, {
+        actor: opts.actor,
+        spaces: csv(opts.spaces),
+        createDemoThreads: opts.demoThreads
+      });
+    },
+    (result) => [
+      `Onboarded actor: ${result.actor}`,
+      `Spaces created: ${result.spacesCreated.length}`,
+      `Threads created: ${result.threadsCreated.length}`,
+      `Board: ${result.boardPath}`,
+      `Command center: ${result.commandCenterPath}`,
+      `Onboarding primitive: ${result.onboardingPath}`
+    ]
+  )
+);
+var onboardingCmd = program.command("onboarding").description("Manage onboarding primitive lifecycle");
+addWorkspaceOption(
+  onboardingCmd.command("show <onboardingPath>").description("Show one onboarding primitive").option("--json", "Emit structured JSON output")
+).action(
+  (onboardingPath, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      const onboarding = store_exports.read(workspacePath, onboardingPath);
+      if (!onboarding) throw new Error(`Onboarding primitive not found: ${onboardingPath}`);
+      if (onboarding.type !== "onboarding") throw new Error(`Target is not onboarding primitive: ${onboardingPath}`);
+      return { onboarding };
+    },
+    (result) => [
+      `Onboarding: ${result.onboarding.path}`,
+      `Status: ${String(result.onboarding.fields.status)}`,
+      `Actor: ${String(result.onboarding.fields.actor)}`
+    ]
+  )
+);
+addWorkspaceOption(
+  onboardingCmd.command("update <onboardingPath>").description("Update onboarding lifecycle status").requiredOption("--status <status>", "active|paused|completed").option("-a, --actor <name>", "Actor", DEFAULT_ACTOR).option("--json", "Emit structured JSON output")
+).action(
+  (onboardingPath, opts) => runCommand(
+    opts,
+    () => {
+      const workspacePath = resolveWorkspacePath(opts);
+      return {
+        onboarding: onboard_exports.updateOnboardingStatus(
+          workspacePath,
+          onboardingPath,
+          normalizeOnboardingStatus(opts.status),
+          opts.actor
+        )
+      };
+    },
+    (result) => [`Updated onboarding: ${result.onboarding.path} [${String(result.onboarding.fields.status)}]`]
+  )
+);
+var mcpCmd = program.command("mcp").description("Run Workgraph MCP server");
+addWorkspaceOption(
+  mcpCmd.command("serve").description("Serve stdio MCP tools/resources for this workspace").option("-a, --actor <name>", "Default actor for MCP write tools", DEFAULT_ACTOR).option("--read-only", "Disable all MCP write tools")
+).action(async (opts) => {
+  const workspacePath = resolveWorkspacePath(opts);
+  console.error(`Starting MCP server for workspace: ${workspacePath}`);
+  await mcp_server_exports.startWorkgraphMcpServer({
+    workspacePath,
+    defaultActor: opts.actor,
+    readOnly: !!opts.readOnly
+  });
+});
+await program.parseAsync();
 function addWorkspaceOption(command) {
   return command.option("-w, --workspace <path>", "Workgraph workspace path").option("--vault <path>", "Alias for --workspace").option("--shared-vault <path>", "Shared vault path (e.g. mounted via Tailscale)");
 }
@@ -610,21 +1225,82 @@ function resolveWorkspacePath(opts) {
   if (explicit) return path.resolve(explicit);
   if (process.env.WORKGRAPH_SHARED_VAULT) return path.resolve(process.env.WORKGRAPH_SHARED_VAULT);
   if (process.env.WORKGRAPH_PATH) return path.resolve(process.env.WORKGRAPH_PATH);
-  if (process.env.CLAWVAULT_PATH) return path.resolve(process.env.CLAWVAULT_PATH);
   return process.cwd();
 }
+function parseSetPairs(pairs) {
+  const fields = {};
+  for (const pair of pairs) {
+    const eqIdx = String(pair).indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = String(pair).slice(0, eqIdx).trim();
+    const raw = String(pair).slice(eqIdx + 1).trim();
+    if (!key) continue;
+    fields[key] = parseScalar(raw);
+  }
+  return fields;
+}
 function csv(value) {
   if (!value) return void 0;
   return String(value).split(",").map((s) => s.trim()).filter(Boolean);
 }
+function installNamedIntegration(workspacePath, integrationName, opts) {
+  return integration_exports.installIntegration(workspacePath, integrationName, {
+    actor: opts.actor,
+    owner: opts.owner,
+    title: opts.title,
+    sourceUrl: opts.sourceUrl,
+    force: !!opts.force
+  });
+}
+function renderInstalledIntegrationResult(result) {
+  return [
+    `${result.replacedExisting ? "Updated" : "Installed"} ${result.provider} integration skill: ${result.skill.path}`,
+    `Source: ${result.sourceUrl}`,
+    `Status: ${String(result.skill.fields.status)}`
+  ];
+}
+function parseScalar(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value === "") return "";
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((item) => parseScalar(item.trim()));
+  }
+  if (value.includes(",")) {
+    return value.split(",").map((item) => parseScalar(item.trim()));
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function normalizeRunStatus(status) {
+  const normalized = String(status).toLowerCase();
+  if (normalized === "running" || normalized === "succeeded" || normalized === "failed" || normalized === "cancelled") {
+    return normalized;
+  }
+  throw new Error(`Invalid run status "${status}". Expected running|succeeded|failed|cancelled.`);
+}
+function normalizeOnboardingStatus(status) {
+  const normalized = String(status).toLowerCase();
+  if (normalized === "active" || normalized === "paused" || normalized === "completed") {
+    return normalized;
+  }
+  throw new Error(`Invalid onboarding status "${status}". Expected active|paused|completed.`);
+}
 function wantsJson(opts) {
   if (opts.json) return true;
   if (process.env.WORKGRAPH_JSON === "1") return true;
   return false;
 }
-function runCommand(opts, action, renderText) {
+async function runCommand(opts, action, renderText) {
   try {
-    const result = action();
+    const result = await action();
     if (wantsJson(opts)) {
       console.log(JSON.stringify({ ok: true, data: result }, null, 2));
       return;