clawvault 3.0.0 → 3.2.0

package/dist/{inject-Bzi5E-By.d.cts → inject-DYUrDqQO.d.ts}

@@ -57,7 +57,7 @@ declare function getMemoryGraph(vaultPath: string, options?: {
     refresh?: boolean;
 }): Promise<MemoryGraph>;
 
-type LlmProvider = 'anthropic' | 'openai' | 'gemini';
+type LlmProvider = 'anthropic' | 'openai' | 'gemini' | 'xai' | 'openclaw';
 interface LlmCompletionOptions {
     prompt: string;
     provider?: LlmProvider | null;
@@ -67,7 +67,7 @@ interface LlmCompletionOptions {
     maxTokens?: number;
     fetchImpl?: typeof fetch;
 }
-declare function resolveLlmProvider(fetchImpl?: typeof fetch): Promise<LlmProvider | null>;
+declare function resolveLlmProvider(): LlmProvider | null;
 declare function requestLlmCompletion(options: LlmCompletionOptions): Promise<string>;
 
 declare const INJECTABLE_CATEGORIES: readonly ["rules", "decisions", "preferences"];
@@ -134,4 +134,4 @@ declare function buildInjectionResult(message: string, options: InjectCommandOpt
 declare function injectCommand(message: string, options: InjectCommandOptions): Promise<void>;
 declare function registerInjectCommand(program: Command): void;
 
-export { runPromptInjection as A, type InjectCommandOptions as I, type LlmCompletionOptions as L, MEMORY_GRAPH_SCHEMA_VERSION as M, type InjectFormat as a, type InjectMatch as b, type InjectMatchReason as c, type InjectMatchSource as d, type InjectResult as e, type InjectRuntimeOptions as f, type InjectSourceCategory as g, type InjectableItem as h, type LlmProvider as i, type MemoryGraph as j, type MemoryGraphEdge as k, type MemoryGraphEdgeType as l, type MemoryGraphIndex as m, type MemoryGraphNode as n, type MemoryGraphNodeType as o, type MemoryGraphStats as p, buildInjectionResult as q, buildOrUpdateMemoryGraphIndex as r, deterministicInjectMatches as s, getMemoryGraph as t, indexInjectableItems as u, injectCommand as v, loadMemoryGraphIndex as w, registerInjectCommand as x, requestLlmCompletion as y, resolveLlmProvider as z };
+export { runPromptInjection as A, type InjectCommandOptions as I, type LlmProvider as L, MEMORY_GRAPH_SCHEMA_VERSION as M, type InjectFormat as a, type InjectMatch as b, type InjectMatchReason as c, type InjectMatchSource as d, type InjectResult as e, type InjectRuntimeOptions as f, type InjectSourceCategory as g, type InjectableItem as h, type LlmCompletionOptions as i, type MemoryGraph as j, type MemoryGraphEdge as k, type MemoryGraphEdgeType as l, type MemoryGraphIndex as m, type MemoryGraphNode as n, type MemoryGraphNodeType as o, type MemoryGraphStats as p, buildInjectionResult as q, buildOrUpdateMemoryGraphIndex as r, deterministicInjectMatches as s, getMemoryGraph as t, indexInjectableItems as u, injectCommand as v, loadMemoryGraphIndex as w, registerInjectCommand as x, requestLlmCompletion as y, resolveLlmProvider as z };

package/dist/ledger-B7g7jhqG.d.ts

@@ -0,0 +1,44 @@
+import { LedgerEntry, LedgerOp } from './workgraph/types.js';
+
+/**
+ * Append-only event ledger.
+ *
+ * Every mutation to the workgraph is logged here. This is the source of truth
+ * for coordination: who claimed what, when, and what's available.
+ *
+ * Format: one JSON object per line (.jsonl) in `.clawvault/ledger.jsonl`.
+ * Agents read the ledger to know the state of the world.
+ */
+
+declare function ledgerPath(vaultPath: string): string;
+declare function append(vaultPath: string, actor: string, op: LedgerOp, target: string, type?: string, data?: Record<string, unknown>): LedgerEntry;
+declare function readAll(vaultPath: string): LedgerEntry[];
+declare function readSince(vaultPath: string, since: string): LedgerEntry[];
+/** Get the current owner of a target (last claim without a subsequent release/done). */
+declare function currentOwner(vaultPath: string, target: string): string | null;
+/** Check if a target is currently claimed by any agent. */
+declare function isClaimed(vaultPath: string, target: string): boolean;
+/** Get all entries for a specific target. */
+declare function historyOf(vaultPath: string, target: string): LedgerEntry[];
+/** Get all entries by a specific actor. */
+declare function activityOf(vaultPath: string, actor: string): LedgerEntry[];
+/** Get all currently claimed targets and their owners. */
+declare function allClaims(vaultPath: string): Map<string, string>;
+/** Get recent ledger entries (last N). */
+declare function recent(vaultPath: string, count?: number): LedgerEntry[];
+
+declare const ledger_activityOf: typeof activityOf;
+declare const ledger_allClaims: typeof allClaims;
+declare const ledger_append: typeof append;
+declare const ledger_currentOwner: typeof currentOwner;
+declare const ledger_historyOf: typeof historyOf;
+declare const ledger_isClaimed: typeof isClaimed;
+declare const ledger_ledgerPath: typeof ledgerPath;
+declare const ledger_readAll: typeof readAll;
+declare const ledger_readSince: typeof readSince;
+declare const ledger_recent: typeof recent;
+declare namespace ledger {
+  export { ledger_activityOf as activityOf, ledger_allClaims as allClaims, ledger_append as append, ledger_currentOwner as currentOwner, ledger_historyOf as historyOf, ledger_isClaimed as isClaimed, ledger_ledgerPath as ledgerPath, ledger_readAll as readAll, ledger_readSince as readSince, ledger_recent as recent };
+}
+
+export { activityOf as a, allClaims as b, append as c, currentOwner as d, ledgerPath as e, readSince as f, recent as g, historyOf as h, isClaimed as i, ledger as l, readAll as r };

package/dist/lib/auto-linker.js

@@ -2,9 +2,9 @@ import {
   autoLink,
   dryRunLink,
   findUnlinkedMentions
-} from "../chunk-42MXU7A6.js";
+} from "../chunk-P62WHA27.js";
 import "../chunk-J7ZWCI2C.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   autoLink,
   dryRunLink,

package/dist/lib/canvas-layout.d.ts

@@ -1,3 +1,32 @@
+/**
+ * Canvas layout utilities for ClawVault
+ * Handles JSON Canvas generation with proper positioning and grouping
+ */
+interface CanvasNode {
+    id: string;
+    type: 'text' | 'file' | 'group';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text?: string;
+    file?: string;
+    label?: string;
+    color?: string;
+}
+interface CanvasEdge {
+    id: string;
+    fromNode: string;
+    fromSide: 'top' | 'right' | 'bottom' | 'left';
+    toNode: string;
+    toSide: 'top' | 'right' | 'bottom' | 'left';
+    label?: string;
+    color?: string;
+}
+interface Canvas {
+    nodes: CanvasNode[];
+    edges: CanvasEdge[];
+}
 declare const CANVAS_COLORS: {
     readonly RED: "1";
     readonly ORANGE: "2";
@@ -7,25 +36,80 @@ declare const CANVAS_COLORS: {
     readonly PURPLE: "6";
 };
 declare const LAYOUT: {
+    readonly LEFT_COLUMN_X: 0;
+    readonly LEFT_COLUMN_WIDTH: 500;
+    readonly RIGHT_COLUMN_X: 550;
+    readonly RIGHT_COLUMN_WIDTH: 450;
     readonly GROUP_PADDING: 20;
-    readonly NODE_SPACING: 10;
-    readonly HEADER_HEIGHT: 40;
+    readonly NODE_SPACING: 15;
+    readonly GROUP_SPACING: 50;
+    readonly DEFAULT_NODE_WIDTH: 280;
+    readonly DEFAULT_NODE_HEIGHT: 80;
+    readonly FILE_NODE_HEIGHT: 60;
+    readonly SMALL_NODE_HEIGHT: 50;
+    readonly GROUP_HEADER_HEIGHT: 40;
 };
+/**
+ * Generate a 16-character lowercase hex ID
+ */
 declare function generateId(): string;
-declare function createTextNode(x: number, y: number, width: number, height: number, text: string, color?: string): any;
-declare function createFileNode(x: number, y: number, width: number, height: number, file: string, color?: string): any;
-declare function createGroupNode(x: number, y: number, width: number, height: number, label: string, color?: string): any;
-declare function createEdge(fromNode: string, fromSide: string, toNode: string, toSide: string, label?: string, color?: string): any;
-declare function stackNodesVertically(nodes: any[], startX: number, startY: number, spacing: number): {
-    nodes: any[];
+/**
+ * Create a text node
+ */
+declare function createTextNode(x: number, y: number, width: number, height: number, text: string, color?: string): CanvasNode;
+/**
+ * Create a file node
+ */
+declare function createFileNode(x: number, y: number, width: number, height: number, file: string, color?: string): CanvasNode;
+/**
+ * Create a group node
+ */
+declare function createGroupNode(x: number, y: number, width: number, height: number, label: string, color?: string): CanvasNode;
+/**
+ * Create an edge between nodes
+ */
+declare function createEdge(fromNode: string, fromSide: 'top' | 'right' | 'bottom' | 'left', toNode: string, toSide: 'top' | 'right' | 'bottom' | 'left', label?: string, color?: string): CanvasEdge;
+/**
+ * Layout helper for vertical stacking of nodes within a group
+ */
+interface StackedLayout {
+    nodes: CanvasNode[];
     totalHeight: number;
-};
-declare function createGroupWithNodes(x: number, y: number, width: number, label: string, childNodes: any[], color?: string): {
-    group: any;
-    nodes: any[];
-};
-declare function getPriorityColor(priority: string | undefined): string | undefined;
-declare function truncateText(text: string, maxLength: number): string;
+}
+declare function stackNodesVertically(nodes: CanvasNode[], startX: number, startY: number, spacing?: number): StackedLayout;
+/**
+ * Create a group with contained nodes
+ * Returns the group node and positioned child nodes
+ */
+interface GroupWithNodes {
+    group: CanvasNode;
+    nodes: CanvasNode[];
+}
+declare function createGroupWithNodes(groupX: number, groupY: number, groupWidth: number, label: string, childNodes: CanvasNode[], color?: string): GroupWithNodes;
+/**
+ * Get priority color for a task
+ */
+declare function getPriorityColor(priority?: string): string | undefined;
+/**
+ * Truncate text to fit within a certain width (approximate)
+ */
+declare function truncateText(text: string, maxChars: number): string;
+/**
+ * Format markdown text for canvas node
+ * Replaces newlines with \n for JSON Canvas spec
+ */
 declare function formatCanvasText(lines: string[]): string;
+/**
+ * Calculate the total height needed for a column of groups
+ */
+declare function calculateColumnHeight(groups: GroupWithNodes[]): number;
+/**
+ * Position groups vertically in a column
+ */
+declare function positionGroupsVertically(groups: GroupWithNodes[], startY?: number): GroupWithNodes[];
+/**
+ * Flatten groups and nodes into a single array
+ */
+declare function flattenGroups(groups: GroupWithNodes[]): CanvasNode[];
 
-export { CANVAS_COLORS, LAYOUT, createEdge, createFileNode, createGroupNode, createGroupWithNodes, createTextNode, formatCanvasText, generateId, getPriorityColor, stackNodesVertically, truncateText };
+export { CANVAS_COLORS, type Canvas, type CanvasEdge, type CanvasNode, type GroupWithNodes, LAYOUT, type StackedLayout, calculateColumnHeight, createEdge, createFileNode, createGroupNode, createGroupWithNodes, createTextNode, flattenGroups, formatCanvasText, generateId, getPriorityColor, positionGroupsVertically, stackNodesVertically, truncateText };

package/dist/lib/canvas-layout.js

@@ -1,92 +1,35 @@
-import "../chunk-3RG5ZIWI.js";
-
-// src/lib/canvas-layout.ts
-import * as crypto from "crypto";
-var CANVAS_COLORS = {
-  RED: "1",
-  ORANGE: "2",
-  YELLOW: "3",
-  GREEN: "4",
-  CYAN: "5",
-  PURPLE: "6"
-};
-var LAYOUT = {
-  GROUP_PADDING: 20,
-  NODE_SPACING: 10,
-  HEADER_HEIGHT: 40
-};
-function generateId() {
-  return crypto.randomBytes(8).toString("hex");
-}
-function createTextNode(x, y, width, height, text, color) {
-  const node = { id: generateId(), type: "text", x, y, width, height, text };
-  if (color !== void 0) node.color = color;
-  return node;
-}
-function createFileNode(x, y, width, height, file, color) {
-  const node = { id: generateId(), type: "file", x, y, width, height, file };
-  if (color !== void 0) node.color = color;
-  return node;
-}
-function createGroupNode(x, y, width, height, label, color) {
-  const node = { id: generateId(), type: "group", x, y, width, height, label };
-  if (color !== void 0) node.color = color;
-  return node;
-}
-function createEdge(fromNode, fromSide, toNode, toSide, label, color) {
-  const edge = { id: generateId(), fromNode, fromSide, toNode, toSide };
-  if (label !== void 0) edge.label = label;
-  if (color !== void 0) edge.color = color;
-  return edge;
-}
-function stackNodesVertically(nodes, startX, startY, spacing) {
-  let currentY = startY;
-  const positioned = nodes.map((node) => {
-    const n = { ...node, x: startX, y: currentY };
-    currentY += node.height + spacing;
-    return n;
-  });
-  return { nodes: positioned, totalHeight: currentY - startY - spacing };
-}
-function createGroupWithNodes(x, y, width, label, childNodes, color) {
-  const padding = LAYOUT.GROUP_PADDING;
-  const headerHeight = LAYOUT.HEADER_HEIGHT;
-  const spacing = LAYOUT.NODE_SPACING;
-  const { nodes, totalHeight } = stackNodesVertically(childNodes, x + padding, y + headerHeight, spacing);
-  const groupHeight = headerHeight + totalHeight + padding;
-  const group = createGroupNode(x, y, width, Math.max(groupHeight, 100), label, color);
-  return { group, nodes };
-}
-function getPriorityColor(priority) {
-  switch (priority) {
-    case "critical":
-      return CANVAS_COLORS.RED;
-    case "high":
-      return CANVAS_COLORS.ORANGE;
-    case "medium":
-      return CANVAS_COLORS.YELLOW;
-    default:
-      return void 0;
-  }
-}
-function truncateText(text, maxLength) {
-  if (text.length <= maxLength) return text;
-  return text.slice(0, maxLength - 3) + "...";
-}
-function formatCanvasText(lines) {
-  return lines.join("\n");
-}
+import {
+  CANVAS_COLORS,
+  LAYOUT,
+  calculateColumnHeight,
+  createEdge,
+  createFileNode,
+  createGroupNode,
+  createGroupWithNodes,
+  createTextNode,
+  flattenGroups,
+  formatCanvasText,
+  generateId,
+  getPriorityColor,
+  positionGroupsVertically,
+  stackNodesVertically,
+  truncateText
+} from "../chunk-MDIH26GC.js";
+import "../chunk-2ZDO52B4.js";
 export {
   CANVAS_COLORS,
   LAYOUT,
+  calculateColumnHeight,
   createEdge,
   createFileNode,
   createGroupNode,
   createGroupWithNodes,
   createTextNode,
+  flattenGroups,
   formatCanvasText,
   generateId,
   getPriorityColor,
+  positionGroupsVertically,
   stackNodesVertically,
   truncateText
 };

package/dist/lib/config.d.ts

@@ -1,11 +1,35 @@
+interface AgentVaultsConfig {
+    [agentName: string]: string;
+}
+interface PluginConfig {
+    vaultPath?: string;
+    agentVaults?: AgentVaultsConfig;
+}
 /**
  * Get the vault path from CLAWVAULT_PATH env var or throw
  */
 declare function getVaultPath(): string;
 declare function findNearestVaultPath(startPath?: string): string | null;
-declare function resolveVaultPath(options?: {
+/**
+ * Resolve vault path for a specific agent from agentVaults config
+ */
+declare function resolveAgentVaultPath(agentVaults: AgentVaultsConfig | undefined, agentId: string | undefined): string | null;
+interface ResolveVaultPathOptions {
     explicitPath?: string;
     cwd?: string;
-}): string;
+    agentId?: string;
+    pluginConfig?: PluginConfig;
+}
+/**
+ * Resolve vault path with support for per-agent vault paths.
+ *
+ * Resolution order:
+ * 1. Explicit path (--vault flag)
+ * 2. Per-agent vault from agentVaults config (if agentId provided)
+ * 3. Plugin config vaultPath (fallback for all agents)
+ * 4. CLAWVAULT_PATH environment variable
+ * 5. Walk up from cwd to find nearest vault
+ */
+declare function resolveVaultPath(options?: ResolveVaultPathOptions): string;
 
-export { findNearestVaultPath, getVaultPath, resolveVaultPath };
+export { type AgentVaultsConfig, type PluginConfig, type ResolveVaultPathOptions, findNearestVaultPath, getVaultPath, resolveAgentVaultPath, resolveVaultPath };

package/dist/lib/config.js

@@ -1,11 +1,13 @@
 import {
   findNearestVaultPath,
   getVaultPath,
+  resolveAgentVaultPath,
   resolveVaultPath
-} from "../chunk-MXSSG3QU.js";
-import "../chunk-3RG5ZIWI.js";
+} from "../chunk-GNJL4YGR.js";
+import "../chunk-2ZDO52B4.js";
 export {
   findNearestVaultPath,
   getVaultPath,
+  resolveAgentVaultPath,
   resolveVaultPath
 };

package/dist/lib/entity-index.js

@@ -2,7 +2,7 @@ import {
   buildEntityIndex,
   getSortedAliases
 } from "../chunk-J7ZWCI2C.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   buildEntityIndex,
   getSortedAliases

package/dist/lib/project-utils.js

@@ -6,11 +6,11 @@ import {
   listProjects,
   readProject,
   updateProject
-} from "../chunk-62YTUT6J.js";
-import "../chunk-N2AXRYLC.js";
-import "../chunk-LYHGEHXG.js";
+} from "../chunk-4PY655YM.js";
+import "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   archiveProject,
   createProject,

package/dist/lib/session-repair.js

@@ -6,7 +6,7 @@ import {
   parseTranscript,
   repairSession
 } from "../chunk-L53L5FCL.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   analyzeSession,
   computeParentRelinks,

package/dist/lib/session-utils.js

@@ -11,7 +11,7 @@ import {
   listSessions,
   loadSessionsStore
 } from "../chunk-HRLWZGMA.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   backupSession,
   findMainSession,

package/dist/lib/tailscale.js

@@ -23,7 +23,7 @@ import {
   syncWithPeer
 } from "../chunk-TIGW564L.js";
 import "../chunk-IVRIKYFE.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   CLAWVAULT_SERVE_PATH,
   DEFAULT_SERVE_PORT,

package/dist/lib/task-utils.js

@@ -23,10 +23,10 @@ import {
   slugify,
   updateBacklogItem,
   updateTask
-} from "../chunk-N2AXRYLC.js";
-import "../chunk-LYHGEHXG.js";
+} from "../chunk-QWQ3TIKS.js";
+import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   completeTask,
   createBacklogItem,

package/dist/lib/template-engine.js

@@ -2,7 +2,7 @@ import {
   buildTemplateVariables,
   renderTemplate
 } from "../chunk-7766SIJP.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   buildTemplateVariables,
   renderTemplate

package/dist/lib/webdav.js

@@ -15,7 +15,7 @@ import {
   isPathSafe,
   resolveWebDAVPath
 } from "../chunk-IVRIKYFE.js";
-import "../chunk-3RG5ZIWI.js";
+import "../chunk-2ZDO52B4.js";
 export {
   WEBDAV_PREFIX,
   checkAuth,

package/dist/openclaw-plugin.d.ts

@@ -0,0 +1,8 @@
+declare const clawvaultPlugin: {
+    id: string;
+    name: string;
+    description: string;
+    register(): void;
+};
+
+export { clawvaultPlugin as default };

package/dist/openclaw-plugin.js

@@ -0,0 +1,14 @@
+import "./chunk-2ZDO52B4.js";
+
+// src/openclaw-plugin.ts
+var clawvaultPlugin = {
+  id: "clawvault",
+  name: "ClawVault",
+  description: "Structured memory system for AI agents with context death resilience",
+  register() {
+  }
+};
+var openclaw_plugin_default = clawvaultPlugin;
+export {
+  openclaw_plugin_default as default
+};

package/dist/registry-BR4326o0.d.ts

@@ -0,0 +1,30 @@
+import { FieldDefinition, PrimitiveTypeDefinition, Registry } from './workgraph/types.js';
+
+/**
+ * Dynamic primitive type registry.
+ *
+ * Agents can define new primitive types at runtime. The registry is stored
+ * as `.clawvault/registry.json` in the vault. Built-in types are seeded on
+ * first access and cannot be deleted (but CAN be extended with new fields).
+ */
+
+declare function registryPath(vaultPath: string): string;
+declare function loadRegistry(vaultPath: string): Registry;
+declare function saveRegistry(vaultPath: string, registry: Registry): void;
+declare function defineType(vaultPath: string, name: string, description: string, fields: Record<string, FieldDefinition>, actor: string, directory?: string): PrimitiveTypeDefinition;
+declare function getType(vaultPath: string, name: string): PrimitiveTypeDefinition | undefined;
+declare function listTypes(vaultPath: string): PrimitiveTypeDefinition[];
+declare function extendType(vaultPath: string, name: string, newFields: Record<string, FieldDefinition>, actor: string): PrimitiveTypeDefinition;
+
+declare const registry_defineType: typeof defineType;
+declare const registry_extendType: typeof extendType;
+declare const registry_getType: typeof getType;
+declare const registry_listTypes: typeof listTypes;
+declare const registry_loadRegistry: typeof loadRegistry;
+declare const registry_registryPath: typeof registryPath;
+declare const registry_saveRegistry: typeof saveRegistry;
+declare namespace registry {
+  export { registry_defineType as defineType, registry_extendType as extendType, registry_getType as getType, registry_listTypes as listTypes, registry_loadRegistry as loadRegistry, registry_registryPath as registryPath, registry_saveRegistry as saveRegistry };
+}
+
+export { loadRegistry as a, registryPath as b, defineType as d, extendType as e, getType as g, listTypes as l, registry as r, saveRegistry as s };

package/dist/store-CA-6sKCJ.d.ts

@@ -0,0 +1,34 @@
+import { PrimitiveInstance } from './workgraph/types.js';
+
+/**
+ * Workgraph store — CRUD for primitive instances.
+ *
+ * Primitives are markdown files with YAML frontmatter. The store reads/writes
+ * them and logs every mutation to the ledger. Schemas are soft: unknown fields
+ * are preserved, missing optional fields get defaults.
+ */
+
+declare function create(vaultPath: string, typeName: string, fields: Record<string, unknown>, body: string, actor: string): PrimitiveInstance;
+declare function read(vaultPath: string, relPath: string): PrimitiveInstance | null;
+declare function list(vaultPath: string, typeName: string): PrimitiveInstance[];
+declare function update(vaultPath: string, relPath: string, fieldUpdates: Record<string, unknown>, bodyUpdate: string | undefined, actor: string): PrimitiveInstance;
+declare function remove(vaultPath: string, relPath: string, actor: string): void;
+declare function findByField(vaultPath: string, typeName: string, field: string, value: unknown): PrimitiveInstance[];
+declare function openThreads(vaultPath: string): PrimitiveInstance[];
+declare function activeThreads(vaultPath: string): PrimitiveInstance[];
+declare function blockedThreads(vaultPath: string): PrimitiveInstance[];
+
+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_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_update as update };
+}
+
+export { activeThreads as a, blockedThreads as b, create as c, remove as d, findByField as f, list as l, openThreads as o, read as r, store as s, update as u };

package/dist/thread-B9LhXNU0.d.ts

@@ -0,0 +1,41 @@
+import { PrimitiveInstance } from './workgraph/types.js';
+
+/**
+ * Thread lifecycle operations.
+ *
+ * Threads are the core coordination primitive. This module handles the
+ * claim/release/block/done lifecycle with ledger-backed exclusivity.
+ */
+
+declare function createThread(vaultPath: string, title: string, goal: string, actor: string, opts?: {
+    priority?: string;
+    deps?: string[];
+    parent?: string;
+    context_refs?: string[];
+    tags?: string[];
+}): PrimitiveInstance;
+declare function claim(vaultPath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function release(vaultPath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function block(vaultPath: string, threadPath: string, actor: string, blockedBy: string, reason?: string): PrimitiveInstance;
+declare function unblock(vaultPath: string, threadPath: string, actor: string): PrimitiveInstance;
+declare function done(vaultPath: string, threadPath: string, actor: string, output?: string): PrimitiveInstance;
+declare function cancel(vaultPath: string, threadPath: string, actor: string, reason?: string): PrimitiveInstance;
+declare function decompose(vaultPath: string, parentPath: string, subthreads: Array<{
+    title: string;
+    goal: string;
+    deps?: string[];
+}>, actor: string): PrimitiveInstance[];
+
+declare const thread_block: typeof block;
+declare const thread_cancel: typeof cancel;
+declare const thread_claim: typeof claim;
+declare const thread_createThread: typeof createThread;
+declare const thread_decompose: typeof decompose;
+declare const thread_done: typeof done;
+declare const thread_release: typeof release;
+declare const thread_unblock: typeof unblock;
+declare namespace thread {
+  export { thread_block as block, thread_cancel as cancel, thread_claim as claim, thread_createThread as createThread, thread_decompose as decompose, thread_done as done, thread_release as release, thread_unblock as unblock };
+}
+
+export { claim as a, block as b, cancel as c, createThread as d, decompose as e, done as f, release as r, thread as t, unblock as u };