pi-vault-mind 0.14.2 → 0.16.3

package/dist/packages/obsidian/src/client.js

@@ -0,0 +1,331 @@
+/**
+ * HTTP + WebSocket client for the pi-vault-mind extension.
+ *
+ * REST calls use `fetch`. WebSocket events use the native `WebSocket` global
+ * with exponential backoff on disconnect (1, 2, 4, 8, 16, 30 s).
+ */
+export class VaultMindClient {
+    config;
+    ws = null;
+    reconnectTimer = null;
+    reconnectDelay = 1000;
+    intentionalClose = false;
+    eventHandlers = new Set();
+    stateHandlers = new Set();
+    _state = { connected: false };
+    constructor(config) {
+        this.config = config;
+    }
+    get baseUrl() {
+        return `http://${this.config.host}:${this.config.port}`;
+    }
+    get wsUrl() {
+        return `ws://${this.config.host}:${this.config.port}/agent/stream`;
+    }
+    get authHeaders() {
+        return {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.token}`,
+        };
+    }
+    setState(state) {
+        this._state = state;
+        for (const h of this.stateHandlers)
+            h(state);
+    }
+    get state() {
+        return this._state;
+    }
+    subscribeEvents(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    subscribeState(handler) {
+        this.stateHandlers.add(handler);
+        return () => this.stateHandlers.delete(handler);
+    }
+    emit(event) {
+        for (const h of this.eventHandlers) {
+            try {
+                h(event);
+            }
+            catch {
+                // never let a bad listener break others
+            }
+        }
+    }
+    connect() {
+        if (this.ws)
+            return;
+        try {
+            this.ws = new WebSocket(this.wsUrl, [`Authorization: Bearer ${this.config.token}`]);
+        }
+        catch (err) {
+            this.setState({ connected: false, error: String(err), reconnecting: true });
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.onopen = () => {
+            this.reconnectDelay = 1000;
+            this.setState({ connected: true, reconnecting: false });
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const parsed = JSON.parse(event.data);
+                this.emit(parsed);
+            }
+            catch {
+                // ignore malformed events
+            }
+        };
+        this.ws.onclose = (event) => {
+            this.ws = null;
+            if (this.intentionalClose) {
+                this.setState({ connected: false, error: undefined, reconnecting: false });
+                return;
+            }
+            const wasConnected = this._state.connected;
+            this.setState({ connected: false, error: `closed ${event.code}`, reconnecting: true });
+            if (wasConnected || event.code !== 4401) {
+                this.scheduleReconnect();
+            }
+        };
+        this.ws.onerror = () => {
+            this.setState({ connected: this.ws?.readyState === WebSocket.OPEN, error: "socket error" });
+        };
+    }
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.intentionalClose = true;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.setState({ connected: false, error: undefined, reconnecting: false });
+        this.intentionalClose = false;
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, this.reconnectDelay);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000);
+    }
+    async httpJson(method, path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers: this.authHeaders,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            let serverMessage = text;
+            try {
+                const parsed = JSON.parse(text);
+                if (typeof parsed.message === "string")
+                    serverMessage = parsed.message;
+            }
+            catch {
+                // keep raw text as the server message
+            }
+            // Never echo the request body or secret material in the thrown error.
+            throw new Error(`${res.status} ${serverMessage}`);
+        }
+        return text ? JSON.parse(text) : undefined;
+    }
+    async status() {
+        return (await this.httpJson("GET", "/vm/status"));
+    }
+    async setup(body) {
+        return (await this.httpJson("POST", "/vm/setup", body));
+    }
+    async probeEmbedding(body) {
+        return (await this.httpJson("POST", "/vm/embedding/probe", body));
+    }
+    async putEmbeddingSecrets(body) {
+        return (await this.httpJson("PUT", "/vm/embedding/secrets", body));
+    }
+    async startServer() {
+        return (await this.httpJson("POST", "/server/start"));
+    }
+    async toggleWatcher() {
+        return (await this.httpJson("POST", "/vm/watcher/toggle"));
+    }
+    async listQueue(status) {
+        const query = status ? `?status=${status}` : "";
+        return (await this.httpJson("GET", `/agent/queue${query}`));
+    }
+    async retryJob(id) {
+        return (await this.httpJson("POST", `/agent/jobs/${encodeURIComponent(id)}/retry`));
+    }
+    async cancelJob(id) {
+        return (await this.httpJson("POST", `/agent/jobs/${encodeURIComponent(id)}/cancel`));
+    }
+    /**
+     * Unified search with mode dispatch. Calls POST /vm/search with mode param.
+     * mode='hybrid' (default) = vector+FTS rank-merge, 'semantic' = vector-only,
+     * 'fts' = keyword, 'graph' = entity traversal, 'full' = all merged.
+     */
+    async searchWithMode(params) {
+        return (await this.httpJson("POST", "/vm/search", {
+            collection: params.collection ?? "main",
+            query: params.query,
+            mode: params.mode ?? "hybrid",
+            limit: params.limit ?? 5,
+            ...(params.entity ? { entity: params.entity } : {}),
+            ...(params.depth ? { depth: params.depth } : {}),
+            ...(params.sources ? { sources: params.sources } : {}),
+        }));
+    }
+    async gitStatus() {
+        return (await this.httpJson("GET", "/git/status"));
+    }
+    async gitBranches() {
+        return (await this.httpJson("GET", "/git/branches"));
+    }
+    async gitCheckout(branch) {
+        return (await this.httpJson("POST", "/git/checkout", { branch }));
+    }
+    async listSessions() {
+        return (await this.httpJson("GET", "/sessions"));
+    }
+    async getSession(id) {
+        return (await this.httpJson("GET", `/sessions/${encodeURIComponent(id)}`));
+    }
+    async renameSession(id, name) {
+        return (await this.httpJson("PATCH", `/sessions/${encodeURIComponent(id)}`, { name }));
+    }
+    async deleteSession(id) {
+        return (await this.httpJson("DELETE", `/sessions/${encodeURIComponent(id)}`));
+    }
+    async exportSession(id) {
+        return (await this.httpJson("POST", `/sessions/${encodeURIComponent(id)}/export`));
+    }
+    async archiveSession(id) {
+        return (await this.httpJson("POST", `/sessions/${encodeURIComponent(id)}/archive`));
+    }
+    /**
+     * List pending edits, optionally filtered by vault-relative file path.
+     */
+    async listEdits(filePath) {
+        const query = filePath ? `?path=${encodeURIComponent(filePath)}` : "";
+        const res = await this.httpJson("GET", `/vm/edits${query}`);
+        return res.edits;
+    }
+    /**
+     * Get a specific pending edit by ID.
+     */
+    async getEdit(id) {
+        const res = await this.httpJson("GET", `/vm/edits/${encodeURIComponent(id)}`);
+        return res.edit;
+    }
+    /**
+     * Apply a pending edit to the target file.
+     */
+    async applyEdit(id) {
+        return (await this.httpJson("POST", `/vm/edits/${encodeURIComponent(id)}/apply`));
+    }
+    /**
+     * Reject a pending edit.
+     */
+    async rejectEdit(id) {
+        return (await this.httpJson("POST", `/vm/edits/${encodeURIComponent(id)}/reject`));
+    }
+    async listPending() {
+        const res = await this.httpJson("GET", "/vm/pending");
+        return res.pending;
+    }
+    async approveEntry(id, collection, action) {
+        await this.httpJson("POST", "/vm/approve", { id, collection, action });
+    }
+    async pushContext(filePath, selection, cursor) {
+        return (await this.httpJson("POST", "/vault-mind/context", {
+            filePath,
+            selection,
+            cursor,
+        }));
+    }
+    async scan(file, vault) {
+        try {
+            return (await this.httpJson("POST", "/vault-mind/scan", { file, vault }));
+        }
+        catch (err) {
+            return { error: String(err) };
+        }
+    }
+    async dispatch(role, instruction, file, vault) {
+        try {
+            return (await this.httpJson("POST", "/vault-mind/dispatch", {
+                role,
+                instruction,
+                file,
+                vault,
+            }));
+        }
+        catch (err) {
+            return { error: String(err) };
+        }
+    }
+    async vmStats() {
+        return (await this.httpJson("GET", "/vm/stats"));
+    }
+    /** GET /vault-mind/config — full config + hasToken + remote block */
+    async getConfig() {
+        return (await this.httpJson("GET", "/vault-mind/config"));
+    }
+    /** GET /vault-mind/paths — vault/agent/env paths */
+    async paths() {
+        return (await this.httpJson("GET", "/vault-mind/paths"));
+    }
+    /** GET /vault-mind/models — provider/model catalog parsed from pi's models.json */
+    async getModels() {
+        return (await this.httpJson("GET", "/vault-mind/models"));
+    }
+    /** POST /vm/token — write PVM_API_TOKEN to vault-mind.env */
+    async writeToken(token) {
+        return (await this.httpJson("POST", "/vm/token", { token }));
+    }
+    /** PATCH /vm/config — partial config update (deep-merged on vaultMind) */
+    async updateConfig(partial) {
+        return (await this.httpJson("PATCH", "/vm/config", partial));
+    }
+    /** GET /vault-mind/tools — full tool catalog + per-role allowlists */
+    async listTools() {
+        return (await this.httpJson("GET", "/vault-mind/tools"));
+    }
+    /** GET /vault-mind/identities — identity registry */
+    async listIdentities() {
+        return (await this.httpJson("GET", "/vault-mind/identities"));
+    }
+    /** PUT /vault-mind/identities/:role/allowedTools — update per-role allowlist */
+    async setAllowedTools(role, allowedTools) {
+        return (await this.httpJson("PUT", `/vault-mind/identities/${encodeURIComponent(role)}/allowedTools`, { allowedTools }));
+    }
+    /** POST /vault-mind/reload-identities — reload bridge registry */
+    async reloadIdentities() {
+        return (await this.httpJson("POST", "/vault-mind/reload-identities"));
+    }
+    /** POST /vm/reindex — trigger a remote reindex of all collections */
+    async reindex() {
+        return (await this.httpJson("POST", "/vm/reindex"));
+    }
+    /** GET /agent/activity — list activity events, optionally filtered by jobId and limited. */
+    async listActivity(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.jobId !== undefined)
+            params.set("jobId", opts.jobId);
+        if (opts.limit !== undefined)
+            params.set("limit", String(opts.limit));
+        const qs = params.toString();
+        return (await this.httpJson("GET", `/agent/activity${qs ? `?${qs}` : ""}`));
+    }
+    /** GET /vault-mind/model-readiness — returns model registry status and current selected model */
+    async getModelReadiness() {
+        return (await this.httpJson("GET", "/vault-mind/model-readiness"));
+    }
+}

package/dist/packages/obsidian/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/activity.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ActivityEvent — v1 status-level timeline derived from queue transitions.
+ *
+ * Persists append-only JSONL at the path resolved via `resolveVaultFile(cfg, "activity")`
+ * (default: `.vault-mind/agent-activity.jsonl`). IDs are monotonic per vault,
+ * initialised lazily by scanning the existing file on first write.
+ */
+import type { QueueEvent } from "./agent-queue.js";
+export type ActivityKind = "session" | "status" | "tool" | "gate" | "approval";
+export type ActivityTone = "neutral" | "ok" | "warn" | "error";
+export interface ActivityEvent {
+    /** Monotonic integer ID, unique within a vault. */
+    id: number;
+    /** Correlates to AgentJob.id / dispatchId. */
+    jobId: string;
+    /** ISO 8601 timestamp. */
+    ts: string;
+    kind: ActivityKind;
+    /** Short human-readable label. */
+    label: string;
+    /** Optional detail line (error text, tool args, gate reason). */
+    detail?: string;
+    tone?: ActivityTone;
+}
+/** Append one ActivityEvent to the vault's activity JSONL. */
+export declare function appendActivity(vaultPath: string, event: ActivityEvent): void;
+/**
+ * List activity events in chronological order (JSONL append order = creation order).
+ * - `jobId`: when provided, only events matching that job are returned.
+ * - `limit`: maximum number of events to return; must be a positive integer.
+ *   Non-positive or missing values are treated as unbounded.
+ * Malformed JSONL rows are silently skipped.
+ */
+export declare function listActivity(vaultPath: string, opts?: {
+    jobId?: string;
+    limit?: number;
+}): ActivityEvent[];
+/**
+ * Map a QueueEvent to an ActivityEvent and allocate the next monotonic ID.
+ * Returns `null` for event types that should not produce an activity record.
+ */
+export declare function mapQueueEventToActivity(e: QueueEvent, vaultPath: string): ActivityEvent | null;
+/**
+ * Map a tool-call request to an ActivityEvent with `kind: "tool"`.
+ * `dispatchId` correlates to AgentJob.id when available; falls back to `agentId`
+ * for tool calls outside a dispatch context (e.g. interactive agent use).
+ * `args` is summarised to a short detail line (first 200 chars of JSON).
+ */
+export declare function mapToolCallToActivity(toolName: string, agentId: string, dispatchId: string | undefined, args: Record<string, unknown>, vaultPath: string): ActivityEvent;

package/dist/src/activity.js

@@ -0,0 +1,175 @@
+/**
+ * ActivityEvent — v1 status-level timeline derived from queue transitions.
+ *
+ * Persists append-only JSONL at the path resolved via `resolveVaultFile(cfg, "activity")`
+ * (default: `.vault-mind/agent-activity.jsonl`). IDs are monotonic per vault,
+ * initialised lazily by scanning the existing file on first write.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig, resolveVaultFile } from "./utils.js";
+// ── Path resolution ───────────────────────────────────────────────────────────
+/** Fully-resolved path to the activity JSONL for a vault. */
+function resolvedActivityPath(vaultPath) {
+    const cfg = loadConfig(vaultPath).vaultMind;
+    return path.join(vaultPath, resolveVaultFile(cfg, "activity"));
+}
+// ── Monotonic ID counter ──────────────────────────────────────────────────────
+/** Per-vault in-memory counter. Initialised lazily from the JSONL file. */
+const nextIdCache = new Map();
+/**
+ * Return the next monotonic ID for the vault and advance the counter.
+ * On first call for a vault, scans the JSONL file to find the current maximum.
+ */
+function nextActivityId(vaultPath) {
+    const cached = nextIdCache.get(vaultPath);
+    if (cached !== undefined) {
+        nextIdCache.set(vaultPath, cached + 1);
+        return cached;
+    }
+    // Lazy init: find the max id already in the file.
+    const p = resolvedActivityPath(vaultPath);
+    let maxId = 0;
+    if (fs.existsSync(p)) {
+        for (const line of fs.readFileSync(p, "utf-8").split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const rec = JSON.parse(trimmed);
+                if (typeof rec.id === "number" && Number.isInteger(rec.id) && rec.id > maxId) {
+                    maxId = rec.id;
+                }
+            }
+            catch {
+                // skip malformed row
+            }
+        }
+    }
+    const id = maxId + 1;
+    nextIdCache.set(vaultPath, id + 1);
+    return id;
+}
+// ── Persistence ───────────────────────────────────────────────────────────────
+/** Append one ActivityEvent to the vault's activity JSONL. */
+export function appendActivity(vaultPath, event) {
+    const p = resolvedActivityPath(vaultPath);
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.appendFileSync(p, `${JSON.stringify(event)}\n`, "utf-8");
+}
+// ── Listing ───────────────────────────────────────────────────────────────────
+/**
+ * List activity events in chronological order (JSONL append order = creation order).
+ * - `jobId`: when provided, only events matching that job are returned.
+ * - `limit`: maximum number of events to return; must be a positive integer.
+ *   Non-positive or missing values are treated as unbounded.
+ * Malformed JSONL rows are silently skipped.
+ */
+export function listActivity(vaultPath, opts = {}) {
+    const p = resolvedActivityPath(vaultPath);
+    if (!fs.existsSync(p))
+        return [];
+    const { jobId, limit } = opts;
+    const cap = typeof limit === "number" && limit > 0 ? limit : Number.MAX_SAFE_INTEGER;
+    const out = [];
+    for (const line of fs.readFileSync(p, "utf-8").split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const rec = JSON.parse(trimmed);
+            if (jobId !== undefined && rec.jobId !== jobId)
+                continue;
+            out.push(rec);
+            if (out.length >= cap)
+                break;
+        }
+        catch {
+            // skip malformed row
+        }
+    }
+    return out;
+}
+// ── Queue-event mapping ───────────────────────────────────────────────────────
+/**
+ * Map a QueueEvent to an ActivityEvent and allocate the next monotonic ID.
+ * Returns `null` for event types that should not produce an activity record.
+ */
+export function mapQueueEventToActivity(e, vaultPath) {
+    let label;
+    let tone;
+    let detail;
+    let jobId;
+    switch (e.type) {
+        case "job-created":
+            jobId = e.job.id;
+            label = "job created";
+            tone = "neutral";
+            break;
+        case "job-updated":
+            jobId = e.job.id;
+            label = `job ${e.job.status}`;
+            tone = "neutral";
+            break;
+        case "job-completed":
+            jobId = e.job.id;
+            if (e.job.status === "failed") {
+                label = "job failed";
+                tone = "error";
+                if (e.job.lastError)
+                    detail = e.job.lastError;
+            }
+            else if (e.job.status === "done") {
+                label = "job done";
+                tone = "ok";
+            }
+            else if (e.job.status === "cancelled") {
+                label = "job cancelled";
+                tone = "warn";
+            }
+            else {
+                label = `job ${e.job.status}`;
+            }
+            break;
+        default:
+            return null;
+    }
+    const id = nextActivityId(vaultPath);
+    const event = {
+        id,
+        jobId,
+        ts: new Date().toISOString(),
+        kind: "status",
+        label,
+    };
+    if (tone !== undefined)
+        event.tone = tone;
+    if (detail !== undefined)
+        event.detail = detail;
+    return event;
+}
+// ── Tool-call mapping ─────────────────────────────────────────────────────────
+/**
+ * Map a tool-call request to an ActivityEvent with `kind: "tool"`.
+ * `dispatchId` correlates to AgentJob.id when available; falls back to `agentId`
+ * for tool calls outside a dispatch context (e.g. interactive agent use).
+ * `args` is summarised to a short detail line (first 200 chars of JSON).
+ */
+export function mapToolCallToActivity(toolName, agentId, dispatchId, args, vaultPath) {
+    const id = nextActivityId(vaultPath);
+    const argSummary = JSON.stringify(args);
+    const event = {
+        id,
+        jobId: dispatchId ?? agentId,
+        ts: new Date().toISOString(),
+        kind: "tool",
+        label: toolName,
+    };
+    if (argSummary.length > 0 && argSummary !== "{}") {
+        event.detail = argSummary.length > 200 ? `${argSummary.slice(0, 200)}…` : argSummary;
+    }
+    return event;
+}

package/dist/src/agent-bus/Agent.d.ts

@@ -15,6 +15,8 @@ export declare abstract class Agent {
     config: AgentConfig;
     protected bus: MessageBus;
     protected llm?: LLMProvider;
+    /** Current dispatch context — set when executing a job, included in tool-call payloads. */
+    protected currentDispatchId?: string;
     constructor(config: AgentConfig, bus: MessageBus, llm?: LLMProvider);
     /**
      * Broadcast a message to the environment
@@ -24,10 +26,16 @@ export declare abstract class Agent {
      * Direct message another agent
      */
     sendDirect(targetAgentId: string, payload: Record<string, unknown>): Promise<void>;
+    /**
+     * Set the dispatch context for the duration of `fn`, so tool calls made
+     * during `fn` carry the `dispatchId` for activity correlation.
+     * Clears the context in `finally` so it never leaks across jobs.
+     */
+    protected withDispatchContext<T>(dispatchId: string, fn: () => Promise<T>): Promise<T>;
     /**
      * Hook for handling incoming messages. To be overridden by implementations.
      */
-    protected handleMessage(message: Message): Promise<void>;
+    protected handleMessage(_message: Message): Promise<void>;
     /**
      * Perform an LLM-driven decision in JSON mode
      */

package/dist/src/agent-bus/Agent.js

@@ -9,6 +9,8 @@ export class Agent {
     config;
     bus;
     llm;
+    /** Current dispatch context — set when executing a job, included in tool-call payloads. */
+    currentDispatchId;
     constructor(config, bus, llm) {
         this.config = config;
         this.bus = bus;
@@ -29,10 +31,24 @@ export class Agent {
     async sendDirect(targetAgentId, payload) {
         await this.bus.publish(`direct:${targetAgentId}`, this.config.id, payload);
     }
+    /**
+     * Set the dispatch context for the duration of `fn`, so tool calls made
+     * during `fn` carry the `dispatchId` for activity correlation.
+     * Clears the context in `finally` so it never leaks across jobs.
+     */
+    async withDispatchContext(dispatchId, fn) {
+        this.currentDispatchId = dispatchId;
+        try {
+            return await fn();
+        }
+        finally {
+            this.currentDispatchId = undefined;
+        }
+    }
     /**
      * Hook for handling incoming messages. To be overridden by implementations.
      */
-    async handleMessage(message) {
+    async handleMessage(_message) {
         // Default: Do nothing
     }
     async askLLM(promptText, jsonMode = true) {
@@ -63,7 +79,6 @@ export class Agent {
         const requestTopic = "pi_tool_bridge_requests";
         const responseTopic = `pi_tool_bridge_responses:${this.config.id}:${requestId}`;
         return new Promise((resolve, reject) => {
-            // biome-ignore lint/style/useConst: assigned after handler/subscribe setup
             let timeout;
             const cleanup = () => {
                 clearTimeout(timeout);
@@ -91,6 +106,7 @@ export class Agent {
                 toolName,
                 args,
                 responseTopic,
+                ...(this.currentDispatchId ? { dispatchId: this.currentDispatchId } : {}),
             });
         });
     }

package/dist/src/agent-bus/index.d.ts

@@ -1,6 +1,6 @@
 export { Agent, type AgentConfig } from "./Agent.js";
-export { AgentLoader, type AgentFileDefinition, type AgentLoaderConfig } from "./AgentLoader.js";
-export { AgentRegistry, type AgentConstructor } from "./AgentRegistry.js";
-export { LLMProvider, AgentModelProvider, type LLMConfig, type PromptOptions, } from "./LLMProvider.js";
-export { MessageBus, type Message, type MessageHandler } from "./MessageBus.js";
-export { TaskQueue, type Task } from "./TaskQueue.js";
+export { type AgentFileDefinition, AgentLoader, type AgentLoaderConfig } from "./AgentLoader.js";
+export { type AgentConstructor, AgentRegistry } from "./AgentRegistry.js";
+export { AgentModelProvider, type LLMConfig, LLMProvider, type PromptOptions, } from "./LLMProvider.js";
+export { type Message, MessageBus, type MessageHandler } from "./MessageBus.js";
+export { type Task, TaskQueue } from "./TaskQueue.js";

package/dist/src/agent-bus/index.js

@@ -1,6 +1,6 @@
 export { Agent } from "./Agent.js";
 export { AgentLoader } from "./AgentLoader.js";
 export { AgentRegistry } from "./AgentRegistry.js";
-export { LLMProvider, AgentModelProvider, } from "./LLMProvider.js";
+export { AgentModelProvider, LLMProvider, } from "./LLMProvider.js";
 export { MessageBus } from "./MessageBus.js";
 export { TaskQueue } from "./TaskQueue.js";