0agent 1.0.2 → 1.0.4

package/dist/daemon.mjs

@@ -0,0 +1,2644 @@
+// packages/daemon/src/ZeroAgentDaemon.ts
+import { writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+
+// packages/core/src/graph/GraphNode.ts
+function createNode(params) {
+  const now = Date.now();
+  return {
+    id: params.id,
+    graph_id: params.graph_id,
+    label: params.label,
+    type: params.type,
+    created_at: now,
+    last_seen: now,
+    visit_count: 1,
+    metadata: params.metadata ?? {},
+    subgraph_id: params.subgraph_id ?? null,
+    embedding: null,
+    embedding_model: null,
+    embedding_at: null,
+    content: params.content ?? []
+  };
+}
+
+// packages/core/src/graph/SubGraph.ts
+var SubGraph = class _SubGraph {
+  id;
+  rootEntityId;
+  nodes;
+  edges;
+  constructor(id, rootEntityId) {
+    this.id = id;
+    this.rootEntityId = rootEntityId;
+    this.nodes = /* @__PURE__ */ new Map();
+    this.edges = /* @__PURE__ */ new Map();
+  }
+  addNode(node) {
+    this.nodes.set(node.id, node);
+  }
+  addEdge(edge) {
+    this.edges.set(edge.id, edge);
+  }
+  getNode(id) {
+    return this.nodes.get(id);
+  }
+  getEdge(id) {
+    return this.edges.get(id);
+  }
+  /** Remove a node and all edges connected to it. */
+  removeNode(id) {
+    this.nodes.delete(id);
+    for (const [edgeId, edge] of this.edges) {
+      if (edge.from_node === id || edge.to_node === id) {
+        this.edges.delete(edgeId);
+      }
+    }
+  }
+  removeEdge(id) {
+    this.edges.delete(id);
+  }
+  getNodes() {
+    return Array.from(this.nodes.values());
+  }
+  getEdges() {
+    return Array.from(this.edges.values());
+  }
+  getEdgesFrom(nodeId) {
+    const result = [];
+    for (const edge of this.edges.values()) {
+      if (edge.from_node === nodeId) {
+        result.push(edge);
+      }
+    }
+    return result;
+  }
+  getEdgesTo(nodeId) {
+    const result = [];
+    for (const edge of this.edges.values()) {
+      if (edge.to_node === nodeId) {
+        result.push(edge);
+      }
+    }
+    return result;
+  }
+  get nodeCount() {
+    return this.nodes.size;
+  }
+  get edgeCount() {
+    return this.edges.size;
+  }
+  /** Serialize to a plain object for snapshot injection into subagents. */
+  toSnapshot() {
+    return {
+      id: this.id,
+      rootEntityId: this.rootEntityId,
+      nodes: this.getNodes(),
+      edges: this.getEdges()
+    };
+  }
+  static fromSnapshot(snapshot) {
+    const sg = new _SubGraph(snapshot.id, snapshot.rootEntityId);
+    for (const node of snapshot.nodes) {
+      sg.addNode(node);
+    }
+    for (const edge of snapshot.edges) {
+      sg.addEdge(edge);
+    }
+    return sg;
+  }
+};
+
+// packages/core/src/graph/KnowledgeGraph.ts
+var KnowledgeGraph = class {
+  adapter;
+  // HNSWIndex is optional — semantic queries return empty if not set
+  hnswIndex;
+  constructor(adapter, hnswIndex) {
+    this.adapter = adapter;
+    this.hnswIndex = hnswIndex ?? null;
+  }
+  // ─── Node CRUD ────────────────────────────
+  addNode(node) {
+    this.adapter.insertNode(node);
+    if (node.embedding && this.hnswIndex) {
+      this.hnswIndex.add(node.id, node.embedding);
+    }
+  }
+  getNode(id) {
+    return this.adapter.getNode(id);
+  }
+  updateNode(id, updates) {
+    const existing = this.adapter.getNode(id);
+    if (!existing) {
+      throw new Error(`Node not found: ${id}`);
+    }
+    if (updates.label !== void 0) {
+      existing.label = updates.label;
+    }
+    if (updates.metadata !== void 0) {
+      existing.metadata = updates.metadata;
+    }
+    if (updates.embedding !== void 0) {
+      existing.embedding = updates.embedding;
+      if (updates.embedding && this.hnswIndex) {
+        this.hnswIndex.add(id, updates.embedding);
+      }
+    }
+    if (updates.embedding_model !== void 0) {
+      existing.embedding_model = updates.embedding_model;
+    }
+    if (updates.embedding_at !== void 0) {
+      existing.embedding_at = updates.embedding_at;
+    }
+    this.adapter.deleteNode(id);
+    this.adapter.insertNode(existing);
+  }
+  touchNode(id) {
+    this.adapter.updateNodeLastSeen(id, Date.now());
+  }
+  deleteNode(id) {
+    this.adapter.deleteNode(id);
+    if (this.hnswIndex) {
+      try {
+        this.hnswIndex.remove(id);
+      } catch {
+      }
+    }
+  }
+  // ─── Node Content ─────────────────────────
+  addContent(nodeId, content) {
+    const node = this.adapter.getNode(nodeId);
+    if (!node) {
+      throw new Error(`Node not found: ${nodeId}`);
+    }
+    this.adapter.insertNodeContent(content);
+  }
+  getContent(nodeId) {
+    return this.adapter.getNodeContent(nodeId);
+  }
+  // ─── Edge CRUD ────────────────────────────
+  addEdge(edge) {
+    this.adapter.insertEdge(edge);
+  }
+  getEdge(id) {
+    return this.adapter.getEdge(id);
+  }
+  deleteEdge(id) {
+    this.adapter.deleteEdge(id);
+  }
+  getEdgesFrom(nodeId) {
+    return this.adapter.getEdgesByNode(nodeId, "from");
+  }
+  getEdgesTo(nodeId) {
+    return this.adapter.getEdgesByNode(nodeId, "to");
+  }
+  getEdgesByNode(nodeId, direction) {
+    return this.adapter.getEdgesByNode(nodeId, direction);
+  }
+  getEdgesBetween(fromId, toId) {
+    const edges = this.adapter.getEdgesByNode(fromId, "from");
+    return edges.filter((e) => e.to_node === toId);
+  }
+  getAllEdges(graphId) {
+    return this.adapter.getAllEdges(graphId);
+  }
+  // ─── Subgraph ─────────────────────────────
+  /**
+   * BFS from entity node, loading nodes + edges up to `depth` hops.
+   */
+  getSubGraph(entityId, depth = 2) {
+    const rootNode = this.adapter.getNode(entityId);
+    if (!rootNode) {
+      throw new Error(`Entity node not found: ${entityId}`);
+    }
+    const subgraph = new SubGraph(entityId, entityId);
+    subgraph.addNode(rootNode);
+    let frontier = /* @__PURE__ */ new Set([entityId]);
+    const visited = /* @__PURE__ */ new Set([entityId]);
+    for (let d = 0; d < depth; d++) {
+      const nextFrontier = /* @__PURE__ */ new Set();
+      for (const nodeId of frontier) {
+        const outEdges = this.adapter.getEdgesByNode(nodeId, "both");
+        for (const edge of outEdges) {
+          subgraph.addEdge(edge);
+          const neighborId = edge.from_node === nodeId ? edge.to_node : edge.from_node;
+          if (!visited.has(neighborId)) {
+            visited.add(neighborId);
+            const neighborNode = this.adapter.getNode(neighborId);
+            if (neighborNode) {
+              subgraph.addNode(neighborNode);
+              nextFrontier.add(neighborId);
+            }
+          }
+        }
+      }
+      frontier = nextFrontier;
+      if (frontier.size === 0) break;
+    }
+    return subgraph;
+  }
+  // ─── Query ────────────────────────────────
+  queryStructural(opts) {
+    const results = [];
+    const limit = opts.limit ?? 50;
+    if (opts.from_node) {
+      let edges = this.adapter.getEdgesByNode(opts.from_node, "from");
+      if (opts.edge_type) {
+        edges = edges.filter((e) => e.type === opts.edge_type);
+      }
+      if (opts.min_weight !== void 0) {
+        edges = edges.filter((e) => e.weight >= opts.min_weight);
+      }
+      if (opts.max_weight !== void 0) {
+        edges = edges.filter((e) => e.weight <= opts.max_weight);
+      }
+      if (opts.graph_id) {
+        edges = edges.filter((e) => e.graph_id === opts.graph_id);
+      }
+      for (const edge of edges) {
+        const targetNode = this.adapter.getNode(edge.to_node);
+        if (!targetNode) continue;
+        if (opts.node_type && targetNode.type !== opts.node_type) continue;
+        results.push({
+          node: targetNode,
+          score: edge.weight,
+          source: "structural"
+        });
+      }
+    } else if (opts.to_node) {
+      let edges = this.adapter.getEdgesByNode(opts.to_node, "to");
+      if (opts.edge_type) {
+        edges = edges.filter((e) => e.type === opts.edge_type);
+      }
+      if (opts.min_weight !== void 0) {
+        edges = edges.filter((e) => e.weight >= opts.min_weight);
+      }
+      if (opts.max_weight !== void 0) {
+        edges = edges.filter((e) => e.weight <= opts.max_weight);
+      }
+      if (opts.graph_id) {
+        edges = edges.filter((e) => e.graph_id === opts.graph_id);
+      }
+      for (const edge of edges) {
+        const sourceNode = this.adapter.getNode(edge.from_node);
+        if (!sourceNode) continue;
+        if (opts.node_type && sourceNode.type !== opts.node_type) continue;
+        results.push({
+          node: sourceNode,
+          score: edge.weight,
+          source: "structural"
+        });
+      }
+    } else if (opts.graph_id || opts.node_type) {
+      const nodes = this.adapter.queryNodes({
+        graph_id: opts.graph_id,
+        type: opts.node_type,
+        limit
+      });
+      for (const node of nodes) {
+        results.push({
+          node,
+          score: 1,
+          // No edge weight context, default to 1.0
+          source: "structural"
+        });
+      }
+    }
+    this.sortResults(results, opts.order_by ?? "weight_desc");
+    return results.slice(0, limit);
+  }
+  querySemantic(opts) {
+    if (!this.hnswIndex) {
+      return [];
+    }
+    const limit = opts.limit ?? 20;
+    const minSimilarity = opts.min_similarity ?? 0;
+    let searchResults;
+    try {
+      searchResults = this.hnswIndex.search(opts.embedding, limit * 2);
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (const hit of searchResults) {
+      if (hit.similarity < minSimilarity) continue;
+      const node = this.adapter.getNode(hit.id);
+      if (!node) continue;
+      if (opts.node_types && opts.node_types.length > 0) {
+        if (!opts.node_types.includes(node.type)) continue;
+      }
+      results.push({
+        node,
+        score: hit.similarity,
+        source: "semantic"
+      });
+      if (results.length >= limit) break;
+    }
+    return results;
+  }
+  queryMerged(opts) {
+    const structuralWeight = opts.structural_weight ?? 0.6;
+    const semanticWeight = opts.semantic_weight ?? 0.4;
+    const limit = opts.limit ?? 50;
+    const structuralResults = this.queryStructural(opts.structural);
+    const semanticResults = opts.semantic ? this.querySemantic(opts.semantic) : [];
+    const scoreMap = /* @__PURE__ */ new Map();
+    for (const r of structuralResults) {
+      scoreMap.set(r.node.id, {
+        node: r.node,
+        structScore: r.score,
+        semScore: 0
+      });
+    }
+    for (const r of semanticResults) {
+      const existing = scoreMap.get(r.node.id);
+      if (existing) {
+        existing.semScore = r.score;
+      } else {
+        scoreMap.set(r.node.id, {
+          node: r.node,
+          structScore: 0,
+          semScore: r.score
+        });
+      }
+    }
+    const merged = [];
+    for (const entry of scoreMap.values()) {
+      const score = structuralWeight * entry.structScore + semanticWeight * entry.semScore;
+      merged.push({
+        node: entry.node,
+        score,
+        source: "merged"
+      });
+    }
+    merged.sort((a, b) => b.score - a.score);
+    return merged.slice(0, limit);
+  }
+  query(q) {
+    const merged = q.getMergedOpts();
+    const structOpts = q.getStructuralOpts();
+    const semOpts = q.getSemanticOpts();
+    if (!structOpts && semOpts) {
+      return this.querySemantic(semOpts);
+    }
+    if (structOpts && !semOpts) {
+      return this.queryStructural(structOpts);
+    }
+    return this.queryMerged(merged);
+  }
+  // ─── Stats ────────────────────────────────
+  nodeCount(graphId) {
+    return this.adapter.countNodes(graphId);
+  }
+  edgeCount(graphId) {
+    return this.adapter.countEdges(graphId);
+  }
+  // ─── Lifecycle ────────────────────────────
+  close() {
+    this.adapter.close();
+  }
+  // ─── Private helpers ──────────────────────
+  sortResults(results, orderBy) {
+    switch (orderBy) {
+      case "weight_desc":
+        results.sort((a, b) => b.score - a.score);
+        break;
+      case "weight_asc":
+        results.sort((a, b) => a.score - b.score);
+        break;
+      case "created_at_desc":
+        results.sort((a, b) => b.node.created_at - a.node.created_at);
+        break;
+      case "traversal_count_desc":
+        results.sort((a, b) => b.node.visit_count - a.node.visit_count);
+        break;
+    }
+  }
+};
+
+// packages/core/src/storage/adapters/SQLiteAdapter.ts
+import Database from "better-sqlite3";
+var SQLiteAdapter = class {
+  db;
+  // Prepared statements — lazily initialized
+  _stmtCache = /* @__PURE__ */ new Map();
+  constructor(opts) {
+    this.db = new Database(opts.db_path === ":memory:" ? ":memory:" : opts.db_path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 5000");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(SCHEMA_SQL);
+    this.db.exec(INDEX_SQL);
+  }
+  // ---- Helpers ----
+  stmt(sql) {
+    let s = this._stmtCache.get(sql);
+    if (!s) {
+      s = this.db.prepare(sql);
+      this._stmtCache.set(sql, s);
+    }
+    return s;
+  }
+  // ---- Nodes ----
+  insertNode(node) {
+    const txn = this.db.transaction(() => {
+      this.stmt(`
+        INSERT INTO nodes (id, graph_id, label, type, created_at, last_seen, visit_count, metadata, subgraph_id, embedding, embedding_model, embedding_at)
+        VALUES (@id, @graph_id, @label, @type, @created_at, @last_seen, @visit_count, @metadata, @subgraph_id, @embedding, @embedding_model, @embedding_at)
+      `).run({
+        id: node.id,
+        graph_id: node.graph_id,
+        label: node.label,
+        type: node.type,
+        created_at: node.created_at,
+        last_seen: node.last_seen,
+        visit_count: node.visit_count,
+        metadata: JSON.stringify(node.metadata),
+        subgraph_id: node.subgraph_id,
+        embedding: node.embedding ? Buffer.from(node.embedding.buffer) : null,
+        embedding_model: node.embedding_model,
+        embedding_at: node.embedding_at
+      });
+      const insertContent = this.stmt(`
+        INSERT INTO node_content (id, node_id, type, data, metadata)
+        VALUES (@id, @node_id, @type, @data, @metadata)
+      `);
+      for (const c of node.content) {
+        insertContent.run({
+          id: c.id,
+          node_id: node.id,
+          type: c.type,
+          data: c.data,
+          metadata: JSON.stringify(c.metadata)
+        });
+      }
+    });
+    txn();
+  }
+  getNode(id) {
+    const row = this.stmt(`SELECT * FROM nodes WHERE id = ?`).get(id);
+    if (!row) return null;
+    const contentRows = this.stmt(`SELECT * FROM node_content WHERE node_id = ?`).all(id);
+    return this.mapNode(row, contentRows);
+  }
+  updateNode(id, updates) {
+    const fields = [];
+    const values = { id };
+    if (updates.graph_id !== void 0) {
+      fields.push("graph_id = @graph_id");
+      values.graph_id = updates.graph_id;
+    }
+    if (updates.label !== void 0) {
+      fields.push("label = @label");
+      values.label = updates.label;
+    }
+    if (updates.type !== void 0) {
+      fields.push("type = @type");
+      values.type = updates.type;
+    }
+    if (updates.created_at !== void 0) {
+      fields.push("created_at = @created_at");
+      values.created_at = updates.created_at;
+    }
+    if (updates.last_seen !== void 0) {
+      fields.push("last_seen = @last_seen");
+      values.last_seen = updates.last_seen;
+    }
+    if (updates.visit_count !== void 0) {
+      fields.push("visit_count = @visit_count");
+      values.visit_count = updates.visit_count;
+    }
+    if (updates.metadata !== void 0) {
+      fields.push("metadata = @metadata");
+      values.metadata = JSON.stringify(updates.metadata);
+    }
+    if (updates.subgraph_id !== void 0) {
+      fields.push("subgraph_id = @subgraph_id");
+      values.subgraph_id = updates.subgraph_id;
+    }
+    if (updates.embedding !== void 0) {
+      fields.push("embedding = @embedding");
+      values.embedding = updates.embedding ? Buffer.from(updates.embedding.buffer) : null;
+    }
+    if (updates.embedding_model !== void 0) {
+      fields.push("embedding_model = @embedding_model");
+      values.embedding_model = updates.embedding_model;
+    }
+    if (updates.embedding_at !== void 0) {
+      fields.push("embedding_at = @embedding_at");
+      values.embedding_at = updates.embedding_at;
+    }
+    if (fields.length === 0) return;
+    this.db.prepare(`UPDATE nodes SET ${fields.join(", ")} WHERE id = @id`).run(values);
+  }
+  updateNodeLastSeen(id, ts) {
+    this.stmt(`UPDATE nodes SET last_seen = ?, visit_count = visit_count + 1 WHERE id = ?`).run(ts, id);
+  }
+  deleteNode(id) {
+    this.stmt(`DELETE FROM nodes WHERE id = ?`).run(id);
+  }
+  queryNodes(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts.graph_id !== void 0) {
+      conditions.push("graph_id = ?");
+      params.push(opts.graph_id);
+    }
+    if (opts.type !== void 0) {
+      conditions.push("type = ?");
+      params.push(opts.type);
+    }
+    if (opts.subgraph_id !== void 0) {
+      conditions.push("subgraph_id = ?");
+      params.push(opts.subgraph_id);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limitClause = opts.limit !== void 0 ? `LIMIT ?` : "";
+    if (opts.limit !== void 0) params.push(opts.limit);
+    const rows = this.db.prepare(`SELECT * FROM nodes ${where} ${limitClause}`).all(...params);
+    return rows.map((row) => {
+      const contentRows = this.stmt(`SELECT * FROM node_content WHERE node_id = ?`).all(row.id);
+      return this.mapNode(row, contentRows);
+    });
+  }
+  countNodes(graph_id) {
+    if (graph_id !== void 0) {
+      const row2 = this.stmt(`SELECT COUNT(*) as cnt FROM nodes WHERE graph_id = ?`).get(graph_id);
+      return row2.cnt;
+    }
+    const row = this.stmt(`SELECT COUNT(*) as cnt FROM nodes`).get();
+    return row.cnt;
+  }
+  // ---- Edges ----
+  insertEdge(edge) {
+    this.stmt(`
+      INSERT INTO edges (id, graph_id, from_node, to_node, type, weight, locked, decay_rate, created_at, last_traversed, traversal_count, metadata)
+      VALUES (@id, @graph_id, @from_node, @to_node, @type, @weight, @locked, @decay_rate, @created_at, @last_traversed, @traversal_count, @metadata)
+    `).run({
+      id: edge.id,
+      graph_id: edge.graph_id,
+      from_node: edge.from_node,
+      to_node: edge.to_node,
+      type: edge.type,
+      weight: edge.weight,
+      locked: edge.locked ? 1 : 0,
+      decay_rate: edge.decay_rate,
+      created_at: edge.created_at,
+      last_traversed: edge.last_traversed,
+      traversal_count: edge.traversal_count,
+      metadata: JSON.stringify(edge.metadata)
+    });
+  }
+  getEdge(id) {
+    const row = this.stmt(`SELECT * FROM edges WHERE id = ?`).get(id);
+    if (!row) return null;
+    return this.mapEdge(row);
+  }
+  updateEdgeWeight(id, newWeight, expectedWeight) {
+    const result = this.stmt(`UPDATE edges SET weight = ? WHERE id = ? AND weight = ?`).run(newWeight, id, expectedWeight);
+    return result.changes === 1;
+  }
+  updateEdgeTraversal(id, ts) {
+    this.stmt(`UPDATE edges SET last_traversed = ?, traversal_count = traversal_count + 1 WHERE id = ?`).run(ts, id);
+  }
+  deleteEdge(id) {
+    this.stmt(`DELETE FROM edges WHERE id = ?`).run(id);
+  }
+  getEdgesByNode(nodeId, direction) {
+    let rows;
+    if (direction === "from") {
+      rows = this.stmt(`SELECT * FROM edges WHERE from_node = ?`).all(nodeId);
+    } else if (direction === "to") {
+      rows = this.stmt(`SELECT * FROM edges WHERE to_node = ?`).all(nodeId);
+    } else {
+      rows = this.stmt(`SELECT * FROM edges WHERE from_node = ? OR to_node = ?`).all(nodeId, nodeId);
+    }
+    return rows.map((r) => this.mapEdge(r));
+  }
+  getEdgesBetween(fromId, toId) {
+    const rows = this.stmt(`SELECT * FROM edges WHERE from_node = ? AND to_node = ?`).all(fromId, toId);
+    return rows.map((r) => this.mapEdge(r));
+  }
+  getAllEdges(graph_id) {
+    let rows;
+    if (graph_id !== void 0) {
+      rows = this.stmt(`SELECT * FROM edges WHERE graph_id = ?`).all(graph_id);
+    } else {
+      rows = this.stmt(`SELECT * FROM edges`).all();
+    }
+    return rows.map((r) => this.mapEdge(r));
+  }
+  // ---- Weight Events ----
+  insertWeightEvent(event) {
+    this.stmt(`
+      INSERT INTO weight_events (id, edge_id, old_weight, new_weight, delta, reason, trace_id, created_at)
+      VALUES (@id, @edge_id, @old_weight, @new_weight, @delta, @reason, @trace_id, @created_at)
+    `).run({
+      id: event.id,
+      edge_id: event.edge_id,
+      old_weight: event.old_weight,
+      new_weight: event.new_weight,
+      delta: event.delta,
+      reason: event.reason,
+      trace_id: event.trace_id,
+      created_at: event.created_at
+    });
+  }
+  getWeightEvents(edgeId) {
+    const rows = this.stmt(`SELECT * FROM weight_events WHERE edge_id = ? ORDER BY created_at`).all(edgeId);
+    return rows.map((r) => this.mapWeightEvent(r));
+  }
+  getWeightEventsByTrace(traceId) {
+    const rows = this.stmt(`SELECT * FROM weight_events WHERE trace_id = ? ORDER BY created_at`).all(traceId);
+    return rows.map((r) => this.mapWeightEvent(r));
+  }
+  // ---- Traces ----
+  insertTrace(trace) {
+    this.stmt(`
+      INSERT INTO traces (id, session_id, input, plan, outcome_signal, outcome_type, resolved_at, deferred, deferred_until, created_at, metadata)
+      VALUES (@id, @session_id, @input, @plan, @outcome_signal, @outcome_type, @resolved_at, @deferred, @deferred_until, @created_at, @metadata)
+    `).run({
+      id: trace.id,
+      session_id: trace.session_id,
+      input: trace.input,
+      plan: trace.plan,
+      outcome_signal: trace.outcome_signal,
+      outcome_type: trace.outcome_type,
+      resolved_at: trace.resolved_at,
+      deferred: trace.deferred ? 1 : 0,
+      deferred_until: trace.deferred_until,
+      created_at: trace.created_at,
+      metadata: JSON.stringify(trace.metadata)
+    });
+  }
+  getTrace(id) {
+    const row = this.stmt(`SELECT * FROM traces WHERE id = ?`).get(id);
+    if (!row) return null;
+    return this.mapTrace(row);
+  }
+  updateTraceOutcome(id, signal, type, resolvedAt) {
+    this.stmt(`UPDATE traces SET outcome_signal = ?, outcome_type = ?, resolved_at = ? WHERE id = ?`).run(signal, type, resolvedAt, id);
+  }
+  queryTraces(opts) {
+    const conditions = [];
+    const params = [];
+    if (opts.session_id !== void 0) {
+      conditions.push("session_id = ?");
+      params.push(opts.session_id);
+    }
+    if (opts.deferred !== void 0) {
+      conditions.push("deferred = ?");
+      params.push(opts.deferred ? 1 : 0);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limitClause = opts.limit !== void 0 ? `LIMIT ?` : "";
+    if (opts.limit !== void 0) params.push(opts.limit);
+    const rows = this.db.prepare(`SELECT * FROM traces ${where} ORDER BY created_at DESC ${limitClause}`).all(...params);
+    return rows.map((r) => this.mapTrace(r));
+  }
+  // ---- Aliases ----
+  insertAlias(alias, nodeId, confidence) {
+    this.stmt(`
+      INSERT OR REPLACE INTO aliases (alias, node_id, confidence, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(alias, nodeId, confidence, Date.now());
+  }
+  getAliases(nodeId) {
+    const rows = this.stmt(`SELECT * FROM aliases WHERE node_id = ?`).all(nodeId);
+    return rows.map((r) => this.mapAlias(r));
+  }
+  findByAlias(alias) {
+    const rows = this.stmt(`SELECT * FROM aliases WHERE alias = ?`).all(alias);
+    return rows.map((r) => this.mapAlias(r));
+  }
+  deleteAlias(alias, nodeId) {
+    this.stmt(`DELETE FROM aliases WHERE alias = ? AND node_id = ?`).run(alias, nodeId);
+  }
+  // ---- Force update (LWW fallback for OCC) ----
+  forceUpdateEdgeWeight(id, newWeight) {
+    this.stmt(`UPDATE edges SET weight = ? WHERE id = ?`).run(newWeight, id);
+  }
+  // ---- Node Content (direct) ----
+  insertNodeContent(content) {
+    this.stmt(`
+      INSERT INTO node_content (id, node_id, type, data, metadata)
+      VALUES (@id, @node_id, @type, @data, @metadata)
+    `).run({
+      id: content.id,
+      node_id: content.node_id,
+      type: content.type,
+      data: content.data,
+      metadata: JSON.stringify(content.metadata)
+    });
+  }
+  getNodeContent(nodeId) {
+    const rows = this.stmt(`SELECT * FROM node_content WHERE node_id = ?`).all(nodeId);
+    return rows.map((c) => ({
+      id: c.id,
+      node_id: c.node_id,
+      type: c.type,
+      data: c.data,
+      metadata: JSON.parse(c.metadata)
+    }));
+  }
+  // ---- Edge Count ----
+  countEdges(graph_id) {
+    if (graph_id !== void 0) {
+      const row2 = this.stmt(`SELECT COUNT(*) as cnt FROM edges WHERE graph_id = ?`).get(graph_id);
+      return row2.cnt;
+    }
+    const row = this.stmt(`SELECT COUNT(*) as cnt FROM edges`).get();
+    return row.cnt;
+  }
+  // ---- Lifecycle ----
+  close() {
+    this.db.close();
+  }
+  // ---- Row mappers ----
+  mapNode(row, contentRows) {
+    let embedding = null;
+    if (row.embedding && row.embedding instanceof Buffer) {
+      embedding = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+    }
+    return {
+      id: row.id,
+      graph_id: row.graph_id,
+      label: row.label,
+      type: row.type,
+      created_at: row.created_at,
+      last_seen: row.last_seen,
+      visit_count: row.visit_count,
+      metadata: JSON.parse(row.metadata),
+      subgraph_id: row.subgraph_id ?? null,
+      embedding,
+      embedding_model: row.embedding_model ?? null,
+      embedding_at: row.embedding_at ?? null,
+      content: contentRows.map((c) => ({
+        id: c.id,
+        node_id: c.node_id,
+        type: c.type,
+        data: c.data,
+        metadata: JSON.parse(c.metadata)
+      }))
+    };
+  }
+  mapEdge(row) {
+    return {
+      id: row.id,
+      graph_id: row.graph_id,
+      from_node: row.from_node,
+      to_node: row.to_node,
+      type: row.type,
+      weight: row.weight,
+      locked: row.locked === 1,
+      decay_rate: row.decay_rate,
+      created_at: row.created_at,
+      last_traversed: row.last_traversed ?? null,
+      traversal_count: row.traversal_count,
+      metadata: JSON.parse(row.metadata)
+    };
+  }
+  mapWeightEvent(row) {
+    return {
+      id: row.id,
+      edge_id: row.edge_id,
+      old_weight: row.old_weight,
+      new_weight: row.new_weight,
+      delta: row.delta,
+      reason: row.reason,
+      trace_id: row.trace_id ?? null,
+      created_at: row.created_at
+    };
+  }
+  mapTrace(row) {
+    return {
+      id: row.id,
+      session_id: row.session_id,
+      input: row.input,
+      plan: row.plan,
+      outcome_signal: row.outcome_signal ?? null,
+      outcome_type: row.outcome_type ?? null,
+      resolved_at: row.resolved_at ?? null,
+      deferred: row.deferred === 1,
+      deferred_until: row.deferred_until ?? null,
+      created_at: row.created_at,
+      metadata: JSON.parse(row.metadata)
+    };
+  }
+  mapAlias(row) {
+    return {
+      alias: row.alias,
+      node_id: row.node_id,
+      confidence: row.confidence,
+      created_at: row.created_at
+    };
+  }
+};
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS nodes (
+  id TEXT PRIMARY KEY,
+  graph_id TEXT NOT NULL,
+  label TEXT NOT NULL,
+  type TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  last_seen INTEGER NOT NULL,
+  visit_count INTEGER NOT NULL DEFAULT 1,
+  metadata TEXT NOT NULL DEFAULT '{}',
+  subgraph_id TEXT,
+  embedding BLOB,
+  embedding_model TEXT,
+  embedding_at INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS node_content (
+  id TEXT PRIMARY KEY,
+  node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  type TEXT NOT NULL,
+  data TEXT NOT NULL,
+  metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  graph_id TEXT NOT NULL,
+  from_node TEXT NOT NULL REFERENCES nodes(id),
+  to_node TEXT NOT NULL REFERENCES nodes(id),
+  type TEXT NOT NULL,
+  weight REAL NOT NULL DEFAULT 0.5,
+  locked INTEGER NOT NULL DEFAULT 0,
+  decay_rate REAL NOT NULL DEFAULT 0.001,
+  created_at INTEGER NOT NULL,
+  last_traversed INTEGER,
+  traversal_count INTEGER NOT NULL DEFAULT 0,
+  metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS weight_events (
+  id TEXT PRIMARY KEY,
+  edge_id TEXT NOT NULL REFERENCES edges(id),
+  old_weight REAL NOT NULL,
+  new_weight REAL NOT NULL,
+  delta REAL NOT NULL,
+  reason TEXT NOT NULL,
+  trace_id TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS traces (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  input TEXT NOT NULL,
+  plan TEXT NOT NULL,
+  outcome_signal REAL,
+  outcome_type TEXT,
+  resolved_at INTEGER,
+  deferred INTEGER NOT NULL DEFAULT 0,
+  deferred_until INTEGER,
+  created_at INTEGER NOT NULL,
+  metadata TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS aliases (
+  alias TEXT NOT NULL,
+  node_id TEXT NOT NULL REFERENCES nodes(id) ON DELETE CASCADE,
+  confidence REAL NOT NULL DEFAULT 1.0,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (alias, node_id)
+);
+`;
+var INDEX_SQL = `
+CREATE INDEX IF NOT EXISTS idx_nodes_graph_type ON nodes(graph_id, type);
+CREATE INDEX IF NOT EXISTS idx_nodes_subgraph ON nodes(subgraph_id);
+CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_node);
+CREATE INDEX IF NOT EXISTS idx_edges_to ON edges(to_node);
+CREATE INDEX IF NOT EXISTS idx_edges_graph ON edges(graph_id);
+CREATE INDEX IF NOT EXISTS idx_weight_events_edge ON weight_events(edge_id);
+CREATE INDEX IF NOT EXISTS idx_weight_events_trace ON weight_events(trace_id);
+CREATE INDEX IF NOT EXISTS idx_aliases_alias ON aliases(alias);
+CREATE INDEX IF NOT EXISTS idx_traces_session ON traces(session_id);
+`;
+
+// packages/core/src/storage/TraceStore.ts
+var TraceStore = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  insert(trace) {
+    this.adapter.insertTrace(trace);
+  }
+  get(id) {
+    return this.adapter.getTrace(id);
+  }
+  updateOutcome(id, signal, type, resolvedAt) {
+    this.adapter.updateTraceOutcome(id, signal, type, resolvedAt);
+  }
+  query(opts) {
+    return this.adapter.queryTraces(opts);
+  }
+};
+
+// packages/core/src/engine/SelectionPolicy.ts
+var SelectionPolicy = class {
+  config;
+  rng;
+  // injectable RNG for testing
+  constructor(config, rng) {
+    this.config = {
+      epsilon: config?.epsilon ?? 0.15,
+      temperature: config?.temperature ?? 0.5
+    };
+    this.rng = rng ?? Math.random;
+  }
+  /**
+   * Select an edge from candidates using epsilon-greedy.
+   * - With probability epsilon: random selection (explore)
+   * - Otherwise: temperature-softmax weighted by edge weight (exploit)
+   * Returns null if no candidates.
+   */
+  select(candidates) {
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1) {
+      return { edge: candidates[0], mode: "exploit", score: candidates[0].weight };
+    }
+    const roll = this.rng();
+    if (roll < this.config.epsilon) {
+      const idx = Math.floor(this.rng() * candidates.length);
+      return { edge: candidates[idx], mode: "explore", score: candidates[idx].weight };
+    }
+    return this.softmaxSelect(candidates);
+  }
+  /**
+   * Softmax selection weighted by edge weight / temperature.
+   * Higher temperature = more uniform. Lower = more greedy.
+   */
+  softmaxSelect(candidates) {
+    const weights = candidates.map((e) => e.weight / this.config.temperature);
+    const maxW = Math.max(...weights);
+    const exps = weights.map((w) => Math.exp(w - maxW));
+    const sumExp = exps.reduce((a, b) => a + b, 0);
+    const probs = exps.map((e) => e / sumExp);
+    let r = this.rng();
+    for (let i = 0; i < probs.length; i++) {
+      r -= probs[i];
+      if (r <= 0) {
+        return { edge: candidates[i], mode: "exploit", score: candidates[i].weight };
+      }
+    }
+    const last = candidates[candidates.length - 1];
+    return { edge: last, mode: "exploit", score: last.weight };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// packages/core/src/engine/InferenceEngine.ts
+var InferenceEngine = class {
+  constructor(graph, resolver, policy, resolutionPipeline, attribution, propagation, updater) {
+    this.graph = graph;
+    this.resolver = resolver;
+    this.policy = policy;
+    this.resolutionPipeline = resolutionPipeline;
+    this.attribution = attribution;
+    this.propagation = propagation;
+    this.updater = updater;
+  }
+  // ─── Phase 2 backward-compatible resolve() ─────────────
+  async resolve(task, _context) {
+    const plan = {
+      task,
+      resolved_entities: [],
+      selected_edge: null,
+      skill: null,
+      confidence: 0,
+      reasoning: ""
+    };
+    const mentions = this.extractMentions(task);
+    for (const mention of mentions) {
+      try {
+        const result = await this.resolver.resolve(mention);
+        plan.resolved_entities.push({
+          mention,
+          node_id: result.node_id,
+          confidence: result.confidence,
+          match_type: result.match_type
+        });
+      } catch {
+      }
+    }
+    const candidateEdges = [];
+    for (const entity of plan.resolved_entities) {
+      const edges = this.graph.getEdgesFrom(entity.node_id);
+      candidateEdges.push(...edges);
+    }
+    if (candidateEdges.length === 0) {
+      const contextNodes = this.graph.queryStructural({
+        node_type: "context" /* CONTEXT */,
+        limit: 10
+      });
+      for (const result of contextNodes) {
+        const edges = this.graph.getEdgesFrom(result.node.id);
+        candidateEdges.push(...edges);
+      }
+    }
+    if (candidateEdges.length > 0) {
+      const unique = new Map(candidateEdges.map((e) => [e.id, e]));
+      const selection = this.policy.select([...unique.values()]);
+      if (selection) {
+        const fromNode = this.graph.getNode(selection.edge.from_node);
+        const toNode = this.graph.getNode(selection.edge.to_node);
+        plan.selected_edge = {
+          edge_id: selection.edge.id,
+          from_label: fromNode?.label ?? selection.edge.from_node,
+          to_label: toNode?.label ?? selection.edge.to_node,
+          weight: selection.edge.weight,
+          mode: selection.mode
+        };
+        plan.confidence = selection.score;
+        if (toNode?.metadata?.is_skill) {
+          plan.skill = toNode.label;
+        }
+        plan.reasoning = `Selected ${plan.selected_edge.from_label} \u2192 ${plan.selected_edge.to_label} (weight: ${selection.edge.weight.toFixed(2)}, mode: ${selection.mode})`;
+      }
+    }
+    if (!plan.selected_edge) {
+      plan.reasoning = "No candidate edges found \u2014 bootstrap mode may be needed";
+    }
+    return plan;
+  }
+  // ─── Phase 4 full inference pipeline ────────────────────
+  async infer(req) {
+    const trace_id = crypto.randomUUID();
+    const started = Date.now();
+    let resolvedEntities;
+    if (this.resolutionPipeline) {
+      resolvedEntities = await this.resolutionPipeline.extractAndResolve(
+        req.input,
+        req.context
+      );
+    } else {
+      resolvedEntities = await this.resolveEntitiesFallback(req.input);
+    }
+    const candidateEdges = [];
+    for (const entity of resolvedEntities) {
+      const edges = this.graph.getEdgesFrom(entity.node_id);
+      candidateEdges.push(...edges);
+    }
+    if (candidateEdges.length === 0) {
+      const contextNodes = this.graph.queryStructural({
+        node_type: "context" /* CONTEXT */,
+        limit: 10
+      });
+      for (const result2 of contextNodes) {
+        const edges = this.graph.getEdgesFrom(result2.node.id);
+        candidateEdges.push(...edges);
+      }
+    }
+    const unique = new Map(candidateEdges.map((e) => [e.id, e]));
+    const deduped = [...unique.values()];
+    const selection = deduped.length > 0 ? this.policy.select(deduped) : null;
+    const planSelected = [];
+    let skillName = null;
+    if (selection) {
+      planSelected.push(selection.edge.id);
+      const toNode = this.graph.getNode(selection.edge.to_node);
+      if (toNode?.metadata?.is_skill) {
+        skillName = toNode.label;
+      }
+      const ledger = req.context?.["_traversal_ledger"];
+      if (ledger) {
+        const siblings = this.graph.getEdgesFrom(selection.edge.from_node);
+        ledger.record(selection.edge, 0, siblings);
+      }
+    }
+    let output;
+    if (selection) {
+      const fromNode = this.graph.getNode(selection.edge.from_node);
+      const toNode = this.graph.getNode(selection.edge.to_node);
+      const fromLabel = fromNode?.label ?? selection.edge.from_node;
+      const toLabel = toNode?.label ?? selection.edge.to_node;
+      output = skillName ? `Skill: ${skillName} (via ${fromLabel} \u2192 ${toLabel}, weight: ${selection.edge.weight.toFixed(2)}, mode: ${selection.mode})` : `Plan: ${fromLabel} \u2192 ${toLabel} (weight: ${selection.edge.weight.toFixed(2)}, mode: ${selection.mode})`;
+    } else {
+      output = "No plan selected \u2014 bootstrap mode may be needed";
+    }
+    const outcomeSignal = req.context?.["outcome_signal"];
+    if (outcomeSignal !== void 0 && this.attribution && this.propagation) {
+      const ledger = req.context?.["_traversal_ledger"];
+      if (ledger) {
+        await this.attribution.attribute(ledger, outcomeSignal, trace_id);
+        const outcome = {
+          value: outcomeSignal,
+          type: "explicit",
+          trace_id,
+          resolved_at: Date.now()
+        };
+        await this.propagation.propagate(ledger.toStepLedgers(), outcome);
+      }
+    }
+    const contextSkillName = req.context?.["skill_name"];
+    const deferred = req.context?.["deferred"] === true;
+    const result = {
+      output,
+      trace_id,
+      entities_resolved: resolvedEntities.map((e) => e.node_id),
+      plan_selected: planSelected,
+      subagent_result: req.context?.["subagent_result"],
+      outcome_signal: outcomeSignal,
+      deferred
+    };
+    return result;
+  }
+  // ─── Private helpers ────────────────────────────────────
+  /**
+   * Fallback entity resolution using the simple NodeResolutionService.
+   * Used when no EntityResolutionPipeline is provided.
+   */
+  async resolveEntitiesFallback(input) {
+    const mentions = this.extractMentions(input);
+    const resolved = [];
+    for (const mention of mentions) {
+      try {
+        const result = await this.resolver.resolve(mention);
+        resolved.push({
+          mention,
+          node_id: result.node_id,
+          confidence: result.confidence,
+          match_type: result.match_type
+        });
+      } catch {
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Simple mention extraction: split task into potential entity names.
+   * Phase 4 EntityResolutionPipeline provides LLM-based NER as upgrade.
+   */
+  extractMentions(task) {
+    const mentions = [];
+    const words = task.split(/\s+/).filter(Boolean);
+    for (let i = 0; i < words.length - 1; i++) {
+      const pair = `${words[i]} ${words[i + 1]}`;
+      if (/^[A-Z]/.test(words[i]) && /^[A-Z]/.test(words[i + 1])) {
+        mentions.push(pair);
+      }
+    }
+    for (const word of words) {
+      if (/^[A-Z]/.test(word) && word.length > 2) {
+        mentions.push(word);
+      }
+    }
+    return [...new Set(mentions)];
+  }
+};
+
+// packages/core/src/memory/WorkingMemory.ts
+var WorkingMemory = class {
+  constructor(graph, config) {
+    this.graph = graph;
+    this.cache = /* @__PURE__ */ new Map();
+    this.config = { max_nodes: config?.max_nodes ?? 200 };
+  }
+  cache;
+  config;
+  /**
+   * Get a node by ID. Checks cache first (promoting to MRU on hit),
+   * then falls back to graph lookup and caches the result.
+   */
+  get(id) {
+    if (this.cache.has(id)) {
+      const node2 = this.cache.get(id);
+      this.cache.delete(id);
+      this.cache.set(id, node2);
+      return node2;
+    }
+    const node = this.graph.getNode(id);
+    if (node) this.put(node);
+    return node;
+  }
+  /**
+   * Insert or update a node in the cache.
+   * Evicts the LRU entry if at capacity.
+   */
+  put(node) {
+    if (this.cache.has(node.id)) {
+      this.cache.delete(node.id);
+    } else if (this.cache.size >= this.config.max_nodes) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) this.cache.delete(firstKey);
+    }
+    this.cache.set(node.id, node);
+  }
+  /**
+   * Get the N most recently accessed nodes (from oldest to newest).
+   */
+  getRecentNodes(n) {
+    return Array.from(this.cache.values()).slice(-n);
+  }
+  /** Check if a node is in the cache. */
+  has(id) {
+    return this.cache.has(id);
+  }
+  /** Number of nodes currently cached. */
+  get size() {
+    return this.cache.size;
+  }
+  /** Clear all cached nodes. */
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// packages/core/src/entity/AliasIndex.ts
+var AliasIndex = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Register an alias for a node.
+   * Normalizes alias to lowercase.
+   */
+  add(alias, nodeId, confidence = 1) {
+    this.adapter.insertAlias(this.normalize(alias), nodeId, confidence);
+  }
+  /**
+   * Remove an alias.
+   */
+  remove(alias, nodeId) {
+    this.adapter.deleteAlias(this.normalize(alias), nodeId);
+  }
+  /**
+   * Find nodes by exact alias match.
+   */
+  findExact(alias) {
+    return this.adapter.findByAlias(this.normalize(alias));
+  }
+  /**
+   * Get all aliases for a node.
+   */
+  getAliases(nodeId) {
+    return this.adapter.getAliases(nodeId);
+  }
+  /**
+   * Generate common abbreviations for a label.
+   * "Acme Corp" -> ["acme corp", "acme", "ac"]
+   * "John Smith" -> ["john smith", "john", "js"]
+   */
+  generateAbbreviations(label) {
+    const normalized = this.normalize(label);
+    const words = normalized.split(/\s+/).filter(Boolean);
+    const results = [normalized];
+    if (words.length > 1) {
+      results.push(words[0]);
+      const initials = words.map((w) => w[0]).join("");
+      if (initials.length >= 2) {
+        results.push(initials);
+      }
+    }
+    return [...new Set(results)];
+  }
+  /**
+   * Register a node with its label and auto-generated abbreviations.
+   */
+  registerNode(nodeId, label) {
+    const abbreviations = this.generateAbbreviations(label);
+    for (const abbr of abbreviations) {
+      this.add(abbr, nodeId, abbr === this.normalize(label) ? 1 : 0.9);
+    }
+  }
+  /**
+   * Fuzzy scan: find aliases that contain the query string.
+   * Returns matches sorted by confidence desc.
+   */
+  fuzzyFind(query) {
+    const normalized = this.normalize(query);
+    const allForQuery = this.adapter.findByAlias(normalized);
+    if (allForQuery.length > 0) return allForQuery;
+    return [];
+  }
+  normalize(s) {
+    return s.toLowerCase().trim();
+  }
+};
+
+// packages/core/src/entity/NodeResolutionService.ts
+var DEFAULT_CONFIG = {
+  exact_threshold: 1,
+  alias_threshold: 0.9,
+  fuzzy_threshold: 0.65,
+  disambiguation_threshold: 0.8
+};
+var NodeResolutionService = class {
+  constructor(graph, aliasIndex, embedder, hnswIndex, config) {
+    this.graph = graph;
+    this.aliasIndex = aliasIndex;
+    this.embedder = embedder;
+    this.hnswIndex = hnswIndex;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  config;
+  /**
+   * Resolve a mention to an existing node or create a new one.
+   *
+   * Pipeline:
+   * 1. Exact label match in graph
+   * 2. Alias match
+   * 3. Fuzzy embedding match (if embedder available)
+   * 4. Create new node if no match above threshold
+   */
+  async resolve(mention, opts) {
+    const graphId = opts?.graph_id ?? "root";
+    const nodeType = opts?.type ?? "entity" /* ENTITY */;
+    const exactMatches = this.graph.queryStructural({
+      graph_id: graphId,
+      node_type: nodeType,
+      limit: 5
+    }).filter((r) => r.node.label.toLowerCase() === mention.toLowerCase());
+    if (exactMatches.length === 1) {
+      this.graph.touchNode(exactMatches[0].node.id);
+      return {
+        node_id: exactMatches[0].node.id,
+        confidence: this.config.exact_threshold,
+        match_type: "exact"
+      };
+    }
+    const aliasMatches = this.aliasIndex.findExact(mention);
+    if (aliasMatches.length === 1) {
+      this.graph.touchNode(aliasMatches[0].node_id);
+      return {
+        node_id: aliasMatches[0].node_id,
+        confidence: aliasMatches[0].confidence,
+        match_type: "alias"
+      };
+    }
+    if (aliasMatches.length > 1 && opts?.context_node_ids?.length) {
+      const disambiguated = this.disambiguate(
+        aliasMatches.map((a) => a.node_id),
+        opts.context_node_ids
+      );
+      if (disambiguated) {
+        return {
+          node_id: disambiguated,
+          confidence: this.config.disambiguation_threshold,
+          match_type: "alias"
+        };
+      }
+    }
+    if (this.embedder?.isAvailable && this.hnswIndex) {
+      const queryEmbedding = await this.embedder.embedText(mention);
+      if (queryEmbedding) {
+        const results = this.hnswIndex.search(queryEmbedding, 5);
+        const bestMatch = results[0];
+        if (bestMatch && bestMatch.similarity >= this.config.fuzzy_threshold) {
+          const node = this.graph.getNode(bestMatch.id);
+          if (node && node.type === nodeType) {
+            this.graph.touchNode(node.id);
+            return {
+              node_id: node.id,
+              confidence: bestMatch.similarity,
+              match_type: "fuzzy"
+            };
+          }
+        }
+      }
+    }
+    const newNode = this.createNewNode(mention, nodeType, graphId);
+    return {
+      node_id: newNode.id,
+      confidence: 1,
+      match_type: "created"
+    };
+  }
+  /**
+   * Disambiguate among multiple candidates using context.
+   * Check which candidate has edges to/from context nodes.
+   * Returns node_id of best candidate, or null if ambiguous.
+   */
+  disambiguate(candidateIds, contextNodeIds) {
+    let bestId = null;
+    let bestScore = 0;
+    for (const candidateId of candidateIds) {
+      let score = 0;
+      for (const ctxId of contextNodeIds) {
+        const edges = this.graph.getEdgesBetween(candidateId, ctxId);
+        const reverseEdges = this.graph.getEdgesBetween(ctxId, candidateId);
+        score += edges.length + reverseEdges.length;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestId = candidateId;
+      }
+    }
+    return bestScore > 0 ? bestId : null;
+  }
+  createNewNode(label, type, graphId) {
+    const id = crypto.randomUUID();
+    const node = createNode({
+      id,
+      graph_id: graphId,
+      label,
+      type
+    });
+    this.graph.addNode(node);
+    this.aliasIndex.registerNode(id, label);
+    if (this.embedder?.isAvailable && this.hnswIndex) {
+      this.embedder.embedText(label).then((emb) => {
+        if (emb) {
+          this.hnswIndex.add(id, emb);
+          this.graph.updateNode(id, {
+            embedding: emb,
+            embedding_model: this.embedder.dimensions.toString(),
+            embedding_at: Date.now()
+          });
+        }
+      }).catch(() => {
+      });
+    }
+    return node;
+  }
+};
+
+// packages/core/src/bootstrap/StagedMutations.ts
+var TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+
+// packages/core/src/bootstrap/HypothesisManager.ts
+var HYPOTHESIS_TTL_MS = 14 * 24 * 60 * 60 * 1e3;
+
+// packages/core/src/maintenance/CompactionOrchestrator.ts
+var DEFAULT_SCHEDULE = {
+  edge_pruning_interval_ms: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  archival_trigger_nodes: 5e3,
+  deduplication_interval_ms: 7 * 24 * 60 * 60 * 1e3
+  // 7 days
+};
+
+// packages/daemon/src/config/DaemonConfig.ts
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import YAML from "yaml";
+
+// packages/daemon/src/config/ConfigSchema.ts
+import { z } from "zod";
+var LLMProviderSchema = z.object({
+  provider: z.enum([
+    "anthropic",
+    "openai",
+    "ollama",
+    "groq",
+    "gemini",
+    "xai",
+    "custom"
+  ]),
+  model: z.string(),
+  api_key: z.string().optional(),
+  base_url: z.string().optional(),
+  is_default: z.boolean().default(false)
+});
+var EmbeddingConfigSchema = z.object({
+  provider: z.enum(["nomic-ollama", "openai", "ollama"]).default("nomic-ollama"),
+  model: z.string().default("nomic-embed-text"),
+  dimensions: z.number().default(768),
+  ollama_base_url: z.string().default("http://localhost:11434"),
+  openai_api_key: z.string().optional()
+});
+var SandboxConfigSchema = z.object({
+  backend: z.enum(["auto", "firecracker", "docker", "podman", "bwrap", "cloud", "process"]).default("auto"),
+  e2b_api_key: z.string().optional(),
+  memory_mb: z.number().default(512),
+  cpus: z.number().default(1)
+});
+var MCPServerEntrySchema = z.object({
+  name: z.string(),
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  enabled: z.boolean().default(true)
+});
+var ServerConfigSchema = z.object({
+  port: z.number().default(4200),
+  host: z.string().default("127.0.0.1"),
+  bearer_token: z.string().optional()
+});
+var GraphConfigSchema = z.object({
+  db_path: z.string(),
+  hnsw_path: z.string(),
+  object_store_path: z.string()
+});
+var LearningConfigSchema = z.object({
+  base_learning_rate: z.number().default(0.1),
+  cross_graph_attenuation: z.number().default(0.3),
+  base_step_discount: z.number().default(0.85),
+  epsilon: z.number().default(0.15),
+  temperature: z.number().default(0.5)
+});
+var DecayConfigSchema = z.object({
+  interval_hours: z.number().default(6),
+  max_deferral_hours: z.number().default(24),
+  grace_period_hours: z.number().default(48),
+  max_per_cycle: z.number().default(0.05)
+});
+var SelfImprovementConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  schedule: z.enum(["weekly", "daily", "after_every_retro", "manual"]).default("weekly"),
+  auto_apply: z.object({
+    graph_health: z.boolean().default(true),
+    workflow_edges: z.boolean().default(false),
+    skill_prompts: z.boolean().default(false),
+    tool_install: z.boolean().default(false),
+    new_skills: z.boolean().default(false)
+  }).default({})
+});
+var EntityVisibilityPolicySchema = z.object({
+  allow_work_context: z.boolean().default(true),
+  allow_signal_nodes: z.boolean().default(true),
+  allow_personality_profile: z.boolean().default(false),
+  allow_raw_conversations: z.boolean().default(false)
+});
+var EntityNestingConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  // When a session has entity_id, accumulate personality after completion
+  accumulate_personality: z.boolean().default(true),
+  // Minimum interactions before personality influences responses
+  personality_min_interactions: z.number().default(3),
+  // How much to attenuate signals propagating to parent entities (0-1)
+  parent_propagation_attenuation: z.number().default(0.5),
+  // Visibility policy — what parent entities see from children
+  visibility_policy: EntityVisibilityPolicySchema.default({})
+});
+var DaemonConfigSchema = z.object({
+  version: z.string().default("1"),
+  llm_providers: z.array(LLMProviderSchema).min(1),
+  embedding: EmbeddingConfigSchema.default({}),
+  sandbox: SandboxConfigSchema.default({}),
+  mcp_servers: z.array(MCPServerEntrySchema).default([]),
+  server: ServerConfigSchema.default({}),
+  graph: GraphConfigSchema,
+  learning: LearningConfigSchema.default({}),
+  decay: DecayConfigSchema.default({}),
+  seed: z.string().optional(),
+  self_improvement: SelfImprovementConfigSchema.default({}),
+  entity_nesting: EntityNestingConfigSchema.default({})
+});
+
+// packages/daemon/src/config/DaemonConfig.ts
+var DEFAULT_CONFIG_PATH = resolve(homedir(), ".0agent", "config.yaml");
+var DEFAULT_GRAPH_CONFIG = {
+  db_path: resolve(homedir(), ".0agent", "graph.db"),
+  hnsw_path: resolve(homedir(), ".0agent", "hnsw.bin"),
+  object_store_path: resolve(homedir(), ".0agent", "objects")
+};
+async function loadConfig(configPath = DEFAULT_CONFIG_PATH) {
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `Config file not found: ${configPath}
+Run '0agent init' to create one.`
+    );
+  }
+  const raw = readFileSync(configPath, "utf8");
+  const parsed = YAML.parse(raw);
+  if (!parsed.graph) {
+    parsed.graph = DEFAULT_GRAPH_CONFIG;
+  }
+  const result = DaemonConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid config:
+${issues}`);
+  }
+  return result.data;
+}
+
+// packages/daemon/src/EntityScopedContext.ts
+var EntityScopedContextLoader = class {
+  constructor(graph) {
+    this.graph = graph;
+  }
+  load(entityId) {
+    const entity = this.graph.getNode(entityId);
+    if (!entity) return null;
+    const personalSubgraph = this.graph.getSubGraph(entityId, 2);
+    const personalNodes = personalSubgraph.getNodes();
+    const memberOfEdges = this.graph.getEdgesFrom(entityId).filter((e) => e.type === "member_of");
+    const parents = memberOfEdges.map((e) => this.graph.getNode(e.to_node)).filter((n) => n !== null);
+    const sharedNodes = [];
+    for (const parent of parents) {
+      const parentSubgraph = this.graph.getSubGraph(parent.id, 1);
+      for (const node of parentSubgraph.getNodes()) {
+        if (["context", "strategy", "plan", "step"].includes(node.type)) {
+          if (!sharedNodes.find((n) => n.id === node.id)) {
+            sharedNodes.push(node);
+          }
+        }
+      }
+    }
+    const personalityNode = personalNodes.find(
+      (n) => n.label === "__personality_profile__" && n.metadata?.entity_id === entityId
+    );
+    let personalityPrompt = "";
+    if (personalityNode?.content[0]) {
+      try {
+        const profile = JSON.parse(personalityNode.content[0].data);
+        if (profile.interaction_count >= 3) {
+          const lines = [];
+          if (profile.communication_style && !profile.communication_style.includes("unknown")) {
+            lines.push(`Communication style: ${profile.communication_style}.`);
+          }
+          if (profile.response_preferences && profile.response_preferences.length > 0) {
+            lines.push(`Preferences: ${profile.response_preferences.join(", ")}.`);
+          }
+          if (profile.working_context) {
+            lines.push(`Currently working on: ${profile.working_context}.`);
+          }
+          if (profile.timezone && profile.timezone !== "UTC") {
+            lines.push(`Timezone: ${profile.timezone}.`);
+          }
+          if (lines.length > 0) {
+            personalityPrompt = [
+              `Context about this person (${profile.interaction_count} past interactions):`,
+              ...lines,
+              "Match their style directly."
+            ].join("\n");
+          }
+        }
+      } catch {
+      }
+    }
+    const workingMemory = new WorkingMemory(this.graph, { max_nodes: 50 });
+    for (const node of personalNodes.slice(-20)) {
+      workingMemory.put(node);
+    }
+    return {
+      entity_id: entityId,
+      entity_label: entity.label,
+      entity_type: entity.type,
+      personality_prompt: personalityPrompt,
+      personal_nodes: personalNodes,
+      shared_nodes: sharedNodes,
+      parent_entity_labels: parents.map((p) => p.label),
+      working_memory: workingMemory
+    };
+  }
+};
+
+// packages/daemon/src/SessionManager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  inferenceEngine;
+  eventBus;
+  graph;
+  constructor(deps = {}) {
+    this.inferenceEngine = deps.inferenceEngine;
+    this.eventBus = deps.eventBus;
+    this.graph = deps.graph;
+  }
+  /**
+   * Create a new session with status 'pending'.
+   */
+  createSession(req) {
+    const id = crypto.randomUUID();
+    const session = {
+      id,
+      task: req.task,
+      skill: req.skill,
+      entity_id: req.entity_id,
+      status: "pending",
+      created_at: Date.now(),
+      steps: []
+    };
+    this.sessions.set(id, session);
+    return session;
+  }
+  /**
+   * Transition session to 'running' and optionally invoke inference engine.
+   */
+  async startSession(id) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "running";
+    session.started_at = Date.now();
+    this.emit({
+      type: "session.started",
+      session_id: session.id,
+      task: session.task
+    });
+    if (this.inferenceEngine) {
+      try {
+        const plan = await this.inferenceEngine.resolve(session.task);
+        session.plan = plan;
+        if (plan.skill) {
+          session.skill = plan.skill;
+        }
+      } catch {
+      }
+    }
+    return session;
+  }
+  /**
+   * Append a step to a running session.
+   */
+  addStep(id, description, result) {
+    const session = this.getSessionOrThrow(id);
+    const step = {
+      index: session.steps.length,
+      description,
+      result,
+      started_at: Date.now()
+    };
+    session.steps.push(step);
+    this.emit({
+      type: "session.step",
+      session_id: session.id,
+      step: description,
+      result: result ?? null
+    });
+    return step;
+  }
+  /**
+   * Mark session as completed with a result.
+   */
+  completeSession(id, result) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "completed";
+    session.completed_at = Date.now();
+    session.result = result;
+    this.emit({
+      type: "session.completed",
+      session_id: session.id,
+      result: result ?? null
+    });
+    return session;
+  }
+  /**
+   * Mark session as failed with an error message.
+   */
+  failSession(id, error) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "failed";
+    session.completed_at = Date.now();
+    session.error = error;
+    this.emit({
+      type: "session.failed",
+      session_id: session.id,
+      error
+    });
+    return session;
+  }
+  /**
+   * Cancel a session.
+   */
+  cancelSession(id) {
+    const session = this.getSessionOrThrow(id);
+    session.status = "cancelled";
+    session.completed_at = Date.now();
+    session.error = "cancelled";
+    this.emit({
+      type: "session.failed",
+      session_id: session.id,
+      error: "cancelled"
+    });
+    return session;
+  }
+  /**
+   * Get session by ID, or null if not found.
+   */
+  getSession(id) {
+    return this.sessions.get(id) ?? null;
+  }
+  /**
+   * List all sessions sorted by created_at descending.
+   */
+  listSessions() {
+    return [...this.sessions.values()].sort(
+      (a, b) => b.created_at - a.created_at
+    );
+  }
+  /**
+   * End-to-end session run: create -> start -> resolve -> step -> complete.
+   * Wraps everything in try/catch to fail gracefully.
+   */
+  async runSession(req) {
+    let enrichedReq = req;
+    if (req.entity_id && this.graph) {
+      const loader = new EntityScopedContextLoader(this.graph);
+      const scopedCtx = loader.load(req.entity_id);
+      if (scopedCtx?.personality_prompt) {
+        enrichedReq = {
+          ...req,
+          context: {
+            ...req.context,
+            system_context: [
+              scopedCtx.personality_prompt,
+              ...req.context?.system_context != null ? [String(req.context.system_context)] : []
+            ].join("\n\n"),
+            entity_label: scopedCtx.entity_label,
+            parent_entity_labels: scopedCtx.parent_entity_labels
+          }
+        };
+      }
+    }
+    const session = this.createSession(enrichedReq);
+    try {
+      await this.startSession(session.id);
+      this.addStep(session.id, `Extracting entities from: "${req.task.slice(0, 60)}${req.task.length > 60 ? "\u2026" : ""}"`);
+      this.addStep(session.id, "Querying knowledge graph (structural + semantic)\u2026");
+      if (session.plan) {
+        const edge = session.plan.selected_edge;
+        if (edge) {
+          this.addStep(
+            session.id,
+            `Selected plan: ${edge.from_label} \u2192 ${edge.to_label} (weight: ${edge.weight.toFixed(2)}, mode: ${edge.mode})`,
+            session.plan
+          );
+        } else {
+          this.addStep(session.id, `No prior plan found \u2014 bootstrapping from scratch`, session.plan);
+        }
+        if (session.plan.skill) {
+          this.addStep(session.id, `Matched skill: /${session.plan.skill}`);
+        }
+      } else {
+        this.addStep(session.id, "No inference engine connected \u2014 executing task directly");
+      }
+      this.addStep(session.id, "Executing\u2026");
+      const output = session.plan?.reasoning ?? "Task queued \u2014 no plan selected";
+      this.addStep(session.id, `Completed: ${output}`);
+      this.completeSession(session.id, {
+        output,
+        plan: session.plan ?? null,
+        steps: session.steps.length
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.failSession(session.id, message);
+    }
+    return this.sessions.get(session.id);
+  }
+  /**
+   * Return the number of active (running) sessions.
+   */
+  activeSessionCount() {
+    let count = 0;
+    for (const s of this.sessions.values()) {
+      if (s.status === "running") count++;
+    }
+    return count;
+  }
+  // ─── Private helpers ───────────────────────────────
+  getSessionOrThrow(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new Error(`Session not found: ${id}`);
+    }
+    return session;
+  }
+  emit(event) {
+    if (this.eventBus) {
+      this.eventBus.emit(event);
+    }
+  }
+};
+
+// packages/daemon/src/WebSocketEvents.ts
+var WebSocketEventBus = class {
+  clients = /* @__PURE__ */ new Set();
+  handlers = /* @__PURE__ */ new Set();
+  heartbeatTimer = null;
+  /**
+   * Register a connected WebSocket client.
+   * Automatically removes on close.
+   */
+  addClient(ws) {
+    this.clients.add(ws);
+    ws.on("close", () => {
+      this.clients.delete(ws);
+    });
+    ws.on("error", () => {
+      this.clients.delete(ws);
+    });
+  }
+  /**
+   * Manually remove a WebSocket client.
+   */
+  removeClient(ws) {
+    this.clients.delete(ws);
+  }
+  /**
+   * Emit an event to all local handlers and broadcast to WS clients.
+   */
+  emit(event) {
+    const typed = event;
+    for (const handler of this.handlers) {
+      try {
+        handler(typed);
+      } catch {
+      }
+    }
+    this.broadcast(typed);
+  }
+  /**
+   * Register a local event handler.
+   * Returns an unsubscribe function.
+   */
+  onEvent(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Send an event to all connected WebSocket clients.
+   */
+  broadcast(event) {
+    if (this.clients.size === 0) return;
+    const data = JSON.stringify(event);
+    for (const ws of this.clients) {
+      try {
+        ws.send(data);
+      } catch {
+        this.clients.delete(ws);
+      }
+    }
+  }
+  /**
+   * Start a periodic heartbeat that emits daemon.stats events.
+   * Runs every 30 seconds.
+   */
+  startStatsHeartbeat(getStats) {
+    this.stopStatsHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      const stats = getStats();
+      this.emit({
+        type: "daemon.stats",
+        graph_nodes: stats.graph_nodes,
+        active_sessions: stats.active_sessions
+      });
+    }, 3e4);
+  }
+  /**
+   * Stop the stats heartbeat.
+   */
+  stopStatsHeartbeat() {
+    if (this.heartbeatTimer !== null) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * Get the number of connected WS clients.
+   */
+  clientCount() {
+    return this.clients.size;
+  }
+  /**
+   * Get the number of registered local handlers.
+   */
+  handlerCount() {
+    return this.handlers.size;
+  }
+};
+
+// packages/daemon/src/BackgroundWorkers.ts
+var DEFAULT_CONFIG2 = {
+  decay_interval_ms: 6 * 60 * 60 * 1e3,
+  // 6 hours
+  deferred_trace_interval_ms: 6e4,
+  // 60 seconds
+  compactor_interval_ms: 24 * 60 * 60 * 1e3,
+  // 24 hours
+  enrichment_interval_ms: 5 * 60 * 1e3
+  // 5 minutes
+};
+var BackgroundWorkers = class {
+  graph;
+  decayScheduler;
+  traceStore;
+  config;
+  timers = /* @__PURE__ */ new Map();
+  lastRunTimes = /* @__PURE__ */ new Map();
+  running = false;
+  constructor(deps = {}) {
+    this.graph = deps.graph;
+    this.decayScheduler = deps.decayScheduler;
+    this.traceStore = deps.traceStore;
+    this.config = { ...DEFAULT_CONFIG2, ...deps.config };
+  }
+  /**
+   * Start all background workers.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    if (this.decayScheduler) {
+      const timer = setInterval(async () => {
+        try {
+          await this.decayScheduler.runCycle();
+          this.lastRunTimes.set("decay", Date.now());
+        } catch (err) {
+          console.error("[BackgroundWorkers] Decay cycle failed:", err);
+        }
+      }, this.config.decay_interval_ms);
+      this.timers.set("decay", timer);
+    }
+    if (this.traceStore) {
+      const timer = setInterval(() => {
+        try {
+          this.resolveDeferredTraces();
+          this.lastRunTimes.set("deferred_traces", Date.now());
+        } catch (err) {
+          console.error("[BackgroundWorkers] Deferred trace resolution failed:", err);
+        }
+      }, this.config.deferred_trace_interval_ms);
+      this.timers.set("deferred_traces", timer);
+    }
+    {
+      const timer = setInterval(() => {
+        console.log("[BackgroundWorkers] compactor not yet implemented");
+        this.lastRunTimes.set("compactor", Date.now());
+      }, this.config.compactor_interval_ms);
+      this.timers.set("compactor", timer);
+    }
+    {
+      const timer = setInterval(() => {
+        console.log("[BackgroundWorkers] enrichment not yet implemented");
+        this.lastRunTimes.set("enrichment", Date.now());
+      }, this.config.enrichment_interval_ms);
+      this.timers.set("enrichment", timer);
+    }
+  }
+  /**
+   * Stop all background workers and clear timers.
+   */
+  stop() {
+    for (const timer of this.timers.values()) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+    this.running = false;
+  }
+  /**
+   * Whether workers are currently running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get status of all registered workers.
+   */
+  getWorkerStatus() {
+    const workerNames = ["decay", "deferred_traces", "compactor", "enrichment"];
+    return workerNames.map((name) => ({
+      name,
+      active: this.timers.has(name),
+      last_run_at: this.lastRunTimes.get(name) ?? null
+    }));
+  }
+  // ─── Private ───────────────────────────────────────
+  /**
+   * Find expired deferred traces and resolve them with signal 0.0.
+   */
+  resolveDeferredTraces() {
+    if (!this.traceStore) return;
+    const now = Date.now();
+    const deferred = this.traceStore.query({ deferred: true, limit: 100 });
+    for (const trace of deferred) {
+      if (trace.deferred_until !== null && trace.deferred_until <= now) {
+        this.traceStore.updateOutcome(trace.id, 0, "timeout", now);
+      }
+    }
+  }
+};
+
+// packages/daemon/src/SkillRegistry.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import YAML2 from "yaml";
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  builtinNames = /* @__PURE__ */ new Set();
+  builtinDir;
+  customDir;
+  constructor(opts) {
+    this.builtinDir = opts?.builtinDir ?? join(homedir2(), ".0agent", "skills", "builtin");
+    this.customDir = opts?.customDir ?? join(homedir2(), ".0agent", "skills", "custom");
+  }
+  /**
+   * Load all skills from builtin + custom directories.
+   */
+  async loadAll() {
+    this.skills.clear();
+    this.builtinNames.clear();
+    this.loadFromDir(this.builtinDir, true);
+    this.loadFromDir(this.customDir, false);
+  }
+  loadFromDir(dir, isBuiltin) {
+    if (!existsSync2(dir)) return;
+    const files = readdirSync(dir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    for (const file of files) {
+      try {
+        const raw = readFileSync2(join(dir, file), "utf8");
+        const skill = YAML2.parse(raw);
+        if (skill.name) {
+          this.skills.set(skill.name, skill);
+          if (isBuiltin) this.builtinNames.add(skill.name);
+        }
+      } catch (err) {
+        console.warn(`Failed to load skill ${file}: ${err}`);
+      }
+    }
+  }
+  /**
+   * Reload all skills (after create/delete).
+   */
+  async reload() {
+    await this.loadAll();
+  }
+  get(name) {
+    const normalized = name.replace(/^\//, "");
+    return this.skills.get(normalized);
+  }
+  list() {
+    return [...this.skills.values()];
+  }
+  isBuiltin(name) {
+    return this.builtinNames.has(name);
+  }
+  /**
+   * Create a custom skill. Returns the SkillDefinition.
+   * Throws if name conflicts with built-in.
+   */
+  createCustom(name, yamlContent) {
+    if (this.builtinNames.has(name)) {
+      throw new Error(`Cannot override built-in skill: ${name}`);
+    }
+    mkdirSync(this.customDir, { recursive: true });
+    const filePath = join(this.customDir, `${name}.yaml`);
+    writeFileSync(filePath, yamlContent, "utf8");
+    const skill = YAML2.parse(yamlContent);
+    this.skills.set(name, skill);
+    return skill;
+  }
+  /**
+   * Remove a custom skill. Throws if built-in.
+   */
+  removeCustom(name) {
+    if (this.builtinNames.has(name)) {
+      throw new Error(`Cannot delete built-in skill: ${name}`);
+    }
+    const filePath = join(this.customDir, `${name}.yaml`);
+    if (existsSync2(filePath)) {
+      unlinkSync(filePath);
+    }
+    this.skills.delete(name);
+  }
+  get size() {
+    return this.skills.size;
+  }
+};
+
+// packages/daemon/src/HTTPServer.ts
+import { Hono as Hono8 } from "hono";
+import { serve } from "@hono/node-server";
+
+// packages/daemon/src/routes/health.ts
+import { Hono } from "hono";
+function healthRoutes(deps) {
+  const app = new Hono();
+  app.get("/", (c) => {
+    const status = deps.getStatus();
+    return c.json({ ok: true, timestamp: Date.now(), ...status });
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/sessions.ts
+import { Hono as Hono2 } from "hono";
+function sessionRoutes(deps) {
+  const app = new Hono2();
+  app.post("/", async (c) => {
+    const body = await c.req.json();
+    if (!body.task || typeof body.task !== "string") {
+      return c.json({ error: "task is required and must be a string" }, 400);
+    }
+    const session = deps.sessions.createSession(body);
+    deps.sessions.runSession(body).catch(() => {
+    });
+    return c.json({ session_id: session.id, status: "pending" }, 201);
+  });
+  app.get("/", (c) => {
+    const sessions = deps.sessions.listSessions();
+    return c.json(sessions);
+  });
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const session = deps.sessions.getSession(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    return c.json(session);
+  });
+  app.delete("/:id", (c) => {
+    const id = c.req.param("id");
+    const session = deps.sessions.getSession(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    deps.sessions.cancelSession(id);
+    return c.json({ ok: true });
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/graph.ts
+import { Hono as Hono3 } from "hono";
+function graphRoutes(deps) {
+  const app = new Hono3();
+  app.get("/nodes", (c) => {
+    const graph_id = c.req.query("graph_id");
+    const type = c.req.query("type");
+    const limitStr = c.req.query("limit");
+    const limit = limitStr ? parseInt(limitStr, 10) : 50;
+    const results = deps.graph.queryStructural({
+      graph_id: graph_id || void 0,
+      node_type: type || void 0,
+      limit
+    });
+    return c.json(results.map((r) => r.node));
+  });
+  app.get("/nodes/:id", (c) => {
+    const id = c.req.param("id");
+    const node = deps.graph.getNode(id);
+    if (!node) {
+      return c.json({ error: "Node not found" }, 404);
+    }
+    return c.json(node);
+  });
+  app.get("/edges", (c) => {
+    const from_node = c.req.query("from_node");
+    const to_node = c.req.query("to_node");
+    const type = c.req.query("type");
+    let edges;
+    if (from_node && to_node) {
+      edges = deps.graph.getEdgesBetween(from_node, to_node);
+    } else if (from_node) {
+      edges = deps.graph.getEdgesFrom(from_node);
+    } else if (to_node) {
+      edges = deps.graph.getEdgesTo(to_node);
+    } else {
+      edges = deps.graph.getAllEdges();
+    }
+    if (type) {
+      edges = edges.filter((e) => e.type === type);
+    }
+    return c.json(edges);
+  });
+  app.post("/query", async (c) => {
+    const body = await c.req.json();
+    const results = deps.graph.queryMerged({
+      structural: body.structural ?? {},
+      semantic: body.semantic,
+      limit: body.limit
+    });
+    return c.json(results);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/entities.ts
+import { Hono as Hono4 } from "hono";
+function entityRoutes(deps) {
+  const app = new Hono4();
+  app.get("/", (c) => {
+    const results = deps.graph.queryStructural({
+      node_type: "entity",
+      limit: 200
+    });
+    return c.json(results.map((r) => r.node));
+  });
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const node = deps.graph.getNode(id);
+    if (!node) {
+      return c.json({ error: "Entity not found" }, 404);
+    }
+    try {
+      const subgraph = deps.graph.getSubGraph(id, 2);
+      const nodes = subgraph.getNodes();
+      const edges = subgraph.getEdges();
+      let last_seen = node.last_seen;
+      for (const n of nodes) {
+        if (n.last_seen > last_seen) {
+          last_seen = n.last_seen;
+        }
+      }
+      return c.json({
+        ...node,
+        subgraph_summary: {
+          nodeCount: nodes.length,
+          edgeCount: edges.length,
+          last_seen
+        }
+      });
+    } catch {
+      return c.json({
+        ...node,
+        subgraph_summary: {
+          nodeCount: 1,
+          edgeCount: 0,
+          last_seen: node.last_seen
+        }
+      });
+    }
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/traces.ts
+import { Hono as Hono5 } from "hono";
+function traceRoutes(deps) {
+  const app = new Hono5();
+  app.get("/", (c) => {
+    const session_id = c.req.query("session_id");
+    const deferredStr = c.req.query("deferred");
+    const limitStr = c.req.query("limit");
+    const deferred = deferredStr !== void 0 && deferredStr !== "" ? deferredStr === "true" : void 0;
+    const limit = limitStr ? parseInt(limitStr, 10) : void 0;
+    const traces = deps.traceStore.query({
+      session_id: session_id || void 0,
+      deferred,
+      limit
+    });
+    return c.json(traces);
+  });
+  app.get("/:id", (c) => {
+    const id = c.req.param("id");
+    const trace = deps.traceStore.get(id);
+    if (!trace) {
+      return c.json({ error: "Trace not found" }, 404);
+    }
+    return c.json(trace);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/subagents.ts
+import { Hono as Hono6 } from "hono";
+function subagentRoutes() {
+  const app = new Hono6();
+  app.get("/", (c) => {
+    return c.json([]);
+  });
+  app.delete("/:id", (c) => {
+    return c.json({ error: "No subagent system in Phase 2" }, 404);
+  });
+  return app;
+}
+
+// packages/daemon/src/routes/skills.ts
+import { Hono as Hono7 } from "hono";
+function skillRoutes(deps) {
+  const app = new Hono7();
+  app.get("/", (c) => {
+    const skills = deps.skillRegistry.list();
+    return c.json(skills);
+  });
+  app.get("/:name", (c) => {
+    const name = c.req.param("name");
+    const skill = deps.skillRegistry.get(name);
+    if (!skill) {
+      return c.json({ error: "Skill not found" }, 404);
+    }
+    return c.json(skill);
+  });
+  app.post("/", async (c) => {
+    const body = await c.req.json();
+    if (!body.name || typeof body.name !== "string") {
+      return c.json({ error: "name is required" }, 400);
+    }
+    if (!body.yaml || typeof body.yaml !== "string") {
+      return c.json({ error: "yaml is required" }, 400);
+    }
+    if (deps.skillRegistry.isBuiltin(body.name)) {
+      return c.json({ error: "Conflicts with built-in skill" }, 409);
+    }
+    try {
+      const skill = deps.skillRegistry.createCustom(body.name, body.yaml);
+      return c.json(skill, 201);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+  app.delete("/:name", (c) => {
+    const name = c.req.param("name");
+    if (deps.skillRegistry.isBuiltin(name)) {
+      return c.json({ error: "Cannot delete built-in skill" }, 403);
+    }
+    const skill = deps.skillRegistry.get(name);
+    if (!skill) {
+      return c.json({ error: "Skill not found" }, 404);
+    }
+    try {
+      deps.skillRegistry.removeCustom(name);
+      return c.json({ ok: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return c.json({ error: message }, 500);
+    }
+  });
+  return app;
+}
+
+// packages/daemon/src/HTTPServer.ts
+var HTTPServer = class {
+  app;
+  server = null;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+    this.app = new Hono8();
+    this.app.route("/api/health", healthRoutes({ getStatus: deps.getStatus }));
+    this.app.route("/api/sessions", sessionRoutes({ sessions: deps.sessions }));
+    this.app.route("/api/graph", graphRoutes({ graph: deps.graph }));
+    this.app.route("/api/entities", entityRoutes({ graph: deps.graph }));
+    this.app.route("/api/traces", traceRoutes({ traceStore: deps.traceStore }));
+    this.app.route("/api/subagents", subagentRoutes());
+    this.app.route("/api/skills", skillRoutes({ skillRegistry: deps.skillRegistry }));
+    this.app.get("/", (c) => {
+      return c.json({ name: "0agent-daemon", version: "2.0.0" });
+    });
+  }
+  start() {
+    return new Promise((resolve4) => {
+      this.server = serve(
+        {
+          fetch: this.app.fetch,
+          port: this.deps.port,
+          hostname: this.deps.host
+        },
+        () => {
+          resolve4();
+        }
+      );
+    });
+  }
+  stop() {
+    return new Promise((resolve4, reject) => {
+      if (!this.server) {
+        resolve4();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) reject(err);
+        else resolve4();
+      });
+    });
+  }
+  getApp() {
+    return this.app;
+  }
+};
+
+// packages/daemon/src/ZeroAgentDaemon.ts
+var ZeroAgentDaemon = class {
+  config = null;
+  adapter = null;
+  graph = null;
+  traceStore = null;
+  inferenceEngine = null;
+  sessionManager = null;
+  eventBus = null;
+  httpServer = null;
+  skillRegistry = null;
+  backgroundWorkers = null;
+  startedAt = 0;
+  pidFilePath;
+  constructor() {
+    this.pidFilePath = resolve2(homedir3(), ".0agent", "daemon.pid");
+  }
+  async start(opts) {
+    this.config = await loadConfig(opts?.config_path);
+    const dotDir = resolve2(homedir3(), ".0agent");
+    if (!existsSync3(dotDir)) {
+      mkdirSync2(dotDir, { recursive: true });
+    }
+    this.adapter = new SQLiteAdapter({ db_path: this.config.graph.db_path });
+    this.graph = new KnowledgeGraph(this.adapter);
+    this.traceStore = new TraceStore(this.adapter);
+    const aliasIndex = new AliasIndex(this.adapter);
+    const resolver = new NodeResolutionService(this.graph, aliasIndex, null, null);
+    const policy = new SelectionPolicy();
+    this.inferenceEngine = new InferenceEngine(this.graph, resolver, policy);
+    this.skillRegistry = new SkillRegistry();
+    await this.skillRegistry.loadAll();
+    this.eventBus = new WebSocketEventBus();
+    this.sessionManager = new SessionManager({
+      inferenceEngine: this.inferenceEngine,
+      eventBus: this.eventBus
+    });
+    this.backgroundWorkers = new BackgroundWorkers({
+      graph: this.graph,
+      traceStore: this.traceStore
+    });
+    this.backgroundWorkers.start();
+    this.eventBus.startStatsHeartbeat(() => ({
+      graph_nodes: this.graph.nodeCount(),
+      active_sessions: this.sessionManager.activeSessionCount()
+    }));
+    this.startedAt = Date.now();
+    this.httpServer = new HTTPServer({
+      port: this.config.server.port,
+      host: this.config.server.host,
+      sessions: this.sessionManager,
+      graph: this.graph,
+      traceStore: this.traceStore,
+      skillRegistry: this.skillRegistry,
+      getStatus: () => this.getStatus()
+    });
+    await this.httpServer.start();
+    writeFileSync2(this.pidFilePath, String(process.pid), "utf8");
+    console.log(
+      `[0agent] Daemon started on ${this.config.server.host}:${this.config.server.port} (PID: ${process.pid})`
+    );
+    const shutdown = async () => {
+      console.log("[0agent] Shutting down...");
+      await this.stop();
+      process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+  }
+  async stop() {
+    if (this.httpServer) {
+      await this.httpServer.stop();
+      this.httpServer = null;
+    }
+    if (this.eventBus) {
+      this.eventBus.stopStatsHeartbeat();
+      this.eventBus = null;
+    }
+    if (this.backgroundWorkers) {
+      this.backgroundWorkers.stop();
+      this.backgroundWorkers = null;
+    }
+    this.sessionManager = null;
+    this.skillRegistry = null;
+    this.inferenceEngine = null;
+    this.traceStore = null;
+    if (this.graph) {
+      this.graph.close();
+      this.graph = null;
+    }
+    this.adapter = null;
+    if (existsSync3(this.pidFilePath)) {
+      try {
+        unlinkSync2(this.pidFilePath);
+      } catch {
+      }
+    }
+    console.log("[0agent] Daemon stopped.");
+  }
+  getStatus() {
+    const runningWorkers = [];
+    if (this.backgroundWorkers?.isRunning()) {
+      const statuses = this.backgroundWorkers.getWorkerStatus();
+      for (const ws of statuses) {
+        if (ws.active) runningWorkers.push(ws.name);
+      }
+    }
+    return {
+      version: "2.0.0",
+      uptime_ms: this.startedAt ? Date.now() - this.startedAt : 0,
+      graph_nodes: this.graph?.nodeCount() ?? 0,
+      graph_edges: this.graph?.edgeCount() ?? 0,
+      active_sessions: this.sessionManager?.activeSessionCount() ?? 0,
+      mcp_servers_connected: 0,
+      workers_running: runningWorkers,
+      sandbox_backend: this.config?.sandbox.backend ?? "auto"
+    };
+  }
+};
+
+// packages/daemon/src/start.ts
+import { resolve as resolve3 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { existsSync as existsSync4 } from "node:fs";
+var CONFIG_PATH = process.env["ZEROAGENT_CONFIG"] ?? resolve3(homedir4(), ".0agent", "config.yaml");
+if (!existsSync4(CONFIG_PATH)) {
+  console.error(`
+  0agent is not initialised.
+
+  Run: npx 0agent@latest init
+`);
+  process.exit(1);
+}
+var daemon = new ZeroAgentDaemon();
+try {
+  await daemon.start({ config_path: CONFIG_PATH });
+} catch (err) {
+  console.error("Failed to start daemon:", err instanceof Error ? err.message : err);
+  process.exit(1);
+}