@versatly/workgraph 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -6,6 +6,27 @@ interface FieldDefinition {
     required?: boolean;
     default?: unknown;
     description?: string;
+    /** Allowed values when type is scalar/string-like. */
+    enum?: Array<string | number | boolean>;
+    /**
+     * Optional semantic template used for additional validation.
+     * - slug: lowercase kebab-case token
+     * - semver: semantic version (x.y.z)
+     * - email: simple email shape
+     * - url: absolute http(s) URL
+     * - iso-date: ISO-8601 date/time string
+     */
+    template?: 'slug' | 'semver' | 'email' | 'url' | 'iso-date';
+    /**
+     * Optional regex pattern constraint for string/ref/date fields.
+     * Uses JavaScript regular expression syntax (without delimiters).
+     */
+    pattern?: string;
+    /**
+     * For ref fields, constrain references to one or more primitive types.
+     * Example: refTypes: ['thread', 'space']
+     */
+    refTypes?: string[];
 }
 interface PrimitiveTypeDefinition {
     name: string;
@@ -66,6 +87,83 @@ interface WorkgraphWorkspaceConfig {
     createdAt: string;
     updatedAt: string;
 }
+interface PrimitiveQueryFilters {
+    type?: string;
+    status?: string;
+    owner?: string;
+    tag?: string;
+    text?: string;
+    pathIncludes?: string;
+    updatedAfter?: string;
+    updatedBefore?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    limit?: number;
+    offset?: number;
+}
+interface WorkgraphStatusSnapshot {
+    generatedAt: string;
+    threads: {
+        total: number;
+        open: number;
+        active: number;
+        blocked: number;
+        done: number;
+        cancelled: number;
+        ready: number;
+    };
+    claims: {
+        active: number;
+    };
+    primitives: {
+        total: number;
+        byType: Record<string, number>;
+    };
+}
+interface WorkgraphBrief {
+    generatedAt: string;
+    actor: string;
+    myClaims: PrimitiveInstance[];
+    myOpenThreads: PrimitiveInstance[];
+    blockedThreads: PrimitiveInstance[];
+    nextReadyThreads: PrimitiveInstance[];
+    recentActivity: LedgerEntry[];
+}
+interface PolicyParty {
+    id: string;
+    roles: string[];
+    capabilities: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface PolicyRegistry {
+    version: number;
+    parties: Record<string, PolicyParty>;
+}
+type RunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+interface DispatchRun {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    actor: string;
+    adapter: string;
+    objective: string;
+    status: RunStatus;
+    idempotencyKey?: string;
+    context?: Record<string, unknown>;
+    output?: string;
+    error?: string;
+    followups: Array<{
+        ts: string;
+        actor: string;
+        input: string;
+    }>;
+    logs: Array<{
+        ts: string;
+        level: 'info' | 'warn' | 'error';
+        message: string;
+    }>;
+}
 
 /**
  * Dynamic primitive type registry.
@@ -93,7 +191,7 @@ declare namespace registry {
 /**
  * Append-only event ledger.
  *
- * Format: one JSON object per line (.jsonl) in `.clawvault/ledger.jsonl`.
+ * Format: one JSON object per line (.jsonl) in `.workgraph/ledger.jsonl`.
  */
 
 declare function ledgerPath(workspacePath: string): string;
@@ -118,7 +216,7 @@ interface LedgerQueryOptions {
     limit?: number;
     offset?: number;
 }
-declare function query(workspacePath: string, options?: LedgerQueryOptions): LedgerEntry[];
+declare function query$1(workspacePath: string, options?: LedgerQueryOptions): LedgerEntry[];
 interface LedgerBlameActorSummary {
     actor: string;
     count: number;
@@ -175,7 +273,6 @@ declare const ledger_ledgerIndexPath: typeof ledgerIndexPath;
 declare const ledger_ledgerPath: typeof ledgerPath;
 declare const ledger_loadChainState: typeof loadChainState;
 declare const ledger_loadIndex: typeof loadIndex;
-declare const ledger_query: typeof query;
 declare const ledger_readAll: typeof readAll;
 declare const ledger_readSince: typeof readSince;
 declare const ledger_rebuildHashChainState: typeof rebuildHashChainState;
@@ -183,14 +280,16 @@ declare const ledger_rebuildIndex: typeof rebuildIndex;
 declare const ledger_recent: typeof recent;
 declare const ledger_verifyHashChain: typeof verifyHashChain;
 declare namespace ledger {
-  export { type ledger_LedgerBlameActorSummary as LedgerBlameActorSummary, type ledger_LedgerBlameResult as LedgerBlameResult, type ledger_LedgerQueryOptions as LedgerQueryOptions, type ledger_LedgerVerifyOptions as LedgerVerifyOptions, type ledger_LedgerVerifyResult as LedgerVerifyResult, ledger_activityOf as activityOf, ledger_allClaims as allClaims, ledger_append as append, ledger_blame as blame, ledger_claimsFromIndex as claimsFromIndex, ledger_currentOwner as currentOwner, ledger_historyOf as historyOf, ledger_isClaimed as isClaimed, ledger_ledgerChainStatePath as ledgerChainStatePath, ledger_ledgerIndexPath as ledgerIndexPath, ledger_ledgerPath as ledgerPath, ledger_loadChainState as loadChainState, ledger_loadIndex as loadIndex, ledger_query as query, ledger_readAll as readAll, ledger_readSince as readSince, ledger_rebuildHashChainState as rebuildHashChainState, ledger_rebuildIndex as rebuildIndex, ledger_recent as recent, ledger_verifyHashChain as verifyHashChain };
+  export { type ledger_LedgerBlameActorSummary as LedgerBlameActorSummary, type ledger_LedgerBlameResult as LedgerBlameResult, type ledger_LedgerQueryOptions as LedgerQueryOptions, type ledger_LedgerVerifyOptions as LedgerVerifyOptions, type ledger_LedgerVerifyResult as LedgerVerifyResult, ledger_activityOf as activityOf, ledger_allClaims as allClaims, ledger_append as append, ledger_blame as blame, ledger_claimsFromIndex as claimsFromIndex, ledger_currentOwner as currentOwner, ledger_historyOf as historyOf, ledger_isClaimed as isClaimed, ledger_ledgerChainStatePath as ledgerChainStatePath, ledger_ledgerIndexPath as ledgerIndexPath, ledger_ledgerPath as ledgerPath, ledger_loadChainState as loadChainState, ledger_loadIndex as loadIndex, query$1 as query, ledger_readAll as readAll, ledger_readSince as readSince, ledger_rebuildHashChainState as rebuildHashChainState, ledger_rebuildIndex as rebuildIndex, ledger_recent as recent, ledger_verifyHashChain as verifyHashChain };
 }
 
 /**
  * Workgraph store — CRUD for primitive instances.
  */
 
-declare function create(workspacePath: string, typeName: string, fields: Record<string, unknown>, body: string, actor: string): PrimitiveInstance;
+declare function create(workspacePath: string, typeName: string, fields: Record<string, unknown>, body: string, actor: string, options?: {
+    pathOverride?: string;
+}): PrimitiveInstance;
 declare function read(workspacePath: string, relPath: string): PrimitiveInstance | null;
 declare function list(workspacePath: string, typeName: string): PrimitiveInstance[];
 declare function update(workspacePath: string, relPath: string, fieldUpdates: Record<string, unknown>, bodyUpdate: string | undefined, actor: string): PrimitiveInstance;
@@ -386,6 +485,8 @@ interface WriteSkillOptions {
     tailscalePath?: string;
     reviewers?: string[];
     tags?: string[];
+    dependsOn?: string[];
+    expectedUpdatedAt?: string;
 }
 interface ProposeSkillOptions {
     proposalThread?: string;
@@ -400,8 +501,18 @@ declare function writeSkill(workspacePath: string, title: string, body: string,
 declare function loadSkill(workspacePath: string, skillRef: string): PrimitiveInstance;
 declare function listSkills(workspacePath: string, options?: {
     status?: string;
+    updatedSince?: string;
 }): PrimitiveInstance[];
 declare function proposeSkill(workspacePath: string, skillRef: string, actor: string, options?: ProposeSkillOptions): PrimitiveInstance;
+declare function skillHistory(workspacePath: string, skillRef: string, options?: {
+    limit?: number;
+}): LedgerEntry[];
+declare function skillDiff(workspacePath: string, skillRef: string): {
+    path: string;
+    latestEntryTs: string | null;
+    previousEntryTs: string | null;
+    changedFields: string[];
+};
 declare function promoteSkill(workspacePath: string, skillRef: string, actor: string, options?: PromoteSkillOptions): PrimitiveInstance;
 
 type skill_PromoteSkillOptions = PromoteSkillOptions;
@@ -411,9 +522,293 @@ declare const skill_listSkills: typeof listSkills;
 declare const skill_loadSkill: typeof loadSkill;
 declare const skill_promoteSkill: typeof promoteSkill;
 declare const skill_proposeSkill: typeof proposeSkill;
+declare const skill_skillDiff: typeof skillDiff;
+declare const skill_skillHistory: typeof skillHistory;
 declare const skill_writeSkill: typeof writeSkill;
 declare namespace skill {
-  export { type skill_PromoteSkillOptions as PromoteSkillOptions, type skill_ProposeSkillOptions as ProposeSkillOptions, type skill_WriteSkillOptions as WriteSkillOptions, skill_listSkills as listSkills, skill_loadSkill as loadSkill, skill_promoteSkill as promoteSkill, skill_proposeSkill as proposeSkill, skill_writeSkill as writeSkill };
+  export { type skill_PromoteSkillOptions as PromoteSkillOptions, type skill_ProposeSkillOptions as ProposeSkillOptions, type skill_WriteSkillOptions as WriteSkillOptions, skill_listSkills as listSkills, skill_loadSkill as loadSkill, skill_promoteSkill as promoteSkill, skill_proposeSkill as proposeSkill, skill_skillDiff as skillDiff, skill_skillHistory as skillHistory, skill_writeSkill as writeSkill };
+}
+
+/**
+ * Cross-primitive query and keyword search helpers.
+ */
+
+declare function queryPrimitives(workspacePath: string, filters?: PrimitiveQueryFilters): PrimitiveInstance[];
+declare function keywordSearch(workspacePath: string, text: string, filters?: Omit<PrimitiveQueryFilters, 'text'>): PrimitiveInstance[];
+
+declare const query_keywordSearch: typeof keywordSearch;
+declare const query_queryPrimitives: typeof queryPrimitives;
+declare namespace query {
+  export { query_keywordSearch as keywordSearch, query_queryPrimitives as queryPrimitives };
+}
+
+/**
+ * Orientation helpers: status, brief, checkpoint/intake.
+ */
+
+declare function statusSnapshot(workspacePath: string): WorkgraphStatusSnapshot;
+declare function brief(workspacePath: string, actor: string, options?: {
+    recentCount?: number;
+    nextCount?: number;
+}): WorkgraphBrief;
+declare function checkpoint(workspacePath: string, actor: string, summary: string, options?: {
+    next?: string[];
+    blocked?: string[];
+    tags?: string[];
+}): PrimitiveInstance;
+declare function intake(workspacePath: string, actor: string, observation: string, options?: {
+    tags?: string[];
+}): PrimitiveInstance;
+
+declare const orientation_brief: typeof brief;
+declare const orientation_checkpoint: typeof checkpoint;
+declare const orientation_intake: typeof intake;
+declare const orientation_statusSnapshot: typeof statusSnapshot;
+declare namespace orientation {
+  export { orientation_brief as brief, orientation_checkpoint as checkpoint, orientation_intake as intake, orientation_statusSnapshot as statusSnapshot };
+}
+
+/**
+ * Wiki-link graph indexing and hygiene reports.
+ */
+interface WikiGraphEdge {
+    from: string;
+    to: string;
+}
+interface WikiGraphIndex {
+    generatedAt: string;
+    nodes: string[];
+    edges: WikiGraphEdge[];
+    backlinks: Record<string, string[]>;
+    orphans: string[];
+    brokenLinks: Array<{
+        from: string;
+        to: string;
+    }>;
+    hubs: Array<{
+        node: string;
+        degree: number;
+    }>;
+}
+interface WikiGraphNeighborhood {
+    node: string;
+    exists: boolean;
+    outgoing: string[];
+    incoming: string[];
+}
+declare function graphIndexPath(workspacePath: string): string;
+declare function buildWikiLinkGraph(workspacePath: string): WikiGraphIndex;
+declare function refreshWikiLinkGraphIndex(workspacePath: string): WikiGraphIndex;
+declare function readWikiLinkGraphIndex(workspacePath: string): WikiGraphIndex | null;
+declare function graphHygieneReport(workspacePath: string): {
+    generatedAt: string;
+    nodeCount: number;
+    edgeCount: number;
+    orphanCount: number;
+    brokenLinkCount: number;
+    hubs: Array<{
+        node: string;
+        degree: number;
+    }>;
+    orphans: string[];
+    brokenLinks: Array<{
+        from: string;
+        to: string;
+    }>;
+};
+declare function graphNeighborhood(workspacePath: string, nodeRef: string, options?: {
+    refresh?: boolean;
+}): WikiGraphNeighborhood;
+
+type graph_WikiGraphEdge = WikiGraphEdge;
+type graph_WikiGraphIndex = WikiGraphIndex;
+type graph_WikiGraphNeighborhood = WikiGraphNeighborhood;
+declare const graph_buildWikiLinkGraph: typeof buildWikiLinkGraph;
+declare const graph_graphHygieneReport: typeof graphHygieneReport;
+declare const graph_graphIndexPath: typeof graphIndexPath;
+declare const graph_graphNeighborhood: typeof graphNeighborhood;
+declare const graph_readWikiLinkGraphIndex: typeof readWikiLinkGraphIndex;
+declare const graph_refreshWikiLinkGraphIndex: typeof refreshWikiLinkGraphIndex;
+declare namespace graph {
+  export { type graph_WikiGraphEdge as WikiGraphEdge, type graph_WikiGraphIndex as WikiGraphIndex, type graph_WikiGraphNeighborhood as WikiGraphNeighborhood, graph_buildWikiLinkGraph as buildWikiLinkGraph, graph_graphHygieneReport as graphHygieneReport, graph_graphIndexPath as graphIndexPath, graph_graphNeighborhood as graphNeighborhood, graph_readWikiLinkGraphIndex as readWikiLinkGraphIndex, graph_refreshWikiLinkGraphIndex as refreshWikiLinkGraphIndex };
+}
+
+/**
+ * Obsidian Kanban board generation and sync helpers.
+ */
+interface BoardOptions {
+    outputPath?: string;
+    includeCancelled?: boolean;
+}
+interface BoardResult {
+    outputPath: string;
+    generatedAt: string;
+    counts: {
+        backlog: number;
+        inProgress: number;
+        blocked: number;
+        done: number;
+        cancelled: number;
+    };
+    content: string;
+}
+declare function generateKanbanBoard(workspacePath: string, options?: BoardOptions): BoardResult;
+declare function syncKanbanBoard(workspacePath: string, options?: BoardOptions): BoardResult;
+
+type board_BoardOptions = BoardOptions;
+type board_BoardResult = BoardResult;
+declare const board_generateKanbanBoard: typeof generateKanbanBoard;
+declare const board_syncKanbanBoard: typeof syncKanbanBoard;
+declare namespace board {
+  export { type board_BoardOptions as BoardOptions, type board_BoardResult as BoardResult, board_generateKanbanBoard as generateKanbanBoard, board_syncKanbanBoard as syncKanbanBoard };
+}
+
+/**
+ * Policy registry and status transition gates.
+ */
+
+interface PolicyDecision {
+    allowed: boolean;
+    reason?: string;
+}
+declare function policyPath(workspacePath: string): string;
+declare function loadPolicyRegistry(workspacePath: string): PolicyRegistry;
+declare function savePolicyRegistry(workspacePath: string, registry: PolicyRegistry): void;
+declare function upsertParty(workspacePath: string, partyId: string, updates: {
+    roles?: string[];
+    capabilities?: string[];
+}): PolicyParty;
+declare function getParty(workspacePath: string, partyId: string): PolicyParty | null;
+declare function canTransitionStatus(workspacePath: string, actor: string, primitiveType: string, fromStatus: string | undefined, toStatus: string | undefined): PolicyDecision;
+
+type policy_PolicyDecision = PolicyDecision;
+declare const policy_canTransitionStatus: typeof canTransitionStatus;
+declare const policy_getParty: typeof getParty;
+declare const policy_loadPolicyRegistry: typeof loadPolicyRegistry;
+declare const policy_policyPath: typeof policyPath;
+declare const policy_savePolicyRegistry: typeof savePolicyRegistry;
+declare const policy_upsertParty: typeof upsertParty;
+declare namespace policy {
+  export { type policy_PolicyDecision as PolicyDecision, policy_canTransitionStatus as canTransitionStatus, policy_getParty as getParty, policy_loadPolicyRegistry as loadPolicyRegistry, policy_policyPath as policyPath, policy_savePolicyRegistry as savePolicyRegistry, policy_upsertParty as upsertParty };
+}
+
+/**
+ * Runtime dispatch contract (MVP local adapter).
+ */
+
+interface DispatchCreateInput {
+    actor: string;
+    adapter?: string;
+    objective: string;
+    context?: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+declare function createRun(workspacePath: string, input: DispatchCreateInput): DispatchRun;
+declare function status(workspacePath: string, runId: string): DispatchRun;
+declare function followup(workspacePath: string, runId: string, actor: string, input: string): DispatchRun;
+declare function stop(workspacePath: string, runId: string, actor: string): DispatchRun;
+declare function markRun(workspacePath: string, runId: string, actor: string, nextStatus: Exclude<RunStatus, 'queued'>, options?: {
+    output?: string;
+    error?: string;
+}): DispatchRun;
+declare function logs(workspacePath: string, runId: string): DispatchRun['logs'];
+declare function listRuns(workspacePath: string, options?: {
+    status?: RunStatus;
+    limit?: number;
+}): DispatchRun[];
+
+type dispatch_DispatchCreateInput = DispatchCreateInput;
+declare const dispatch_createRun: typeof createRun;
+declare const dispatch_followup: typeof followup;
+declare const dispatch_listRuns: typeof listRuns;
+declare const dispatch_logs: typeof logs;
+declare const dispatch_markRun: typeof markRun;
+declare const dispatch_status: typeof status;
+declare const dispatch_stop: typeof stop;
+declare namespace dispatch {
+  export { type dispatch_DispatchCreateInput as DispatchCreateInput, dispatch_createRun as createRun, dispatch_followup as followup, dispatch_listRuns as listRuns, dispatch_logs as logs, dispatch_markRun as markRun, dispatch_status as status, dispatch_stop as stop };
+}
+
+/**
+ * Agent-first onboarding flow for new workgraph workspaces.
+ */
+
+interface OnboardOptions {
+    actor: string;
+    spaces?: string[];
+    createDemoThreads?: boolean;
+}
+interface OnboardResult {
+    actor: string;
+    spacesCreated: string[];
+    threadsCreated: string[];
+    boardPath: string;
+    commandCenterPath: string;
+    checkpointPath: string;
+    onboardingPath: string;
+}
+type OnboardingStatus = 'active' | 'completed' | 'paused';
+declare function onboardWorkspace(workspacePath: string, options: OnboardOptions): OnboardResult;
+declare function updateOnboardingStatus(workspacePath: string, onboardingPath: string, status: OnboardingStatus, actor: string): PrimitiveInstance;
+
+type onboard_OnboardOptions = OnboardOptions;
+type onboard_OnboardResult = OnboardResult;
+type onboard_OnboardingStatus = OnboardingStatus;
+declare const onboard_onboardWorkspace: typeof onboardWorkspace;
+declare const onboard_updateOnboardingStatus: typeof updateOnboardingStatus;
+declare namespace onboard {
+  export { type onboard_OnboardOptions as OnboardOptions, type onboard_OnboardResult as OnboardResult, type onboard_OnboardingStatus as OnboardingStatus, onboard_onboardWorkspace as onboardWorkspace, onboard_updateOnboardingStatus as updateOnboardingStatus };
+}
+
+/**
+ * QMD-compatible search adapter.
+ *
+ * This package intentionally degrades gracefully to core keyword search when
+ * a QMD backend is not configured.
+ */
+
+interface QmdSearchOptions {
+    mode?: 'auto' | 'core' | 'qmd';
+    type?: string;
+    limit?: number;
+}
+interface QmdSearchResult {
+    mode: 'core' | 'qmd';
+    query: string;
+    results: PrimitiveInstance[];
+    fallbackReason?: string;
+}
+declare function search(workspacePath: string, text: string, options?: QmdSearchOptions): QmdSearchResult;
+
+type searchQmdAdapter_QmdSearchOptions = QmdSearchOptions;
+type searchQmdAdapter_QmdSearchResult = QmdSearchResult;
+declare const searchQmdAdapter_search: typeof search;
+declare namespace searchQmdAdapter {
+  export { type searchQmdAdapter_QmdSearchOptions as QmdSearchOptions, type searchQmdAdapter_QmdSearchResult as QmdSearchResult, searchQmdAdapter_search as search };
+}
+
+/**
+ * Trigger-to-run dispatch helpers.
+ */
+
+interface FireTriggerOptions {
+    actor: string;
+    eventKey?: string;
+    objective?: string;
+    context?: Record<string, unknown>;
+}
+interface FireTriggerResult {
+    triggerPath: string;
+    run: DispatchRun;
+    idempotencyKey: string;
+}
+declare function fireTrigger(workspacePath: string, triggerPath: string, options: FireTriggerOptions): FireTriggerResult;
+
+type trigger_FireTriggerOptions = FireTriggerOptions;
+type trigger_FireTriggerResult = FireTriggerResult;
+declare const trigger_fireTrigger: typeof fireTrigger;
+declare namespace trigger {
+  export { type trigger_FireTriggerOptions as FireTriggerOptions, type trigger_FireTriggerResult as FireTriggerResult, trigger_fireTrigger as fireTrigger };
 }
 
-export { type FieldDefinition, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PrimitiveInstance, type PrimitiveTypeDefinition, type Registry, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphWorkspaceConfig, bases, commandCenter, ledger, registry, skill, store, thread, workspace };
+export { type DispatchRun, type FieldDefinition, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, bases, board, commandCenter, dispatch, graph, ledger, onboard, orientation, policy, query, registry, searchQmdAdapter, skill, store, thread, trigger, workspace };

package/dist/index.js

@@ -1,22 +1,40 @@
 import {
   THREAD_STATUS_TRANSITIONS,
   bases_exports,
+  board_exports,
   command_center_exports,
+  dispatch_exports,
+  graph_exports,
   ledger_exports,
+  onboard_exports,
+  orientation_exports,
+  policy_exports,
+  query_exports,
   registry_exports,
+  search_qmd_adapter_exports,
   skill_exports,
   store_exports,
   thread_exports,
+  trigger_exports,
   workspace_exports
-} from "./chunk-CRQXDCPR.js";
+} from "./chunk-XUMA4O2Z.js";
 export {
   THREAD_STATUS_TRANSITIONS,
   bases_exports as bases,
+  board_exports as board,
   command_center_exports as commandCenter,
+  dispatch_exports as dispatch,
+  graph_exports as graph,
   ledger_exports as ledger,
+  onboard_exports as onboard,
+  orientation_exports as orientation,
+  policy_exports as policy,
+  query_exports as query,
   registry_exports as registry,
+  search_qmd_adapter_exports as searchQmdAdapter,
   skill_exports as skill,
   store_exports as store,
   thread_exports as thread,
+  trigger_exports as trigger,
   workspace_exports as workspace
 };

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@versatly/workgraph",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Agent-first workgraph workspace for multi-agent coordination with dynamic primitives, append-only ledger, and markdown-native storage.",
+  "workspaces": [
+    "packages/*"
+  ],
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -28,9 +31,14 @@
   ],
   "scripts": {
     "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+    "build:packages": "npm run build --workspaces --if-present",
     "typecheck": "tsc --noEmit",
+    "typecheck:packages": "npm run typecheck --workspaces --if-present",
     "test": "vitest run --config vitest.config.ts",
-    "ci": "npm run typecheck && npm run test && npm run build",
+    "test:packages": "npm run test --workspaces --if-present",
+    "demo:workspace": "npm run build --silent && node scripts/generate-demo-workspace.mjs /tmp/workgraph-obsidian-demo",
+    "demo:obsidian-setup": "npm run build --silent && node scripts/setup-obsidian-demo.mjs /tmp/workgraph-obsidian-demo",
+    "ci": "npm run typecheck && npm run typecheck:packages && npm run test && npm run build",
     "prepublishOnly": "npm run ci"
   },
   "keywords": [
@@ -45,12 +53,11 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Versatly/clawvault.git",
-    "directory": "packages/workgraph"
+    "url": "git+https://github.com/Versatly/workgraph.git"
   },
-  "homepage": "https://github.com/Versatly/clawvault/tree/main/packages/workgraph",
+  "homepage": "https://github.com/Versatly/workgraph",
   "bugs": {
-    "url": "https://github.com/Versatly/clawvault/issues"
+    "url": "https://github.com/Versatly/workgraph/issues"
   },
   "engines": {
     "node": ">=18"
@@ -62,6 +69,8 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
     "tsup": "^8.5.1",
     "typescript": "^5.3.3",
     "vitest": "^1.6.1"