@tini-works/inv-node 0.1.4

package/dist/cli.js

@@ -0,0 +1,2051 @@
+// @bun
+// src/cli.ts
+import * as readline from "readline";
+import { writeFileSync } from "fs";
+function generateInvConfig(input) {
+  return {
+    node: {
+      name: input.name,
+      vertical: input.vertical,
+      project: input.project,
+      owner: input.owner
+    },
+    server: {
+      url: input.serverUrl,
+      token: input.token
+    },
+    database: {
+      path: input.dbPath
+    }
+  };
+}
+function generateMcpConfig(configPath) {
+  return {
+    mcpServers: {
+      inventory: {
+        command: "bunx",
+        args: ["@tini-works/inv-node@latest", "serve", configPath]
+      }
+    }
+  };
+}
+var VERTICALS = ["pm", "design", "dev", "qa", "devops"];
+function ask(rl, question, defaultValue) {
+  const prompt = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+async function runWizard() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log("");
+  console.log("Inventory Node Setup");
+  console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("");
+  const name = await ask(rl, "Node name");
+  const verticalInput = await ask(rl, `Vertical (${VERTICALS.join("/")})`, "dev");
+  if (!VERTICALS.includes(verticalInput)) {
+    console.error(`Invalid vertical: ${verticalInput}. Must be one of: ${VERTICALS.join(", ")}`);
+    rl.close();
+    process.exit(1);
+  }
+  const vertical = verticalInput;
+  const project = await ask(rl, "Project");
+  const owner = await ask(rl, "Owner");
+  console.log("");
+  const serverUrl = await ask(rl, "Server URL", "ws://localhost:8080/ws");
+  const token = await ask(rl, "Auth token");
+  console.log("");
+  const dbPath = await ask(rl, "Database path", "./inventory.db");
+  rl.close();
+  const invConfig = generateInvConfig({ name, vertical, project, owner, serverUrl, token, dbPath });
+  const mcpConfig = generateMcpConfig("./inv-config.json");
+  console.log("");
+  const invConfigPath = "./inv-config.json";
+  writeFileSync(invConfigPath, JSON.stringify(invConfig, null, 2) + `
+`);
+  console.log(`Writing ${invConfigPath}... \u2713`);
+  const mcpConfigPath = "./.mcp.json";
+  writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2) + `
+`);
+  console.log(`Writing ${mcpConfigPath}... \u2713`);
+  console.log("");
+  console.log("Setup complete! Start Claude Code:");
+  console.log("  claude");
+  console.log("");
+}
+
+// src/channel.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync, writeFileSync as writeFileSync2, existsSync } from "fs";
+
+// src/logger.ts
+class Logger {
+  name;
+  writer = (line) => process.stderr.write(line + `
+`);
+  constructor(name) {
+    this.name = name;
+  }
+  setWriter(fn) {
+    this.writer = fn;
+  }
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  log(level, msg, data) {
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      logger: this.name,
+      msg,
+      ...data
+    };
+    this.writer(JSON.stringify(entry));
+  }
+}
+
+// src/store.ts
+import { Database } from "bun:sqlite";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../shared/src/types.ts
+var UPSTREAM_VERTICALS = {
+  pm: [],
+  design: ["pm"],
+  dev: ["pm", "design"],
+  qa: ["dev"],
+  devops: ["dev", "qa"]
+};
+// ../shared/src/messages.ts
+import { randomUUID } from "crypto";
+function createEnvelope(fromNode, toNode, projectId, payload) {
+  return {
+    messageId: randomUUID(),
+    fromNode,
+    toNode,
+    projectId,
+    timestamp: new Date().toISOString(),
+    payload
+  };
+}
+function parseEnvelope(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed.messageId || !parsed.payload?.type) {
+    throw new Error("Invalid envelope");
+  }
+  return parsed;
+}
+// src/store.ts
+function mapNodeRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    vertical: row.vertical,
+    project: row.project,
+    owner: row.owner,
+    isAI: row.is_ai === 1,
+    createdAt: row.created_at
+  };
+}
+function mapItemRow(row) {
+  return {
+    id: row.id,
+    nodeId: row.node_id,
+    kind: row.kind,
+    title: row.title,
+    body: row.body,
+    externalRef: row.external_ref,
+    state: row.state,
+    evidence: row.evidence,
+    confirmedBy: row.confirmed_by,
+    confirmedAt: row.confirmed_at,
+    version: row.version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function mapTraceRow(row) {
+  return {
+    id: row.id,
+    fromItemId: row.from_item_id,
+    fromNodeId: row.from_node_id,
+    toItemId: row.to_item_id,
+    toNodeId: row.to_node_id,
+    relation: row.relation,
+    confirmedBy: row.confirmed_by,
+    confirmedAt: row.confirmed_at,
+    createdAt: row.created_at
+  };
+}
+function mapSignalRow(row) {
+  return {
+    id: row.id,
+    kind: row.kind,
+    sourceItem: row.source_item,
+    sourceNode: row.source_node,
+    targetItem: row.target_item,
+    targetNode: row.target_node,
+    payload: row.payload,
+    processed: row.processed === 1,
+    createdAt: row.created_at
+  };
+}
+function mapTransitionRow(row) {
+  return {
+    id: row.id,
+    itemId: row.item_id,
+    kind: row.kind,
+    from: row.from_s,
+    to: row.to_s,
+    evidence: row.evidence,
+    reason: row.reason,
+    actor: row.actor,
+    timestamp: row.timestamp
+  };
+}
+function mapQueryRow(row) {
+  return {
+    id: row.id,
+    askerId: row.asker_id,
+    askerNode: row.asker_node,
+    question: row.question,
+    context: row.context,
+    targetNode: row.target_node,
+    resolved: row.resolved === 1,
+    createdAt: row.created_at
+  };
+}
+function mapQueryResponseRow(row) {
+  return {
+    id: row.id,
+    queryId: row.query_id,
+    responderId: row.responder_id,
+    nodeId: row.node_id,
+    answer: row.answer,
+    isAI: row.is_ai === 1,
+    createdAt: row.created_at
+  };
+}
+function mapPendingActionRow(row) {
+  return {
+    id: row.id,
+    messageType: row.message_type,
+    envelope: row.envelope,
+    summary: row.summary,
+    proposed: row.proposed,
+    status: row.status,
+    createdAt: row.created_at
+  };
+}
+function mapChangeRequestRow(row) {
+  return {
+    id: row.id,
+    proposerNode: row.proposer_node,
+    proposerId: row.proposer_id,
+    targetItemId: row.target_item_id,
+    description: row.description,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function mapVoteRow(row) {
+  return {
+    id: row.id,
+    crId: row.cr_id,
+    nodeId: row.node_id,
+    vertical: row.vertical,
+    approve: row.approve === 1,
+    reason: row.reason,
+    createdAt: row.created_at
+  };
+}
+function mapPairSessionRow(row) {
+  return {
+    id: row.id,
+    initiatorNode: row.initiator_node,
+    partnerNode: row.partner_node,
+    project: row.project,
+    status: row.status,
+    startedAt: row.started_at,
+    endedAt: row.ended_at
+  };
+}
+function mapChecklistItemRow(row) {
+  return {
+    id: row.id,
+    itemId: row.item_id,
+    text: row.text,
+    checked: row.checked === 1,
+    createdAt: row.created_at
+  };
+}
+function mapKindMappingRow(row) {
+  return {
+    id: row.id,
+    fromVertical: row.from_vertical,
+    fromKind: row.from_kind,
+    toVertical: row.to_vertical,
+    toKind: row.to_kind,
+    createdAt: row.created_at
+  };
+}
+
+class Store {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA foreign_keys = ON;");
+    this.migrate();
+  }
+  close() {
+    this.db.close();
+  }
+  migrate() {
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        vertical TEXT NOT NULL,
+        project TEXT NOT NULL,
+        owner TEXT NOT NULL,
+        is_ai INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS items (
+        id TEXT PRIMARY KEY,
+        node_id TEXT NOT NULL REFERENCES nodes(id),
+        kind TEXT NOT NULL,
+        title TEXT NOT NULL,
+        body TEXT DEFAULT '',
+        external_ref TEXT DEFAULT '',
+        state TEXT DEFAULT 'unverified',
+        evidence TEXT DEFAULT '',
+        confirmed_by TEXT DEFAULT '',
+        confirmed_at TEXT,
+        version INTEGER DEFAULT 1,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS traces (
+        id TEXT PRIMARY KEY,
+        from_item_id TEXT NOT NULL REFERENCES items(id),
+        from_node_id TEXT NOT NULL REFERENCES nodes(id),
+        to_item_id TEXT NOT NULL REFERENCES items(id),
+        to_node_id TEXT NOT NULL REFERENCES nodes(id),
+        relation TEXT NOT NULL,
+        confirmed_by TEXT DEFAULT '',
+        confirmed_at TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS signals (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        source_item TEXT NOT NULL,
+        source_node TEXT NOT NULL,
+        target_item TEXT NOT NULL,
+        target_node TEXT NOT NULL,
+        payload TEXT DEFAULT '',
+        processed INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS transitions (
+        id TEXT PRIMARY KEY,
+        item_id TEXT NOT NULL REFERENCES items(id),
+        kind TEXT NOT NULL,
+        from_s TEXT NOT NULL,
+        to_s TEXT NOT NULL,
+        evidence TEXT DEFAULT '',
+        reason TEXT DEFAULT '',
+        actor TEXT NOT NULL,
+        timestamp TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS queries (
+        id TEXT PRIMARY KEY,
+        asker_id TEXT NOT NULL,
+        asker_node TEXT NOT NULL,
+        question TEXT NOT NULL,
+        context TEXT DEFAULT '',
+        target_node TEXT DEFAULT '',
+        resolved INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS query_responses (
+        id TEXT PRIMARY KEY,
+        query_id TEXT NOT NULL REFERENCES queries(id),
+        responder_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        answer TEXT NOT NULL,
+        is_ai INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS pending_actions (
+        id TEXT PRIMARY KEY,
+        message_type TEXT NOT NULL,
+        envelope TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        proposed TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS change_requests (
+        id TEXT PRIMARY KEY,
+        proposer_node TEXT NOT NULL,
+        proposer_id TEXT NOT NULL,
+        target_item_id TEXT NOT NULL,
+        description TEXT NOT NULL,
+        status TEXT DEFAULT 'draft',
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS votes (
+        id TEXT PRIMARY KEY,
+        cr_id TEXT NOT NULL REFERENCES change_requests(id),
+        node_id TEXT NOT NULL,
+        vertical TEXT NOT NULL,
+        approve INTEGER NOT NULL,
+        reason TEXT DEFAULT '',
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(cr_id, node_id)
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS pair_sessions (
+        id TEXT PRIMARY KEY,
+        initiator_node TEXT NOT NULL,
+        partner_node TEXT NOT NULL,
+        project TEXT NOT NULL,
+        status TEXT DEFAULT 'pending',
+        started_at TEXT DEFAULT (datetime('now')),
+        ended_at TEXT
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS checklists (
+        id TEXT PRIMARY KEY,
+        item_id TEXT NOT NULL,
+        text TEXT NOT NULL,
+        checked INTEGER DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS kind_mappings (
+        id TEXT PRIMARY KEY,
+        from_vertical TEXT NOT NULL,
+        from_kind TEXT NOT NULL,
+        to_vertical TEXT NOT NULL,
+        to_kind TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(from_vertical, from_kind, to_vertical)
+      )
+    `);
+  }
+  createNode(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO nodes (id, name, vertical, project, owner, is_ai)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.name, input.vertical, input.project, input.owner, input.isAI ? 1 : 0);
+    if (!row)
+      throw new Error("Failed to create node");
+    return mapNodeRow(row);
+  }
+  getNode(id) {
+    const row = this.db.query("SELECT * FROM nodes WHERE id = ?").get(id);
+    return row ? mapNodeRow(row) : null;
+  }
+  listNodes(project) {
+    const rows = this.db.query("SELECT * FROM nodes WHERE project = ?").all(project);
+    return rows.map(mapNodeRow);
+  }
+  createItem(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO items (id, node_id, kind, title, body, external_ref)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.nodeId, input.kind, input.title, input.body ?? "", input.externalRef ?? "");
+    if (!row)
+      throw new Error("Failed to create item");
+    return mapItemRow(row);
+  }
+  getItem(id) {
+    const row = this.db.query("SELECT * FROM items WHERE id = ?").get(id);
+    return row ? mapItemRow(row) : null;
+  }
+  listItems(nodeId) {
+    const rows = this.db.query("SELECT * FROM items WHERE node_id = ?").all(nodeId);
+    return rows.map(mapItemRow);
+  }
+  updateItemStatus(id, state, evidence, confirmedBy) {
+    const stmt = this.db.query(`UPDATE items
+       SET state = ?, evidence = ?, confirmed_by = ?,
+           confirmed_at = datetime('now'),
+           version = version + 1,
+           updated_at = datetime('now')
+       WHERE id = ?
+       RETURNING *`);
+    const row = stmt.get(state, evidence, confirmedBy, id);
+    if (!row)
+      throw new Error(`Item not found: ${id}`);
+    return mapItemRow(row);
+  }
+  findItemsByExternalRef(externalRef) {
+    const rows = this.db.query("SELECT * FROM items WHERE external_ref = ?").all(externalRef);
+    return rows.map(mapItemRow);
+  }
+  createTrace(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO traces (id, from_item_id, from_node_id, to_item_id, to_node_id, relation)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.fromItemId, input.fromNodeId, input.toItemId, input.toNodeId, input.relation);
+    if (!row)
+      throw new Error("Failed to create trace");
+    return mapTraceRow(row);
+  }
+  getItemTraces(itemId) {
+    const rows = this.db.query("SELECT * FROM traces WHERE from_item_id = ? OR to_item_id = ?").all(itemId, itemId);
+    return rows.map(mapTraceRow);
+  }
+  getDependentTraces(itemId) {
+    const rows = this.db.query("SELECT * FROM traces WHERE to_item_id = ?").all(itemId);
+    return rows.map(mapTraceRow);
+  }
+  getUpstreamTraces(itemId) {
+    const rows = this.db.query("SELECT * FROM traces WHERE from_item_id = ?").all(itemId);
+    return rows.map(mapTraceRow);
+  }
+  createSignal(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO signals (id, kind, source_item, source_node, target_item, target_node, payload)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.kind, input.sourceItem, input.sourceNode, input.targetItem, input.targetNode, input.payload ?? "");
+    if (!row)
+      throw new Error("Failed to create signal");
+    return mapSignalRow(row);
+  }
+  markSignalProcessed(id) {
+    this.db.query("UPDATE signals SET processed = 1 WHERE id = ?").run(id);
+  }
+  recordTransition(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO transitions (id, item_id, kind, from_s, to_s, evidence, reason, actor)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.itemId, input.kind, input.from, input.to, input.evidence ?? "", input.reason ?? "", input.actor);
+    if (!row)
+      throw new Error("Failed to record transition");
+    return mapTransitionRow(row);
+  }
+  getItemTransitions(itemId) {
+    const rows = this.db.query("SELECT * FROM transitions WHERE item_id = ? ORDER BY timestamp").all(itemId);
+    return rows.map(mapTransitionRow);
+  }
+  createQuery(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO queries (id, asker_id, asker_node, question, context, target_node)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.askerId, input.askerNode, input.question, input.context ?? "", input.targetNode ?? "");
+    if (!row)
+      throw new Error("Failed to create query");
+    return mapQueryRow(row);
+  }
+  createQueryResponse(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO query_responses (id, query_id, responder_id, node_id, answer, is_ai)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.queryId, input.responderId, input.nodeId, input.answer, input.isAI ? 1 : 0);
+    if (!row)
+      throw new Error("Failed to create query response");
+    return mapQueryResponseRow(row);
+  }
+  createPendingAction(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO pending_actions (id, message_type, envelope, summary, proposed)
+       VALUES (?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.messageType, input.envelope, input.summary, input.proposed);
+    if (!row)
+      throw new Error("Failed to create pending action");
+    return mapPendingActionRow(row);
+  }
+  listPendingActions() {
+    const rows = this.db.query("SELECT * FROM pending_actions WHERE status = 'pending' ORDER BY created_at").all();
+    return rows.map(mapPendingActionRow);
+  }
+  updatePendingActionStatus(id, status) {
+    this.db.query("UPDATE pending_actions SET status = ? WHERE id = ?").run(status, id);
+  }
+  createChangeRequest(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO change_requests (id, proposer_node, proposer_id, target_item_id, description)
+       VALUES (?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.proposerNode, input.proposerId, input.targetItemId, input.description);
+    if (!row)
+      throw new Error("Failed to create change request");
+    return mapChangeRequestRow(row);
+  }
+  getChangeRequest(id) {
+    const row = this.db.query("SELECT * FROM change_requests WHERE id = ?").get(id);
+    return row ? mapChangeRequestRow(row) : null;
+  }
+  updateChangeRequestStatus(id, status) {
+    const stmt = this.db.query(`UPDATE change_requests
+       SET status = ?, updated_at = datetime('now')
+       WHERE id = ?
+       RETURNING *`);
+    const row = stmt.get(status, id);
+    if (!row)
+      throw new Error(`Change request not found: ${id}`);
+    return mapChangeRequestRow(row);
+  }
+  listChangeRequests(status) {
+    if (status) {
+      const rows2 = this.db.query("SELECT * FROM change_requests WHERE status = ? ORDER BY created_at").all(status);
+      return rows2.map(mapChangeRequestRow);
+    }
+    const rows = this.db.query("SELECT * FROM change_requests ORDER BY created_at").all();
+    return rows.map(mapChangeRequestRow);
+  }
+  createVote(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO votes (id, cr_id, node_id, vertical, approve, reason)
+       VALUES (?, ?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.crId, input.nodeId, input.vertical, input.approve ? 1 : 0, input.reason);
+    if (!row)
+      throw new Error("Failed to create vote");
+    return mapVoteRow(row);
+  }
+  listVotes(crId) {
+    const rows = this.db.query("SELECT * FROM votes WHERE cr_id = ? ORDER BY created_at").all(crId);
+    return rows.map(mapVoteRow);
+  }
+  tallyVotes(crId) {
+    const votes = this.listVotes(crId);
+    let approved = 0;
+    let rejected = 0;
+    for (const vote of votes) {
+      if (vote.approve) {
+        approved++;
+      } else {
+        rejected++;
+      }
+    }
+    return { approved, rejected, total: votes.length };
+  }
+  createPairSession(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO pair_sessions (id, initiator_node, partner_node, project)
+       VALUES (?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.initiatorNode, input.partnerNode, input.project);
+    if (!row)
+      throw new Error("Failed to create pair session");
+    return mapPairSessionRow(row);
+  }
+  getPairSession(id) {
+    const row = this.db.query("SELECT * FROM pair_sessions WHERE id = ?").get(id);
+    return row ? mapPairSessionRow(row) : null;
+  }
+  updatePairSessionStatus(id, status) {
+    if (status === "ended") {
+      const stmt2 = this.db.query(`UPDATE pair_sessions SET status = ?, ended_at = datetime('now') WHERE id = ? RETURNING *`);
+      const row2 = stmt2.get(status, id);
+      if (!row2)
+        throw new Error(`Pair session not found: ${id}`);
+      return mapPairSessionRow(row2);
+    }
+    const stmt = this.db.query(`UPDATE pair_sessions SET status = ? WHERE id = ? RETURNING *`);
+    const row = stmt.get(status, id);
+    if (!row)
+      throw new Error(`Pair session not found: ${id}`);
+    return mapPairSessionRow(row);
+  }
+  listPairSessions(nodeId) {
+    const rows = this.db.query("SELECT * FROM pair_sessions WHERE (initiator_node = ? OR partner_node = ?) AND status != 'ended' ORDER BY started_at").all(nodeId, nodeId);
+    return rows.map(mapPairSessionRow);
+  }
+  createChecklistItem(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO checklists (id, item_id, text)
+       VALUES (?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.itemId, input.text);
+    if (!row)
+      throw new Error("Failed to create checklist item");
+    return mapChecklistItemRow(row);
+  }
+  getChecklistItem(id) {
+    const row = this.db.query("SELECT * FROM checklists WHERE id = ?").get(id);
+    return row ? mapChecklistItemRow(row) : null;
+  }
+  updateChecklistItemChecked(id, checked) {
+    this.db.query("UPDATE checklists SET checked = ? WHERE id = ?").run(checked ? 1 : 0, id);
+  }
+  listChecklistItems(itemId) {
+    const rows = this.db.query("SELECT * FROM checklists WHERE item_id = ? ORDER BY created_at").all(itemId);
+    return rows.map(mapChecklistItemRow);
+  }
+  createKindMapping(input) {
+    const id = randomUUID2();
+    const stmt = this.db.query(`INSERT INTO kind_mappings (id, from_vertical, from_kind, to_vertical, to_kind)
+       VALUES (?, ?, ?, ?, ?)
+       RETURNING *`);
+    const row = stmt.get(id, input.fromVertical, input.fromKind, input.toVertical, input.toKind);
+    if (!row)
+      throw new Error("Failed to create kind mapping");
+    return mapKindMappingRow(row);
+  }
+  getMappedKind(fromVertical, fromKind, toVertical) {
+    const row = this.db.query("SELECT * FROM kind_mappings WHERE from_vertical = ? AND from_kind = ? AND to_vertical = ?").get(fromVertical, fromKind, toVertical);
+    return row ? row.to_kind : null;
+  }
+  listKindMappings() {
+    const rows = this.db.query("SELECT * FROM kind_mappings ORDER BY created_at").all();
+    return rows.map(mapKindMappingRow);
+  }
+  audit(nodeId) {
+    const node = this.getNode(nodeId);
+    if (!node)
+      throw new Error(`Node not found: ${nodeId}`);
+    const items = this.listItems(nodeId);
+    const unverified = [];
+    const proven = [];
+    const suspect = [];
+    const broke = [];
+    const orphans = [];
+    const missingUpstreamRefs = [];
+    const upstreamVerticals = UPSTREAM_VERTICALS[node.vertical];
+    for (const item of items) {
+      switch (item.state) {
+        case "unverified":
+          unverified.push(item.id);
+          break;
+        case "proven":
+          proven.push(item.id);
+          break;
+        case "suspect":
+          suspect.push(item.id);
+          break;
+        case "broke":
+          broke.push(item.id);
+          break;
+      }
+      const traces = this.getItemTraces(item.id);
+      if (traces.length === 0) {
+        orphans.push(item.id);
+      }
+      if (upstreamVerticals.length > 0) {
+        const incomingTraces = this.getDependentTraces(item.id);
+        const hasUpstreamTrace = incomingTraces.some((t) => {
+          const fromNode = this.getNode(t.fromNodeId);
+          return fromNode !== null && upstreamVerticals.includes(fromNode.vertical);
+        });
+        if (!hasUpstreamTrace) {
+          missingUpstreamRefs.push(item.id);
+        }
+      }
+    }
+    return {
+      nodeId,
+      totalItems: items.length,
+      unverified,
+      proven,
+      suspect,
+      broke,
+      orphans,
+      missingUpstreamRefs
+    };
+  }
+}
+
+// src/state.ts
+class StateMachine {
+  rules = [
+    { from: "unverified", kind: "verify", to: "proven" },
+    { from: "proven", kind: "suspect", to: "suspect" },
+    { from: "suspect", kind: "re_verify", to: "proven" },
+    { from: "suspect", kind: "break", to: "broke" },
+    { from: "broke", kind: "fix", to: "proven" }
+  ];
+  canTransition(from, kind) {
+    return this.rules.some((r) => r.from === from && r.kind === kind);
+  }
+  apply(from, kind) {
+    const rule = this.rules.find((r) => r.from === from && r.kind === kind);
+    if (!rule) {
+      throw new Error(`Invalid transition: cannot apply "${kind}" from state "${from}"`);
+    }
+    return rule.to;
+  }
+  availableTransitions(from) {
+    return this.rules.filter((r) => r.from === from).map((r) => r.kind);
+  }
+}
+
+class CRStateMachine {
+  rules = [
+    { from: "draft", kind: "submit", to: "proposed" },
+    { from: "proposed", kind: "open_voting", to: "voting" },
+    { from: "voting", kind: "approve", to: "approved" },
+    { from: "voting", kind: "reject", to: "rejected" },
+    { from: "approved", kind: "apply", to: "applied" },
+    { from: "applied", kind: "archive", to: "archived" },
+    { from: "rejected", kind: "archive", to: "archived" }
+  ];
+  apply(from, kind) {
+    const rule = this.rules.find((r) => r.from === from && r.kind === kind);
+    if (!rule) {
+      throw new Error(`Invalid CR transition: cannot apply "${kind}" from status "${from}"`);
+    }
+    return rule.to;
+  }
+}
+
+// src/signal.ts
+class SignalPropagator {
+  store;
+  sm;
+  constructor(store, sm) {
+    this.store = store;
+    this.sm = sm;
+  }
+  propagateChange(changedItemId) {
+    const visited = new Set;
+    const signals = [];
+    this.propagateRecursive(changedItemId, visited, signals);
+    return signals;
+  }
+  computeImpact(itemId) {
+    const visited = new Set;
+    const impacted = [];
+    this.collectImpactRecursive(itemId, visited, impacted);
+    return impacted;
+  }
+  propagateRecursive(itemId, visited, signals) {
+    visited.add(itemId);
+    const dependentTraces = this.store.getDependentTraces(itemId);
+    for (const trace of dependentTraces) {
+      const downstreamId = trace.fromItemId;
+      if (visited.has(downstreamId)) {
+        continue;
+      }
+      const downstreamItem = this.store.getItem(downstreamId);
+      if (!downstreamItem) {
+        continue;
+      }
+      if (downstreamItem.state === "proven" && this.sm.canTransition("proven", "suspect")) {
+        this.store.updateItemStatus(downstreamId, "suspect", "upstream-change", "signal-propagator");
+        this.store.recordTransition({
+          itemId: downstreamId,
+          kind: "suspect",
+          from: "proven",
+          to: "suspect",
+          evidence: "upstream-change",
+          reason: `Upstream item ${itemId} changed`,
+          actor: "signal-propagator"
+        });
+        const signal = this.store.createSignal({
+          kind: "change",
+          sourceItem: itemId,
+          sourceNode: trace.toNodeId,
+          targetItem: downstreamId,
+          targetNode: trace.fromNodeId,
+          payload: `Propagated change from ${itemId}`
+        });
+        signals.push(signal);
+        this.propagateRecursive(downstreamId, visited, signals);
+      }
+    }
+  }
+  collectImpactRecursive(itemId, visited, impacted) {
+    visited.add(itemId);
+    const dependentTraces = this.store.getDependentTraces(itemId);
+    for (const trace of dependentTraces) {
+      const downstreamId = trace.fromItemId;
+      if (visited.has(downstreamId)) {
+        continue;
+      }
+      const downstreamItem = this.store.getItem(downstreamId);
+      if (!downstreamItem) {
+        continue;
+      }
+      impacted.push(downstreamItem);
+      this.collectImpactRecursive(downstreamId, visited, impacted);
+    }
+  }
+}
+
+// src/engine.ts
+class Engine {
+  store;
+  sm;
+  propagator;
+  crSm = new CRStateMachine;
+  constructor(store, sm, propagator) {
+    this.store = store;
+    this.sm = sm;
+    this.propagator = propagator;
+  }
+  registerNode(name, vertical, project, owner, isAI) {
+    return this.store.createNode({ name, vertical, project, owner, isAI });
+  }
+  getNode(id) {
+    const node = this.store.getNode(id);
+    if (!node)
+      throw new Error(`Node not found: ${id}`);
+    return node;
+  }
+  listNodes(project) {
+    return this.store.listNodes(project);
+  }
+  addItem(nodeId, kind, title, body, externalRef) {
+    const node = this.store.getNode(nodeId);
+    if (!node)
+      throw new Error(`Node not found: ${nodeId}`);
+    return this.store.createItem({ nodeId, kind, title, body, externalRef });
+  }
+  getItem(id) {
+    const item = this.store.getItem(id);
+    if (!item)
+      throw new Error(`Item not found: ${id}`);
+    return item;
+  }
+  listItems(nodeId) {
+    return this.store.listItems(nodeId);
+  }
+  addTrace(fromItemId, toItemId, relation, actor) {
+    const fromItem = this.store.getItem(fromItemId);
+    if (!fromItem)
+      throw new Error(`Item not found: ${fromItemId}`);
+    const toItem = this.store.getItem(toItemId);
+    if (!toItem)
+      throw new Error(`Item not found: ${toItemId}`);
+    return this.store.createTrace({
+      fromItemId,
+      fromNodeId: fromItem.nodeId,
+      toItemId,
+      toNodeId: toItem.nodeId,
+      relation
+    });
+  }
+  verifyItem(itemId, evidence, actor) {
+    const item = this.getItem(itemId);
+    let kind;
+    switch (item.state) {
+      case "unverified":
+        kind = "verify";
+        break;
+      case "suspect":
+        kind = "re_verify";
+        break;
+      case "broke":
+        kind = "fix";
+        break;
+      default:
+        throw new Error(`Cannot verify item in state "${item.state}": no valid transition`);
+    }
+    const newState = this.sm.apply(item.state, kind);
+    this.store.updateItemStatus(itemId, newState, evidence, actor);
+    this.store.recordTransition({
+      itemId,
+      kind,
+      from: item.state,
+      to: newState,
+      evidence,
+      actor
+    });
+    return this.propagator.propagateChange(itemId);
+  }
+  markBroken(itemId, reason, actor) {
+    const item = this.getItem(itemId);
+    if (item.state !== "suspect") {
+      throw new Error(`Cannot mark item as broken: item is in "${item.state}" state, must be "suspect"`);
+    }
+    const newState = this.sm.apply(item.state, "break");
+    this.store.updateItemStatus(itemId, newState, reason, actor);
+    this.store.recordTransition({
+      itemId,
+      kind: "break",
+      from: item.state,
+      to: newState,
+      reason,
+      actor
+    });
+  }
+  propagateChange(itemId) {
+    return this.propagator.propagateChange(itemId);
+  }
+  impact(itemId) {
+    return this.propagator.computeImpact(itemId);
+  }
+  ask(askerId, askerNode, question, context, targetNode) {
+    return this.store.createQuery({
+      askerId,
+      askerNode,
+      question,
+      context,
+      targetNode
+    });
+  }
+  respond(queryId, responderId, nodeId, answer, isAI) {
+    return this.store.createQueryResponse({
+      queryId,
+      responderId,
+      nodeId,
+      answer,
+      isAI
+    });
+  }
+  audit(nodeId) {
+    return this.store.audit(nodeId);
+  }
+  sweep(externalRef) {
+    const matchedItems = this.store.findItemsByExternalRef(externalRef);
+    const allSignals = [];
+    const affectedItemIds = new Set;
+    for (const item of matchedItems) {
+      const signals = this.propagator.propagateChange(item.id);
+      for (const signal of signals) {
+        allSignals.push(signal);
+        affectedItemIds.add(signal.targetItem);
+      }
+    }
+    const affectedItems = [];
+    for (const id of affectedItemIds) {
+      const item = this.store.getItem(id);
+      if (item) {
+        affectedItems.push(item);
+      }
+    }
+    return {
+      triggerRef: externalRef,
+      matchedItems,
+      affectedItems,
+      signalsCreated: allSignals.length
+    };
+  }
+  createProposal(proposerNode, proposerId, targetItemId, description) {
+    this.getItem(targetItemId);
+    return this.store.createChangeRequest({ proposerNode, proposerId, targetItemId, description });
+  }
+  submitProposal(crId) {
+    const cr = this.getChangeRequest(crId);
+    this.crSm.apply(cr.status, "submit");
+    return this.store.updateChangeRequestStatus(crId, "proposed");
+  }
+  openVoting(crId) {
+    const cr = this.getChangeRequest(crId);
+    this.crSm.apply(cr.status, "open_voting");
+    return this.store.updateChangeRequestStatus(crId, "voting");
+  }
+  castVote(crId, nodeId, vertical, approve, reason) {
+    const cr = this.getChangeRequest(crId);
+    if (cr.status !== "voting") {
+      throw new Error(`Cannot vote on CR in "${cr.status}" status`);
+    }
+    return this.store.createVote({ crId, nodeId, vertical, approve, reason });
+  }
+  resolveVoting(crId) {
+    const cr = this.getChangeRequest(crId);
+    if (cr.status !== "voting") {
+      throw new Error(`Cannot resolve CR in "${cr.status}" status`);
+    }
+    const tally = this.store.tallyVotes(crId);
+    let approved;
+    if (tally.approved > tally.rejected) {
+      approved = true;
+    } else if (tally.rejected > tally.approved) {
+      approved = false;
+    } else {
+      approved = this.tieBreak(cr);
+    }
+    const kind = approved ? "approve" : "reject";
+    this.crSm.apply(cr.status, kind);
+    return this.store.updateChangeRequestStatus(crId, approved ? "approved" : "rejected");
+  }
+  applyProposal(crId) {
+    const cr = this.getChangeRequest(crId);
+    this.crSm.apply(cr.status, "apply");
+    const updated = this.store.updateChangeRequestStatus(crId, "applied");
+    const signals = this.propagator.propagateChange(cr.targetItemId);
+    return { cr: updated, signals };
+  }
+  archiveProposal(crId) {
+    const cr = this.getChangeRequest(crId);
+    this.crSm.apply(cr.status, "archive");
+    return this.store.updateChangeRequestStatus(crId, "archived");
+  }
+  createChallenge(challengerNode, challengerId, targetItemId, reason) {
+    this.getItem(targetItemId);
+    return this.store.createChangeRequest({
+      proposerNode: challengerNode,
+      proposerId: challengerId,
+      targetItemId,
+      description: `Challenge: ${reason}`
+    });
+  }
+  upholdChallenge(crId) {
+    const cr = this.getChangeRequest(crId);
+    if (cr.status !== "approved") {
+      throw new Error(`Cannot uphold challenge in "${cr.status}" status \u2014 must be approved`);
+    }
+    const item = this.getItem(cr.targetItemId);
+    if (item.state === "proven") {
+      this.store.updateItemStatus(cr.targetItemId, "suspect", `Challenge upheld: ${cr.description}`, "challenge-system");
+      this.store.recordTransition({
+        itemId: cr.targetItemId,
+        kind: "suspect",
+        from: "proven",
+        to: "suspect",
+        evidence: cr.description,
+        reason: "Challenge upheld by vote",
+        actor: "challenge-system"
+      });
+    }
+    this.crSm.apply(cr.status, "apply");
+    const updated = this.store.updateChangeRequestStatus(crId, "applied");
+    const signals = this.propagator.propagateChange(cr.targetItemId);
+    return { cr: updated, signals };
+  }
+  dismissChallenge(crId) {
+    const cr = this.getChangeRequest(crId);
+    if (cr.status !== "rejected") {
+      throw new Error(`Cannot dismiss challenge in "${cr.status}" status \u2014 must be rejected`);
+    }
+    this.crSm.apply(cr.status, "archive");
+    return this.store.updateChangeRequestStatus(crId, "archived");
+  }
+  invitePair(initiatorNode, partnerNode, project) {
+    this.getNode(initiatorNode);
+    this.getNode(partnerNode);
+    return this.store.createPairSession({ initiatorNode, partnerNode, project });
+  }
+  joinPair(sessionId) {
+    const session = this.store.getPairSession(sessionId);
+    if (!session)
+      throw new Error(`Pair session not found: ${sessionId}`);
+    if (session.status !== "pending")
+      throw new Error(`Session is "${session.status}", cannot join`);
+    return this.store.updatePairSessionStatus(sessionId, "active");
+  }
+  endPair(sessionId) {
+    const session = this.store.getPairSession(sessionId);
+    if (!session)
+      throw new Error(`Pair session not found: ${sessionId}`);
+    if (session.status !== "active")
+      throw new Error(`Session is "${session.status}", cannot end`);
+    return this.store.updatePairSessionStatus(sessionId, "ended");
+  }
+  listPairSessions(nodeId) {
+    return this.store.listPairSessions(nodeId);
+  }
+  addChecklistItem(itemId, text) {
+    this.getItem(itemId);
+    return this.store.createChecklistItem({ itemId, text });
+  }
+  checkChecklistItem(checklistItemId) {
+    this.store.updateChecklistItemChecked(checklistItemId, true);
+  }
+  uncheckChecklistItem(checklistItemId) {
+    this.store.updateChecklistItemChecked(checklistItemId, false);
+  }
+  listChecklist(itemId) {
+    return this.store.listChecklistItems(itemId);
+  }
+  addKindMapping(fromVertical, fromKind, toVertical, toKind) {
+    return this.store.createKindMapping({ fromVertical, fromKind, toVertical, toKind });
+  }
+  getMappedKind(fromVertical, fromKind, toVertical) {
+    return this.store.getMappedKind(fromVertical, fromKind, toVertical);
+  }
+  getChangeRequest(id) {
+    const cr = this.store.getChangeRequest(id);
+    if (!cr)
+      throw new Error(`Change request not found: ${id}`);
+    return cr;
+  }
+  tieBreak(cr) {
+    const proposerNode = this.store.getNode(cr.proposerNode);
+    if (!proposerNode)
+      return false;
+    const upstreams = UPSTREAM_VERTICALS[proposerNode.vertical];
+    const votes = this.store.listVotes(cr.id);
+    for (const vote of votes) {
+      if (upstreams.includes(vote.vertical) && vote.approve) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+// src/event-bus.ts
+class EventBus {
+  listeners = new Map;
+  on(event, handler) {
+    let handlers = this.listeners.get(event);
+    if (!handlers) {
+      handlers = new Set;
+      this.listeners.set(event, handlers);
+    }
+    handlers.add(handler);
+  }
+  off(event, handler) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      handlers.delete(handler);
+    }
+  }
+  emit(event, data) {
+    const handlers = this.listeners.get(event);
+    if (!handlers)
+      return;
+    for (const handler of handlers) {
+      handler(data);
+    }
+  }
+}
+
+// src/ws-handlers.ts
+class WSHandlers {
+  engine;
+  store;
+  eventBus;
+  constructor(engine, store, eventBus) {
+    this.engine = engine;
+    this.store = store;
+    this.eventBus = eventBus;
+  }
+  handle(envelope) {
+    const { payload } = envelope;
+    switch (payload.type) {
+      case "signal_change":
+        this.handleSignalChange(payload);
+        break;
+      case "sweep":
+        this.handleSweep(payload);
+        break;
+      case "trace_resolve_request":
+        this.handleTraceResolveRequest(payload);
+        break;
+      case "query_ask":
+        this.handleQueryAsk(envelope, payload);
+        break;
+      case "query_respond":
+        this.handleQueryRespond(payload);
+        break;
+      case "permission_request":
+      case "permission_verdict":
+      case "proposal_create":
+      case "proposal_vote":
+      case "proposal_result":
+      case "challenge_create":
+      case "pair_invite":
+      case "pair_respond":
+      case "pair_end":
+      case "checklist_update":
+        break;
+      case "ack":
+        break;
+      case "error":
+        break;
+    }
+    this.eventBus.emit(payload.type, payload);
+  }
+  handleSignalChange(payload) {
+    try {
+      this.engine.propagateChange(payload.itemId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.eventBus.emit("error", {
+        type: "error",
+        code: "SIGNAL_CHANGE_FAILED",
+        message: `signal_change for item ${payload.itemId}: ${message}`
+      });
+    }
+  }
+  handleSweep(payload) {
+    try {
+      this.engine.sweep(payload.externalRef);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.eventBus.emit("error", {
+        type: "error",
+        code: "SWEEP_FAILED",
+        message: `sweep for ref ${payload.externalRef}: ${message}`
+      });
+    }
+  }
+  handleTraceResolveRequest(payload) {
+    try {
+      const item = this.engine.getItem(payload.itemId);
+      this.eventBus.emit("trace_resolve_response", {
+        type: "trace_resolve_response",
+        itemId: item.id,
+        title: item.title,
+        kind: item.kind,
+        state: item.state
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.eventBus.emit("error", {
+        type: "error",
+        code: "TRACE_RESOLVE_FAILED",
+        message: `trace_resolve_request for item ${payload.itemId}: ${message}`
+      });
+    }
+  }
+  handleQueryAsk(envelope, payload) {
+    try {
+      this.store.createQuery({
+        askerId: payload.askerId,
+        askerNode: envelope.fromNode,
+        question: payload.question
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.eventBus.emit("error", {
+        type: "error",
+        code: "QUERY_ASK_FAILED",
+        message: `query_ask: ${message}`
+      });
+    }
+  }
+  handleQueryRespond(payload) {}
+}
+
+// src/ws-client.ts
+class WSClient {
+  config;
+  ws = null;
+  messageHandler = null;
+  reconnectDelay = 1000;
+  maxReconnectDelay = 30000;
+  shouldReconnect = true;
+  log = new Logger("ws-client");
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const url = `${this.config.serverUrl}?token=${this.config.token}`;
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        this.reconnectDelay = 1000;
+        resolve();
+      };
+      this.ws.onmessage = (event) => {
+        if (!this.messageHandler)
+          return;
+        try {
+          const raw = typeof event.data === "string" ? event.data : String(event.data);
+          const envelope = parseEnvelope(raw);
+          this.messageHandler(envelope);
+        } catch (err) {
+          this.log.error("Failed to parse incoming message", { error: String(err) });
+        }
+      };
+      this.ws.onclose = () => {
+        this.ws = null;
+        if (this.shouldReconnect) {
+          setTimeout(() => {
+            this.connect().catch((err) => {
+              this.log.error("Reconnection failed", { error: String(err) });
+            });
+          }, this.reconnectDelay);
+          this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+        }
+      };
+      this.ws.onerror = (event) => {
+        this.log.error("WebSocket error");
+        if (!this.connected) {
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+    });
+  }
+  send(envelope) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(envelope));
+  }
+  sendMessage(toNode, payload) {
+    const envelope = createEnvelope(this.config.nodeId, toNode, this.config.projectId, payload);
+    this.send(envelope);
+  }
+  broadcast(payload) {
+    const envelope = createEnvelope(this.config.nodeId, "", this.config.projectId, payload);
+    this.send(envelope);
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  close() {
+    this.shouldReconnect = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  get connected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+}
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    node: {
+      id: "",
+      name: "",
+      vertical: "dev",
+      project: "",
+      owner: "",
+      isAI: false
+    },
+    server: {
+      url: "ws://localhost:8080/ws",
+      token: ""
+    },
+    database: {
+      path: "./inventory.db"
+    },
+    autonomy: {
+      auto: ["signal_change", "trace_resolve_request", "sweep", "query_respond"],
+      approval: ["proposal_vote", "challenge_respond", "pair_invite", "cr_create"]
+    }
+  };
+}
+function loadConfig(partial) {
+  const cfg = defaultConfig();
+  return deepMerge(cfg, partial);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal !== null && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal !== null && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      result[key] = deepMerge(tgtVal, srcVal);
+    } else {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+
+// src/channel.ts
+var TOOL_DEFINITIONS = [
+  {
+    name: "inv_add_item",
+    description: "Add a new inventory item. Requires kind and title. Optionally accepts body and externalRef.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: {
+          type: "string",
+          description: "Item kind",
+          enum: [
+            "adr",
+            "api-spec",
+            "data-model",
+            "tech-design",
+            "epic",
+            "user-story",
+            "prd",
+            "screen-spec",
+            "user-flow",
+            "test-case",
+            "test-plan",
+            "runbook",
+            "bug-report",
+            "decision",
+            "custom"
+          ]
+        },
+        title: { type: "string", description: "Title of the item" },
+        body: { type: "string", description: "Optional body/description" },
+        externalRef: { type: "string", description: "Optional external reference (URL or ticket ID)" }
+      },
+      required: ["kind", "title"]
+    }
+  },
+  {
+    name: "inv_add_trace",
+    description: "Create a trace link between two items. Relations: traced_from, matched_by, proven_by.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fromItemId: { type: "string", description: "Source item UUID" },
+        toItemId: { type: "string", description: "Target item UUID" },
+        relation: {
+          type: "string",
+          description: "Relation type",
+          enum: ["traced_from", "matched_by", "proven_by"]
+        }
+      },
+      required: ["fromItemId", "toItemId", "relation"]
+    }
+  },
+  {
+    name: "inv_verify",
+    description: "Verify an item (unverified\u2192proven, suspect\u2192proven, broke\u2192proven). Requires evidence.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: { type: "string", description: "Item UUID" },
+        evidence: { type: "string", description: "Evidence for verification" }
+      },
+      required: ["itemId", "evidence"]
+    }
+  },
+  {
+    name: "inv_mark_broken",
+    description: "Mark a suspect item as broken. Requires reason.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: { type: "string", description: "Item UUID" },
+        reason: { type: "string", description: "Reason for marking broken" }
+      },
+      required: ["itemId"]
+    }
+  },
+  {
+    name: "inv_audit",
+    description: "Audit inventory health. Returns counts by state, orphans, missing upstream refs.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "inv_ask",
+    description: "Ask a question to the inventory network. Optionally target a specific node.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The question to ask" },
+        targetNode: { type: "string", description: "Optional target node UUID" }
+      },
+      required: ["question"]
+    }
+  },
+  {
+    name: "inv_reply",
+    description: "Send a reply message to a specific node through the inventory network.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        message: { type: "string", description: "The reply message" },
+        targetNode: { type: "string", description: "Target node UUID" }
+      },
+      required: ["message", "targetNode"]
+    }
+  },
+  {
+    name: "inv_proposal_create",
+    description: "Create a change request proposal for an item. Starts as draft, submits, and opens for voting.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetItemId: { type: "string", description: "Item UUID to propose changes for" },
+        description: { type: "string", description: "Description of the proposed change" }
+      },
+      required: ["targetItemId", "description"]
+    }
+  },
+  {
+    name: "inv_proposal_vote",
+    description: "Vote on a proposal that is in voting status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        crId: { type: "string", description: "Change request UUID" },
+        approve: { type: "boolean", description: "true to approve, false to reject" },
+        reason: { type: "string", description: "Reason for your vote" }
+      },
+      required: ["crId", "approve", "reason"]
+    }
+  },
+  {
+    name: "inv_challenge_create",
+    description: "Challenge a proven item. Creates a CR that goes through voting. If upheld, item becomes suspect.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetItemId: { type: "string", description: "Item UUID to challenge" },
+        reason: { type: "string", description: "Reason for the challenge" }
+      },
+      required: ["targetItemId", "reason"]
+    }
+  },
+  {
+    name: "inv_challenge_respond",
+    description: "Vote on an active challenge.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        challengeId: { type: "string", description: "Challenge (CR) UUID" },
+        approve: { type: "boolean", description: "true to uphold challenge, false to dismiss" },
+        reason: { type: "string", description: "Reason" }
+      },
+      required: ["challengeId", "approve", "reason"]
+    }
+  },
+  {
+    name: "inv_pair_invite",
+    description: "Invite another node to a pairing session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        targetNode: { type: "string", description: "Target node UUID to pair with" }
+      },
+      required: ["targetNode"]
+    }
+  },
+  {
+    name: "inv_pair_join",
+    description: "Accept a pending pairing session invitation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Pair session UUID" }
+      },
+      required: ["sessionId"]
+    }
+  },
+  {
+    name: "inv_pair_end",
+    description: "End an active pairing session.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: { type: "string", description: "Pair session UUID" }
+      },
+      required: ["sessionId"]
+    }
+  },
+  {
+    name: "inv_pair_list",
+    description: "List active pairing sessions for this node.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "inv_checklist_add",
+    description: "Add a checklist item to an inventory item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: { type: "string", description: "Parent inventory item UUID" },
+        text: { type: "string", description: "Checklist item text" }
+      },
+      required: ["itemId", "text"]
+    }
+  },
+  {
+    name: "inv_checklist_check",
+    description: "Mark a checklist item as checked.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        checklistItemId: { type: "string", description: "Checklist item UUID" }
+      },
+      required: ["checklistItemId"]
+    }
+  },
+  {
+    name: "inv_checklist_uncheck",
+    description: "Uncheck a checklist item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        checklistItemId: { type: "string", description: "Checklist item UUID" }
+      },
+      required: ["checklistItemId"]
+    }
+  },
+  {
+    name: "inv_checklist_list",
+    description: "List all checklist items for an inventory item.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        itemId: { type: "string", description: "Parent inventory item UUID" }
+      },
+      required: ["itemId"]
+    }
+  }
+];
+function buildToolHandlers(engine, config, wsClient) {
+  return (name, args) => {
+    const text = (s) => ({
+      content: [{ type: "text", text: s }]
+    });
+    try {
+      switch (name) {
+        case "inv_add_item": {
+          const item = engine.addItem(config.node.id, args.kind, args.title ?? "", args.body, args.externalRef);
+          return text(JSON.stringify(item, null, 2));
+        }
+        case "inv_add_trace": {
+          const trace = engine.addTrace(args.fromItemId ?? "", args.toItemId ?? "", args.relation, config.node.owner);
+          return text(JSON.stringify(trace, null, 2));
+        }
+        case "inv_verify": {
+          const signals = engine.verifyItem(args.itemId ?? "", args.evidence ?? "", config.node.owner);
+          return text(JSON.stringify({
+            verified: true,
+            itemId: args.itemId,
+            signalsPropagated: signals.length
+          }, null, 2));
+        }
+        case "inv_mark_broken": {
+          engine.markBroken(args.itemId ?? "", args.reason ?? "", config.node.owner);
+          return text(JSON.stringify({
+            markedBroken: true,
+            itemId: args.itemId
+          }, null, 2));
+        }
+        case "inv_audit": {
+          const report = engine.audit(config.node.id);
+          return text(JSON.stringify(report, null, 2));
+        }
+        case "inv_ask": {
+          const question = args.question ?? "";
+          const query = engine.ask(config.node.owner, config.node.id, question, undefined, args.targetNode);
+          if (wsClient?.connected) {
+            if (args.targetNode) {
+              wsClient.sendMessage(args.targetNode, {
+                type: "query_ask",
+                question,
+                askerId: config.node.id
+              });
+            } else {
+              wsClient.broadcast({
+                type: "query_ask",
+                question,
+                askerId: config.node.id
+              });
+            }
+          }
+          return text(JSON.stringify({
+            queryId: query.id,
+            broadcast: !args.targetNode,
+            networkSent: wsClient?.connected ?? false
+          }, null, 2));
+        }
+        case "inv_reply": {
+          if (!wsClient?.connected) {
+            return text(JSON.stringify({ error: "Not connected to server" }));
+          }
+          wsClient.sendMessage(args.targetNode ?? "", {
+            type: "query_respond",
+            answer: args.message ?? "",
+            responderId: config.node.id
+          });
+          return text(JSON.stringify({
+            sent: true,
+            targetNode: args.targetNode
+          }, null, 2));
+        }
+        case "inv_proposal_create": {
+          const cr = engine.createProposal(config.node.id, config.node.owner, args.targetItemId ?? "", args.description ?? "");
+          engine.submitProposal(cr.id);
+          engine.openVoting(cr.id);
+          if (wsClient?.connected) {
+            wsClient.broadcast({
+              type: "proposal_create",
+              crId: cr.id,
+              targetItemId: args.targetItemId ?? "",
+              description: args.description ?? "",
+              proposerNode: config.node.id
+            });
+          }
+          return text(JSON.stringify({ crId: cr.id, status: "voting" }, null, 2));
+        }
+        case "inv_proposal_vote": {
+          const nodeInfo = engine.getNode(config.node.id);
+          const vote = engine.castVote(args.crId ?? "", config.node.id, nodeInfo.vertical, args.approve === "true" || args.approve === true, args.reason ?? "");
+          if (wsClient?.connected) {
+            wsClient.broadcast({
+              type: "proposal_vote",
+              crId: args.crId ?? "",
+              approve: vote.approve,
+              reason: args.reason ?? ""
+            });
+          }
+          return text(JSON.stringify({ voted: true, crId: args.crId, approve: vote.approve }, null, 2));
+        }
+        case "inv_challenge_create": {
+          const cr = engine.createChallenge(config.node.id, config.node.owner, args.targetItemId ?? "", args.reason ?? "");
+          engine.submitProposal(cr.id);
+          engine.openVoting(cr.id);
+          if (wsClient?.connected) {
+            wsClient.broadcast({
+              type: "challenge_create",
+              challengeId: cr.id,
+              targetItemId: args.targetItemId ?? "",
+              reason: args.reason ?? "",
+              challengerNode: config.node.id
+            });
+          }
+          return text(JSON.stringify({ challengeId: cr.id, status: "voting" }, null, 2));
+        }
+        case "inv_challenge_respond": {
+          const nodeInfo = engine.getNode(config.node.id);
+          const vote = engine.castVote(args.challengeId ?? "", config.node.id, nodeInfo.vertical, args.approve === "true" || args.approve === true, args.reason ?? "");
+          if (wsClient?.connected) {
+            wsClient.broadcast({
+              type: "proposal_vote",
+              crId: args.challengeId ?? "",
+              approve: vote.approve,
+              reason: args.reason ?? ""
+            });
+          }
+          return text(JSON.stringify({ voted: true, challengeId: args.challengeId, approve: vote.approve }, null, 2));
+        }
+        case "inv_pair_invite": {
+          const session = engine.invitePair(config.node.id, args.targetNode ?? "", config.node.project);
+          if (wsClient?.connected) {
+            wsClient.sendMessage(args.targetNode ?? "", {
+              type: "pair_invite",
+              sessionId: session.id,
+              initiatorNode: config.node.id
+            });
+          }
+          return text(JSON.stringify({ sessionId: session.id, status: "pending" }, null, 2));
+        }
+        case "inv_pair_join": {
+          const session = engine.joinPair(args.sessionId ?? "");
+          if (wsClient?.connected) {
+            wsClient.sendMessage(session.initiatorNode, {
+              type: "pair_respond",
+              sessionId: session.id,
+              accepted: true
+            });
+          }
+          return text(JSON.stringify({ sessionId: session.id, status: "active" }, null, 2));
+        }
+        case "inv_pair_end": {
+          const session = engine.endPair(args.sessionId ?? "");
+          if (wsClient?.connected) {
+            const partner = session.initiatorNode === config.node.id ? session.partnerNode : session.initiatorNode;
+            wsClient.sendMessage(partner, {
+              type: "pair_end",
+              sessionId: session.id
+            });
+          }
+          return text(JSON.stringify({ sessionId: session.id, status: "ended" }, null, 2));
+        }
+        case "inv_pair_list": {
+          const sessions = engine.listPairSessions(config.node.id);
+          return text(JSON.stringify(sessions, null, 2));
+        }
+        case "inv_checklist_add": {
+          const cl = engine.addChecklistItem(args.itemId ?? "", args.text ?? "");
+          return text(JSON.stringify(cl, null, 2));
+        }
+        case "inv_checklist_check": {
+          engine.checkChecklistItem(args.checklistItemId ?? "");
+          return text(JSON.stringify({ checked: true, checklistItemId: args.checklistItemId }, null, 2));
+        }
+        case "inv_checklist_uncheck": {
+          engine.uncheckChecklistItem(args.checklistItemId ?? "");
+          return text(JSON.stringify({ unchecked: true, checklistItemId: args.checklistItemId }, null, 2));
+        }
+        case "inv_checklist_list": {
+          const items = engine.listChecklist(args.itemId ?? "");
+          return text(JSON.stringify(items, null, 2));
+        }
+        default:
+          return text(JSON.stringify({ error: `Unknown tool: ${name}` }));
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return text(JSON.stringify({ error: message }));
+    }
+  };
+}
+async function startChannelServer(configPath) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const partial = JSON.parse(raw);
+  const config = loadConfig(partial);
+  const store = new Store(config.database.path);
+  const sm = new StateMachine;
+  const propagator = new SignalPropagator(store, sm);
+  const engine = new Engine(store, sm, propagator);
+  if (!config.node.id) {
+    const node = engine.registerNode(config.node.name || "unnamed-node", config.node.vertical, config.node.project || "default", config.node.owner || "local", config.node.isAI);
+    config.node.id = node.id;
+    const updatedRaw = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (!updatedRaw.node)
+      updatedRaw.node = {};
+    updatedRaw.node.id = node.id;
+    writeFileSync2(configPath, JSON.stringify(updatedRaw, null, 2) + `
+`);
+  }
+  const eventBus = new EventBus;
+  const wsHandlers = new WSHandlers(engine, store, eventBus);
+  let wsClient = null;
+  if (config.server.url && config.server.token) {
+    wsClient = new WSClient({
+      serverUrl: config.server.url,
+      token: config.server.token,
+      nodeId: config.node.id,
+      projectId: config.node.project
+    });
+    wsClient.onMessage((envelope) => {
+      wsHandlers.handle(envelope);
+    });
+    try {
+      await wsClient.connect();
+    } catch {
+      wsClient = null;
+    }
+  }
+  const mcp = new Server({ name: "inventory", version: "0.1.0" }, {
+    capabilities: {
+      experimental: {
+        "claude/channel": {},
+        "claude/channel/permission": {}
+      },
+      tools: {}
+    },
+    instructions: `You are connected to the inventory network as node "${config.node.name}" (${config.node.vertical}, project: ${config.node.project}, owner: ${config.node.owner}).
+
+Events from the inventory network arrive as <channel source="inventory"> tags. These include:
+- signal_change: an item changed state
+- sweep: an external reference triggered a sweep
+- query_ask/query_respond: Q&A between nodes
+- permission_request/permission_verdict: approval workflows
+- proposal_create/proposal_vote/proposal_result: change request voting
+- challenge_create: a node challenges an item
+- pair_invite/pair_respond/pair_end: pairing session events
+- checklist_update: checklist item checked/unchecked
+
+Use the inv_* tools to manage inventory, propose changes, vote, challenge items, pair with other nodes, and manage checklists.`
+  });
+  const handleTool = buildToolHandlers(engine, config, wsClient);
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOL_DEFINITIONS
+  }));
+  mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return handleTool(name, args ?? {});
+  });
+  const channelEvents = [
+    "signal_change",
+    "sweep",
+    "query_ask",
+    "query_respond",
+    "permission_request",
+    "permission_verdict",
+    "proposal_create",
+    "proposal_vote",
+    "proposal_result",
+    "challenge_create",
+    "pair_invite",
+    "pair_respond",
+    "pair_end",
+    "checklist_update",
+    "error"
+  ];
+  for (const eventType of channelEvents) {
+    eventBus.on(eventType, (data) => {
+      mcp.notification({
+        method: "notifications/claude/channel",
+        params: {
+          content: JSON.stringify(data),
+          meta: { source: "inventory", eventType }
+        }
+      });
+    });
+  }
+  const transport = new StdioServerTransport;
+  await mcp.connect(transport);
+}
+if (false) {}
+
+// src/index.ts
+async function main() {
+  const command = process.argv[2];
+  switch (command) {
+    case "init":
+      await runWizard();
+      break;
+    case "serve":
+      await startChannelServer(process.argv[3] ?? "./inv-config.json");
+      break;
+    case undefined:
+      await startChannelServer(process.argv[3] ?? "./inv-config.json");
+      break;
+    case "update":
+      console.log("Clearing bunx cache for @tini-works/inv-node...");
+      const proc = Bun.spawn(["bun", "pm", "cache", "rm"], { stdout: "inherit", stderr: "inherit" });
+      await proc.exited;
+      console.log("Cache cleared. Next run will fetch the latest version.");
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error("Usage:");
+      console.error("  inv-node init              Set up a new node");
+      console.error("  inv-node serve [config]    Start MCP server");
+      console.error("  inv-node update            Update to latest version");
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error("Fatal error:", err);
+  process.exit(1);
+});