sentinelayer-cli 0.30.10 → 0.30.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sentinelayer-cli",
-  "version": "0.30.10",
+  "version": "0.30.12",
   "description": "Scaffold Sentinelayer spec/prompt/guide artifacts with secure browser auth and token bootstrap.",
   "type": "module",
   "scripts": {
@@ -9,7 +9,7 @@
     "docs:build": "node scripts/docs-build.mjs",
     "test": "npm run test:unit && npm run test:e2e",
     "test:unit": "node --import ./tests/setup-env.mjs --test tests/unit*.test.mjs",
-    "test:e2e": "node --import ./tests/setup-env.mjs --test tests/e2e.test.mjs",
+    "test:e2e": "node --import ./tests/setup-env.mjs --test tests/e2e*.test.mjs",
     "test:coverage": "c8 node --import ./tests/setup-env.mjs --test tests/unit*.test.mjs",
     "verify": "npm run check && npm run docs:build && npm run test:e2e && npm run test:coverage && npm pack --dry-run",
     "release:publish": "node scripts/release-publish.mjs"

package/src/commands/session.js

@@ -1712,6 +1712,47 @@ function canPublishListenerPresence(agentId) {
   );
 }
 
+const SESSION_OBSERVATION_SEVERITIES = new Set(["info", "p3", "p2", "p1", "p0"]);
+const SESSION_OBSERVATION_KINDS = new Set([
+  "ux",
+  "process",
+  "reliability",
+  "security",
+  "billing",
+  "coordination",
+  "architecture",
+  "testing",
+  "release",
+  "other",
+]);
+const SESSION_OBSERVATION_SUMMARY_MAX_LENGTH = 4_000;
+const SESSION_OBSERVATION_OPTION_MAX_LENGTH = 512;
+const SESSION_OBSERVATION_PROPOSAL_MAX_LENGTH = 2_000;
+
+function requireGrantedNonHumanAgentId(rawAgentId, commandName) {
+  const agentId = normalizeAgentId(rawAgentId, "");
+  if (!agentId || !canPublishListenerPresence(agentId)) {
+    throw new Error(`${commandName} requires a granted non-human agent id.`);
+  }
+  return agentId;
+}
+
+function normalizeSessionObservationChoice(rawValue, allowedValues, fallbackValue, fieldName) {
+  const value = normalizeString(rawValue || fallbackValue).toLowerCase();
+  if (!allowedValues.has(value)) {
+    throw new Error(`${fieldName} must be one of: ${[...allowedValues].join(", ")}.`);
+  }
+  return value;
+}
+
+function normalizeSessionObservationText(rawValue, fieldName, maxLength) {
+  const value = normalizeString(rawValue);
+  if (value.length > maxLength) {
+    throw new Error(`${fieldName} must be ${maxLength} characters or fewer.`);
+  }
+  return value;
+}
+
 function listenerLifecycleEventName(type = "") {
   const normalized = normalizeString(type).toLowerCase();
   if (normalized === "started") return "session_listener_started";
@@ -3660,6 +3701,174 @@ export function registerSessionCommand(program) {
       console.log(formatEventLine(persisted));
     });
 
+  session
+    .command("observe <sessionId> [summary...]")
+    .description("Record a durable product/process observation in the session")
+    .requiredOption("--agent <id>", "Granted non-human agent id to record the observation as")
+    .option("--model <model>", "Agent model/provider hint", "cli")
+    .option("--display-name <name>", "Human-readable agent display name")
+    .option("--role <role>", "Agent role metadata", "observer")
+    .option(
+      "--kind <kind>",
+      `Observation kind: ${[...SESSION_OBSERVATION_KINDS].join(", ")}`,
+      "process",
+    )
+    .option(
+      "--severity <level>",
+      `Observation severity: ${[...SESSION_OBSERVATION_SEVERITIES].join(", ")}`,
+      "info",
+    )
+    .option("--owner <owner>", "Suggested owner/team for follow-up")
+    .option("--batch <batch>", "Suggested PR batch or backlog lane")
+    .option("--target-sequence <n>", "Anchor the observation to a session sequence id")
+    .option("--target-cursor <cursor>", "Anchor the observation to a session event cursor")
+    .option("--proposal <text>", "Suggested remediation or next step")
+    .option("--message-file <path>", "Read the observation summary from a UTF-8 file")
+    .option("--stdin", "Read the observation summary from stdin")
+    .option("--path <path>", "Workspace path for the session", ".")
+    .option("--json", "Emit machine-readable output")
+    .action(async (sessionId, summaryParts, options, command) => {
+      const normalizedSessionId = normalizeString(sessionId);
+      if (!normalizedSessionId) {
+        throw new Error("session id is required.");
+      }
+      const summary = normalizeSessionObservationText(
+        await resolveSessionSayMessageInput(summaryParts, options),
+        "summary",
+        SESSION_OBSERVATION_SUMMARY_MAX_LENGTH,
+      );
+      if (!summary) {
+        throw new Error("summary is required.");
+      }
+      const targetPath = path.resolve(process.cwd(), String(options.path || "."));
+      const agentId = requireGrantedNonHumanAgentId(options.agent, "observe");
+      const kind = normalizeSessionObservationChoice(
+        options.kind,
+        SESSION_OBSERVATION_KINDS,
+        "process",
+        "kind",
+      );
+      const severity = normalizeSessionObservationChoice(
+        options.severity,
+        SESSION_OBSERVATION_SEVERITIES,
+        "info",
+        "severity",
+      );
+      const owner = normalizeSessionObservationText(
+        options.owner,
+        "owner",
+        SESSION_OBSERVATION_OPTION_MAX_LENGTH,
+      );
+      const proposedBatch = normalizeSessionObservationText(
+        options.batch,
+        "batch",
+        SESSION_OBSERVATION_OPTION_MAX_LENGTH,
+      );
+      const proposal = normalizeSessionObservationText(
+        options.proposal,
+        "proposal",
+        SESSION_OBSERVATION_PROPOSAL_MAX_LENGTH,
+      );
+      const targetSequenceId = parseOptionalPositiveInteger(options.targetSequence, "target-sequence");
+      const targetCursor = normalizeSessionObservationText(
+        options.targetCursor,
+        "target-cursor",
+        SESSION_OBSERVATION_OPTION_MAX_LENGTH,
+      );
+      const localSession = await ensureLocalSessionForRemoteCommand(normalizedSessionId, {
+        targetPath,
+      });
+      const clientMessageId = `cli-observation-${randomUUID()}`;
+      const eventPayload = {
+        schema: "session_observation/v1",
+        summary,
+        message: summary,
+        kind,
+        severity,
+        channel: "session",
+        source: "session_observe",
+        clientKind: "cli",
+        clientMessageId,
+      };
+      if (owner) eventPayload.owner = owner;
+      if (proposedBatch) eventPayload.proposedBatch = proposedBatch;
+      if (proposal) eventPayload.proposal = proposal;
+      if (targetSequenceId) eventPayload.targetSequenceId = targetSequenceId;
+      if (targetCursor) eventPayload.targetCursor = targetCursor;
+
+      const agent = await resolveSessionAgentEnvelope(normalizedSessionId, agentId, {
+        targetPath,
+        model: options.model,
+        role: normalizeString(options.role) || "observer",
+        displayName: options.displayName,
+      });
+      agent.role = normalizeString(agent.role) || "observer";
+      agent.model = normalizeString(agent.model) || "cli";
+      agent.clientKind = normalizeString(agent.clientKind) || "cli";
+
+      const event = createAgentEvent({
+        event: "session_observation",
+        agent,
+        sessionId: normalizedSessionId,
+        payload: eventPayload,
+      });
+      event.eventId = clientMessageId;
+      event.idempotencyToken = clientMessageId;
+
+      const remoteConfirmationAnchor = await readSessionConfirmationAnchor(normalizedSessionId, {
+        targetPath,
+      });
+      if (!remoteConfirmationAnchor?.ok) {
+        if (remoteConfirmationAnchor?.reason === "api_403") {
+          throw new Error(
+            `Observation failed (api_403). Ensure this user has an active grant for '${agentId}'.`,
+          );
+        }
+        throw new Error(
+          `Observation confirmation anchor failed (${remoteConfirmationAnchor?.reason || "unknown"}); local cache was not updated.`,
+        );
+      }
+      const remoteSync = await syncSessionEventToApi(normalizedSessionId, event, {
+        targetPath,
+      });
+      if (!remoteSync?.synced) {
+        throw new Error(
+          `Observation failed (${remoteSync?.reason || "unknown"}). Ensure this user has an active grant for '${agentId}'.`,
+        );
+      }
+      const remoteConfirmation = await confirmSessionEventVisible(normalizedSessionId, clientMessageId, {
+        targetPath,
+        anchorCursor: remoteConfirmationAnchor?.cursor,
+      });
+      if (!remoteConfirmation?.confirmed) {
+        throw new Error(
+          `Observation was accepted but not visible in canonical session events (${remoteConfirmation?.reason || "not_visible"}); local cache was not updated.`,
+        );
+      }
+
+      const persisted = await appendToStream(normalizedSessionId, event, {
+        targetPath,
+        syncRemote: false,
+      });
+      const payload = {
+        command: "session observe",
+        targetPath,
+        sessionId: normalizedSessionId,
+        agentId,
+        event: persisted,
+        materializedLocalSession: localSession.materialized,
+        refreshedLocalSession: Boolean(localSession.refreshed),
+        remoteSync,
+        remoteConfirmationAnchor,
+        remoteConfirmation,
+      };
+      if (shouldEmitJson(options, command)) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+      console.log(formatEventLine(persisted));
+    });
+
   async function runMessageActionCommand({
     sessionId,
     actionType,

package/src/session/daemon.js

@@ -71,6 +71,7 @@ const CHECKPOINT_MEANINGFUL_EVENT_NAMES = new Set([
   "help_response",
   "session_admin_kill",
   "session_message",
+  "session_observation",
   "task_accepted",
   "task_assign",
   "task_blocked",

package/src/session/preview.js

@@ -12,6 +12,7 @@ const PREVIEW_EVENTS = new Set([
   "session_message",
   "session_say",
   "agent_response",
+  "session_observation",
   "human_relay",
   "daemon_alert",
   "session_admin_kill",
@@ -45,6 +46,7 @@ export function pickLatestPreview(events = []) {
     if (!kind || !PREVIEW_EVENTS.has(kind)) continue;
     const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
     const text =
+      payload.summary ||
       payload.message ||
       payload.response ||
       payload.alert ||

package/src/session/pricing-ledger.js

@@ -138,7 +138,10 @@ export function buildUsageLedgerEntry(
   { sessionId = "", priceBookVersion = DEFAULT_PRICE_BOOK_VERSION, billingTier = "unknown" } = {},
 ) {
   const kind = n(event?.event || event?.type);
-  const payload = object(event?.payload);
+  const rawPayload = event?.payload;
+  const payload = object(rawPayload);
+  const payloadWasObject = rawPayload && typeof rawPayload === "object" && !Array.isArray(rawPayload);
+  if (kind === SESSION_USAGE_EVENT && !payloadWasObject) return null;
   const schema = n(payload.schema);
   const usage = object(payload.usage);
   const legacyUsageEvent = kind !== SESSION_USAGE_EVENT && hasUsageHints(usage);

package/src/session/transcript.js

@@ -47,6 +47,7 @@ const TRANSCRIPT_EVENT_KINDS = new Set([
   "session_reply",
   "session_reaction",
   "session_usage",
+  "session_observation",
   "human_relay",
   "agent_join",
   "agent_left",
@@ -209,11 +210,56 @@ function actionBody(event) {
   return "";
 }
 
+function boundedMarkdownText(value, { maxLength = 2_000 } = {}) {
+  const text = normalize(value).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (!maxLength || text.length <= maxLength) return text;
+  const head = Math.max(120, Math.floor((maxLength - 3) * 0.75));
+  const tail = Math.max(40, maxLength - 3 - head);
+  return `${text.slice(0, head)}...${text.slice(-tail)}`;
+}
+
+function observationTargetLabel(payload = {}) {
+  const targetSequence = Number(payload.targetSequenceId || payload.target_sequence_id || 0);
+  if (Number.isFinite(targetSequence) && targetSequence > 0) {
+    return `#${Math.floor(targetSequence)}`;
+  }
+  const targetCursor = tableText(payload.targetCursor || payload.target_cursor, { maxLength: 96 });
+  return targetCursor ? `cursor ${targetCursor}` : "";
+}
+
+function observationBody(event) {
+  const payload = event && typeof event.payload === "object" ? event.payload : {};
+  const severity = tableText(payload.severity || "info", { maxLength: 16 }).toLowerCase();
+  const kind = tableText(payload.kind || "process", { maxLength: 32 }).toLowerCase();
+  const summary = boundedMarkdownText(payload.summary || payload.message || payload.text, {
+    maxLength: 4_000,
+  });
+  const proposal = boundedMarkdownText(payload.proposal || payload.recommendation, {
+    maxLength: 2_000,
+  });
+  const owner = tableText(payload.owner || payload.assignee, { maxLength: 96 });
+  const proposedBatch = tableText(payload.proposedBatch || payload.batch, { maxLength: 96 });
+  const target = observationTargetLabel(payload);
+  const metadata = [];
+  if (owner) metadata.push(`Owner: \`${owner}\``);
+  if (proposedBatch) metadata.push(`Batch: \`${proposedBatch}\``);
+  if (target) metadata.push(`Target: \`${target}\``);
+
+  const lines = [`**Observation:** \`${severity || "info"}\` · \`${kind || "process"}\``];
+  if (metadata.length) lines.push(metadata.join(" · "));
+  if (summary) lines.push("", summary);
+  if (proposal) lines.push("", "**Proposal:**", proposal);
+  return lines.join("\n");
+}
+
 function eventBody(event) {
   const kind = normalize(event?.event || event?.type);
   if (kind === "session_action" || kind === "session_reply" || kind === "session_reaction") {
     return actionBody(event);
   }
+  if (kind === "session_observation") {
+    return observationBody(event);
+  }
   const payload = event && typeof event.payload === "object" ? event.payload : {};
   // session_usage carries the response inside payload.response.text
   const responseText =
@@ -237,7 +283,12 @@ function eventBody(event) {
  *  - totals: { tokenTotal, costTotalUsd } summed through the pricing ledger
  *  - sentiActions: count of orchestrator events
  */
-export function computeTranscriptStats({ sessionMeta = {}, events = [], speakerProfiles = new Map() } = {}) {
+export function computeTranscriptStats({
+  sessionMeta = {},
+  events = [],
+  speakerProfiles = new Map(),
+  usageLedger = null,
+} = {}) {
   const perAgent = new Map();
   let firstEventTs = null;
   let lastEventTs = null;
@@ -305,14 +356,14 @@ export function computeTranscriptStats({ sessionMeta = {}, events = [], speakerP
     if (epoch > record.lastSeenMs) record.lastSeenMs = epoch;
   }
 
-  const usageLedger = buildSessionUsageLedger(events, {
+  const resolvedUsageLedger = usageLedger || buildSessionUsageLedger(events, {
     sessionId: normalize(sessionMeta.sessionId),
   });
   const fallbackUsageEpoch =
     lastEventTs ??
     firstEventTs ??
     (Number.isFinite(Date.parse(sessionMeta?.createdAt)) ? Date.parse(sessionMeta.createdAt) : 0);
-  for (const entry of usageLedger.entries) {
+  for (const entry of resolvedUsageLedger.entries) {
     const entryEpoch = Number.isFinite(Date.parse(entry.timestamp))
       ? Date.parse(entry.timestamp)
       : fallbackUsageEpoch;
@@ -364,17 +415,17 @@ export function computeTranscriptStats({ sessionMeta = {}, events = [], speakerP
     sessionLiveSeconds,
     agents,
     totals: {
-      tokenTotal: usageLedger.totals.totalTokens,
-      inputTokens: usageLedger.totals.inputTokens,
-      outputTokens: usageLedger.totals.outputTokens,
-      costTotalUsd: usageLedger.totals.providerCostUsd,
-      customerCostTotalUsd: usageLedger.totals.hasCustomerCost
-        ? usageLedger.totals.customerCostUsd
+      tokenTotal: resolvedUsageLedger.totals.totalTokens,
+      inputTokens: resolvedUsageLedger.totals.inputTokens,
+      outputTokens: resolvedUsageLedger.totals.outputTokens,
+      costTotalUsd: resolvedUsageLedger.totals.providerCostUsd,
+      customerCostTotalUsd: resolvedUsageLedger.totals.hasCustomerCost
+        ? resolvedUsageLedger.totals.customerCostUsd
         : null,
-      usageEntries: usageLedger.entries.length,
-      duplicatesSkipped: usageLedger.duplicatesSkipped,
-      unpriced: usageLedger.totals.unpriced,
-      priceBookVersions: usageLedger.priceBookVersions,
+      usageEntries: resolvedUsageLedger.entries.length,
+      duplicatesSkipped: resolvedUsageLedger.duplicatesSkipped,
+      unpriced: resolvedUsageLedger.totals.unpriced,
+      priceBookVersions: resolvedUsageLedger.priceBookVersions,
     },
     sentiActions,
   };
@@ -408,6 +459,134 @@ function avatarMd(identity) {
   return identity.avatar || letterTile(identity.displayName || identity.agentId);
 }
 
+function intCell(value) {
+  return Math.max(0, Math.floor(Number(value || 0))).toLocaleString("en-US");
+}
+
+function usdCell(value) {
+  return `$${Number(value || 0).toFixed(6)}`;
+}
+
+function tableText(value, { maxLength = 160 } = {}) {
+  const escaped = normalize(value)
+    .replace(/\r?\n/g, " ")
+    .replace(/\|/g, "\\|")
+    .replace(/`/g, "'");
+  if (!maxLength || escaped.length <= maxLength) return escaped;
+  const head = Math.max(24, Math.floor((maxLength - 3) * 0.7));
+  const tail = Math.max(12, maxLength - 3 - head);
+  return `${escaped.slice(0, head)}...${escaped.slice(-tail)}`;
+}
+
+function codeCell(value) {
+  const text = tableText(value);
+  return text ? `\`${text}\`` : "—";
+}
+
+function optionalUsdCell(value, hasValue) {
+  return hasValue ? usdCell(value) : "—";
+}
+
+function shortenIdempotencyKey(value, maxLength = 36) {
+  const text = tableText(value, { maxLength: 0 });
+  if (!text || text.length <= maxLength) return text;
+  const head = Math.max(8, Math.floor((maxLength - 3) * 0.58));
+  const tail = Math.max(6, maxLength - 3 - head);
+  return `${text.slice(0, head)}...${text.slice(-tail)}`;
+}
+
+function rollupsByCostAndTokens(map) {
+  return [...map.values()].sort((a, b) => (
+    b.providerCostUsd - a.providerCostUsd ||
+    b.totalTokens - a.totalTokens ||
+    b.entries - a.entries ||
+    tableText(a.label).localeCompare(tableText(b.label))
+  ));
+}
+
+function recentUsageEntries(entries, limit = 10) {
+  return entries
+    .map((entry, index) => ({ entry, index }))
+    .sort((a, b) => {
+      const aSequence = Number.isFinite(a.entry.sequenceId) ? a.entry.sequenceId : null;
+      const bSequence = Number.isFinite(b.entry.sequenceId) ? b.entry.sequenceId : null;
+      if (aSequence != null && bSequence != null && aSequence !== bSequence) {
+        return bSequence - aSequence;
+      }
+      const aTime = Date.parse(a.entry.timestamp);
+      const bTime = Date.parse(b.entry.timestamp);
+      if (Number.isFinite(aTime) && Number.isFinite(bTime) && aTime !== bTime) {
+        return bTime - aTime;
+      }
+      return b.index - a.index;
+    })
+    .slice(0, limit)
+    .map(({ entry }) => entry);
+}
+
+function appendUsageRollupTable(lines, { title, labelHeader, rollups }) {
+  lines.push(`### ${title}`);
+  lines.push("");
+  lines.push(`| ${labelHeader} | Entries | Input | Output | Total | Provider cost | Customer cost | Unpriced |`);
+  lines.push("|---|---:|---:|---:|---:|---:|---:|---:|");
+  if (rollups.length === 0) {
+    lines.push(`| — | 0 | 0 | 0 | 0 | ${usdCell(0)} | — | 0 |`);
+  } else {
+    for (const rollup of rollups) {
+      lines.push(
+        `| ${codeCell(rollup.label)} | ${intCell(rollup.entries)} | ${intCell(rollup.inputTokens)} | ${intCell(rollup.outputTokens)} | ${intCell(rollup.totalTokens)} | ${usdCell(rollup.providerCostUsd)} | ${optionalUsdCell(rollup.customerCostUsd, rollup.hasCustomerCost)} | ${intCell(rollup.unpriced)} |`,
+      );
+    }
+  }
+  lines.push("");
+}
+
+function appendUsageLedgerSection(lines, usageLedger) {
+  const totals = usageLedger.totals;
+  lines.push("## Usage Ledger");
+  lines.push("");
+
+  if (usageLedger.entries.length === 0 && usageLedger.duplicatesSkipped === 0) {
+    lines.push("_No usage telemetry recorded._");
+    lines.push("");
+    return;
+  }
+
+  const customerCostText = totals.hasCustomerCost
+    ? `Customer cost: ${usdCell(totals.customerCostUsd)}`
+    : "Customer cost: —";
+  lines.push(`Accepted entries: ${intCell(usageLedger.entries.length)}`);
+  lines.push(
+    `Tokens: ${intCell(totals.totalTokens)} (input ${intCell(totals.inputTokens)} / output ${intCell(totals.outputTokens)})`,
+  );
+  lines.push(`Provider cost: ${usdCell(totals.providerCostUsd)} · ${customerCostText}`);
+  lines.push(`Price books: ${usageLedger.priceBookVersions.map(tableText).filter(Boolean).join(", ") || "—"}`);
+  lines.push(`Duplicates skipped: ${intCell(usageLedger.duplicatesSkipped)} · Unpriced entries: ${intCell(totals.unpriced)}`);
+  lines.push("");
+
+  appendUsageRollupTable(lines, {
+    title: "Per Agent",
+    labelHeader: "Agent",
+    rollups: rollupsByCostAndTokens(usageLedger.perAgent),
+  });
+  appendUsageRollupTable(lines, {
+    title: "Per Action",
+    labelHeader: "Action",
+    rollups: rollupsByCostAndTokens(usageLedger.perAction),
+  });
+
+  lines.push("### Recent Entries");
+  lines.push("");
+  lines.push("| Time | Agent | Action | Model | Tokens | Provider cost | Customer cost | Idempotency key |");
+  lines.push("|---|---|---|---|---:|---:|---:|---|");
+  for (const entry of recentUsageEntries(usageLedger.entries)) {
+    lines.push(
+      `| ${tableText(timestampOnly(entry.timestamp)) || "—"} | ${codeCell(entry.agentId)} | ${codeCell(entry.action)} | ${codeCell(entry.model)} | ${intCell(entry.totalTokens)} | ${usdCell(entry.providerCostUsd)} | ${optionalUsdCell(entry.customerCostUsd, entry.customerCostUsd != null)} | ${codeCell(shortenIdempotencyKey(entry.idempotencyKey))} |`,
+    );
+  }
+  lines.push("");
+}
+
 /**
  * Build the iMessage-style markdown transcript.
  *
@@ -429,8 +608,11 @@ export function buildTranscriptMarkdown({
   speakerProfiles = new Map(),
   options = {},
 } = {}) {
+  const usageLedger = buildSessionUsageLedger(events, {
+    sessionId: normalize(sessionMeta.sessionId),
+  });
   const includeSystemEvents = options.includeSystemEvents !== false;
-  const stats = computeTranscriptStats({ sessionMeta, events, speakerProfiles });
+  const stats = computeTranscriptStats({ sessionMeta, events, speakerProfiles, usageLedger });
 
   const lines = [];
   const sessionId = normalize(sessionMeta.sessionId) || "unknown";
@@ -496,15 +678,17 @@ export function buildTranscriptMarkdown({
   stats.participantCount = stats.agents.length + silentRegisteredAgents.length;
   lines.push("");
 
+  appendUsageLedgerSection(lines, usageLedger);
+
   // Conversation
   lines.push("## Conversation");
   lines.push("");
   for (const event of events) {
-    const kind = normalize(event.event || event.type);
+    const kind = normalize(event?.event || event?.type);
     if (!kind || !TRANSCRIPT_EVENT_KINDS.has(kind)) continue;
     if (!includeSystemEvents && SYSTEM_EVENT_KINDS.has(kind)) continue;
 
-    const agentId = normalize(event.agent?.id || event.agentId);
+    const agentId = normalize(event?.agent?.id || event?.agentId);
     const profile = speakerProfiles.get(agentId) || null;
     const identity = resolveSpeakerIdentity({
       agentId,