@graph-tl/graph 0.1.0

package/dist/server-7IB2VIMK.js

@@ -0,0 +1,1476 @@
+#!/usr/bin/env node
+import {
+  getLicenseTier
+} from "./chunk-WKOEKYTF.js";
+import {
+  EngineError,
+  ValidationError,
+  closeDb,
+  createNode,
+  getAncestors,
+  getChildren,
+  getDb,
+  getEvents,
+  getNode,
+  getNodeOrThrow,
+  getProjectRoot,
+  getProjectSummary,
+  initDb,
+  listProjects,
+  logEvent,
+  optionalBoolean,
+  optionalNumber,
+  optionalString,
+  requireArray,
+  requireString,
+  updateNode
+} from "./chunk-RVM33A4A.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/open.ts
+function handleOpen(input, agent) {
+  const project = optionalString(input?.project, "project");
+  const goal = optionalString(input?.goal, "goal");
+  if (!project) {
+    return { projects: listProjects() };
+  }
+  let root = getProjectRoot(project);
+  if (!root) {
+    root = createNode({
+      project,
+      summary: goal ?? project,
+      agent
+    });
+  }
+  const summary = getProjectSummary(project);
+  return { project, root, summary };
+}
+
+// src/edges.ts
+import { nanoid } from "nanoid";
+function wouldCreateCycle(from, to) {
+  const db = getDb();
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [to];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === from) return true;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const deps = db.prepare(
+      `SELECT to_node FROM edges WHERE from_node = ? AND type = 'depends_on'`
+    ).all(current);
+    for (const dep of deps) {
+      stack.push(dep.to_node);
+    }
+  }
+  return false;
+}
+function addEdge(input) {
+  const db = getDb();
+  const fromExists = db.prepare("SELECT id FROM nodes WHERE id = ?").get(input.from);
+  const toExists = db.prepare("SELECT id FROM nodes WHERE id = ?").get(input.to);
+  if (!fromExists) {
+    return { edge: null, rejected: true, reason: "node_not_found: " + input.from };
+  }
+  if (!toExists) {
+    return { edge: null, rejected: true, reason: "node_not_found: " + input.to };
+  }
+  const existing = db.prepare(
+    "SELECT id FROM edges WHERE from_node = ? AND to_node = ? AND type = ?"
+  ).get(input.from, input.to, input.type);
+  if (existing) {
+    return { edge: null, rejected: true, reason: "duplicate_edge" };
+  }
+  if (input.type === "depends_on") {
+    if (wouldCreateCycle(input.from, input.to)) {
+      return { edge: null, rejected: true, reason: "cycle_detected" };
+    }
+  }
+  const edge = {
+    id: nanoid(),
+    from_node: input.from,
+    to_node: input.to,
+    type: input.type,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  db.prepare(`
+    INSERT INTO edges (id, from_node, to_node, type, created_at)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(edge.id, edge.from_node, edge.to_node, edge.type, edge.created_at);
+  logEvent(input.from, input.agent, "edge_added", [
+    { field: "edge", before: null, after: { to: input.to, type: input.type } }
+  ]);
+  return { edge, rejected: false };
+}
+function removeEdge(from, to, type, agent) {
+  const db = getDb();
+  const result = db.prepare(
+    "DELETE FROM edges WHERE from_node = ? AND to_node = ? AND type = ?"
+  ).run(from, to, type);
+  if (result.changes > 0) {
+    logEvent(from, agent, "edge_removed", [
+      { field: "edge", before: { to, type }, after: null }
+    ]);
+    return true;
+  }
+  return false;
+}
+function getEdgesFrom(nodeId, type) {
+  const db = getDb();
+  if (type) {
+    return db.prepare("SELECT * FROM edges WHERE from_node = ? AND type = ?").all(nodeId, type);
+  }
+  return db.prepare("SELECT * FROM edges WHERE from_node = ?").all(nodeId);
+}
+function getEdgesTo(nodeId, type) {
+  const db = getDb();
+  if (type) {
+    return db.prepare("SELECT * FROM edges WHERE to_node = ? AND type = ?").all(nodeId, type);
+  }
+  return db.prepare("SELECT * FROM edges WHERE to_node = ?").all(nodeId);
+}
+function findNewlyActionable(project, resolvedNodeIds) {
+  const db = getDb();
+  if (resolvedNodeIds && resolvedNodeIds.length > 0) {
+    const placeholders = resolvedNodeIds.map(() => "?").join(",");
+    const rows2 = db.prepare(
+      `SELECT DISTINCT n.id, n.summary FROM nodes n
+         WHERE n.resolved = 0 AND n.project = ?
+         AND (
+           -- nodes that had a depends_on edge to one of the resolved nodes
+           n.id IN (
+             SELECT e.from_node FROM edges e
+             WHERE e.type = 'depends_on' AND e.to_node IN (${placeholders})
+           )
+           OR
+           -- parents of resolved nodes (might now be leaf if all children resolved)
+           n.id IN (SELECT parent FROM nodes WHERE id IN (${placeholders}) AND parent IS NOT NULL)
+         )
+         -- is a leaf (no unresolved children)
+         AND NOT EXISTS (
+           SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0
+         )
+         -- all deps resolved
+         AND NOT EXISTS (
+           SELECT 1 FROM edges e
+           JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+           WHERE e.from_node = n.id AND e.type = 'depends_on'
+         )`
+    ).all(project, ...resolvedNodeIds, ...resolvedNodeIds);
+    return rows2;
+  }
+  const rows = db.prepare(
+    `SELECT n.id, n.summary FROM nodes n
+       WHERE n.project = ? AND n.resolved = 0
+       AND NOT EXISTS (
+         SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM edges e
+         JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+         WHERE e.from_node = n.id AND e.type = 'depends_on'
+       )`
+  ).all(project);
+  return rows;
+}
+
+// src/tools/plan.ts
+function handlePlan(input, agent) {
+  const db = getDb();
+  const nodes = requireArray(input?.nodes, "nodes");
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    requireString(n.ref, `nodes[${i}].ref`);
+    requireString(n.summary, `nodes[${i}].summary`);
+  }
+  const refMap = /* @__PURE__ */ new Map();
+  const created = [];
+  const refs = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (refs.has(node.ref)) {
+      throw new Error(`Duplicate ref in batch: ${node.ref}`);
+    }
+    refs.add(node.ref);
+  }
+  const transaction = db.transaction(() => {
+    for (const nodeInput of nodes) {
+      let parentId;
+      if (nodeInput.parent_ref) {
+        parentId = refMap.get(nodeInput.parent_ref);
+        if (!parentId) {
+          const existing = getNode(nodeInput.parent_ref);
+          if (existing) {
+            parentId = existing.id;
+          } else {
+            throw new Error(
+              `parent_ref "${nodeInput.parent_ref}" is neither a batch ref nor an existing node ID`
+            );
+          }
+        }
+      }
+      let project;
+      if (parentId) {
+        const parentNode = getNode(parentId);
+        project = parentNode.project;
+      } else {
+        throw new Error(
+          `Node "${nodeInput.ref}" has no parent_ref. All planned nodes must have a parent (an existing node or a batch ref).`
+        );
+      }
+      const node = createNode({
+        project,
+        parent: parentId,
+        summary: nodeInput.summary,
+        context_links: nodeInput.context_links,
+        properties: nodeInput.properties,
+        agent
+      });
+      refMap.set(nodeInput.ref, node.id);
+      created.push({ ref: nodeInput.ref, id: node.id });
+    }
+    for (const nodeInput of nodes) {
+      if (!nodeInput.depends_on || nodeInput.depends_on.length === 0) continue;
+      const fromId = refMap.get(nodeInput.ref);
+      for (const dep of nodeInput.depends_on) {
+        let toId = refMap.get(dep);
+        if (!toId) {
+          const existing = getNode(dep);
+          if (existing) {
+            toId = existing.id;
+          } else {
+            throw new Error(
+              `depends_on "${dep}" in node "${nodeInput.ref}" is neither a batch ref nor an existing node ID`
+            );
+          }
+        }
+        const result = addEdge({
+          from: fromId,
+          to: toId,
+          type: "depends_on",
+          agent
+        });
+        if (result.rejected) {
+          throw new Error(
+            `Dependency edge from "${nodeInput.ref}" to "${dep}" rejected: ${result.reason}`
+          );
+        }
+      }
+    }
+  });
+  transaction();
+  return { created };
+}
+
+// src/tools/update.ts
+function handleUpdate(input, agent) {
+  const updates = requireArray(input?.updates, "updates");
+  for (let i = 0; i < updates.length; i++) {
+    requireString(updates[i].node_id, `updates[${i}].node_id`);
+    if (updates[i].add_evidence) {
+      for (let j = 0; j < updates[i].add_evidence.length; j++) {
+        requireString(updates[i].add_evidence[j].type, `updates[${i}].add_evidence[${j}].type`);
+        requireString(updates[i].add_evidence[j].ref, `updates[${i}].add_evidence[${j}].ref`);
+      }
+    }
+  }
+  const updated = [];
+  const resolvedIds = [];
+  let project = null;
+  for (const entry of updates) {
+    const node = updateNode({
+      node_id: entry.node_id,
+      agent,
+      resolved: entry.resolved,
+      state: entry.state,
+      summary: entry.summary,
+      properties: entry.properties,
+      add_context_links: entry.add_context_links,
+      remove_context_links: entry.remove_context_links,
+      add_evidence: entry.add_evidence
+    });
+    updated.push({ node_id: node.id, rev: node.rev });
+    if (entry.resolved === true) {
+      resolvedIds.push(node.id);
+      project = node.project;
+    }
+  }
+  const result = { updated };
+  if (resolvedIds.length > 0 && project) {
+    result.newly_actionable = findNewlyActionable(project, resolvedIds);
+  }
+  return result;
+}
+
+// src/tools/connect.ts
+function handleConnect(input, agent) {
+  const edges = requireArray(input?.edges, "edges");
+  for (let i = 0; i < edges.length; i++) {
+    requireString(edges[i].from, `edges[${i}].from`);
+    requireString(edges[i].to, `edges[${i}].to`);
+    requireString(edges[i].type, `edges[${i}].type`);
+  }
+  let applied = 0;
+  const rejected = [];
+  for (const edge of edges) {
+    if (edge.type === "parent") {
+      rejected.push({
+        from: edge.from,
+        to: edge.to,
+        reason: "parent_edges_not_allowed: use graph_restructure to reparent"
+      });
+      continue;
+    }
+    if (edge.remove) {
+      const removed = removeEdge(edge.from, edge.to, edge.type, agent);
+      if (removed) {
+        applied++;
+      } else {
+        rejected.push({
+          from: edge.from,
+          to: edge.to,
+          reason: "edge_not_found"
+        });
+      }
+    } else {
+      const result2 = addEdge({
+        from: edge.from,
+        to: edge.to,
+        type: edge.type,
+        agent
+      });
+      if (result2.rejected) {
+        rejected.push({
+          from: edge.from,
+          to: edge.to,
+          reason: result2.reason
+        });
+      } else {
+        applied++;
+      }
+    }
+  }
+  const result = { applied };
+  if (rejected.length > 0) {
+    result.rejected = rejected;
+  }
+  return result;
+}
+
+// src/tools/context.ts
+function buildNodeTree(nodeId, currentDepth, maxDepth) {
+  const node = getNodeOrThrow(nodeId);
+  const children = getChildren(nodeId);
+  const tree = {
+    id: node.id,
+    summary: node.summary,
+    resolved: node.resolved,
+    state: node.state
+  };
+  if (children.length === 0) {
+    return tree;
+  }
+  if (currentDepth < maxDepth) {
+    tree.children = children.map(
+      (child) => buildNodeTree(child.id, currentDepth + 1, maxDepth)
+    );
+  } else {
+    tree.child_count = children.length;
+  }
+  return tree;
+}
+function handleContext(input) {
+  const nodeId = requireString(input?.node_id, "node_id");
+  const depth = optionalNumber(input?.depth, "depth", 0, 10) ?? 2;
+  const node = getNodeOrThrow(nodeId);
+  const ancestors = getAncestors(nodeId);
+  const children = buildNodeTree(nodeId, 0, depth);
+  const depsOut = getEdgesFrom(nodeId, "depends_on");
+  const depsIn = getEdgesTo(nodeId, "depends_on");
+  const depends_on = depsOut.map((edge) => {
+    const target = getNode(edge.to_node);
+    return {
+      node: target,
+      satisfied: target?.resolved ?? false
+    };
+  });
+  const depended_by = depsIn.map((edge) => {
+    const source = getNode(edge.from_node);
+    return {
+      node: source,
+      satisfied: node.resolved
+    };
+  });
+  return { node, ancestors, children, depends_on, depended_by };
+}
+
+// src/tools/query.ts
+function getDescendantIds(nodeId) {
+  const db = getDb();
+  const rows = db.prepare(
+    `WITH RECURSIVE descendants(id) AS (
+        SELECT id FROM nodes WHERE parent = ?
+        UNION ALL
+        SELECT n.id FROM nodes n JOIN descendants d ON n.parent = d.id
+      )
+      SELECT id FROM descendants`
+  ).all(nodeId);
+  return rows.map((r) => r.id);
+}
+function handleQuery(input) {
+  const project = requireString(input?.project, "project");
+  const db = getDb();
+  const limit = Math.min(optionalNumber(input?.limit, "limit", 1, 100) ?? 20, 100);
+  const filter = input?.filter;
+  const cursor = optionalString(input?.cursor, "cursor");
+  const conditions = ["n.project = ?"];
+  const params = [project];
+  if (filter?.resolved !== void 0) {
+    conditions.push("n.resolved = ?");
+    params.push(filter.resolved ? 1 : 0);
+  }
+  if (filter?.text) {
+    conditions.push("n.summary LIKE ?");
+    params.push(`%${filter.text}%`);
+  }
+  if (filter?.ancestor) {
+    const descendantIds = getDescendantIds(filter.ancestor);
+    if (descendantIds.length === 0) {
+      return { nodes: [], total: 0 };
+    }
+    conditions.push(`n.id IN (${descendantIds.map(() => "?").join(",")})`);
+    params.push(...descendantIds);
+  }
+  if (filter?.has_evidence_type) {
+    conditions.push("n.evidence LIKE ?");
+    params.push(`%"type":"${filter.has_evidence_type}"%`);
+  }
+  if (filter?.is_leaf) {
+    conditions.push(
+      "NOT EXISTS (SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0)"
+    );
+  }
+  if (filter?.is_actionable) {
+    conditions.push("n.resolved = 0");
+    conditions.push(
+      "NOT EXISTS (SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0)"
+    );
+    conditions.push(
+      `NOT EXISTS (
+        SELECT 1 FROM edges e
+        JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+        WHERE e.from_node = n.id AND e.type = 'depends_on'
+      )`
+    );
+  }
+  if (filter?.is_blocked) {
+    conditions.push("n.resolved = 0");
+    conditions.push(
+      `EXISTS (
+        SELECT 1 FROM edges e
+        JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+        WHERE e.from_node = n.id AND e.type = 'depends_on'
+      )`
+    );
+  }
+  if (filter?.properties) {
+    for (const [key, value] of Object.entries(filter.properties)) {
+      conditions.push("json_extract(n.properties, ?) = ?");
+      params.push(`$.${key}`, value);
+    }
+  }
+  if (filter?.claimed_by !== void 0) {
+    if (filter.claimed_by === null) {
+      conditions.push(
+        "(json_extract(n.properties, '$._claimed_by') IS NULL)"
+      );
+    } else {
+      conditions.push("json_extract(n.properties, '$._claimed_by') = ?");
+      params.push(filter.claimed_by);
+    }
+  }
+  if (cursor) {
+    const [cursorTime, cursorId] = cursor.split("|");
+    conditions.push("(n.created_at > ? OR (n.created_at = ? AND n.id > ?))");
+    params.push(cursorTime, cursorTime, cursorId);
+  }
+  const whereClause = conditions.join(" AND ");
+  let orderBy;
+  switch (input.sort) {
+    case "depth":
+      orderBy = "n.created_at ASC, n.id ASC";
+      break;
+    case "recent":
+      orderBy = "n.updated_at DESC, n.id ASC";
+      break;
+    case "created":
+      orderBy = "n.created_at ASC, n.id ASC";
+      break;
+    case "readiness":
+    default:
+      orderBy = "n.updated_at ASC, n.id ASC";
+      break;
+  }
+  const countConditions = cursor ? conditions.slice(0, -1) : conditions;
+  const countParams = cursor ? params.slice(0, -3) : [...params];
+  const total = db.prepare(`SELECT COUNT(*) as count FROM nodes n WHERE ${countConditions.join(" AND ")}`).get(...countParams).count;
+  params.push(limit + 1);
+  const query = `SELECT * FROM nodes n WHERE ${whereClause} ORDER BY ${orderBy} LIMIT ?`;
+  const rows = db.prepare(query).all(...params);
+  const hasMore = rows.length > limit;
+  const slice = hasMore ? rows.slice(0, limit) : rows;
+  const nodes = slice.map((row) => ({
+    id: row.id,
+    summary: row.summary,
+    resolved: row.resolved === 1,
+    state: row.state ? JSON.parse(row.state) : null,
+    parent: row.parent,
+    depth: row.depth,
+    properties: JSON.parse(row.properties)
+  }));
+  const result = { nodes, total };
+  if (hasMore) {
+    const last = slice[slice.length - 1];
+    result.next_cursor = `${last.created_at}|${last.id}`;
+  }
+  return result;
+}
+
+// src/tools/next.ts
+function handleNext(input, agent, claimTtlMinutes = 60) {
+  const project = requireString(input?.project, "project");
+  const scope = optionalString(input?.scope, "scope");
+  const count = optionalNumber(input?.count, "count", 1, 50) ?? 1;
+  const claim = optionalBoolean(input?.claim, "claim") ?? false;
+  const db = getDb();
+  let scopeFilter = "";
+  const scopeParams = [];
+  if (scope) {
+    const descendantIds = db.prepare(
+      `WITH RECURSIVE descendants(id) AS (
+          SELECT id FROM nodes WHERE parent = ?
+          UNION ALL
+          SELECT n.id FROM nodes n JOIN descendants d ON n.parent = d.id
+        )
+        SELECT id FROM descendants`
+    ).all(scope);
+    if (descendantIds.length === 0) {
+      return { nodes: [] };
+    }
+    scopeFilter = `AND n.id IN (${descendantIds.map(() => "?").join(",")})`;
+    scopeParams.push(...descendantIds.map((d) => d.id));
+  }
+  let query = `
+    SELECT n.* FROM nodes n
+    WHERE n.project = ? AND n.resolved = 0
+    ${scopeFilter}
+    AND NOT EXISTS (
+      SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0
+    )
+    AND NOT EXISTS (
+      SELECT 1 FROM edges e
+      JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+      WHERE e.from_node = n.id AND e.type = 'depends_on'
+    )
+  `;
+  const params = [project, ...scopeParams];
+  const claimCutoff = new Date(
+    Date.now() - claimTtlMinutes * 60 * 1e3
+  ).toISOString();
+  query += `
+    AND (
+      json_extract(n.properties, '$._claimed_by') IS NULL
+      OR json_extract(n.properties, '$._claimed_by') = ?
+      OR json_extract(n.properties, '$._claimed_at') <= ?
+    )
+  `;
+  params.push(agent, claimCutoff);
+  if (input.filter) {
+    for (const [key, value] of Object.entries(input.filter)) {
+      query += " AND json_extract(n.properties, ?) = ?";
+      params.push(`$.${key}`, value);
+    }
+  }
+  query += `
+    ORDER BY
+      COALESCE(CAST(json_extract(n.properties, '$.priority') AS REAL), 0) DESC,
+      n.depth DESC,
+      n.updated_at ASC
+    LIMIT ?
+  `;
+  params.push(count);
+  const rows = db.prepare(query).all(...params);
+  const selected = rows.map((row) => ({ row }));
+  const results = selected.map(({ row }) => {
+    const node = getNode(row.id);
+    const ancestors = getAncestors(row.id);
+    const inherited = [];
+    for (const anc of ancestors) {
+      const ancNode = getNode(anc.id);
+      if (ancNode && ancNode.context_links.length > 0) {
+        inherited.push({ node_id: anc.id, links: ancNode.context_links });
+      }
+    }
+    const depEdges = getEdgesFrom(row.id, "depends_on");
+    const resolved_deps = depEdges.map((edge) => {
+      const depNode = getNode(edge.to_node);
+      if (!depNode || !depNode.resolved) return null;
+      return {
+        id: depNode.id,
+        summary: depNode.summary,
+        evidence: depNode.evidence
+      };
+    }).filter(Boolean);
+    if (claim) {
+      updateNode({
+        node_id: node.id,
+        agent,
+        properties: {
+          _claimed_by: agent,
+          _claimed_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    }
+    return {
+      node: claim ? getNode(row.id) : node,
+      ancestors: ancestors.map((a) => ({ id: a.id, summary: a.summary })),
+      context_links: {
+        self: node.context_links,
+        inherited
+      },
+      resolved_deps
+    };
+  });
+  return { nodes: results };
+}
+
+// src/tools/restructure.ts
+function wouldCreateParentCycle(nodeId, newParentId) {
+  const db = getDb();
+  let current = newParentId;
+  while (current) {
+    if (current === nodeId) return true;
+    const row = db.prepare("SELECT parent FROM nodes WHERE id = ?").get(current);
+    current = row?.parent ?? null;
+  }
+  return false;
+}
+function getAllDescendants(nodeId) {
+  const ids = [];
+  const stack = [nodeId];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const children = getChildren(current);
+    for (const child of children) {
+      ids.push(child.id);
+      stack.push(child.id);
+    }
+  }
+  return ids;
+}
+function recomputeSubtreeDepth(nodeId, newDepth) {
+  const db = getDb();
+  db.prepare("UPDATE nodes SET depth = ? WHERE id = ?").run(newDepth, nodeId);
+  const children = db.prepare("SELECT id FROM nodes WHERE parent = ?").all(nodeId);
+  for (const child of children) {
+    recomputeSubtreeDepth(child.id, newDepth + 1);
+  }
+}
+function handleMove(op, agent) {
+  const db = getDb();
+  const node = getNodeOrThrow(op.node_id);
+  const newParent = getNodeOrThrow(op.new_parent);
+  if (wouldCreateParentCycle(op.node_id, op.new_parent)) {
+    throw new Error(
+      `Move would create cycle: ${op.node_id} cannot be moved under ${op.new_parent}`
+    );
+  }
+  const oldParent = node.parent;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare("UPDATE nodes SET parent = ?, updated_at = ? WHERE id = ?").run(
+    op.new_parent,
+    now,
+    op.node_id
+  );
+  recomputeSubtreeDepth(op.node_id, newParent.depth + 1);
+  logEvent(op.node_id, agent, "moved", [
+    { field: "parent", before: oldParent, after: op.new_parent }
+  ]);
+  return { node_id: op.node_id, result: `moved under ${op.new_parent}` };
+}
+function handleMerge(op, agent) {
+  const db = getDb();
+  const source = getNodeOrThrow(op.source);
+  const target = getNodeOrThrow(op.target);
+  const movedChildren = db.prepare("SELECT id FROM nodes WHERE parent = ?").all(op.source);
+  db.prepare("UPDATE nodes SET parent = ?, updated_at = ? WHERE parent = ?").run(
+    op.target,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    op.source
+  );
+  for (const child of movedChildren) {
+    recomputeSubtreeDepth(child.id, target.depth + 1);
+  }
+  const targetEvidence = [...target.evidence, ...source.evidence];
+  db.prepare("UPDATE nodes SET evidence = ?, updated_at = ? WHERE id = ?").run(
+    JSON.stringify(targetEvidence),
+    (/* @__PURE__ */ new Date()).toISOString(),
+    op.target
+  );
+  const sourceOutEdges = getEdgesFrom(op.source);
+  const sourceInEdges = getEdgesTo(op.source);
+  for (const edge of sourceOutEdges) {
+    const existing = db.prepare(
+      "SELECT id FROM edges WHERE from_node = ? AND to_node = ? AND type = ?"
+    ).get(op.target, edge.to_node, edge.type);
+    if (!existing) {
+      db.prepare(
+        "UPDATE edges SET from_node = ? WHERE id = ?"
+      ).run(op.target, edge.id);
+    } else {
+      db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
+    }
+  }
+  for (const edge of sourceInEdges) {
+    const existing = db.prepare(
+      "SELECT id FROM edges WHERE from_node = ? AND to_node = ? AND type = ?"
+    ).get(edge.from_node, op.target, edge.type);
+    if (!existing) {
+      db.prepare(
+        "UPDATE edges SET to_node = ? WHERE id = ?"
+      ).run(op.target, edge.id);
+    } else {
+      db.prepare("DELETE FROM edges WHERE id = ?").run(edge.id);
+    }
+  }
+  logEvent(op.target, agent, "merged", [
+    { field: "merged_from", before: null, after: op.source }
+  ]);
+  logEvent(op.source, agent, "merged_into", [
+    { field: "merged_into", before: null, after: op.target }
+  ]);
+  db.prepare("DELETE FROM edges WHERE from_node = ? OR to_node = ?").run(
+    op.source,
+    op.source
+  );
+  db.prepare("DELETE FROM nodes WHERE id = ?").run(op.source);
+  return { node_id: op.target, result: `merged ${op.source} into ${op.target}` };
+}
+function handleDrop(op, agent) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const descendants = getAllDescendants(op.node_id);
+  const allIds = [op.node_id, ...descendants];
+  for (const id of allIds) {
+    const node = getNode(id);
+    if (!node || node.resolved) continue;
+    updateNode({
+      node_id: id,
+      agent,
+      resolved: true,
+      add_evidence: [{ type: "dropped", ref: op.reason }]
+    });
+    logEvent(id, agent, "dropped", [
+      { field: "resolved", before: false, after: true },
+      { field: "reason", before: null, after: op.reason }
+    ]);
+  }
+  return {
+    node_id: op.node_id,
+    result: `dropped ${allIds.length} node(s): ${op.reason}`
+  };
+}
+function handleRestructure(input, agent) {
+  const operations = requireArray(input?.operations, "operations");
+  for (let i = 0; i < operations.length; i++) {
+    const op = operations[i];
+    requireString(op.op, `operations[${i}].op`);
+    if (op.op === "move") {
+      requireString(op.node_id, `operations[${i}].node_id`);
+      requireString(op.new_parent, `operations[${i}].new_parent`);
+    } else if (op.op === "merge") {
+      requireString(op.source, `operations[${i}].source`);
+      requireString(op.target, `operations[${i}].target`);
+    } else if (op.op === "drop") {
+      requireString(op.node_id, `operations[${i}].node_id`);
+      requireString(op.reason, `operations[${i}].reason`);
+    } else {
+      throw new Error(`Unknown operation: ${op.op}`);
+    }
+  }
+  const db = getDb();
+  let applied = 0;
+  const details = [];
+  let project = null;
+  const transaction = db.transaction(() => {
+    for (const op of operations) {
+      let detail;
+      switch (op.op) {
+        case "move":
+          detail = handleMove(op, agent);
+          project = getNode(op.node_id)?.project ?? project;
+          break;
+        case "merge":
+          detail = handleMerge(op, agent);
+          project = getNode(op.target)?.project ?? project;
+          break;
+        case "drop":
+          detail = handleDrop(op, agent);
+          project = getNode(op.node_id)?.project ?? project;
+          break;
+        default:
+          throw new Error(`Unknown operation: ${op.op}`);
+      }
+      details.push({ op: op.op, ...detail });
+      applied++;
+    }
+  });
+  transaction();
+  const result = { applied, details };
+  if (project) {
+    const actionable = findNewlyActionable(project);
+    if (actionable.length > 0) {
+      result.newly_actionable = actionable;
+    }
+  }
+  return result;
+}
+
+// src/tools/history.ts
+function handleHistory(input) {
+  const nodeId = requireString(input?.node_id, "node_id");
+  const limit = optionalNumber(input?.limit, "limit", 1, 100) ?? 20;
+  const cursor = optionalString(input?.cursor, "cursor");
+  getNodeOrThrow(nodeId);
+  const { events, next_cursor } = getEvents(nodeId, limit, cursor);
+  const result = {
+    events: events.map((e) => ({
+      timestamp: e.timestamp,
+      agent: e.agent,
+      action: e.action,
+      changes: e.changes
+    }))
+  };
+  if (next_cursor) {
+    result.next_cursor = next_cursor;
+  }
+  return result;
+}
+
+// src/tools/onboard.ts
+function handleOnboard(input) {
+  const project = requireString(input?.project, "project");
+  const evidenceLimit = optionalNumber(input?.evidence_limit, "evidence_limit", 1, 50) ?? 20;
+  const db = getDb();
+  const root = getProjectRoot(project);
+  if (!root) {
+    throw new EngineError("project_not_found", `Project not found: ${project}`);
+  }
+  const summary = getProjectSummary(project);
+  const topChildren = db.prepare("SELECT * FROM nodes WHERE parent = ? ORDER BY created_at ASC").all(root.id);
+  const tree = topChildren.map((child) => {
+    const grandchildren = db.prepare(
+      `SELECT id, summary, resolved,
+         (SELECT COUNT(*) FROM nodes gc WHERE gc.parent = n.id) as child_count
+         FROM nodes n WHERE parent = ? ORDER BY created_at ASC`
+    ).all(child.id);
+    return {
+      id: child.id,
+      summary: child.summary,
+      resolved: child.resolved === 1,
+      children: grandchildren.map((gc) => ({
+        id: gc.id,
+        summary: gc.summary,
+        resolved: gc.resolved === 1,
+        child_count: gc.child_count
+      }))
+    };
+  });
+  const allNodes = db.prepare("SELECT id, summary, evidence FROM nodes WHERE project = ? AND resolved = 1 AND evidence != '[]'").all(project);
+  const allEvidence = [];
+  for (const node of allNodes) {
+    const evidence = JSON.parse(node.evidence);
+    for (const ev of evidence) {
+      allEvidence.push({
+        node_id: node.id,
+        node_summary: node.summary,
+        type: ev.type,
+        ref: ev.ref,
+        agent: ev.agent,
+        timestamp: ev.timestamp
+      });
+    }
+  }
+  allEvidence.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  const recent_evidence = allEvidence.slice(0, evidenceLimit);
+  const linkRows = db.prepare("SELECT context_links FROM nodes WHERE project = ? AND context_links != '[]'").all(project);
+  const linkSet = /* @__PURE__ */ new Set();
+  for (const row of linkRows) {
+    const links = JSON.parse(row.context_links);
+    for (const link of links) {
+      linkSet.add(link);
+    }
+  }
+  const context_links = [...linkSet].sort();
+  const actionableRows = db.prepare(
+    `SELECT n.id, n.summary, n.properties FROM nodes n
+       WHERE n.project = ? AND n.resolved = 0
+       AND NOT EXISTS (
+         SELECT 1 FROM nodes child WHERE child.parent = n.id AND child.resolved = 0
+       )
+       AND NOT EXISTS (
+         SELECT 1 FROM edges e
+         JOIN nodes dep ON dep.id = e.to_node AND dep.resolved = 0
+         WHERE e.from_node = n.id AND e.type = 'depends_on'
+       )
+       ORDER BY
+         COALESCE(CAST(json_extract(n.properties, '$.priority') AS REAL), 0) DESC,
+         n.depth DESC,
+         n.updated_at ASC
+       LIMIT 10`
+  ).all(project);
+  const actionable = actionableRows.map((row) => ({
+    id: row.id,
+    summary: row.summary,
+    properties: JSON.parse(row.properties)
+  }));
+  return {
+    project,
+    summary,
+    tree,
+    recent_evidence,
+    context_links,
+    actionable
+  };
+}
+
+// src/tools/agent-config.ts
+var AGENT_PROMPT = `---
+name: graph
+description: Use this agent for tasks tracked in Graph. Enforces the claim-work-resolve workflow \u2014 always checks graph_next before working, adds new work to the graph before executing, and resolves with evidence.
+tools: Read, Edit, Write, Bash, Glob, Grep, Task(Explore)
+model: sonnet
+---
+
+You are a graph-optimized agent. You execute tasks tracked in a Graph project. Follow this workflow strictly.
+
+# Workflow
+
+## 1. ORIENT
+On your first call, orient yourself:
+\`\`\`
+graph_onboard({ project: "<project-name>" })
+\`\`\`
+Read the summary, recent evidence, context links, and actionable tasks. Understand what was done and what's left.
+
+## 2. CLAIM
+Get your next task:
+\`\`\`
+graph_next({ project: "<project-name>", claim: true })
+\`\`\`
+Read the task summary, ancestor chain (for scope), resolved dependencies (for context on what was done before you), and context links (for files to look at).
+
+## 3. PLAN
+If you discover work that isn't in the graph, add it BEFORE executing:
+\`\`\`
+graph_plan({ nodes: [{ ref: "new-work", parent_ref: "<parent-id>", summary: "..." }] })
+\`\`\`
+Never execute ad-hoc work. The graph is the source of truth.
+
+## 4. WORK
+Execute the claimed task. While working:
+- Annotate key code changes with \`// [sl:nodeId]\` where nodeId is the task you're working on
+- This creates a traceable link from code back to the task, its evidence, and its history
+
+## 5. RESOLVE
+When done, resolve the task with evidence:
+\`\`\`
+graph_update({ updates: [{
+  node_id: "<task-id>",
+  resolved: true,
+  add_evidence: [
+    { type: "note", ref: "What you did and why" },
+    { type: "git", ref: "<commit-hash> \u2014 <summary>" },
+    { type: "test", ref: "Test results" }
+  ],
+  add_context_links: ["path/to/files/you/touched"]
+}] })
+\`\`\`
+Evidence is mandatory. At minimum, include one note explaining what you did.
+
+## 6. LOOP
+Check the response for \`newly_actionable\` tasks. Then call \`graph_next\` again for your next task. Repeat until no actionable tasks remain.
+
+# Rules
+
+- NEVER start work without a claimed task
+- NEVER resolve without evidence
+- NEVER execute ad-hoc work \u2014 add it to the graph first via graph_plan
+- ALWAYS include context_links for files you modified when resolving
+- If a parent task becomes actionable (all children resolved), resolve it with a summary of what its children accomplished
+- If you're approaching context limits, ensure your current task's state is captured (update with evidence even if not fully resolved) so the next agent can pick up where you left off
+`;
+function handleAgentConfig(dbPath) {
+  const tier = getLicenseTier(dbPath);
+  if (tier !== "pro") {
+    throw new EngineError(
+      "free_tier_limit",
+      "The graph-optimized agent configuration is a pro feature. Activate a license key to unlock it."
+    );
+  }
+  return {
+    agent_file: AGENT_PROMPT,
+    install_path: ".claude/agents/graph.md",
+    instructions: "Save the agent_file content to .claude/agents/graph.md in your project root. Claude Code will automatically discover it and use it when tasks match the agent description."
+  };
+}
+
+// src/gates.ts
+var FREE_LIMITS = {
+  maxProjects: 1,
+  maxNodesPerProject: 50,
+  onboardEvidenceLimit: 5,
+  scopeEnabled: false
+};
+function checkNodeLimit(tier, project, adding) {
+  if (tier === "pro") return;
+  const db = getDb();
+  const { count } = db.prepare("SELECT COUNT(*) as count FROM nodes WHERE project = ?").get(project);
+  if (count + adding > FREE_LIMITS.maxNodesPerProject) {
+    throw new EngineError(
+      "free_tier_limit",
+      `Free tier is limited to ${FREE_LIMITS.maxNodesPerProject} nodes per project. Current: ${count}, adding: ${adding}. Activate a license key to remove this limit.`
+    );
+  }
+}
+function checkProjectLimit(tier) {
+  if (tier === "pro") return;
+  const db = getDb();
+  const { count } = db.prepare("SELECT COUNT(*) as count FROM nodes WHERE parent IS NULL").get();
+  if (count >= FREE_LIMITS.maxProjects) {
+    throw new EngineError(
+      "free_tier_limit",
+      `Free tier is limited to ${FREE_LIMITS.maxProjects} project. Activate a license key to create unlimited projects.`
+    );
+  }
+}
+function capEvidenceLimit(tier, requested) {
+  const max = tier === "pro" ? requested ?? 20 : FREE_LIMITS.onboardEvidenceLimit;
+  return Math.min(requested ?? max, tier === "pro" ? 50 : FREE_LIMITS.onboardEvidenceLimit);
+}
+function checkScope(tier, scope) {
+  if (tier === "pro") return scope;
+  return void 0;
+}
+
+// src/server.ts
+var AGENT_IDENTITY = process.env.GRAPH_AGENT ?? "default-agent";
+var DB_PATH = process.env.GRAPH_DB ?? "./graph.db";
+var CLAIM_TTL = parseInt(process.env.GRAPH_CLAIM_TTL ?? "60", 10);
+var TOOLS = [
+  {
+    name: "graph_open",
+    description: "Open an existing project or create a new one. Omit 'project' to list all projects. Returns project root node and summary stats (total, resolved, unresolved, blocked, actionable counts).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: {
+          type: "string",
+          description: "Project name (e.g. 'my-project'). Omit to list all projects."
+        },
+        goal: {
+          type: "string",
+          description: "Project goal/description. Used on creation only."
+        }
+      }
+    }
+  },
+  {
+    name: "graph_plan",
+    description: "Batch create nodes with parent-child and dependency relationships in one atomic call. Use for decomposing work into subtrees. Each node needs a temp 'ref' for intra-batch references. parent_ref and depends_on can reference batch refs or existing node IDs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        nodes: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              ref: {
+                type: "string",
+                description: "Temp ID for referencing within this batch"
+              },
+              parent_ref: {
+                type: "string",
+                description: "Parent: a ref from this batch OR an existing node ID"
+              },
+              summary: { type: "string" },
+              context_links: {
+                type: "array",
+                items: { type: "string" },
+                description: "Pointers to files, commits, URLs"
+              },
+              depends_on: {
+                type: "array",
+                items: { type: "string" },
+                description: "Refs within batch OR existing node IDs this depends on"
+              },
+              properties: {
+                type: "object",
+                description: "Freeform key-value properties"
+              }
+            },
+            required: ["ref", "summary"]
+          },
+          description: "Nodes to create"
+        }
+      },
+      required: ["nodes"]
+    }
+  },
+  {
+    name: "graph_next",
+    description: "Get the next actionable node \u2014 an unresolved leaf with all dependencies resolved. Ranked by priority (from properties), depth, and least-recently-updated. Returns the node with ancestor chain, context links, and resolved dependency info. Use claim=true to soft-lock the node. When modifying code for this task, annotate key changes with // [sl:nodeId] so future agents can trace code back to this task.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name (e.g. 'my-project'), not a node ID" },
+        scope: {
+          type: "string",
+          description: "Node ID to scope results to. Only returns actionable descendants of this node."
+        },
+        filter: {
+          type: "object",
+          description: "Match against node properties"
+        },
+        count: {
+          type: "number",
+          description: "Return top N nodes (default 1)"
+        },
+        claim: {
+          type: "boolean",
+          description: "If true, soft-lock returned nodes with agent identity"
+        }
+      },
+      required: ["project"]
+    }
+  },
+  {
+    name: "graph_context",
+    description: "Deep-read a node and its neighborhood: ancestors (scope chain), children tree (to configurable depth), dependency graph (what it depends on, what depends on it). Look for // [sl:nodeId] annotations in source files to find code tied to specific tasks.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node_id: { type: "string", description: "Node ID to inspect" },
+        depth: {
+          type: "number",
+          description: "Levels of children to return (default 2)"
+        }
+      },
+      required: ["node_id"]
+    }
+  },
+  {
+    name: "graph_update",
+    description: "Update one or more nodes. Can change resolved, state, summary, properties (merged), context_links, and add evidence. When resolving nodes, returns newly_actionable \u2014 nodes that became unblocked. ENFORCED: Resolving a node requires evidence \u2014 the engine rejects resolved=true if the node has no existing evidence and no add_evidence in the call. Include at least one add_evidence entry (type: 'git' for commits, 'note' for what was done and why, 'test' for results). Also add context_links to files you modified.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        updates: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              node_id: { type: "string" },
+              resolved: { type: "boolean" },
+              state: { description: "Agent-defined state, any type" },
+              summary: { type: "string" },
+              properties: {
+                type: "object",
+                description: "Merged into existing. Set a key to null to delete it."
+              },
+              add_context_links: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files modified or created for this task. Add when resolving so future agents know what was touched."
+              },
+              remove_context_links: {
+                type: "array",
+                items: { type: "string" }
+              },
+              add_evidence: {
+                type: "array",
+                description: "Evidence of work done. Always add when resolving. Types: 'git' (commit hash + summary), 'note' (what was implemented and why), 'test' (test results).",
+                items: {
+                  type: "object",
+                  properties: {
+                    type: { type: "string", description: "Evidence type: git, note, test, or custom" },
+                    ref: { type: "string", description: "The evidence content \u2014 commit ref, implementation note, test result" }
+                  },
+                  required: ["type", "ref"]
+                }
+              }
+            },
+            required: ["node_id"]
+          }
+        }
+      },
+      required: ["updates"]
+    }
+  },
+  {
+    name: "graph_connect",
+    description: "Add or remove edges between nodes. Types: 'depends_on' (with cycle detection), 'relates_to', or custom. Parent edges not allowed \u2014 use graph_restructure for reparenting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        edges: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              from: { type: "string", description: "Source node ID" },
+              to: { type: "string", description: "Target node ID" },
+              type: {
+                type: "string",
+                description: "'depends_on', 'relates_to', or custom"
+              },
+              remove: {
+                type: "boolean",
+                description: "True to remove this edge"
+              }
+            },
+            required: ["from", "to", "type"]
+          }
+        }
+      },
+      required: ["edges"]
+    }
+  },
+  {
+    name: "graph_query",
+    description: "Search and filter nodes. Filters: resolved, properties, text, ancestor (descendants of), is_leaf, is_actionable, is_blocked, claimed_by. Supports sorting and cursor pagination.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name (e.g. 'my-project'), not a node ID" },
+        filter: {
+          type: "object",
+          properties: {
+            resolved: { type: "boolean" },
+            properties: { type: "object" },
+            text: { type: "string", description: "Substring match on summary" },
+            ancestor: {
+              type: "string",
+              description: "Return all descendants of this node"
+            },
+            has_evidence_type: { type: "string" },
+            is_leaf: { type: "boolean" },
+            is_actionable: { type: "boolean" },
+            is_blocked: { type: "boolean" },
+            claimed_by: {
+              type: ["string", "null"],
+              description: "Filter by claim. null = unclaimed."
+            }
+          }
+        },
+        sort: {
+          type: "string",
+          enum: ["readiness", "depth", "recent", "created"]
+        },
+        limit: { type: "number", description: "Max results (default 20, max 100)" },
+        cursor: { type: "string", description: "Pagination cursor" }
+      },
+      required: ["project"]
+    }
+  },
+  {
+    name: "graph_restructure",
+    description: "Modify graph structure: move (reparent), merge (combine two nodes), drop (resolve node + subtree with reason). Atomic. Reports newly_actionable nodes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              op: {
+                type: "string",
+                enum: ["move", "merge", "drop"]
+              },
+              node_id: { type: "string", description: "For move and drop" },
+              new_parent: { type: "string", description: "For move" },
+              source: { type: "string", description: "For merge: node to absorb" },
+              target: {
+                type: "string",
+                description: "For merge: node that survives"
+              },
+              reason: { type: "string", description: "For drop: why" }
+            },
+            required: ["op"]
+          }
+        }
+      },
+      required: ["operations"]
+    }
+  },
+  {
+    name: "graph_history",
+    description: "Read the audit trail for a node. Shows who changed what, when, and why. Useful for understanding past decisions across sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node_id: { type: "string" },
+        limit: { type: "number", description: "Max events (default 20)" },
+        cursor: { type: "string", description: "Pagination cursor" }
+      },
+      required: ["node_id"]
+    }
+  },
+  {
+    name: "graph_onboard",
+    description: "Single-call orientation for new agents joining a project. Returns project summary, tree structure (depth 2), recent evidence from resolved nodes (knowledge transfer), all context links, and actionable tasks. Use this as your first call when starting work on an existing project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name (e.g. 'my-project')" },
+        evidence_limit: {
+          type: "number",
+          description: "Max evidence entries to return (default 20, max 50)"
+        }
+      },
+      required: ["project"]
+    }
+  },
+  {
+    name: "graph_agent_config",
+    description: "Returns the graph-optimized agent configuration file for Claude Code. Pro tier only. Save the returned content to .claude/agents/graph.md to enable the graph workflow agent.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+async function startServer() {
+  initDb(DB_PATH);
+  const tier = getLicenseTier(DB_PATH);
+  const server = new Server(
+    { name: "graph", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let result;
+      switch (name) {
+        case "graph_open": {
+          const openArgs = args;
+          if (openArgs?.project) {
+            const { getProjectRoot: getProjectRoot2 } = await import("./nodes-75II37NJ.js");
+            if (!getProjectRoot2(openArgs.project)) {
+              checkProjectLimit(tier);
+            }
+          }
+          result = handleOpen(openArgs, AGENT_IDENTITY);
+          break;
+        }
+        case "graph_plan": {
+          const planArgs = args;
+          if (planArgs?.nodes?.length > 0) {
+            const { getNode: getNode2 } = await import("./nodes-75II37NJ.js");
+            const firstParent = planArgs.nodes[0]?.parent_ref;
+            if (firstParent && typeof firstParent === "string" && !planArgs.nodes.some((n) => n.ref === firstParent)) {
+              const parentNode = getNode2(firstParent);
+              if (parentNode) {
+                checkNodeLimit(tier, parentNode.project, planArgs.nodes.length);
+              }
+            }
+          }
+          result = handlePlan(planArgs, AGENT_IDENTITY);
+          break;
+        }
+        case "graph_next": {
+          const nextArgs = args;
+          if (nextArgs?.scope) {
+            nextArgs.scope = checkScope(tier, nextArgs.scope);
+          }
+          result = handleNext(nextArgs, AGENT_IDENTITY, CLAIM_TTL);
+          break;
+        }
+        case "graph_context":
+          result = handleContext(args);
+          break;
+        case "graph_update":
+          result = handleUpdate(args, AGENT_IDENTITY);
+          break;
+        case "graph_connect":
+          result = handleConnect(args, AGENT_IDENTITY);
+          break;
+        case "graph_query":
+          result = handleQuery(args);
+          break;
+        case "graph_restructure":
+          result = handleRestructure(args, AGENT_IDENTITY);
+          break;
+        case "graph_history":
+          result = handleHistory(args);
+          break;
+        case "graph_onboard": {
+          const onboardArgs = args;
+          onboardArgs.evidence_limit = capEvidenceLimit(tier, onboardArgs?.evidence_limit);
+          result = handleOnboard(onboardArgs);
+          break;
+        }
+        case "graph_agent_config":
+          result = handleAgentConfig(DB_PATH);
+          break;
+        default:
+          return {
+            content: [
+              { type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }
+            ],
+            isError: true
+          };
+      }
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = error instanceof ValidationError ? "validation_error" : error instanceof EngineError ? error.code : "error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: message, code })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.on("SIGINT", () => {
+    closeDb();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    closeDb();
+    process.exit(0);
+  });
+}
+export {
+  startServer
+};
+//# sourceMappingURL=server-7IB2VIMK.js.map