opencandle 0.11.0 → 0.11.1

package/src/runtime/session-coordinator.ts

@@ -4,6 +4,16 @@ import type {
   ExtensionContext,
   SessionEntry,
 } from "@earendil-works/pi-coding-agent";
+import { isAnalystSplit, parseAnalystOutput, parseDebateOutput } from "../analysts/contracts.js";
+import { buildAnalystVoteTallyBlock } from "../analysts/orchestrator.js";
+import type { FreshnessStamp } from "../infra/freshness.js";
+import { MarketStateService } from "../market-state/service.js";
+import {
+  formatJsonSummary,
+  formatLatestReportSummary,
+  formatPortfolioSummary,
+  formatWatchlistSummary,
+} from "../market-state/summaries.js";
 import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/index.js";
 
 /**
@@ -15,7 +25,6 @@ import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/in
 type ReadonlySessionManager = ExtensionContext["sessionManager"];
 
 import type Database from "better-sqlite3";
-import { MarketStateService } from "../market-state/service.js";
 import type { FilteredMemoryEntry } from "../memory/manager.js";
 import { MemoryManager } from "../memory/manager.js";
 import { extractPreferences } from "../memory/preference-extractor.js";
@@ -26,12 +35,21 @@ import type { SymbolValidationCache } from "../prompts/symbol-preflight.js";
 import type { RouterRouteKind } from "../routing/router-types.js";
 import type { ResolvedTurnContext } from "../routing/turn-context.js";
 import { getAddonToolDescriptions } from "../tool-kit.js";
+import type { EvidenceRecord } from "./evidence.js";
+import { collectToolNumbers, extractNumericClaims } from "./numeric-claims.js";
 import type { WorkflowDefinition } from "./prompt-step.js";
-import { promptStepOutput, toStepDefinitions } from "./prompt-step.js";
+import {
+  captureToolEvidence,
+  extractAssistantText,
+  promptStepOutput,
+  toStepDefinitions,
+} from "./prompt-step.js";
 import { ProviderTracker } from "./provider-tracker.js";
 import { clearRunContext, type RunContextToken, setRunContext } from "./run-context.js";
+import { checkNumberMatch } from "./validation.js";
 import { WorkflowEventLogger } from "./workflow-events.js";
 import { WorkflowRunner } from "./workflow-runner.js";
+import type { AnalystOutput, StepOutput, WorkflowRun } from "./workflow-types.js";
 
 const PROMPT_SETTLE_POLL_MS = 25;
 const IMMEDIATE_IDLE_GRACE_MS = 100;
@@ -41,6 +59,12 @@ interface ActiveWorkflowRunRef {
   contextToken: RunContextToken;
 }
 
+interface ActiveStepCapture {
+  evidence: EvidenceRecord[];
+  pendingTools: Map<string, { tool: string; args: unknown; startedAt: string }>;
+  rawText: string;
+}
+
 function parseMaybeJson(raw: unknown): Record<string, unknown> | undefined {
   if (typeof raw !== "string" || raw.length === 0) return undefined;
   try {
@@ -59,6 +83,7 @@ type QueueContext =
       isIdle(): boolean;
       hasPendingMessages?(): boolean;
       ui?: { notify(message: string, level?: string): void };
+      sessionManager?: { getEntries(): SessionEntry[] };
     };
 
 function hasPendingMessages(ctx: QueueContext): boolean {
@@ -69,6 +94,11 @@ function isReadyForNextPrompt(ctx: QueueContext): boolean {
   return ctx.isIdle() && !hasPendingMessages(ctx);
 }
 
+function readSessionEntries(ctx: QueueContext): SessionEntry[] {
+  const manager = "sessionManager" in ctx ? ctx.sessionManager : undefined;
+  return manager?.getEntries?.() ?? [];
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -119,6 +149,8 @@ export class SessionCoordinator {
   private providerTracker: ProviderTracker;
   private activeWorkflowRunRef: ActiveWorkflowRunRef | null = null;
   private activeWorkflowType: string | undefined;
+  private activeStepCapture: ActiveStepCapture | null = null;
+  private workflowEventCaptureInstalled = false;
   private tickerValidationCache: SymbolValidationCache = new Map();
   private sessionId = "unknown";
 
@@ -416,6 +448,7 @@ export class SessionCoordinator {
     firstPromptMode: "send" | "transform",
   ): void {
     if (definition.steps.length === 0) return;
+    this.installWorkflowEventCapture(pi);
 
     const runner = this.runner;
     if (this.activeWorkflowRunRef) {
@@ -444,26 +477,101 @@ export class SessionCoordinator {
     // Start the runner in the background for state tracking
     const stepDefs = toStepDefinitions(definition.steps);
     void runner
-      .start(definition.workflowType, stepDefs, async (step, stepIndex) => {
-        // First step was already sent above — just wait for settlement
-        if (stepIndex > 0) {
-          const settled = await waitForPromptSettlement(ctx, () => runRef.active);
-          if (!settled || !runRef.active) {
-            throw new Error("run_cancelled");
+      .start(
+        definition.workflowType,
+        stepDefs,
+        async (step, stepIndex, _priorEvidence, context) => {
+          let entriesBeforeStep = readSessionEntries(ctx).length;
+          const eventCapture = this.startStepCapture();
+
+          // First step was already sent above — later steps are sent here.
+          if (stepIndex > 0) {
+            const settled = await waitForPromptSettlement(ctx, () => runRef.active);
+            if (!settled || !runRef.active) {
+              throw new Error("run_cancelled");
+            }
+            if (shouldSkipRebuttal(runner.getActiveRun(), step.stepType)) {
+              this.appendWorkflowEvent(pi, "step_skipped", {
+                stepType: step.stepType,
+                reason: "analyst_consensus",
+              });
+              throw new Error("analyst_consensus");
+            }
+            entriesBeforeStep = readSessionEntries(ctx).length;
+            const prompt = this.prepareWorkflowPrompt(
+              pi,
+              definition.steps[stepIndex].prompt,
+              step.stepType,
+              runner.getActiveRun(),
+            );
+            pi.sendUserMessage(prompt);
           }
-          pi.sendUserMessage(definition.steps[stepIndex].prompt);
-        } else {
-          // For the first step, just wait for it to settle
+
           const settled = await waitForPromptSettlement(ctx, () => runRef.active, {
-            requireActivity: firstPromptMode === "transform",
+            requireActivity: stepIndex === 0 && firstPromptMode === "transform",
           });
           if (!settled || !runRef.active) {
             throw new Error("run_cancelled");
           }
-        }
-        return promptStepOutput(stepIndex, step.stepType);
-      })
+
+          let stepEntries = readSessionEntries(ctx).slice(entriesBeforeStep);
+          let rawText = capturedText(eventCapture, stepEntries);
+          let output = promptStepOutput(stepIndex, step.stepType, {
+            evidence: capturedEvidence(eventCapture, stepEntries),
+            rawText,
+          });
+
+          if (
+            isStructuredAnalystStep(step.stepType) &&
+            !hasStructuredContract(step.stepType, rawText)
+          ) {
+            pi.sendUserMessage(
+              "Please revise your previous response to include the exact required final output format from the stage prompt. Do not add new tool calls.",
+            );
+            const retrySettled = await waitForPromptSettlement(ctx, () => runRef.active);
+            if (!retrySettled || !runRef.active) {
+              throw new Error("run_cancelled");
+            }
+            stepEntries = readSessionEntries(ctx).slice(entriesBeforeStep);
+            rawText = capturedText(eventCapture, stepEntries);
+            output = promptStepOutput(stepIndex, step.stepType, {
+              evidence: capturedEvidence(eventCapture, stepEntries),
+              rawText,
+            });
+          }
+
+          for (const record of output.evidence) {
+            const value = isPlainObject(record.value) ? record.value : {};
+            this.eventLogger?.log(context.runId, stepIndex, "tool_called", {
+              stepType: step.stepType,
+              tool: value.tool,
+              args: value.args,
+              resultDigest: value.resultDigest,
+            });
+          }
+
+          if (this.activeStepCapture === eventCapture) {
+            this.activeStepCapture = null;
+          }
+
+          const structuredOutput = attachStructuredOutput(pi, output);
+          if (step.stepType === "synthesis") {
+            this.emitSynthesisValidation(
+              pi,
+              context.runId,
+              stepIndex,
+              runner.getActiveRun(),
+              structuredOutput,
+            );
+          }
+
+          return structuredOutput;
+        },
+      )
       .finally(() => {
+        if (this.activeWorkflowRunRef === runRef) {
+          this.activeStepCapture = null;
+        }
         clearRunContext(runRef.contextToken);
         if (this.activeWorkflowRunRef === runRef) {
           this.activeWorkflowRunRef = null;
@@ -479,8 +587,261 @@ export class SessionCoordinator {
       clearRunContext(activeRef.contextToken);
       this.activeWorkflowRunRef = null;
     }
+    this.activeStepCapture = null;
     this.runner?.cancel();
   }
+
+  private startStepCapture(): ActiveStepCapture {
+    const capture: ActiveStepCapture = {
+      evidence: [],
+      pendingTools: new Map(),
+      rawText: "",
+    };
+    this.activeStepCapture = capture;
+    return capture;
+  }
+
+  private installWorkflowEventCapture(pi: ExtensionAPI): void {
+    const on = (pi as { on?: unknown }).on;
+    if (this.workflowEventCaptureInstalled || typeof on !== "function") return;
+    this.workflowEventCaptureInstalled = true;
+
+    pi.on("message_update", (event) => {
+      const capture = this.activeStepCapture;
+      if (!capture || event.assistantMessageEvent.type !== "text_delta") return;
+      capture.rawText += event.assistantMessageEvent.delta;
+    });
+
+    pi.on("tool_execution_start", (event) => {
+      const capture = this.activeStepCapture;
+      if (!capture) return;
+      capture.pendingTools.set(event.toolCallId, {
+        tool: event.toolName,
+        args: event.args ?? {},
+        startedAt: new Date().toISOString(),
+      });
+    });
+
+    pi.on("tool_execution_end", (event) => {
+      const capture = this.activeStepCapture;
+      if (!capture) return;
+      const completedAt = new Date().toISOString();
+      const pending = capture.pendingTools.get(event.toolCallId);
+      capture.pendingTools.delete(event.toolCallId);
+      const tool = pending?.tool ?? event.toolName;
+      if (!tool) return;
+      capture.evidence.push(
+        toolEvidenceRecord({
+          tool,
+          args: pending?.args ?? {},
+          result: event.result,
+          startedAt: pending?.startedAt ?? completedAt,
+          completedAt,
+          isError: event.isError === true,
+        }),
+      );
+    });
+  }
+
+  private prepareWorkflowPrompt(
+    pi: ExtensionAPI,
+    prompt: string,
+    stepType: string,
+    run: WorkflowRun | null,
+  ): string {
+    if (stepType !== "synthesis") return prompt;
+    const parsedAnalysts = collectParsedAnalystOutputs(run);
+    const tallyBlock = buildAnalystVoteTallyBlock(parsedAnalysts);
+    if (!tallyBlock) {
+      this.eventLogger?.log(run?.runId ?? "unknown", run?.currentStepIndex ?? 0, "tally_skipped", {
+        reason: "tally_skipped",
+        parsedAnalystCount: parsedAnalysts.length,
+      });
+      this.appendWorkflowEvent(pi, "tally_skipped", {
+        reason: "fewer_than_2_parsed_analysts",
+        parsedAnalystCount: parsedAnalysts.length,
+      });
+      return prompt;
+    }
+    this.eventLogger?.log(run?.runId ?? "unknown", run?.currentStepIndex ?? 0, "tally_injected", {
+      tallyBlock,
+      parsedAnalystCount: parsedAnalysts.length,
+    });
+    this.appendWorkflowEvent(pi, "tally_injected", {
+      tallyBlock,
+      parsedAnalystCount: parsedAnalysts.length,
+    });
+    return `${tallyBlock}\n\n${prompt}`;
+  }
+
+  private emitSynthesisValidation(
+    pi: ExtensionAPI,
+    runId: string,
+    stepIndex: number,
+    run: WorkflowRun | null,
+    currentOutput: StepOutput,
+  ): void {
+    const validationInput = collectValidationInput(run, currentOutput);
+    const mismatches = checkNumberMatch(
+      validationInput.evidence,
+      validationInput.toolResults,
+    ).filter((entry) => entry.type === "failure");
+    const passed = mismatches.length === 0;
+    const payload = {
+      passed,
+      mismatches,
+      skipped_unparsed: validationInput.skippedUnparsed,
+    };
+    this.eventLogger?.log(runId, stepIndex, passed ? "validation_passed" : "validation_failed", {
+      mismatches,
+      skipped_unparsed: validationInput.skippedUnparsed,
+    });
+    pi.appendEntry("opencandle-validation", payload);
+    this.appendWorkflowEvent(pi, passed ? "validation_passed" : "validation_failed", {
+      mismatches,
+      skipped_unparsed: validationInput.skippedUnparsed,
+    });
+  }
+
+  private appendWorkflowEvent(
+    pi: ExtensionAPI,
+    eventType: string,
+    payload: Record<string, unknown>,
+  ): void {
+    pi.appendEntry("opencandle-workflow-event", {
+      eventType,
+      ...payload,
+    });
+  }
+}
+
+function capturedText(capture: ActiveStepCapture, entries: SessionEntry[]): string {
+  return capture.rawText.trim() || extractAssistantText(entries);
+}
+
+function capturedEvidence(capture: ActiveStepCapture, entries: SessionEntry[]): EvidenceRecord[] {
+  return capture.evidence.length > 0 ? [...capture.evidence] : captureToolEvidence(entries);
+}
+
+function collectParsedAnalystOutputs(run: WorkflowRun | null): AnalystOutput[] {
+  if (!run) return [];
+  const outputs: AnalystOutput[] = [];
+  for (const output of run.stepOutputs.values()) {
+    if (output.parsed === true && output.analystOutput) {
+      outputs.push(output.analystOutput);
+    }
+  }
+  return outputs;
+}
+
+function shouldSkipRebuttal(run: WorkflowRun | null, stepType: string): boolean {
+  if (stepType !== "debate_rebuttal") return false;
+  const parsedAnalysts = collectParsedAnalystOutputs(run);
+  // Degradation rule: with fewer than two parsed analyst outputs there is no
+  // trustworthy consensus signal to gate on — run the rebuttal exactly as the
+  // status quo instead of skipping because isAnalystSplit([]) is false.
+  if (parsedAnalysts.length < 2) return false;
+  return !isAnalystSplit(parsedAnalysts);
+}
+
+function collectValidationInput(
+  run: WorkflowRun | null,
+  currentOutput?: StepOutput,
+): {
+  evidence: EvidenceRecord[];
+  toolResults: Map<string, number>;
+  skippedUnparsed: string[];
+} {
+  const evidence: EvidenceRecord[] = [];
+  const toolResults = new Map<string, number>();
+  const skippedUnparsed: string[] = [];
+  const outputs = run ? [...run.stepOutputs.values()] : [];
+  if (currentOutput) {
+    outputs.push(currentOutput);
+  }
+
+  for (const output of outputs) {
+    if (output.stepType.startsWith("analyst_") && output.parsed === false) {
+      skippedUnparsed.push(output.stepType);
+    }
+    for (const record of output.evidence) {
+      collectToolNumbers(record, toolResults);
+    }
+  }
+
+  for (const output of outputs) {
+    if (!output.rawText) continue;
+    evidence.push(...extractNumericClaims(output.rawText, toolResults));
+  }
+
+  return { evidence, toolResults, skippedUnparsed };
+}
+
+function toolEvidenceRecord(input: {
+  tool: string;
+  args: unknown;
+  result: unknown;
+  startedAt: string;
+  completedAt: string;
+  isError: boolean;
+}): EvidenceRecord {
+  const serializedResult = serialize(input.result);
+  const freshness = extractFreshness(input.result);
+  return {
+    label: `tool:${input.tool}`,
+    value: {
+      tool: input.tool,
+      args: truncate(serialize(input.args), 500),
+      ...(freshness ? { freshness } : {}),
+      resultDigest: {
+        preview: truncate(serializedResult, 500),
+        totalLength: serializedResult.length,
+      },
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+    },
+    provenance: {
+      source: "computed",
+      timestamp: freshness?.providerDataAt ?? freshness?.fetchedAt ?? input.completedAt,
+      provider: input.tool,
+      confidence: input.isError ? 0.5 : undefined,
+    },
+  };
+}
+
+function summarizeStepEvidence(evidence: EvidenceRecord[]): unknown[] {
+  return evidence.map((record) => (isPlainObject(record.value) ? record.value : record));
+}
+
+function serialize(value: unknown): string {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function truncate(value: string, maxLength: number): string {
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+
+function extractFreshness(value: unknown): FreshnessStamp | undefined {
+  const record = isPlainObject(value) ? value : {};
+  const direct = record.freshness;
+  if (isFreshnessStamp(direct)) return direct;
+  const details = isPlainObject(record.details) ? record.details : {};
+  return isFreshnessStamp(details.freshness) ? details.freshness : undefined;
+}
+
+function isFreshnessStamp(value: unknown): value is FreshnessStamp {
+  const record = isPlainObject(value) ? value : {};
+  return (
+    typeof record.fetchedAt === "string" &&
+    typeof record.cacheStatus === "string" &&
+    typeof record.marketSession === "string" &&
+    typeof record.isStaleForSession === "boolean"
+  );
 }
 
 function formatToolDefaultsForPrompt(): string[] {
@@ -511,6 +872,89 @@ function flattenDefaults(defaults: Record<string, unknown>, prefix = ""): Array<
   return out;
 }
 
+function isStructuredAnalystStep(stepType: string): boolean {
+  return stepType.startsWith("analyst_") || stepType.startsWith("debate_");
+}
+
+function hasStructuredContract(stepType: string, text: string): boolean {
+  if (stepType.startsWith("analyst_")) {
+    // The conviction range check must match extractConviction's 1-10
+    // contract: parseAnalystOutput silently defaults out-of-range values to
+    // 5, so accepting them here would record a fabricated conviction.
+    const conviction = text.match(/CONVICTION:\s*(\d+)/i);
+    const convictionInRange =
+      conviction !== null && Number(conviction[1]) >= 1 && Number(conviction[1]) <= 10;
+    return (
+      /SIGNAL:\s*(BUY|HOLD|SELL)/i.test(text) && convictionInRange && /THESIS:\s*(.+)/i.test(text)
+    );
+  }
+  if (stepType === "debate_bull") {
+    return (
+      /BULL THESIS:\s*(.+)/i.test(text) && /KEY RISK(?:\s+TO THIS THESIS)?:\s*(.+)/i.test(text)
+    );
+  }
+  if (stepType === "debate_bear") {
+    return /BEAR THESIS:\s*(.+)/i.test(text) && /WHAT WOULD CHANGE MY MIND:\s*(.+)/i.test(text);
+  }
+  if (stepType === "debate_rebuttal") {
+    return (
+      /^REBUTTAL SKIPPED/i.test(text.trim()) ||
+      (/CONCESSIONS:\s*[\s\S]+/i.test(text) && /REMAINING CONVICTION:\s*(\d+)/i.test(text))
+    );
+  }
+  return false;
+}
+
+function attachStructuredOutput(pi: ExtensionAPI, output: ReturnType<typeof promptStepOutput>) {
+  if (!isStructuredAnalystStep(output.stepType)) return output;
+
+  const rawText = output.rawText ?? "";
+  const evidence = summarizeStepEvidence(output.evidence);
+  const evidenceCount = output.evidence.length;
+  if (!hasStructuredContract(output.stepType, rawText)) {
+    const role = analystRoleFromStep(output.stepType);
+    pi.appendEntry("opencandle-analyst-step", {
+      stage: output.stepType,
+      ...(role ? { role } : {}),
+      parsed: false,
+      evidenceCount,
+      evidence,
+    });
+    return { ...output, parsed: false };
+  }
+
+  if (output.stepType.startsWith("analyst_")) {
+    const role = analystRoleFromStep(output.stepType) ?? "analyst";
+    const analystOutput = parseAnalystOutput(role, rawText);
+    const parsedOutput = { ...output, analystOutput, parsed: true };
+    pi.appendEntry("opencandle-analyst-step", {
+      stage: output.stepType,
+      role,
+      signal: analystOutput.signal,
+      conviction: analystOutput.conviction,
+      parsed: true,
+      evidenceCount,
+      evidence,
+    });
+    return parsedOutput;
+  }
+
+  const side = output.stepType === "debate_bear" ? "bear" : "bull";
+  const debateOutput = parseDebateOutput(side, rawText);
+  pi.appendEntry("opencandle-analyst-step", {
+    stage: output.stepType,
+    side,
+    parsed: true,
+    evidenceCount,
+    evidence,
+  });
+  return { ...output, debateOutput, parsed: true };
+}
+
+function analystRoleFromStep(stepType: string): string | undefined {
+  return stepType.startsWith("analyst_") ? stepType.slice("analyst_".length) : undefined;
+}
+
 function buildSavedMarketStateContext(db: Database.Database): string {
   try {
     const service = new MarketStateService(db);
@@ -538,34 +982,11 @@ function buildSavedMarketStateContext(db: Database.Database): string {
     ];
 
     if (lots.length > 0) {
-      lines.push("Portfolio lots:");
-      for (const lot of lots.slice(0, 8)) {
-        const costBasis = formatMoney(lot.quantity * lot.avgCost, lot.currency);
-        const name = lot.name ? ` (${lot.name})` : "";
-        lines.push(
-          `- ${lot.symbol}: ${lot.quantity} @ ${formatMoney(lot.avgCost, lot.currency)}, cost basis ${costBasis}${name}`,
-        );
-      }
+      lines.push(...formatPortfolioSummary(lots));
     }
 
     if (watchlist.length > 0) {
-      lines.push("Watchlist:");
-      for (const item of watchlist.slice(0, 8)) {
-        const parts = [
-          item.targetPrice == null
-            ? null
-            : `target ${formatMoney(item.targetPrice, item.priceCurrency ?? item.currency ?? "USD")}`,
-          item.stopPrice == null
-            ? null
-            : `stop ${formatMoney(item.stopPrice, item.priceCurrency ?? item.currency ?? "USD")}`,
-          item.thesis ? `thesis: ${item.thesis}` : null,
-          item.tags && item.tags.length > 0 ? `tags: ${item.tags.join(", ")}` : null,
-          item.notes ? `notes: ${item.notes}` : null,
-        ].filter((part): part is string => part != null);
-        lines.push(
-          `- ${item.symbol}${item.name ? ` (${item.name})` : ""}${parts.length > 0 ? ` — ${parts.join("; ")}` : ""}`,
-        );
-      }
+      lines.push(...formatWatchlistSummary(watchlist));
     }
 
     if (alerts.length > 0) {
@@ -589,10 +1010,7 @@ function buildSavedMarketStateContext(db: Database.Database): string {
     }
 
     if (reportRuns.length > 0) {
-      const latest = reportRuns[0];
-      lines.push(
-        `Latest report run: ${latest.status} at ${latest.completedAt ?? latest.startedAt}`,
-      );
+      lines.push(...formatLatestReportSummary(reportRuns[0], { includeSummary: false }));
     }
 
     return lines.join("\n");
@@ -614,19 +1032,6 @@ function shouldIncludeSavedMarketStateContext(
   return workflowType != null || fallbackContext != null;
 }
 
-function formatMoney(value: number, currency: string): string {
-  const normalized = currency.toUpperCase();
-  if (normalized === "USD") return `$${value.toFixed(2)}`;
-  return `${normalized} ${value.toFixed(2)}`;
-}
-
-function formatJsonSummary(value: unknown): string {
-  if (value == null) return "";
-  const json = JSON.stringify(value);
-  if (json.length <= 90) return json;
-  return `${json.slice(0, 87)}...`;
-}
-
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/src/runtime/validation.ts

@@ -187,7 +187,7 @@ export class RuntimeValidator {
 export function checkNumberMatch(
   evidence: EvidenceRecord[],
   toolResults: Map<string, number>,
-): ValidationEntry[] {
+): Array<ValidationEntry & { type: "pass" | "failure" }> {
   const results: (ValidationEntry & { type: "pass" | "failure" })[] = [];
   for (const record of evidence) {
     if (typeof record.value !== "number") continue;

package/src/runtime/workflow-events.ts

@@ -12,6 +12,8 @@ export type WorkflowEventType =
   | "step_skipped"
   | "tool_called"
   | "tool_failed"
+  | "tally_injected"
+  | "tally_skipped"
   | "validation_passed"
   | "validation_failed"
   | "workflow_completed"

package/src/runtime/workflow-types.ts

@@ -44,6 +44,9 @@ export interface StepOutput {
   stepType: string;
   evidence: EvidenceRecord[];
   rawText?: string;
+  analystOutput?: AnalystOutput;
+  debateOutput?: DebateOutput;
+  parsed?: boolean;
 }
 
 /** Analyst signal direction. */