opencandle 0.11.0 → 0.12.0

package/dist/runtime/prompt-step.js

@@ -15,13 +15,95 @@ export function promptStep(stepType, description, prompt, options = {}) {
  * Create a StepOutput for a prompt-based step (no structured evidence yet).
  * Evidence will be captured separately via tool call hooks.
  */
-export function promptStepOutput(stepIndex, stepType) {
+export function promptStepOutput(stepIndex, stepType, options = {}) {
     return {
         stepIndex,
         stepType,
-        evidence: [],
+        evidence: options.evidence ?? [],
+        ...(options.rawText ? { rawText: options.rawText } : {}),
     };
 }
+/** Capture compact evidence records from session entries produced by one step. */
+export function captureToolEvidence(entries) {
+    const calls = new Map();
+    const evidence = [];
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const message = entry.message;
+        if (message.role === "assistant") {
+            for (const part of Array.isArray(message.content) ? message.content : []) {
+                const record = asRecord(part);
+                if (record.type !== "toolCall")
+                    continue;
+                const id = stringValue(record.id);
+                const tool = stringValue(record.name);
+                if (!id || !tool)
+                    continue;
+                calls.set(id, {
+                    tool,
+                    args: record.arguments ?? record.args ?? {},
+                    startedAt: entry.timestamp,
+                });
+            }
+            continue;
+        }
+        if (message.role !== "toolResult")
+            continue;
+        const toolCallId = stringValue(message.toolCallId);
+        const pending = toolCallId ? calls.get(toolCallId) : undefined;
+        const tool = pending?.tool ?? stringValue(message.toolName);
+        if (!tool)
+            continue;
+        const resultValue = message.details ?? message.content ?? "";
+        const freshness = extractFreshness(resultValue);
+        const serializedResult = serialize(resultValue);
+        evidence.push({
+            label: `tool:${tool}`,
+            value: {
+                tool,
+                args: truncate(serialize(pending?.args ?? {}), 500),
+                ...(freshness ? { freshness } : {}),
+                resultDigest: {
+                    preview: truncate(serializedResult, 500),
+                    totalLength: serializedResult.length,
+                },
+                startedAt: pending?.startedAt ?? entry.timestamp,
+                completedAt: entry.timestamp,
+            },
+            provenance: {
+                source: "computed",
+                timestamp: freshness?.providerDataAt ?? freshness?.fetchedAt ?? entry.timestamp,
+                provider: tool,
+                confidence: message.isError === true ? 0.5 : undefined,
+            },
+        });
+    }
+    return evidence;
+}
+/** Extract assistant text emitted during a step, preserving final response order. */
+export function extractAssistantText(entries) {
+    return entries
+        .filter((entry) => entry.type === "message")
+        .flatMap((entry) => {
+        const message = entry
+            .message;
+        if (message.role !== "assistant")
+            return [];
+        const content = message.content;
+        if (typeof content === "string")
+            return [content];
+        if (!Array.isArray(content))
+            return [];
+        return content
+            .map((part) => asRecord(part))
+            .filter((part) => part.type === "text")
+            .map((part) => stringValue(part.text) ?? "")
+            .filter(Boolean);
+    })
+        .join("\n")
+        .trim();
+}
 /**
  * Extract just the WorkflowStep metadata from PromptStep definitions
  * (dropping the prompt field) for passing to WorkflowRunner.
@@ -29,4 +111,35 @@ export function promptStepOutput(stepIndex, stepType) {
 export function toStepDefinitions(steps) {
     return steps.map(({ prompt: _prompt, ...step }) => step);
 }
-//# sourceMappingURL=prompt-step.js.map
+function serialize(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function extractFreshness(value) {
+    const record = asRecord(value);
+    return isFreshnessStamp(record.freshness) ? record.freshness : undefined;
+}
+function isFreshnessStamp(value) {
+    const record = asRecord(value);
+    return (typeof record.fetchedAt === "string" &&
+        typeof record.cacheStatus === "string" &&
+        typeof record.marketSession === "string" &&
+        typeof record.isStaleForSession === "boolean");
+}

package/dist/runtime/provider-tracker.js

@@ -33,4 +33,3 @@ export class ProviderTracker {
         this.failures.clear();
     }
 }
-//# sourceMappingURL=provider-tracker.js.map

package/dist/runtime/run-context.js

@@ -18,4 +18,3 @@ export function clearRunContext(token) {
 export function getProviderTracker() {
     return activeContext?.providerTracker;
 }
-//# sourceMappingURL=run-context.js.map

package/dist/runtime/session-coordinator.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
 import { MemoryStorage } from "../memory/index.js";
 /**
  * Alias for the session-manager handle extensions receive via
@@ -21,6 +21,9 @@ type QueueContext = ExtensionCommandContext | {
     ui?: {
         notify(message: string, level?: string): void;
     };
+    sessionManager?: {
+        getEntries(): SessionEntry[];
+    };
 };
 /**
  * Coordinates session lifecycle, memory, workflow execution,
@@ -35,6 +38,8 @@ export declare class SessionCoordinator {
     private providerTracker;
     private activeWorkflowRunRef;
     private activeWorkflowType;
+    private activeStepCapture;
+    private workflowEventCaptureInstalled;
     private tickerValidationCache;
     private sessionId;
     constructor();
@@ -129,5 +134,10 @@ export declare class SessionCoordinator {
     private startWorkflowRun;
     /** Cancel any active workflow. */
     cancelActiveWorkflow(): void;
+    private startStepCapture;
+    private installWorkflowEventCapture;
+    private prepareWorkflowPrompt;
+    private emitSynthesisValidation;
+    private appendWorkflowEvent;
 }
 export {};

package/dist/runtime/session-coordinator.js

@@ -1,13 +1,18 @@
-import { getAllDefaults, initDefaultDatabase, MemoryStorage } from "../memory/index.js";
+import { isAnalystSplit, parseAnalystOutput, parseDebateOutput } from "../analysts/contracts.js";
+import { buildAnalystVoteTallyBlock } from "../analysts/orchestrator.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";
 import { MemoryManager } from "../memory/manager.js";
 import { extractPreferences } from "../memory/preference-extractor.js";
 import { runOpenCandleSetup } from "../pi/setup.js";
 import { PromptContextBuilder } from "../prompts/context-builder.js";
 import { getAddonToolDescriptions } from "../tool-kit.js";
-import { promptStepOutput, toStepDefinitions } from "./prompt-step.js";
+import { collectToolNumbers, extractNumericClaims } from "./numeric-claims.js";
+import { captureToolEvidence, extractAssistantText, promptStepOutput, toStepDefinitions, } from "./prompt-step.js";
 import { ProviderTracker } from "./provider-tracker.js";
 import { clearRunContext, setRunContext } from "./run-context.js";
+import { checkNumberMatch } from "./validation.js";
 import { WorkflowEventLogger } from "./workflow-events.js";
 import { WorkflowRunner } from "./workflow-runner.js";
 const PROMPT_SETTLE_POLL_MS = 25;
@@ -31,6 +36,10 @@ function hasPendingMessages(ctx) {
 function isReadyForNextPrompt(ctx) {
     return ctx.isIdle() && !hasPendingMessages(ctx);
 }
+function readSessionEntries(ctx) {
+    const manager = "sessionManager" in ctx ? ctx.sessionManager : undefined;
+    return manager?.getEntries?.() ?? [];
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -68,6 +77,8 @@ export class SessionCoordinator {
     providerTracker;
     activeWorkflowRunRef = null;
     activeWorkflowType;
+    activeStepCapture = null;
+    workflowEventCaptureInstalled = false;
     tickerValidationCache = new Map();
     sessionId = "unknown";
     constructor() {
@@ -297,6 +308,7 @@ export class SessionCoordinator {
     startWorkflowRun(pi, definition, ctx, firstPromptMode) {
         if (definition.steps.length === 0)
             return;
+        this.installWorkflowEventCapture(pi);
         const runner = this.runner;
         if (this.activeWorkflowRunRef) {
             this.activeWorkflowRunRef.active = false;
@@ -321,27 +333,74 @@ 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
+            .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");
                 }
-                pi.sendUserMessage(definition.steps[stepIndex].prompt);
+                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);
             }
-            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) {
+            const settled = await waitForPromptSettlement(ctx, () => runRef.active, {
+                requireActivity: stepIndex === 0 && firstPromptMode === "transform",
+            });
+            if (!settled || !runRef.active) {
+                throw new Error("run_cancelled");
+            }
+            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 promptStepOutput(stepIndex, step.stepType);
+            return structuredOutput;
         })
             .finally(() => {
+            if (this.activeWorkflowRunRef === runRef) {
+                this.activeStepCapture = null;
+            }
             clearRunContext(runRef.contextToken);
             if (this.activeWorkflowRunRef === runRef) {
                 this.activeWorkflowRunRef = null;
@@ -356,8 +415,216 @@ export class SessionCoordinator {
             clearRunContext(activeRef.contextToken);
             this.activeWorkflowRunRef = null;
         }
+        this.activeStepCapture = null;
         this.runner?.cancel();
     }
+    startStepCapture() {
+        const capture = {
+            evidence: [],
+            pendingTools: new Map(),
+            rawText: "",
+        };
+        this.activeStepCapture = capture;
+        return capture;
+    }
+    installWorkflowEventCapture(pi) {
+        const on = pi.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,
+            }));
+        });
+    }
+    prepareWorkflowPrompt(pi, prompt, stepType, run) {
+        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}`;
+    }
+    emitSynthesisValidation(pi, runId, stepIndex, run, currentOutput) {
+        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,
+        });
+    }
+    appendWorkflowEvent(pi, eventType, payload) {
+        pi.appendEntry("opencandle-workflow-event", {
+            eventType,
+            ...payload,
+        });
+    }
+}
+function capturedText(capture, entries) {
+    return capture.rawText.trim() || extractAssistantText(entries);
+}
+function capturedEvidence(capture, entries) {
+    return capture.evidence.length > 0 ? [...capture.evidence] : captureToolEvidence(entries);
+}
+function collectParsedAnalystOutputs(run) {
+    if (!run)
+        return [];
+    const outputs = [];
+    for (const output of run.stepOutputs.values()) {
+        if (output.parsed === true && output.analystOutput) {
+            outputs.push(output.analystOutput);
+        }
+    }
+    return outputs;
+}
+function shouldSkipRebuttal(run, stepType) {
+    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, currentOutput) {
+    const evidence = [];
+    const toolResults = new Map();
+    const skippedUnparsed = [];
+    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) {
+    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) {
+    return evidence.map((record) => (isPlainObject(record.value) ? record.value : record));
+}
+function serialize(value) {
+    if (typeof value === "string")
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function truncate(value, maxLength) {
+    return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+function extractFreshness(value) {
+    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) {
+    const record = isPlainObject(value) ? value : {};
+    return (typeof record.fetchedAt === "string" &&
+        typeof record.cacheStatus === "string" &&
+        typeof record.marketSession === "string" &&
+        typeof record.isStaleForSession === "boolean");
 }
 function formatToolDefaultsForPrompt() {
     try {
@@ -387,6 +654,76 @@ function flattenDefaults(defaults, prefix = "") {
     }
     return out;
 }
+function isStructuredAnalystStep(stepType) {
+    return stepType.startsWith("analyst_") || stepType.startsWith("debate_");
+}
+function hasStructuredContract(stepType, text) {
+    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, output) {
+    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) {
+    return stepType.startsWith("analyst_") ? stepType.slice("analyst_".length) : undefined;
+}
 function buildSavedMarketStateContext(db) {
     try {
         const service = new MarketStateService(db);
@@ -409,29 +746,10 @@ function buildSavedMarketStateContext(db) {
             '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}`);
-            }
+            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 != null);
-                lines.push(`- ${item.symbol}${item.name ? ` (${item.name})` : ""}${parts.length > 0 ? ` — ${parts.join("; ")}` : ""}`);
-            }
+            lines.push(...formatWatchlistSummary(watchlist));
         }
         if (alerts.length > 0) {
             lines.push("Alert rules:");
@@ -447,8 +765,7 @@ function buildSavedMarketStateContext(db) {
             }
         }
         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");
     }
@@ -464,21 +781,6 @@ function shouldIncludeSavedMarketStateContext(workflowType, resolvedTurnContext,
     // general finance or LLM-router fallback), never for pass-through prompts.
     return workflowType != null || fallbackContext != null;
 }
-function formatMoney(value, currency) {
-    const normalized = currency.toUpperCase();
-    if (normalized === "USD")
-        return `$${value.toFixed(2)}`;
-    return `${normalized} ${value.toFixed(2)}`;
-}
-function formatJsonSummary(value) {
-    if (value == null)
-        return "";
-    const json = JSON.stringify(value);
-    if (json.length <= 90)
-        return json;
-    return `${json.slice(0, 87)}...`;
-}
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=session-coordinator.js.map

package/dist/runtime/session-title.js

@@ -47,4 +47,3 @@ function sanitizeTitle(raw) {
     }
     return title;
 }
-//# sourceMappingURL=session-title.js.map

package/dist/runtime/tool-defaults-wrapper.js

@@ -24,4 +24,3 @@ function mergeDefaults(defaults, args) {
 function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=tool-defaults-wrapper.js.map