sentinelayer-cli 0.4.5 → 0.8.0

package/src/agents/jules/loop.js

@@ -5,6 +5,7 @@ import { dispatchTool, createAgentContext, BudgetExhaustedError } from "./tools/
 import { JULES_DEFINITION } from "./config/definition.js";
 import { shouldSpawnSubAgents, runJulesSwarm } from "./swarm/orchestrator.js";
 import { frontendAnalyze } from "./tools/frontend-analyze.js";
+import { createAgentEvent } from "../../events/schema.js";
 
 /**
  * Jules Tanaka — Agentic Loop
@@ -66,10 +67,14 @@ export async function* julesAuditLoop(config) {
   });
 
   const emit = (event, payload) => {
-    const evt = {
-      stream: "sl_event",
+    const evt = createAgentEvent({
       event,
-      agent: { id: JULES_DEFINITION.id, persona: JULES_DEFINITION.persona, color: JULES_DEFINITION.color, avatar: JULES_DEFINITION.avatar },
+      agent: {
+        id: JULES_DEFINITION.id,
+        persona: JULES_DEFINITION.persona,
+        color: JULES_DEFINITION.color,
+        avatar: JULES_DEFINITION.avatar,
+      },
       payload,
       usage: {
         costUsd: ctx.usage.costUsd,
@@ -77,7 +82,9 @@ export async function* julesAuditLoop(config) {
         toolCalls: ctx.usage.toolCalls,
         durationMs: Date.now() - startedAt,
       },
-    };
+      runId,
+      sessionId: ctx.sessionId,
+    });
     if (onEvent) onEvent(evt);
     return evt;
   };
@@ -128,30 +135,16 @@ export async function* julesAuditLoop(config) {
 
   yield emit("progress", { phase: "deep_analysis", message: "Starting deep analysis..." });
 
-  // Build context for LLM
+  // Build context for LLM — BLIND-FIRST: no Omar baseline or swarm findings
+  // in the initial context. Only codebase metadata and memory recall (past runs,
+  // not current-run findings). Swarm/baseline reconciliation happens AFTER the
+  // independent deep analysis completes.
   const contextParts = [];
   contextParts.push(`Framework: ${framework.framework || "unknown"}`);
   contextParts.push(`Mode: ${mode}`);
   contextParts.push(`Components: ${framework.componentCount || "unknown"}`);
   contextParts.push(`Scope: ${(scopeMap.primary || []).length} primary files`);
 
-  if (swarmFindings.length > 0) {
-    contextParts.push(`\nSub-agent findings (${swarmFindings.length} total):`);
-    for (const f of swarmFindings.slice(0, 30)) {
-      contextParts.push(`- [${f.severity || "P3"}] ${f.file || ""}:${f.line || ""} ${f.title || f.type || ""}`);
-    }
-  }
-
-  if (omarBaseline) {
-    const baselineFindings = omarBaseline.findings || omarBaseline.summary || [];
-    if (Array.isArray(baselineFindings) && baselineFindings.length > 0) {
-      contextParts.push(`\nOmar baseline findings (${baselineFindings.length}):`);
-      for (const f of baselineFindings.slice(0, 20)) {
-        contextParts.push(`- [${f.severity || ""}] ${f.file || ""}:${f.line || ""} ${f.message || f.title || ""}`);
-      }
-    }
-  }
-
   if (memory) {
     try {
       const recalled = memory.query ? memory.query({
@@ -170,7 +163,7 @@ export async function* julesAuditLoop(config) {
   const messages = [
     { role: "user", content: contextParts.join("\n") +
       "\n\nPerform your deep analysis now. Use FileRead, Grep, Glob, and FrontendAnalyze tools as needed. " +
-      "Return your findings in a ```json code block as an array of { severity, file, line, title, evidence, rootCause, recommendedFix, trafficLight }." },
+      "Return your findings in a ```json code block as an array of { severity, file, line, title, evidence, rootCause, recommendedFix, trafficLight, reproduction, user_impact, confidence }." },
   ];
 
   const allFindings = [...swarmFindings];
@@ -217,12 +210,12 @@ export async function* julesAuditLoop(config) {
       });
     }
 
-    // Call LLM
+    // Call LLM — format system prompt + messages into a single prompt
+    // for the MultiProviderApiClient which uses a completions-style API
     let response;
     try {
       response = await client.invoke({
-        systemPrompt,
-        messages,
+        prompt: formatPromptForClient(systemPrompt, messages),
       });
     } catch (err) {
       yield emit("llm_error", { error: err.message, turn: turnCount });
@@ -290,6 +283,89 @@ export async function* julesAuditLoop(config) {
     });
   }
 
+  // ── Phase 2b: Reconciliation (post-blind-pass) ─────────────────────
+  // Now that the independent analysis is complete, cross-reference with
+  // swarm findings and Omar baseline. This preserves blind-first: the
+  // persona formed its own opinion before seeing prior conclusions.
+
+  const hasSwarmContext = swarmFindings.length > 0;
+  const baselineFindings = omarBaseline
+    ? (omarBaseline.findings || omarBaseline.summary || [])
+    : [];
+  const hasBaselineContext = Array.isArray(baselineFindings) && baselineFindings.length > 0;
+
+  if (hasSwarmContext || hasBaselineContext) {
+    yield emit("progress", { phase: "reconciliation", message: "Cross-referencing with sub-agent and baseline findings..." });
+
+    const reconcileParts = [];
+    reconcileParts.push("Your independent analysis is complete. Now cross-reference with the following prior findings.");
+    reconcileParts.push("For each prior finding: confirm if your analysis agrees, dispute with evidence if you disagree, or flag as missed if you did not cover it.");
+
+    if (hasSwarmContext) {
+      reconcileParts.push(`\nYour sub-agents found ${swarmFindings.length} findings:`);
+      for (const f of swarmFindings.slice(0, 30)) {
+        reconcileParts.push(`- [${f.severity || "P3"}] ${f.file || ""}:${f.line || ""} ${f.title || f.type || ""}`);
+      }
+    }
+
+    if (hasBaselineContext) {
+      reconcileParts.push(`\nOmar baseline reported ${baselineFindings.length} findings:`);
+      for (const f of baselineFindings.slice(0, 20)) {
+        reconcileParts.push(`- [${f.severity || ""}] ${f.file || ""}:${f.line || ""} ${f.message || f.title || ""}`);
+      }
+    }
+
+    reconcileParts.push("\nReturn any additional or revised findings as a JSON array in a ```json code block. If no changes, return an empty array [].");
+
+    messages.push({ role: "user", content: reconcileParts.join("\n") });
+
+    // Budget check before reconciliation turn
+    const reconcilePreCheck = evaluateBudget({
+      sessionSummary: {
+        costUsd: ctx.usage.costUsd,
+        outputTokens: ctx.usage.outputTokens,
+        durationMs: Date.now() - startedAt,
+        toolCalls: ctx.usage.toolCalls,
+      },
+      ...budget,
+    });
+
+    if (!reconcilePreCheck.blocking) {
+      try {
+        const reconcileResponse = await client.invoke({
+          prompt: formatPromptForClient(systemPrompt, messages),
+        });
+
+        const reconcileText = reconcileResponse.text || "";
+        ctx.usage.outputTokens += Math.ceil(reconcileText.length / 4);
+        ctx.usage.costUsd += (Math.ceil(reconcileText.length / 4) / 1_000_000) * 15;
+
+        yield emit("reasoning", { phase: "reconciliation", summary: reconcileText.slice(0, 200) });
+
+        const reconcileFindings = extractJsonFindings(reconcileText);
+        for (const finding of reconcileFindings) {
+          allFindings.push(finding);
+          yield emit("finding", { ...finding, source: "reconciliation" });
+          if (blackboard) {
+            try {
+              await blackboard.appendEntry({
+                agentId: JULES_DEFINITION.id,
+                source: "jules-reconciliation",
+                ...finding,
+              });
+            } catch { /* blackboard write failure non-blocking */ }
+          }
+        }
+
+        messages.push({ role: "assistant", content: reconcileText });
+      } catch (err) {
+        yield emit("llm_error", { error: err.message, phase: "reconciliation" });
+      }
+    } else {
+      yield emit("budget_stop", { reasons: reconcilePreCheck.reasons, phase: "reconciliation" });
+    }
+  }
+
   // ── Phase 3: Build final report ───────────────────────────────────
 
   const durationMs = Date.now() - startedAt;
@@ -365,3 +441,17 @@ function sanitizeForEvent(input) {
   }
   return sanitized;
 }
+
+/**
+ * Format system prompt + chat messages into a single prompt string
+ * for MultiProviderApiClient which uses a completions-style API.
+ */
+function formatPromptForClient(systemPrompt, messages) {
+  const parts = [];
+  if (systemPrompt) parts.push(systemPrompt);
+  for (const msg of messages) {
+    const role = msg.role === "assistant" ? "ASSISTANT" : "USER";
+    parts.push(`\n${role}:\n${msg.content}`);
+  }
+  return parts.join("\n");
+}

package/src/agents/jules/pulse.js

@@ -1,327 +1,10 @@
-import { PERSONA_VISUALS } from "./config/definition.js";
-
-/**
- * Pulse — SentinelLayer Internal Daemon Monitor
- *
- * Monitors running agent health, routes errors to the right persona,
- * detects stuck/idle agents, and sends alerts on state changes.
- * NOT called Kairos — Pulse monitors the heartbeat of all agents.
- */
-
-// ── Stuck Detection ──────────────────────────────────────────────────
-
-const STUCK_THRESHOLDS = Object.freeze({
-  noToolCallSeconds: 90,
-  noProgressTurns: 5,
-  sameFileReadCount: 3,
-  budgetConsumedNoOutput: 0.5,
-  maxIdleBeforeEscalate: 300,
-  maxIdleBeforeKill: 600,
-});
-
-/**
- * Detect if an agent is stuck based on its current state.
- *
- * @param {object} agentState
- * @param {number} agentState.lastToolCallAt - Epoch ms
- * @param {number} agentState.lastTurnProgressAt - Epoch ms
- * @param {number} agentState.sameFileReadCount - Consecutive reads of same file
- * @param {string} [agentState.lastFileRead] - Path of last file read
- * @param {number} agentState.budgetConsumedPct - 0-100
- * @param {number} agentState.findingCount
- * @param {number} [agentState.turnsSinceLastProgress]
- * @returns {{ stuck: boolean, reason?: string, idleSeconds?: number, file?: string, budgetPct?: number }}
- */
-export function detectStuckState(agentState) {
-  const now = Date.now();
-
-  // No tool calls for threshold period
-  if (agentState.lastToolCallAt) {
-    const idleMs = now - agentState.lastToolCallAt;
-    if (idleMs > STUCK_THRESHOLDS.noToolCallSeconds * 1000) {
-      return { stuck: true, reason: "no_tool_calls", idleSeconds: Math.floor(idleMs / 1000) };
-    }
-  }
-
-  // Same file read repeatedly (loop detection)
-  if (agentState.sameFileReadCount >= STUCK_THRESHOLDS.sameFileReadCount) {
-    return { stuck: true, reason: "loop_detected", file: agentState.lastFileRead };
-  }
-
-  // High budget consumption with no findings
-  if (
-    agentState.budgetConsumedPct > STUCK_THRESHOLDS.budgetConsumedNoOutput * 100 &&
-    agentState.findingCount === 0
-  ) {
-    return { stuck: true, reason: "inefficient", budgetPct: agentState.budgetConsumedPct };
-  }
-
-  // No turn progress
-  if (agentState.turnsSinceLastProgress >= STUCK_THRESHOLDS.noProgressTurns) {
-    return { stuck: true, reason: "no_progress", turns: agentState.turnsSinceLastProgress };
-  }
-
-  return { stuck: false };
-}
-
-/**
- * Determine recovery action based on idle duration.
- *
- * @param {number} idleSeconds
- * @returns {"hint" | "escalate" | "kill"}
- */
-export function determineRecoveryAction(idleSeconds) {
-  if (idleSeconds >= STUCK_THRESHOLDS.maxIdleBeforeKill) return "kill";
-  if (idleSeconds >= STUCK_THRESHOLDS.maxIdleBeforeEscalate) return "escalate";
-  return "hint";
-}
-
-// ── Error-to-Persona Routing ─────────────────────────────────────────
-
-const ROUTING_RULES = [
-  // Stack trace patterns (most reliable)
-  { test: (w) => /\.(tsx|jsx|vue|svelte):\d+/.test(w.stackTrace || ""), persona: "frontend" },
-  { test: (w) => /React|Next|Vite|Webpack|hydrat/i.test(w.stackTrace || ""), persona: "frontend" },
-  { test: (w) => /\.py:\d+/.test(w.stackTrace || ""), persona: "backend" },
-  { test: (w) => /\.go:\d+/.test(w.stackTrace || ""), persona: "backend" },
-
-  // Endpoint patterns
-  { test: (w) => /\.(html|css|js|png|svg|woff)$/.test(w.endpoint || ""), persona: "frontend" },
-  { test: (w) => /\/api\/v\d+\/auth/.test(w.endpoint || ""), persona: "security" },
-  { test: (w) => /\/api\//.test(w.endpoint || ""), persona: "backend" },
-
-  // Error code patterns
-  { test: (w) => /HYDRATION|RENDER|DOM|CSR|SSR/i.test(w.errorCode || ""), persona: "frontend" },
-  { test: (w) => /AUTH|TOKEN|SESSION|PERMISSION/i.test(w.errorCode || ""), persona: "security" },
-  { test: (w) => /TIMEOUT|ECONNREFUSED|DNS|SOCKET/i.test(w.errorCode || ""), persona: "infrastructure" },
-  { test: (w) => /QUERY|MIGRATION|CONSTRAINT|DEADLOCK/i.test(w.errorCode || ""), persona: "data" },
-];
-
-/**
- * Route an error work item to the appropriate persona.
- *
- * @param {object} workItem - Error queue item
- * @returns {string} Persona ID (e.g., "frontend", "backend", "security")
- */
-export function routeErrorToPersona(workItem) {
-  for (const rule of ROUTING_RULES) {
-    if (rule.test(workItem)) return rule.persona;
-  }
-  return "backend"; // default fallback
-}
-
-// ── Alert Building ───────────────────────────────────────────────────
-
-/**
- * Build a concise alert payload for Slack/Telegram.
- *
- * @param {object} config
- * @param {string} config.agentId - Persona ID
- * @param {string} config.event - Alert event type
- * @param {object} config.state - Agent state snapshot
- * @param {string} [config.workItemId]
- * @param {string} [config.jiraIssueKey]
- * @returns {{ headline, body, severity }}
- */
-export function buildAlertPayload({ agentId, event, state, workItemId, jiraIssueKey }) {
-  const visual = PERSONA_VISUALS[agentId] || { avatar: "", fullName: agentId, color: "white" };
-  const avatar = visual.avatar;
-  const name = visual.fullName;
-
-  const lines = [];
-  lines.push(`${avatar} ${name} \u2014 ${formatAlertEvent(event)}`);
-  lines.push("\u2501".repeat(30));
-
-  if (workItemId) lines.push(`Work Item: ${workItemId}`);
-  if (jiraIssueKey) lines.push(`Jira: ${jiraIssueKey}`);
-
-  if (state) {
-    if (state.durationMs) lines.push(`Duration: ${formatDuration(state.durationMs)}`);
-    if (state.budgetPct !== undefined) lines.push(`Budget: ${state.budgetPct.toFixed(0)}%`);
-    if (state.turnsCompleted !== undefined) lines.push(`Turns: ${state.turnsCompleted}/${state.turnsMax || "?"}`);
-    if (state.findingCount !== undefined) lines.push(`Findings: ${state.findingCount}`);
-    if (state.lastAction) lines.push(`Last: ${state.lastAction}`);
-    if (state.costUsd !== undefined) lines.push(`Cost: $${state.costUsd.toFixed(2)}`);
-    if (state.prNumber) lines.push(`PR: #${state.prNumber}`);
-  }
-
-  const severity = event.includes("stuck") || event.includes("kill") ? "warning" :
-    event.includes("merged") || event.includes("complete") ? "success" : "info";
-
-  lines.push("");
-  lines.push(`\u2014 ${name}, SentinelLayer`);
-
-  return {
-    headline: `${avatar} ${name}: ${formatAlertEvent(event)}`,
-    body: lines.join("\n"),
-    severity,
-  };
-}
-
-function formatAlertEvent(event) {
-  const map = {
-    agent_stuck: "Agent Stuck",
-    agent_recovered: "Agent Recovered",
-    budget_warning: "Budget Warning",
-    budget_exhausted: "Budget Exhausted",
-    pr_merged: "PR Merged",
-    audit_complete: "Audit Complete",
-    fix_complete: "Fix Complete",
-    kill_switch: "Kill Switch Activated",
-    error_intake: "Error Received",
-    jira_resolved: "Jira Resolved",
-  };
-  return map[event] || event;
-}
-
-function formatDuration(ms) {
-  if (ms < 60000) return `${(ms / 1000).toFixed(0)}s`;
-  if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
-  return `${(ms / 3600000).toFixed(1)}h`;
-}
-
-// ── Health Summary ───────────────────────────────────────────────────
-
-/**
- * Build a periodic health summary for Slack/Telegram.
- *
- * @param {object[]} agentStates - Current states of all running agents
- * @returns {{ headline, body } | null} null if nothing to report
- */
-export function buildHealthSummary(agentStates) {
-  if (!agentStates || agentStates.length === 0) return null;
-
-  const active = agentStates.filter(a => a.status === "active");
-  const stuck = agentStates.filter(a => a.stuck);
-  const completed = agentStates.filter(a => a.status === "completed");
-
-  if (active.length === 0 && stuck.length === 0 && completed.length === 0) return null;
-
-  const lines = [];
-  lines.push("\u{1F4CA} Pulse Health Summary");
-  lines.push("\u2501".repeat(30));
-  lines.push(`Active: ${active.length} | Stuck: ${stuck.length} | Completed: ${completed.length}`);
-
-  for (const a of active.slice(0, 5)) {
-    const visual = PERSONA_VISUALS[a.agentId] || {};
-    lines.push(`  ${visual.avatar || ""} ${visual.shortName || a.agentId}: ${a.findingCount || 0} findings, $${(a.costUsd || 0).toFixed(2)}`);
-  }
-
-  if (stuck.length > 0) {
-    lines.push("");
-    lines.push("\u26A0\uFE0F Stuck agents:");
-    for (const s of stuck) {
-      const visual = PERSONA_VISUALS[s.agentId] || {};
-      lines.push(`  ${visual.avatar || ""} ${visual.shortName || s.agentId}: ${s.reason || "unknown"} (${s.idleSeconds || 0}s idle)`);
-    }
-  }
-
-  return {
-    headline: `Pulse: ${active.length} active, ${stuck.length} stuck, ${completed.length} done`,
-    body: lines.join("\n"),
-  };
-}
-
-// ── Webhook Delivery ─────────────────────────────────────────────────
-
-/**
- * Send an alert to configured Slack/Telegram webhooks.
- * Reads config from env or .sentinelayer.yml.
- * Fails silently — alert delivery must never block agent work.
- *
- * @param {object} alert - { headline, body, severity } from buildAlertPayload
- * @param {object} [channels] - Override channel config
- * @returns {Promise<{ sent: object[], errors: object[] }>}
- */
-export async function sendAlert(alert, channels) {
-  const resolved = channels || resolveAlertChannels();
-  const sent = [];
-  const errors = [];
-
-  for (const channel of resolved) {
-    try {
-      if (channel.type === "slack" && channel.webhook_url) {
-        await sendSlackWebhook(channel.webhook_url, alert);
-        sent.push({ type: "slack", status: "sent" });
-      } else if (channel.type === "telegram" && channel.bot_token && channel.chat_id) {
-        await sendTelegramMessage(channel.bot_token, channel.chat_id, alert);
-        sent.push({ type: "telegram", status: "sent" });
-      }
-    } catch (err) {
-      errors.push({ type: channel.type, error: err.message });
-    }
-  }
-
-  return { sent, errors };
-}
-
-async function sendSlackWebhook(webhookUrl, alert) {
-  const payload = JSON.stringify({
-    text: alert.headline,
-    blocks: [
-      { type: "header", text: { type: "plain_text", text: alert.headline } },
-      { type: "section", text: { type: "mrkdwn", text: alert.body } },
-    ],
-  });
-
-  const response = await fetchWithTimeout(webhookUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: payload,
-  }, 10000);
-
-  if (!response.ok) {
-    throw new Error("Slack webhook failed: " + response.status);
-  }
-}
-
-async function sendTelegramMessage(botToken, chatId, alert) {
-  const url = "https://api.telegram.org/bot" + botToken + "/sendMessage";
-  const payload = JSON.stringify({
-    chat_id: chatId,
-    text: alert.body,
-    parse_mode: "Markdown",
-    disable_web_page_preview: true,
-  });
-
-  const response = await fetchWithTimeout(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: payload,
-  }, 10000);
-
-  if (!response.ok) {
-    throw new Error("Telegram send failed: " + response.status);
-  }
-}
-
-function resolveAlertChannels() {
-  const channels = [];
-
-  // Slack from env
-  const slackUrl = process.env.SENTINELAYER_SLACK_WEBHOOK_URL;
-  if (slackUrl) {
-    channels.push({ type: "slack", webhook_url: slackUrl });
-  }
-
-  // Telegram from env
-  const tgToken = process.env.SENTINELAYER_TELEGRAM_BOT_TOKEN;
-  const tgChat = process.env.SENTINELAYER_TELEGRAM_CHAT_ID;
-  if (tgToken && tgChat) {
-    channels.push({ type: "telegram", bot_token: tgToken, chat_id: tgChat });
-  }
-
-  return channels;
-}
-
-async function fetchWithTimeout(url, options, timeoutMs) {
-  const controller = new AbortController();
-  const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { ...options, signal: controller.signal });
-  } finally {
-    clearTimeout(timeoutHandle);
-  }
-}
-
-export { STUCK_THRESHOLDS };
+// Re-export from platform daemon. Pulse is not Jules-specific.
+export {
+  detectStuckState,
+  determineRecoveryAction,
+  routeErrorToPersona,
+  buildAlertPayload,
+  buildHealthSummary,
+  sendAlert,
+  STUCK_THRESHOLDS,
+} from "../../daemon/pulse.js";

package/src/agents/jules/stream.js

@@ -1,4 +1,5 @@
 import { PERSONA_VISUALS, resolvePersonaVisual } from "./config/definition.js";
+import { createAgentEvent } from "../../events/schema.js";
 
 /**
  * Jules Tanaka — Streaming Event Formatter
@@ -22,20 +23,20 @@ const SCHEMA_VERSION = 1;
 export function buildStreamEvent(event, agentIdentity, payload, usage, runId) {
   const visual = resolvePersonaVisual(agentIdentity?.id) || {};
   return {
-    stream: "sl_event",
+    ...createAgentEvent({
+      event,
+      agent: {
+        id: agentIdentity?.id || "unknown",
+        persona: agentIdentity?.persona || visual.fullName || "unknown",
+        color: agentIdentity?.color || visual.color || "white",
+        avatar: agentIdentity?.avatar || visual.avatar || "",
+      },
+      payload: payload || {},
+      usage: usage || {},
+      runId: runId || undefined,
+    }),
     version: SCHEMA_VERSION,
     command: "audit.deep",
-    runId: runId || null,
-    timestamp: new Date().toISOString(),
-    agent: {
-      id: agentIdentity?.id || "unknown",
-      persona: agentIdentity?.persona || visual.fullName || "unknown",
-      color: agentIdentity?.color || visual.color || "white",
-      avatar: agentIdentity?.avatar || visual.avatar || "",
-    },
-    event,
-    payload: payload || {},
-    usage: usage || {},
   };
 }
 

package/src/agents/jules/swarm/orchestrator.js

@@ -7,6 +7,7 @@ import { createPatternHunter, HUNT_TYPES } from "./pattern-hunter.js";
 import { runSubAgentBatch } from "./sub-agent.js";
 import { frontendAnalyze } from "../tools/frontend-analyze.js";
 import { createAgentContext } from "../tools/dispatch.js";
+import { createAgentEvent } from "../../../events/schema.js";
 
 /**
  * Jules Swarm Orchestrator
@@ -352,11 +353,10 @@ function collectDiscoveredDeps(scanResults) {
 
 function emit(onEvent, event, payload) {
   if (onEvent) {
-    onEvent({
-      stream: "sl_event",
+    onEvent(createAgentEvent({
       event,
       agent: { id: "frontend", persona: "Jules Tanaka", color: "cyan", avatar: "\u{1F3AF}" },
       payload,
-    });
+    }));
   }
 }

package/src/agents/jules/swarm/sub-agent.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { createAgentContext, dispatchTool, isReadOnlyTool, BudgetExhaustedError } from "../tools/dispatch.js";
 import { createMultiProviderApiClient } from "../../../ai/client.js";
+import { createAgentEvent } from "../../../events/schema.js";
 
 /**
  * JulesSubAgent — lightweight isolated agent for parallel audit work.
@@ -201,14 +202,14 @@ export class JulesSubAgent {
         costUsd: this.ctx.usage.costUsd,
         outputTokens: this.ctx.usage.outputTokens,
         durationMs: Date.now() - this.ctx.startedAt,
+        filesRead: [...(this.ctx.usage.filesRead || [])],
       },
     };
   }
 
   emitEvent(event, payload) {
     if (this.onEvent) {
-      this.onEvent({
-        stream: "sl_event",
+      this.onEvent(createAgentEvent({
         event,
         agent: { id: this.id, persona: `Jules Sub-Agent (${this.role})`, parentId: "frontend" },
         payload,
@@ -217,7 +218,9 @@ export class JulesSubAgent {
           toolCalls: this.ctx.usage.toolCalls,
           durationMs: Date.now() - this.ctx.startedAt,
         },
-      });
+        sessionId: this.ctx.sessionId,
+        runId: this.ctx.runId,
+      }));
     }
   }
 }