@tangle-network/agent-app 0.44.9 → 0.44.10

package/dist/turn-health/index.d.ts

@@ -67,6 +67,55 @@ type TurnHealthReason =
  | {
     kind: 'turn_failed';
     reason: string;
+}
+/** A tool call the harness REJECTED, settled as `completed`.
+ *
+ *  Found live in legal-agent production, and missed by every other rule here:
+ *  the model called `submit_proposal`, the harness answered "Model tried to
+ *  call unavailable tool 'submit_proposal'", and the part persisted as
+ *  `{"tool":"invalid","state":{"status":"completed","input":{"error":"…"}}}`.
+ *
+ *  Status is `completed`, the arguments parse cleanly, and the turn has text —
+ *  so the blank-completion, malformed-argument and no-effect rules all pass it.
+ *  Six deliverables were requested and silently discarded while the product
+ *  reported success six times.
+ *
+ *  Detected structurally, on the presence of an `error` in the settled state
+ *  rather than on any harness's name for a rejected call — `invalid` is one
+ *  harness's convention and must not be baked into the shell. */
+ | {
+    kind: 'tool_call_rejected';
+    /** The tool the model was trying to reach, when the payload names it. */
+    tool: string;
+    error: string;
+}
+/** The turn was answered without the model ever running — a pre-producer gate
+ *  short-circuited and returned the product's own response.
+ *
+ *  Reported as a `warning`, never `critical`: gating an unready turn is a
+ *  legitimate design (an intake flow SHOULD answer before spending a model
+ *  call). What is pathological is the RATE, which only the caller's own
+ *  threshold can judge — so this variant exists to be COUNTED, and alerting
+ *  on it is opt-in. It is the per-turn evidence behind a dead tool surface:
+ *  a gate that answers every turn means the agent never runs at all. */
+ | {
+    kind: 'answered_without_model';
+}
+/** The detector could not read this turn.
+ *
+ *  Every part carried a type outside the vocabulary this classifier
+ *  understands — which is what field-level encryption at rest looks like from
+ *  the outside (tax-agent persists `{"type":"__encrypted_parts__"}`, its own
+ *  convention, and 32 of its 129 assistant rows are exactly that).
+ *
+ *  This exists because the alternative is the bug this whole module hunts.
+ *  An unreadable row has no text, no artifact and no tool part, so every
+ *  other rule here would happily conclude "nothing wrong" — a detector
+ *  reporting health from data it cannot see. Blindness is a finding, not a
+ *  pass, so it gets its own reason and its own counter. */
+ | {
+    kind: 'unreadable_turn';
+    partTypes: string[];
 };
 /** A settled turn, in the narrowest shape both call sites can supply.
  *
@@ -86,6 +135,10 @@ interface TurnOutcomeInput {
     failed?: boolean;
     failureReason?: string | null;
     durationMs?: number;
+    /** Set when a pre-producer gate answered this turn and the model never ran.
+     *  Supplied by `/chat-routes`' lifecycle seam, which stamps `gated` on the
+     *  completion it now fires for a `contextGate` short-circuit. */
+    gated?: boolean;
 }
 /** The verdict for one turn. `healthy` is exactly `reasons.length === 0`, kept
  *  as a field so callers read intent rather than an array length. */
@@ -93,6 +146,37 @@ interface TurnHealthVerdict {
     healthy: boolean;
     severity: TurnHealthSeverity | null;
     reasons: TurnHealthReason[];
+    /** How many tool parts this turn carried.
+     *
+     *  Zero is NOT a per-turn defect — plenty of good turns answer from context
+     *  without touching a tool, and paging on each one would be pure noise. It is
+     *  reported so a WINDOW can be judged: a product whose deliverable is tool
+     *  output and which produced zero tool calls across every turn in the
+     *  lookback has a dead tool surface, and that is the shape no per-turn rule
+     *  can see. (Measured: tax-agent, 129 of 129 assistant rows all-time.) */
+    toolCalls: number;
+    /** True when nothing about this turn could be judged — no interpretable part
+     *  AND no visible text. Callers MUST exclude these from any healthy/unhealthy
+     *  ratio, because counting an unreadable turn as healthy is how a detector
+     *  reports green on data it never read. */
+    unreadable: boolean;
+    /** False when this turn carried parts that could not be interpreted.
+     *
+     *  Separate from {@link unreadable} because the two blindnesses have
+     *  different consequences, and production has a row that is one but not the
+     *  other: tax-agent persists CIPHERTEXT as `content` alongside an encrypted
+     *  `parts` blob, so the turn plainly delivered something (there is text) while
+     *  its tool calls are completely invisible.
+     *
+     *  Any conclusion ABOUT TOOLS — above all the dead-tool-surface verdict — may
+     *  only be drawn over turns where this is true. Reading "no tool parts" off an
+     *  encrypted blob and declaring the tool surface dead would be the same
+     *  crime as declaring it healthy: a finding asserted from data never read. */
+    partsReadable: boolean;
+    /** The part types that could not be interpreted. Empty when
+     *  {@link partsReadable}. Named in the alert so a reader can see EXACTLY what
+     *  the detector was blind to instead of taking "unreadable" on faith. */
+    opaquePartTypes: string[];
 }
 /**
  * Judge one settled turn.
@@ -172,6 +256,27 @@ declare function createWebhookAlertSink(options: {
     webhookUrl: string;
     fetchImpl?: FetchLike;
 }): AlertSink;
+/**
+ * POST to Slack `chat.postMessage` with a bot token.
+ *
+ * This is the transport the org actually has. A survey of the four product
+ * repos found NO ops alert path of any kind — no incoming webhook, no pager, no
+ * notifier — which is the mechanical reason a 17-day outage never reached a
+ * human. What does exist is a Slack bot token in the shared secrets store, and
+ * `@tangle-network/agent-integrations` already speaks this exact API, so this
+ * routes alerts through the channel the org runs rather than standing up a new
+ * one.
+ *
+ * Slack answers `200 OK` with `{"ok": false, "error": "..."}` for an invalid
+ * token or channel, so the body is checked and not just the status — a
+ * transport that reports success on a rejected post would make the alerter
+ * itself a silent failure.
+ */
+declare function createSlackBotAlertSink(options: {
+    botToken: string;
+    channel: string;
+    fetchImpl?: FetchLike;
+}): AlertSink;
 /** stderr sink. The zero-config fallback so a product that has not yet been
  *  given a webhook still emits something a log search can find. */
 declare function createConsoleAlertSink(log?: (message: string) => void): AlertSink;
@@ -231,6 +336,9 @@ interface TurnHealthCompleteInfo {
     threadId?: string;
     turnStreamId?: string;
     executionId?: string;
+    /** `/chat-routes` sets this when a `contextGate` short-circuited the turn and
+     *  the producer never ran. */
+    gated?: boolean;
 }
 /** Structural mirror of the lifecycle error payload. */
 interface TurnHealthErrorInfo {
@@ -258,6 +366,15 @@ interface TurnHealthLifecycleOptions {
         kinds: string[];
         durationMs: number;
     }): void;
+    /** Page when a turn was answered by a gate instead of the model.
+     *
+     *  Default `false`, and the default is the honest one: gating is a legitimate
+     *  design and a product that gates its intake would otherwise page on every
+     *  healthy turn. Whether the rate is pathological is domain knowledge, so it
+     *  stays a product decision — the verdict is ALWAYS reported through
+     *  {@link TurnHealthLifecycleOptions.onVerdict} so a counter can watch the
+     *  rate even when nobody is paged. */
+    alertOnGatedTurn?: boolean;
 }
 /**
  * Build the lifecycle hooks that page on a turn which succeeded at nothing.
@@ -353,6 +470,22 @@ interface SweepOptions {
     emptyRateThreshold?: number;
     /** Absolute floor: never page on a rate computed from fewer turns than this. */
     minTurnsForRate?: number;
+    /** Declare that this product's deliverable comes from TOOL calls, which
+     *  switches on the dead-tool-surface detector.
+     *
+     *  Opt-in because only the product knows: a copilot that answers from context
+     *  is perfectly healthy with zero tool calls, while an agent whose entire job
+     *  is to file, draft, or submit something is broken the moment its tool
+     *  surface goes quiet — and broken INVISIBLY, because every turn still
+     *  returns fluent prose and HTTP 200.
+     *
+     *  This is the fourth failure shape, and the only one no per-turn rule can
+     *  see. Measured on production: tax-agent has 129 assistant turns across 64
+     *  threads, all-time, with zero tool parts — while every other detector in
+     *  this module reports it healthy. */
+    expectsToolCalls?: boolean;
+    /** Turns needed before a dead tool surface is called. Default 10. */
+    minTurnsForToolSurface?: number;
     now?: number;
 }
 /** What the sweep found. Returned as well as alerted, so a cron can log it and
@@ -367,20 +500,23 @@ interface SweepResult {
     emptyCompletions: number;
     malformedToolCalls: number;
     toolCallsWithoutEffect: number;
+    /** Tool calls the harness rejected while settling them as `completed`. */
+    rejectedToolCalls: number;
+    /** Turns carrying at least one tool part. */
+    turnsWithToolCalls: number;
+    /** Total tool parts across the window. */
+    toolCalls: number;
+    /** Turns the classifier could not interpret at all (encrypted at rest, or a
+     *  part vocabulary this module does not know). These are EXCLUDED from
+     *  `turnsJudged`-based rates — a rate computed over rows nobody could read is
+     *  a fabricated number. */
+    unreadableTurns: number;
+    /** Turns whose PARTS could not be interpreted. A superset of
+     *  {@link unreadableTurns} (a row can have readable text and opaque parts).
+     *  No tool verdict is drawn over these. */
+    opaquePartsTurns: number;
     alerts: TurnHealthAlert[];
 }
-/**
- * Assistant-row openers agent-app writes ITSELF when a sandbox turn fails.
- *
- * Kept byte-identical to the strings `createSandboxChatProducer` composes
- * (`src/chat-routes/sandbox-producer.ts`). They are shell vocabulary, not
- * product domain, so recognising them is this package's job — a product on
- * the shared producer gets a correct sweep with no configuration.
- *
- * `tests/turn-health/turn-health.test.ts` pins these against the producer, so
- * changing the producer's wording without changing this list fails CI rather
- * than silently making dead threads look answered.
- */
 declare const SHELL_ERROR_REPLY_PREFIXES: readonly string[];
 /**
  * Run one sweep and deliver whatever it finds.
@@ -451,4 +587,4 @@ declare function createD1TurnHealthSource(db: D1LikeForHealth, options?: {
     errorReplyPrefixes?: readonly string[];
 }): TurnHealthSource;
 
-export { type AlertSink, type AlertThrottleStore, type D1LikeForHealth, type FetchLike, type PersistedTurnRow, SHELL_ERROR_REPLY_PREFIXES, type SweepOptions, type SweepResult, type TurnHealthAlert, type TurnHealthCompleteInfo, type TurnHealthErrorInfo, type TurnHealthLifecycle, type TurnHealthLifecycleOptions, type TurnHealthReason, type TurnHealthSeverity, type TurnHealthSource, type TurnHealthVerdict, type TurnOutcomeInput, type UnansweredThread, classifyTurnOutcome, createConsoleAlertSink, createD1TurnHealthSource, createGuardedAlertSink, createMemoryThrottleStore, createMultiAlertSink, createThrottledAlertSink, createTurnHealthLifecycle, createWebhookAlertSink, describeReason, sweepSilentFailures, turnAlert };
+export { type AlertSink, type AlertThrottleStore, type D1LikeForHealth, type FetchLike, type PersistedTurnRow, SHELL_ERROR_REPLY_PREFIXES, type SweepOptions, type SweepResult, type TurnHealthAlert, type TurnHealthCompleteInfo, type TurnHealthErrorInfo, type TurnHealthLifecycle, type TurnHealthLifecycleOptions, type TurnHealthReason, type TurnHealthSeverity, type TurnHealthSource, type TurnHealthVerdict, type TurnOutcomeInput, type UnansweredThread, classifyTurnOutcome, createConsoleAlertSink, createD1TurnHealthSource, createGuardedAlertSink, createMemoryThrottleStore, createMultiAlertSink, createSlackBotAlertSink, createThrottledAlertSink, createTurnHealthLifecycle, createWebhookAlertSink, describeReason, sweepSilentFailures, turnAlert };

package/dist/turn-health/index.js

@@ -1,5 +1,13 @@
 // src/turn-health/classify.ts
 var ARTIFACT_PART_KINDS = /* @__PURE__ */ new Set(["file", "image", "work-product", "plan", "interaction"]);
+var KNOWN_NON_OUTPUT_PART_KINDS = /* @__PURE__ */ new Set([
+  "reasoning",
+  "step-start",
+  "step-finish",
+  "source",
+  "source-url",
+  "data"
+]);
 var SAMPLE_CHARS = 120;
 function asRecord(value) {
   return typeof value === "object" && value !== null ? value : null;
@@ -29,23 +37,49 @@ function classifyTurnOutcome(input) {
   const parts = Array.isArray(input.parts) ? input.parts : [];
   let hasVisibleText = nonEmptyString(input.finalText) !== null;
   let artifactCount = 0;
+  let toolCalls = 0;
+  const opaqueTypes = [];
+  let interpretedParts = 0;
   for (const raw of parts) {
     const part = asRecord(raw);
     if (!part) continue;
     const type = typeof part.type === "string" ? part.type : "";
-    if (type === "text" && nonEmptyString(part.text) !== null) {
-      hasVisibleText = true;
+    if (type === "text") {
+      interpretedParts += 1;
+      if (nonEmptyString(part.text) !== null) hasVisibleText = true;
       continue;
     }
     if (ARTIFACT_PART_KINDS.has(type)) {
+      interpretedParts += 1;
       artifactCount += 1;
       continue;
     }
-    if (type !== "tool") continue;
+    if (KNOWN_NON_OUTPUT_PART_KINDS.has(type)) {
+      interpretedParts += 1;
+      continue;
+    }
+    if (type !== "tool") {
+      opaqueTypes.push(type || "(missing type)");
+      continue;
+    }
+    interpretedParts += 1;
+    toolCalls += 1;
     const tool = nonEmptyString(part.tool) ?? "unknown";
     const state = asRecord(part.state);
     const status = typeof state?.status === "string" ? state.status : "unknown";
     const toolInput = state?.input;
+    const inputRecord = asRecord(toolInput);
+    const rejection = nonEmptyString(inputRecord?.error) ?? nonEmptyString(state?.error);
+    if (rejection) {
+      reasons.push({
+        kind: "tool_call_rejected",
+        // The payload names the tool the model MEANT to call; the part's own
+        // `tool` is the harness's placeholder for a rejected call.
+        tool: nonEmptyString(inputRecord?.tool) ?? tool,
+        error: rejection.slice(0, 200)
+      });
+      continue;
+    }
     if (typeof toolInput === "string" && isUnparseableJson(toolInput)) {
       reasons.push({
         kind: "malformed_tool_call",
@@ -59,7 +93,24 @@ function classifyTurnOutcome(input) {
       reasons.push({ kind: "tool_call_no_effect", tool, status });
     }
   }
-  if (!input.failed && !hasVisibleText && artifactCount === 0) {
+  const partsReadable = opaqueTypes.length === 0;
+  const uniqueOpaque = [...new Set(opaqueTypes)];
+  const unreadable = opaqueTypes.length > 0 && interpretedParts === 0 && !hasVisibleText;
+  if (unreadable) {
+    reasons.push({ kind: "unreadable_turn", partTypes: uniqueOpaque });
+    return {
+      healthy: false,
+      severity: "warning",
+      reasons,
+      toolCalls,
+      unreadable: true,
+      partsReadable: false,
+      opaquePartTypes: uniqueOpaque
+    };
+  }
+  if (input.gated) {
+    reasons.push({ kind: "answered_without_model" });
+  } else if (!input.failed && !hasVisibleText && artifactCount === 0) {
     reasons.push({
       kind: "empty_completion",
       outputTokens: input.outputTokens ?? null,
@@ -70,12 +121,18 @@ function classifyTurnOutcome(input) {
   return {
     healthy: reasons.length === 0,
     severity: severityOf(reasons),
-    reasons
+    reasons,
+    toolCalls,
+    unreadable: false,
+    partsReadable,
+    opaquePartTypes: uniqueOpaque
   };
 }
 function severityOf(reasons) {
   if (reasons.length === 0) return null;
-  const critical = reasons.some((r) => r.kind === "empty_completion" || r.kind === "turn_failed");
+  const critical = reasons.some(
+    (r) => r.kind === "empty_completion" || r.kind === "turn_failed" || r.kind === "tool_call_rejected"
+  );
   return critical ? "critical" : "warning";
 }
 function describeReason(reason) {
@@ -88,6 +145,14 @@ function describeReason(reason) {
       return `tool \`${reason.tool}\` left no effect (status=${reason.status})`;
     case "turn_failed":
       return `turn failed: ${reason.reason}`;
+    case "tool_call_rejected":
+      return `tool \`${reason.tool}\` was REJECTED but settled as completed: ${reason.error}`;
+    case "answered_without_model":
+      return "answered by a pre-producer gate \u2014 the model never ran";
+    case "unreadable_turn":
+      return `turn could not be read: every part had an uninterpretable type (${reason.partTypes.join(
+        ", "
+      )})`;
   }
 }
 
@@ -132,6 +197,32 @@ function createWebhookAlertSink(options) {
     }
   };
 }
+function createSlackBotAlertSink(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  return {
+    async deliver(alert) {
+      const icon = alert.severity === "critical" ? ":rotating_light:" : ":warning:";
+      const lines = [
+        `${icon} *${alert.title}*`,
+        ...alert.details.map((d) => `\u2022 ${d}`),
+        `_${new Date(alert.at).toISOString()}_`
+      ];
+      const response = await fetchImpl("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=utf-8",
+          Authorization: `Bearer ${options.botToken}`
+        },
+        body: JSON.stringify({ channel: options.channel, text: lines.join("\n") })
+      });
+      if (!response.ok) throw new Error(`slack chat.postMessage responded ${response.status}`);
+      const body = await response.text?.() ?? "";
+      if (body && !/"ok"\s*:\s*true/.test(body)) {
+        throw new Error(`slack rejected the alert: ${body.slice(0, 200)}`);
+      }
+    }
+  };
+}
 function createConsoleAlertSink(log = console.error) {
   return {
     async deliver(alert) {
@@ -199,7 +290,8 @@ function createTurnHealthLifecycle(options) {
       const verdict = classifyTurnOutcome({
         finalText: info.finalText,
         outputTokens: info.usage?.outputTokens ?? null,
-        durationMs: info.durationMs
+        durationMs: info.durationMs,
+        ...info.gated ? { gated: true } : {}
       });
       options.onVerdict?.({
         product: options.product,
@@ -208,6 +300,9 @@ function createTurnHealthLifecycle(options) {
         durationMs: info.durationMs
       });
       if (verdict.healthy || verdict.severity === null) return;
+      if (!options.alertOnGatedTurn && verdict.reasons.every((r) => r.kind === "answered_without_model")) {
+        return;
+      }
       await sink.deliver(
         turnAlert({
           product: options.product,
@@ -255,6 +350,7 @@ function parseParts(raw) {
   }
 }
 var HOUR_MS = 36e5;
+var D1_MAX_LIKE_PATTERN_LENGTH = 50;
 var SHELL_ERROR_REPLY_PREFIXES = [
   "The sandbox model stream stopped before a clean completion.",
   "The sandbox agent returned an error before producing a visible answer."
@@ -267,6 +363,8 @@ async function sweepSilentFailures(options) {
   const limit = options.limit ?? 500;
   const emptyRateThreshold = options.emptyRateThreshold ?? 0.05;
   const minTurnsForRate = options.minTurnsForRate ?? 10;
+  const minTurnsForToolSurface = options.minTurnsForToolSurface ?? 10;
+  const blindThreshold = 0.5;
   const [unanswered, turns] = await Promise.all([
     options.source.findUnansweredThreads({ minAgeMs, maxAgeMs, now }),
     options.source.listRecentAssistantTurns({ sinceMs: now - lookbackMs, now, limit })
@@ -299,14 +397,33 @@ async function sweepSilentFailures(options) {
   let emptyCompletions = 0;
   let malformedToolCalls = 0;
   let toolCallsWithoutEffect = 0;
+  let rejectedToolCalls = 0;
   let unhealthyTurns = 0;
+  let turnsWithToolCalls = 0;
+  let toolCalls = 0;
+  let unreadableTurns = 0;
+  let toolReadableTurns = 0;
+  let opaquePartsTurns = 0;
+  const opaqueTypes = /* @__PURE__ */ new Set();
   const malformedSamples = [];
+  const rejectedSamples = [];
   for (const row of turns) {
     const verdict = classifyTurnOutcome({
       finalText: row.content,
       parts: parseParts(row.parts),
       outputTokens: row.outputTokens ?? null
     });
+    toolCalls += verdict.toolCalls;
+    if (verdict.toolCalls > 0) turnsWithToolCalls += 1;
+    if (verdict.partsReadable) toolReadableTurns += 1;
+    else {
+      opaquePartsTurns += 1;
+      for (const t of verdict.opaquePartTypes) opaqueTypes.add(t);
+    }
+    if (verdict.unreadable) {
+      unreadableTurns += 1;
+      continue;
+    }
     if (verdict.healthy) continue;
     unhealthyTurns += 1;
     for (const reason of verdict.reasons) {
@@ -316,8 +433,13 @@ async function sweepSilentFailures(options) {
         if (malformedSamples.length < 3) malformedSamples.push(reason);
       }
       if (reason.kind === "tool_call_no_effect") toolCallsWithoutEffect += 1;
+      if (reason.kind === "tool_call_rejected") {
+        rejectedToolCalls += 1;
+        if (rejectedSamples.length < 3) rejectedSamples.push(reason);
+      }
     }
   }
+  const readableTurns = turns.length - unreadableTurns;
   if (malformedToolCalls > 0) {
     alerts.push({
       product: options.product,
@@ -329,8 +451,19 @@ async function sweepSilentFailures(options) {
       at: now
     });
   }
-  if (turns.length >= minTurnsForRate) {
-    const rate = emptyCompletions / turns.length;
+  if (rejectedToolCalls > 0) {
+    alerts.push({
+      product: options.product,
+      severity: "critical",
+      key: `sweep:${options.product}:tool_call_rejected`,
+      title: `${options.product}: ${rejectedToolCalls} tool call(s) were REJECTED but settled as completed \u2014 deliverables silently dropped`,
+      details: rejectedSamples.map(describeReason),
+      data: { rejectedToolCalls, turnsJudged: readableTurns },
+      at: now
+    });
+  }
+  if (readableTurns >= minTurnsForRate) {
+    const rate = emptyCompletions / readableTurns;
     if (rate > emptyRateThreshold) {
       alerts.push({
         product: options.product,
@@ -338,14 +471,53 @@ async function sweepSilentFailures(options) {
         key: `sweep:${options.product}:empty_completion_rate`,
         title: `${options.product}: ${(rate * 100).toFixed(1)}% of turns completed with no output`,
         details: [
-          `${emptyCompletions} of ${turns.length} settled turns delivered nothing`,
+          `${emptyCompletions} of ${readableTurns} readable settled turns delivered nothing`,
           `threshold ${(emptyRateThreshold * 100).toFixed(1)}%`
         ],
-        data: { emptyCompletions, turnsJudged: turns.length, rate },
+        data: { emptyCompletions, turnsJudged: readableTurns, rate },
         at: now
       });
     }
   }
+  if (options.expectsToolCalls && toolReadableTurns >= minTurnsForToolSurface && toolCalls === 0) {
+    alerts.push({
+      product: options.product,
+      severity: "critical",
+      key: `sweep:${options.product}:dead_tool_surface`,
+      title: `${options.product}: ZERO tool calls across ${toolReadableTurns} turns \u2014 the tool surface is dead`,
+      details: [
+        `${toolReadableTurns} assistant turns with readable parts in the lookback, none of which called a tool`,
+        "the product declares its deliverable comes from tool calls, so it has answered without doing anything",
+        ...opaquePartsTurns > 0 ? [`${opaquePartsTurns} further turn(s) had unreadable parts and were not judged`] : []
+      ],
+      data: {
+        turnsJudged: toolReadableTurns,
+        toolCalls: 0,
+        turnsWithToolCalls: 0,
+        turnsNotJudged: opaquePartsTurns
+      },
+      at: now
+    });
+  }
+  if (opaquePartsTurns > 0 && opaquePartsTurns >= turns.length * blindThreshold) {
+    alerts.push({
+      product: options.product,
+      severity: "warning",
+      key: `sweep:${options.product}:detector_blind`,
+      title: `${options.product}: ${opaquePartsTurns} of ${turns.length} turns have unreadable parts \u2014 this sweep cannot certify them`,
+      details: [
+        `uninterpretable part types: ${[...opaqueTypes].join(", ") || "(none named)"}`,
+        "these rows are excluded from every verdict above; treat them as UNMEASURED, not healthy"
+      ],
+      data: {
+        opaquePartsTurns,
+        unreadableTurns,
+        turnsSeen: turns.length,
+        opaqueTypes: [...opaqueTypes]
+      },
+      at: now
+    });
+  }
   for (const alert of alerts) await options.sink.deliver(alert);
   return {
     product: options.product,
@@ -357,13 +529,20 @@ async function sweepSilentFailures(options) {
     emptyCompletions,
     malformedToolCalls,
     toolCallsWithoutEffect,
+    rejectedToolCalls,
+    turnsWithToolCalls,
+    toolCalls,
+    unreadableTurns,
+    opaquePartsTurns,
     alerts
   };
 }
 function createD1TurnHealthSource(db, options = {}) {
   const message = safeIdentifier(options.messageTable ?? "message");
   const thread = safeIdentifier(options.threadTable ?? "thread");
-  const errorPrefixes = [...options.errorReplyPrefixes ?? SHELL_ERROR_REPLY_PREFIXES];
+  const errorPrefixes = [...options.errorReplyPrefixes ?? SHELL_ERROR_REPLY_PREFIXES].map(
+    (p) => p.slice(0, D1_MAX_LIKE_PATTERN_LENGTH - 1)
+  );
   return {
     async findUnansweredThreads({ minAgeMs, maxAgeMs, now }) {
       const cutoffSeconds = Math.floor((now - minAgeMs) / 1e3);
@@ -428,6 +607,7 @@ export {
   createGuardedAlertSink,
   createMemoryThrottleStore,
   createMultiAlertSink,
+  createSlackBotAlertSink,
   createThrottledAlertSink,
   createTurnHealthLifecycle,
   createWebhookAlertSink,