@a-company/paradigm 5.11.0 → 5.21.0

package/dist/symphony-4OCY36AI.js

@@ -1,791 +0,0 @@
-#!/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-PDX44BCA.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-UJYUXN65.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-2ZQYLRNI.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-2ZQYLRNI.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-UJYUXN65.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
-};