@gestaltrun/dsh-agent-eval 0.0.0-stage → 0.1.1

package/lib/types/production-workspace.d.ts

@@ -0,0 +1,64 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { type CaseDataTask, type CaseDataReplayEntry } from '@gestaltrun/dsh-cs-hosting/case-data';
+import { type SalesCase, type SalesTimelineMessage } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+import { type ProductionOperations } from './script-production.ts';
+import type { AgentRuns } from './agent-runs.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        /** Interrupted evaluation turn which received a recovery follow-up. */
+        'evaluation-restart': {
+            readonly kind: 'evaluation-restart';
+            readonly turnStartSeq: import('@deepseek-ai/dsh-session').SessionSeq;
+        };
+    }
+}
+/** Task timing choices, resolved by the evaluation plugin at load. */
+export interface ProductionWorkspaceConfig {
+    readonly taskTimeoutMs: number;
+    readonly scriptTaskTimeoutMs: number;
+    readonly dealWindowDays: number;
+    readonly orderLookbackDays: number;
+}
+/** Opens the built-in workspace only; every task owns and disposes its own Agent Session. */
+export declare class ProductionWorkspace {
+    private readonly ctx;
+    private readonly tenantId;
+    private readonly config;
+    private readonly agentRuns?;
+    private readonly fromCollection;
+    private readonly runId?;
+    private readonly replay;
+    private path;
+    private loaded;
+    /** @param ctx - Production task and merchant capabilities. @param tenantId - Captured shop identity. @param config - Resolved timing choices. @param agentRuns - Optional administrator task observer. @param fromCollection - Uses a separate fresh-collection checkpoint. @param runId - Durable production identity for reopening interrupted Sessions. */
+    constructor(ctx: Context, tenantId: string, config: ProductionWorkspaceConfig, agentRuns?: AgentRuns | undefined, fromCollection?: boolean, runId?: string | undefined);
+    private taskReference;
+    /** @param buyers - Authoritative server buyer pagination. @param budget - Live quota admission. @returns Pipeline task and checkpoint operations. */
+    operations(buyers: ProductionOperations['buyers'], budget: ProductionOperations['budget']): ProductionOperations;
+    /**
+     * @param caseId - Demand line the script was written from.
+     * @param revision - Case revision recorded on the script.
+     * @param signal - Checkpoint read lifetime.
+     * @returns Replay collected for that revision on this Host, or empty when this Host retains none.
+     */
+    replayOf(caseId: string, revision: number, signal: AbortSignal): Promise<readonly CaseDataReplayEntry[]>;
+    private location;
+    private load;
+    private save;
+    private timeline;
+    private collect;
+    private author;
+    private session;
+}
+/**
+ * Build one current-revision task from formal messages; only explicit linked entity identifiers enter read scopes.
+ * Messages carry readable bodies; the Host renders them as a dated transcript with short references.
+ * @param row - Current sales case.
+ * @param timeline - Complete buyer timeline.
+ * @param destinations - Server dictionary.
+ * @param captureTime - Host capture instant.
+ * @param config - Configured order windows.
+ * @returns One buyer-bound case task.
+ */
+export declare function caseDataInput(row: z.infer<typeof SalesCase>, timeline: readonly z.infer<typeof SalesTimelineMessage>[], destinations: CaseDataTask['destinations'], captureTime: number, config: Pick<ProductionWorkspaceConfig, 'dealWindowDays' | 'orderLookbackDays'>): CaseDataTask;

package/lib/types/purchase-intent.d.ts

@@ -0,0 +1,66 @@
+/** Product-owned capture of the original buying-analysis results for persisted buyer inputs. */
+import { z } from 'zod';
+import type { Branded } from '@deepseek-ai/dsh-brand';
+import type { BuyingAdmissionObservations } from '@gestaltrun/dsh-cs-hosting';
+import type { EvaluationScript } from './types.ts';
+/** Formal optional v1 schema; legacy records omit it. */
+export { PurchaseIntent as EvaluationPurchaseIntent } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+import { PurchaseIntent as EvaluationPurchaseIntent } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+/** Failure categories retained only in operator records. */
+export declare const PurchaseIntentUnavailableReason: z.ZodEnum<{
+    failed: "failed";
+    timeout: "timeout";
+    disabled: "disabled";
+    "not-collected": "not-collected";
+    reconstructed: "reconstructed";
+    cancelled: "cancelled";
+}>;
+export type PurchaseIntentUnavailableReason = z.infer<typeof PurchaseIntentUnavailableReason>;
+/** Opaque input identity supplied by a target transport. */
+export type EvaluationInputId = Branded<'EvaluationInputId'>;
+/** Opaque persisted admission identity supplied by a target. */
+export type EvaluationAdmissionId = Branded<'EvaluationAdmissionId'>;
+/** A persisted external-buyer batch, projected from the target Session source. */
+export interface PurchaseIntentAdmission {
+    readonly id: EvaluationAdmissionId;
+    readonly messageIds: readonly EvaluationInputId[];
+}
+/** Runner-owned turn and message identities joined to transport input identities. */
+export interface PurchaseIntentStep {
+    readonly turn: number;
+    readonly at: number;
+    readonly inputs: readonly {
+        readonly messageId: string;
+        readonly sourceMessageIds: readonly EvaluationInputId[];
+    }[];
+    readonly failure?: PurchaseIntentUnavailableReason;
+}
+/** Capture lifetime for one isolated case. */
+export interface PurchaseIntentObserver {
+    /** @param step - Persisted target inputs and the runner's canonical identities. */
+    record(step: PurchaseIntentStep): void;
+    /** @returns Original observations retained during this case; no cache rebuild or model request occurs. */
+    snapshot(): EvaluationPurchaseIntent;
+    /** Release the underlying observation reader. */
+    dispose(): void;
+}
+/** Product adapter that observes one isolated target without requesting model work. */
+export interface PurchaseIntentObserverFactory<Binding> {
+    /** @param script - Frozen case. @param binding - Target-owned resources. @returns One case-scoped capture. */
+    open(script: EvaluationScript, binding: Binding): PurchaseIntentObserver;
+}
+/** Joins only exact persisted source ids; equal text and equal clocks do not establish identity. */
+export declare class PurchaseIntentCapture implements PurchaseIntentObserver {
+    private readonly reader;
+    private readonly admissions;
+    private readonly inputs;
+    private readonly points;
+    /** @param reader - Case-scoped raw observations. @param admissions - Current persisted admission sources for this case. */
+    constructor(reader: BuyingAdmissionObservations, admissions: () => readonly PurchaseIntentAdmission[]);
+    /** @inheritdoc */
+    record(step: PurchaseIntentStep): void;
+    /** @inheritdoc */
+    snapshot(): EvaluationPurchaseIntent;
+    /** @inheritdoc */
+    dispose(): void;
+}

package/lib/types/record.d.ts

@@ -0,0 +1,169 @@
+/** Formal server record validation with local opaque identities. */
+import { z } from 'zod';
+import { type Branded } from '@deepseek-ai/dsh-brand';
+/** Opaque case identity from the evaluation set. */
+export type EvaluationCaseId = Branded<'EvaluationCaseId'>;
+/** Opaque script identity from the versioned script source. */
+export type EvaluationScriptId = Branded<'EvaluationScriptId'>;
+/** Server contract package version consumed by this runner. */
+export declare const EVALUATION_CONTRACT_REVISION = "0.2.32-pre.3";
+/** Formal record timestamp, message and check schemas. */
+export { EvaluationTime, EvaluationMessage, EvaluationCheck } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+/** Branded identities serialize unchanged; all server fields and reference checks remain active. */
+export declare const EvaluationCaseRecord: z.ZodObject<{
+    buyerInvalidReason: z.ZodOptional<z.ZodEnum<{
+        "boundary-rewrites-exhausted": "boundary-rewrites-exhausted";
+        "boundary-check-failed": "boundary-check-failed";
+    }>>;
+    sales: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodEnum<{
+            other: "other";
+            presales: "presales";
+        }>;
+        simulatedDeal: z.ZodBoolean;
+        purchaseIntent: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            source: z.ZodLiteral<"buying-insights">;
+            questionVersion: z.ZodString;
+            samplePhase: z.ZodLiteral<"buyer-admitted-before-assistant">;
+            points: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                observationId: z.ZodString;
+                turn: z.ZodNumber;
+                buyerMessageIds: z.ZodArray<z.ZodString>;
+                at: z.ZodNumber;
+                status: z.ZodLiteral<"observed">;
+                score: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                observationId: z.ZodString;
+                turn: z.ZodNumber;
+                buyerMessageIds: z.ZodArray<z.ZodString>;
+                at: z.ZodNumber;
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodEnum<{
+                    failed: "failed";
+                    timeout: "timeout";
+                    disabled: "disabled";
+                    "not-collected": "not-collected";
+                    reconstructed: "reconstructed";
+                    cancelled: "cancelled";
+                }>;
+            }, z.core.$strict>], "status">>;
+        }, z.core.$strict>>;
+        humanComparisons: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            turn: z.ZodNumber;
+            buyerMessageId: z.ZodString;
+            originalBuyerMessageId: z.ZodString;
+            originalHumanMessageId: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    schemaVersion: z.ZodLiteral<1>;
+    scriptVersion: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        turn: z.ZodNumber;
+        role: z.ZodEnum<{
+            operator: "operator";
+            buyer: "buyer";
+            assistant: "assistant";
+        }>;
+        at: z.ZodNumber;
+        clockAt: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    originalMessages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        turn: z.ZodNumber;
+        role: z.ZodEnum<{
+            operator: "operator";
+            buyer: "buyer";
+            assistant: "assistant";
+        }>;
+        at: z.ZodNumber;
+        clockAt: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    tools: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        turn: z.ZodNumber;
+        at: z.ZodNumber;
+        command: z.ZodString;
+        arguments: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        result: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull, z.ZodArray<z.ZodUnknown>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        status: z.ZodEnum<{
+            error: "error";
+            timeout: "timeout";
+            ok: "ok";
+        }>;
+        replay: z.ZodEnum<{
+            hit: "hit";
+            miss: "miss";
+            passthrough: "passthrough";
+            not_applicable: "not_applicable";
+        }>;
+        affectsConclusion: z.ZodBoolean;
+    }, z.core.$strict>>;
+    requiredFacts: z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        turn: z.ZodNumber;
+        command: z.ZodString;
+        available: z.ZodBoolean;
+    }, z.core.$strict>>;
+    orderFactsAvailable: z.ZodBoolean;
+    facts: z.ZodArray<z.ZodObject<{
+        turn: z.ZodNumber;
+        at: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    buyerKnowledge: z.ZodString;
+    referenceConclusion: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            required: "required";
+            recommended: "recommended";
+            forbidden: "forbidden";
+        }>;
+        text: z.ZodString;
+        turns: z.ZodArray<z.ZodNumber>;
+        destination: z.ZodOptional<z.ZodString>;
+        dependsOnOrderFacts: z.ZodBoolean;
+    }, z.core.$strict>>;
+    humanActions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        turn: z.ZodNumber;
+        at: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            correction: "correction";
+            stop: "stop";
+            proposal: "proposal";
+            violation: "violation";
+        }>;
+        channel: z.ZodEnum<{
+            conversation: "conversation";
+            private: "private";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodNumber;
+    endReason: z.ZodEnum<{
+        error: "error";
+        timeout: "timeout";
+        paused: "paused";
+        handoff: "handoff";
+        cancelled: "cancelled";
+        goal_reached: "goal_reached";
+        buyer_abandoned: "buyer_abandoned";
+        message_limit: "message_limit";
+    }>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cost: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    caseId: z.ZodPipe<z.ZodString, z.ZodTransform<EvaluationCaseId, string>>;
+    scriptId: z.ZodPipe<z.ZodString, z.ZodTransform<EvaluationScriptId, string>>;
+}, z.core.$strict>;
+export type EvaluationCaseRecord = z.infer<typeof EvaluationCaseRecord>;

package/lib/types/replay-world.d.ts

@@ -0,0 +1,25 @@
+import type { MerchantPlatformCommands } from '@gestaltrun/dsh-cs-hosting/merchant-cli';
+import type { ImAccountId } from '@gestaltrun/dsh-im-runtime';
+import type { EvaluationCaseRecord } from './record.ts';
+import type { ImEvaluationBinding } from './im-target.ts';
+import type { EvaluationReplayEntry, EvaluationReplayRequirement, EvaluationScript, EvaluationWorld, EvaluationWorldHandle } from './types.ts';
+/** One already-validated historical command result. */
+export type ReplayEntry = EvaluationReplayEntry;
+/** World inputs are case-local and must belong to the evaluated shop. */
+export interface ReplayWorldOptions {
+    readonly accountId: ImAccountId;
+    readonly caseId: EvaluationCaseRecord['caseId'];
+    readonly entries: readonly ReplayEntry[];
+    /** Reads whose misses affect scoring; omission makes every seller-read miss affect scoring; platform misses require an explicit entry. */
+    readonly requiredReads?: readonly EvaluationReplayRequirement[];
+}
+/** Each attachment owns its trace; facts must precede both the query time and case clock, with exact non-time arguments except the explicit snapshot product views and recorded snapshot `include*` sections, which answer any requested subset. */
+export declare class CustomerServiceReplayWorld implements EvaluationWorld<ImEvaluationBinding> {
+    private readonly commands;
+    private readonly options;
+    /** @param commands - Production merchant CLI Host. @param options - Validated historical results for one shop. */
+    constructor(commands: Pick<MerchantPlatformCommands, 'registerSimulationRead'>, options: ReplayWorldOptions);
+    /** @param binding - Running target pair. @param script - Frozen role input. @param signal - Case lifetime. @returns Instance-local replay evidence and disposer. */
+    attach(binding: ImEvaluationBinding, script: EvaluationScript, signal: AbortSignal): Promise<EvaluationWorldHandle>;
+    private find;
+}

package/lib/types/reply-latency.d.ts

@@ -0,0 +1,21 @@
+/** First durable AI reply to one accepted simulation input, independent of the script clock. */
+import type { ToolCallId } from '@deepseek-ai/dsh-llm';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import { type ImDeliveryScope, type ImMessageId, type ImRuntimeService } from '@gestaltrun/dsh-im-runtime';
+import type { FirstReplyTiming } from '@gestaltrun/dsh-cs-hosting/types';
+/** One round's observation, frozen before cancellation cleanup can deliver late results. */
+export interface ReplyLatencyObserver {
+    /** @param messageId - Exact buyer receipt; paused receipts have no reply observation. */
+    acceptInput(messageId: ImMessageId): void;
+    /** @param callId - Send-tool call identity. @param value - Structured send result from the tool pipeline; unrecognized receipts are ignored. */
+    acceptReply(callId: ToolCallId, value: unknown): void;
+    /** Preserve the observation endpoint; late receipts can still identify sends completed before it. Repeated calls keep the same endpoint. */
+    freeze(): void;
+    /** @returns Frozen timing, or undefined when no matching buyer input was observed. */
+    snapshot(): FirstReplyTiming | undefined;
+    /** Freeze and release the delivery listener. */
+    dispose(): void;
+}
+/** @param ctx - Event owner for this active round. @param runtime - Durable outbound and handling-state reader. @param scope - Exact evaluated conversation. @param now - Monotonic Host milliseconds. @param session - Tested Session containing consumed inputs and send-tool receipts. @returns Observer installed before buyer injection; the caller disposes it after the round. */
+export declare function observeReplyLatency(ctx: Context, runtime: Pick<ImRuntimeService, 'getOutbound' | 'queryOutbound' | 'getHandlingControl'>, scope: ImDeliveryScope, now: () => number, session: Session): ReplyLatencyObserver;

package/lib/types/runner.d.ts

@@ -0,0 +1,97 @@
+/** Domain-independent execution of one versioned evaluation case. */
+import { z } from 'zod';
+import { EvaluationCaseRecord } from './record.ts';
+import { type EvaluationHumanAction, type EvaluationRunRecord } from './human-actions.ts';
+import { EvaluationSalesOptions } from './sales.ts';
+import type { PurchaseIntentObserverFactory } from './purchase-intent.ts';
+import type { FirstReplyTiming } from '@gestaltrun/dsh-cs-hosting/types';
+import type { EvaluationMetricPack, EvaluationRole, EvaluationScript, EvaluationScriptSource, EvaluationTarget, EvaluationVariant, EvaluationWorld } from './types.ts';
+/** Host-controlled execution limits. */
+export interface Config {
+    /** Buyer message ceiling, including the last answered message; defaults to 150. */
+    readonly maxBuyerMessages?: number;
+    /** Real elapsed milliseconds allowed for one reply; defaults to 120000. */
+    readonly responseTimeoutMs?: number;
+    /** Currency used by this run's usage observations; defaults to CNY. */
+    readonly currency?: string;
+    /** Number of eligible cases receiving one planned human action; defaults to 3. */
+    readonly humanActionSampleSize?: number;
+}
+/** Concrete execution limits. */
+export declare const Config: z.ZodObject<{
+    maxBuyerMessages: z.ZodDefault<z.ZodNumber>;
+    responseTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    currency: z.ZodDefault<z.ZodString>;
+    humanActionSampleSize: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/** One buyer turn's monotonic first-reply observation. */
+export interface EvaluationReplyObservation extends FirstReplyTiming {
+    readonly turn: number;
+}
+/** All domain choices needed for one run. */
+export interface EvaluationRequest<Binding> {
+    readonly script: EvaluationScript;
+    readonly target: EvaluationTarget<Binding>;
+    readonly role: EvaluationRole<Binding>;
+    readonly world: EvaluationWorld<Binding>;
+    readonly metrics: EvaluationMetricPack;
+    /** Explicit Host-side plan for a controlled single-case run. */
+    readonly humanAction?: EvaluationHumanAction;
+    /** Optional product-owned capture; it does not change model requests or annotation injection. */
+    readonly purchaseIntent?: PurchaseIntentObserverFactory<Binding>;
+    /** Observe a contained step failure; absence leaves only the terminal record. */
+    readonly onFailure?: (error: unknown) => void;
+    /** Receives first-reply observations without extending the server case record. */
+    readonly onReplyTiming?: (value: EvaluationReplyObservation) => void;
+}
+/** One seeded run; roles never choose or emit its human actions. */
+export interface EvaluationRunRequest<Binding> {
+    readonly cases: readonly Omit<EvaluationRequest<Binding>, 'humanAction'>[];
+    /** Replay seed; omission creates one that is retained in the returned record. */
+    readonly seed?: string;
+    /** Server sales-run options; every case script must declare its sales phase. */
+    readonly sales?: EvaluationSalesOptions;
+}
+/** Two annotation groups over the same scripts, seed and human-action plan. */
+export interface EvaluationPairedRequest<Binding> {
+    readonly cases: readonly Omit<EvaluationRequest<Binding>, 'humanAction'>[];
+    /** Same-store category and optional calibration; pair and comparison ids are filled by the runner. */
+    readonly sales: Pick<EvaluationSalesOptions, 'category'> & Pick<Partial<EvaluationSalesOptions>, 'calibrationId'>;
+    readonly variants: readonly EvaluationVariant[];
+    /** Comparison seed; omission creates one shared by both groups. */
+    readonly seed?: string;
+    /** Annotation pair identity; omission creates one shared by both groups. */
+    readonly pairId?: string;
+}
+/** Both completed groups of one paired sales run. */
+export interface EvaluationPairedResult {
+    readonly pairId: string;
+    readonly seed: string;
+    readonly groups: readonly EvaluationRunRecord[];
+}
+/** Execute the fixed buyer messages without generating or inferring new buyer knowledge. */
+export declare const deterministicRole: EvaluationRole;
+/** A runner owns limits; target and world instances own all external resources. */
+export declare class EvaluationRunner {
+    private readonly config;
+    /** @param config - Validated deployment limits; omitted fields use the documented defaults. */
+    constructor(config?: Config);
+    /** @param request - Cases with optional script-authored human plans and an optional replay seed. @param signal - Run lifetime. @returns The seed, selected plans and completed case records; setup/cleanup errors reject. */
+    runCases<Binding>(request: EvaluationRunRequest<Binding>, signal?: AbortSignal): Promise<EvaluationRunRecord>;
+    /**
+     * Run the same scripts once under each annotation variant, sharing seed, pair id and human-action plan.
+     * @param request - Cases, sales category and exactly one annotation-on and one annotation-off variant.
+     * @param signal - Run lifetime.
+     * @returns Both group records whose `sales.annotation` marks the group.
+     */
+    runPaired<Binding>(request: EvaluationPairedRequest<Binding>, signal?: AbortSignal): Promise<EvaluationPairedResult>;
+    /** @param source - Versioned script source. @param caseId - Requested case. @param adapters - Target, world, role and metric pack. @param signal - Caller lifetime. @returns The server-compatible version-1 record. */
+    runFrom<Binding>(source: EvaluationScriptSource, caseId: EvaluationCaseRecord['caseId'], adapters: Omit<EvaluationRequest<Binding>, 'script'>, signal?: AbortSignal): Promise<EvaluationCaseRecord>;
+    /**
+     * Run one case and join target work before removing its world.
+     * @param request - Frozen script and domain adapters.
+     * @param signal - Caller cancellation; omitted means no caller deadline.
+     * @returns A record with Host-derived termination and usage. Setup/cleanup failures reject; step failures produce error records.
+     */
+    run<Binding>(request: EvaluationRequest<Binding>, signal?: AbortSignal): Promise<EvaluationCaseRecord>;
+}

package/lib/types/sales.d.ts

@@ -0,0 +1,33 @@
+/** Sales-run options and per-case results shared with server#164 (agent-evaluation-sales.ts). */
+import { z } from 'zod';
+import type { EvaluationCaseRecord } from './record.ts';
+import { EvaluationSalesOptions, EvaluationSalesRecord } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+/** Formal sales schemas; ordinary runs omit sales options and non-presales records omit intent. */
+export { EvaluationSalesOptions, EvaluationSalesRecord } from '@gestaltrun/dsh-cs-hosting/sales-case-contract';
+export type EvaluationSalesOptions = z.infer<typeof EvaluationSalesOptions>;
+export type EvaluationSalesRecord = z.infer<typeof EvaluationSalesRecord>;
+/** One simulated buyer turn paired with the recorded buyer wording and human reply. */
+export declare const EvaluationSalesHumanComparison: z.ZodObject<{
+    turn: z.ZodNumber;
+    buyerMessageId: z.ZodString;
+    originalBuyerMessageId: z.ZodString;
+    originalHumanMessageId: z.ZodString;
+}, z.core.$strict>;
+export type EvaluationSalesHumanComparison = z.infer<typeof EvaluationSalesHumanComparison>;
+/**
+ * Pair each answered simulated buyer message with the next original buyer message of identical wording
+ * that has an operator reply before the next original buyer message.
+ * @param messages - Simulated timeline.
+ * @param originalMessages - Historical human conversation.
+ * @returns One reference per simulated turn, in message order.
+ */
+export declare function humanComparisonsFor(messages: EvaluationCaseRecord['messages'], originalMessages: EvaluationCaseRecord['originalMessages']): EvaluationSalesHumanComparison[];
+/**
+ * Build the case-level sales extension.
+ * @param phase - Script sales phase; non-presales cases never report a deal or comparisons.
+ * @param simulatedDeal - Whether the buyer mindset reached the ordering state.
+ * @param messages - Simulated timeline.
+ * @param originalMessages - Historical human conversation.
+ * @returns Validated sales record.
+ */
+export declare function salesRecordFor(phase: 'presales' | 'other', simulatedDeal: boolean, messages: EvaluationCaseRecord['messages'], originalMessages: EvaluationCaseRecord['originalMessages']): EvaluationSalesRecord;