@a-company/paradigm 3.44.0 → 3.46.0

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/{chunk-SOBTKFSP.js → chunk-S2HO5MLR.js}

@@ -246,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);
@@ -596,7 +599,9 @@ export {
   markAgentPollTime,
   isAgentAsleep,
   discoverClaudeCodeSessions,
+  appendToInbox,
   readInbox,
+  readOutbox,
   acknowledgeMessages,
   garbageCollect,
   createThread,

package/dist/index.js

@@ -710,7 +710,7 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
   await loreServeCommand(void 0, options);
 });
 program.command("serve").description("Launch Paradigm Platform \u2014 unified development management UI").option("-p, --port <port>", "Port to run on", "3850").option("--no-open", "Don't open browser automatically").option("--sections <list>", "Comma-separated sections to enable (e.g., lore,graph,git)").action(async (options) => {
-  const { serveCommand } = await import("./serve-JVXSRSUB.js");
+  const { serveCommand } = await import("./serve-KKEHE44G.js");
   await serveCommand(options);
 });
 var graphCmd = program.command("graph").description("Interactive symbol relationship graph").argument("[path]", "Project directory", void 0).option("-p, --port <port>", "Port to run on", "3841").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
@@ -835,71 +835,92 @@ pipelineCmd.action(async () => {
 });
 var symphonyCmd = program.command("symphony").description("Symphony \u2014 agent-to-agent messaging for multi-session collaboration");
 symphonyCmd.command("join").description("Join this session to the Symphony network").option("--remote <ip>", "Connect to remote Symphony server").action(async (options) => {
-  const { symphonyJoinCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyJoinCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyJoinCommand(options);
 });
 symphonyCmd.command("leave").description("Remove this session from the Symphony network").action(async () => {
-  const { symphonyLeaveCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyLeaveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyLeaveCommand();
 });
 symphonyCmd.command("whoami").description("Show this agent's identity and linked peers").action(async () => {
-  const { symphonyWhoamiCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyWhoamiCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyWhoamiCommand();
 });
 symphonyCmd.command("list").alias("ls").description("List all joined agents").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyListCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyListCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyListCommand(options);
 });
 symphonyCmd.command("send <message>").description("Send a note to agents").option("--to <agent>", "Send to specific agent (omit for broadcast)").option("--thread <id>", "Reply to existing thread").action(async (message, options) => {
-  const { symphonySendCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonySendCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonySendCommand(message, options);
 });
 symphonyCmd.command("read").description("Show unread notes").action(async () => {
-  const { symphonyReadCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyReadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyReadCommand();
 });
 symphonyCmd.command("inbox").description("Show unread notes (alias for read)").action(async () => {
-  const { symphonyReadCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyReadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyReadCommand();
 });
 symphonyCmd.command("threads").description("List all threads").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyThreadsCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyThreadsCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyThreadsCommand(options);
 });
 symphonyCmd.command("thread <id>").description("Show full thread conversation").action(async (id) => {
-  const { symphonyThreadCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyThreadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyThreadCommand(id);
 });
 symphonyCmd.command("resolve <id>").description("Mark a thread as resolved").option("--decision <text>", "Decision text to record").action(async (id, options) => {
-  const { symphonyResolveCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyResolveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyResolveCommand(id, options);
 });
 symphonyCmd.command("status").description("Show Symphony network status").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyStatusCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyStatusCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyStatusCommand(options);
 });
-symphonyCmd.command("serve").description("Start TCP server for remote Symphony linking").option("--port <port>", "Port to listen on", "3939").action(async (options) => {
-  const { symphonyServeCommand } = await import("./symphony-EYRGGVNE.js");
+symphonyCmd.command("serve").description("Start Symphony relay server for cross-machine networking").option("--port <port>", "Port to listen on", "3939").option("--public", "Show connection string for internet access").action(async (options) => {
+  const { symphonyServeCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyServeCommand(options);
 });
+var peersCmd = symphonyCmd.command("peers").description("Manage trusted remote peers");
+peersCmd.command("list", { isDefault: true }).description("List trusted peers and their agents").option("--json", "Output as JSON").action(async (options) => {
+  const { symphonyPeersCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersCommand(options);
+});
+peersCmd.command("revoke <id>").description("Revoke trust for a peer (disconnects immediately)").action(async (id) => {
+  const { symphonyPeersRevokeCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersRevokeCommand(id);
+});
+peersCmd.command("forget").description("Clear all peer trust records").option("--force", "Skip confirmation").action(async (options) => {
+  const { symphonyPeersForgetCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersForgetCommand(options);
+});
+peersCmd.action(async () => {
+  const { symphonyPeersCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersCommand({});
+});
 symphonyCmd.command("request <file>").description("Request a file from another agent").option("--from <agent>", "Agent to request from").option("--reason <text>", "Why this file is needed").action(async (file, options) => {
-  const { symphonyRequestCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyRequestCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyRequestCommand(file, options);
 });
 symphonyCmd.command("requests").description("List pending file requests").action(async () => {
-  const { symphonyRequestsCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyRequestsCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyRequestsCommand();
 });
 symphonyCmd.command("approve <id>").description("Approve a file request").option("--redact", "Strip sensitive lines before sending").action(async (id, options) => {
-  const { symphonyApproveCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyApproveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyApproveCommand(id, options);
 });
 symphonyCmd.command("deny <id>").description("Deny a file request").option("--reason <text>", "Reason for denial").action(async (id, options) => {
-  const { symphonyDenyCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyDenyCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyDenyCommand(id, options);
 });
+symphonyCmd.command("watch").description("Watch inbox in real-time \u2014 zero AI tokens, pure file monitoring").option("--interval <ms>", "Poll interval in milliseconds (default: 2000)").option("--thread <id>", "Only show messages from this thread").option("--quiet", "Minimal output \u2014 messages only, no header").action(async (options) => {
+  const { symphonyWatchCommand } = await import("./symphony-6K3HD7AW.js");
+  await symphonyWatchCommand(options);
+});
 symphonyCmd.action(async () => {
-  const { symphonyStatusCommand } = await import("./symphony-EYRGGVNE.js");
+  const { symphonyStatusCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyStatusCommand({});
 });
 program.parse();

package/dist/mcp.js

@@ -14584,6 +14584,35 @@ function outboxPath(agentId) {
 function ackPath(agentId) {
   return path28.join(getAgentDir(agentId), "ack.json");
 }
+function peekInbox(agentId) {
+  const filePath = inboxPath(agentId);
+  if (!fs26.existsSync(filePath)) return { hasNew: false, inboxSize: 0 };
+  const stat = fs26.statSync(filePath);
+  const inboxSize = stat.size;
+  const ack = readAck(agentId);
+  if (!ack) {
+    return { hasNew: inboxSize > 0, inboxSize };
+  }
+  const ackSizePath = path28.join(getAgentDir(agentId), "ack-size.json");
+  if (fs26.existsSync(ackSizePath)) {
+    try {
+      const ackSize = JSON.parse(fs26.readFileSync(ackSizePath, "utf-8"));
+      return { hasNew: inboxSize > (ackSize.size || 0), inboxSize };
+    } catch {
+    }
+  }
+  return { hasNew: inboxSize > 0, inboxSize };
+}
+function recordAckSize(agentId) {
+  const filePath = inboxPath(agentId);
+  const ackSizePath = path28.join(getAgentDir(agentId), "ack-size.json");
+  try {
+    const size = fs26.existsSync(filePath) ? fs26.statSync(filePath).size : 0;
+    ensureAgentDir(agentId);
+    fs26.writeFileSync(ackSizePath, JSON.stringify({ size }), "utf-8");
+  } catch {
+  }
+}
 function appendToInbox(agentId, message) {
   ensureAgentDir(agentId);
   appendJsonlLine(inboxPath(agentId), message);
@@ -14942,9 +14971,26 @@ function isProcessAlive2(pid) {
 // ../paradigm-mcp/src/tools/symphony.ts
 function getSymphonyToolsList() {
   return [
+    {
+      name: "paradigm_symphony_peek",
+      description: "Ultra-cheap inbox check \u2014 file stat only, no parsing. Returns { hasNew: true/false }. Use with /loop 10s for near-free monitoring. When hasNew is true, call paradigm_symphony_poll to read messages. ~15 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            description: "Short status blurb (same as poll). Updates heartbeat."
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
     {
       name: "paradigm_symphony_poll",
-      description: "Poll inbox for new notes. Call via /loop for continuous agent messaging. Returns unread notes formatted as markdown with thread context and suggested actions. Updates heartbeat and optional status blurb. ~200 tokens.",
+      description: "Read inbox notes and process them. Call when paradigm_symphony_peek returns hasNew: true, or directly via /loop for continuous messaging. Returns unread notes formatted as markdown with thread context and suggested actions. Updates heartbeat and optional status blurb. ~200 tokens.",
       inputSchema: {
         type: "object",
         properties: {
@@ -15121,6 +15167,16 @@ async function handleSymphonyTool(name, args, ctx) {
     identity = registerAgent(ctx.rootDir);
   }
   switch (name) {
+    case "paradigm_symphony_peek": {
+      const peekStatus = args.status;
+      markAgentPollTime(identity.id, peekStatus);
+      const { hasNew } = peekInbox(identity.id);
+      const pendingRequests = hasNew ? listFileRequests("pending").length : 0;
+      return {
+        handled: true,
+        text: JSON.stringify(hasNew ? { hasNew: true, pendingFileRequests: pendingRequests, action: "call paradigm_symphony_poll to read" } : { hasNew: false })
+      };
+    }
     case "paradigm_symphony_poll": {
       cleanStaleAgents();
       expireOldRequests();
@@ -15130,6 +15186,7 @@ async function handleSymphonyTool(name, args, ctx) {
       if (messages.length > 0) {
         const lastId = messages[messages.length - 1].id;
         acknowledgeMessages(identity.id, lastId);
+        recordAckSize(identity.id);
       }
       garbageCollect(identity.id);
       const pendingRequests = listFileRequests("pending");
@@ -15236,6 +15293,18 @@ async function handleSymphonyTool(name, args, ctx) {
       const threads = listThreads("active");
       const unread = readInbox(identity.id);
       const pendingRequests = listFileRequests("pending");
+      let peers = [];
+      try {
+        const { loadPeers } = await import("./symphony-peers-APOGJPF4.js");
+        const allPeers = loadPeers();
+        peers = allPeers.filter((p) => !p.revoked).map((p) => ({
+          id: p.id,
+          address: p.address,
+          agents: p.agents?.length ?? 0,
+          lastSeen: p.lastSeen
+        }));
+      } catch {
+      }
       return {
         handled: true,
         text: JSON.stringify({
@@ -15253,6 +15322,7 @@ async function handleSymphonyTool(name, args, ctx) {
             lastPoll: a.lastPoll,
             statusBlurb: a.statusBlurb
           })),
+          peers,
           activeThreads: threads.map((t) => ({
             id: t.id,
             topic: t.topic,

package/dist/peers-RFQCWVLV.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  forgetAllPeers,
+  loadPeers,
+  revokePeer
+} from "./chunk-KVDYJLTC.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/symphony/peers.ts
+import chalk from "chalk";
+async function symphonyPeersCommand(options) {
+  const peers = loadPeers();
+  if (options.json) {
+    console.log(JSON.stringify(peers, null, 2));
+    return;
+  }
+  if (peers.length === 0) {
+    console.log(chalk.yellow('No trusted peers. Run "paradigm symphony serve" to accept connections.'));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Trusted Peers (${peers.length})
+`));
+  console.log(chalk.gray(`  ${"PEER ID".padEnd(20)} ${"ADDRESS".padEnd(22)} ${"STATUS".padEnd(10)} ${"AGENTS".padEnd(8)} LAST SEEN`));
+  console.log(chalk.gray(`  ${"\u2500".repeat(20)} ${"\u2500".repeat(22)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)} ${"\u2500".repeat(20)}`));
+  for (const peer of peers) {
+    const status = peer.revoked ? chalk.red("revoked") : chalk.green("trusted");
+    const agentCount = (peer.agents || []).length.toString();
+    const lastSeen = peer.lastSeen ? formatRelativeTime(peer.lastSeen) : chalk.gray("never");
+    console.log(`  ${chalk.white(peer.id.padEnd(20))} ${peer.address.padEnd(22)} ${status.padEnd(10)} ${agentCount.padEnd(8)} ${lastSeen}`);
+    if (peer.agents && peer.agents.length > 0) {
+      for (const agent of peer.agents) {
+        const agentStatus = agent.status === "awake" ? chalk.green("awake") : chalk.yellow("asleep");
+        console.log(chalk.gray(`    \u2514 ${agent.id} [${agentStatus}]`));
+      }
+    }
+  }
+  console.log();
+}
+async function symphonyPeersRevokeCommand(peerId) {
+  const success = revokePeer(peerId);
+  if (success) {
+    console.log(chalk.green(`\u2713 Revoked peer ${chalk.bold(peerId)}`));
+    console.log(chalk.gray("  Peer will be disconnected and cannot reconnect until re-paired."));
+  } else {
+    console.log(chalk.red(`Peer "${peerId}" not found.`));
+    const peers = loadPeers();
+    if (peers.length > 0) {
+      console.log(chalk.gray("\n  Available peers:"));
+      for (const p of peers) {
+        console.log(chalk.gray(`    ${p.id} (${p.address})`));
+      }
+    }
+  }
+}
+async function symphonyPeersForgetCommand(options) {
+  const peers = loadPeers();
+  if (peers.length === 0) {
+    console.log(chalk.yellow("No peers to forget."));
+    return;
+  }
+  if (!options.force) {
+    console.log(chalk.yellow(`This will remove all ${peers.length} trusted peer(s). Use --force to confirm.`));
+    return;
+  }
+  const count = forgetAllPeers();
+  console.log(chalk.green(`\u2713 Forgot ${count} peer${count !== 1 ? "s" : ""}`));
+  console.log(chalk.gray("  All peer trust records deleted. Re-pairing required for remote connections."));
+}
+function formatRelativeTime(isoDate) {
+  const diff = Date.now() - new Date(isoDate).getTime();
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+export {
+  symphonyPeersCommand,
+  symphonyPeersForgetCommand,
+  symphonyPeersRevokeCommand
+};

package/dist/{platform-server-KHL6ZPPN.js → platform-server-H7Y6Q7O4.js}

@@ -857,7 +857,7 @@ async function startPlatformServer(options) {
   }
   if (sections.has("symphony")) {
     try {
-      const { createSymphonyRouter } = await import("./symphony-QWOEKZMC.js");
+      const { createSymphonyRouter } = await import("./symphony-YCHBYN3E.js");
       app.use("/api/symphony", createSymphonyRouter(options.projectDir, wsContext.broadcast));
       log.component("platform-server").success("Symphony routes mounted");
     } catch (err) {

package/dist/{serve-JVXSRSUB.js → serve-KKEHE44G.js}

@@ -10,7 +10,7 @@ async function serveCommand(options) {
   const sections = options.sections ? options.sections.split(",").map((s) => s.trim()) : void 0;
   console.log(chalk.cyan("\n  Starting Paradigm Platform...\n"));
   try {
-    const { startPlatformServer } = await import("./platform-server-KHL6ZPPN.js");
+    const { startPlatformServer } = await import("./platform-server-H7Y6Q7O4.js");
     await startPlatformServer({ port, projectDir, open: shouldOpen, sections });
     console.log(chalk.green(`  Platform running at ${chalk.bold(`http://localhost:${port}`)}`));
     console.log(chalk.gray("  Press Ctrl+C to stop\n"));