opencandle 0.4.0 → 0.6.0

package/src/runtime/run-context.ts

@@ -4,16 +4,26 @@ interface RunContext {
   providerTracker: ProviderTracker;
 }
 
+export interface RunContextToken {
+  readonly id: symbol;
+}
+
 let activeContext: RunContext | null = null;
+let activeToken: RunContextToken | null = null;
 
 /** Set the active run context. Called by SessionCoordinator at workflow start. */
-export function setRunContext(ctx: RunContext): void {
+export function setRunContext(ctx: RunContext): RunContextToken {
+  const token = { id: Symbol("run-context") };
   activeContext = ctx;
+  activeToken = token;
+  return token;
 }
 
 /** Clear the active run context. Called when a workflow ends or is cancelled. */
-export function clearRunContext(): void {
+export function clearRunContext(token?: RunContextToken): void {
+  if (token && activeToken !== token) return;
   activeContext = null;
+  activeToken = null;
 }
 
 /** Get the current run's ProviderTracker, or undefined outside a workflow. */

package/src/runtime/session-coordinator.ts

@@ -1,4 +1,9 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+  SessionEntry,
+} from "@earendil-works/pi-coding-agent";
 import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/index.js";
 
 /**
@@ -8,22 +13,34 @@ import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/in
  * the shape we need from the public `ExtensionContext` type.
  */
 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";
+import type { MemoryEntry } from "../memory/types.js";
 import { runOpenCandleSetup } from "../pi/setup.js";
-import { WorkflowEventLogger } from "./workflow-events.js";
-import { ProviderTracker } from "./provider-tracker.js";
-import { WorkflowRunner } from "./workflow-runner.js";
-import { setRunContext, clearRunContext } from "./run-context.js";
-import { PromptContextBuilder, type FallbackContext } from "../prompts/context-builder.js";
+import { type FallbackContext, PromptContextBuilder } from "../prompts/context-builder.js";
+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 { WorkflowDefinition } from "./prompt-step.js";
-import { toStepDefinitions, promptStepOutput } from "./prompt-step.js";
-import type Database from "better-sqlite3";
+import { promptStepOutput, toStepDefinitions } from "./prompt-step.js";
+import { ProviderTracker } from "./provider-tracker.js";
+import { clearRunContext, type RunContextToken, setRunContext } from "./run-context.js";
+import { WorkflowEventLogger } from "./workflow-events.js";
+import { WorkflowRunner } from "./workflow-runner.js";
 
 const PROMPT_SETTLE_POLL_MS = 25;
 const IMMEDIATE_IDLE_GRACE_MS = 100;
 
+interface ActiveWorkflowRunRef {
+  active: boolean;
+  contextToken: RunContextToken;
+}
+
 function parseMaybeJson(raw: unknown): Record<string, unknown> | undefined {
   if (typeof raw !== "string" || raw.length === 0) return undefined;
   try {
@@ -36,11 +53,13 @@ function parseMaybeJson(raw: unknown): Record<string, unknown> | undefined {
   }
 }
 
-type QueueContext = ExtensionCommandContext | {
-  isIdle(): boolean;
-  hasPendingMessages?(): boolean;
-  ui?: { notify(message: string, level?: string): void };
-};
+type QueueContext =
+  | ExtensionCommandContext
+  | {
+      isIdle(): boolean;
+      hasPendingMessages?(): boolean;
+      ui?: { notify(message: string, level?: string): void };
+    };
 
 function hasPendingMessages(ctx: QueueContext): boolean {
   return ctx.hasPendingMessages?.() ?? false;
@@ -57,6 +76,7 @@ function sleep(ms: number): Promise<void> {
 async function waitForPromptSettlement(
   ctx: QueueContext,
   isCurrentRun: () => boolean,
+  options: { requireActivity?: boolean } = {},
 ): Promise<boolean> {
   let sawBusyOrPending = !isReadyForNextPrompt(ctx);
   const startedAt = Date.now();
@@ -71,7 +91,12 @@ async function waitForPromptSettlement(
       return true;
     }
 
-    if (!sawBusyOrPending && ready && Date.now() - startedAt >= IMMEDIATE_IDLE_GRACE_MS) {
+    if (
+      !options.requireActivity &&
+      !sawBusyOrPending &&
+      ready &&
+      Date.now() - startedAt >= IMMEDIATE_IDLE_GRACE_MS
+    ) {
       return true;
     }
 
@@ -92,6 +117,9 @@ export class SessionCoordinator {
   private eventLogger: WorkflowEventLogger | null = null;
   private runner: WorkflowRunner;
   private providerTracker: ProviderTracker;
+  private activeWorkflowRunRef: ActiveWorkflowRunRef | null = null;
+  private activeWorkflowType: string | undefined;
+  private tickerValidationCache: SymbolValidationCache = new Map();
   private sessionId = "unknown";
 
   constructor() {
@@ -108,6 +136,14 @@ export class SessionCoordinator {
     return this.runner;
   }
 
+  getTickerValidationCache(): SymbolValidationCache {
+    return this.tickerValidationCache;
+  }
+
+  clearTickerValidationCache(): void {
+    this.tickerValidationCache.clear();
+  }
+
   /** Initialize session: database, memory, event logger, workflow runner. */
   initSession(sessionId: string): void {
     this.db = initDefaultDatabase();
@@ -150,7 +186,7 @@ export class SessionCoordinator {
     entities: object,
     resolved: object,
     defaultsUsed: unknown[],
-    turnType: "workflow" | "fallback" = "workflow",
+    turnType = "workflow",
   ): void {
     this.storage?.insertWorkflowRun({
       sessionId: this.sessionId,
@@ -263,34 +299,56 @@ export class SessionCoordinator {
     return { profileSnapshot, recentWorkflowRuns: runs, priorTurns };
   }
 
+  retrieveMemoryForRoute(
+    routeKind: RouterRouteKind,
+    workflowType?: string,
+    overriddenSlots?: string[],
+  ): { entries: MemoryEntry[]; filtered: FilteredMemoryEntry[] } {
+    if (!this.memoryManager) return { entries: [], filtered: [] };
+    return this.memoryManager.retrieveDetailed(workflowType ?? routeKind, overriddenSlots);
+  }
+
   /** Build system prompt using composable sections. */
   buildSystemPrompt(
     basePrompt: string,
     workflowType?: string,
     fallbackContext?: FallbackContext,
+    resolvedTurnContext?: ResolvedTurnContext,
   ): string {
     const builder = new PromptContextBuilder();
 
     const addonTools = getAddonToolDescriptions();
-    const addonDescriptions = addonTools.length > 0
-      ? addonTools.map((t) => `${t.name}: ${t.description}`)
-      : undefined;
+    const addonDescriptions =
+      addonTools.length > 0 ? addonTools.map((t) => `${t.name}: ${t.description}`) : undefined;
 
     const memoryContext = this.memoryManager
-      ? this.memoryManager.buildContext(workflowType ?? "unclassified")
+      ? this.memoryManager.buildContext(
+          resolvedTurnContext?.workflow ??
+            workflowType ??
+            resolvedTurnContext?.routeKind ??
+            "unclassified",
+        )
       : undefined;
+    const savedMarketStateContext =
+      this.db &&
+      shouldIncludeSavedMarketStateContext(workflowType, resolvedTurnContext, fallbackContext)
+        ? buildSavedMarketStateContext(this.db)
+        : "";
+    const combinedMemoryContext = [savedMarketStateContext, memoryContext]
+      .filter((part) => part && part.trim().length > 0)
+      .join("\n\n");
 
     builder.populateFromOptions({
       workflowType,
-      memoryContext: memoryContext || undefined,
+      memoryContext: combinedMemoryContext || undefined,
       addonToolDescriptions: addonDescriptions,
       fallbackContext,
+      resolvedTurnContext,
     });
 
     const toolDefaults = formatToolDefaultsForPrompt();
-    const defaultsSection = toolDefaults.length > 0
-      ? `\n\n## User Tool Defaults\n${toolDefaults.join("\n")}`
-      : "";
+    const defaultsSection =
+      toolDefaults.length > 0 ? `\n\n## User Tool Defaults\n${toolDefaults.join("\n")}` : "";
 
     return `${basePrompt}\n\n${builder.build()}${defaultsSection}`;
   }
@@ -301,71 +359,126 @@ export class SessionCoordinator {
    * subsequent turns do not inherit stale fallback directives.
    */
   private pendingFallbackContext: FallbackContext | null = null;
+  private pendingResolvedTurnContext: ResolvedTurnContext | null = null;
 
   setPendingFallbackContext(ctx: FallbackContext | null): void {
     this.pendingFallbackContext = ctx;
   }
 
+  setPendingResolvedTurnContext(ctx: ResolvedTurnContext | null): void {
+    this.pendingResolvedTurnContext = ctx;
+  }
+
   consumePendingFallbackContext(): FallbackContext | null {
     const ctx = this.pendingFallbackContext;
     this.pendingFallbackContext = null;
     return ctx;
   }
 
+  consumePendingResolvedTurnContext(): ResolvedTurnContext | null {
+    const ctx = this.pendingResolvedTurnContext;
+    this.pendingResolvedTurnContext = null;
+    return ctx;
+  }
+
   /**
    * Execute a workflow definition through the WorkflowRunner,
    * sending prompts via Pi with settlement-based sequencing.
    */
-  executeWorkflow(
+  executeWorkflow(pi: ExtensionAPI, definition: WorkflowDefinition, ctx: QueueContext): void {
+    this.startWorkflowRun(pi, definition, ctx, "send");
+  }
+
+  /**
+   * Start workflow tracking for an input handler that will return a Pi
+   * transform result. The current prompt becomes the first workflow prompt;
+   * only later steps are sent through Pi.
+   */
+  /** Workflow type of the in-flight run, for prompt context on workflow turns. */
+  getActiveWorkflowType(): string | undefined {
+    return this.activeWorkflowRunRef?.active ? this.activeWorkflowType : undefined;
+  }
+
+  transformWorkflowInput(
     pi: ExtensionAPI,
     definition: WorkflowDefinition,
     ctx: QueueContext,
+  ): string | undefined {
+    if (definition.steps.length === 0) return undefined;
+    this.startWorkflowRun(pi, definition, ctx, "transform");
+    return definition.steps[0].prompt;
+  }
+
+  private startWorkflowRun(
+    pi: ExtensionAPI,
+    definition: WorkflowDefinition,
+    ctx: QueueContext,
+    firstPromptMode: "send" | "transform",
   ): void {
     if (definition.steps.length === 0) return;
 
     const runner = this.runner;
-    const runRef = { active: true };
+    if (this.activeWorkflowRunRef) {
+      this.activeWorkflowRunRef.active = false;
+    }
+    runner.cancel();
+    this.activeWorkflowType = definition.workflowType;
 
-    // Send the first prompt immediately
-    const [firstStep, ...restSteps] = definition.steps;
-    const startedBusy = !isReadyForNextPrompt(ctx);
+    const [firstStep] = definition.steps;
 
-    if (startedBusy) {
-      pi.sendUserMessage(firstStep.prompt, { deliverAs: "followUp" });
-      ctx.ui?.notify?.("Analysis queued as follow-up.", "info");
-    } else {
-      pi.sendUserMessage(firstStep.prompt);
+    if (firstPromptMode === "send") {
+      const startedBusy = !isReadyForNextPrompt(ctx);
+      if (startedBusy) {
+        pi.sendUserMessage(firstStep.prompt, { deliverAs: "followUp" });
+        ctx.ui?.notify?.("Analysis queued as follow-up.", "info");
+      } else {
+        pi.sendUserMessage(firstStep.prompt);
+      }
     }
 
     // Make the run's ProviderTracker accessible to tools during execution
-    setRunContext({ providerTracker: this.providerTracker });
+    const contextToken = setRunContext({ providerTracker: this.providerTracker });
+    const runRef: ActiveWorkflowRunRef = { active: true, contextToken };
+    this.activeWorkflowRunRef = runRef;
 
     // 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");
+    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");
+          }
+          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",
+          });
+          if (!settled || !runRef.active) {
+            throw new Error("run_cancelled");
+          }
         }
-        pi.sendUserMessage(definition.steps[stepIndex].prompt);
-      } else {
-        // For the first step, just wait for it to settle
-        const settled = await waitForPromptSettlement(ctx, () => runRef.active);
-        if (!settled || !runRef.active) {
-          throw new Error("run_cancelled");
+        return promptStepOutput(stepIndex, step.stepType);
+      })
+      .finally(() => {
+        clearRunContext(runRef.contextToken);
+        if (this.activeWorkflowRunRef === runRef) {
+          this.activeWorkflowRunRef = null;
         }
-      }
-      return promptStepOutput(stepIndex, step.stepType);
-    }).finally(() => {
-      clearRunContext();
-    });
+      });
   }
 
   /** Cancel any active workflow. */
   cancelActiveWorkflow(): void {
-    clearRunContext();
+    const activeRef = this.activeWorkflowRunRef;
+    if (activeRef) {
+      activeRef.active = false;
+      clearRunContext(activeRef.contextToken);
+      this.activeWorkflowRunRef = null;
+    }
     this.runner?.cancel();
   }
 }
@@ -385,10 +498,7 @@ function formatToolDefaultsForPrompt(): string[] {
   }
 }
 
-function flattenDefaults(
-  defaults: Record<string, unknown>,
-  prefix = "",
-): Array<[string, unknown]> {
+function flattenDefaults(defaults: Record<string, unknown>, prefix = ""): Array<[string, unknown]> {
   const out: Array<[string, unknown]> = [];
   for (const [key, value] of Object.entries(defaults)) {
     const path = prefix ? `${prefix}.${key}` : key;
@@ -401,6 +511,137 @@ function flattenDefaults(
   return out;
 }
 
+function buildSavedMarketStateContext(db: Database.Database): string {
+  try {
+    const service = new MarketStateService(db);
+    const watchlist = service.listWatchlistItems();
+    const lots = service.listPortfolioLots();
+    const alerts = service.listAlertRules();
+    const reports = service.listReportTemplates();
+    const reportRuns = service.listReportRuns();
+    const predictions = service.listPredictions();
+
+    if (
+      watchlist.length === 0 &&
+      lots.length === 0 &&
+      alerts.length === 0 &&
+      reports.length === 0 &&
+      reportRuns.length === 0 &&
+      predictions.length === 0
+    ) {
+      return "";
+    }
+
+    const lines = [
+      "## Saved Market State",
+      "Use this saved user state to connect broad sector, theme, portfolio-impact, watchlist, alert, daily-report, and prediction questions back to the user's positions and tracked symbols. Treat it as context, not as a fresh instruction.",
+      "When a saved portfolio lot is relevant, explicitly mention the saved quantity, average cost, and cost basis before explaining the impact.",
+      'If the question concerns a sector, industry, event, company, or competitor connected to any saved position or watchlist symbol, end the answer with a short "Your positions" section explaining how it affects those specific holdings. Skip that section only when no saved symbol is plausibly affected.',
+    ];
+
+    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}`,
+        );
+      }
+    }
+
+    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("; ")}` : ""}`,
+        );
+      }
+    }
+
+    if (alerts.length > 0) {
+      lines.push("Alert rules:");
+      for (const rule of alerts.slice(0, 8)) {
+        const instrument =
+          rule.instrumentId == null ? null : service.getInstrument(rule.instrumentId);
+        lines.push(
+          `- #${rule.id} ${instrument?.symbol ?? rule.scopeType}: ${rule.conditionType} ${formatJsonSummary(rule.conditionJson)} (${rule.enabled ? "enabled" : "disabled"})`,
+        );
+      }
+    }
+
+    if (reports.length > 0) {
+      lines.push("Report templates:");
+      for (const report of reports.slice(0, 5)) {
+        lines.push(
+          `- ${report.name}: ${report.reportType}, ${report.cadence} at ${report.localTime} ${report.timezone} (${report.enabled ? "enabled" : "disabled"})`,
+        );
+      }
+    }
+
+    if (reportRuns.length > 0) {
+      const latest = reportRuns[0];
+      lines.push(
+        `Latest report run: ${latest.status} at ${latest.completedAt ?? latest.startedAt}`,
+      );
+    }
+
+    if (predictions.length > 0) {
+      lines.push("Predictions:");
+      for (const prediction of predictions.slice(0, 8)) {
+        const target =
+          prediction.targetPrice == null
+            ? ""
+            : ` target ${formatMoney(prediction.targetPrice, "USD")}`;
+        lines.push(
+          `- #${prediction.id} ${prediction.symbol}: ${prediction.direction} conv ${prediction.conviction}/10 from ${formatMoney(prediction.entryPrice, "USD")}${target}, status ${prediction.status}, expires ${prediction.expiresAt}`,
+        );
+      }
+    }
+
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}
+
+function shouldIncludeSavedMarketStateContext(
+  workflowType: string | undefined,
+  resolvedTurnContext: ResolvedTurnContext | undefined,
+  fallbackContext: FallbackContext | undefined,
+): boolean {
+  if (resolvedTurnContext) {
+    return resolvedTurnContext.routeKind !== "pass_through";
+  }
+  // A pending fallback context only exists for routed finance turns (rules-mode
+  // general finance or LLM-router fallback), never for pass-through prompts.
+  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/session-title.ts

@@ -0,0 +1,60 @@
+/**
+ * LLM-summarized session titles.
+ *
+ * Builds a strict short-title prompt from the user's first message (plus an
+ * optional slice of the first assistant reply), delegates to an injected
+ * completion function, and sanitizes the result. Returns null when the model
+ * output is unusable (empty or rambling) so callers can keep the existing
+ * placeholder name. Completion errors propagate to the caller.
+ */
+
+const MAX_TITLE_CHARS = 60;
+const MAX_TITLE_WORDS = 12;
+
+export interface SessionTitleInput {
+  userText: string;
+  assistantText?: string;
+}
+
+export async function generateSessionTitle(
+  input: SessionTitleInput,
+  complete: (prompt: string) => Promise<string>,
+): Promise<string | null> {
+  const lines = [
+    "Write a 4-8 word title for this finance chat session.",
+    "No quotes, no punctuation at the end, no markdown. Return only the title.",
+    "",
+    `User: ${input.userText}`,
+  ];
+  if (input.assistantText !== undefined && input.assistantText.trim().length > 0) {
+    lines.push("", `Assistant: ${input.assistantText}`);
+  }
+  const raw = await complete(lines.join("\n"));
+  return sanitizeTitle(raw);
+}
+
+function sanitizeTitle(raw: string): string | null {
+  // First non-empty line only — discard any model commentary after a newline.
+  let title =
+    raw
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0) ?? "";
+  // Strip markdown emphasis/heading/code characters.
+  title = title.replace(/[*_`#]/g, "");
+  // Strip surrounding quotes.
+  title = title.replace(/^["'“”‘’]+/, "").replace(/["'“”‘’]+$/, "");
+  // Strip trailing punctuation.
+  title = title.replace(/[.!?:;,]+$/, "");
+  // Collapse whitespace.
+  title = title.replace(/\s+/g, " ").trim();
+
+  if (title.length === 0) return null;
+  if (title.split(" ").length > MAX_TITLE_WORDS) return null;
+  if (title.length > MAX_TITLE_CHARS) {
+    const cut = title.slice(0, MAX_TITLE_CHARS);
+    const lastSpace = cut.lastIndexOf(" ");
+    title = (lastSpace > 0 ? cut.slice(0, lastSpace) : cut).trim();
+  }
+  return title;
+}

package/src/runtime/tool-defaults-wrapper.ts

@@ -23,9 +23,7 @@ function mergeDefaults(
   const out: Record<string, unknown> = { ...defaults };
   for (const [key, value] of Object.entries(args)) {
     const base = out[key];
-    out[key] = isPlainObject(base) && isPlainObject(value)
-      ? mergeDefaults(base, value)
-      : value;
+    out[key] = isPlainObject(base) && isPlainObject(value) ? mergeDefaults(base, value) : value;
   }
   return out;
 }

package/src/runtime/validation.ts

@@ -41,10 +41,7 @@ export function checkTimestamps(
 }
 
 /** Check that options expiry dates are in the future. */
-export function checkOptionsExpiries(
-  evidence: EvidenceRecord[],
-  today: string,
-): ValidationEntry[] {
+export function checkOptionsExpiries(evidence: EvidenceRecord[], today: string): ValidationEntry[] {
   const failures: ValidationEntry[] = [];
   for (const record of evidence) {
     if (

package/src/runtime/workflow-events.ts

@@ -55,13 +55,13 @@ export class WorkflowEventLogger {
         "SELECT id, run_id, step_index, event_type, payload_json, timestamp FROM workflow_events WHERE run_id = ? ORDER BY id",
       )
       .all(runId) as Array<{
-        id: number;
-        run_id: string;
-        step_index: number;
-        event_type: string;
-        payload_json: string | null;
-        timestamp: string;
-      }>;
+      id: number;
+      run_id: string;
+      step_index: number;
+      event_type: string;
+      payload_json: string | null;
+      timestamp: string;
+    }>;
 
     return rows.map((r) => ({
       id: r.id,

package/src/runtime/workflow-runner.ts

@@ -1,11 +1,8 @@
-import type { WorkflowRun, StepOutput, WorkflowStep } from "./workflow-types.js";
-import {
-  createWorkflowRun,
-  transitionStepStatus,
-} from "./workflow-types.js";
-import type { WorkflowEventLogger } from "./workflow-events.js";
-import type { ProviderTracker } from "./provider-tracker.js";
 import type { EvidenceRecord } from "./evidence.js";
+import type { ProviderTracker } from "./provider-tracker.js";
+import type { WorkflowEventLogger } from "./workflow-events.js";
+import type { StepOutput, WorkflowRun, WorkflowStep } from "./workflow-types.js";
+import { createWorkflowRun, transitionStepStatus } from "./workflow-types.js";
 
 /** Function that executes a single workflow step. */
 export type StepExecutor = (
@@ -106,10 +103,7 @@ export class WorkflowRunner {
     });
   }
 
-  private async executeSteps(
-    run: WorkflowRun,
-    executor: StepExecutor,
-  ): Promise<void> {
+  private async executeSteps(run: WorkflowRun, executor: StepExecutor): Promise<void> {
     for (let i = 0; i < run.steps.length; i++) {
       // Check if run was cancelled externally
       if (run.status !== "running") return;

package/src/sentiment/adapters/finnhub.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
-import type { SentinelRecord } from "../types.js";
 import type { FinnhubArticle } from "../../providers/finnhub.js";
 import { extractEntities } from "../../routing/entity-extractor.js";
+import type { SentinelRecord } from "../types.js";
 
 const MAX_TICKERS = 3;
 
@@ -31,7 +31,12 @@ export class FinnhubAdapter {
         score: 0,
         confidence: 0,
         method: "keyword" as const,
-        tickers: article.related ? article.related.split(",").map((t) => t.trim()).filter(Boolean) : [],
+        tickers: article.related
+          ? article.related
+              .split(",")
+              .map((t) => t.trim())
+              .filter(Boolean)
+          : [],
       },
       metadata: { category: article.category },
     }));