taskplane 0.22.17 → 0.23.0

package/dashboard/server.cjs

@@ -352,6 +352,167 @@ function tailJsonlFile(filePath) {
  * @param {object|null} batchState - The batch state from batch-state.json
  * @returns {object} Map of tmuxPrefix → accumulated telemetry
  */
+
+// ── Runtime V2 Data Loaders (TP-107) ─────────────────────────────
+
+/**
+ * Load the Runtime V2 process registry for the current batch.
+ * Returns null if no registry exists (legacy batch).
+ */
+function loadRuntimeRegistry(batchId) {
+  if (!batchId) return null;
+  const registryPath = path.join(REPO_ROOT, ".pi", "runtime", batchId, "registry.json");
+  try {
+    if (!fs.existsSync(registryPath)) return null;
+    return JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load Runtime V2 lane snapshots for the current batch.
+ * Returns a map of laneNumber → snapshot data.
+ */
+function loadRuntimeLaneSnapshots(batchId) {
+  if (!batchId) return {};
+  const lanesDir = path.join(REPO_ROOT, ".pi", "runtime", batchId, "lanes");
+  const snapshots = {};
+  try {
+    if (!fs.existsSync(lanesDir)) return snapshots;
+    const files = fs.readdirSync(lanesDir).filter(f => f.startsWith("lane-") && f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(lanesDir, file), "utf-8"));
+        if (data.laneNumber != null) snapshots[data.laneNumber] = data;
+      } catch { continue; }
+    }
+  } catch { /* dir missing */ }
+  return snapshots;
+}
+
+/**
+ * Load Runtime V2 agent events for a specific agent.
+ * Returns the last N events from the agent's events.jsonl.
+ */
+function loadRuntimeAgentEvents(batchId, agentId, maxEvents) {
+  if (!batchId || !agentId) return [];
+  maxEvents = maxEvents || 200;
+  const eventsPath = path.join(REPO_ROOT, ".pi", "runtime", batchId, "agents", agentId, "events.jsonl");
+  try {
+    if (!fs.existsSync(eventsPath)) return [];
+    const raw = fs.readFileSync(eventsPath, "utf-8");
+    const lines = raw.split("\n").filter(l => l.trim());
+    const events = [];
+    const start = Math.max(0, lines.length - maxEvents);
+    for (let i = start; i < lines.length; i++) {
+      try { events.push(JSON.parse(lines[i])); } catch { continue; }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load mailbox message activity for the current batch.
+ *
+ * TP-093 hardening: event-authoritative model.
+ * Primary source: .pi/mailbox/{batchId}/events.jsonl (audit event stream).
+ * Fallback: directory scans (inbox/ack/outbox/outbox/processed) for
+ * compatibility when events.jsonl is absent.
+ *
+ * Includes:
+ * - Consumed replies (outbox/processed/) so they don't disappear after ack
+ * - Per-recipient broadcast delivery state from ack markers
+ * - Rate-limited events in the timeline
+ */
+function loadMailboxData(batchId) {
+  if (!batchId) return { messages: [], agentIds: [], auditEvents: [] };
+  const mbRoot = path.join(REPO_ROOT, ".pi", "mailbox", batchId);
+  if (!fs.existsSync(mbRoot)) return { messages: [], agentIds: [], auditEvents: [] };
+
+  // ── Primary: events.jsonl audit trail ──
+  const auditEvents = loadMailboxAuditEvents(mbRoot);
+
+  // ── Fallback: directory scan ──
+  const messages = [];
+  const agentIds = [];
+
+  try {
+    const dirs = fs.readdirSync(mbRoot, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+
+    for (const agentDir of dirs) {
+      if (agentDir === "_broadcast") continue;
+      agentIds.push(agentDir);
+
+      // Scan inbox (pending), ack (delivered), outbox (active replies), outbox/processed (consumed replies)
+      for (const subdir of ["inbox", "ack", "outbox", "outbox/processed"]) {
+        const dir = path.join(mbRoot, agentDir, subdir);
+        if (!fs.existsSync(dir)) continue;
+        try {
+          const files = fs.readdirSync(dir).filter(f => f.endsWith(".msg.json"));
+          for (const file of files) {
+            try {
+              const msg = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+              let status;
+              if (subdir === "inbox") status = "pending";
+              else if (subdir === "ack") status = "delivered";
+              else if (subdir === "outbox") status = "reply";
+              else status = "reply-acked"; // outbox/processed
+              const isBroadcast = msg.to === "_broadcast";
+              messages.push({ ...msg, _status: status, _agentDir: agentDir, _isBroadcast: isBroadcast });
+            } catch { continue; }
+          }
+        } catch { continue; }
+      }
+    }
+
+    // _broadcast: per-recipient delivery state
+    const broadcastInbox = path.join(mbRoot, "_broadcast", "inbox");
+    const broadcastAck = path.join(mbRoot, "_broadcast", "ack");
+    for (const [dir, status] of [[broadcastInbox, "pending"], [broadcastAck, "delivered"]]) {
+      if (!fs.existsSync(dir)) continue;
+      try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith(".msg.json"));
+        for (const file of files) {
+          try {
+            const msg = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+            messages.push({ ...msg, _status: status, _agentDir: "_broadcast", _isBroadcast: true });
+          } catch { continue; }
+        }
+      } catch { continue; }
+    }
+  } catch { /* mailbox dir issues */ }
+
+  messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+  return { messages, agentIds, auditEvents };
+}
+
+/**
+ * Load mailbox audit events from events.jsonl.
+ * Returns events sorted by timestamp. Includes: message_sent, message_delivered,
+ * message_replied, message_escalated, message_rate_limited.
+ */
+function loadMailboxAuditEvents(mbRoot) {
+  const eventsPath = path.join(mbRoot, "events.jsonl");
+  if (!fs.existsSync(eventsPath)) return [];
+  try {
+    const raw = fs.readFileSync(eventsPath, "utf-8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try { events.push(JSON.parse(line)); } catch { continue; }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────
 function loadTelemetryData(batchState) {
   const telemetryDir = path.join(REPO_ROOT, ".pi", "telemetry");
   const result = {};
@@ -849,11 +1010,20 @@ function buildDashboardState() {
     return { ...task, statusData };
   });
 
+  // TP-107: Load Runtime V2 data when available
+  const runtimeRegistry = loadRuntimeRegistry(state.batchId);
+  const runtimeLaneSnapshots = loadRuntimeLaneSnapshots(state.batchId);
+  const mailboxData = loadMailboxData(state.batchId);
+
   return {
     laneStates,
     telemetry,
     batchTotalCost,
     supervisor,
+    // Runtime V2 data (null/empty for legacy batches)
+    runtimeRegistry,
+    runtimeLaneSnapshots,
+    mailbox: mailboxData,
     batch: {
       batchId: state.batchId,
       phase: state.phase,
@@ -1220,6 +1390,35 @@ function createServer() {
     } else if (pathname.startsWith("/api/conversation/") && req.method === "GET") {
       const prefix = pathname.slice("/api/conversation/".length);
       serveConversation(req, res, prefix);
+    } else if (pathname.startsWith("/api/agent-events/") && req.method === "GET") {
+      // TP-107: Serve Runtime V2 agent events (hardened)
+      const agentId = decodeURIComponent(pathname.slice("/api/agent-events/".length));
+      // Strict validation: same pattern as /api/conversation/:prefix
+      if (!/^[\w-]+$/.test(agentId)) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Invalid agent ID");
+        return;
+      }
+      const batchState = loadBatchState();
+      // Path containment: verify resolved path stays inside runtime dir
+      if (batchState?.batchId) {
+        const runtimeBase = path.join(REPO_ROOT, ".pi", "runtime", batchState.batchId, "agents");
+        const resolvedAgent = path.resolve(runtimeBase, agentId);
+        if (!resolvedAgent.startsWith(path.resolve(runtimeBase))) {
+          res.writeHead(403, { "Content-Type": "text/plain" });
+          res.end("Forbidden");
+          return;
+        }
+      }
+      // Optional: ?sinceTs= to return only events after a timestamp
+      const reqUrl = new URL(req.url, "http://localhost");
+      const sinceTs = parseInt(reqUrl.searchParams.get("sinceTs") || "0", 10);
+      let events = loadRuntimeAgentEvents(batchState?.batchId, agentId, 300);
+      if (sinceTs > 0) {
+        events = events.filter(e => (e.ts || 0) > sinceTs);
+      }
+      res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify(events));
     } else if (pathname === "/api/state" && req.method === "GET") {
       const state = buildDashboardState();
       res.writeHead(200, {