clawvault 3.1.0 → 3.2.0

package/dist/{inject-Bzi5E-By.d.ts → 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

@@ -0,0 +1,115 @@
+/**
+ * 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";
+    readonly YELLOW: "3";
+    readonly GREEN: "4";
+    readonly CYAN: "5";
+    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: 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;
+/**
+ * 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 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, 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

@@ -0,0 +1,35 @@
+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.d.ts

@@ -0,0 +1,225 @@
+import { ChildProcess } from 'child_process';
+import * as http from 'http';
+
+/**
+ * Tailscale Integration for ClawVault
+ *
+ * Provides native Tailscale networking capabilities for vault synchronization
+ * across devices on a Tailscale network (tailnet).
+ *
+ * Features:
+ * - Tailscale status detection and peer discovery
+ * - MagicDNS hostname resolution
+ * - Secure peer-to-peer vault sync
+ * - Tailscale Funnel/Serve integration for vault sharing
+ */
+
+interface TailscaleStatus {
+    /** Whether Tailscale is installed */
+    installed: boolean;
+    /** Whether Tailscale daemon is running */
+    running: boolean;
+    /** Whether connected to tailnet */
+    connected: boolean;
+    /** Current device's Tailscale IP */
+    selfIP?: string;
+    /** Current device's MagicDNS hostname */
+    selfHostname?: string;
+    /** Current device's full domain name */
+    selfDNSName?: string;
+    /** Tailnet name */
+    tailnetName?: string;
+    /** Backend state (Running, Stopped, etc.) */
+    backendState?: string;
+    /** List of peers on the tailnet */
+    peers: TailscalePeer[];
+    /** Error message if any */
+    error?: string;
+}
+interface TailscalePeer {
+    /** Peer's hostname */
+    hostname: string;
+    /** Peer's MagicDNS name */
+    dnsName: string;
+    /** Peer's Tailscale IP addresses */
+    tailscaleIPs: string[];
+    /** Whether peer is currently online */
+    online: boolean;
+    /** Operating system */
+    os?: string;
+    /** Whether this peer is the exit node */
+    exitNode?: boolean;
+    /** Whether this peer is a tagged device */
+    tags?: string[];
+    /** Last seen timestamp */
+    lastSeen?: string;
+    /** Whether peer is running ClawVault serve */
+    clawvaultServing?: boolean;
+    /** ClawVault serve port if detected */
+    clawvaultPort?: number;
+}
+interface TailscaleServeConfig {
+    /** Port to serve on (default: 8384) */
+    port?: number;
+    /** Whether to use HTTPS (via Tailscale) */
+    https?: boolean;
+    /** Whether to expose via Tailscale Funnel (public internet) */
+    funnel?: boolean;
+    /** Path prefix for the serve endpoint */
+    pathPrefix?: string;
+    /** Optional WebDAV Basic Auth credentials */
+    webdavAuth?: {
+        username: string;
+        password: string;
+    };
+}
+interface TailscaleSyncOptions {
+    /** Target peer hostname or IP */
+    peer: string;
+    /** Port on the peer (default: 8384) */
+    port?: number;
+    /** Direction: push, pull, or bidirectional */
+    direction?: 'push' | 'pull' | 'bidirectional';
+    /** Dry run - don't actually sync */
+    dryRun?: boolean;
+    /** Delete files on target that don't exist on source */
+    deleteOrphans?: boolean;
+    /** Categories to sync (default: all) */
+    categories?: string[];
+    /** Use HTTPS for connection */
+    https?: boolean;
+}
+interface TailscaleSyncResult {
+    /** Files pushed to peer */
+    pushed: string[];
+    /** Files pulled from peer */
+    pulled: string[];
+    /** Files deleted */
+    deleted: string[];
+    /** Files unchanged */
+    unchanged: string[];
+    /** Errors encountered */
+    errors: string[];
+    /** Sync statistics */
+    stats: {
+        bytesTransferred: number;
+        filesProcessed: number;
+        duration: number;
+    };
+}
+interface VaultManifest {
+    /** Vault name */
+    name: string;
+    /** Vault version */
+    version: string;
+    /** Last updated timestamp */
+    lastUpdated: string;
+    /** File manifest with checksums */
+    files: VaultFileEntry[];
+}
+interface VaultFileEntry {
+    /** Relative path */
+    path: string;
+    /** File size in bytes */
+    size: number;
+    /** Last modified timestamp */
+    modified: string;
+    /** SHA-256 checksum */
+    checksum: string;
+    /** Category */
+    category: string;
+}
+declare const DEFAULT_SERVE_PORT = 8384;
+declare const CLAWVAULT_SERVE_PATH = "/.clawvault";
+declare const MANIFEST_ENDPOINT = "/.clawvault/manifest";
+declare const SYNC_ENDPOINT = "/.clawvault/sync";
+declare const FILE_ENDPOINT = "/.clawvault/files";
+/**
+ * Check if Tailscale CLI is installed
+ */
+declare function hasTailscale(): boolean;
+/**
+ * Get Tailscale version
+ */
+declare function getTailscaleVersion(): string | null;
+/**
+ * Get comprehensive Tailscale status
+ */
+declare function getTailscaleStatus(): TailscaleStatus;
+/**
+ * Find a peer by hostname (partial match supported)
+ */
+declare function findPeer(hostname: string): TailscalePeer | null;
+/**
+ * Get online peers only
+ */
+declare function getOnlinePeers(): TailscalePeer[];
+/**
+ * Resolve a peer hostname to its Tailscale IP
+ */
+declare function resolvePeerIP(hostname: string): string | null;
+/**
+ * Generate vault manifest for synchronization
+ */
+declare function generateVaultManifest(vaultPath: string): VaultManifest;
+/**
+ * Compare two manifests and return differences
+ */
+declare function compareManifests(local: VaultManifest, remote: VaultManifest): {
+    toPush: VaultFileEntry[];
+    toPull: VaultFileEntry[];
+    conflicts: Array<{
+        path: string;
+        local: VaultFileEntry;
+        remote: VaultFileEntry;
+    }>;
+    unchanged: string[];
+};
+interface ServeInstance {
+    server: http.Server;
+    port: number;
+    stop: () => Promise<void>;
+}
+/**
+ * Start serving a vault over HTTP for Tailscale sync
+ * Includes WebDAV support at /webdav/ for Obsidian mobile sync
+ */
+declare function serveVault(vaultPath: string, options?: TailscaleServeConfig): ServeInstance;
+/**
+ * Fetch remote vault manifest
+ */
+declare function fetchRemoteManifest(host: string, port?: number, useHttps?: boolean): Promise<VaultManifest>;
+/**
+ * Fetch a file from remote vault
+ */
+declare function fetchRemoteFile(host: string, filePath: string, port?: number, useHttps?: boolean): Promise<string>;
+/**
+ * Push a file to remote vault
+ */
+declare function pushFileToRemote(host: string, filePath: string, content: string, port?: number, useHttps?: boolean): Promise<void>;
+/**
+ * Sync vault with a remote peer
+ */
+declare function syncWithPeer(vaultPath: string, options: TailscaleSyncOptions): Promise<TailscaleSyncResult>;
+/**
+ * Configure Tailscale serve for the vault
+ * This uses `tailscale serve` to expose the vault server via Tailscale's HTTPS
+ */
+declare function configureTailscaleServe(localPort: number, options?: {
+    funnel?: boolean;
+    background?: boolean;
+}): ChildProcess | null;
+/**
+ * Stop Tailscale serve
+ */
+declare function stopTailscaleServe(): boolean;
+/**
+ * Check if a peer is serving ClawVault
+ */
+declare function checkPeerClawVault(host: string, port?: number): Promise<boolean>;
+/**
+ * Discover ClawVault peers on the tailnet
+ */
+declare function discoverClawVaultPeers(port?: number): Promise<TailscalePeer[]>;
+
+export { CLAWVAULT_SERVE_PATH, DEFAULT_SERVE_PORT, FILE_ENDPOINT, MANIFEST_ENDPOINT, SYNC_ENDPOINT, type ServeInstance, type TailscalePeer, type TailscaleServeConfig, type TailscaleStatus, type TailscaleSyncOptions, type TailscaleSyncResult, type VaultFileEntry, type VaultManifest, checkPeerClawVault, compareManifests, configureTailscaleServe, discoverClawVaultPeers, fetchRemoteFile, fetchRemoteManifest, findPeer, generateVaultManifest, getOnlinePeers, getTailscaleStatus, getTailscaleVersion, hasTailscale, pushFileToRemote, resolvePeerIP, serveVault, stopTailscaleServe, syncWithPeer };

package/dist/lib/tailscale.js

@@ -0,0 +1,50 @@
+import {
+  CLAWVAULT_SERVE_PATH,
+  DEFAULT_SERVE_PORT,
+  FILE_ENDPOINT,
+  MANIFEST_ENDPOINT,
+  SYNC_ENDPOINT,
+  checkPeerClawVault,
+  compareManifests,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  fetchRemoteFile,
+  fetchRemoteManifest,
+  findPeer,
+  generateVaultManifest,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  hasTailscale,
+  pushFileToRemote,
+  resolvePeerIP,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+} from "../chunk-TIGW564L.js";
+import "../chunk-IVRIKYFE.js";
+import "../chunk-2ZDO52B4.js";
+export {
+  CLAWVAULT_SERVE_PATH,
+  DEFAULT_SERVE_PORT,
+  FILE_ENDPOINT,
+  MANIFEST_ENDPOINT,
+  SYNC_ENDPOINT,
+  checkPeerClawVault,
+  compareManifests,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  fetchRemoteFile,
+  fetchRemoteManifest,
+  findPeer,
+  generateVaultManifest,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  hasTailscale,
+  pushFileToRemote,
+  resolvePeerIP,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+};

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