agent-inspect 4.3.0 → 4.4.0

package/packages/cli/dist/index.cjs

@@ -306,6 +306,9 @@ function isTraceEvent(value) {
     case "step_completed": {
       return typeof value.runId === "string" && typeof value.stepId === "string" && (value.status === "success" || value.status === "error") && typeof value.endTime === "number" && typeof value.durationMs === "number";
     }
+    case "outcome_observed": {
+      return typeof value.runId === "string" && typeof value.outcomeId === "string" && typeof value.name === "string" && typeof value.expectation === "string" && (value.status === "passed" || value.status === "failed" || value.status === "unknown" || value.status === "skipped") && typeof value.observedAt === "number";
+    }
     default:
       return false;
   }
@@ -436,7 +439,8 @@ var init_persisted_inspect_event = __esm({
       "RESULT",
       "ERROR",
       "LOGIC",
-      "LOG"
+      "LOG",
+      "OUTCOME"
     ];
     ATTRIBUTION_CONFIDENCES = [
       "explicit",
@@ -634,6 +638,32 @@ function fromLegacyStepCompleted(event) {
   if (error) out.error = error;
   return out;
 }
+function fromLegacyOutcomeObserved(event) {
+  const attrs = event.attributes ?? {};
+  const observedAtRaw = attrs.observedAt;
+  const observedAt = typeof observedAtRaw === "string" ? Date.parse(observedAtRaw) : typeof observedAtRaw === "number" && Number.isFinite(observedAtRaw) ? observedAtRaw : resolveTimes(event).timestamp;
+  const status = attrs.outcomeStatus;
+  const out = {
+    schemaVersion: "0.1",
+    event: "outcome_observed",
+    timestamp: observedAt,
+    runId: event.runId,
+    outcomeId: typeof attrs.outcomeId === "string" ? attrs.outcomeId : event.eventId,
+    name: event.name,
+    expectation: typeof attrs.expectation === "string" ? attrs.expectation : event.name,
+    status: status === "passed" || status === "failed" || status === "unknown" || status === "skipped" ? status : "unknown",
+    observedAt
+  };
+  if (event.parentId !== void 0) out.parentId = event.parentId;
+  if (typeof attrs.method === "string") out.method = attrs.method;
+  if (attrs.actual !== void 0) out.actual = attrs.actual;
+  if (event.outputSummary !== void 0) out.actual = event.outputSummary;
+  if (attrs.evidence !== void 0) out.evidence = attrs.evidence;
+  return out;
+}
+function fromNativeOutcome(event) {
+  return [fromLegacyOutcomeObserved(event)];
+}
 function fromNativeRun(event) {
   const { timestamp, startTime, endTime } = resolveTimes(event);
   const runStatus = mapPersistedStatusToRunStatus(event.status);
@@ -721,9 +751,13 @@ function persistedInspectEventToTraceEvents(event) {
   if (legacyEvent === "run_completed") return [fromLegacyRunCompleted(event)];
   if (legacyEvent === "step_started") return [fromLegacyStepStarted(event)];
   if (legacyEvent === "step_completed") return [fromLegacyStepCompleted(event)];
+  if (legacyEvent === "outcome_observed") return [fromLegacyOutcomeObserved(event)];
   if (event.kind === "RUN") {
     return fromNativeRun(event);
   }
+  if (event.kind === "OUTCOME") {
+    return fromNativeOutcome(event);
+  }
   return fromNativeStep(event);
 }
 function persistedInspectEventsToTraceEvents(events, options) {
@@ -1071,6 +1105,9 @@ function validateEvent(event) {
     case "step_completed": {
       return nonEmptyString(event.runId) && nonEmptyString(event.stepId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
     }
+    case "outcome_observed": {
+      return nonEmptyString(event.runId) && nonEmptyString(event.outcomeId) && nonEmptyString(event.name) && nonEmptyString(event.expectation) && (event.status === "passed" || event.status === "failed" || event.status === "unknown" || event.status === "skipped") && finiteNumber(event.observedAt);
+    }
     default:
       return false;
   }
@@ -1119,10 +1156,178 @@ var init_inspector_runtime = __esm({
   }
 });
 
+// packages/core/src/outcomes/types.ts
+var OBSERVED_OUTCOME_STATUSES, OUTCOME_ATTRIBUTE_STATUS_KEY, OUTCOME_ATTRIBUTE_EXPECTATION_KEY, OUTCOME_ATTRIBUTE_METHOD_KEY, OUTCOME_ATTRIBUTE_OBSERVED_AT_KEY, OUTCOME_LEGACY_EVENT;
+var init_types2 = __esm({
+  "packages/core/src/outcomes/types.ts"() {
+    OBSERVED_OUTCOME_STATUSES = [
+      "passed",
+      "failed",
+      "unknown",
+      "skipped"
+    ];
+    OUTCOME_ATTRIBUTE_STATUS_KEY = "outcomeStatus";
+    OUTCOME_ATTRIBUTE_EXPECTATION_KEY = "expectation";
+    OUTCOME_ATTRIBUTE_METHOD_KEY = "method";
+    OUTCOME_ATTRIBUTE_OBSERVED_AT_KEY = "observedAt";
+    OUTCOME_LEGACY_EVENT = "outcome_observed";
+  }
+});
+
+// packages/core/src/outcomes/validate.ts
+function parseObservedOutcomeStatus(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (OBSERVED_OUTCOME_STATUSES.includes(trimmed)) {
+    return trimmed;
+  }
+  throw new Error(
+    `Unsupported observation status "${value}". Use passed, failed, unknown, or skipped.`
+  );
+}
+var init_validate = __esm({
+  "packages/core/src/outcomes/validate.ts"() {
+    init_trace_event_safety();
+    init_types2();
+  }
+});
+
+// packages/core/src/outcomes/extract.ts
+function isOutcomeStatus(value) {
+  return value === "passed" || value === "failed" || value === "unknown" || value === "skipped";
+}
+function parseMethod(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  return value;
+}
+function fromOutcomeObservedEvent(event) {
+  return {
+    outcomeId: event.outcomeId,
+    runId: event.runId,
+    ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+    name: event.name,
+    expectation: event.expectation,
+    status: event.status,
+    ...event.method !== void 0 ? { method: event.method } : {},
+    ...event.actual !== void 0 ? { actual: event.actual } : {},
+    ...event.evidence !== void 0 ? { evidence: event.evidence } : {},
+    observedAt: event.observedAt
+  };
+}
+function fromPersistedOutcome(event) {
+  if (event.kind !== "OUTCOME") return void 0;
+  const attrs = event.attributes ?? {};
+  const statusRaw = attrs[OUTCOME_ATTRIBUTE_STATUS_KEY];
+  if (!isOutcomeStatus(statusRaw)) return void 0;
+  const expectation = typeof attrs[OUTCOME_ATTRIBUTE_EXPECTATION_KEY] === "string" ? attrs[OUTCOME_ATTRIBUTE_EXPECTATION_KEY] : event.name;
+  const observedAtRaw = attrs[OUTCOME_ATTRIBUTE_OBSERVED_AT_KEY];
+  const observedAt = typeof observedAtRaw === "string" ? Date.parse(observedAtRaw) : typeof observedAtRaw === "number" && Number.isFinite(observedAtRaw) ? observedAtRaw : Date.parse(event.timestamp);
+  return {
+    outcomeId: event.eventId,
+    runId: event.runId,
+    ...event.parentId !== void 0 ? { parentId: event.parentId } : {},
+    name: event.name,
+    expectation,
+    status: statusRaw,
+    ...parseMethod(attrs[OUTCOME_ATTRIBUTE_METHOD_KEY]) !== void 0 ? { method: parseMethod(attrs[OUTCOME_ATTRIBUTE_METHOD_KEY]) } : {},
+    ...event.outputSummary !== void 0 ? { actual: event.outputSummary } : {},
+    ...attrs.evidence !== void 0 ? { evidence: attrs.evidence } : {},
+    observedAt: Number.isFinite(observedAt) ? observedAt : Date.parse(event.timestamp)
+  };
+}
+function extractOutcomesFromTraceEvents(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.event === OUTCOME_LEGACY_EVENT) {
+      out.push(fromOutcomeObservedEvent(event));
+    }
+  }
+  return out.sort((a, b) => a.observedAt - b.observedAt || a.name.localeCompare(b.name));
+}
+function extractOutcomesFromPersistedEvents(events) {
+  const out = [];
+  for (const event of events) {
+    const outcome = fromPersistedOutcome(event);
+    if (outcome) out.push(outcome);
+  }
+  return out.sort((a, b) => a.observedAt - b.observedAt || a.name.localeCompare(b.name));
+}
+function summarizeObservedOutcomes(outcomes) {
+  const summary = {
+    total: outcomes.length,
+    passed: 0,
+    failed: 0,
+    unknown: 0,
+    skipped: 0,
+    outcomes: [...outcomes]
+  };
+  for (const outcome of outcomes) {
+    summary[outcome.status] += 1;
+  }
+  return summary;
+}
+function outcomesMatchingStatus(outcomes, statuses) {
+  const set = new Set(statuses);
+  return outcomes.filter((outcome) => set.has(outcome.status));
+}
+function parseObservationFilter(value) {
+  if (value === void 0 || value.trim() === "") return void 0;
+  return parseObservedOutcomeStatus(value);
+}
+var init_extract = __esm({
+  "packages/core/src/outcomes/extract.ts"() {
+    init_types2();
+    init_validate();
+  }
+});
+
+// packages/core/src/outcomes/render.ts
+function renderObservedOutcomesMarkdown(summary) {
+  if (summary.total === 0) {
+    return "No observed outcomes recorded for this run.";
+  }
+  const lines = [
+    `Total: ${summary.total} (passed ${summary.passed}, failed ${summary.failed}, unknown ${summary.unknown}, skipped ${summary.skipped})`,
+    "",
+    "| Name | Status | Expectation | Method |",
+    "| --- | --- | --- | --- |"
+  ];
+  for (const outcome of summary.outcomes) {
+    lines.push(
+      `| ${outcome.name} | ${outcome.status} | ${outcome.expectation.replace(/\|/g, "\\|")} | ${outcome.method ?? "-"} |`
+    );
+  }
+  return lines.join("\n");
+}
+function renderObservedOutcomesHtml(summary) {
+  if (summary.total === 0) {
+    return "<p>No observed outcomes recorded for this run.</p>";
+  }
+  const rows = summary.outcomes.map((outcome) => {
+    const esc = (v) => v.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    return `<tr><td>${esc(outcome.name)}</td><td>${esc(outcome.status)}</td><td>${esc(outcome.expectation)}</td><td>${esc(outcome.method ?? "-")}</td></tr>`;
+  }).join("");
+  return `<p>Total: ${summary.total} (passed ${summary.passed}, failed ${summary.failed}, unknown ${summary.unknown}, skipped ${summary.skipped})</p><table><thead><tr><th>Name</th><th>Status</th><th>Expectation</th><th>Method</th></tr></thead><tbody>${rows}</tbody></table>`;
+}
+var init_render = __esm({
+  "packages/core/src/outcomes/render.ts"() {
+  }
+});
+
+// packages/core/src/outcomes/index.ts
+var init_outcomes = __esm({
+  "packages/core/src/outcomes/index.ts"() {
+    init_types2();
+    init_extract();
+    init_validate();
+    init_render();
+  }
+});
+
 // packages/core/src/inspector.ts
 var init_inspector = __esm({
   "packages/core/src/inspector.ts"() {
     init_inspector_runtime();
+    init_outcomes();
     init_trace_event_safety();
     init_utils();
   }
@@ -2737,8 +2942,9 @@ async function searchTraces(metas, options) {
   }
   const limit = options.limit ?? 50;
   const sessionId = options.session?.trim();
+  const observationStatus = parseObservationFilter(options.observation);
   const hasContentFilter = Boolean(
-    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter
+    options.status || stepTypeFilter || nameQuery || toolQuery || durationFilter || observationStatus
   );
   const results = [];
   const sessionLabel = sessionId && sessionId !== "" ? sessionId : void 0;
@@ -2783,6 +2989,22 @@ async function searchTraces(metas, options) {
       statusFilter: options.status
     });
     results.push(...stepMatches);
+    if (observationStatus) {
+      const outcomes = extractOutcomesFromTraceEvents(events);
+      const matched = outcomes.filter((outcome) => outcome.status === observationStatus);
+      for (const outcome of matched) {
+        results.push({
+          runId: m.runId,
+          runName: m.name,
+          runStatus: m.status,
+          stepName: outcome.name,
+          timestamp: outcome.observedAt,
+          matchReason: `observation status=${outcome.status}`,
+          matchedFields: ["outcome.status", "outcome.name"],
+          filePath: m.filePath
+        });
+      }
+    }
   }
   results.sort((a, b) => {
     const ta = a.timestamp ?? 0;
@@ -2898,6 +3120,7 @@ var init_search = __esm({
     init_trace_filter();
     init_storage();
     init_duration();
+    init_outcomes();
   }
 });
 
@@ -3189,9 +3412,10 @@ function buildActivitySummary(index, options = {}) {
     entries
   };
 }
-function renderActivitySummaryHuman(summary) {
+function renderActivitySummaryHuman(summary, options) {
   const lines = [];
-  const todayStart = /* @__PURE__ */ new Date();
+  const nowMs = Date.now();
+  const todayStart = new Date(nowMs);
   todayStart.setHours(0, 0, 0, 0);
   const todayMs = todayStart.getTime();
   const today = summary.entries.filter(
@@ -3217,7 +3441,7 @@ var init_activity = __esm({
 });
 
 // packages/core/src/sessions/types.ts
-var init_types2 = __esm({
+var init_types3 = __esm({
   "packages/core/src/sessions/types.ts"() {
   }
 });
@@ -3675,7 +3899,7 @@ var init_sessions = __esm({
     init_metadata();
     init_status();
     init_activity();
-    init_types2();
+    init_types3();
     init_load();
     init_scope();
     init_cohort();
@@ -4000,7 +4224,7 @@ var init_advanced = __esm({
 
 // packages/index-sqlite/src/types.ts
 var INDEX_SCHEMA_VERSION, INDEX_DB_FILENAME;
-var init_types3 = __esm({
+var init_types4 = __esm({
   "packages/index-sqlite/src/types.ts"() {
     INDEX_SCHEMA_VERSION = "1";
     INDEX_DB_FILENAME = "trace-index.sqlite";
@@ -4778,7 +5002,7 @@ function metaDefaults(sourceDir, fileCount) {
 var INDEX_SCHEMA_SQL, DERIVE_SESSIONS_SQL, META_KEYS;
 var init_schema = __esm({
   "packages/index-sqlite/src/schema.ts"() {
-    init_types3();
+    init_types4();
     INDEX_SCHEMA_SQL = `
 DROP TABLE IF EXISTS meta;
 DROP TABLE IF EXISTS errors;
@@ -5031,7 +5255,7 @@ var init_builder = __esm({
     import_better_sqlite3 = __toESM(require_lib());
     init_advanced();
     init_schema();
-    init_types3();
+    init_types4();
     DEFAULT_MAX_RUNS = 1e4;
     rebuildIndex = buildIndex;
   }
@@ -5181,14 +5405,14 @@ __export(src_exports, {
 });
 var init_src = __esm({
   "packages/index-sqlite/src/index.ts"() {
-    init_types3();
+    init_types4();
     init_builder();
     init_query();
   }
 });
 
 // package.json
-var version = "4.3.0";
+var version = "4.4.0";
 
 // packages/cli/src/list.ts
 init_advanced();
@@ -5548,6 +5772,8 @@ function nodeIdForEvent(event) {
     case "step_started":
     case "step_completed":
       return event.stepId;
+    case "outcome_observed":
+      return event.outcomeId;
     default:
       return "unknown";
   }
@@ -5731,6 +5957,39 @@ function traceEventToPersistedInspectEvent(event, options) {
         error
       };
     }
+    case "outcome_observed": {
+      const tsObserved = toIsoTimestamp(event.observedAt);
+      const attributes = compactAttributes({
+        legacyEvent: "outcome_observed",
+        outcomeId: event.outcomeId,
+        outcomeStatus: event.status,
+        expectation: event.expectation,
+        method: event.method,
+        actual: event.actual,
+        evidence: event.evidence,
+        observedAt: tsObserved.iso,
+        invalidTimestamp: tsMain.invalidTimestamp || tsObserved.invalidTimestamp ? true : void 0
+      });
+      const out = {
+        schemaVersion: "0.2",
+        eventId,
+        runId: event.runId,
+        kind: "OUTCOME",
+        name: event.name,
+        status: event.status === "failed" ? "error" : "ok",
+        timestamp: tsMain.iso,
+        confidence: "explicit",
+        source,
+        attributes
+      };
+      if (event.parentId !== void 0) {
+        out.parentId = event.parentId;
+      }
+      if (event.actual !== void 0) {
+        out.outputSummary = event.actual;
+      }
+      return out;
+    }
     default: {
       const _exhaustive = event;
       throw new Error(`Unsupported trace event: ${_exhaustive.event}`);
@@ -6467,7 +6726,7 @@ function sanitizeOpenInferenceAttributes(attributes, pathPrefix) {
 function mapOpenInferenceKind(span, attributes, pathPrefix) {
   const warnings = [];
   const agentInspectKind = attributes["agent_inspect.kind"];
-  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG") {
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
     return { kind: agentInspectKind, warnings };
   }
   const rawKind = readStringField(span, ["kind", "span_kind", "spanKind"]) ?? (typeof attributes["openinference.span.kind"] === "string" ? attributes["openinference.span.kind"] : void 0);
@@ -6988,7 +7247,7 @@ function mapOtlpStatus(status) {
 function readOtlpKind(attributes, pathPrefix) {
   const warnings = [];
   const agentInspectKind = attributes["agent_inspect.kind"];
-  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG") {
+  if (agentInspectKind === "RUN" || agentInspectKind === "AGENT" || agentInspectKind === "LLM" || agentInspectKind === "TOOL" || agentInspectKind === "CHAIN" || agentInspectKind === "RETRIEVER" || agentInspectKind === "DECISION" || agentInspectKind === "RESULT" || agentInspectKind === "ERROR" || agentInspectKind === "LOGIC" || agentInspectKind === "LOG" || agentInspectKind === "OUTCOME") {
     return { kind: agentInspectKind, warnings };
   }
   const operation = attributes["gen_ai.operation.name"];
@@ -9127,6 +9386,40 @@ function redactTraceEventsForReport(events, options) {
             )
           } : {}
         };
+      case "outcome_observed": {
+        const actualAttrs = event.actual !== void 0 ? redactEventAttributes(
+          { value: event.actual },
+          redactor,
+          maxMetadataValueLength,
+          maxPreviewLength
+        ) : void 0;
+        const redactedActual = actualAttrs !== void 0 && "value" in actualAttrs ? actualAttrs.value : void 0;
+        const redactedEvidence = event.evidence !== void 0 ? redactEventAttributes(
+          isRecord12(event.evidence) ? event.evidence : { value: event.evidence },
+          redactor,
+          maxMetadataValueLength,
+          maxPreviewLength
+        ) : void 0;
+        return {
+          ...event,
+          name: truncateStringForProfile(
+            event.name,
+            "name",
+            maxMetadataValueLength,
+            maxPreviewLength
+          ),
+          expectation: truncateStringForProfile(
+            event.expectation,
+            "expectation",
+            maxMetadataValueLength,
+            maxPreviewLength
+          ),
+          ...redactedActual !== void 0 ? { actual: redactedActual } : {},
+          ...redactedEvidence !== void 0 ? { evidence: redactedEvidence } : {}
+        };
+      }
+      default:
+        return event;
     }
   });
 }
@@ -9265,7 +9558,8 @@ function zeroKinds() {
     RESULT: 0,
     ERROR: 0,
     LOGIC: 0,
-    LOG: 0
+    LOG: 0,
+    OUTCOME: 0
   };
 }
 
@@ -10040,6 +10334,7 @@ function validateExport(result) {
 // packages/core/src/report.ts
 init_timeline();
 init_what();
+init_outcomes();
 function resolveTree(events, profile) {
   const tree = manualTraceEventsToRunTree(events);
   return profile === "local" ? tree : redactRunTreeForExport(tree, { redactionProfile: profile });
@@ -10070,9 +10365,34 @@ footer{margin-top:2rem;font-size:0.85rem;color:#555}
 `.trim();
 function buildRunReport(events, options) {
   const profile = options.redactionProfile ?? "local";
+  const section = options.section ?? "all";
   const safeEvents = redactTraceEventsForReport(events, {
     redactionProfile: profile
   });
+  const outcomes = summarizeObservedOutcomes(
+    extractOutcomesFromTraceEvents(safeEvents)
+  );
+  const observationsMarkdown = renderObservedOutcomesMarkdown(outcomes);
+  const observationsHtml = renderObservedOutcomesHtml(outcomes);
+  if (section === "observations") {
+    if (options.format === "markdown") {
+      return {
+        format: "markdown",
+        content: `## Observed outcomes
+
+${observationsMarkdown}
+`,
+        contentType: "text/markdown",
+        fileExtension: ".md"
+      };
+    }
+    return {
+      format: "html",
+      content: `<!doctype html><html lang="en"><head><meta charset="utf-8"/><title>Observed outcomes</title><style>${REPORT_HTML_CSS}</style></head><body><h1>Observed outcomes</h1>${observationsHtml}</body></html>`,
+      contentType: "text/html",
+      fileExtension: ".html"
+    };
+  }
   const whatSummary = buildRunWhatSummary(safeEvents);
   const whatText = renderRunWhat(whatSummary, {
     correlation: options.correlation !== false
@@ -10106,6 +10426,10 @@ function buildRunReport(events, options) {
       "```text",
       timelineText,
       "```",
+      "",
+      "## Observed outcomes",
+      "",
+      observationsMarkdown,
       ""
     ];
     if (tail2) {
@@ -10149,6 +10473,7 @@ function buildRunReport(events, options) {
 <p class="note">Generated locally by AgentInspect. Review for sensitive data before sharing.</p>
 <section class="what"><h2>What happened</h2><pre>${escapeHtml(whatText)}</pre></section>
 <section class="timeline"><h2>Timeline</h2><pre>${escapeHtml(timelineText)}</pre></section>
+<section class="observations"><h2>Observed outcomes</h2>${observationsHtml}</section>
 ${treeSection || '<section class="tree"><h2>Execution tree</h2><p>No steps recorded.</p></section>'}
 ${errorsSection}
 ${attrsSection}
@@ -11007,7 +11332,8 @@ async function searchCommand(options = {}) {
       duration: options.duration,
       limit: parseLimit2(options.limit),
       ...sessionId ? { session: sessionId } : {},
-      ...options.correlateGroup ? { correlateGroup: true } : {}
+      ...options.correlateGroup ? { correlateGroup: true } : {},
+      ...options.observation ? { observation: options.observation } : {}
     });
     if (options.json) {
       console.log(JSON.stringify(results, null, 2));
@@ -11534,7 +11860,8 @@ async function reportCommand(runId, options = {}) {
     includeAttributes: options.includeAttributes === true,
     includeErrors: options.noErrors !== true,
     redactionProfile,
-    correlation: !options.noCorrelation
+    correlation: !options.noCorrelation,
+    ...options.section ? { section: options.section } : {}
   });
   const outPath = options.output !== void 0 && options.output.trim() !== "" ? path19__default.default.resolve(options.output.trim()) : void 0;
   if (outPath !== void 0) {
@@ -12542,6 +12869,7 @@ async function migrateCommand(input3, options = {}) {
 init_advanced();
 
 // packages/core/src/checks/index.ts
+init_outcomes();
 var SEVERITY_RANK = {
   error: 0,
   warning: 1,
@@ -13852,6 +14180,40 @@ function createBaselineRegressionRule(options) {
     }
   };
 }
+function createObservedOutcomeRule(options = {}) {
+  const failOn = options.failOn ?? ["failed"];
+  return {
+    id: "outcome.status",
+    category: "run",
+    defaultSeverity: "error",
+    evaluate(context) {
+      const outcomes = extractOutcomesFromPersistedEvents(context.events);
+      const matching = outcomesMatchingStatus(outcomes, failOn);
+      if (matching.length === 0) return [];
+      return [
+        failFinding(
+          "outcome.status",
+          `Observed outcome count ${matching.length} matched [${failOn.join(", ")}].`,
+          matching.map((outcome) => ({
+            runId: outcome.runId,
+            eventId: outcome.outcomeId,
+            ...outcome.parentId !== void 0 ? { parentId: outcome.parentId } : {},
+            kind: "OUTCOME",
+            name: outcome.name,
+            status: outcome.status,
+            path: `outcome.${outcome.name}`
+          })),
+          { failOn },
+          matching.map((outcome) => ({
+            name: outcome.name,
+            status: outcome.status,
+            expectation: outcome.expectation
+          }))
+        )
+      ];
+    }
+  };
+}
 function runTraceChecks(input3, options = {}) {
   const selected = resolveSelectedRun(input3, options.runId);
   if (selected.diagnostics.length > 0) {
@@ -14623,6 +14985,22 @@ function buildRules(config, options) {
   if (options.detectStalls) {
     rules.push(createStallDetectionRule({ requireEndedAt: true }));
   }
+  if (options.failOnObservation !== void 0 && options.failOnObservation.trim() !== "") {
+    try {
+      const statuses = options.failOnObservation.split(",").map((value) => value.trim()).filter((value) => value !== "").map((value) => {
+        if (value === "passed" || value === "failed" || value === "unknown" || value === "skipped") {
+          return value;
+        }
+        throw new Error(`unsupported status "${value}"`);
+      });
+      rules.push(createObservedOutcomeRule({ failOn: statuses }));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      diagnostics.push(
+        diagnostic2("AI_CHECK_INVALID_ARGUMENTS", `--fail-on-observation: ${message}`)
+      );
+    }
+  }
   if (run.maxDepth !== void 0) {
     rules.push(createRunDepthRule({ maxDepth: run.maxDepth }));
   }
@@ -18762,7 +19140,10 @@ function createCliProgram() {
   ]).option("--max-total-tokens <number>", "add llm.usage with a max total-token budget").option(
     "--max-step-duration <duration>",
     "add run.maxStepDuration (e.g. 30s, 5m)"
-  ).option("--require-completed", "add run.requireCompleted").option("--detect-stalls", "add run.stall for running or incomplete events").option("--session <id>", "check all runs in a workflow session (requires --dir)").option("--group <id>", "check all runs sharing a groupId (requires --dir)").option(
+  ).option("--require-completed", "add run.requireCompleted").option("--detect-stalls", "add run.stall for running or incomplete events").option(
+    "--fail-on-observation <status>",
+    "fail when observed outcomes match status (passed, failed, unknown, skipped; comma-separated)"
+  ).option("--session <id>", "check all runs in a workflow session (requires --dir)").option("--group <id>", "check all runs sharing a groupId (requires --dir)").option(
     "--correlate-group",
     "when using --session, also match synthetic group: session keys"
   ).option(
@@ -18883,6 +19264,9 @@ function createCliProgram() {
       "unknown"
     ])
   ).option("--kind <kind>", "filter by step kind/type (llm, tool, logic, \u2026)").option("--type <type>", "alias for --kind on manual trace step type").option("--name <query>", "substring match on run or step name").option("--tool <query>", "substring match on tool step name or metadata.toolName").option(
+    "--observation <status>",
+    "filter by observed outcome status (passed, failed, unknown, skipped)"
+  ).option(
     "--duration <expr>",
     "duration filter on run or step (e.g. >5s, >=500ms)"
   ).option("--limit <number>", "max results (default 50)").option("--session <id>", "limit search to one workflow session").option(
@@ -18929,6 +19313,14 @@ function createCliProgram() {
       "html"
     ])
   ).option("-o, --output <path>", "write report to file (creates parent dirs)").option("--json", "emit JSON wrapper (includes content when writing to stdout)").option("--include-attributes", "include bounded step attributes in tree section").option("--no-errors", "omit error details from tree section").option("--no-correlation", "omit correlation metadata from what section").addOption(
+    new commander.Option("--section <section>", "report section (default: all)").choices([
+      "all",
+      "observations",
+      "what",
+      "timeline",
+      "tree"
+    ])
+  ).addOption(
     new commander.Option(
       "--redaction-profile <profile>",
       "redaction profile for entire report: local, share, strict (default: local)"