@super-harness/server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# @super-harness/server
+
+The super-line binding for a `@super-harness/core` Harness, shipped as a
+super-line **plugin**. Two exports, two adoption modes:
+
+- **`harness(engine)`** — a `SuperLinePlugin` a host adds to its own
+  `createSuperLineServer` `plugins:` array. The primary story: one server, one
+  socket, one auth, one collections backend for the host AND the harness.
+- **`serve(engine, config)`** — the standalone host, built from the same
+  pieces: it owns the collections backend, a default query-param
+  `authenticate`, `identify`, and mounts `plugins: [harness(engine), ...]`.
+
+The tree rides **collections**, not the request surface: structural state is
+`harness.threads`/`nodes`/`tools`/`membership` rows (declared by
+`harnessContract()` in `@super-harness/shared`), and the token stream rides
+ephemeral per-thread room events that are never persisted per-token. Clients
+assemble the live tree with `subscribeTree` from `@super-harness/shared` (or
+`@super-harness/react`).
+
+## Install
+
+```bash
+pnpm add @super-harness/server @super-harness/core @super-harness/shared \
+  @mastra/core @super-line/core @super-line/server \
+  @super-line/collections-memory @super-line/collections-sqlite
+```
+
+All `@super-line/*` packages are **peers** — your app owns one core instance
+shared by host and library. What you need:
+
+| Peer | Version | When |
+| --- | --- | --- |
+| `@super-line/core` | `^0.11.0` | always |
+| `@super-line/server` | `^0.11.0` | always |
+| `@super-line/collections-memory` | `^0.1.0` | always (serve's `memory` backend; cheap) |
+| `@super-line/collections-sqlite` | `^0.1.0` | always (serve's default backend) |
+| `@super-line/collections-pglite` | `^0.1.0` | **optional** — only for `storage: { type: 'pglite' }` |
+| `@mastra/core` | `^1.49.0-alpha.2` | always (the engine's peer) |
+
+A transport is the host's choice — e.g. `@super-line/transport-websocket`
+(`^0.6.0`). Composing hosts that bring their own backend only need the
+collections package they actually use.
+
+## Composition — the harness as a plugin in your server
+
+If the app runs (or should run) its own super-line server, add the harness
+beside its surface. Four obligations (see `examples/composed-host` for the
+runnable version, `composition.test.ts` for the e2e):
+
+```ts
+import { z } from 'zod'
+import { defineContract, defineSurface } from '@super-line/core'
+import { createSuperLineServer } from '@super-line/server'
+import { memoryCollections } from '@super-line/collections-memory'
+import { webSocketServerTransport } from '@super-line/transport-websocket'
+import { harnessContract } from '@super-harness/shared'
+import { harness } from '@super-harness/server'
+
+// 1. Merge the contract fragment: harnessContract() contributes the harness
+//    surface (on `shared`) + the four harness.* collections.
+const hostContract = defineContract({
+  plugins: [harnessContract()],
+  shared: defineSurface({
+    clientToServer: {
+      'demo.echo': { input: z.object({ text: z.string() }), output: z.object({ echoed: z.string() }) },
+    },
+  }),
+  roles: { user: {} },
+})
+
+const srv = createSuperLineServer(hostContract, {
+  transports: [webSocketServerTransport({ server: httpServer, path: '/ws' })],
+  // 2. ONE collections backend, host-owned — serves the harness collections
+  //    beside any of the host's own.
+  collections: memoryCollections(),
+  // 3. authenticate ctx carries userId (+resourceId); identify returns it.
+  authenticate: (h) => ({ role: 'user' as const, ctx: { userId: userIdFrom(h) } }),
+  identify: (conn) => (conn.ctx as { userId: string }).userId,
+  // 4. Add the plugin. harness.* handler keys are subtracted from implement().
+  plugins: [harness(engine)],
+})
+
+// The host implements only its own surface — harness.* is owned by the plugin.
+srv.implement({ shared: { 'demo.echo': async ({ text }) => ({ echoed: text.toUpperCase() }) }, user: {} })
+```
+
+**`identify` is load-bearing.** The harness collections' RLS keys on
+`ctx.userId`, and super-line's principal is `identify(conn) ?? conn.id` — a
+random connection id. A host that skips `identify` gets a working request
+surface and a **silently empty tree**: every membership-gated read is denied.
+With `@super-line/plugin-auth`, `identify` comes from the session and the
+identity becomes the principal for free (see `examples/auth`).
+
+Client side: one `createSuperLineClient(hostContract)` handed to
+`createHarnessClient({ client })` from `@super-harness/react` in borrowed mode — its
+`close()` detaches listeners, never the host's socket.
+
+## Standalone — `serve()`
+
+The harness-only contract on its own server, same pieces pre-wired:
+
+```ts
+import { createServer } from 'node:http'
+import { webSocketServerTransport } from '@super-line/transport-websocket'
+import { serve } from '@super-harness/server'
+
+const httpServer = createServer()
+const { server, close } = await serve(engine, {
+  storage: { type: 'sqlite', file: './harness.db' },   // default; 'memory' for tests
+  transports: [webSocketServerTransport({ server: httpServer, path: '/super-line' })],
+  // authenticate?: (handshake) => ({ role: 'user', ctx: { userId, resourceId? } })
+  // plugin?: { roleFor, defaultRole } — membership role policy (see below)
+  // plugins?: [inspector(), auth()] — extra super-line plugins beside harness()
+})
+httpServer.listen(4111)
+```
+
+The storage union picks the collections backend:
+
+- `{ type: 'sqlite', file? }` — default; owns its own file. Needs
+  `better-sqlite3`'s native build.
+- `{ type: 'memory' }` — tests/dev.
+- `{ type: 'pglite', pgUrl, electricUrl? }` — multi-node: central Postgres for
+  writes + Electric-synced per-node replicas for fan-out. Loads
+  `@super-line/collections-pglite` (the optional peer) on demand. Viable even
+  though writes round-trip PG → Electric → replica, because tokens are
+  ephemeral — only low-frequency structural rows hit the backend.
+
+The default `authenticate` trusts `userId`/`resourceId` query params — replace
+it (or compose `@super-line/plugin-auth` via `plugins:`) for anything
+non-local. `close()` tears the server down and disposes the plugin's bus
+subscription; the transports/http server are the caller's to close.
+
+## What the plugin contributes
+
+`harness(engine, opts)` returns `{ policies, handlers, setup }`:
+
+- **Policies** — membership-based RLS over the four collections.
+  `harness.nodes`/`tools` read `isIn('threadId', joinedThreads(principal))`;
+  `harness.threads` reads `eq('resourceId', ctx.resourceId)` (the sidebar
+  list), falling back to membership when the connection carries no
+  `resourceId`; `harness.membership` reads `eq('userId', principal)`. Client
+  writes are all **deny** — the plugin co-writes server-authoritatively,
+  bypassing policy.
+- **Handlers** — the `harness.*` requests (send/resume/abort/approve/
+  switchMode/listModes/thread CRUD/join), subtracted from the host's
+  `implement()`. `harness.join` adds the connection to the thread room and
+  inserts a membership row.
+- **`setup(ctx)`** — subscribes the engine bus. Token deltas
+  (`reasoning`/`text`/`argsText`) broadcast to the per-thread room
+  (`harness:thread:{id}`) — ephemeral, never persisted — and fold into a
+  per-thread Projector; structural events fold through the Projector into the
+  collections writer (`collectionsTreeSink`), which lands the final strings on
+  the row at `node_end`/`tool_end`. Session signals (`suspended`,
+  `approvalRequired`, `modeChanged`, `followUpQueued`) broadcast; a
+  suspension's `{resumeSchema, request}` also parks on the node row
+  (`pendingResume`) so a mid-turn reload rebuilds the prompt. Thread metadata
+  persists as row updates (thread-list reactivity is `harness.threads` row
+  deltas, not events); `thread_deleted` cascades node/tool/membership rows.
+
+### Roles: viewer vs operator
+
+The viewer/operator split is a **`role` column on `harness.membership`** —
+per-user, per-thread — NOT a connection role. Control ops (send/resume/abort/
+approve/switchMode/rename/delete) reject a `viewer` membership with
+`FORBIDDEN`; read ops don't, so a viewer still sees the full live tree. The
+default join role is `operator` (every joiner can drive — preserves
+single-user behavior); pass `roleFor(ctx)` or `defaultRole` in
+`HarnessPluginOptions` to hand out `viewer` memberships.
+
+## Auth
+
+The plugin is auth-agnostic: it reads `ctx.userId` however the host's
+`authenticate` supplies it — query-param dev auth, `@super-line/plugin-auth`,
+or a custom scheme. `resourceId` (optional) scopes the thread list. See
+`examples/auth` for the plugin-auth pairing.

package/dist/index.cjs

@@ -0,0 +1,422 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  collectionsTreeSink: () => collectionsTreeSink,
+  harness: () => harness,
+  harnessContract: () => import_shared3.harnessContract,
+  serve: () => serve
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/serve.ts
+var import_server = require("@super-line/server");
+var import_collections_memory = require("@super-line/collections-memory");
+var import_collections_sqlite = require("@super-line/collections-sqlite");
+var import_shared2 = require("@super-harness/shared");
+
+// src/plugin.ts
+var import_core = require("@super-line/core");
+var import_core2 = require("@super-harness/core");
+var import_shared = require("@super-harness/shared");
+
+// src/sink.ts
+var isCode = (e, code) => e?.code === code;
+function collectionsTreeSink(opts) {
+  const { collections, threadId } = opts;
+  const nodesCol = () => collections(opts.nodes);
+  const toolsCol = () => collections(opts.tools);
+  const threadsCol = () => collections(opts.threads);
+  const known = /* @__PURE__ */ new Set();
+  const lastWritten = /* @__PURE__ */ new Map();
+  const chains = /* @__PURE__ */ new Map();
+  const run = (key, fn) => {
+    const prev = chains.get(key) ?? Promise.resolve();
+    chains.set(
+      key,
+      prev.then(fn).catch((e) => console.error("[harness] collection write failed", key, e))
+    );
+  };
+  const upsert = (handle, ns, id, row) => {
+    const key = `${ns}\0${id}`;
+    const serialized = JSON.stringify(row);
+    if (lastWritten.get(key) === serialized) return;
+    lastWritten.set(key, serialized);
+    run(key, async () => {
+      if (known.has(key)) return handle.update(row);
+      try {
+        await handle.insert(row);
+        known.add(key);
+      } catch (e) {
+        if (!isCode(e, "CONFLICT")) throw e;
+        known.add(key);
+        await handle.update(row);
+      }
+    });
+  };
+  let threadRow = { id: threadId, turns: [], todos: [], createdAt: 0, updatedAt: 0 };
+  const flushThread = () => upsert(threadsCol(), opts.threads, threadId, threadRow);
+  const pending = /* @__PURE__ */ new Map();
+  const pendingPayload = /* @__PURE__ */ new Map();
+  const nodeRowOf = (node) => {
+    const terminal = node.status !== "running";
+    const parkedTool = pending.get(node.nodeId);
+    const stillPending = parkedTool !== void 0 && !isSettled(node.tools[parkedTool]?.status);
+    if (parkedTool !== void 0 && !stillPending) pending.delete(node.nodeId);
+    return {
+      id: node.nodeId,
+      threadId,
+      parentNodeId: node.parentNodeId,
+      depth: node.depth,
+      agentType: node.agentType,
+      task: node.task,
+      status: node.status,
+      reasoning: terminal ? node.reasoning : "",
+      text: terminal ? node.text : "",
+      toolOrder: node.toolOrder,
+      childOrder: node.childOrder,
+      usage: node.usage,
+      durationMs: node.durationMs,
+      error: node.error,
+      textOffset: node.textOffset,
+      pendingResume: stillPending ? pendingPayload.get(node.nodeId) : void 0
+    };
+  };
+  const toolRowOf = (node, toolCallId) => {
+    const t = node.tools[toolCallId];
+    const streaming = t.status === "input-streaming";
+    return {
+      id: t.toolCallId,
+      threadId,
+      nodeId: node.nodeId,
+      toolName: t.toolName,
+      status: t.status,
+      argsText: streaming ? "" : t.argsText,
+      args: t.args,
+      result: t.result,
+      isError: t.isError,
+      textOffset: t.textOffset
+    };
+  };
+  return {
+    writeNode: (node) => {
+      upsert(nodesCol(), opts.nodes, node.nodeId, nodeRowOf(node));
+      for (const tid of node.toolOrder) upsert(toolsCol(), opts.tools, tid, toolRowOf(node, tid));
+    },
+    writeThread: (doc) => {
+      threadRow = { ...threadRow, turns: doc.turns, todos: doc.todos ?? [] };
+      flushThread();
+    },
+    setThreadMeta: (meta) => {
+      threadRow = {
+        ...threadRow,
+        resourceId: meta.resourceId ?? threadRow.resourceId,
+        title: meta.title ?? threadRow.title,
+        createdAt: threadRow.createdAt || meta.createdAt || 0,
+        updatedAt: meta.updatedAt ?? threadRow.updatedAt
+      };
+      flushThread();
+    },
+    setPending: (nodeId, toolCallId, payload) => {
+      pending.set(nodeId, toolCallId);
+      pendingPayload.set(nodeId, payload);
+    }
+  };
+}
+function isSettled(status) {
+  return status === "output-available" || status === "error";
+}
+
+// src/plugin.ts
+function harness(engine, opts = {}) {
+  let pctx;
+  const P = () => {
+    if (!pctx) throw new Error("harness plugin: setup() has not run yet");
+    return pctx;
+  };
+  const col = (name) => P().collection(name);
+  const room = (threadId) => P().room((0, import_shared.harnessThreadRoom)(threadId));
+  const sinks = /* @__PURE__ */ new Map();
+  const projectors = /* @__PURE__ */ new Map();
+  const sinkFor = (threadId) => {
+    let s = sinks.get(threadId);
+    if (!s) {
+      s = collectionsTreeSink({
+        collections: (n) => col(n),
+        threadId,
+        nodes: import_shared.HARNESS_NODES,
+        tools: import_shared.HARNESS_TOOLS,
+        threads: import_shared.HARNESS_THREADS
+      });
+      sinks.set(threadId, s);
+    }
+    return s;
+  };
+  const projectorFor = (threadId) => {
+    let p = projectors.get(threadId);
+    if (!p) {
+      p = new import_core2.Projector(sinkFor(threadId));
+      projectors.set(threadId, p);
+    }
+    return p;
+  };
+  const joined = async (principal) => {
+    const rows = await col(import_shared.HARNESS_MEMBERSHIP).snapshot({ filter: (0, import_core.eq)("userId", principal) });
+    return rows.map((r) => r.threadId);
+  };
+  const roleOf = async (threadId, userId) => {
+    const row = await col(import_shared.HARNESS_MEMBERSHIP).read((0, import_shared.membershipId)(threadId, userId));
+    return row?.role;
+  };
+  const requireDriver = async (threadId, ctx) => {
+    if (await roleOf(threadId, ctx.userId) === "viewer") {
+      throw new import_core.SuperLineError("FORBIDDEN", "viewer role cannot drive the thread");
+    }
+  };
+  const ok = { ok: true };
+  const attempt = async (fn) => {
+    try {
+      await fn();
+      return ok;
+    } catch (e) {
+      console.error("[harness] request failed", e);
+      return { ok: false };
+    }
+  };
+  const purgeThread = async (threadId) => {
+    projectors.delete(threadId);
+    sinks.delete(threadId);
+    for (const c of [import_shared.HARNESS_NODES, import_shared.HARNESS_TOOLS, import_shared.HARNESS_MEMBERSHIP]) {
+      const rows = await col(c).snapshot({ filter: (0, import_core.eq)("threadId", threadId) }).catch(() => []);
+      for (const r of rows) await col(c).delete(r.id).catch(() => {
+      });
+    }
+    await col(import_shared.HARNESS_THREADS).delete(threadId).catch(() => {
+    });
+  };
+  const onBus = (threadId, e) => {
+    switch (e.type) {
+      case "reasoning_delta":
+        room(threadId).broadcast("harness.reasoningDelta", { threadId, nodeId: e.nodeId, text: e.text });
+        projectorFor(threadId).emit(e);
+        return;
+      case "text_delta":
+        room(threadId).broadcast("harness.textDelta", { threadId, nodeId: e.nodeId, text: e.text });
+        projectorFor(threadId).emit(e);
+        return;
+      case "tool_input_delta":
+        room(threadId).broadcast("harness.toolInputDelta", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          argsTextDelta: e.argsTextDelta
+        });
+        projectorFor(threadId).emit(e);
+        return;
+      case "suspended":
+        room(threadId).broadcast("harness.suspended", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          toolName: e.toolName,
+          request: e.request,
+          resumeSchema: e.resumeSchema
+        });
+        if (e.nodeId && e.toolCallId) sinkFor(threadId).setPending(e.nodeId, e.toolCallId, { resumeSchema: e.resumeSchema, request: e.request });
+        return;
+      case "approval_required":
+        room(threadId).broadcast("harness.approvalRequired", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          toolName: e.toolName,
+          args: e.args
+        });
+        return;
+      case "mode_changed":
+        room(threadId).broadcast("harness.modeChanged", { threadId, modeId: e.modeId, previousModeId: e.previousModeId });
+        return;
+      case "follow_up_queued":
+        room(threadId).broadcast("harness.followUpQueued", { threadId, count: e.count });
+        return;
+      case "thread_created":
+        sinkFor(threadId).setThreadMeta({ resourceId: e.resourceId, title: e.title, createdAt: now(), updatedAt: now() });
+        return;
+      case "thread_renamed":
+        sinkFor(threadId).setThreadMeta({ title: e.title, updatedAt: now() });
+        return;
+      case "thread_deleted":
+        void purgeThread(threadId);
+        return;
+      case "tree_changed":
+        return;
+      default:
+        projectorFor(threadId).emit(e);
+    }
+  };
+  const buildHandlers = (ctx) => {
+    pctx = ctx;
+    return {
+      "harness.join": async ({ threadId }, connCtx, conn) => {
+        const c = connCtx;
+        room(threadId).add(conn);
+        const role = opts.roleFor?.(c) ?? opts.defaultRole ?? "operator";
+        const row = { id: (0, import_shared.membershipId)(threadId, c.userId), threadId, userId: c.userId, role, joinedAt: now() };
+        await col(import_shared.HARNESS_MEMBERSHIP).insert(row).catch((e) => {
+          if (e?.code !== "CONFLICT") console.error("[harness] membership insert failed", e);
+        });
+        return ok;
+      },
+      "harness.sendMessage": async ({ threadId, message, files }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        void engine.sendMessage({ threadId, content: message, files }).catch((e) => console.error("[harness] run failed", e));
+        return ok;
+      },
+      "harness.resumeMessage": async ({ threadId, toolCallId, resumeData }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        try {
+          void engine.resume({ threadId, toolCallId, resumeData }).catch((e) => console.error("[harness] resume failed", e));
+          return ok;
+        } catch (e) {
+          console.error("[harness] resume rejected", e);
+          return { ok: false };
+        }
+      },
+      "harness.abort": async ({ threadId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        engine.abort(threadId);
+        return ok;
+      },
+      "harness.respondToApproval": async (input, connCtx) => {
+        await requireDriver(input.threadId, connCtx);
+        return attempt(() => engine.respondToApproval(input));
+      },
+      "harness.switchMode": async ({ threadId, modeId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.switchMode(threadId, modeId));
+      },
+      "harness.listModes": async () => ({
+        modes: engine.listModes().map((m) => ({ id: m.id, name: m.name, description: m.description })),
+        defaultModeId: engine.defaultModeId
+      }),
+      // A connection-pinned resourceId is AUTHORITATIVE (the host's authenticate
+      // validated it — honoring the request's would let any client enumerate or
+      // write another tenant's scope). Hosts that leave ctx.resourceId unset opt
+      // into request-level scoping instead: clients switch resources per call,
+      // no reconnect. Note this covers the REQUEST surface only — a
+      // harness.threads collection subscription's read filter is frozen per
+      // connection from ctx, so live sidebar reactivity follows ctx, not requests.
+      "harness.listThreads": async (input, connCtx) => ({
+        threads: await engine.threads.list(connCtx.resourceId ?? input.resourceId)
+      }),
+      "harness.createThread": async (input, connCtx) => ({
+        threadId: (await engine.threads.create({ ...input, resourceId: connCtx.resourceId ?? input.resourceId })).id
+      }),
+      "harness.renameThread": async ({ threadId, title }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.threads.rename(threadId, title));
+      },
+      "harness.deleteThread": async ({ threadId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.threads.delete(threadId));
+      }
+    };
+  };
+  return {
+    name: "harness",
+    policies: {
+      [import_shared.HARNESS_MEMBERSHIP]: { read: (principal) => (0, import_core.eq)("userId", principal) },
+      [import_shared.HARNESS_NODES]: { read: async (principal) => (0, import_core.isIn)("threadId", await joined(principal)) },
+      [import_shared.HARNESS_TOOLS]: { read: async (principal) => (0, import_core.isIn)("threadId", await joined(principal)) },
+      // Thread LIST = your resource's threads (sidebar) UNIONED with threads you
+      // joined. Membership must never be masked by resourceId: a client-minted
+      // thread (join + send, no createThread) has no resourceId on its row, and
+      // an eq-only filter would hide the caller's OWN thread — empty turns.
+      [import_shared.HARNESS_THREADS]: {
+        read: async (principal, ctx) => {
+          const rid = ctx?.resourceId;
+          const mine = (0, import_core.isIn)("id", await joined(principal));
+          return rid ? (0, import_core.or)((0, import_core.eq)("resourceId", rid), mine) : mine;
+        }
+      }
+    },
+    handlers: buildHandlers,
+    setup: (ctx) => {
+      pctx = ctx;
+      const unsub = engine.subscribe(onBus);
+      return () => unsub();
+    }
+  };
+}
+function now() {
+  return Date.now();
+}
+
+// src/serve.ts
+async function collectionsFor(storage) {
+  switch (storage.type) {
+    case "memory":
+      return (0, import_collections_memory.memoryCollections)();
+    case "pglite": {
+      const { pgliteCollections } = await import("@super-line/collections-pglite");
+      return pgliteCollections({ pgUrl: storage.pgUrl, electricUrl: storage.electricUrl });
+    }
+    default:
+      return (0, import_collections_sqlite.sqliteCollections)({ file: storage.file ?? "./harness.db" });
+  }
+}
+var defaultAuthenticate = (h) => {
+  const q = h?.query ?? {};
+  return { role: "user", ctx: { userId: q.userId ?? q.resourceId ?? "local", resourceId: q.resourceId } };
+};
+async function serve(engine, config = {}) {
+  const collections = await collectionsFor(config.storage ?? { type: "sqlite" });
+  const server = (0, import_server.createSuperLineServer)(import_shared2.contract, {
+    transports: config.transports ?? [],
+    authenticate: config.authenticate ?? defaultAuthenticate,
+    identify: (conn) => conn.ctx.userId,
+    collections,
+    plugins: [harness(engine, config.plugin), ...config.plugins ?? []],
+    adapter: config.adapter
+  });
+  server.implement({});
+  return { server, close: () => void server.close() };
+}
+
+// src/index.ts
+var import_shared3 = require("@super-harness/shared");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectionsTreeSink,
+  harness,
+  harnessContract,
+  serve
+});

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+import { ServerTransport, Adapter } from '@super-line/core';
+import { SuperLinePlugin, createSuperLineServer } from '@super-line/server';
+import { Harness, TreeSink } from '@super-harness/core';
+import { MemberRole, HarnessSurface } from '@super-harness/shared';
+export { harnessContract } from '@super-harness/shared';
+
+interface HarnessCtx {
+    userId: string;
+    resourceId?: string;
+    roles?: string[];
+}
+interface HarnessPluginOptions {
+    roleFor?: (ctx: HarnessCtx) => MemberRole;
+    defaultRole?: MemberRole;
+}
+declare function harness(engine: Harness, opts?: HarnessPluginOptions): SuperLinePlugin<HarnessSurface>;
+
+type HarnessStorage = {
+    type: 'memory';
+} | {
+    type: 'sqlite';
+    file?: string;
+} | {
+    type: 'pglite';
+    pgUrl: string;
+    electricUrl?: string;
+};
+interface ServeConfig {
+    storage?: HarnessStorage;
+    transports?: ServerTransport[];
+    adapter?: Adapter;
+    authenticate?: (handshake: unknown) => {
+        role: 'user';
+        ctx: HarnessCtx;
+    };
+    plugin?: HarnessPluginOptions;
+    plugins?: SuperLinePlugin[];
+}
+interface HarnessServer {
+    server: ReturnType<typeof createSuperLineServer>;
+    close(): void;
+}
+declare function serve(engine: Harness, config?: ServeConfig): Promise<HarnessServer>;
+
+interface CollectionHandleLike {
+    insert(row: unknown): Promise<void>;
+    update(row: unknown): Promise<void>;
+    delete(id: string): Promise<void>;
+    snapshot(query?: unknown): Promise<unknown[]>;
+}
+interface Collections {
+    (name: string): CollectionHandleLike;
+}
+interface CollectionsTreeSink extends TreeSink {
+    setThreadMeta(meta: {
+        resourceId?: string;
+        title?: string;
+        createdAt?: number;
+        updatedAt?: number;
+    }): void;
+    setPending(nodeId: string, toolCallId: string, payload: {
+        resumeSchema?: string;
+        request?: unknown;
+    }): void;
+}
+declare function collectionsTreeSink(opts: {
+    collections: Collections;
+    threadId: string;
+    nodes: string;
+    tools: string;
+    threads: string;
+}): CollectionsTreeSink;
+
+export { type CollectionHandleLike, type Collections, type CollectionsTreeSink, type HarnessCtx, type HarnessPluginOptions, type HarnessServer, type HarnessStorage, type ServeConfig, collectionsTreeSink, harness, serve };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { ServerTransport, Adapter } from '@super-line/core';
+import { SuperLinePlugin, createSuperLineServer } from '@super-line/server';
+import { Harness, TreeSink } from '@super-harness/core';
+import { MemberRole, HarnessSurface } from '@super-harness/shared';
+export { harnessContract } from '@super-harness/shared';
+
+interface HarnessCtx {
+    userId: string;
+    resourceId?: string;
+    roles?: string[];
+}
+interface HarnessPluginOptions {
+    roleFor?: (ctx: HarnessCtx) => MemberRole;
+    defaultRole?: MemberRole;
+}
+declare function harness(engine: Harness, opts?: HarnessPluginOptions): SuperLinePlugin<HarnessSurface>;
+
+type HarnessStorage = {
+    type: 'memory';
+} | {
+    type: 'sqlite';
+    file?: string;
+} | {
+    type: 'pglite';
+    pgUrl: string;
+    electricUrl?: string;
+};
+interface ServeConfig {
+    storage?: HarnessStorage;
+    transports?: ServerTransport[];
+    adapter?: Adapter;
+    authenticate?: (handshake: unknown) => {
+        role: 'user';
+        ctx: HarnessCtx;
+    };
+    plugin?: HarnessPluginOptions;
+    plugins?: SuperLinePlugin[];
+}
+interface HarnessServer {
+    server: ReturnType<typeof createSuperLineServer>;
+    close(): void;
+}
+declare function serve(engine: Harness, config?: ServeConfig): Promise<HarnessServer>;
+
+interface CollectionHandleLike {
+    insert(row: unknown): Promise<void>;
+    update(row: unknown): Promise<void>;
+    delete(id: string): Promise<void>;
+    snapshot(query?: unknown): Promise<unknown[]>;
+}
+interface Collections {
+    (name: string): CollectionHandleLike;
+}
+interface CollectionsTreeSink extends TreeSink {
+    setThreadMeta(meta: {
+        resourceId?: string;
+        title?: string;
+        createdAt?: number;
+        updatedAt?: number;
+    }): void;
+    setPending(nodeId: string, toolCallId: string, payload: {
+        resumeSchema?: string;
+        request?: unknown;
+    }): void;
+}
+declare function collectionsTreeSink(opts: {
+    collections: Collections;
+    threadId: string;
+    nodes: string;
+    tools: string;
+    threads: string;
+}): CollectionsTreeSink;
+
+export { type CollectionHandleLike, type Collections, type CollectionsTreeSink, type HarnessCtx, type HarnessPluginOptions, type HarnessServer, type HarnessStorage, type ServeConfig, collectionsTreeSink, harness, serve };

package/dist/index.js

@@ -0,0 +1,389 @@
+// src/serve.ts
+import { createSuperLineServer } from "@super-line/server";
+import { memoryCollections } from "@super-line/collections-memory";
+import { sqliteCollections } from "@super-line/collections-sqlite";
+import { contract } from "@super-harness/shared";
+
+// src/plugin.ts
+import { SuperLineError, eq, isIn, or } from "@super-line/core";
+import { Projector } from "@super-harness/core";
+import {
+  HARNESS_THREADS,
+  HARNESS_NODES,
+  HARNESS_TOOLS,
+  HARNESS_MEMBERSHIP,
+  membershipId,
+  harnessThreadRoom
+} from "@super-harness/shared";
+
+// src/sink.ts
+var isCode = (e, code) => e?.code === code;
+function collectionsTreeSink(opts) {
+  const { collections, threadId } = opts;
+  const nodesCol = () => collections(opts.nodes);
+  const toolsCol = () => collections(opts.tools);
+  const threadsCol = () => collections(opts.threads);
+  const known = /* @__PURE__ */ new Set();
+  const lastWritten = /* @__PURE__ */ new Map();
+  const chains = /* @__PURE__ */ new Map();
+  const run = (key, fn) => {
+    const prev = chains.get(key) ?? Promise.resolve();
+    chains.set(
+      key,
+      prev.then(fn).catch((e) => console.error("[harness] collection write failed", key, e))
+    );
+  };
+  const upsert = (handle, ns, id, row) => {
+    const key = `${ns}\0${id}`;
+    const serialized = JSON.stringify(row);
+    if (lastWritten.get(key) === serialized) return;
+    lastWritten.set(key, serialized);
+    run(key, async () => {
+      if (known.has(key)) return handle.update(row);
+      try {
+        await handle.insert(row);
+        known.add(key);
+      } catch (e) {
+        if (!isCode(e, "CONFLICT")) throw e;
+        known.add(key);
+        await handle.update(row);
+      }
+    });
+  };
+  let threadRow = { id: threadId, turns: [], todos: [], createdAt: 0, updatedAt: 0 };
+  const flushThread = () => upsert(threadsCol(), opts.threads, threadId, threadRow);
+  const pending = /* @__PURE__ */ new Map();
+  const pendingPayload = /* @__PURE__ */ new Map();
+  const nodeRowOf = (node) => {
+    const terminal = node.status !== "running";
+    const parkedTool = pending.get(node.nodeId);
+    const stillPending = parkedTool !== void 0 && !isSettled(node.tools[parkedTool]?.status);
+    if (parkedTool !== void 0 && !stillPending) pending.delete(node.nodeId);
+    return {
+      id: node.nodeId,
+      threadId,
+      parentNodeId: node.parentNodeId,
+      depth: node.depth,
+      agentType: node.agentType,
+      task: node.task,
+      status: node.status,
+      reasoning: terminal ? node.reasoning : "",
+      text: terminal ? node.text : "",
+      toolOrder: node.toolOrder,
+      childOrder: node.childOrder,
+      usage: node.usage,
+      durationMs: node.durationMs,
+      error: node.error,
+      textOffset: node.textOffset,
+      pendingResume: stillPending ? pendingPayload.get(node.nodeId) : void 0
+    };
+  };
+  const toolRowOf = (node, toolCallId) => {
+    const t = node.tools[toolCallId];
+    const streaming = t.status === "input-streaming";
+    return {
+      id: t.toolCallId,
+      threadId,
+      nodeId: node.nodeId,
+      toolName: t.toolName,
+      status: t.status,
+      argsText: streaming ? "" : t.argsText,
+      args: t.args,
+      result: t.result,
+      isError: t.isError,
+      textOffset: t.textOffset
+    };
+  };
+  return {
+    writeNode: (node) => {
+      upsert(nodesCol(), opts.nodes, node.nodeId, nodeRowOf(node));
+      for (const tid of node.toolOrder) upsert(toolsCol(), opts.tools, tid, toolRowOf(node, tid));
+    },
+    writeThread: (doc) => {
+      threadRow = { ...threadRow, turns: doc.turns, todos: doc.todos ?? [] };
+      flushThread();
+    },
+    setThreadMeta: (meta) => {
+      threadRow = {
+        ...threadRow,
+        resourceId: meta.resourceId ?? threadRow.resourceId,
+        title: meta.title ?? threadRow.title,
+        createdAt: threadRow.createdAt || meta.createdAt || 0,
+        updatedAt: meta.updatedAt ?? threadRow.updatedAt
+      };
+      flushThread();
+    },
+    setPending: (nodeId, toolCallId, payload) => {
+      pending.set(nodeId, toolCallId);
+      pendingPayload.set(nodeId, payload);
+    }
+  };
+}
+function isSettled(status) {
+  return status === "output-available" || status === "error";
+}
+
+// src/plugin.ts
+function harness(engine, opts = {}) {
+  let pctx;
+  const P = () => {
+    if (!pctx) throw new Error("harness plugin: setup() has not run yet");
+    return pctx;
+  };
+  const col = (name) => P().collection(name);
+  const room = (threadId) => P().room(harnessThreadRoom(threadId));
+  const sinks = /* @__PURE__ */ new Map();
+  const projectors = /* @__PURE__ */ new Map();
+  const sinkFor = (threadId) => {
+    let s = sinks.get(threadId);
+    if (!s) {
+      s = collectionsTreeSink({
+        collections: (n) => col(n),
+        threadId,
+        nodes: HARNESS_NODES,
+        tools: HARNESS_TOOLS,
+        threads: HARNESS_THREADS
+      });
+      sinks.set(threadId, s);
+    }
+    return s;
+  };
+  const projectorFor = (threadId) => {
+    let p = projectors.get(threadId);
+    if (!p) {
+      p = new Projector(sinkFor(threadId));
+      projectors.set(threadId, p);
+    }
+    return p;
+  };
+  const joined = async (principal) => {
+    const rows = await col(HARNESS_MEMBERSHIP).snapshot({ filter: eq("userId", principal) });
+    return rows.map((r) => r.threadId);
+  };
+  const roleOf = async (threadId, userId) => {
+    const row = await col(HARNESS_MEMBERSHIP).read(membershipId(threadId, userId));
+    return row?.role;
+  };
+  const requireDriver = async (threadId, ctx) => {
+    if (await roleOf(threadId, ctx.userId) === "viewer") {
+      throw new SuperLineError("FORBIDDEN", "viewer role cannot drive the thread");
+    }
+  };
+  const ok = { ok: true };
+  const attempt = async (fn) => {
+    try {
+      await fn();
+      return ok;
+    } catch (e) {
+      console.error("[harness] request failed", e);
+      return { ok: false };
+    }
+  };
+  const purgeThread = async (threadId) => {
+    projectors.delete(threadId);
+    sinks.delete(threadId);
+    for (const c of [HARNESS_NODES, HARNESS_TOOLS, HARNESS_MEMBERSHIP]) {
+      const rows = await col(c).snapshot({ filter: eq("threadId", threadId) }).catch(() => []);
+      for (const r of rows) await col(c).delete(r.id).catch(() => {
+      });
+    }
+    await col(HARNESS_THREADS).delete(threadId).catch(() => {
+    });
+  };
+  const onBus = (threadId, e) => {
+    switch (e.type) {
+      case "reasoning_delta":
+        room(threadId).broadcast("harness.reasoningDelta", { threadId, nodeId: e.nodeId, text: e.text });
+        projectorFor(threadId).emit(e);
+        return;
+      case "text_delta":
+        room(threadId).broadcast("harness.textDelta", { threadId, nodeId: e.nodeId, text: e.text });
+        projectorFor(threadId).emit(e);
+        return;
+      case "tool_input_delta":
+        room(threadId).broadcast("harness.toolInputDelta", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          argsTextDelta: e.argsTextDelta
+        });
+        projectorFor(threadId).emit(e);
+        return;
+      case "suspended":
+        room(threadId).broadcast("harness.suspended", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          toolName: e.toolName,
+          request: e.request,
+          resumeSchema: e.resumeSchema
+        });
+        if (e.nodeId && e.toolCallId) sinkFor(threadId).setPending(e.nodeId, e.toolCallId, { resumeSchema: e.resumeSchema, request: e.request });
+        return;
+      case "approval_required":
+        room(threadId).broadcast("harness.approvalRequired", {
+          threadId,
+          nodeId: e.nodeId,
+          toolCallId: e.toolCallId,
+          toolName: e.toolName,
+          args: e.args
+        });
+        return;
+      case "mode_changed":
+        room(threadId).broadcast("harness.modeChanged", { threadId, modeId: e.modeId, previousModeId: e.previousModeId });
+        return;
+      case "follow_up_queued":
+        room(threadId).broadcast("harness.followUpQueued", { threadId, count: e.count });
+        return;
+      case "thread_created":
+        sinkFor(threadId).setThreadMeta({ resourceId: e.resourceId, title: e.title, createdAt: now(), updatedAt: now() });
+        return;
+      case "thread_renamed":
+        sinkFor(threadId).setThreadMeta({ title: e.title, updatedAt: now() });
+        return;
+      case "thread_deleted":
+        void purgeThread(threadId);
+        return;
+      case "tree_changed":
+        return;
+      default:
+        projectorFor(threadId).emit(e);
+    }
+  };
+  const buildHandlers = (ctx) => {
+    pctx = ctx;
+    return {
+      "harness.join": async ({ threadId }, connCtx, conn) => {
+        const c = connCtx;
+        room(threadId).add(conn);
+        const role = opts.roleFor?.(c) ?? opts.defaultRole ?? "operator";
+        const row = { id: membershipId(threadId, c.userId), threadId, userId: c.userId, role, joinedAt: now() };
+        await col(HARNESS_MEMBERSHIP).insert(row).catch((e) => {
+          if (e?.code !== "CONFLICT") console.error("[harness] membership insert failed", e);
+        });
+        return ok;
+      },
+      "harness.sendMessage": async ({ threadId, message, files }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        void engine.sendMessage({ threadId, content: message, files }).catch((e) => console.error("[harness] run failed", e));
+        return ok;
+      },
+      "harness.resumeMessage": async ({ threadId, toolCallId, resumeData }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        try {
+          void engine.resume({ threadId, toolCallId, resumeData }).catch((e) => console.error("[harness] resume failed", e));
+          return ok;
+        } catch (e) {
+          console.error("[harness] resume rejected", e);
+          return { ok: false };
+        }
+      },
+      "harness.abort": async ({ threadId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        engine.abort(threadId);
+        return ok;
+      },
+      "harness.respondToApproval": async (input, connCtx) => {
+        await requireDriver(input.threadId, connCtx);
+        return attempt(() => engine.respondToApproval(input));
+      },
+      "harness.switchMode": async ({ threadId, modeId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.switchMode(threadId, modeId));
+      },
+      "harness.listModes": async () => ({
+        modes: engine.listModes().map((m) => ({ id: m.id, name: m.name, description: m.description })),
+        defaultModeId: engine.defaultModeId
+      }),
+      // A connection-pinned resourceId is AUTHORITATIVE (the host's authenticate
+      // validated it — honoring the request's would let any client enumerate or
+      // write another tenant's scope). Hosts that leave ctx.resourceId unset opt
+      // into request-level scoping instead: clients switch resources per call,
+      // no reconnect. Note this covers the REQUEST surface only — a
+      // harness.threads collection subscription's read filter is frozen per
+      // connection from ctx, so live sidebar reactivity follows ctx, not requests.
+      "harness.listThreads": async (input, connCtx) => ({
+        threads: await engine.threads.list(connCtx.resourceId ?? input.resourceId)
+      }),
+      "harness.createThread": async (input, connCtx) => ({
+        threadId: (await engine.threads.create({ ...input, resourceId: connCtx.resourceId ?? input.resourceId })).id
+      }),
+      "harness.renameThread": async ({ threadId, title }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.threads.rename(threadId, title));
+      },
+      "harness.deleteThread": async ({ threadId }, connCtx) => {
+        await requireDriver(threadId, connCtx);
+        return attempt(() => engine.threads.delete(threadId));
+      }
+    };
+  };
+  return {
+    name: "harness",
+    policies: {
+      [HARNESS_MEMBERSHIP]: { read: (principal) => eq("userId", principal) },
+      [HARNESS_NODES]: { read: async (principal) => isIn("threadId", await joined(principal)) },
+      [HARNESS_TOOLS]: { read: async (principal) => isIn("threadId", await joined(principal)) },
+      // Thread LIST = your resource's threads (sidebar) UNIONED with threads you
+      // joined. Membership must never be masked by resourceId: a client-minted
+      // thread (join + send, no createThread) has no resourceId on its row, and
+      // an eq-only filter would hide the caller's OWN thread — empty turns.
+      [HARNESS_THREADS]: {
+        read: async (principal, ctx) => {
+          const rid = ctx?.resourceId;
+          const mine = isIn("id", await joined(principal));
+          return rid ? or(eq("resourceId", rid), mine) : mine;
+        }
+      }
+    },
+    handlers: buildHandlers,
+    setup: (ctx) => {
+      pctx = ctx;
+      const unsub = engine.subscribe(onBus);
+      return () => unsub();
+    }
+  };
+}
+function now() {
+  return Date.now();
+}
+
+// src/serve.ts
+async function collectionsFor(storage) {
+  switch (storage.type) {
+    case "memory":
+      return memoryCollections();
+    case "pglite": {
+      const { pgliteCollections } = await import("@super-line/collections-pglite");
+      return pgliteCollections({ pgUrl: storage.pgUrl, electricUrl: storage.electricUrl });
+    }
+    default:
+      return sqliteCollections({ file: storage.file ?? "./harness.db" });
+  }
+}
+var defaultAuthenticate = (h) => {
+  const q = h?.query ?? {};
+  return { role: "user", ctx: { userId: q.userId ?? q.resourceId ?? "local", resourceId: q.resourceId } };
+};
+async function serve(engine, config = {}) {
+  const collections = await collectionsFor(config.storage ?? { type: "sqlite" });
+  const server = createSuperLineServer(contract, {
+    transports: config.transports ?? [],
+    authenticate: config.authenticate ?? defaultAuthenticate,
+    identify: (conn) => conn.ctx.userId,
+    collections,
+    plugins: [harness(engine, config.plugin), ...config.plugins ?? []],
+    adapter: config.adapter
+  });
+  server.implement({});
+  return { server, close: () => void server.close() };
+}
+
+// src/index.ts
+import { harnessContract } from "@super-harness/shared";
+export {
+  collectionsTreeSink,
+  harness,
+  harnessContract,
+  serve
+};

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@super-harness/server",
+  "version": "0.1.0",
+  "description": "Batteries-included super-line binding for Super Harness: the harness() plugin and standalone serve() expose a core Harness over a super-line server with durable harness.* collections, the wire contract, and HITL suspension/approval broadcast.",
+  "keywords": [
+    "agent",
+    "agents",
+    "multi-agent",
+    "ai",
+    "llm",
+    "language-model",
+    "tool-calling",
+    "orchestration",
+    "supervisor",
+    "subagent",
+    "streaming",
+    "harness",
+    "mastra",
+    "super-line",
+    "typescript"
+  ],
+  "homepage": "https://mertdogar.github.io/super-harness/",
+  "bugs": "https://github.com/mertdogar/super-harness/issues",
+  "license": "MIT",
+  "author": "Mert Dogar",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mertdogar/super-harness.git",
+    "directory": "packages/server"
+  },
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@super-harness/shared": "^0.1.0",
+    "@super-harness/core": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@mastra/core": "^1.49.0-alpha.2",
+    "@super-line/collections-memory": "^0.1.0",
+    "@super-line/collections-pglite": "^0.1.0",
+    "@super-line/collections-sqlite": "^0.1.0",
+    "@super-line/core": "^0.11.0",
+    "@super-line/server": "^0.11.0"
+  },
+  "peerDependenciesMeta": {
+    "@super-line/collections-pglite": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.5.4",
+    "@libsql/client": "^0.17.4",
+    "@mastra/core": "1.49.0-alpha.2",
+    "@super-line/client": "^0.9.0",
+    "@super-line/collections-memory": "^0.1.0",
+    "@super-line/collections-pglite": "^0.1.0",
+    "@super-line/collections-sqlite": "^0.1.0",
+    "@super-line/core": "^0.11.0",
+    "@super-line/server": "^0.11.0",
+    "@super-line/transport-websocket": "^0.6.0",
+    "vitest": "^4.1.2",
+    "zod": "^4.4.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}