@versatly/workgraph 0.2.0 → 1.0.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.
  */
@@ -45,7 +48,7 @@ interface Registry {
     version: number;
     types: Record<string, PrimitiveTypeDefinition>;
 }
-type LedgerOp = 'create' | 'update' | 'delete' | 'claim' | 'release' | 'block' | 'unblock' | 'done' | 'cancel' | 'define' | 'decompose';
+type LedgerOp = 'create' | 'update' | 'delete' | 'claim' | 'heartbeat' | 'release' | 'block' | 'unblock' | 'done' | 'reopen' | 'cancel' | 'define' | 'decompose' | 'handoff';
 interface LedgerEntry {
     ts: string;
     actor: string;
@@ -149,6 +152,9 @@ interface DispatchRun {
     adapter: string;
     objective: string;
     status: RunStatus;
+    leaseExpires?: string;
+    leaseDurationMinutes?: number;
+    heartbeats?: string[];
     idempotencyKey?: string;
     context?: Record<string, unknown>;
     output?: string;
@@ -291,8 +297,12 @@ declare function create(workspacePath: string, typeName: string, fields: Record<
     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;
+declare function list$1(workspacePath: string, typeName: string): PrimitiveInstance[];
+interface PrimitiveUpdateOptions {
+    expectedEtag?: string;
+    concurrentConflictMode?: 'warn' | 'error';
+}
+declare function update(workspacePath: string, relPath: string, fieldUpdates: Record<string, unknown>, bodyUpdate: string | undefined, actor: string, options?: PrimitiveUpdateOptions): PrimitiveInstance;
 declare function remove(workspacePath: string, relPath: string, actor: string): void;
 declare function findByField(workspacePath: string, typeName: string, field: string, value: unknown): PrimitiveInstance[];
 declare function openThreads(workspacePath: string): PrimitiveInstance[];
@@ -300,18 +310,49 @@ declare function activeThreads(workspacePath: string): PrimitiveInstance[];
 declare function blockedThreads(workspacePath: string): PrimitiveInstance[];
 declare function threadsInSpace(workspacePath: string, spaceRef: string): PrimitiveInstance[];
 
+type store_PrimitiveUpdateOptions = PrimitiveUpdateOptions;
 declare const store_activeThreads: typeof activeThreads;
 declare const store_blockedThreads: typeof blockedThreads;
 declare const store_create: typeof create;
 declare const store_findByField: typeof findByField;
-declare const store_list: typeof list;
 declare const store_openThreads: typeof openThreads;
 declare const store_read: typeof read;
 declare const store_remove: typeof remove;
 declare const store_threadsInSpace: typeof threadsInSpace;
 declare const store_update: typeof update;
 declare namespace store {
-  export { store_activeThreads as activeThreads, store_blockedThreads as blockedThreads, store_create as create, store_findByField as findByField, store_list as list, store_openThreads as openThreads, store_read as read, store_remove as remove, store_threadsInSpace as threadsInSpace, store_update as update };
+  export { type store_PrimitiveUpdateOptions as PrimitiveUpdateOptions, store_activeThreads as activeThreads, store_blockedThreads as blockedThreads, store_create as create, store_findByField as findByField, list$1 as list, store_openThreads as openThreads, store_read as read, store_remove as remove, store_threadsInSpace as threadsInSpace, store_update as update };
+}
+
+interface ClaimLeaseRecord {
+    target: string;
+    owner: string;
+    claimedAt: string;
+    lastHeartbeatAt: string;
+    expiresAt: string;
+    ttlMinutes: number;
+}
+interface ClaimLeaseStatus extends ClaimLeaseRecord {
+    stale: boolean;
+    msUntilExpiry: number;
+}
+declare function listClaimLeases(workspacePath: string, nowMs?: number): ClaimLeaseStatus[];
+declare function setClaimLease(workspacePath: string, target: string, owner: string, options?: {
+    ttlMinutes?: number;
+    now?: Date;
+    claimedAt?: string;
+}): ClaimLeaseRecord;
+declare function removeClaimLease(workspacePath: string, target: string): void;
+declare function claimLeasePath(workspacePath: string): string;
+
+type claimLease_ClaimLeaseRecord = ClaimLeaseRecord;
+type claimLease_ClaimLeaseStatus = ClaimLeaseStatus;
+declare const claimLease_claimLeasePath: typeof claimLeasePath;
+declare const claimLease_listClaimLeases: typeof listClaimLeases;
+declare const claimLease_removeClaimLease: typeof removeClaimLease;
+declare const claimLease_setClaimLease: typeof setClaimLease;
+declare namespace claimLease {
+  export { type claimLease_ClaimLeaseRecord as ClaimLeaseRecord, type claimLease_ClaimLeaseStatus as ClaimLeaseStatus, claimLease_claimLeasePath as claimLeasePath, claimLease_listClaimLeases as listClaimLeases, claimLease_removeClaimLease as removeClaimLease, claimLease_setClaimLease as setClaimLease };
 }
 
 /**
@@ -333,18 +374,58 @@ declare function pickNextReadyThread(workspacePath: string): PrimitiveInstance |
 declare function pickNextReadyThreadInSpace(workspacePath: string, spaceRef: string): PrimitiveInstance | null;
 declare function claimNextReady(workspacePath: string, actor: string): PrimitiveInstance | null;
 declare function claimNextReadyInSpace(workspacePath: string, actor: string, spaceRef: string): PrimitiveInstance | null;
-declare function claim(workspacePath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function claim(workspacePath: string, threadPath: string, actor: string, options?: {
+    leaseTtlMinutes?: number;
+}): PrimitiveInstance;
 declare function release(workspacePath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function heartbeat$2(workspacePath: string, threadPath: string, actor: string, leaseMinutes?: number): PrimitiveInstance;
+declare function handoff(workspacePath: string, threadPath: string, fromActor: string, toActor: string, note?: string): PrimitiveInstance;
 declare function block(workspacePath: string, threadPath: string, actor: string, blockedBy: string, reason?: string): PrimitiveInstance;
 declare function unblock(workspacePath: string, threadPath: string, actor: string): PrimitiveInstance;
 declare function done(workspacePath: string, threadPath: string, actor: string, output?: string): PrimitiveInstance;
 declare function cancel(workspacePath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function reopen(workspacePath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+interface ThreadHeartbeatResult {
+    actor: string;
+    touched: Array<{
+        threadPath: string;
+        expiresAt: string;
+        ttlMinutes: number;
+    }>;
+    skipped: Array<{
+        threadPath: string;
+        reason: string;
+    }>;
+}
+declare function heartbeatClaim(workspacePath: string, actor: string, threadPath?: string, options?: {
+    ttlMinutes?: number;
+}): ThreadHeartbeatResult;
+interface ReapStaleClaimsResult {
+    actor: string;
+    scanned: number;
+    reaped: Array<{
+        threadPath: string;
+        previousOwner: string;
+        expiredAt: string;
+    }>;
+    skipped: Array<{
+        threadPath: string;
+        reason: string;
+    }>;
+}
+declare function reapStaleClaims(workspacePath: string, actor: string, options?: {
+    limit?: number;
+}): ReapStaleClaimsResult;
+declare function listClaimLeaseStatus(workspacePath: string): ClaimLeaseStatus[];
 declare function decompose(workspacePath: string, parentPath: string, subthreads: Array<{
     title: string;
     goal: string;
     deps?: string[];
 }>, actor: string): PrimitiveInstance[];
+declare function inferThreadDependenciesFromText(text: string): string[];
 
+type thread_ReapStaleClaimsResult = ReapStaleClaimsResult;
+type thread_ThreadHeartbeatResult = ThreadHeartbeatResult;
 declare const thread_block: typeof block;
 declare const thread_cancel: typeof cancel;
 declare const thread_claim: typeof claim;
@@ -353,15 +434,21 @@ declare const thread_claimNextReadyInSpace: typeof claimNextReadyInSpace;
 declare const thread_createThread: typeof createThread;
 declare const thread_decompose: typeof decompose;
 declare const thread_done: typeof done;
+declare const thread_handoff: typeof handoff;
+declare const thread_heartbeatClaim: typeof heartbeatClaim;
+declare const thread_inferThreadDependenciesFromText: typeof inferThreadDependenciesFromText;
 declare const thread_isReadyForClaim: typeof isReadyForClaim;
+declare const thread_listClaimLeaseStatus: typeof listClaimLeaseStatus;
 declare const thread_listReadyThreads: typeof listReadyThreads;
 declare const thread_listReadyThreadsInSpace: typeof listReadyThreadsInSpace;
 declare const thread_pickNextReadyThread: typeof pickNextReadyThread;
 declare const thread_pickNextReadyThreadInSpace: typeof pickNextReadyThreadInSpace;
+declare const thread_reapStaleClaims: typeof reapStaleClaims;
 declare const thread_release: typeof release;
+declare const thread_reopen: typeof reopen;
 declare const thread_unblock: typeof unblock;
 declare namespace thread {
-  export { thread_block as block, thread_cancel as cancel, thread_claim as claim, thread_claimNextReady as claimNextReady, thread_claimNextReadyInSpace as claimNextReadyInSpace, thread_createThread as createThread, thread_decompose as decompose, thread_done as done, thread_isReadyForClaim as isReadyForClaim, thread_listReadyThreads as listReadyThreads, thread_listReadyThreadsInSpace as listReadyThreadsInSpace, thread_pickNextReadyThread as pickNextReadyThread, thread_pickNextReadyThreadInSpace as pickNextReadyThreadInSpace, thread_release as release, thread_unblock as unblock };
+  export { type thread_ReapStaleClaimsResult as ReapStaleClaimsResult, type thread_ThreadHeartbeatResult as ThreadHeartbeatResult, thread_block as block, thread_cancel as cancel, thread_claim as claim, thread_claimNextReady as claimNextReady, thread_claimNextReadyInSpace as claimNextReadyInSpace, thread_createThread as createThread, thread_decompose as decompose, thread_done as done, thread_handoff as handoff, heartbeat$2 as heartbeat, thread_heartbeatClaim as heartbeatClaim, thread_inferThreadDependenciesFromText as inferThreadDependenciesFromText, thread_isReadyForClaim as isReadyForClaim, thread_listClaimLeaseStatus as listClaimLeaseStatus, thread_listReadyThreads as listReadyThreads, thread_listReadyThreadsInSpace as listReadyThreadsInSpace, thread_pickNextReadyThread as pickNextReadyThread, thread_pickNextReadyThreadInSpace as pickNextReadyThreadInSpace, thread_reapStaleClaims as reapStaleClaims, thread_release as release, thread_reopen as reopen, thread_unblock as unblock };
 }
 
 /**
@@ -569,15 +656,26 @@ declare namespace orientation {
 }
 
 /**
- * Wiki-link graph indexing and hygiene reports.
+ * Wiki-link graph indexing and graph-intelligence queries.
  */
+type WikiGraphEdgeType = 'wiki' | 'context_refs' | 'depends_on' | 'blocks' | 'informs' | 'contradicts' | 'supports' | 'supersedes' | 'parent';
 interface WikiGraphEdge {
     from: string;
     to: string;
+    type: WikiGraphEdgeType;
+    source: 'body' | 'frontmatter';
+    field?: string;
+}
+interface WikiGraphNode {
+    path: string;
+    slug: string;
+    type: string;
+    title?: string;
 }
 interface WikiGraphIndex {
     generatedAt: string;
     nodes: string[];
+    nodeInfo: Record<string, WikiGraphNode>;
     edges: WikiGraphEdge[];
     backlinks: Record<string, string[]>;
     orphans: string[];
@@ -596,6 +694,66 @@ interface WikiGraphNeighborhood {
     outgoing: string[];
     incoming: string[];
 }
+interface WikiGraphNeighborhoodQueryNode extends WikiGraphNode {
+    exists: boolean;
+    distance: number;
+}
+interface WikiGraphNeighborhoodQuery {
+    center: WikiGraphNeighborhoodQueryNode;
+    depth: number;
+    connectedNodes: WikiGraphNeighborhoodQueryNode[];
+    edges: WikiGraphEdge[];
+}
+interface WikiGraphImpactReference {
+    node: WikiGraphNode;
+    edgeTypes: WikiGraphEdgeType[];
+    referenceCount: number;
+}
+interface WikiGraphImpactGroup {
+    type: string;
+    references: WikiGraphImpactReference[];
+    referenceCount: number;
+}
+interface WikiGraphImpactAnalysis {
+    target: WikiGraphNode & {
+        exists: boolean;
+    };
+    totalReferences: number;
+    incomingEdges: WikiGraphEdge[];
+    groups: WikiGraphImpactGroup[];
+}
+interface WikiGraphContextSection {
+    path: string;
+    type: string;
+    distance: number;
+    chars: number;
+    tokens: number;
+}
+interface WikiGraphContextAssembly {
+    center: WikiGraphNode & {
+        exists: boolean;
+    };
+    budgetTokens: number;
+    usedTokens: number;
+    sections: WikiGraphContextSection[];
+    markdown: string;
+}
+interface WikiGraphTypedEdges {
+    node: WikiGraphNode & {
+        exists: boolean;
+    };
+    outgoing: WikiGraphEdge[];
+    incoming: WikiGraphEdge[];
+}
+interface WikiGraphExportResult {
+    center: WikiGraphNode;
+    depth: number;
+    format: 'md';
+    outputDirectory: string;
+    manifestPath: string;
+    exportedNodes: string[];
+    exportedEdgeCount: number;
+}
 declare function graphIndexPath(workspacePath: string): string;
 declare function buildWikiLinkGraph(workspacePath: string): WikiGraphIndex;
 declare function refreshWikiLinkGraphIndex(workspacePath: string): WikiGraphIndex;
@@ -616,21 +774,60 @@ declare function graphHygieneReport(workspacePath: string): {
         to: string;
     }>;
 };
+/**
+ * Backward-compatible one-hop direct neighborhood.
+ */
 declare function graphNeighborhood(workspacePath: string, nodeRef: string, options?: {
     refresh?: boolean;
 }): WikiGraphNeighborhood;
+declare function graphNeighborhoodQuery(workspacePath: string, nodeRef: string, options?: {
+    depth?: number;
+    refresh?: boolean;
+}): WikiGraphNeighborhoodQuery;
+declare function graphImpactAnalysis(workspacePath: string, nodeRef: string, options?: {
+    refresh?: boolean;
+}): WikiGraphImpactAnalysis;
+declare function graphContextAssembly(workspacePath: string, nodeRef: string, options?: {
+    budgetTokens?: number;
+    refresh?: boolean;
+}): WikiGraphContextAssembly;
+declare function graphTypedEdges(workspacePath: string, nodeRef: string, options?: {
+    refresh?: boolean;
+}): WikiGraphTypedEdges;
+declare function graphExportSubgraph(workspacePath: string, nodeRef: string, options?: {
+    depth?: number;
+    format?: 'md';
+    outputDir?: string;
+    refresh?: boolean;
+}): WikiGraphExportResult;
 
+type graph_WikiGraphContextAssembly = WikiGraphContextAssembly;
+type graph_WikiGraphContextSection = WikiGraphContextSection;
 type graph_WikiGraphEdge = WikiGraphEdge;
+type graph_WikiGraphEdgeType = WikiGraphEdgeType;
+type graph_WikiGraphExportResult = WikiGraphExportResult;
+type graph_WikiGraphImpactAnalysis = WikiGraphImpactAnalysis;
+type graph_WikiGraphImpactGroup = WikiGraphImpactGroup;
+type graph_WikiGraphImpactReference = WikiGraphImpactReference;
 type graph_WikiGraphIndex = WikiGraphIndex;
 type graph_WikiGraphNeighborhood = WikiGraphNeighborhood;
+type graph_WikiGraphNeighborhoodQuery = WikiGraphNeighborhoodQuery;
+type graph_WikiGraphNeighborhoodQueryNode = WikiGraphNeighborhoodQueryNode;
+type graph_WikiGraphNode = WikiGraphNode;
+type graph_WikiGraphTypedEdges = WikiGraphTypedEdges;
 declare const graph_buildWikiLinkGraph: typeof buildWikiLinkGraph;
+declare const graph_graphContextAssembly: typeof graphContextAssembly;
+declare const graph_graphExportSubgraph: typeof graphExportSubgraph;
 declare const graph_graphHygieneReport: typeof graphHygieneReport;
+declare const graph_graphImpactAnalysis: typeof graphImpactAnalysis;
 declare const graph_graphIndexPath: typeof graphIndexPath;
 declare const graph_graphNeighborhood: typeof graphNeighborhood;
+declare const graph_graphNeighborhoodQuery: typeof graphNeighborhoodQuery;
+declare const graph_graphTypedEdges: typeof graphTypedEdges;
 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 };
+  export { type graph_WikiGraphContextAssembly as WikiGraphContextAssembly, type graph_WikiGraphContextSection as WikiGraphContextSection, type graph_WikiGraphEdge as WikiGraphEdge, type graph_WikiGraphEdgeType as WikiGraphEdgeType, type graph_WikiGraphExportResult as WikiGraphExportResult, type graph_WikiGraphImpactAnalysis as WikiGraphImpactAnalysis, type graph_WikiGraphImpactGroup as WikiGraphImpactGroup, type graph_WikiGraphImpactReference as WikiGraphImpactReference, type graph_WikiGraphIndex as WikiGraphIndex, type graph_WikiGraphNeighborhood as WikiGraphNeighborhood, type graph_WikiGraphNeighborhoodQuery as WikiGraphNeighborhoodQuery, type graph_WikiGraphNeighborhoodQueryNode as WikiGraphNeighborhoodQueryNode, type graph_WikiGraphNode as WikiGraphNode, type graph_WikiGraphTypedEdges as WikiGraphTypedEdges, graph_buildWikiLinkGraph as buildWikiLinkGraph, graph_graphContextAssembly as graphContextAssembly, graph_graphExportSubgraph as graphExportSubgraph, graph_graphHygieneReport as graphHygieneReport, graph_graphImpactAnalysis as graphImpactAnalysis, graph_graphIndexPath as graphIndexPath, graph_graphNeighborhood as graphNeighborhood, graph_graphNeighborhoodQuery as graphNeighborhoodQuery, graph_graphTypedEdges as graphTypedEdges, graph_readWikiLinkGraphIndex as readWikiLinkGraphIndex, graph_refreshWikiLinkGraphIndex as refreshWikiLinkGraphIndex };
 }
 
 /**
@@ -693,7 +890,40 @@ declare namespace policy {
 }
 
 /**
- * Runtime dispatch contract (MVP local adapter).
+ * Thread quality gate evaluation.
+ */
+interface GateRuleResult {
+    rule: 'required-facts' | 'required-approvals' | 'min-age-seconds' | 'gate-status' | 'gate-exists';
+    ok: boolean;
+    message: string;
+}
+interface GateEvaluation {
+    gateRef: string;
+    gatePath?: string;
+    gateTitle?: string;
+    ok: boolean;
+    rules: GateRuleResult[];
+}
+interface ThreadGateCheckResult {
+    checkedAt: string;
+    threadPath: string;
+    allowed: boolean;
+    gates: GateEvaluation[];
+}
+declare function checkThreadGates(workspacePath: string, threadRef: string, now?: Date): ThreadGateCheckResult;
+declare function summarizeGateFailures(result: ThreadGateCheckResult): string;
+
+type gate_GateEvaluation = GateEvaluation;
+type gate_GateRuleResult = GateRuleResult;
+type gate_ThreadGateCheckResult = ThreadGateCheckResult;
+declare const gate_checkThreadGates: typeof checkThreadGates;
+declare const gate_summarizeGateFailures: typeof summarizeGateFailures;
+declare namespace gate {
+  export { type gate_GateEvaluation as GateEvaluation, type gate_GateRuleResult as GateRuleResult, type gate_ThreadGateCheckResult as ThreadGateCheckResult, gate_checkThreadGates as checkThreadGates, gate_summarizeGateFailures as summarizeGateFailures };
+}
+
+/**
+ * Runtime dispatch contract with adapter-backed execution.
  */
 
 interface DispatchCreateInput {
@@ -703,30 +933,103 @@ interface DispatchCreateInput {
     context?: Record<string, unknown>;
     idempotencyKey?: string;
 }
+interface DispatchExecuteInput {
+    actor: string;
+    agents?: string[];
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    createCheckpoint?: boolean;
+}
+interface DispatchHeartbeatInput {
+    actor: string;
+    leaseMinutes?: number;
+}
+interface DispatchReconcileResult {
+    reconciledAt: string;
+    inspectedRuns: number;
+    requeuedRuns: DispatchRun[];
+}
+interface DispatchHandoffInput {
+    actor: string;
+    to: string;
+    reason: string;
+    adapter?: string;
+}
+interface DispatchHandoffResult {
+    sourceRun: DispatchRun;
+    handoffRun: DispatchRun;
+}
+interface DispatchClaimResult {
+    thread: PrimitiveInstance;
+    gateCheck: ThreadGateCheckResult;
+}
 declare function createRun(workspacePath: string, input: DispatchCreateInput): DispatchRun;
+declare function claimThread(workspacePath: string, threadRef: string, actor: string): DispatchClaimResult;
 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 heartbeat$1(workspacePath: string, runId: string, input: DispatchHeartbeatInput): DispatchRun;
+declare function reconcileExpiredLeases(workspacePath: string, actor: string): DispatchReconcileResult;
+declare function handoffRun(workspacePath: string, runId: string, input: DispatchHandoffInput): DispatchHandoffResult;
 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_DispatchClaimResult = DispatchClaimResult;
 type dispatch_DispatchCreateInput = DispatchCreateInput;
+type dispatch_DispatchExecuteInput = DispatchExecuteInput;
+type dispatch_DispatchHandoffInput = DispatchHandoffInput;
+type dispatch_DispatchHandoffResult = DispatchHandoffResult;
+type dispatch_DispatchHeartbeatInput = DispatchHeartbeatInput;
+type dispatch_DispatchReconcileResult = DispatchReconcileResult;
+declare const dispatch_claimThread: typeof claimThread;
+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_handoffRun: typeof handoffRun;
 declare const dispatch_listRuns: typeof listRuns;
 declare const dispatch_logs: typeof logs;
 declare const dispatch_markRun: typeof markRun;
+declare const dispatch_reconcileExpiredLeases: typeof reconcileExpiredLeases;
 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 };
+  export { type dispatch_DispatchClaimResult as DispatchClaimResult, type dispatch_DispatchCreateInput as DispatchCreateInput, type dispatch_DispatchExecuteInput as DispatchExecuteInput, type dispatch_DispatchHandoffInput as DispatchHandoffInput, type dispatch_DispatchHandoffResult as DispatchHandoffResult, type dispatch_DispatchHeartbeatInput as DispatchHeartbeatInput, type dispatch_DispatchReconcileResult as DispatchReconcileResult, dispatch_claimThread as claimThread, dispatch_createAndExecuteRun as createAndExecuteRun, dispatch_createRun as createRun, dispatch_executeRun as executeRun, dispatch_followup as followup, dispatch_handoffRun as handoffRun, heartbeat$1 as heartbeat, dispatch_listRuns as listRuns, dispatch_logs as logs, dispatch_markRun as markRun, dispatch_reconcileExpiredLeases as reconcileExpiredLeases, dispatch_status as status, dispatch_stop as stop };
+}
+
+/**
+ * Agent presence primitives.
+ */
+
+type AgentPresenceStatus = 'online' | 'busy' | 'offline';
+interface AgentHeartbeatOptions {
+    status?: AgentPresenceStatus;
+    currentTask?: string;
+    capabilities?: string[];
+    actor?: string;
+}
+declare function heartbeat(workspacePath: string, name: string, options?: AgentHeartbeatOptions): PrimitiveInstance;
+declare function list(workspacePath: string): PrimitiveInstance[];
+declare function getPresence(workspacePath: string, name: string): PrimitiveInstance | null;
+
+type agent_AgentHeartbeatOptions = AgentHeartbeatOptions;
+type agent_AgentPresenceStatus = AgentPresenceStatus;
+declare const agent_getPresence: typeof getPresence;
+declare const agent_heartbeat: typeof heartbeat;
+declare const agent_list: typeof list;
+declare namespace agent {
+  export { type agent_AgentHeartbeatOptions as AgentHeartbeatOptions, type agent_AgentPresenceStatus as AgentPresenceStatus, agent_getPresence as getPresence, agent_heartbeat as heartbeat, agent_list as list };
 }
 
 /**
@@ -760,6 +1063,31 @@ 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 };
 }
 
+type ThreadAuditIssueKind = 'thread_without_ledger_history' | 'active_without_claim' | 'active_owner_mismatch' | 'claim_without_active_status' | 'owner_set_without_active' | 'dependency_reference_not_declared' | 'declared_dependency_missing_target' | 'active_without_lease' | 'stale_lease';
+interface ThreadAuditIssue {
+    kind: ThreadAuditIssueKind;
+    path: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface ThreadAuditReport {
+    ok: boolean;
+    generatedAt: string;
+    totalThreads: number;
+    totalClaims: number;
+    totalLeases: number;
+    issues: ThreadAuditIssue[];
+}
+declare function reconcileThreadState(workspacePath: string): ThreadAuditReport;
+
+type threadAudit_ThreadAuditIssue = ThreadAuditIssue;
+type threadAudit_ThreadAuditIssueKind = ThreadAuditIssueKind;
+type threadAudit_ThreadAuditReport = ThreadAuditReport;
+declare const threadAudit_reconcileThreadState: typeof reconcileThreadState;
+declare namespace threadAudit {
+  export { type threadAudit_ThreadAuditIssue as ThreadAuditIssue, type threadAudit_ThreadAuditIssueKind as ThreadAuditIssueKind, type threadAudit_ThreadAuditReport as ThreadAuditReport, threadAudit_reconcileThreadState as reconcileThreadState };
+}
+
 /**
  * QMD-compatible search adapter.
  *
@@ -811,4 +1139,585 @@ declare namespace trigger {
   export { type trigger_FireTriggerOptions as FireTriggerOptions, type trigger_FireTriggerResult as FireTriggerResult, trigger_fireTrigger as fireTrigger };
 }
 
-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 };
+/**
+ * Trigger polling engine, cascade evaluator, and dashboard/status helpers.
+ */
+
+type TriggerRuntimeStatus = 'ready' | 'cooldown' | 'inactive' | 'error';
+interface TriggerRuntimeState {
+    fireCount: number;
+    lastEvaluatedAt?: string;
+    lastFiredAt?: string;
+    cooldownUntil?: string;
+    lastError?: string;
+    state?: TriggerRuntimeStatus;
+    lastResult?: Record<string, unknown>;
+    lastEventCursorTs?: string;
+    lastFileScanTs?: string;
+    lastCronBucket?: string;
+    synthesisCursorTs?: string;
+}
+interface TriggerStateData {
+    version: number;
+    updatedAt: string;
+    engine: {
+        cycleCount: number;
+        lastCycleAt?: string;
+        intervalSeconds: number;
+        lastError?: string;
+    };
+    triggers: Record<string, TriggerRuntimeState>;
+}
+interface TriggerEngineCycleTriggerResult {
+    triggerPath: string;
+    fired: boolean;
+    reason: string;
+    actionType?: string;
+    runtimeState: TriggerRuntimeStatus;
+    error?: string;
+}
+interface TriggerEngineCycleResult {
+    cycleAt: string;
+    evaluated: number;
+    fired: number;
+    errors: number;
+    triggers: TriggerEngineCycleTriggerResult[];
+    statePath: string;
+}
+interface TriggerEngineCycleOptions {
+    actor?: string;
+    now?: Date;
+    intervalSeconds?: number;
+}
+interface StartTriggerEngineOptions {
+    actor?: string;
+    intervalSeconds?: number;
+    maxCycles?: number;
+    logger?: (line: string) => void;
+}
+interface TriggerDashboardItem {
+    path: string;
+    title: string;
+    status: string;
+    condition: string;
+    action: string;
+    cooldownSeconds: number;
+    fireCount: number;
+    lastFiredAt?: string;
+    nextFireAt?: string;
+    currentState: TriggerRuntimeStatus;
+    lastError?: string;
+}
+interface TriggerDashboard {
+    generatedAt: string;
+    statePath: string;
+    engine: TriggerStateData['engine'];
+    triggers: TriggerDashboardItem[];
+}
+interface CascadeEvaluationResult {
+    completedThreadPath: string;
+    evaluated: number;
+    fired: number;
+    errors: number;
+    results: TriggerEngineCycleTriggerResult[];
+}
+interface AddSynthesisTriggerOptions {
+    tagPattern: string;
+    threshold: number;
+    actor: string;
+    cooldownSeconds?: number;
+}
+interface AddSynthesisTriggerResult {
+    trigger: PrimitiveInstance;
+}
+declare function triggerStatePath(workspacePath: string): string;
+declare function loadTriggerState(workspacePath: string): TriggerStateData;
+declare function saveTriggerState(workspacePath: string, state: TriggerStateData): void;
+declare function runTriggerEngineCycle(workspacePath: string, options?: TriggerEngineCycleOptions): TriggerEngineCycleResult;
+declare function startTriggerEngine(workspacePath: string, options?: StartTriggerEngineOptions): Promise<void>;
+declare function evaluateThreadCompleteCascadeTriggers(workspacePath: string, completedThreadPath: string, actor?: string, now?: Date): CascadeEvaluationResult;
+declare function triggerDashboard(workspacePath: string, now?: Date): TriggerDashboard;
+declare function addSynthesisTrigger(workspacePath: string, options: AddSynthesisTriggerOptions): AddSynthesisTriggerResult;
+
+type triggerEngine_AddSynthesisTriggerOptions = AddSynthesisTriggerOptions;
+type triggerEngine_AddSynthesisTriggerResult = AddSynthesisTriggerResult;
+type triggerEngine_CascadeEvaluationResult = CascadeEvaluationResult;
+type triggerEngine_StartTriggerEngineOptions = StartTriggerEngineOptions;
+type triggerEngine_TriggerDashboard = TriggerDashboard;
+type triggerEngine_TriggerDashboardItem = TriggerDashboardItem;
+type triggerEngine_TriggerEngineCycleOptions = TriggerEngineCycleOptions;
+type triggerEngine_TriggerEngineCycleResult = TriggerEngineCycleResult;
+type triggerEngine_TriggerEngineCycleTriggerResult = TriggerEngineCycleTriggerResult;
+declare const triggerEngine_addSynthesisTrigger: typeof addSynthesisTrigger;
+declare const triggerEngine_evaluateThreadCompleteCascadeTriggers: typeof evaluateThreadCompleteCascadeTriggers;
+declare const triggerEngine_loadTriggerState: typeof loadTriggerState;
+declare const triggerEngine_runTriggerEngineCycle: typeof runTriggerEngineCycle;
+declare const triggerEngine_saveTriggerState: typeof saveTriggerState;
+declare const triggerEngine_startTriggerEngine: typeof startTriggerEngine;
+declare const triggerEngine_triggerDashboard: typeof triggerDashboard;
+declare const triggerEngine_triggerStatePath: typeof triggerStatePath;
+declare namespace triggerEngine {
+  export { type triggerEngine_AddSynthesisTriggerOptions as AddSynthesisTriggerOptions, type triggerEngine_AddSynthesisTriggerResult as AddSynthesisTriggerResult, type triggerEngine_CascadeEvaluationResult as CascadeEvaluationResult, type triggerEngine_StartTriggerEngineOptions as StartTriggerEngineOptions, type triggerEngine_TriggerDashboard as TriggerDashboard, type triggerEngine_TriggerDashboardItem as TriggerDashboardItem, type triggerEngine_TriggerEngineCycleOptions as TriggerEngineCycleOptions, type triggerEngine_TriggerEngineCycleResult as TriggerEngineCycleResult, type triggerEngine_TriggerEngineCycleTriggerResult as TriggerEngineCycleTriggerResult, triggerEngine_addSynthesisTrigger as addSynthesisTrigger, triggerEngine_evaluateThreadCompleteCascadeTriggers as evaluateThreadCompleteCascadeTriggers, triggerEngine_loadTriggerState as loadTriggerState, triggerEngine_runTriggerEngineCycle as runTriggerEngineCycle, triggerEngine_saveTriggerState as saveTriggerState, triggerEngine_startTriggerEngine as startTriggerEngine, triggerEngine_triggerDashboard as triggerDashboard, triggerEngine_triggerStatePath as triggerStatePath };
+}
+
+interface AutonomyLoopOptions {
+    actor: string;
+    adapter?: string;
+    agents?: string[];
+    space?: string;
+    pollMs?: number;
+    watch?: boolean;
+    maxCycles?: number;
+    maxIdleCycles?: number;
+    maxSteps?: number;
+    stepDelayMs?: number;
+    staleClaimMinutes?: number;
+    executeTriggers?: boolean;
+    executeReadyThreads?: boolean;
+    heartbeatFile?: string;
+}
+interface AutonomyCycleReport {
+    cycle: number;
+    readyThreads: number;
+    triggerActions: number;
+    runId?: string;
+    runStatus?: string;
+    driftOk: boolean;
+    driftIssues: number;
+}
+interface AutonomyLoopResult {
+    cycles: AutonomyCycleReport[];
+    finalReadyThreads: number;
+    finalDriftOk: boolean;
+}
+declare function runAutonomyLoop(workspacePath: string, options: AutonomyLoopOptions): Promise<AutonomyLoopResult>;
+
+type autonomy_AutonomyCycleReport = AutonomyCycleReport;
+type autonomy_AutonomyLoopOptions = AutonomyLoopOptions;
+type autonomy_AutonomyLoopResult = AutonomyLoopResult;
+declare const autonomy_runAutonomyLoop: typeof runAutonomyLoop;
+declare namespace autonomy {
+  export { type autonomy_AutonomyCycleReport as AutonomyCycleReport, type autonomy_AutonomyLoopOptions as AutonomyLoopOptions, type autonomy_AutonomyLoopResult as AutonomyLoopResult, autonomy_runAutonomyLoop as runAutonomyLoop };
+}
+
+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 };
+}
+
+/**
+ * Lightweight 5-field cron parsing and matching utilities.
+ *
+ * Supported field syntax:
+ * - "*" (any value)
+ * - step syntax (for example, star-slash-5 to mean every 5 units)
+ * - "a,b,c" (list)
+ * - "a-b" (range)
+ * - "a-b/n" (range with step)
+ * - "n" (single value)
+ */
+interface CronField {
+    all: boolean;
+    values: Set<number>;
+}
+interface CronSchedule {
+    expression: string;
+    minute: CronField;
+    hour: CronField;
+    dayOfMonth: CronField;
+    month: CronField;
+    dayOfWeek: CronField;
+}
+declare function parseCronExpression(expression: string): CronSchedule;
+declare function matchesCronSchedule(schedule: CronSchedule, date: Date): boolean;
+declare function nextCronMatch(scheduleOrExpression: CronSchedule | string, after: Date, maxSearchMinutes?: number): Date | null;
+
+type DoctorSeverity = 'warning' | 'error';
+interface DoctorIssue {
+    code: string;
+    severity: DoctorSeverity;
+    message: string;
+    path?: string;
+    details?: Record<string, unknown>;
+}
+interface DoctorChecks {
+    orphanWikiLinks: number;
+    staleClaims: number;
+    staleRuns: number;
+    missingRequiredFields: number;
+    brokenPrimitiveRegistryReferences: number;
+    emptyPrimitiveDirectories: number;
+    duplicateSlugs: number;
+}
+interface DoctorFixSummary {
+    enabled: boolean;
+    orphanLinksRemoved: number;
+    staleClaimsReleased: number;
+    staleRunsCancelled: number;
+    filesUpdated: string[];
+    errors: string[];
+}
+interface DoctorReport {
+    generatedAt: string;
+    workspacePath: string;
+    ok: boolean;
+    summary: {
+        errors: number;
+        warnings: number;
+    };
+    checks: DoctorChecks;
+    issues: DoctorIssue[];
+    fixes: DoctorFixSummary;
+}
+interface DoctorOptions {
+    fix?: boolean;
+    actor?: string;
+    staleAfterMs?: number;
+}
+declare function diagnoseVaultHealth(workspacePath: string, options?: DoctorOptions): DoctorReport;
+
+type ReplayEventTypeFilter = 'create' | 'update' | 'transition';
+interface ReplayOptions {
+    type?: ReplayEventTypeFilter;
+    actor?: string;
+    primitive?: string;
+    since?: string;
+    until?: string;
+    color?: boolean;
+}
+interface ReplayUpdateDiff {
+    changedFields: string[];
+    statusTransition?: {
+        from: string | null;
+        to: string | null;
+    };
+}
+interface ReplayEvent {
+    ts: string;
+    actor: string;
+    op: string;
+    target: string;
+    primitiveType?: string;
+    category: ReplayEventTypeFilter;
+    diff?: ReplayUpdateDiff;
+}
+interface ReplayReport {
+    generatedAt: string;
+    workspacePath: string;
+    filters: {
+        type?: ReplayEventTypeFilter;
+        actor?: string;
+        primitive?: string;
+        since?: string;
+        until?: string;
+    };
+    totalEvents: number;
+    events: ReplayEvent[];
+}
+declare function replayLedger(workspacePath: string, options?: ReplayOptions): ReplayReport;
+declare function renderReplayText(report: ReplayReport, options?: {
+    color?: boolean;
+}): string[];
+
+interface VizOptions {
+    focus?: string;
+    depth?: number;
+    top?: number;
+    color?: boolean;
+}
+interface VizReport {
+    generatedAt: string;
+    workspacePath: string;
+    nodeCount: number;
+    edgeCount: number;
+    hubs: Array<{
+        path: string;
+        degree: number;
+    }>;
+    focus?: string;
+    rendered: string;
+}
+declare function visualizeVaultGraph(workspacePath: string, options?: VizOptions): VizReport;
+
+interface VaultStats {
+    generatedAt: string;
+    workspacePath: string;
+    primitives: {
+        total: number;
+        byType: Record<string, number>;
+    };
+    links: {
+        total: number;
+        wikiLinkDensity: number;
+        graphDensityRatio: number;
+        orphanCount: number;
+        orphanNodeCount: number;
+        mostConnectedNodes: Array<{
+            path: string;
+            degree: number;
+        }>;
+    };
+    frontmatter: {
+        averageCompleteness: number;
+        byType: Record<string, number>;
+    };
+    ledger: {
+        totalEvents: number;
+        eventRatePerDay: {
+            average: number;
+            byDay: Array<{
+                day: string;
+                count: number;
+            }>;
+        };
+    };
+    threads: {
+        completedCount: number;
+        averageOpenToDoneHours: number;
+    };
+}
+declare function computeVaultStats(workspacePath: string): VaultStats;
+
+interface ChangelogOptions {
+    since: string;
+    until?: string;
+}
+interface ChangelogItem {
+    ts: string;
+    actor: string;
+    op: string;
+    target: string;
+    summary?: string;
+}
+interface ChangelogTypeGroup {
+    primitiveType: string;
+    items: ChangelogItem[];
+}
+interface ChangelogDayGroup {
+    day: string;
+    created: ChangelogTypeGroup[];
+    updated: ChangelogTypeGroup[];
+    completed: ChangelogTypeGroup[];
+}
+interface ChangelogReport {
+    generatedAt: string;
+    workspacePath: string;
+    since: string;
+    until?: string;
+    totalEvents: number;
+    days: ChangelogDayGroup[];
+}
+declare function generateLedgerChangelog(workspacePath: string, options: ChangelogOptions): ChangelogReport;
+declare function renderChangelogText(report: ChangelogReport): string[];
+
+declare function renderDoctorReport(report: DoctorReport): string[];
+declare function renderStatsReport(stats: VaultStats): string[];
+
+type index_ChangelogDayGroup = ChangelogDayGroup;
+type index_ChangelogItem = ChangelogItem;
+type index_ChangelogOptions = ChangelogOptions;
+type index_ChangelogReport = ChangelogReport;
+type index_ChangelogTypeGroup = ChangelogTypeGroup;
+type index_DoctorChecks = DoctorChecks;
+type index_DoctorFixSummary = DoctorFixSummary;
+type index_DoctorIssue = DoctorIssue;
+type index_DoctorOptions = DoctorOptions;
+type index_DoctorReport = DoctorReport;
+type index_DoctorSeverity = DoctorSeverity;
+type index_ReplayEvent = ReplayEvent;
+type index_ReplayEventTypeFilter = ReplayEventTypeFilter;
+type index_ReplayOptions = ReplayOptions;
+type index_ReplayReport = ReplayReport;
+type index_ReplayUpdateDiff = ReplayUpdateDiff;
+type index_VaultStats = VaultStats;
+type index_VizOptions = VizOptions;
+type index_VizReport = VizReport;
+declare const index_computeVaultStats: typeof computeVaultStats;
+declare const index_diagnoseVaultHealth: typeof diagnoseVaultHealth;
+declare const index_generateLedgerChangelog: typeof generateLedgerChangelog;
+declare const index_renderChangelogText: typeof renderChangelogText;
+declare const index_renderDoctorReport: typeof renderDoctorReport;
+declare const index_renderReplayText: typeof renderReplayText;
+declare const index_renderStatsReport: typeof renderStatsReport;
+declare const index_replayLedger: typeof replayLedger;
+declare const index_visualizeVaultGraph: typeof visualizeVaultGraph;
+declare namespace index {
+  export { type index_ChangelogDayGroup as ChangelogDayGroup, type index_ChangelogItem as ChangelogItem, type index_ChangelogOptions as ChangelogOptions, type index_ChangelogReport as ChangelogReport, type index_ChangelogTypeGroup as ChangelogTypeGroup, type index_DoctorChecks as DoctorChecks, type index_DoctorFixSummary as DoctorFixSummary, type index_DoctorIssue as DoctorIssue, type index_DoctorOptions as DoctorOptions, type index_DoctorReport as DoctorReport, type index_DoctorSeverity as DoctorSeverity, type index_ReplayEvent as ReplayEvent, type index_ReplayEventTypeFilter as ReplayEventTypeFilter, type index_ReplayOptions as ReplayOptions, type index_ReplayReport as ReplayReport, type index_ReplayUpdateDiff as ReplayUpdateDiff, type index_VaultStats as VaultStats, type index_VizOptions as VizOptions, type index_VizReport as VizReport, index_computeVaultStats as computeVaultStats, index_diagnoseVaultHealth as diagnoseVaultHealth, index_generateLedgerChangelog as generateLedgerChangelog, index_renderChangelogText as renderChangelogText, index_renderDoctorReport as renderDoctorReport, index_renderReplayText as renderReplayText, index_renderStatsReport as renderStatsReport, index_replayLedger as replayLedger, index_visualizeVaultGraph as visualizeVaultGraph };
+}
+
+interface AutonomyDaemonStartInput {
+    cliEntrypointPath: string;
+    actor: string;
+    adapter?: string;
+    agents?: string[];
+    pollMs?: number;
+    maxCycles?: number;
+    maxIdleCycles?: number;
+    maxSteps?: number;
+    stepDelayMs?: number;
+    space?: string;
+    staleClaimMinutes?: number;
+    executeTriggers?: boolean;
+    executeReadyThreads?: boolean;
+    logPath?: string;
+    heartbeatPath?: string;
+}
+interface AutonomyDaemonStopInput {
+    signal?: NodeJS.Signals;
+    timeoutMs?: number;
+}
+interface AutonomyDaemonHeartbeat {
+    ts: string;
+    cycle?: number;
+    readyThreads?: number;
+    triggerActions?: number;
+    runStatus?: string;
+    driftOk?: boolean;
+    driftIssues?: number;
+    finalReadyThreads?: number;
+    finalDriftOk?: boolean;
+}
+interface AutonomyDaemonStatus {
+    running: boolean;
+    pid?: number;
+    pidPath: string;
+    logPath: string;
+    heartbeatPath: string;
+    heartbeat?: AutonomyDaemonHeartbeat;
+}
+interface AutonomyDaemonStopResult {
+    stopped: boolean;
+    previouslyRunning: boolean;
+    pid?: number;
+    status: AutonomyDaemonStatus;
+}
+declare function startAutonomyDaemon(workspacePath: string, input: AutonomyDaemonStartInput): AutonomyDaemonStatus;
+declare function stopAutonomyDaemon(workspacePath: string, input?: AutonomyDaemonStopInput): Promise<AutonomyDaemonStopResult>;
+declare function readAutonomyDaemonStatus(workspacePath: string, options?: {
+    cleanupStalePidFile?: boolean;
+}): AutonomyDaemonStatus;
+
+type autonomyDaemon_AutonomyDaemonHeartbeat = AutonomyDaemonHeartbeat;
+type autonomyDaemon_AutonomyDaemonStartInput = AutonomyDaemonStartInput;
+type autonomyDaemon_AutonomyDaemonStatus = AutonomyDaemonStatus;
+type autonomyDaemon_AutonomyDaemonStopInput = AutonomyDaemonStopInput;
+type autonomyDaemon_AutonomyDaemonStopResult = AutonomyDaemonStopResult;
+declare const autonomyDaemon_readAutonomyDaemonStatus: typeof readAutonomyDaemonStatus;
+declare const autonomyDaemon_startAutonomyDaemon: typeof startAutonomyDaemon;
+declare const autonomyDaemon_stopAutonomyDaemon: typeof stopAutonomyDaemon;
+declare namespace autonomyDaemon {
+  export { type autonomyDaemon_AutonomyDaemonHeartbeat as AutonomyDaemonHeartbeat, type autonomyDaemon_AutonomyDaemonStartInput as AutonomyDaemonStartInput, type autonomyDaemon_AutonomyDaemonStatus as AutonomyDaemonStatus, type autonomyDaemon_AutonomyDaemonStopInput as AutonomyDaemonStopInput, type autonomyDaemon_AutonomyDaemonStopResult as AutonomyDaemonStopResult, autonomyDaemon_readAutonomyDaemonStatus as readAutonomyDaemonStatus, autonomyDaemon_startAutonomyDaemon as startAutonomyDaemon, autonomyDaemon_stopAutonomyDaemon as stopAutonomyDaemon };
+}
+
+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 CronField, type CronSchedule, 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, agent, autonomy, autonomyDaemon, bases, board, claimLease, clawdapus, commandCenter, index as diagnostics, dispatch, fetchSkillMarkdownFromUrl, gate, graph, installSkillIntegration, integration, ledger, matchesCronSchedule, nextCronMatch, onboard, orientation, parseCronExpression, policy, query, registry, searchQmdAdapter, skill, store, thread, threadAudit, trigger, triggerEngine, workspace };