@a-company/paradigm 3.43.0 → 3.46.0

package/dist/{chunk-YW5OCVKB.js → chunk-FKJUBQU3.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../sentinel/dist/chunk-DANAUKOJ.js
+// ../sentinel/dist/chunk-OKYYIAML.js
 import initSqlJs from "sql.js";
 import { v4 as uuidv4 } from "uuid";
 import * as path from "path";
@@ -598,6 +598,19 @@ var SentinelStorage = class {
     );
     this.save();
   }
+  resolveIncident(id, options) {
+    this.updateIncident(id, {
+      status: "resolved",
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (options?.notes) {
+      this.addIncidentNote(id, {
+        author: "system",
+        content: options.notes,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
   addIncidentNote(incidentId, note) {
     this.initializeSync();
     const incident = this.getIncident(incidentId);

package/dist/chunk-KVDYJLTC.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/symphony-peers.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
+var PEERS_FILE = path.join(SCORE_DIR, "peers.json");
+var PAIRING_TTL_MS = 5 * 60 * 1e3;
+function loadPeers() {
+  try {
+    if (!fs.existsSync(PEERS_FILE)) return [];
+    const content = fs.readFileSync(PEERS_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function savePeers(peers) {
+  if (!fs.existsSync(SCORE_DIR)) {
+    fs.mkdirSync(SCORE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(PEERS_FILE, JSON.stringify(peers, null, 2), { mode: 384 });
+}
+function findPeer(id) {
+  const peers = loadPeers();
+  return peers.find((p) => p.id === id) ?? null;
+}
+function addPeer(peer) {
+  const peers = loadPeers();
+  const idx = peers.findIndex((p) => p.id === peer.id);
+  if (idx >= 0) {
+    peers[idx] = peer;
+  } else {
+    peers.push(peer);
+  }
+  savePeers(peers);
+}
+function revokePeer(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return false;
+  peer.revoked = true;
+  savePeers(peers);
+  return true;
+}
+function forgetAllPeers() {
+  const peers = loadPeers();
+  const count = peers.length;
+  if (fs.existsSync(PEERS_FILE)) {
+    fs.unlinkSync(PEERS_FILE);
+  }
+  return count;
+}
+function updatePeerLastSeen(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+  savePeers(peers);
+}
+function updatePeerAgents(id, agents) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.agents = agents;
+  savePeers(peers);
+}
+function generatePairing() {
+  const sharedSecret = crypto.randomBytes(32).toString("hex");
+  const code = (parseInt(crypto.randomBytes(3).toString("hex"), 16) % 1e6).toString().padStart(6, "0");
+  const codeHash = crypto.createHash("sha256").update(code).digest("hex");
+  return {
+    code,
+    codeHash,
+    sharedSecret,
+    createdAt: Date.now()
+  };
+}
+function verifyPairingCode(state, code) {
+  if (Date.now() - state.createdAt > PAIRING_TTL_MS) {
+    return false;
+  }
+  const hash = crypto.createHash("sha256").update(code).digest("hex");
+  return hash === state.codeHash;
+}
+function computeHmacProof(challenge, codeHash) {
+  return crypto.createHmac("sha256", codeHash).update(challenge).digest("hex");
+}
+function verifyHmacProof(challenge, codeHash, proof) {
+  const expected = computeHmacProof(challenge, codeHash);
+  if (expected.length !== proof.length) return false;
+  try {
+    return crypto.timingSafeEqual(
+      Buffer.from(expected, "hex"),
+      Buffer.from(proof, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+
+export {
+  PEERS_FILE,
+  PAIRING_TTL_MS,
+  loadPeers,
+  savePeers,
+  findPeer,
+  addPeer,
+  revokePeer,
+  forgetAllPeers,
+  updatePeerLastSeen,
+  updatePeerAgents,
+  generatePairing,
+  verifyPairingCode,
+  computeHmacProof,
+  verifyHmacProof
+};

package/dist/{symphony-ROEKK7VD.js → chunk-S2HO5MLR.js}

@@ -1,9 +1,4 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
-
-// src/commands/symphony/index.ts
-import chalk from "chalk";
-import * as net from "net";
 
 // ../paradigm-mcp/src/utils/symphony-loader.ts
 import * as fs from "fs";
@@ -171,12 +166,15 @@ function getMyIdentity(projectDir) {
     return null;
   }
 }
-function markAgentPollTime(agentId) {
+function markAgentPollTime(agentId, statusBlurb) {
   const identityPath = path.join(getAgentDir(agentId), "identity.json");
   if (!fs.existsSync(identityPath)) return;
   try {
     const identity = JSON.parse(fs.readFileSync(identityPath, "utf-8"));
     identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    if (statusBlurb !== void 0) {
+      identity.statusBlurb = statusBlurb || void 0;
+    }
     fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
   } catch {
   }
@@ -248,6 +246,9 @@ function appendToOutbox(agentId, message) {
   ensureAgentDir(agentId);
   appendJsonlLine(outboxPath(agentId), message);
 }
+function readOutbox(agentId) {
+  return readJsonlFile(outboxPath(agentId));
+}
 function acknowledgeMessages(agentId, lastMessageId) {
   const filePath = ackPath(agentId);
   ensureAgentDir(agentId);
@@ -561,6 +562,24 @@ function isPathDenied(filePath, config, user) {
   }
   return false;
 }
+function expireOldRequests() {
+  const requests = listFileRequests("pending");
+  let expired = 0;
+  for (const record of requests) {
+    const age = Date.now() - new Date(record.createdAt).getTime();
+    if (age > FILE_REQUEST_TTL_MS) {
+      record.status = "expired";
+      record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+      fs.writeFileSync(
+        fileRequestPath(record.request.requestId),
+        JSON.stringify(record, null, 2),
+        "utf-8"
+      );
+      expired++;
+    }
+  }
+  return expired;
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -570,430 +589,33 @@ function isProcessAlive(pid) {
   }
 }
 
-// src/commands/symphony/index.ts
-async function symphonyJoinCommand(options) {
-  const rootDir = process.cwd();
-  if (options.remote) {
-    console.log(chalk.yellow(`Remote linking to ${options.remote} \u2014 not yet implemented in Phase 0.`));
-    console.log(chalk.gray("Remote linking will be available in a future Symphony phase."));
-    return;
-  }
-  const identity = registerAgent(rootDir);
-  console.log(chalk.green(`\u2713 Joined as ${chalk.bold(identity.id)}`));
-  const sessions = discoverClaudeCodeSessions();
-  const others = sessions.filter((s) => s.id !== identity.id);
-  if (others.length > 0) {
-    console.log(chalk.cyan(`
-  Found ${others.length} other session${others.length !== 1 ? "s" : ""}:`));
-    for (const s of others) {
-      const status = isAgentAsleep(s) ? chalk.yellow("asleep") : chalk.green("awake");
-      console.log(`    ${chalk.white(s.id)} \u2014 ${s.name} [${status}]`);
-    }
-  } else {
-    console.log(chalk.gray('\n  No other sessions found. Open another terminal and run "paradigm symphony join".'));
-  }
-  console.log(chalk.gray(`
-  Tip: Set up polling with: /loop 10s paradigm_symphony_poll`));
-}
-async function symphonyLeaveCommand() {
-  const rootDir = process.cwd();
-  const agentId = resolveAgentIdentity(rootDir);
-  const success = unregisterAgent(agentId);
-  if (success) {
-    console.log(chalk.green(`\u2713 Left the score: ${agentId}`));
-  } else {
-    console.log(chalk.yellow(`No active part found for this project.`));
-  }
-}
-async function symphonyWhoamiCommand() {
-  const rootDir = process.cwd();
-  const identity = getMyIdentity(rootDir);
-  if (!identity) {
-    console.log(chalk.yellow('Not joined. Run "paradigm symphony join" first.'));
-    return;
-  }
-  const agents = listAgents();
-  const others = agents.filter((a) => a.id !== identity.id);
-  const threads = listThreads("active");
-  const unread = readInbox(identity.id);
-  console.log(chalk.cyan(`
-  ${chalk.bold(identity.id)}`));
-  console.log(chalk.gray(`  Project: ${identity.project}`));
-  console.log(chalk.gray(`  Role: ${identity.role}`));
-  console.log(chalk.gray(`  PID: ${identity.pid}`));
-  console.log(chalk.gray(`  Started: ${identity.startedAt}`));
-  console.log(`
-  ${chalk.white(`${others.length} linked peer${others.length !== 1 ? "s" : ""}`)} \u2014 ${chalk.white(`${threads.length} active thread${threads.length !== 1 ? "s" : ""}`)} \u2014 ${chalk.white(`${unread.length} unread`)}`);
-}
-async function symphonyListCommand(options) {
-  cleanStaleAgents();
-  const agents = listAgents();
-  if (options.json) {
-    console.log(JSON.stringify(agents, null, 2));
-    return;
-  }
-  if (agents.length === 0) {
-    console.log(chalk.yellow('No agents joined. Run "paradigm symphony join" in each terminal.'));
-    return;
-  }
-  console.log(chalk.cyan(`
-  Symphony Agents (${agents.length})
-`));
-  console.log(chalk.gray(`  ${"AGENT ID".padEnd(30)} ${"PROJECT".padEnd(15)} ${"ROLE".padEnd(10)} STATUS`));
-  console.log(chalk.gray(`  ${"\u2500".repeat(30)} ${"\u2500".repeat(15)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)}`));
-  for (const agent of agents) {
-    const status = isAgentAsleep(agent) ? chalk.yellow("asleep") : chalk.green("awake");
-    console.log(`  ${chalk.white(agent.id.padEnd(30))} ${agent.project.padEnd(15)} ${agent.role.padEnd(10)} ${status}`);
-  }
-  console.log();
-}
-async function symphonySendCommand(messageText, options) {
-  const rootDir = process.cwd();
-  let identity = getMyIdentity(rootDir);
-  if (!identity) {
-    identity = registerAgent(rootDir);
-    console.log(chalk.gray(`Auto-joined as ${identity.id}`));
-  }
-  const sender = {
-    id: identity.id,
-    name: identity.name,
-    type: "human",
-    // CLI notes come from the human
-    project: identity.project,
-    role: identity.role
-  };
-  let recipients;
-  if (options.to) {
-    recipients = [{ id: options.to, name: options.to, type: "agent" }];
-  }
-  let threadRoot = options.thread;
-  if (!threadRoot) {
-    const topic = messageText.length > 60 ? messageText.slice(0, 60) + "..." : messageText;
-    const thread = createThread(topic, sender);
-    threadRoot = thread.id;
-  }
-  const message = buildMessage({
-    sender,
-    recipients,
-    intent: "context",
-    text: messageText,
-    threadRoot
-  });
-  const deliveryCount = routeMessage(message);
-  console.log(chalk.green(`\u2713 Sent to ${deliveryCount} agent${deliveryCount !== 1 ? "s" : ""}`));
-  console.log(chalk.gray(`  Thread: ${threadRoot}`));
-  console.log(chalk.gray(`  Note: ${message.id}`));
-}
-async function symphonyReadCommand() {
-  const rootDir = process.cwd();
-  const identity = getMyIdentity(rootDir);
-  if (!identity) {
-    console.log(chalk.yellow('Not joined. Run "paradigm symphony join" first.'));
-    return;
-  }
-  markAgentPollTime(identity.id);
-  const messages = readInbox(identity.id);
-  if (messages.length === 0) {
-    console.log(chalk.gray("\n  No unread notes.\n"));
-    return;
-  }
-  const byThread = /* @__PURE__ */ new Map();
-  for (const msg of messages) {
-    const tid = msg.threadRoot || "direct";
-    if (!byThread.has(tid)) byThread.set(tid, []);
-    byThread.get(tid).push(msg);
-  }
-  console.log(chalk.cyan(`
-  ${messages.length} unread note${messages.length !== 1 ? "s" : ""}
-`));
-  for (const [threadId, msgs] of byThread) {
-    let threadLabel = threadId;
-    if (threadId !== "direct") {
-      const thread = loadThread(threadId);
-      if (thread) threadLabel = `${thread.topic} (${threadId})`;
-    }
-    console.log(chalk.white(`  \u250C\u2500 ${threadLabel}`));
-    for (let i = 0; i < msgs.length; i++) {
-      const msg = msgs[i];
-      const isLast = i === msgs.length - 1;
-      const prefix = isLast ? "  \u2514\u2500" : "  \u251C\u2500";
-      const time = new Date(msg.timestamp).toLocaleTimeString(void 0, { hour: "numeric", minute: "2-digit" });
-      console.log(`${prefix} ${chalk.cyan(msg.sender.name)} ${chalk.gray(`[${msg.intent}]`)} ${chalk.gray(time)}`);
-      const textLines = msg.content.text.split("\n");
-      const indent = isLast ? "     " : "  \u2502  ";
-      for (const line of textLines) {
-        console.log(`${indent}${line}`);
-      }
-      if (msg.symbols.length > 0) {
-        console.log(`${indent}${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
-      }
-    }
-    console.log();
-  }
-  const lastId = messages[messages.length - 1].id;
-  acknowledgeMessages(identity.id, lastId);
-  garbageCollect(identity.id);
-}
-async function symphonyThreadsCommand(options) {
-  const threads = listThreads();
-  if (options.json) {
-    console.log(JSON.stringify(threads, null, 2));
-    return;
-  }
-  if (threads.length === 0) {
-    console.log(chalk.gray("\n  No threads.\n"));
-    return;
-  }
-  console.log(chalk.cyan(`
-  Threads (${threads.length})
-`));
-  console.log(chalk.gray(`  ${"ID".padEnd(14)} ${"TOPIC".padEnd(35)} ${"MSGS".padEnd(6)} ${"STATUS".padEnd(10)} LAST ACTIVITY`));
-  console.log(chalk.gray(`  ${"\u2500".repeat(14)} ${"\u2500".repeat(35)} ${"\u2500".repeat(6)} ${"\u2500".repeat(10)} ${"\u2500".repeat(20)}`));
-  for (const thread of threads) {
-    const topic = thread.topic.length > 33 ? thread.topic.slice(0, 33) + ".." : thread.topic;
-    const status = thread.status === "active" ? chalk.green("active") : chalk.gray("resolved");
-    const lastAct = new Date(thread.lastActivity).toLocaleString(void 0, {
-      month: "short",
-      day: "numeric",
-      hour: "numeric",
-      minute: "2-digit"
-    });
-    console.log(`  ${chalk.white(thread.id.padEnd(14))} ${topic.padEnd(35)} ${String(thread.messageCount).padEnd(6)} ${status.padEnd(10)} ${chalk.gray(lastAct)}`);
-  }
-  console.log();
-}
-async function symphonyThreadCommand(threadId) {
-  const thread = loadThread(threadId);
-  if (!thread) {
-    console.log(chalk.red(`Thread not found: ${threadId}`));
-    return;
-  }
-  const messages = getThreadMessages(threadId);
-  console.log(chalk.cyan(`
-  Thread: ${thread.topic}`));
-  console.log(chalk.gray(`  ID: ${thread.id} | Status: ${thread.status} | Notes: ${thread.messageCount}`));
-  console.log(chalk.gray(`  Participants: ${thread.participants.map((p) => p.name).join(", ")}`));
-  if (thread.decision) {
-    console.log(chalk.green(`  Decision: ${thread.decision}`));
-  }
-  console.log(chalk.gray(`
-  ${"\u2500".repeat(60)}
-`));
-  for (const msg of messages) {
-    const time = new Date(msg.timestamp).toLocaleString(void 0, {
-      month: "short",
-      day: "numeric",
-      hour: "numeric",
-      minute: "2-digit"
-    });
-    console.log(`  ${chalk.cyan(msg.sender.name)} ${chalk.gray(`[${msg.intent}]`)} ${chalk.gray(time)}`);
-    const textLines = msg.content.text.split("\n");
-    for (const line of textLines) {
-      console.log(`    ${line}`);
-    }
-    if (msg.symbols.length > 0) {
-      console.log(`    ${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
-    }
-    if (msg.content.decision) {
-      console.log(`    ${chalk.green(`Decision: ${msg.content.decision}`)}`);
-    }
-    console.log();
-  }
-}
-async function symphonyResolveCommand(threadId, options) {
-  const thread = loadThread(threadId);
-  if (!thread) {
-    console.log(chalk.red(`Thread not found: ${threadId}`));
-    return;
-  }
-  const success = resolveThread(threadId, options.decision);
-  if (success) {
-    console.log(chalk.green(`\u2713 Thread resolved: ${thread.topic}`));
-    if (options.decision) {
-      console.log(chalk.gray(`  Decision: ${options.decision}`));
-    }
-    console.log(chalk.gray(`  Tip: Record this as lore with "paradigm lore record --title 'Thread: ${thread.topic}'"`));
-  } else {
-    console.log(chalk.red("Failed to resolve thread."));
-  }
-}
-async function symphonyStatusCommand(options) {
-  cleanStaleAgents();
-  const rootDir = process.cwd();
-  const identity = getMyIdentity(rootDir);
-  const agents = listAgents();
-  const threads = listThreads("active");
-  const pendingRequests = listFileRequests("pending");
-  const unread = identity ? readInbox(identity.id) : [];
-  if (options.json) {
-    console.log(JSON.stringify({
-      identity: identity ? { id: identity.id, project: identity.project, role: identity.role } : null,
-      agents: agents.map((a) => ({ id: a.id, status: isAgentAsleep(a) ? "asleep" : "awake" })),
-      activeThreads: threads.length,
-      unreadMessages: unread.length,
-      pendingFileRequests: pendingRequests.length
-    }, null, 2));
-    return;
-  }
-  console.log(chalk.cyan("\n  Symphony Status\n"));
-  if (identity) {
-    console.log(`  ${chalk.white("Identity:")} ${identity.id}`);
-  } else {
-    console.log(`  ${chalk.yellow("Not joined.")} Run "paradigm symphony join" to join.`);
-  }
-  const awake = agents.filter((a) => !isAgentAsleep(a)).length;
-  console.log(`  ${chalk.white("Agents:")} ${agents.length} joined (${awake} awake)`);
-  console.log(`  ${chalk.white("Threads:")} ${threads.length} active`);
-  console.log(`  ${chalk.white("Unread:")} ${unread.length} note${unread.length !== 1 ? "s" : ""}`);
-  console.log(`  ${chalk.white("File Requests:")} ${pendingRequests.length} pending`);
-  console.log();
-}
-async function symphonyServeCommand(options) {
-  const port = parseInt(options.port || "3939", 10);
-  console.log(chalk.cyan(`
-  Starting Symphony TCP server on port ${port}...`));
-  console.log(chalk.gray("  Phase 0 stub \u2014 remote linking protocol not yet implemented.\n"));
-  const server = net.createServer((socket) => {
-    socket.write(JSON.stringify({ type: "hello", version: "0.1.0" }) + "\n");
-    socket.on("data", (data) => {
-      try {
-        const msg = JSON.parse(data.toString().trim());
-        socket.write(JSON.stringify({ type: "ack", received: msg.type }) + "\n");
-      } catch {
-        socket.write(JSON.stringify({ type: "error", message: "Invalid JSON" }) + "\n");
-      }
-    });
-    socket.on("error", () => {
-    });
-  });
-  server.listen(port, "0.0.0.0", () => {
-    console.log(chalk.green(`  \u2713 Symphony server listening on 0.0.0.0:${port}`));
-    console.log(chalk.gray(`  Connect from another machine: paradigm symphony join --remote <this-ip>:${port}`));
-  });
-  server.on("error", (err) => {
-    console.log(chalk.red(`  Failed to start server: ${err.message}`));
-  });
-  await new Promise(() => {
-  });
-}
-async function symphonyRequestCommand(file, options) {
-  const rootDir = process.cwd();
-  let identity = getMyIdentity(rootDir);
-  if (!identity) {
-    identity = registerAgent(rootDir);
-  }
-  const from = options.from;
-  const reason = options.reason || "Needed for current task";
-  if (!from) {
-    console.log(chalk.red("--from is required. Specify which agent to request from."));
-    const agents = listAgents().filter((a) => a.id !== identity.id);
-    if (agents.length > 0) {
-      console.log(chalk.gray("\nAvailable agents:"));
-      for (const a of agents) {
-        console.log(chalk.gray(`  ${a.id}`));
-      }
-    }
-    return;
-  }
-  const trust = loadTrustConfig();
-  if (isPathDenied(file, trust)) {
-    console.log(chalk.red(`\u2717 "${file}" is on the hard-deny list and cannot be requested.`));
-    return;
-  }
-  const record = createFileRequest({
-    filePath: file,
-    requester: {
-      id: identity.id,
-      name: identity.name,
-      type: "agent",
-      project: identity.project,
-      role: identity.role
-    },
-    reason
-  });
-  const msg = buildMessage({
-    sender: {
-      id: identity.id,
-      name: identity.name,
-      type: "agent",
-      project: identity.project,
-      role: identity.role
-    },
-    recipients: [{ id: from, name: from, type: "agent" }],
-    intent: "fileRequest",
-    text: `File request: ${file}
-Reason: ${reason}`,
-    symbols: []
-  });
-  routeMessage(msg);
-  console.log(chalk.green(`\u2713 File request created: ${record.request.requestId}`));
-  console.log(chalk.gray(`  File: ${file}`));
-  console.log(chalk.gray(`  From: ${from}`));
-  console.log(chalk.gray(`  Reason: ${reason}`));
-  console.log(chalk.gray(`
-  The owning agent's human must approve with:`));
-  console.log(chalk.white(`    paradigm symphony approve ${record.request.requestId}`));
-}
-async function symphonyRequestsCommand() {
-  const requests = listFileRequests("pending");
-  if (requests.length === 0) {
-    console.log(chalk.gray("\n  No pending file requests.\n"));
-    return;
-  }
-  console.log(chalk.cyan(`
-  Pending File Requests (${requests.length})
-`));
-  for (const req of requests) {
-    const age = Date.now() - new Date(req.createdAt).getTime();
-    const ageMin = Math.round(age / 6e4);
-    console.log(`  ${chalk.white(req.request.requestId)}`);
-    console.log(`    File: ${req.request.filePath}`);
-    console.log(`    From: ${req.request.requester.name} (${req.request.requester.id})`);
-    console.log(`    Reason: ${req.request.reason}`);
-    console.log(chalk.gray(`    ${ageMin}m ago`));
-    console.log(chalk.gray(`    \u2192 paradigm symphony approve ${req.request.requestId}`));
-    console.log(chalk.gray(`    \u2192 paradigm symphony deny ${req.request.requestId}`));
-    console.log();
-  }
-}
-async function symphonyApproveCommand(requestId, options) {
-  const rootDir = process.cwd();
-  const result = approveFileRequest(requestId, rootDir, options.redact);
-  if (!result.success) {
-    console.log(chalk.red(`\u2717 ${result.error}`));
-    return;
-  }
-  const label = options.redact ? "approved (redacted)" : "approved";
-  console.log(chalk.green(`\u2713 File request ${label}`));
-  console.log(chalk.gray(`  File: ${result.delivery?.filePath}`));
-  console.log(chalk.gray(`  Size: ${result.delivery?.size} bytes`));
-  console.log(chalk.gray(`  SHA-256: ${result.delivery?.hash?.slice(0, 16)}...`));
-}
-async function symphonyDenyCommand(requestId, options) {
-  const success = denyFileRequest(requestId, options.reason);
-  if (success) {
-    console.log(chalk.green(`\u2713 File request denied: ${requestId}`));
-    if (options.reason) {
-      console.log(chalk.gray(`  Reason: ${options.reason}`));
-    }
-  } else {
-    console.log(chalk.red(`\u2717 File request not found or already resolved: ${requestId}`));
-  }
-}
 export {
-  symphonyApproveCommand,
-  symphonyDenyCommand,
-  symphonyJoinCommand,
-  symphonyLeaveCommand,
-  symphonyListCommand,
-  symphonyReadCommand,
-  symphonyRequestCommand,
-  symphonyRequestsCommand,
-  symphonyResolveCommand,
-  symphonySendCommand,
-  symphonyServeCommand,
-  symphonyStatusCommand,
-  symphonyThreadCommand,
-  symphonyThreadsCommand,
-  symphonyWhoamiCommand
+  resolveAgentIdentity,
+  registerAgent,
+  unregisterAgent,
+  listAgents,
+  cleanStaleAgents,
+  getMyIdentity,
+  markAgentPollTime,
+  isAgentAsleep,
+  discoverClaudeCodeSessions,
+  appendToInbox,
+  readInbox,
+  readOutbox,
+  acknowledgeMessages,
+  garbageCollect,
+  createThread,
+  loadThread,
+  listThreads,
+  resolveThread,
+  getThreadMessages,
+  buildMessage,
+  routeMessage,
+  loadTrustConfig,
+  createFileRequest,
+  listFileRequests,
+  approveFileRequest,
+  denyFileRequest,
+  isPathDenied,
+  expireOldRequests
 };

package/dist/{chunk-RGFANZ4Q.js → chunk-ZDHLG5VP.js}

@@ -413,7 +413,7 @@ function enableSentinel(logger, clientOrOptions) {
   return transport;
 }
 
-// ../sentinel/dist/chunk-DANAUKOJ.js
+// ../sentinel/dist/chunk-OKYYIAML.js
 import initSqlJs from "sql.js";
 import { v4 as uuidv42 } from "uuid";
 import * as path from "path";
@@ -1011,6 +1011,19 @@ var SentinelStorage = class {
     );
     this.save();
   }
+  resolveIncident(id, options) {
+    this.updateIncident(id, {
+      status: "resolved",
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (options?.notes) {
+      this.addIncidentNote(id, {
+        author: "system",
+        content: options.notes,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
   addIncidentNote(incidentId, note) {
     this.initializeSync();
     const incident = this.getIncident(incidentId);