@a-company/paradigm 3.28.0 → 3.43.0

package/dist/symphony-ROEKK7VD.js

@@ -0,0 +1,999 @@
+#!/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";
+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 LEGACY_MAIL_DIR = path.join(os.homedir(), ".paradigm", "mail");
+var AGENTS_DIR = path.join(SCORE_DIR, "agents");
+var THREADS_DIR = path.join(SCORE_DIR, "threads");
+var FILE_REQUESTS_DIR = path.join(SCORE_DIR, "file-requests");
+var TRUST_CONFIG_PATH = path.join(SCORE_DIR, "trust.yaml");
+var FILE_REQUEST_TTL_MS = 60 * 60 * 1e3;
+var DEFAULT_TRUST = {
+  users: {},
+  defaults: {
+    level: "restricted",
+    autoApprove: [],
+    neverApprove: [
+      ".env*",
+      "**/*.key",
+      "**/*.pem",
+      "**/credentials*",
+      "**/secrets/**"
+    ]
+  }
+};
+function migrateFromLegacyMail() {
+  if (fs.existsSync(LEGACY_MAIL_DIR) && !fs.existsSync(SCORE_DIR)) {
+    try {
+      fs.renameSync(LEGACY_MAIL_DIR, SCORE_DIR);
+    } catch {
+    }
+  }
+}
+function ensureScoreDirs() {
+  migrateFromLegacyMail();
+  for (const dir of [AGENTS_DIR, THREADS_DIR, FILE_REQUESTS_DIR]) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+function getAgentDir(agentId) {
+  return path.join(AGENTS_DIR, agentId);
+}
+function ensureAgentDir(agentId) {
+  const dir = getAgentDir(agentId);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function readJsonlFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim().length > 0);
+  const items = [];
+  for (const line of lines) {
+    try {
+      items.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return items;
+}
+function appendJsonlLine(filePath, item) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.appendFileSync(filePath, JSON.stringify(item) + "\n", "utf-8");
+}
+function sanitizeId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40) || "unknown";
+}
+function resolveProjectName(projectDir) {
+  try {
+    const configPath = path.join(projectDir, ".paradigm", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const match = content.match(/^project:\s*(.+)$/m);
+      if (match) return sanitizeId(match[1].trim().replace(/["']/g, ""));
+    }
+  } catch {
+  }
+  return sanitizeId(path.basename(projectDir));
+}
+function resolveAgentIdentity(projectDir, role) {
+  const project = resolveProjectName(projectDir);
+  const agentRole = role || "core";
+  return `${project}/${agentRole}`;
+}
+function registerAgent(projectDir, role, label) {
+  ensureScoreDirs();
+  const agentId = resolveAgentIdentity(projectDir, role);
+  const agentDir = ensureAgentDir(agentId);
+  const project = resolveProjectName(projectDir);
+  const identity = {
+    id: agentId,
+    name: label || `${project} (${role || "core"})`,
+    type: "agent",
+    project,
+    role: role || "core",
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    label
+  };
+  fs.writeFileSync(
+    path.join(agentDir, "identity.json"),
+    JSON.stringify(identity, null, 2),
+    "utf-8"
+  );
+  return identity;
+}
+function unregisterAgent(agentId) {
+  const agentDir = getAgentDir(agentId);
+  if (!fs.existsSync(agentDir)) return false;
+  try {
+    fs.rmSync(agentDir, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listAgents() {
+  ensureScoreDirs();
+  if (!fs.existsSync(AGENTS_DIR)) return [];
+  const agents = [];
+  const projectDirs = fs.readdirSync(AGENTS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const projectDir of projectDirs) {
+    const projectPath = path.join(AGENTS_DIR, projectDir.name);
+    const roleDirs = fs.readdirSync(projectPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const roleDir of roleDirs) {
+      const identityPath = path.join(projectPath, roleDir.name, "identity.json");
+      if (!fs.existsSync(identityPath)) continue;
+      try {
+        const content = fs.readFileSync(identityPath, "utf-8");
+        const identity = JSON.parse(content);
+        agents.push(identity);
+      } catch {
+      }
+    }
+  }
+  return agents;
+}
+function cleanStaleAgents() {
+  const agents = listAgents();
+  let cleaned = 0;
+  for (const agent of agents) {
+    if (!isProcessAlive(agent.pid)) {
+      unregisterAgent(agent.id);
+      cleaned++;
+    }
+  }
+  return cleaned;
+}
+function getMyIdentity(projectDir) {
+  const agentId = resolveAgentIdentity(projectDir);
+  const identityPath = path.join(getAgentDir(agentId), "identity.json");
+  if (!fs.existsSync(identityPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(identityPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function markAgentPollTime(agentId) {
+  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();
+    fs.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
+  } catch {
+  }
+}
+function isAgentAsleep(identity, thresholdMs = 6e4) {
+  if (!identity.lastPoll) return true;
+  const lastPoll = new Date(identity.lastPoll).getTime();
+  return Date.now() - lastPoll > thresholdMs;
+}
+function discoverClaudeCodeSessions() {
+  const agents = listAgents();
+  const alive = agents.filter((a) => isProcessAlive(a.pid));
+  try {
+    const conductorSessionsDir = path.join(os.homedir(), ".conductor", "sessions");
+    if (fs.existsSync(conductorSessionsDir)) {
+      const files = fs.readdirSync(conductorSessionsDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(conductorSessionsDir, file), "utf-8");
+          const session = JSON.parse(content);
+          const pid = parseInt(path.basename(file, ".json"), 10);
+          if (!alive.some((a) => a.pid === pid) && isProcessAlive(pid)) {
+            alive.push({
+              id: `conductor/${pid}`,
+              name: session.label || `Session ${pid}`,
+              type: "agent",
+              project: session.projectDir ? path.basename(session.projectDir) : "unknown",
+              role: "conductor",
+              pid,
+              startedAt: session.registeredAt || (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return alive;
+}
+function inboxPath(agentId) {
+  return path.join(getAgentDir(agentId), "inbox.jsonl");
+}
+function outboxPath(agentId) {
+  return path.join(getAgentDir(agentId), "outbox.jsonl");
+}
+function ackPath(agentId) {
+  return path.join(getAgentDir(agentId), "ack.json");
+}
+function appendToInbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(inboxPath(agentId), message);
+}
+function readInbox(agentId, afterAck) {
+  const messages = readJsonlFile(inboxPath(agentId));
+  if (!afterAck) {
+    const ack = readAck(agentId);
+    if (ack) {
+      const ackIndex2 = messages.findIndex((m) => m.id === ack);
+      if (ackIndex2 >= 0) return messages.slice(ackIndex2 + 1);
+    }
+    return messages;
+  }
+  const ackIndex = messages.findIndex((m) => m.id === afterAck);
+  if (ackIndex >= 0) return messages.slice(ackIndex + 1);
+  return messages;
+}
+function appendToOutbox(agentId, message) {
+  ensureAgentDir(agentId);
+  appendJsonlLine(outboxPath(agentId), message);
+}
+function acknowledgeMessages(agentId, lastMessageId) {
+  const filePath = ackPath(agentId);
+  ensureAgentDir(agentId);
+  fs.writeFileSync(filePath, JSON.stringify({ lastAck: lastMessageId }), "utf-8");
+}
+function readAck(agentId) {
+  const filePath = ackPath(agentId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return content.lastAck || null;
+  } catch {
+    return null;
+  }
+}
+function garbageCollect(agentId) {
+  const ack = readAck(agentId);
+  if (!ack) return 0;
+  const filePath = inboxPath(agentId);
+  const messages = readJsonlFile(filePath);
+  const ackIndex = messages.findIndex((m) => m.id === ack);
+  if (ackIndex < 0) return 0;
+  const kept = messages.slice(ackIndex + 1);
+  const removed = messages.length - kept.length;
+  if (kept.length === 0) {
+    if (fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf-8");
+  } else {
+    fs.writeFileSync(filePath, kept.map((m) => JSON.stringify(m)).join("\n") + "\n", "utf-8");
+  }
+  return removed;
+}
+function threadPath(threadId) {
+  return path.join(THREADS_DIR, `${threadId}.json`);
+}
+function createThread(topic, initiator) {
+  ensureScoreDirs();
+  const id = "thr-" + crypto.randomBytes(4).toString("hex");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const thread = {
+    id,
+    topic,
+    initiator,
+    participants: [initiator],
+    status: "active",
+    createdAt: now,
+    lastActivity: now,
+    messageCount: 0
+  };
+  fs.writeFileSync(threadPath(id), JSON.stringify(thread, null, 2), "utf-8");
+  return thread;
+}
+function loadThread(threadId) {
+  const filePath = threadPath(threadId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listThreads(status) {
+  ensureScoreDirs();
+  if (!fs.existsSync(THREADS_DIR)) return [];
+  const files = fs.readdirSync(THREADS_DIR).filter((f) => f.endsWith(".json"));
+  const threads = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(THREADS_DIR, file), "utf-8");
+      const thread = JSON.parse(content);
+      if (!status || thread.status === status) {
+        threads.push(thread);
+      }
+    } catch {
+    }
+  }
+  return threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+}
+function updateThread(threadId, partial) {
+  const thread = loadThread(threadId);
+  if (!thread) return false;
+  const updated = { ...thread, ...partial };
+  fs.writeFileSync(threadPath(threadId), JSON.stringify(updated, null, 2), "utf-8");
+  return true;
+}
+function resolveThread(threadId, decision) {
+  return updateThread(threadId, {
+    status: "resolved",
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    decision
+  });
+}
+function getThreadMessages(threadId) {
+  const agents = listAgents();
+  const messages = [];
+  for (const agent of agents) {
+    const inbox = readJsonlFile(inboxPath(agent.id));
+    const outbox = readJsonlFile(outboxPath(agent.id));
+    for (const msg of [...inbox, ...outbox]) {
+      if (msg.threadRoot === threadId || msg.id === threadId) {
+        if (!messages.some((m) => m.id === msg.id)) {
+          messages.push(msg);
+        }
+      }
+    }
+  }
+  return messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+}
+function buildMessage(params) {
+  return {
+    id: crypto.randomUUID(),
+    parentId: params.parentId,
+    threadRoot: params.threadRoot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    sender: params.sender,
+    recipients: params.recipients,
+    intent: params.intent,
+    content: {
+      text: params.text,
+      diff: params.diff,
+      decision: params.decision
+    },
+    symbols: params.symbols || [],
+    attachments: params.attachments,
+    metadata: params.metadata
+  };
+}
+function routeMessage(message) {
+  ensureScoreDirs();
+  appendToOutbox(message.sender.id, message);
+  let deliveryCount = 0;
+  if (message.recipients && message.recipients.length > 0) {
+    for (const recipient of message.recipients) {
+      appendToInbox(recipient.id, message);
+      deliveryCount++;
+    }
+  } else {
+    const agents = listAgents();
+    for (const agent of agents) {
+      if (agent.id !== message.sender.id) {
+        appendToInbox(agent.id, message);
+        deliveryCount++;
+      }
+    }
+  }
+  if (message.threadRoot) {
+    const thread = loadThread(message.threadRoot);
+    if (thread) {
+      const isParticipant = thread.participants.some((p) => p.id === message.sender.id);
+      const updatedParticipants = isParticipant ? thread.participants : [...thread.participants, message.sender];
+      updateThread(message.threadRoot, {
+        participants: updatedParticipants,
+        lastActivity: message.timestamp,
+        messageCount: thread.messageCount + 1
+      });
+    }
+  }
+  return deliveryCount;
+}
+function fileRequestPath(requestId) {
+  return path.join(FILE_REQUESTS_DIR, `${requestId}.json`);
+}
+function loadTrustConfig() {
+  if (!fs.existsSync(TRUST_CONFIG_PATH)) return DEFAULT_TRUST;
+  try {
+    const content = fs.readFileSync(TRUST_CONFIG_PATH, "utf-8");
+    try {
+      return JSON.parse(content);
+    } catch {
+      return DEFAULT_TRUST;
+    }
+  } catch {
+    return DEFAULT_TRUST;
+  }
+}
+function createFileRequest(params) {
+  ensureScoreDirs();
+  const requestId = "freq-" + crypto.randomBytes(4).toString("hex");
+  const record = {
+    request: {
+      requestId,
+      filePath: params.filePath,
+      reason: params.reason,
+      requester: params.requester,
+      urgency: params.urgency || "normal",
+      snippet: params.snippet,
+      threadRoot: params.threadRoot
+    },
+    status: "pending",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  return record;
+}
+function loadFileRequest(requestId) {
+  const filePath = fileRequestPath(requestId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function listFileRequests(status) {
+  ensureScoreDirs();
+  if (!fs.existsSync(FILE_REQUESTS_DIR)) return [];
+  const files = fs.readdirSync(FILE_REQUESTS_DIR).filter((f) => f.endsWith(".json"));
+  const requests = [];
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(path.join(FILE_REQUESTS_DIR, file), "utf-8");
+      const record = JSON.parse(content);
+      if (!status || record.status === status) {
+        requests.push(record);
+      }
+    } catch {
+    }
+  }
+  return requests.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+function approveFileRequest(requestId, projectDir, redact) {
+  const record = loadFileRequest(requestId);
+  if (!record) return { success: false, error: `File request not found: ${requestId}` };
+  if (record.status !== "pending") return { success: false, error: `Request already ${record.status}` };
+  const absolutePath = path.resolve(projectDir, record.request.filePath);
+  if (!absolutePath.startsWith(path.resolve(projectDir))) {
+    return { success: false, error: "File path escapes project directory" };
+  }
+  if (!fs.existsSync(absolutePath)) {
+    return { success: false, error: `File not found: ${record.request.filePath}` };
+  }
+  try {
+    let content = fs.readFileSync(absolutePath, "utf-8");
+    let encoding = "utf8";
+    if (redact) {
+      const secretPatterns = [
+        /(?:api[_-]?key|secret|token|password|credential|auth)\s*[:=]/i,
+        /(?:^|\s)(?:export\s+)?[A-Z_]+(?:KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)\s*=/,
+        /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
+      ];
+      content = content.split("\n").map((line) => {
+        for (const pattern of secretPatterns) {
+          if (pattern.test(line)) return "[REDACTED]";
+        }
+        return line;
+      }).join("\n");
+    }
+    const hash = crypto.createHash("sha256").update(content).digest("hex");
+    const delivery = {
+      requestId,
+      filePath: record.request.filePath,
+      content,
+      encoding,
+      size: Buffer.byteLength(content),
+      hash
+    };
+    record.status = "approved";
+    record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+    record.delivery = delivery;
+    fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+    const deliveryMessage = buildMessage({
+      sender: { id: "system", name: "File Transfer", type: "human" },
+      recipients: [record.request.requester],
+      intent: "fileDelivery",
+      text: `File delivered: ${record.request.filePath} (${delivery.size} bytes, SHA-256: ${hash.slice(0, 12)}...)`,
+      threadRoot: record.request.threadRoot,
+      symbols: []
+    });
+    deliveryMessage.attachments = [{
+      name: path.basename(record.request.filePath),
+      type: "file",
+      content: delivery.content,
+      encoding: delivery.encoding
+    }];
+    routeMessage(deliveryMessage);
+    return { success: true, delivery };
+  } catch (err) {
+    return { success: false, error: `Failed to read file: ${err.message}` };
+  }
+}
+function denyFileRequest(requestId, reason) {
+  const record = loadFileRequest(requestId);
+  if (!record || record.status !== "pending") return false;
+  record.status = "denied";
+  record.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+  record.denyReason = reason;
+  fs.writeFileSync(fileRequestPath(requestId), JSON.stringify(record, null, 2), "utf-8");
+  const denialMessage = buildMessage({
+    sender: { id: "system", name: "File Transfer", type: "human" },
+    recipients: [record.request.requester],
+    intent: "fileDenied",
+    text: `File request denied: ${record.request.filePath}${reason ? ` \u2014 ${reason}` : ""}`,
+    threadRoot: record.request.threadRoot,
+    symbols: []
+  });
+  routeMessage(denialMessage);
+  return true;
+}
+function matchesGlob(filePath, pattern) {
+  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(filePath);
+}
+function isPathDenied(filePath, config, user) {
+  const trust = config || loadTrustConfig();
+  if (user && trust.users[user]) {
+    for (const pattern of trust.users[user].neverApprove) {
+      if (matchesGlob(filePath, pattern)) return true;
+    }
+  }
+  for (const pattern of trust.defaults.neverApprove) {
+    if (matchesGlob(filePath, pattern)) return true;
+  }
+  return false;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// 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
+};