opencandle 0.11.0 → 0.12.0

package/dist/routing/router.js

@@ -2,6 +2,7 @@ import { extractEntities, isAmbiguousConceptUsage, isCurrencyCodeUsage, } from "
 import { classifyWithLegacyRules } from "./legacy-rule-router.js";
 import { computeMissingRequiredSlots, isDispatchableWorkflow, isRouteKind, isToolBundleName, legacyRouteForRouteKind, routeKindFromLegacyRoute, selectToolBundles, workflowRequiredSlots, } from "./route-manifest.js";
 import { buildRouterPrompt } from "./router-prompt.js";
+import { mapDteHintToTarget } from "./slot-resolver.js";
 import { disambiguateSymbols } from "./symbol-disambiguator.js";
 const VALID_ROUTES = ["workflow", "fallback"];
 const VALID_WORKFLOWS = [
@@ -26,7 +27,7 @@ export async function route(input, client) {
     let firstError;
     try {
         const raw = await client.complete(prompt);
-        return postProcessRouterOutput(input.text, validateRouterOutput(raw));
+        return postProcessRouterOutput(input.text, validateRouterOutput(raw), input);
     }
     catch (err) {
         firstError = err instanceof Error ? err.message : String(err);
@@ -35,11 +36,11 @@ export async function route(input, client) {
     try {
         const retryPrompt = `${prompt}\n\n(Your previous response failed validation: ${firstError}. Return a valid JSON object conforming to RouterOutput. Nothing else.)`;
         const raw = await client.complete(retryPrompt);
-        return postProcessRouterOutput(input.text, validateRouterOutput(raw));
+        return postProcessRouterOutput(input.text, validateRouterOutput(raw), input);
     }
     catch {
         // Persistent failure — return a minimal fallback with regex-extracted symbols.
-        return postProcessRouterOutput(input.text, minimalFallback(input.text));
+        return postProcessRouterOutput(input.text, minimalFallback(input.text), input);
     }
 }
 export function validateRouterOutput(raw) {
@@ -153,15 +154,17 @@ function validateEntities(raw) {
         out.compareMetrics = compareMetrics;
     return out;
 }
-export function postProcessRouterOutput(text, output) {
+export function postProcessRouterOutput(text, output, inputContext) {
     const extracted = extractEntities(text);
     const deterministic = classifyWithLegacyRules(text);
     let diagnostics = [...output.diagnostics];
+    const symbolsAfterAmbiguousFilter = output.entities.symbols.filter((symbol) => !isAmbiguousConceptUsage(text, symbol));
+    const droppedAmbiguousSymbols = output.entities.symbols.filter((symbol) => !symbolsAfterAmbiguousFilter.includes(symbol));
     let next = {
         ...output,
         entities: {
             ...output.entities,
-            symbols: output.entities.symbols.filter((symbol) => !isAmbiguousConceptUsage(text, symbol)),
+            symbols: symbolsAfterAmbiguousFilter,
             budget: output.entities.budget ?? extracted.budget,
             maxPremium: output.entities.maxPremium ?? extracted.maxPremium,
             timeHorizon: output.entities.timeHorizon ?? extracted.timeHorizon,
@@ -179,6 +182,148 @@ export function postProcessRouterOutput(text, output) {
         },
         diagnostics,
     };
+    if (next.workflow === "compare_assets") {
+        const restorableExtractedSymbols = extracted.symbols.filter((symbol) => disambiguateSymbols([symbol], text).kept.length > 0);
+        const orderedSymbols = orderSymbolsByText(text, mergeSymbols(next.entities.symbols, restorableExtractedSymbols));
+        if (!sameStringArray(orderedSymbols, next.entities.symbols)) {
+            diagnostics.push({
+                code: "compare_symbols_canonicalized",
+                message: "compare symbols restored from deterministic extraction and ordered by user text",
+            });
+            next = {
+                ...next,
+                entities: {
+                    ...next.entities,
+                    symbols: orderedSymbols,
+                },
+                slots: syncSymbolListSlot(next.slots, orderedSymbols),
+                diagnostics,
+            };
+        }
+        // Prior-turn symbols merged into the slot (by the model or by the sync
+        // above) must not claim user provenance: the user typed only what is in
+        // this turn's text, and the Assumptions block renders slot sources.
+        // preference/memory/default sources legitimately reference out-of-text
+        // symbols and are left alone.
+        if (symbolsSlotClaimsPriorTurnUserProvenance(next.slots, text, inputContext?.priorTurns)) {
+            diagnostics.push({
+                code: "symbols_slot_provenance_prior_context",
+                message: "compare symbols slot includes symbols absent from the user text; source downgraded from user to prior_context",
+            });
+            next = {
+                ...next,
+                slots: {
+                    ...next.slots,
+                    symbols: {
+                        ...next.slots.symbols,
+                        source: "prior_context",
+                    },
+                },
+                diagnostics,
+            };
+        }
+    }
+    // The DTE horizon is a named historical loss class; when the model drops
+    // the slot on an options dispatch, the deterministic extraction preserves
+    // the user's stated range (mirrors the profile risk-slot fill below).
+    const dteHint = next.entities.dteHint ?? extracted.dteHint;
+    if (next.workflow === "options_screener" && !next.slots.dte_target && dteHint) {
+        const dteTarget = mapDteHintToTarget(dteHint);
+        if (dteTarget) {
+            diagnostics.push({
+                code: "dte_slot_filled_from_extraction",
+                message: "dte_target slot filled from deterministic horizon extraction",
+            });
+            next = {
+                ...next,
+                slots: {
+                    ...next.slots,
+                    dte_target: {
+                        value: dteTarget,
+                        source: "user",
+                        confidence: "high",
+                    },
+                },
+                diagnostics,
+            };
+        }
+    }
+    // Model-vocabulary synonyms for the canonical asset_scope value
+    // ("etf_only" for "etf_focused") drift saved preferences and slot
+    // consumers onto private vocabularies; canonicalize before the echo
+    // suppression below so restatements still match the profile.
+    next = canonicalizeAssetScopeVocabulary(next);
+    // A preference update that restates the saved profile value is an echo,
+    // not a change; writing it pollutes preference provenance (the
+    // preference-ECHO contract, fixture 029).
+    const echoedUpdates = next.preference_updates.filter((update) => readProfileString(inputContext?.profileSnapshot, update.key) === update.value);
+    if (echoedUpdates.length > 0) {
+        diagnostics.push({
+            code: "preference_echo_suppressed",
+            message: `dropped preference update(s) restating the saved profile: ${echoedUpdates
+                .map((update) => update.key)
+                .join(", ")}`,
+        });
+        next = {
+            ...next,
+            preference_updates: next.preference_updates.filter((update) => !echoedUpdates.includes(update)),
+            diagnostics,
+        };
+    }
+    const profileRiskProfile = readProfileString(inputContext?.profileSnapshot, "risk_profile");
+    if (next.workflow === "portfolio_builder" &&
+        profileRiskProfile &&
+        !next.slots.risk_profile &&
+        !next.entities.riskProfile) {
+        diagnostics.push({
+            code: "profile_risk_slot_filled",
+            message: "risk_profile slot filled from investor profile snapshot",
+        });
+        next = {
+            ...next,
+            slots: {
+                ...next.slots,
+                risk_profile: {
+                    value: profileRiskProfile,
+                    source: "preference",
+                    confidence: "high",
+                },
+            },
+            diagnostics,
+        };
+    }
+    if (next.routeKind === "pass_through" &&
+        extracted.riskProfile &&
+        isConversationalRiskPreferenceUpdate(text, inputContext)) {
+        diagnostics.push({
+            code: "conversational_risk_preference_recovered",
+            message: "risk preference update recovered from profile/prior-turn context",
+        });
+        next = {
+            ...next,
+            routeKind: "agent_task",
+            route: "fallback",
+            entities: {
+                ...next.entities,
+                riskProfile: extracted.riskProfile,
+            },
+            slots: {
+                ...next.slots,
+                risk_profile: {
+                    value: extracted.riskProfile,
+                    source: "user",
+                    confidence: "high",
+                },
+            },
+            preference_updates: ensurePreferenceUpdate(next.preference_updates, {
+                key: "risk_profile",
+                value: extracted.riskProfile,
+                confidence: "high",
+                source: "inferred",
+            }),
+            diagnostics,
+        };
+    }
     if (next.workflow === "options_screener" &&
         isExistingPositionOptionRequest(text, extracted) &&
         extracted.heldSymbol) {
@@ -456,6 +601,24 @@ export function postProcessRouterOutput(text, output) {
             diagnostics,
         };
     }
+    if (next.workflow === "compare_assets" &&
+        (disambiguated.dropped.length > 0 || droppedAmbiguousSymbols.length > 0) &&
+        next.entities.symbols.length < 2 &&
+        isExplicitMacroDataRequest(text)) {
+        diagnostics.push({
+            code: "compare_route_corrected_to_macro_task",
+            message: "macro/source acronyms were not explicit tickers",
+        });
+        next = {
+            ...next,
+            routeKind: "agent_task",
+            route: "fallback",
+            workflow: "general_finance_qa",
+            missing_required: [],
+            slots: removeSymbolSlots(next.slots),
+            diagnostics,
+        };
+    }
     const missingRequired = computeMissingRequiredSlots(next.workflow, next.entities, next.slots, next.missing_required);
     if (missingRequired.length > 0 && next.routeKind !== "pass_through") {
         if (next.routeKind !== "clarification") {
@@ -698,6 +861,112 @@ function canonicalizeSymbolSlots(workflow, slots) {
     }
     return next;
 }
+function syncSymbolListSlot(slots, symbols) {
+    if (!slots.symbols || symbols.length === 0)
+        return slots;
+    return {
+        ...slots,
+        symbols: {
+            ...slots.symbols,
+            value: symbols,
+        },
+    };
+}
+const ASSET_SCOPE_SYNONYMS = {
+    etf_only: "etf_focused",
+    etfs_only: "etf_focused",
+    only_etfs: "etf_focused",
+    etf: "etf_focused",
+    etfs: "etf_focused",
+};
+function canonicalAssetScope(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return ASSET_SCOPE_SYNONYMS[value.toLowerCase()];
+}
+function canonicalizeAssetScopeVocabulary(output) {
+    let next = output;
+    const slotCanonical = canonicalAssetScope(next.slots.asset_scope?.value);
+    if (slotCanonical) {
+        next = {
+            ...next,
+            slots: {
+                ...next.slots,
+                asset_scope: { ...next.slots.asset_scope, value: slotCanonical },
+            },
+        };
+    }
+    const entityCanonical = canonicalAssetScope(next.entities.assetScope);
+    if (entityCanonical) {
+        next = {
+            ...next,
+            entities: { ...next.entities, assetScope: entityCanonical },
+        };
+    }
+    if (next.preference_updates.some((update) => update.key === "asset_scope" && canonicalAssetScope(update.value))) {
+        next = {
+            ...next,
+            preference_updates: next.preference_updates.map((update) => update.key === "asset_scope"
+                ? { ...update, value: canonicalAssetScope(update.value) ?? update.value }
+                : update),
+        };
+    }
+    return next;
+}
+function symbolsSlotClaimsPriorTurnUserProvenance(slots, text, priorTurns) {
+    const slot = slots.symbols;
+    if (slot?.source !== "user" || !Array.isArray(slot.value))
+        return false;
+    if (!priorTurns || priorTurns.length === 0)
+        return false;
+    const priorText = priorTurns.map((turn) => turn.text).join("\n");
+    // A symbol absent from this turn's text but present in prior turns is a
+    // carryover, not a user-typed value. Symbols absent from both (e.g. tickers
+    // resolved from company names in the current text) are left alone.
+    return slot.value.some((symbol) => typeof symbol === "string" &&
+        symbolPosition(text, symbol) === Number.MAX_SAFE_INTEGER &&
+        symbolPosition(priorText, symbol) !== Number.MAX_SAFE_INTEGER);
+}
+function removeSymbolSlots(slots) {
+    const next = { ...slots };
+    delete next.symbol;
+    delete next.symbols;
+    return next;
+}
+function orderSymbolsByText(text, symbols) {
+    return [...symbols].sort((a, b) => symbolPosition(text, a) - symbolPosition(text, b));
+}
+function symbolPosition(text, symbol) {
+    const escaped = escapeRegExp(symbol);
+    const match = new RegExp(`\\$?${escaped}\\b`, "i").exec(text);
+    return match?.index ?? Number.MAX_SAFE_INTEGER;
+}
+function sameStringArray(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function readProfileString(profileSnapshot, key) {
+    const value = profileSnapshot?.[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function isConversationalRiskPreferenceUpdate(text, inputContext) {
+    if (!/\b(?:now|lately|getting|becoming|thinking|feel|feeling|prefer|preference)\b/i.test(text)) {
+        return false;
+    }
+    // Finance context must come from the conversation itself — a saved
+    // risk_profile alone must not convert non-finance chat ("more aggressive
+    // on the tennis court lately") into a routed preference write.
+    const priorText = inputContext?.priorTurns.map((turn) => turn.text).join(" ") ?? "";
+    return /\b(?:profile|risk|portfolio|position|invest|sizing)\b/i.test(`${text} ${priorText}`);
+}
+function ensurePreferenceUpdate(updates, update) {
+    if (updates.some((item) => item.key === update.key && item.value === update.value)) {
+        return updates;
+    }
+    return [...updates, update];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function validatePreferenceUpdates(raw) {
     if (raw === undefined || raw === null)
         return [];
@@ -822,4 +1091,3 @@ function minimalFallback(text) {
         reasoning: "router validation failed; emitted minimal fallback",
     };
 }
-//# sourceMappingURL=router.js.map

package/dist/routing/slot-resolver.d.ts

@@ -10,6 +10,7 @@ interface Preferences {
     moneynessPreference?: string;
     liquidityMinimum?: string;
 }
+export declare function mapDteHintToTarget(dteHint: string | undefined): string | undefined;
 export declare function resolvePortfolioSlots(entities: ExtractedEntities, preferences?: Preferences): SlotResolution<PortfolioSlots>;
 export declare function resolveOptionsScreenerSlots(entities: ExtractedEntities, preferences?: Preferences): SlotResolution<OptionsScreenerSlots>;
 export {};

package/dist/routing/slot-resolver.js

@@ -1,5 +1,5 @@
 import { OPTIONS_SCREENER_DEFAULTS, PORTFOLIO_DEFAULTS } from "./defaults.js";
-function mapDteHintToTarget(dteHint) {
+export function mapDteHintToTarget(dteHint) {
     const normalized = dteHint?.toLowerCase().trim();
     if (!normalized)
         return undefined;
@@ -155,4 +155,3 @@ export function resolveOptionsScreenerSlots(entities, preferences = {}) {
         missingRequired,
     };
 }
-//# sourceMappingURL=slot-resolver.js.map

package/dist/routing/symbol-disambiguator.js

@@ -49,4 +49,3 @@ function hasLocalTickerPhrase(token, rawInput) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-//# sourceMappingURL=symbol-disambiguator.js.map

package/dist/routing/turn-context.js

@@ -42,4 +42,3 @@ function memoryEntryToProvenance(entry) {
         confidence: entry.confidence,
     };
 }
-//# sourceMappingURL=turn-context.js.map

package/dist/routing/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/runtime/answer-contracts.js

@@ -450,4 +450,3 @@ function structuredResult(checkId, passed, failureReason) {
         failureReason,
     };
 }
-//# sourceMappingURL=answer-contracts.js.map

package/dist/runtime/artifact-contracts.js

@@ -54,4 +54,3 @@ export function validateArtifactContractRegistry() {
     }
     return errors;
 }
-//# sourceMappingURL=artifact-contracts.js.map

package/dist/runtime/evidence.d.ts

@@ -19,6 +19,7 @@ export interface ProviderResultOk<T> {
     status: "ok";
     data: T;
     timestamp: string;
+    cached?: boolean;
     stale?: boolean;
 }
 /** Failed/unavailable provider result. */

package/dist/runtime/evidence.js

@@ -26,4 +26,3 @@ export function toEvidenceRecord(label, result, providerId) {
         },
     };
 }
-//# sourceMappingURL=evidence.js.map

package/dist/runtime/numeric-claims.d.ts

@@ -0,0 +1,23 @@
+import type { EvidenceRecord } from "./evidence.js";
+/**
+ * Observe-only numeric-claim extraction for synthesis validation (I3).
+ *
+ * These heuristics bind numbers in analyst prose to tool-result metrics so
+ * checkNumberMatch has claims to verify. They are deliberately conservative:
+ * every false mismatch poisons the false-positive-rate data that gates the
+ * answer-receipts direction (I8 phase 1), so a missed claim is cheaper than
+ * a wrong one.
+ */
+/** Flatten numeric values from a tool-evidence digest preview into labeled tool results. */
+export declare function collectToolNumbers(record: EvidenceRecord, toolResults: Map<string, number>): void;
+/**
+ * Extract numeric claims from step text for metrics present in toolResults.
+ *
+ * Binding rules (each guards against a live-observed false-positive class):
+ * - the metric term must appear as a whole word ("opening" is not `open`)
+ * - the number must follow within a short window (no cross-sentence binding)
+ * - thousands separators parse as one number ("129,935,067" is not 129)
+ * - a prose value that rounds to the tool result is normalized onto it
+ *   ("197.14" claims the tool's 197.13999938964844, not a mismatch)
+ */
+export declare function extractNumericClaims(text: string, toolResults: Map<string, number>): EvidenceRecord[];

package/dist/runtime/numeric-claims.js

@@ -0,0 +1,99 @@
+/**
+ * Observe-only numeric-claim extraction for synthesis validation (I3).
+ *
+ * These heuristics bind numbers in analyst prose to tool-result metrics so
+ * checkNumberMatch has claims to verify. They are deliberately conservative:
+ * every false mismatch poisons the false-positive-rate data that gates the
+ * answer-receipts direction (I8 phase 1), so a missed claim is cheaper than
+ * a wrong one.
+ */
+/** Flatten numeric values from a tool-evidence digest preview into labeled tool results. */
+export function collectToolNumbers(record, toolResults) {
+    if (!isPlainObject(record.value))
+        return;
+    const tool = typeof record.value.tool === "string" ? record.value.tool : undefined;
+    const digest = isPlainObject(record.value.resultDigest) ? record.value.resultDigest : undefined;
+    const preview = typeof digest?.preview === "string" ? digest.preview : undefined;
+    if (!tool || !preview)
+        return;
+    const parsed = parseMaybeJson(preview);
+    if (!parsed)
+        return;
+    for (const [path, value] of flattenNumericValues(parsed)) {
+        toolResults.set(`${tool}.${path}`, value);
+    }
+}
+/**
+ * Extract numeric claims from step text for metrics present in toolResults.
+ *
+ * Binding rules (each guards against a live-observed false-positive class):
+ * - the metric term must appear as a whole word ("opening" is not `open`)
+ * - the number must follow within a short window (no cross-sentence binding)
+ * - thousands separators parse as one number ("129,935,067" is not 129)
+ * - a prose value that rounds to the tool result is normalized onto it
+ *   ("197.14" claims the tool's 197.13999938964844, not a mismatch)
+ */
+export function extractNumericClaims(text, toolResults) {
+    const records = [];
+    for (const [label, expected] of toolResults) {
+        const metric = label.split(".").at(-1);
+        if (!metric)
+            continue;
+        const pattern = new RegExp(`\\b${escapeRegex(metric)}\\b[^\\d-]{0,30}(-?\\d{1,3}(?:,\\d{3})+(?:\\.\\d+)?|-?\\d+(?:\\.\\d+)?)`, "i");
+        const match = text.match(pattern);
+        if (!match)
+            continue;
+        const value = Number(match[1].replace(/,/g, ""));
+        if (!Number.isFinite(value))
+            continue;
+        records.push({
+            label,
+            value: isRoundingOf(value, expected) ? expected : value,
+            provenance: { source: "computed" },
+        });
+    }
+    return records;
+}
+/** True when `claim` is `expected` rounded to the claim's own precision. */
+function isRoundingOf(claim, expected) {
+    if (claim === expected)
+        return true;
+    const decimals = countDecimals(claim);
+    const factor = 10 ** decimals;
+    return Math.round(expected * factor) / factor === claim;
+}
+function countDecimals(value) {
+    const text = String(value);
+    const dot = text.indexOf(".");
+    return dot === -1 ? 0 : text.length - dot - 1;
+}
+function flattenNumericValues(value, prefix = "") {
+    const values = [];
+    for (const [key, item] of Object.entries(value)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof item === "number" && Number.isFinite(item)) {
+            values.push([path, item]);
+        }
+        else if (isPlainObject(item)) {
+            values.push(...flattenNumericValues(item, path));
+        }
+    }
+    return values;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseMaybeJson(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPlainObject(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/runtime/planning-evidence.js

@@ -1,3 +1,4 @@
+import { classifyMarketStatus, KNOWN_US_MARKET_HOLIDAYS, lastTradingDay, localDateTimeParts, } from "../infra/market-calendar.js";
 import { parseToolTag } from "../onboarding/tool-tags.js";
 export const EVIDENCE_PLAN_REGISTRY = {
     market_status: {
@@ -30,18 +31,6 @@ export const EVIDENCE_PLAN_REGISTRY = {
     placeholder_stateful_tracking_update: placeholderPlan("placeholder_stateful_tracking_update", ["stateful_tracking_update"], []),
     placeholder_general_fallback: placeholderPlan("placeholder_general_fallback", ["general_fallback"], []),
 };
-const KNOWN_US_MARKET_HOLIDAYS = {
-    "2026-01-01": "New Year's Day",
-    "2026-01-19": "Martin Luther King Jr. Day",
-    "2026-02-16": "Washington's Birthday",
-    "2026-04-03": "Good Friday",
-    "2026-05-25": "Memorial Day",
-    "2026-06-19": "Juneteenth",
-    "2026-07-03": "Independence Day observed",
-    "2026-09-07": "Labor Day",
-    "2026-11-26": "Thanksgiving Day",
-    "2026-12-25": "Christmas Day",
-};
 function placeholderPlan(id, taskFamilies, capabilityGapIds) {
     return {
         id,
@@ -389,19 +378,6 @@ function temporalReferencesFor(text) {
         refs.push("holiday");
     return refs;
 }
-function classifyMarketStatus(local, isWeekend, isMarketHoliday, temporalReferences) {
-    if (isWeekend)
-        return "closed_weekend";
-    if (isMarketHoliday)
-        return "closed_holiday";
-    if (local.minutesSinceMidnight < 9 * 60 + 30)
-        return "pre_market";
-    if (local.minutesSinceMidnight < 16 * 60)
-        return "open";
-    if (temporalReferences.includes("after_close"))
-        return "after_close";
-    return "closed_after_hours";
-}
 function quoteAsOfCaveat(marketStatus) {
     if (marketStatus === "open")
         return "Quote evidence may be intraday or delayed depending on provider.";
@@ -409,58 +385,6 @@ function quoteAsOfCaveat(marketStatus) {
         return "Quote evidence may reflect the previous regular session until premarket data is fetched.";
     return "Quote evidence should distinguish the current calendar date from the most recent trading session.";
 }
-function localDateTimeParts(date, timezone) {
-    const formatter = new Intl.DateTimeFormat("en-US", {
-        timeZone: timezone,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-        hour12: false,
-        weekday: "short",
-    });
-    const parts = formatter.formatToParts(date).reduce((acc, part) => {
-        acc[part.type] = part.value;
-        return acc;
-    }, {});
-    const hour = Number(parts.hour);
-    const minute = Number(parts.minute);
-    return {
-        date: `${parts.year}-${parts.month}-${parts.day}`,
-        time: `${parts.hour}:${parts.minute}`,
-        weekday: parts.weekday ?? "",
-        minutesSinceMidnight: hour * 60 + minute,
-    };
-}
-function lastTradingDay(localDate) {
-    let cursor = dateFromKey(localDate);
-    do {
-        cursor = addDays(cursor, -1);
-    } while (isWeekendOrKnownHoliday(dateKey(cursor)));
-    return dateKey(cursor);
-}
-function isWeekendOrKnownHoliday(key) {
-    const date = dateFromKey(key);
-    const day = date.getUTCDay();
-    return day === 0 || day === 6 || KNOWN_US_MARKET_HOLIDAYS[key] !== undefined;
-}
-function dateFromKey(key) {
-    const [year, month, day] = key.split("-").map(Number);
-    return new Date(Date.UTC(year, month - 1, day));
-}
-function addDays(date, days) {
-    const next = new Date(date);
-    next.setUTCDate(next.getUTCDate() + days);
-    return next;
-}
-function dateKey(date) {
-    const year = date.getUTCFullYear();
-    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
-    const day = String(date.getUTCDate()).padStart(2, "0");
-    return `${year}-${month}-${day}`;
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=planning-evidence.js.map

package/dist/runtime/prompt-step.d.ts

@@ -1,3 +1,5 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { EvidenceRecord } from "./evidence.js";
 import type { StepOutput, WorkflowStep } from "./workflow-types.js";
 /**
  * A workflow step definition that carries its prompt text.
@@ -25,7 +27,14 @@ export declare function promptStep(stepType: string, description: string, prompt
  * Create a StepOutput for a prompt-based step (no structured evidence yet).
  * Evidence will be captured separately via tool call hooks.
  */
-export declare function promptStepOutput(stepIndex: number, stepType: string): StepOutput;
+export declare function promptStepOutput(stepIndex: number, stepType: string, options?: {
+    evidence?: EvidenceRecord[];
+    rawText?: string;
+}): StepOutput;
+/** Capture compact evidence records from session entries produced by one step. */
+export declare function captureToolEvidence(entries: SessionEntry[]): EvidenceRecord[];
+/** Extract assistant text emitted during a step, preserving final response order. */
+export declare function extractAssistantText(entries: SessionEntry[]): string;
 /**
  * Extract just the WorkflowStep metadata from PromptStep definitions
  * (dropping the prompt field) for passing to WorkflowRunner.