@a-company/paradigm 3.43.0 → 3.46.0

package/dist/{chunk-CZEIK3Y2.js → chunk-ZMQA6SCO.js}

@@ -4405,7 +4405,7 @@ function assertStep(step, event) {
 async function validateAgainstSentinel(persona, options = {}) {
   const steps = [];
   try {
-    const { SentinelStorage } = await import("./dist-RVKYUCRU.js");
+    const { SentinelStorage } = await import("./dist-CM3MVWWW.js");
     const storage = new SentinelStorage();
     const events = storage.queryEvents?.({
       schemaId: "paradigm-personas",

package/dist/{chunk-7WEKMZ46.js → chunk-ZSYVKSY6.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   SentinelStorage
-} from "./chunk-YW5OCVKB.js";
+} from "./chunk-FKJUBQU3.js";
 
 // ../sentinel/dist/chunk-VQ3SIN7S.js
 import { v4 as uuidv4 } from "uuid";

package/dist/{commands-LEPFD7S5.js → commands-5N4ILTPH.js}

@@ -599,6 +599,19 @@ var SentinelStorage = class {
     );
     this.save();
   }
+  resolveIncident(id, options) {
+    this.updateIncident(id, {
+      status: "resolved",
+      resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (options?.notes) {
+      this.addIncidentNote(id, {
+        author: "system",
+        content: options.notes,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
   addIncidentNote(incidentId, note) {
     this.initializeSync();
     const incident = this.getIncident(incidentId);

package/dist/{dist-RVKYUCRU.js → dist-CM3MVWWW.js}

@@ -28,7 +28,7 @@ import {
   loadServerConfig,
   loadUniversalPatterns,
   writeConfig
-} from "./chunk-RGFANZ4Q.js";
+} from "./chunk-ZDHLG5VP.js";
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,

package/dist/{dist-Y7I3CFY5.js → dist-POMVY6WP.js}

@@ -19,7 +19,7 @@ import {
   loadAllSeedPatterns,
   loadParadigmPatterns,
   loadUniversalPatterns
-} from "./chunk-7WEKMZ46.js";
+} from "./chunk-ZSYVKSY6.js";
 import {
   DEFAULT_AUTH_CONFIG,
   DEFAULT_RATE_LIMIT_CONFIG,
@@ -30,7 +30,7 @@ import {
   loadConfig,
   loadServerConfig,
   writeConfig
-} from "./chunk-YW5OCVKB.js";
+} from "./chunk-FKJUBQU3.js";
 import "./chunk-ZXMDA7VB.js";
 export {
   ContextEnricher,

package/dist/{habits-O37HTUKE.js → habits-RG5SVKXP.js}

@@ -934,7 +934,7 @@ async function habitsStatusCommand(options) {
   const enabled = getEnabledHabits(habits);
   let practiceData = null;
   try {
-    const { SentinelStorage } = await import("./dist-Y7I3CFY5.js");
+    const { SentinelStorage } = await import("./dist-POMVY6WP.js");
     const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
     if (fs2.existsSync(sentinelDir)) {
       const storage = new SentinelStorage(sentinelDir);
@@ -1302,7 +1302,7 @@ async function habitsCheckCommand(options) {
     try {
       const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
       if (fs2.existsSync(sentinelDir)) {
-        const { SentinelStorage } = await import("./dist-Y7I3CFY5.js");
+        const { SentinelStorage } = await import("./dist-POMVY6WP.js");
         const storage = new SentinelStorage(sentinelDir);
         for (const e of evaluation.evaluations) {
           storage.recordPracticeEvent({

package/dist/index.js

@@ -588,76 +588,76 @@ hooksCmd.action(async () => {
 });
 var triageCmd = program.command("triage").description("Semantic error triage - incident management and pattern matching");
 triageCmd.command("list").alias("ls").description("List recent incidents with matched patterns").option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status: open, investigating, resolved, wont-fix, all").option("--symbol <symbol>", "Filter by symbol (e.g., @checkout, ^auth)").option("-e, --env <environment>", "Filter by environment").option("--search <text>", "Search in error messages").option("--from <date>", "Filter from date (ISO format)").option("--to <date>", "Filter to date (ISO format)").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageListCommand } = await import("./triage-IZ4MDYNB.js");
   await triageListCommand(options);
 });
 triageCmd.command("show <id>").description("Show full incident details").option("--timeline", "Include flow timeline").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triageShowCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageShowCommand } = await import("./triage-IZ4MDYNB.js");
   await triageShowCommand(id, options);
 });
 triageCmd.command("resolve <id>").description("Mark incident as resolved").option("-p, --pattern <patternId>", "Pattern that led to resolution").option("-c, --commit <hash>", "Git commit hash of fix").option("--pr <url>", "Pull request URL").option("-n, --notes <text>", "Resolution notes").option("--wont-fix", "Mark as will not fix").action(async (id, options) => {
-  const { triageResolveCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageResolveCommand } = await import("./triage-IZ4MDYNB.js");
   await triageResolveCommand(id, options);
 });
 triageCmd.command("note <id> <note>").description("Add a note to an incident").action(async (id, note) => {
-  const { triageNoteCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageNoteCommand } = await import("./triage-IZ4MDYNB.js");
   await triageNoteCommand(id, note);
 });
 triageCmd.command("link <id1> <id2>").description("Link two related incidents").action(async (id1, id2) => {
-  const { triageLinkCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageLinkCommand } = await import("./triage-IZ4MDYNB.js");
   await triageLinkCommand(id1, id2);
 });
 var triagePatternsCmd = triageCmd.command("patterns").description("Manage failure patterns");
 triagePatternsCmd.command("list").alias("ls").description("List all patterns").option("--source <source>", "Filter by source: manual, suggested, imported, community").option("--min-confidence <score>", "Minimum confidence score").option("--json", "Output as JSON").action(async (options) => {
-  const { triagePatternsListCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsListCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsListCommand(options);
 });
 triagePatternsCmd.command("show <id>").description("Show pattern details").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsShowCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsShowCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsShowCommand(id, options);
 });
 triagePatternsCmd.command("add").description("Create a new pattern").requiredOption("--id <id>", "Pattern ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").option("--description <text>", "Pattern description").option("--symbols <pairs>", 'Symbol criteria (e.g., "feature:@checkout,gate:^auth")').option("--error-contains <keywords>", "Error keywords (comma-separated)").option("--missing-signals <signals>", "Expected missing signals (comma-separated)").option("--strategy <strategy>", "Resolution strategy: retry, fallback, fix-data, fix-code, ignore, escalate", "fix-code").option("--priority <priority>", "Priority: low, medium, high, critical", "medium").option("--code-hint <text>", "Code hint for resolution").option("--tags <tags>", "Tags (comma-separated)").option("--from-incident <id>", "Generate suggestion from incident").action(async (options) => {
-  const { triagePatternsAddCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsAddCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsAddCommand(options);
 });
 triagePatternsCmd.command("delete <id>").alias("rm").description("Delete a pattern").action(async (id) => {
-  const { triagePatternsDeleteCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsDeleteCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsDeleteCommand(id);
 });
 triagePatternsCmd.command("test <id>").description("Test pattern against historical incidents").option("-l, --limit <number>", "Max incidents to test against", "100").option("--json", "Output as JSON").action(async (id, options) => {
-  const { triagePatternsTestCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsTestCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsTestCommand(id, options);
 });
 triagePatternsCmd.command("seed").description("Load built-in seed patterns").action(async () => {
-  const { triagePatternsSeedCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsSeedCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsSeedCommand();
 });
 triagePatternsCmd.action(async () => {
-  const { triagePatternsListCommand } = await import("./triage-POXJ2TIX.js");
+  const { triagePatternsListCommand } = await import("./triage-IZ4MDYNB.js");
   await triagePatternsListCommand({});
 });
 triageCmd.command("export <type>").description("Export patterns or full backup (type: patterns, backup)").option("-o, --output <path>", "Output file path").option("--include-private", "Include private patterns").action(async (type, options) => {
-  const { triageExportCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageExportCommand } = await import("./triage-IZ4MDYNB.js");
   await triageExportCommand(type, options);
 });
 triageCmd.command("import <file>").description("Import patterns from JSON file").option("--overwrite", "Overwrite existing patterns").action(async (file, options) => {
-  const { triageImportCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageImportCommand } = await import("./triage-IZ4MDYNB.js");
   await triageImportCommand(file, options);
 });
 triageCmd.command("restore <file>").description("Restore from full backup").action(async (file) => {
-  const { triageRestoreCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageRestoreCommand } = await import("./triage-IZ4MDYNB.js");
   await triageRestoreCommand(file);
 });
 triageCmd.command("stats").description("Show statistics dashboard").option("-p, --period <period>", "Time period: 1d, 7d, 30d, 90d", "7d").option("--symbol <symbol>", "Show health for specific symbol").option("--json", "Output as JSON").action(async (options) => {
-  const { triageStatsCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageStatsCommand } = await import("./triage-IZ4MDYNB.js");
   await triageStatsCommand(options);
 });
 triageCmd.command("record").description("Manually record an incident").requiredOption("--error <message>", "Error message").requiredOption("-e, --env <environment>", "Environment").option("--feature <symbol>", "Feature symbol (@...)").option("--component <symbol>", "Component symbol (#...)").option("--flow <symbol>", "Flow symbol ($...)").option("--gate <symbol>", "Gate symbol (^...)").option("--signal <symbol>", "Signal symbol (!...)").option("--state <symbol>", "State symbol (%...)").option("--integration <symbol>", "Integration symbol (&...)").option("--service <name>", "Service name").option("--version <version>", "App version").option("--stack <trace>", "Stack trace").option("--json", "Output as JSON").action(async (options) => {
-  const { triageRecordCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageRecordCommand } = await import("./triage-IZ4MDYNB.js");
   await triageRecordCommand(options);
 });
 triageCmd.option("-l, --limit <number>", "Maximum incidents to show", "10").option("-s, --status <status>", "Filter by status").option("--json", "Output as JSON").action(async (options) => {
-  const { triageListCommand } = await import("./triage-POXJ2TIX.js");
+  const { triageListCommand } = await import("./triage-IZ4MDYNB.js");
   await triageListCommand(options);
 });
 var loreCmd = program.command("lore").description("Project lore - timeline of everything that happened to this project");
@@ -710,7 +710,7 @@ loreCmd.option("-p, --port <port>", "Port to run on", "3840").option("--no-open"
   await loreServeCommand(void 0, options);
 });
 program.command("serve").description("Launch Paradigm Platform \u2014 unified development management UI").option("-p, --port <port>", "Port to run on", "3850").option("--no-open", "Don't open browser automatically").option("--sections <list>", "Comma-separated sections to enable (e.g., lore,graph,git)").action(async (options) => {
-  const { serveCommand } = await import("./serve-3V2WXLGM.js");
+  const { serveCommand } = await import("./serve-KKEHE44G.js");
   await serveCommand(options);
 });
 var graphCmd = program.command("graph").description("Interactive symbol relationship graph").argument("[path]", "Project directory", void 0).option("-p, --port <port>", "Port to run on", "3841").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
@@ -723,48 +723,48 @@ graphCmd.command("generate").description("Generate a named graph file in .paradi
 });
 var habitsCmd = program.command("habits").description("Behavioral habits - practice tracking and compliance");
 habitsCmd.command("list").alias("ls").description("List all configured habits").option("--trigger <trigger>", "Filter by trigger: preflight, postflight, on-stop, on-commit").option("--category <category>", "Filter by category: discovery, verification, testing, documentation, collaboration, security").option("--json", "Output as JSON").action(async (options) => {
-  const { habitsListCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsListCommand } = await import("./habits-RG5SVKXP.js");
   await habitsListCommand(options);
 });
 habitsCmd.command("status").description("Show practice profile with compliance rates").option("-p, --period <period>", "Time period: 7d, 30d, 90d, all", "30d").option("--json", "Output as JSON").action(async (options) => {
-  const { habitsStatusCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsStatusCommand } = await import("./habits-RG5SVKXP.js");
   await habitsStatusCommand(options);
 });
 habitsCmd.command("init").description("Initialize habits.yaml with seed habits").option("-f, --force", "Overwrite existing file").action(async (options) => {
-  const { habitsInitCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsInitCommand } = await import("./habits-RG5SVKXP.js");
   await habitsInitCommand(options);
 });
 habitsCmd.command("check").description("Evaluate habit compliance for a trigger point").requiredOption("-t, --trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--record", "Record practice events to Sentinel").option("--json", "Output as JSON").option("--files <files>", "Comma-separated files modified (default: git diff)").option("--symbols <symbols>", "Comma-separated symbols touched").action(async (options) => {
-  const { habitsCheckCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsCheckCommand } = await import("./habits-RG5SVKXP.js");
   await habitsCheckCommand(options);
 });
 habitsCmd.command("add").description("Add a custom habit").requiredOption("--id <id>", "Habit ID (kebab-case)").requiredOption("--name <name>", "Human-readable name").requiredOption("--description <desc>", "What this habit enforces").requiredOption("--category <category>", "Category: discovery, verification, testing, documentation, collaboration, security").requiredOption("--trigger <trigger>", "Trigger: preflight, postflight, on-stop, on-commit").option("--severity <severity>", "Severity: advisory, warn, block", "advisory").option("--tools <tools>", "Comma-separated tools to check (for tool-called check type)").option("--check-type <type>", "Check type: tool-called, file-exists, file-modified, lore-recorded, symbols-registered, gates-declared, tests-exist, git-clean", "tool-called").option("--patterns <patterns>", "Comma-separated patterns (for file-exists, file-modified, tests-exist check types)").action(async (options) => {
-  const { habitsAddCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsAddCommand } = await import("./habits-RG5SVKXP.js");
   await habitsAddCommand({ ...options, checkType: options.checkType });
 });
 habitsCmd.command("edit <id>").description("Edit a habit (seed habits: only severity/enabled; custom: all fields)").option("--name <name>", "New name").option("--description <desc>", "New description").option("--category <category>", "New category").option("--trigger <trigger>", "New trigger").option("--severity <severity>", "New severity: advisory, warn, block").option("--enabled <bool>", "Enable or disable: true, false").option("--check-type <type>", "New check type").option("--patterns <patterns>", "Comma-separated patterns").option("--tools <tools>", "Comma-separated tools").action(async (id, options) => {
-  const { habitsEditCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsEditCommand } = await import("./habits-RG5SVKXP.js");
   await habitsEditCommand(id, { ...options, checkType: options.checkType });
 });
 habitsCmd.command("remove <id>").description("Remove a custom habit (seed habits cannot be removed, only disabled)").option("-y, --yes", "Skip confirmation").action(async (id, options) => {
-  const { habitsRemoveCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsRemoveCommand } = await import("./habits-RG5SVKXP.js");
   await habitsRemoveCommand(id, options);
 });
 habitsCmd.command("enable <id>").description("Enable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsToggleCommand } = await import("./habits-RG5SVKXP.js");
   await habitsToggleCommand(id, "enable");
 });
 habitsCmd.command("disable <id>").description("Disable a habit").action(async (id) => {
-  const { habitsToggleCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsToggleCommand } = await import("./habits-RG5SVKXP.js");
   await habitsToggleCommand(id, "disable");
 });
 habitsCmd.action(async () => {
-  const { habitsListCommand } = await import("./habits-O37HTUKE.js");
+  const { habitsListCommand } = await import("./habits-RG5SVKXP.js");
   await habitsListCommand({});
 });
 var sentinelCmd = program.command("sentinel").description("Sentinel \u2014 semantic error monitoring");
 sentinelCmd.command("defend [path]", { isDefault: true }).description("Launch the Sentinel UI - unified codebase intelligence visualizer").option("-p, --port <port>", "Port to run on", "3838").option("--no-open", "Don't open browser automatically").action(async (path2, options) => {
-  const { sentinelCommand } = await import("./sentinel-BKYTBT7M.js");
+  const { sentinelCommand } = await import("./sentinel-UOIGJWHH.js");
   await sentinelCommand(path2, options);
 });
 program.command("conductor").description("Launch Paradigm Conductor \u2014 multimodal mission control for Claude Code sessions").option("--build", "Force rebuild the native binary").option("-v, --verbose", "Show build output").action(async (options) => {
@@ -835,71 +835,92 @@ pipelineCmd.action(async () => {
 });
 var symphonyCmd = program.command("symphony").description("Symphony \u2014 agent-to-agent messaging for multi-session collaboration");
 symphonyCmd.command("join").description("Join this session to the Symphony network").option("--remote <ip>", "Connect to remote Symphony server").action(async (options) => {
-  const { symphonyJoinCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyJoinCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyJoinCommand(options);
 });
 symphonyCmd.command("leave").description("Remove this session from the Symphony network").action(async () => {
-  const { symphonyLeaveCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyLeaveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyLeaveCommand();
 });
 symphonyCmd.command("whoami").description("Show this agent's identity and linked peers").action(async () => {
-  const { symphonyWhoamiCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyWhoamiCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyWhoamiCommand();
 });
 symphonyCmd.command("list").alias("ls").description("List all joined agents").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyListCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyListCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyListCommand(options);
 });
 symphonyCmd.command("send <message>").description("Send a note to agents").option("--to <agent>", "Send to specific agent (omit for broadcast)").option("--thread <id>", "Reply to existing thread").action(async (message, options) => {
-  const { symphonySendCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonySendCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonySendCommand(message, options);
 });
 symphonyCmd.command("read").description("Show unread notes").action(async () => {
-  const { symphonyReadCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyReadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyReadCommand();
 });
 symphonyCmd.command("inbox").description("Show unread notes (alias for read)").action(async () => {
-  const { symphonyReadCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyReadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyReadCommand();
 });
 symphonyCmd.command("threads").description("List all threads").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyThreadsCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyThreadsCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyThreadsCommand(options);
 });
 symphonyCmd.command("thread <id>").description("Show full thread conversation").action(async (id) => {
-  const { symphonyThreadCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyThreadCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyThreadCommand(id);
 });
 symphonyCmd.command("resolve <id>").description("Mark a thread as resolved").option("--decision <text>", "Decision text to record").action(async (id, options) => {
-  const { symphonyResolveCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyResolveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyResolveCommand(id, options);
 });
 symphonyCmd.command("status").description("Show Symphony network status").option("--json", "Output as JSON").action(async (options) => {
-  const { symphonyStatusCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyStatusCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyStatusCommand(options);
 });
-symphonyCmd.command("serve").description("Start TCP server for remote Symphony linking").option("--port <port>", "Port to listen on", "3939").action(async (options) => {
-  const { symphonyServeCommand } = await import("./symphony-ROEKK7VD.js");
+symphonyCmd.command("serve").description("Start Symphony relay server for cross-machine networking").option("--port <port>", "Port to listen on", "3939").option("--public", "Show connection string for internet access").action(async (options) => {
+  const { symphonyServeCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyServeCommand(options);
 });
+var peersCmd = symphonyCmd.command("peers").description("Manage trusted remote peers");
+peersCmd.command("list", { isDefault: true }).description("List trusted peers and their agents").option("--json", "Output as JSON").action(async (options) => {
+  const { symphonyPeersCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersCommand(options);
+});
+peersCmd.command("revoke <id>").description("Revoke trust for a peer (disconnects immediately)").action(async (id) => {
+  const { symphonyPeersRevokeCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersRevokeCommand(id);
+});
+peersCmd.command("forget").description("Clear all peer trust records").option("--force", "Skip confirmation").action(async (options) => {
+  const { symphonyPeersForgetCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersForgetCommand(options);
+});
+peersCmd.action(async () => {
+  const { symphonyPeersCommand } = await import("./peers-RFQCWVLV.js");
+  await symphonyPeersCommand({});
+});
 symphonyCmd.command("request <file>").description("Request a file from another agent").option("--from <agent>", "Agent to request from").option("--reason <text>", "Why this file is needed").action(async (file, options) => {
-  const { symphonyRequestCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyRequestCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyRequestCommand(file, options);
 });
 symphonyCmd.command("requests").description("List pending file requests").action(async () => {
-  const { symphonyRequestsCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyRequestsCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyRequestsCommand();
 });
 symphonyCmd.command("approve <id>").description("Approve a file request").option("--redact", "Strip sensitive lines before sending").action(async (id, options) => {
-  const { symphonyApproveCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyApproveCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyApproveCommand(id, options);
 });
 symphonyCmd.command("deny <id>").description("Deny a file request").option("--reason <text>", "Reason for denial").action(async (id, options) => {
-  const { symphonyDenyCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyDenyCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyDenyCommand(id, options);
 });
+symphonyCmd.command("watch").description("Watch inbox in real-time \u2014 zero AI tokens, pure file monitoring").option("--interval <ms>", "Poll interval in milliseconds (default: 2000)").option("--thread <id>", "Only show messages from this thread").option("--quiet", "Minimal output \u2014 messages only, no header").action(async (options) => {
+  const { symphonyWatchCommand } = await import("./symphony-6K3HD7AW.js");
+  await symphonyWatchCommand(options);
+});
 symphonyCmd.action(async () => {
-  const { symphonyStatusCommand } = await import("./symphony-ROEKK7VD.js");
+  const { symphonyStatusCommand } = await import("./symphony-6K3HD7AW.js");
   await symphonyStatusCommand({});
 });
 program.parse();

package/dist/mcp.js

@@ -14,7 +14,7 @@ import {
   StatsCalculator,
   TimelineBuilder,
   loadAllSeedPatterns
-} from "./chunk-RGFANZ4Q.js";
+} from "./chunk-ZDHLG5VP.js";
 import {
   addStep,
   addToolBreadcrumb,
@@ -90,7 +90,7 @@ import {
   validateProtocol,
   validatePurposeFile,
   validateUniversityContent
-} from "./chunk-CZEIK3Y2.js";
+} from "./chunk-ZMQA6SCO.js";
 import {
   addLoreAssessment,
   deleteLoreEntry,
@@ -12098,7 +12098,7 @@ var PERSONA_SCHEMA = {
 var sentinelSchemaRegistered = false;
 async function emitPersonaEvents(result) {
   try {
-    const { SentinelStorage: SentinelStorage2 } = await import("./dist-RVKYUCRU.js");
+    const { SentinelStorage: SentinelStorage2 } = await import("./dist-CM3MVWWW.js");
     const storage2 = new SentinelStorage2();
     if (!sentinelSchemaRegistered) {
       try {
@@ -14557,12 +14557,15 @@ function getMyIdentity(projectDir2) {
     return null;
   }
 }
-function markAgentPollTime(agentId) {
+function markAgentPollTime(agentId, statusBlurb) {
   const identityPath = path28.join(getAgentDir(agentId), "identity.json");
   if (!fs26.existsSync(identityPath)) return;
   try {
     const identity = JSON.parse(fs26.readFileSync(identityPath, "utf-8"));
     identity.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    if (statusBlurb !== void 0) {
+      identity.statusBlurb = statusBlurb || void 0;
+    }
     fs26.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
   } catch {
   }
@@ -14581,6 +14584,35 @@ function outboxPath(agentId) {
 function ackPath(agentId) {
   return path28.join(getAgentDir(agentId), "ack.json");
 }
+function peekInbox(agentId) {
+  const filePath = inboxPath(agentId);
+  if (!fs26.existsSync(filePath)) return { hasNew: false, inboxSize: 0 };
+  const stat = fs26.statSync(filePath);
+  const inboxSize = stat.size;
+  const ack = readAck(agentId);
+  if (!ack) {
+    return { hasNew: inboxSize > 0, inboxSize };
+  }
+  const ackSizePath = path28.join(getAgentDir(agentId), "ack-size.json");
+  if (fs26.existsSync(ackSizePath)) {
+    try {
+      const ackSize = JSON.parse(fs26.readFileSync(ackSizePath, "utf-8"));
+      return { hasNew: inboxSize > (ackSize.size || 0), inboxSize };
+    } catch {
+    }
+  }
+  return { hasNew: inboxSize > 0, inboxSize };
+}
+function recordAckSize(agentId) {
+  const filePath = inboxPath(agentId);
+  const ackSizePath = path28.join(getAgentDir(agentId), "ack-size.json");
+  try {
+    const size = fs26.existsSync(filePath) ? fs26.statSync(filePath).size : 0;
+    ensureAgentDir(agentId);
+    fs26.writeFileSync(ackSizePath, JSON.stringify({ size }), "utf-8");
+  } catch {
+  }
+}
 function appendToInbox(agentId, message) {
   ensureAgentDir(agentId);
   appendJsonlLine(inboxPath(agentId), message);
@@ -14939,12 +14971,34 @@ function isProcessAlive2(pid) {
 // ../paradigm-mcp/src/tools/symphony.ts
 function getSymphonyToolsList() {
   return [
+    {
+      name: "paradigm_symphony_peek",
+      description: "Ultra-cheap inbox check \u2014 file stat only, no parsing. Returns { hasNew: true/false }. Use with /loop 10s for near-free monitoring. When hasNew is true, call paradigm_symphony_poll to read messages. ~15 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            description: "Short status blurb (same as poll). Updates heartbeat."
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
     {
       name: "paradigm_symphony_poll",
-      description: "Poll inbox for new notes. Call via /loop for continuous agent messaging. Returns unread notes formatted as markdown with thread context and suggested actions. Updates heartbeat. ~200 tokens.",
+      description: "Read inbox notes and process them. Call when paradigm_symphony_peek returns hasNew: true, or directly via /loop for continuous messaging. Returns unread notes formatted as markdown with thread context and suggested actions. Updates heartbeat and optional status blurb. ~200 tokens.",
       inputSchema: {
         type: "object",
-        properties: {}
+        properties: {
+          status: {
+            type: "string",
+            description: 'Short status blurb describing what you are currently working on (e.g., "Implementing auth middleware \u2014 3 files modified"). Visible to humans and other agents in the Network view.'
+          }
+        }
       },
       annotations: {
         readOnlyHint: false,
@@ -15113,14 +15167,26 @@ async function handleSymphonyTool(name, args, ctx) {
     identity = registerAgent(ctx.rootDir);
   }
   switch (name) {
+    case "paradigm_symphony_peek": {
+      const peekStatus = args.status;
+      markAgentPollTime(identity.id, peekStatus);
+      const { hasNew } = peekInbox(identity.id);
+      const pendingRequests = hasNew ? listFileRequests("pending").length : 0;
+      return {
+        handled: true,
+        text: JSON.stringify(hasNew ? { hasNew: true, pendingFileRequests: pendingRequests, action: "call paradigm_symphony_poll to read" } : { hasNew: false })
+      };
+    }
     case "paradigm_symphony_poll": {
       cleanStaleAgents();
       expireOldRequests();
-      markAgentPollTime(identity.id);
+      const statusBlurb = args.status;
+      markAgentPollTime(identity.id, statusBlurb);
       const messages = readInbox(identity.id);
       if (messages.length > 0) {
         const lastId = messages[messages.length - 1].id;
         acknowledgeMessages(identity.id, lastId);
+        recordAckSize(identity.id);
       }
       garbageCollect(identity.id);
       const pendingRequests = listFileRequests("pending");
@@ -15227,6 +15293,18 @@ async function handleSymphonyTool(name, args, ctx) {
       const threads = listThreads("active");
       const unread = readInbox(identity.id);
       const pendingRequests = listFileRequests("pending");
+      let peers = [];
+      try {
+        const { loadPeers } = await import("./symphony-peers-APOGJPF4.js");
+        const allPeers = loadPeers();
+        peers = allPeers.filter((p) => !p.revoked).map((p) => ({
+          id: p.id,
+          address: p.address,
+          agents: p.agents?.length ?? 0,
+          lastSeen: p.lastSeen
+        }));
+      } catch {
+      }
       return {
         handled: true,
         text: JSON.stringify({
@@ -15241,8 +15319,10 @@ async function handleSymphonyTool(name, args, ctx) {
             project: a.project,
             role: a.role,
             status: isAgentAsleep(a) ? "asleep" : "awake",
-            lastPoll: a.lastPoll
+            lastPoll: a.lastPoll,
+            statusBlurb: a.statusBlurb
           })),
+          peers,
           activeThreads: threads.map((t) => ({
             id: t.id,
             topic: t.topic,
@@ -17440,7 +17520,7 @@ Update command:
               trackToolCall(noWsText.length, name);
               return { content: [{ type: "text", text: noWsText }] };
             }
-            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-NZQRGKPN.js");
+            const { rebuildStaticFiles: rebuildStaticFiles2 } = await import("./reindex-WIJMCJ4A.js");
             const memberResults = [];
             for (const member of ctx.workspace.config.members) {
               const memberAbsPath = path31.resolve(path31.dirname(ctx.workspace.workspacePath), member.path);

package/dist/peers-RFQCWVLV.js

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