@versatly/workgraph 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export { m as mcpServer } from './mcp-server-fU6U6ht8.js';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+
 /**
  * Workgraph type definitions.
  */
@@ -6,6 +9,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 +90,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 +194,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 +219,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 +276,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 +283,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 +488,8 @@ interface WriteSkillOptions {
     tailscalePath?: string;
     reviewers?: string[];
     tags?: string[];
+    dependsOn?: string[];
+    expectedUpdatedAt?: string;
 }
 interface ProposeSkillOptions {
     proposalThread?: string;
@@ -400,8 +504,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 +525,423 @@ 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 with adapter-backed execution.
+ */
+
+interface DispatchCreateInput {
+    actor: string;
+    adapter?: string;
+    objective: string;
+    context?: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+interface DispatchExecuteInput {
+    actor: string;
+    agents?: string[];
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    createCheckpoint?: boolean;
+}
+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;
+    contextPatch?: Record<string, unknown>;
+}): DispatchRun;
+declare function logs(workspacePath: string, runId: string): DispatchRun['logs'];
+declare function listRuns(workspacePath: string, options?: {
+    status?: RunStatus;
+    limit?: number;
+}): DispatchRun[];
+declare function executeRun(workspacePath: string, runId: string, input: DispatchExecuteInput): Promise<DispatchRun>;
+declare function createAndExecuteRun(workspacePath: string, createInput: DispatchCreateInput, executeInput?: Omit<DispatchExecuteInput, 'actor'>): Promise<DispatchRun>;
+
+type dispatch_DispatchCreateInput = DispatchCreateInput;
+type dispatch_DispatchExecuteInput = DispatchExecuteInput;
+declare const dispatch_createAndExecuteRun: typeof createAndExecuteRun;
+declare const dispatch_createRun: typeof createRun;
+declare const dispatch_executeRun: typeof executeRun;
+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, type dispatch_DispatchExecuteInput as DispatchExecuteInput, dispatch_createAndExecuteRun as createAndExecuteRun, dispatch_createRun as createRun, dispatch_executeRun as executeRun, 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 };
+}
+
+interface SkillIntegrationProvider {
+    id: string;
+    defaultTitle: string;
+    defaultSourceUrl: string;
+    distribution: string;
+    defaultTags: string[];
+    userAgent?: string;
+}
+interface InstallSkillIntegrationOptions {
+    actor: string;
+    owner?: string;
+    title?: string;
+    sourceUrl?: string;
+    force?: boolean;
+    status?: WriteSkillOptions['status'];
+    tags?: string[];
+    fetchSkillMarkdown?: (sourceUrl: string) => Promise<string>;
+}
+interface InstallSkillIntegrationResult {
+    provider: string;
+    skill: PrimitiveInstance;
+    sourceUrl: string;
+    importedAt: string;
+    replacedExisting: boolean;
+}
+declare function installSkillIntegration(workspacePath: string, provider: SkillIntegrationProvider, options: InstallSkillIntegrationOptions): Promise<InstallSkillIntegrationResult>;
+declare function fetchSkillMarkdownFromUrl(sourceUrl: string, userAgent?: string): Promise<string>;
+
+declare const DEFAULT_CLAWDAPUS_SKILL_URL = "https://raw.githubusercontent.com/mostlydev/clawdapus/master/skills/clawdapus/SKILL.md";
+declare const CLAWDAPUS_INTEGRATION_PROVIDER: SkillIntegrationProvider;
+type InstallClawdapusSkillOptions = InstallSkillIntegrationOptions;
+type InstallClawdapusSkillResult = InstallSkillIntegrationResult;
+declare function installClawdapusSkill(workspacePath: string, options: InstallClawdapusSkillOptions): Promise<InstallClawdapusSkillResult>;
+declare function fetchClawdapusSkillMarkdown(sourceUrl: string): Promise<string>;
+
+declare const clawdapus_CLAWDAPUS_INTEGRATION_PROVIDER: typeof CLAWDAPUS_INTEGRATION_PROVIDER;
+declare const clawdapus_DEFAULT_CLAWDAPUS_SKILL_URL: typeof DEFAULT_CLAWDAPUS_SKILL_URL;
+type clawdapus_InstallClawdapusSkillOptions = InstallClawdapusSkillOptions;
+type clawdapus_InstallClawdapusSkillResult = InstallClawdapusSkillResult;
+declare const clawdapus_fetchClawdapusSkillMarkdown: typeof fetchClawdapusSkillMarkdown;
+declare const clawdapus_installClawdapusSkill: typeof installClawdapusSkill;
+declare namespace clawdapus {
+  export { clawdapus_CLAWDAPUS_INTEGRATION_PROVIDER as CLAWDAPUS_INTEGRATION_PROVIDER, clawdapus_DEFAULT_CLAWDAPUS_SKILL_URL as DEFAULT_CLAWDAPUS_SKILL_URL, type clawdapus_InstallClawdapusSkillOptions as InstallClawdapusSkillOptions, type clawdapus_InstallClawdapusSkillResult as InstallClawdapusSkillResult, clawdapus_fetchClawdapusSkillMarkdown as fetchClawdapusSkillMarkdown, clawdapus_installClawdapusSkill as installClawdapusSkill };
+}
+
+interface IntegrationDescriptor {
+    id: string;
+    description: string;
+    defaultTitle: string;
+    defaultSourceUrl: string;
+}
+declare function listIntegrations(): IntegrationDescriptor[];
+declare function installIntegration(workspacePath: string, integrationId: string, options: InstallSkillIntegrationOptions): Promise<InstallSkillIntegrationResult>;
+
+type integration_IntegrationDescriptor = IntegrationDescriptor;
+declare const integration_installIntegration: typeof installIntegration;
+declare const integration_listIntegrations: typeof listIntegrations;
+declare namespace integration {
+  export { type integration_IntegrationDescriptor as IntegrationDescriptor, integration_installIntegration as installIntegration, integration_listIntegrations as listIntegrations };
+}
+
+interface DispatchAdapterCreateInput {
+    actor: string;
+    objective: string;
+    idempotencyKey?: string;
+    context?: Record<string, unknown>;
+}
+interface DispatchAdapterRunStatus {
+    runId: string;
+    status: RunStatus;
+}
+interface DispatchAdapterLogEntry {
+    ts: string;
+    level: 'info' | 'warn' | 'error';
+    message: string;
+}
+interface DispatchAdapterExecutionInput {
+    workspacePath: string;
+    runId: string;
+    actor: string;
+    objective: string;
+    context?: Record<string, unknown>;
+    agents?: string[];
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    createCheckpoint?: boolean;
+    isCancelled?: () => boolean;
+}
+interface DispatchAdapterExecutionResult {
+    status: RunStatus;
+    output?: string;
+    error?: string;
+    logs: DispatchAdapterLogEntry[];
+    metrics?: Record<string, unknown>;
+}
+interface DispatchAdapter {
+    name: string;
+    create(input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
+    status(runId: string): Promise<DispatchAdapterRunStatus>;
+    followup(runId: string, actor: string, input: string): Promise<DispatchAdapterRunStatus>;
+    stop(runId: string, actor: string): Promise<DispatchAdapterRunStatus>;
+    logs(runId: string): Promise<DispatchAdapterLogEntry[]>;
+    execute?(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
+}
+
+declare class CursorCloudAdapter implements DispatchAdapter {
+    name: string;
+    create(_input: DispatchAdapterCreateInput): Promise<DispatchAdapterRunStatus>;
+    status(runId: string): Promise<DispatchAdapterRunStatus>;
+    followup(runId: string, _actor: string, _input: string): Promise<DispatchAdapterRunStatus>;
+    stop(runId: string, _actor: string): Promise<DispatchAdapterRunStatus>;
+    logs(_runId: string): Promise<DispatchAdapterLogEntry[]>;
+    execute(input: DispatchAdapterExecutionInput): Promise<DispatchAdapterExecutionResult>;
 }
 
-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 { CursorCloudAdapter, type DispatchAdapter, type DispatchAdapterCreateInput, type DispatchAdapterExecutionInput, type DispatchAdapterExecutionResult, type DispatchAdapterLogEntry, type DispatchAdapterRunStatus, type DispatchRun, type FieldDefinition, type InstallSkillIntegrationOptions, type InstallSkillIntegrationResult, type LedgerChainState, type LedgerEntry, type LedgerIndex, type LedgerOp, type PolicyParty, type PolicyRegistry, type PrimitiveInstance, type PrimitiveQueryFilters, type PrimitiveTypeDefinition, type Registry, type RunStatus, type SkillIntegrationProvider, THREAD_STATUS_TRANSITIONS, type ThreadStatus, type WorkgraphBrief, type WorkgraphStatusSnapshot, type WorkgraphWorkspaceConfig, bases, board, clawdapus, commandCenter, dispatch, fetchSkillMarkdownFromUrl, graph, installSkillIntegration, integration, ledger, onboard, orientation, policy, query, registry, searchQmdAdapter, skill, store, thread, trigger, workspace };

package/dist/index.js

@@ -1,22 +1,54 @@
 import {
-  THREAD_STATUS_TRANSITIONS,
   bases_exports,
+  board_exports,
+  clawdapus_exports,
   command_center_exports,
+  fetchSkillMarkdownFromUrl,
+  installSkillIntegration,
+  integration_exports,
+  onboard_exports,
+  search_qmd_adapter_exports,
+  skill_exports,
+  trigger_exports,
+  workspace_exports
+} from "./chunk-E3QU5Y53.js";
+import {
+  CursorCloudAdapter,
+  THREAD_STATUS_TRANSITIONS,
+  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";
 export {
+  CursorCloudAdapter,
   THREAD_STATUS_TRANSITIONS,
   bases_exports as bases,
+  board_exports as board,
+  clawdapus_exports as clawdapus,
   command_center_exports as commandCenter,
+  dispatch_exports as dispatch,
+  fetchSkillMarkdownFromUrl,
+  graph_exports as graph,
+  installSkillIntegration,
+  integration_exports as integration,
   ledger_exports as ledger,
+  mcp_server_exports as mcpServer,
+  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/dist/mcp-server-fU6U6ht8.d.ts

@@ -0,0 +1,20 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+interface WorkgraphMcpServerOptions {
+    workspacePath: string;
+    defaultActor?: string;
+    readOnly?: boolean;
+    name?: string;
+    version?: string;
+}
+declare function createWorkgraphMcpServer(options: WorkgraphMcpServerOptions): McpServer;
+declare function startWorkgraphMcpServer(options: WorkgraphMcpServerOptions): Promise<McpServer>;
+
+type mcpServer_WorkgraphMcpServerOptions = WorkgraphMcpServerOptions;
+declare const mcpServer_createWorkgraphMcpServer: typeof createWorkgraphMcpServer;
+declare const mcpServer_startWorkgraphMcpServer: typeof startWorkgraphMcpServer;
+declare namespace mcpServer {
+  export { type mcpServer_WorkgraphMcpServerOptions as WorkgraphMcpServerOptions, mcpServer_createWorkgraphMcpServer as createWorkgraphMcpServer, mcpServer_startWorkgraphMcpServer as startWorkgraphMcpServer };
+}
+
+export { type WorkgraphMcpServerOptions as W, createWorkgraphMcpServer as c, mcpServer as m, startWorkgraphMcpServer as s };