@a-company/paradigm 3.43.0 → 3.46.0

package/dist/symphony-6K3HD7AW.js

@@ -0,0 +1,791 @@
+#!/usr/bin/env node
+import {
+  acknowledgeMessages,
+  approveFileRequest,
+  buildMessage,
+  cleanStaleAgents,
+  createFileRequest,
+  createThread,
+  denyFileRequest,
+  discoverClaudeCodeSessions,
+  garbageCollect,
+  getMyIdentity,
+  getThreadMessages,
+  isAgentAsleep,
+  isPathDenied,
+  listAgents,
+  listFileRequests,
+  listThreads,
+  loadThread,
+  loadTrustConfig,
+  markAgentPollTime,
+  readInbox,
+  registerAgent,
+  resolveAgentIdentity,
+  resolveThread,
+  routeMessage,
+  unregisterAgent
+} from "./chunk-S2HO5MLR.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/symphony/index.ts
+import chalk from "chalk";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+async function symphonyJoinCommand(options) {
+  const rootDir = process.cwd();
+  if (options.remote) {
+    await symphonyJoinRemote(rootDir, options.remote);
+    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 symphonyJoinRemote(rootDir, remote) {
+  const { SymphonyRelay } = await import("./symphony-relay-GTAJRCVF.js");
+  let address;
+  let embeddedCode;
+  if (remote.includes("#")) {
+    const parts = remote.split("#");
+    address = parts[0];
+    embeddedCode = parts[1];
+  } else {
+    address = remote;
+  }
+  if (!address.includes(":")) {
+    address = `${address}:3939`;
+  }
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+  }
+  let code;
+  if (embeddedCode) {
+    code = embeddedCode;
+    console.log(chalk.cyan(`
+  Connecting to ${address} with embedded pairing code...`));
+  } else {
+    console.log(chalk.cyan(`
+  Connecting to ${address}...`));
+    console.log(chalk.white("  Enter the 6-digit pairing code shown on the host:"));
+    code = await readLineFromStdin("  Code: ");
+    code = code.trim();
+    if (!/^\d{6}$/.test(code)) {
+      console.log(chalk.red("  Invalid code. Must be 6 digits."));
+      return;
+    }
+  }
+  const relay = new SymphonyRelay({
+    mode: "client",
+    peerId: identity.id,
+    events: {
+      onPeerConnected: (peerId, displayName) => {
+        console.log(chalk.green(`  \u2713 Connected to ${chalk.bold(displayName)} (${peerId})`));
+      },
+      onPeerDisconnected: (peerId) => {
+        console.log(chalk.yellow(`  Peer ${peerId} disconnected. Reconnecting...`));
+      },
+      onMessageRelayed: (messageId, from, to) => {
+        console.log(chalk.gray(`  \u2190 Message ${messageId.slice(0, 8)} from ${from} \u2192 ${to}`));
+      },
+      onError: (err) => {
+        console.log(chalk.red(`  Error: ${err.message}`));
+      }
+    }
+  });
+  try {
+    await relay.connectToServer(address, code);
+    console.log(chalk.green("\n  \u2713 Paired and connected!"));
+    console.log(chalk.gray("  Messages from remote agents will appear in your inbox."));
+    console.log(chalk.gray("  Press Ctrl+C to disconnect.\n"));
+    process.on("SIGINT", () => {
+      console.log(chalk.yellow("\n  Disconnecting..."));
+      relay.stop();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.log(chalk.red(`  Failed to connect: ${err.message}`));
+    relay.stop();
+  }
+}
+function readLineFromStdin(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.resume();
+    process.stdin.once("data", (chunk) => {
+      data = chunk.toString();
+      process.stdin.pause();
+      resolve(data);
+    });
+  });
+}
+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}`));
+  if (identity.statusBlurb) {
+    console.log(chalk.white(`  Status: ${identity.statusBlurb}`));
+  }
+  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();
+  const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+  const peers = loadPeers();
+  const remoteAgents = [];
+  for (const peer of peers) {
+    if (peer.revoked) continue;
+    for (const agent of peer.agents || []) {
+      remoteAgents.push({ ...agent, peerId: peer.id });
+    }
+  }
+  const totalCount = agents.length + remoteAgents.length;
+  if (options.json) {
+    console.log(JSON.stringify({
+      local: agents,
+      remote: remoteAgents
+    }, null, 2));
+    return;
+  }
+  if (totalCount === 0) {
+    console.log(chalk.yellow('No agents joined. Run "paradigm symphony join" in each terminal.'));
+    return;
+  }
+  console.log(chalk.cyan(`
+  Symphony Agents (${totalCount})
+`));
+  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}`);
+    if (agent.statusBlurb) {
+      console.log(`  ${chalk.gray(`  \u2514 ${agent.statusBlurb}`)}`);
+    }
+  }
+  if (remoteAgents.length > 0) {
+    console.log(chalk.gray(`
+  ${"\u2500".repeat(65)}`));
+    console.log(chalk.cyan(`  Remote Agents (${remoteAgents.length})
+`));
+    for (const agent of remoteAgents) {
+      const status = agent.status === "awake" ? chalk.green("awake") : chalk.yellow("asleep");
+      const tag = chalk.magenta(`(remote: ${agent.peerId})`);
+      console.log(`  ${chalk.white(agent.id.padEnd(30))} ${agent.project.padEnd(15)} ${agent.role.padEnd(10)} ${status} ${tag}`);
+    }
+  }
+  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) : [];
+  const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+  const peers = loadPeers();
+  const activePeers = peers.filter((p) => !p.revoked);
+  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", statusBlurb: a.statusBlurb })),
+      peers: activePeers.map((p) => ({ id: p.id, address: p.address, agents: p.agents?.length ?? 0, lastSeen: p.lastSeen })),
+      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)`);
+  for (const a of agents) {
+    const st = isAgentAsleep(a) ? chalk.yellow("asleep") : chalk.green("awake");
+    const blurb = a.statusBlurb ? chalk.gray(` \u2014 ${a.statusBlurb}`) : "";
+    console.log(`    ${chalk.white(a.id)} [${st}]${blurb}`);
+  }
+  if (activePeers.length > 0) {
+    const totalRemoteAgents = activePeers.reduce((sum, p) => sum + (p.agents?.length ?? 0), 0);
+    console.log(`  ${chalk.white("Peers:")} ${activePeers.length} connected (${totalRemoteAgents} remote agents)`);
+    for (const p of activePeers) {
+      const agentCount = p.agents?.length ?? 0;
+      console.log(`    ${chalk.white(p.id)} at ${p.address} (${agentCount} agent${agentCount !== 1 ? "s" : ""})`);
+    }
+  } else {
+    console.log(`  ${chalk.white("Peers:")} ${chalk.gray('none (run "paradigm symphony serve" to accept connections)')}`);
+  }
+  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);
+  const rootDir = process.cwd();
+  const { SymphonyRelay } = await import("./symphony-relay-GTAJRCVF.js");
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+  }
+  console.log(chalk.cyan("\n  Starting Symphony relay server...\n"));
+  const relay = new SymphonyRelay({
+    mode: "server",
+    peerId: identity.id,
+    port,
+    events: {
+      onPeerConnected: (peerId, displayName) => {
+        console.log(chalk.green(`  \u2713 Peer connected: ${chalk.bold(displayName)} (${peerId})`));
+        const remoteAgents = relay.getRemoteAgents();
+        if (remoteAgents.length > 0) {
+          console.log(chalk.gray(`    Remote agents: ${remoteAgents.map((a) => a.id).join(", ")}`));
+        }
+      },
+      onPeerDisconnected: (peerId) => {
+        console.log(chalk.yellow(`  Peer disconnected: ${peerId}`));
+      },
+      onPeerAuthFailed: (address, reason) => {
+        console.log(chalk.red(`  Auth failed from ${address}: ${reason}`));
+      },
+      onMessageRelayed: (messageId, from, to) => {
+        console.log(chalk.gray(`  \u2194 Relayed ${messageId.slice(0, 8)} from ${from} to ${to}`));
+      },
+      onError: (err) => {
+        console.log(chalk.red(`  Error: ${err.message}`));
+      }
+    }
+  });
+  try {
+    const pairing = await relay.startServer();
+    const localIp = getLocalIpAddress();
+    console.log(chalk.green(`  \u2713 Symphony relay listening on port ${port}`));
+    console.log();
+    console.log(chalk.white("  Pairing Code:"));
+    console.log();
+    console.log(chalk.bold.cyan(`      ${pairing.code.slice(0, 3)} ${pairing.code.slice(3)}`));
+    console.log();
+    console.log(chalk.gray("  Share this code with the person connecting."));
+    console.log(chalk.gray(`  Code rotates every 5 minutes.
+`));
+    console.log(chalk.white("  LAN connect:"));
+    console.log(chalk.gray(`    paradigm symphony join --remote ${localIp}:${port}`));
+    if (options.public) {
+      const connectionString = `${localIp}:${port}#${pairing.code}`;
+      console.log();
+      console.log(chalk.white("  Internet connect (connection string):"));
+      console.log(chalk.cyan(`    paradigm symphony join --remote ${connectionString}`));
+      console.log(chalk.gray("  (Requires port 3939 reachable: port forward, VPN, or SSH tunnel)"));
+    }
+    console.log(chalk.gray("\n  Press Ctrl+C to stop.\n"));
+    const rotateInterval = setInterval(() => {
+      const newPairing = relay.rotatePairingCode();
+      console.log(chalk.cyan(`  Code rotated: ${newPairing.code.slice(0, 3)} ${newPairing.code.slice(3)}`));
+    }, 5 * 60 * 1e3);
+    process.on("SIGINT", () => {
+      console.log(chalk.yellow("\n  Shutting down relay..."));
+      clearInterval(rotateInterval);
+      relay.stop();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.log(chalk.red(`  Failed to start server: ${err.message}`));
+    relay.stop();
+  }
+}
+function getLocalIpAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+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}`));
+  }
+}
+var INTENT_COLORS = {
+  question: chalk.blue,
+  context: chalk.gray,
+  clarification: chalk.blue,
+  proposal: chalk.cyan,
+  verification: chalk.blue,
+  action: chalk.cyan,
+  decision: chalk.yellow,
+  alert: chalk.red,
+  approval: chalk.green,
+  rejection: chalk.red,
+  reference: chalk.gray,
+  handoff: chalk.magenta,
+  fileRequest: chalk.green,
+  fileApproved: chalk.green,
+  fileDenied: chalk.red,
+  fileDelivery: chalk.green
+};
+function formatWatchMessage(msg) {
+  const time = new Date(msg.timestamp).toLocaleTimeString(void 0, {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const colorFn = INTENT_COLORS[msg.intent] || chalk.white;
+  const intentLabel = colorFn(`[${msg.intent}]`);
+  const sender = chalk.cyan(msg.sender.name);
+  const threadLabel = msg.threadRoot ? chalk.gray(` (${msg.threadRoot})`) : "";
+  const lines = [];
+  lines.push(`  ${chalk.gray(time)} ${sender} ${intentLabel}${threadLabel}`);
+  const textLines = msg.content.text.split("\n");
+  for (const line of textLines) {
+    lines.push(`    ${line}`);
+  }
+  if (msg.symbols.length > 0) {
+    lines.push(`    ${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
+  }
+  if (msg.content.decision) {
+    lines.push(`    ${chalk.yellow(`Decision: ${msg.content.decision}`)}`);
+  }
+  if (msg.content.diff) {
+    lines.push(`    ${chalk.gray("[diff attached]")}`);
+  }
+  return lines.join("\n");
+}
+async function symphonyWatchCommand(options) {
+  const rootDir = process.cwd();
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+    console.log(chalk.gray(`Auto-joined as ${identity.id}`));
+  }
+  const intervalMs = parseInt(options.interval || "2000", 10);
+  const threadFilter = options.thread;
+  const quiet = options.quiet;
+  const scoreDir = path.join(os.homedir(), ".paradigm", "score");
+  const inboxPath = path.join(scoreDir, "agents", ...identity.id.split("/"), "inbox.jsonl");
+  let lastLineCount = 0;
+  let lastSize = 0;
+  if (fs.existsSync(inboxPath)) {
+    const content = fs.readFileSync(inboxPath, "utf-8");
+    lastLineCount = content.split("\n").filter((l) => l.trim().length > 0).length;
+    lastSize = fs.statSync(inboxPath).size;
+  }
+  if (!quiet) {
+    console.log(chalk.cyan("\n  Symphony Watch"));
+    console.log(chalk.gray(`  Agent: ${identity.id}`));
+    console.log(chalk.gray(`  Inbox: ${inboxPath}`));
+    console.log(chalk.gray(`  Poll: ${intervalMs}ms`));
+    if (threadFilter) {
+      console.log(chalk.gray(`  Filter: thread ${threadFilter}`));
+    }
+    console.log(chalk.gray(`  Press Ctrl+C to stop
+`));
+    console.log(chalk.gray(`  ${"\u2500".repeat(60)}
+`));
+  }
+  const threadsDir = path.join(scoreDir, "threads");
+  let knownThreads = /* @__PURE__ */ new Set();
+  if (fs.existsSync(threadsDir)) {
+    for (const f of fs.readdirSync(threadsDir)) {
+      knownThreads.add(f);
+    }
+  }
+  const poll = () => {
+    try {
+      if (fs.existsSync(inboxPath)) {
+        const stat = fs.statSync(inboxPath);
+        if (stat.size > lastSize) {
+          const content = fs.readFileSync(inboxPath, "utf-8");
+          const lines = content.split("\n").filter((l) => l.trim().length > 0);
+          if (lines.length > lastLineCount) {
+            const newLines = lines.slice(lastLineCount);
+            for (const line of newLines) {
+              try {
+                const msg = JSON.parse(line);
+                if (threadFilter && msg.threadRoot !== threadFilter) continue;
+                console.log(formatWatchMessage(msg));
+                console.log();
+              } catch {
+              }
+            }
+            lastLineCount = lines.length;
+          }
+          lastSize = stat.size;
+        }
+      }
+      if (fs.existsSync(threadsDir)) {
+        const currentFiles = fs.readdirSync(threadsDir);
+        for (const f of currentFiles) {
+          if (!knownThreads.has(f)) {
+            knownThreads.add(f);
+            try {
+              const threadData = JSON.parse(
+                fs.readFileSync(path.join(threadsDir, f), "utf-8")
+              );
+              if (!quiet) {
+                console.log(`  ${chalk.green("+")} ${chalk.white("New thread:")} ${threadData.topic || threadData.id}`);
+                console.log(`    ${chalk.gray(`by ${threadData.initiator?.name || "unknown"} \u2014 ${threadData.id}`)}`);
+                console.log();
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      markAgentPollTime(identity.id);
+    } catch {
+    }
+  };
+  poll();
+  const timer = setInterval(poll, intervalMs);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    if (!quiet) {
+      console.log(chalk.gray("\n  Watch stopped.\n"));
+    }
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+export {
+  symphonyApproveCommand,
+  symphonyDenyCommand,
+  symphonyJoinCommand,
+  symphonyLeaveCommand,
+  symphonyListCommand,
+  symphonyReadCommand,
+  symphonyRequestCommand,
+  symphonyRequestsCommand,
+  symphonyResolveCommand,
+  symphonySendCommand,
+  symphonyServeCommand,
+  symphonyStatusCommand,
+  symphonyThreadCommand,
+  symphonyThreadsCommand,
+  symphonyWatchCommand,
+  symphonyWhoamiCommand
+};