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

package/lib/cs-hosting.js

@@ -0,0 +1,2 @@
+import { n as inject, r as name, t as apply } from "./cs-hosting-plugin-B9bjLaoE.js";
+export { apply, inject, name };

package/lib/index.js

@@ -0,0 +1,2 @@
+import { A as EvaluationReplyTimeout, C as planHumanActions, D as EvaluationMessage, E as EvaluationCheck, O as EvaluationTime, S as humanActionChannel, T as EvaluationCaseRecord, _ as EvaluationSalesHumanComparison, a as ImPurchaseIntentObserver, b as humanComparisonsFor, c as MerchantServerScriptSource, d as CustomerServiceReplayWorld, f as SimulatedBuyerRole, g as deterministicRole, h as EvaluationRunner, i as AgentEvaluationService, j as EvaluationStepFailure, k as EvaluationCaseFailure, l as merchantScriptReader, m as Config, o as EvaluationPurchaseIntent, p as ImEvaluationTarget, s as PurchaseIntentCapture, t as apply, u as scriptOf, v as EvaluationSalesOptions, w as EVALUATION_CONTRACT_REVISION, x as salesRecordFor, y as EvaluationSalesRecord } from "./cs-hosting-plugin-B9bjLaoE.js";
+export { AgentEvaluationService, Config, CustomerServiceReplayWorld, EVALUATION_CONTRACT_REVISION, EvaluationCaseFailure, EvaluationCaseRecord, EvaluationCheck, EvaluationMessage, EvaluationPurchaseIntent, EvaluationReplyTimeout, EvaluationRunner, EvaluationSalesHumanComparison, EvaluationSalesOptions, EvaluationSalesRecord, EvaluationStepFailure, EvaluationTime, ImEvaluationTarget, ImPurchaseIntentObserver, MerchantServerScriptSource, PurchaseIntentCapture, SimulatedBuyerRole, apply as applyCsHostingEvaluation, deterministicRole, humanActionChannel, humanComparisonsFor, merchantScriptReader, planHumanActions, salesRecordFor, scriptOf };

package/lib/types/agent-runs.d.ts

@@ -0,0 +1,56 @@
+/** Process-local evaluation task observations; Session logs remain the durable transcript. */
+import type { CsHostingAgentTask } from '@gestaltrun/dsh-cs-hosting';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { EvaluationCaseRecord } from './record.ts';
+/** An opened task Session and its optional IM pairing. */
+export type AgentTaskStart = Omit<CsHostingAgentTask, 'sessions' | 'taskKey'> & {
+    readonly taskKey: string;
+    readonly sessionId: string;
+};
+/** Task references could not be saved before execution. */
+export declare class AgentTaskPersistenceError extends Error {
+    readonly code = "EVALUATION_TASK_METADATA_UNCONFIRMED";
+    /** @param cause - Host-only storage failure. */
+    constructor(cause: unknown);
+}
+/** @param tasks - Task references from a live run or storage. @returns The references without process-local simulation instance ids, which restored tasks never carry. */
+export declare function inspectionTasks(tasks: readonly CsHostingAgentTask[]): readonly CsHostingAgentTask[];
+/** One evaluation's observable tasks, grouped across revision-driven Session reopens. */
+export declare class AgentRuns {
+    private readonly recentLimit;
+    private readonly changed;
+    private readonly persist;
+    private tasks;
+    private readonly submissions;
+    /** @param recentLimit - Number of ended tasks retained beside active tasks. @param changed - Publish updated evaluation state. @param persist - Wait for durable task references. */
+    constructor(recentLimit: number, changed: () => void, persist?: () => Promise<void>);
+    /** @returns After task references have been persisted. */
+    flush(): Promise<void>;
+    /** @param input - Task identity and opened Session. @param at - Start time. @param resumedAfterRestart - Session continued after Host restart. */
+    start({ sessionId, ...input }: AgentTaskStart, at?: number, resumedAfterRestart?: boolean): void;
+    /** @param sessionId - Observed Session. @param command - Tool name or CLI command without arguments. */
+    step(sessionId: string, command: string): void;
+    /** @param sessionId - Session whose submission the Host rejected. */
+    reject(sessionId: string): void;
+    /** @param sessionId - Completed Session. @param status - Terminal outcome. @param reasonCode - Stable failure code. @param at - End time. */
+    finish(sessionId: string, status: 'submitted' | 'failed' | 'cancelled', reasonCode?: string, at?: number): void;
+    /** @param sessionId - Tested Session. @param count - Delivered buyer message count. */
+    messages(sessionId: string, count: number): void;
+    /** @param taskKey - Practice task identity. @param status - Settled runner outcome. @param reasonCode - Failure code. */
+    finishTask(taskKey: string, status: 'submitted' | 'failed' | 'cancelled', reasonCode?: string): void;
+    /** @param taskKey - Practice task identity. @param reason - Outcome recorded by the runner after the pair stops. */
+    completePractice(taskKey: string, reason: EvaluationCaseRecord['endReason']): void;
+    /** @param sessionId - Event owner. @param event - Logged tool call or result. */
+    observe(sessionId: string, event: SessionEvent): void;
+    /** @returns All task references retained for a hosting transition, independent of the visible recent limit. */
+    retainedTasks(): readonly CsHostingAgentTask[];
+    /** @param tasks - Validated persisted task references. Restore inspection only; no Agent is resumed. */
+    restore(tasks: readonly CsHostingAgentTask[]): void;
+    /** @param interruptedAt - Last executor report as an estimate, when available. */
+    interruptForRestart(interruptedAt?: number): void;
+    /** @returns Every owned transcript reference, including tasks outside the visible recent limit. */
+    sessionIds(): readonly string[];
+    /** @returns Active tasks and the configured number of most recently ended tasks, with complete Session histories. */
+    snapshot(): readonly CsHostingAgentTask[];
+    private update;
+}

package/lib/types/cs-hosting-evaluation.d.ts

@@ -0,0 +1,235 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import { CsHostingEvaluation, type CsHostingEvaluationRun, type CsHostingEvaluationView, type CsHostingEvaluationResume } from '@gestaltrun/dsh-cs-hosting';
+import { type CsHostingAgentTask, type CsHostingEvaluationCommandId, type CsHostingEvaluationJobId, type CsHostingScriptCap } from '@gestaltrun/dsh-cs-hosting/types';
+import { type EvaluationHumanAction } from './human-actions.ts';
+import { type EvaluationReplyObservation } from './runner.ts';
+import { type ServerEvaluationScript } from './server-script-source.ts';
+import { ScriptRecoveryRequest, type ProductionOperations } from './script-production.ts';
+import type { EvaluationCaseRecord } from './record.ts';
+/** Deployment limits and estimates for the pre-evaluation run. */
+export interface Config {
+    /** Explicit administrator-started script recovery; its operation id is applied once per checkpoint. */
+    readonly productionScriptRecovery?: z.input<typeof ScriptRecoveryRequest>;
+    /** Recently ended Agent tasks beside active tasks; defaults to 20. */
+    readonly recentAgentTaskLimit?: number;
+    /** Initially selected buyer/last-message window, 1–180 days; defaults to 30. Must occur in historyWindowOptions. */
+    readonly historyWindowDays?: number;
+    /** Selectable history windows, unique integers from 1–180; defaults to 7, 30, 90 and 180. */
+    readonly historyWindowOptions?: readonly number[];
+    /** Script admission cap. `auto` admits at most 200 cases the quota can pay for; 50, 100, or 200 admit at most that many. */
+    readonly scriptCap?: 'auto' | 50 | 100 | 200;
+    /** Maximum desktop evaluations in flight; defaults to 2. */
+    readonly desktopConcurrency?: number;
+    /** Consecutive settled Host/transport failures of the same code before stopping; defaults to 3. */
+    readonly practiceSystemicFailureLimit?: number;
+    /** Case-data workers; configurable from cordis.yml, defaults to 2. */
+    readonly productionTaskConcurrency?: number;
+    /** Script-authoring workers; configurable from cordis.yml, integers 1–16, defaults to 4. */
+    readonly productionScriptConcurrency?: number;
+    /** Delay between production job reads; defaults to 1000 ms. */
+    readonly productionPollIntervalMs?: number;
+    /** Maximum wait for one server production job; defaults to 30 minutes. */
+    readonly productionJobTimeoutMs?: number;
+    /** Maximum duration of one case-data Session; defaults to 10 minutes. */
+    readonly productionTaskTimeoutMs?: number;
+    /** Maximum duration of one script-authoring Session; defaults to 20 minutes. */
+    readonly productionScriptTaskTimeoutMs?: number;
+    /** Refill attempts when a case revision changes; defaults to 3. */
+    readonly productionRevisionRetries?: number;
+    /** Additional transient case-page read attempts; defaults to 3. */
+    readonly productionCaseReadRetries?: number;
+    /** First exponential case-page retry delay; defaults to 1000 ms. */
+    readonly productionCaseReadRetryInitialMs?: number;
+    /** Case-page retry-delay ceiling; defaults to 10000 ms. */
+    readonly productionCaseReadRetryMaxMs?: number;
+    /** Days after the final case message covered by order matching; defaults to 7. */
+    readonly productionDealWindowDays?: number;
+    /** Days before the first case message included in order search; defaults to 30. */
+    readonly productionOrderLookbackDays?: number;
+    /** Estimated tokens for collecting one case; defaults to 8000. */
+    readonly estimatedDataTokensPerCase?: number;
+    /** Estimated USD for collecting one case; defaults to 0.03. */
+    readonly estimatedDataCostUsdPerCase?: number;
+    /** Estimated tokens for authoring one script; defaults to 6000. */
+    readonly estimatedScriptTokensPerCase?: number;
+    /** Estimated USD for authoring one script; defaults to 0.02. */
+    readonly estimatedScriptCostUsdPerCase?: number;
+    /** Estimated cases for each not-yet-aggregated buyer; defaults to 2. */
+    readonly estimatedCasesPerBuyer?: number;
+    /** Real milliseconds allowed for one tested-Agent reply; defaults to 120000. */
+    readonly responseTimeoutMs?: number;
+    /** Real milliseconds allowed for one simulated-buyer step; defaults to 120000. */
+    readonly buyerStepTimeoutMs?: number;
+    /** First-reply latency target in milliseconds; reporting only, defaults to 30000. */
+    readonly firstReplyTargetMs?: number;
+    /** Buyer message ceiling per case. */
+    readonly maxBuyerMessages?: number;
+    /** Estimated input+output tokens per case for the start-page budget. */
+    readonly estimatedTokensPerCase?: number;
+    /** Estimated USD per case for the real monthly quota check. */
+    readonly estimatedCostUsdPerCase?: number;
+    /** Explicit provider input price used by the target's usage observation. */
+    readonly inputPerMillion?: number;
+    /** Explicit provider output price used by the target's usage observation. */
+    readonly outputPerMillion?: number;
+    /** Currency for target usage. */
+    readonly currency?: string;
+    /** Delay between report reads while server judging is pending; defaults to 1000 ms. */
+    readonly reportPollIntervalMs?: number;
+    /** Eligible cases receiving one authored action; defaults to 3. */
+    readonly humanActionSampleSize?: number;
+    /** Reproducible action seed; trimmed value must contain 1–120 characters. Omission generates and records one per run. */
+    readonly humanActionSeed?: string;
+}
+/** @param script - Frozen case and judge inputs. @param signal - Case lifetime. @param humanAction - Optional Host-selected action; omission runs without operator input. @param onReplyTiming - Observes accepted buyer rounds without changing the server record. @returns The settled case record. */
+export type EvaluationCaseDriver = (script: ServerEvaluationScript, signal: AbortSignal, humanAction?: EvaluationHumanAction, onReplyTiming?: (value: EvaluationReplyObservation) => void) => Promise<EvaluationCaseRecord>;
+/** One pre-evaluation run owned by the Host; the tested Agent and simulated buyer use production presets. */
+export declare class AgentEvaluationService extends CsHostingEvaluation {
+    private readonly drive?;
+    private readonly productionOperations?;
+    static inject: string[];
+    private readonly metadata;
+    private readonly config;
+    private summary;
+    private loading;
+    private error;
+    private errorCode;
+    private skippedOutsideWindow;
+    private skippedPrescreen;
+    private prepareCounts;
+    private dataProgress;
+    private scriptProgress;
+    private collectionRestart;
+    private productionFromCollection;
+    private dataCollection;
+    private collectionFailureCount;
+    private collectionFailureReasons;
+    private scriptFailureCount;
+    private scriptFailureReasons;
+    private invalidScripts;
+    private scriptRecoveryOperationIds;
+    private selectedHistoryWindowDays;
+    private selectedScriptCap;
+    private runHistoryWindowDays;
+    private previewAbort;
+    private metadataBlocked;
+    private run;
+    private plan;
+    private practiceMissing;
+    private firstReplies;
+    private productionSetId;
+    private resumeWindow;
+    private runCoverageSetId;
+    private abort;
+    private execution;
+    private starting;
+    private startingJobId;
+    private startingCommandId;
+    private activeJobId;
+    private activeCommandId;
+    private resuming;
+    private lastResume;
+    private lastResumeRequestId;
+    private cancelling;
+    private runIdentity;
+    private summaryIdentity;
+    private scopeGeneration;
+    private closed;
+    private hostingPending;
+    private cleanupUnconfirmed;
+    private cleanupCause;
+    private preparingHosting;
+    private preparingScope;
+    /** Exact settled projection and identity certified by NOT_FOUND plus the durable batch audit. */
+    private completedProductionCancellation;
+    private readonly lifetime;
+    private readonly refreshes;
+    private readonly shopReadiness;
+    private agentRuns;
+    /** Run and serialized task list most recently written to, or restored from, run metadata. */
+    private retainedAgentTasks;
+    private agentTaskWrites;
+    private agentTaskWriteFailure;
+    /** @param ctx - Host context. @param config - deployment limits and estimates. */
+    constructor(ctx: Context, config?: Config, drive?: EvaluationCaseDriver | undefined, productionOperations?: ProductionOperations | undefined);
+    /** @returns start-page facts and the latest run projection. */
+    view(): CsHostingEvaluationView;
+    /** @returns All task references of the current run, independent of the local recent limit. */
+    retainedTasks(): readonly CsHostingAgentTask[];
+    private noteStageProgress;
+    private rememberProduction;
+    private failureView;
+    private failureMetadata;
+    private isAdmin;
+    /**
+     * Create one server run, coalescing concurrent starts, then execute the T4 runner in the background.
+     * @returns the initial running projection.
+     */
+    start(jobId?: CsHostingEvaluationJobId, commandId?: CsHostingEvaluationCommandId): Promise<CsHostingEvaluationRun>;
+    /** @param jobId - Server assignment. @param interruptedAt - Last executor report, if known. @param commandId - Individual command identity, if recovering a claimed command. @returns Its matching local recovery, or null if it has not started. */
+    resumeAssigned(jobId: CsHostingEvaluationJobId, interruptedAt: string | null, commandId?: CsHostingEvaluationCommandId): Promise<CsHostingEvaluationResume | null>;
+    /** @param jobId - Server assignment. @param runId - Current Host run. @returns Whether this captured shop owns the exact assignment. */
+    ownsAssignment(jobId: CsHostingEvaluationJobId, runId: string): boolean;
+    /** @param runId - Persisted server run. @param interruptedAt - Last executor report, if known. @returns Restored execution and recovery times. */
+    resume(runId: string, interruptedAt: string | null): Promise<CsHostingEvaluationResume>;
+    private resumeRun;
+    /** @returns A fresh immutable set with forced collection, or the unfinished restart batch; administrator only. */
+    restartFromCollection(jobId?: CsHostingEvaluationJobId, commandId?: CsHostingEvaluationCommandId): Promise<CsHostingEvaluationRun>;
+    /** @returns The active production batch after audited retry grants for failed primary cases, alternates and script slots; only idle administrators may invoke it. */
+    retryFailedCases(jobId?: CsHostingEvaluationJobId, commandId?: CsHostingEvaluationCommandId): Promise<CsHostingEvaluationRun>;
+    /**
+     * Select a configured history window and replace the complete preview; active runs keep their admitted range.
+     * @param days - One of the configured historyWindowOptions.
+     * @returns After the replacement preview settles; previous reads are aborted and joined on disposal.
+     */
+    setHistoryWindowDays(days: number): Promise<void>;
+    /**
+     * Select how many scripts the next run may admit and refresh the preview.
+     * @param cap - `auto` or a fixed cap of 50, 100, or 200.
+     * @returns After the replacement preview settles. An in-progress run keeps the cap it started with.
+     */
+    setScriptCap(cap: CsHostingScriptCap): Promise<void>;
+    private startRun;
+    /** @returns the server-confirmed run, or its last known state with a visible cancellation failure. */
+    cancel(): Promise<CsHostingEvaluationRun | null>;
+    private cancelOperation;
+    /** @returns After evaluation joins and confirms cancellation; unknown cleanup blocks formal hosting. */
+    prepareForHosting(): Promise<void>;
+    private prepareHosting;
+    private cleanupStep;
+    private logCleanupPhase;
+    private checkPendingCreations;
+    private writeMetadata;
+    private cancelRun;
+    private cancelRunResult;
+    private cancelPersistedProduction;
+    private productionWorkspace;
+    private productionPipeline;
+    private produce;
+    private createServerRun;
+    private execute;
+    private productionDriver;
+    private submit;
+    private poll;
+    private observe;
+    private control;
+    private identity;
+    private fail;
+    private failProduction;
+    private emit;
+    private createAgentRuns;
+    /** Persist task references before their Sessions perform work. */
+    private retainAgentTasks;
+    private refresh;
+    private previewRefreshAllowed;
+    private followShopReadiness;
+    private readinessStopped;
+    private track;
+    private productionBudget;
+    private productionSummary;
+    private collectionRestartPreview;
+    private refreshData;
+}
+/** @param count - Uncapped admission count. @param cap - Operator cap. @returns The count production and the preview may admit. */
+export declare function applyScriptCap(count: number, cap: CsHostingScriptCap): number;

package/lib/types/cs-hosting-plugin.d.ts

@@ -0,0 +1,10 @@
+/** Cordis plugin that registers the server-backed pre-evaluation service. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type Config } from './cs-hosting-evaluation.ts';
+export declare const name = "gestaltrun-agent-eval-cs-hosting";
+export declare const inject: string[];
+/**
+ * @param ctx - Host context.
+ * @param config - deployment limits and estimates.
+ */
+export declare function apply(ctx: Context, config?: Config): Promise<void>;

package/lib/types/handoff.d.ts

@@ -0,0 +1,4 @@
+/** Confirmed transfer state shared by evaluation role and target adapters. */
+import type { ImHandlingControl } from '@gestaltrun/dsh-im-runtime';
+/** @param control - Current automatic-handling state. @returns Whether the shop AI confirmed a transfer to staff. */
+export declare function isConfirmedHandoff(control: ImHandlingControl | undefined): boolean;

package/lib/types/human-actions.d.ts

@@ -0,0 +1,36 @@
+import type { EvaluationCaseRecord } from './record.ts';
+import type { EvaluationSalesOptions } from './sales.ts';
+import type { EvaluationScript } from './types.ts';
+/** One script-authored action at a buyer turn's boundary. */
+export interface EvaluationHumanAction {
+    readonly kind: EvaluationCaseRecord['humanActions'][number]['kind'];
+    readonly turn: number;
+    readonly phase: 'before-buyer' | 'after-buyer' | 'after-reply';
+    readonly text: string;
+}
+/** One selected case and action; a case is selected at most once. */
+export interface EvaluationHumanActionSelection {
+    readonly caseId: EvaluationCaseRecord['caseId'];
+    readonly action: EvaluationHumanAction;
+}
+/** Run-level observations; individual case records retain the server's version-1 fields. */
+export interface EvaluationRunRecord {
+    readonly schemaVersion: 1;
+    readonly seed: string;
+    readonly plannedHumanActions: readonly EvaluationHumanActionSelection[];
+    readonly cases: readonly EvaluationCaseRecord[];
+    /** Server sales-run options; paired groups share the pair and comparison ids and differ only by annotation. */
+    readonly sales?: EvaluationSalesOptions;
+}
+/** @param action - Script-authored action. @param turns - Available buyer turns. @returns Validated action; invalid or unreachable turns reject before a target opens. */
+export declare function validateHumanAction(action: EvaluationHumanAction, turns: number): EvaluationHumanAction;
+/** @param kind - Script-authored action kind. @returns Conversation for public answers/corrections, otherwise private operator input. */
+export declare function humanActionChannel(kind: EvaluationHumanAction['kind']): 'conversation' | 'private';
+/**
+ * Rank eligible cases and their authored actions using SHA-256; input order does not affect selection.
+ * @param scripts - Unique case identities and optional action plans.
+ * @param seed - Run seed, recorded by the caller before replay.
+ * @param count - Maximum number of distinct cases to select; zero disables human actions.
+ * @returns One validated action per selected case in stable rank order; no text is generated.
+ */
+export declare function planHumanActions(scripts: readonly EvaluationScript[], seed: string, count: number): EvaluationHumanActionSelection[];

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

@@ -0,0 +1,12 @@
+import type { BuyingInsights } from '@gestaltrun/dsh-cs-hosting';
+import type { ImEvaluationBinding } from './im-target.ts';
+import { type PurchaseIntentObserver, type PurchaseIntentObserverFactory } from './purchase-intent.ts';
+import type { EvaluationScript } from './types.ts';
+/** Only a running pair's tested Session may supply purchase-intent observations. */
+export declare class ImPurchaseIntentObserver implements PurchaseIntentObserverFactory<ImEvaluationBinding> {
+    private readonly insights;
+    /** @param insights - Shop-owned raw analysis source; opening a reader performs no analysis. */
+    constructor(insights: Pick<BuyingInsights, 'observeAdmissions'>);
+    /** @param _script - Frozen evaluation case. @param binding - Pair and tested Agent owned by that case. @returns An effect-owned reader matched to persisted buyer admissions. */
+    open(_script: EvaluationScript, binding: ImEvaluationBinding): PurchaseIntentObserver;
+}

package/lib/types/im-target.d.ts

@@ -0,0 +1,45 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImSimulationInstanceView, ImRuntimeService } from '@gestaltrun/dsh-im-runtime';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { WorkspaceId } from '@deepseek-ai/dsh-workspace';
+import type { AgentRuns } from './agent-runs.ts';
+import type { EvaluationConversation, EvaluationScript, EvaluationTarget } from './types.ts';
+/** References passed only to the customer-service world and role adapters. */
+export interface ImEvaluationBinding {
+    readonly instance: ImSimulationInstanceView;
+    /** Tested customer-service Agent. */
+    readonly agent: Agent;
+    /** Simulated-user Agent in the evaluation buyer Workspace. */
+    readonly buyer: Agent;
+    readonly runtime: ImRuntimeService;
+}
+/** Host-selected buyer workspace and explicit provider prices. */
+export interface ImEvaluationTargetOptions {
+    readonly agentRuns?: AgentRuns;
+    /** Display title supplied by the script source, with no effect on model input. */
+    readonly title?: (script: EvaluationScript) => string;
+    readonly buyerWorkspaceId: WorkspaceId;
+    readonly buyerPreset: string;
+    readonly pricing: {
+        readonly inputPerMillion: number;
+        readonly outputPerMillion: number;
+        readonly currency: string;
+    };
+}
+/** Production target; every run owns a new pair and keeps durable Sessions for inspection. */
+export declare class ImEvaluationTarget implements EvaluationTarget<ImEvaluationBinding> {
+    private readonly ctx;
+    private readonly options;
+    /** @param ctx - Host with the production IM runtime, presets, workspaces and Session persistence. @param options - Prepared buyer workspace and provider pricing. */
+    constructor(ctx: Context, options: ImEvaluationTargetOptions);
+    /** @param script - Frozen case. @param signal - Caller lifetime. @returns New isolated pair using the configured target route's real preset. */
+    open(script: EvaluationScript, signal: AbortSignal): Promise<EvaluationConversation<ImEvaluationBinding>>;
+    private requireHandoff;
+    private closePair;
+    private send;
+    private intervene;
+    private injectHuman;
+    private perform;
+    private uncheckedError;
+    private collect;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,22 @@
+/** Product-owned evaluation execution and extension points. */
+export { EvaluationRunner, Config, deterministicRole } from './runner.ts';
+export type { EvaluationPairedRequest, EvaluationPairedResult, EvaluationRequest, EvaluationRunRequest } from './runner.ts';
+export { EvaluationCaseRecord, EvaluationMessage, EvaluationCheck, EvaluationTime, EVALUATION_CONTRACT_REVISION } from './record.ts';
+export { EvaluationSalesOptions, EvaluationSalesRecord, EvaluationSalesHumanComparison, humanComparisonsFor, salesRecordFor } from './sales.ts';
+export type * from './types.ts';
+export { ImEvaluationTarget } from './im-target.ts';
+export type { ImEvaluationBinding, ImEvaluationTargetOptions } from './im-target.ts';
+export { SimulatedBuyerRole } from './simulated-buyer-role.ts';
+export type { SimulatedBuyerRoleOptions } from './simulated-buyer-role.ts';
+export { CustomerServiceReplayWorld } from './replay-world.ts';
+export type { ReplayEntry, ReplayWorldOptions } from './replay-world.ts';
+export { EvaluationStepFailure, EvaluationCaseFailure, EvaluationReplyTimeout } from './step-failure.ts';
+export { MerchantServerScriptSource, merchantScriptReader, scriptOf } from './server-script-source.ts';
+export type { ServerEvaluationScript, ServerScriptAccount, ServerScriptReader, ServerScriptSourceOptions } from './server-script-source.ts';
+export { planHumanActions, humanActionChannel } from './human-actions.ts';
+export type { EvaluationHumanAction, EvaluationHumanActionSelection, EvaluationRunRecord } from './human-actions.ts';
+export { AgentEvaluationService, type Config as AgentEvaluationConfig } from './cs-hosting-evaluation.ts';
+export { ImPurchaseIntentObserver } from './im-purchase-intent.ts';
+export { EvaluationPurchaseIntent, PurchaseIntentCapture } from './purchase-intent.ts';
+export type { EvaluationInputId, EvaluationAdmissionId, PurchaseIntentStep, PurchaseIntentAdmission, PurchaseIntentObserver, PurchaseIntentObserverFactory } from './purchase-intent.ts';
+export { apply as applyCsHostingEvaluation } from './cs-hosting-plugin.ts';

package/lib/types/input-admission.d.ts

@@ -0,0 +1,10 @@
+/** Match accepted simulation inputs to their durable Session messages. */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { MessageId } from '@deepseek-ai/dsh-llm';
+import type { ImMessageId } from '@gestaltrun/dsh-im-runtime';
+/** Transport input or private operator-message identity, with its original brand. */
+export type EvaluationReceiptId = ImMessageId | MessageId;
+/** @param event - Persisted event. @param id - Accepted transport or private-message identity. @returns Whether the model-visible input consumes that receipt; queued inbox items are not yet model input. */
+export declare function consumesInput(event: SessionEvent, id: EvaluationReceiptId): boolean;
+/** @param event - Persisted event. @param id - Accepted transport or private-message identity. @returns Whether the Agent durably queued that input, even if a later pre-step discards it. */
+export declare function queuesInput(event: SessionEvent, id: EvaluationReceiptId): boolean;

package/lib/types/practice-failure.d.ts

@@ -0,0 +1,17 @@
+import type { EvaluationCaseRecord } from './record.ts';
+import type { ServerEvaluationScript } from './server-script-source.ts';
+/** Failure disposition used by the case-local retry and systemic stop policy. */
+export interface PracticeFailure {
+    readonly kind: 'case' | 'host' | 'transport';
+    readonly code: string;
+}
+/** A run-level stop that must retain its checkpoint and all submitted cases. */
+export declare class PracticeRunFailure extends Error {
+    readonly code: string;
+    /** @param code - Stable systemic, budget, evidence or uncertain-write reason. */
+    constructor(code: string);
+}
+/** @param error - Original failure, or absence for a returned terminal record. @param record - Settled evidence when available. @returns Stable reason and systemic category. */
+export declare function practiceFailure(error: unknown, record?: EvaluationCaseRecord): PracticeFailure;
+/** @param script - Frozen source identifiers and permitted knowledge. @param currency - Observed-cost currency. @returns Empty observed evidence when a driver supplies none; no buyer message or inferred expenditure is invented. */
+export declare function emptyPracticeEvidence(script: ServerEvaluationScript, currency: string): EvaluationCaseRecord;

package/lib/types/product-field-policy.d.ts

@@ -0,0 +1,129 @@
+/** Product fields admitted from collection-time details or historical observations. */
+import type { CliResult } from '@gestaltrun/dsh-cs-hosting/merchant-cli';
+type Screen = 'first' | 'second';
+type Change = 'slow' | 'fast' | 'mixed';
+interface FieldRule {
+    readonly subject: string;
+    readonly change: Change;
+    readonly screens: readonly Screen[];
+    readonly fields: readonly string[];
+    readonly snapshotOverride?: boolean;
+}
+/** Explicit volatility and screen table; dotted paths override parent policies, * selects map keys and [] selects array rows. */
+export declare const PRODUCT_FIELD_POLICY: readonly [{
+    readonly subject: "标题";
+    readonly snapshotOverride: true;
+    readonly change: "slow";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["title", "itemTitle", "name", "subTitle"];
+}, {
+    readonly subject: "主图与图片";
+    readonly snapshotOverride: true;
+    readonly change: "slow";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["pictures", "images", "auctionPictures", "mainPic", "picUrl", "extraImageMap"];
+}, {
+    readonly subject: "类目";
+    readonly snapshotOverride: true;
+    readonly change: "slow";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["category", "categoryId", "catId", "catDOList"];
+}, {
+    readonly subject: "行程与地点";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["itinerary", "duration", "location", "address", "cityName", "city", "prov"];
+}, {
+    readonly subject: "费用包含、不含与自费";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["include", "exclude", "costInclude", "costExclude", "feesIncluded", "feesExcluded", "selfPaid", "selfPay", "optionalCosts"];
+}, {
+    readonly subject: "退改";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["refundRules", "cancellationPolicy", "cancelRules", "refund"];
+}, {
+    readonly subject: "预订须知与服务";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["bookingNotice", "bookingNotices", "bookingInstructions", "booking", "services", "terms"];
+}, {
+    readonly subject: "规格";
+    readonly change: "slow";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["sku.data.props"];
+}, {
+    readonly subject: "详情行程";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["itineraryInfo"];
+}, {
+    readonly subject: "详情费用、须知与改期";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["feeInfo.data.feeDetailVOList[].feeInclude", "feeInfo.data.feeDetailVOList[].feeExclude", "feeInfo.data.feeDetailVOList[].feeExtraDesc", "feeInfo.data.feeDetailVOList[].notice", "feeInfo.data.feeDetailVOList[].richNotice", "feeInfo.data.feeDetailVOList[].travelReschedule"];
+}, {
+    readonly subject: "详情退改与安全须知";
+    readonly change: "slow";
+    readonly screens: readonly ["second"];
+    readonly fields: readonly ["standardRefund.data", "safeNotice"];
+}, {
+    readonly subject: "详情当前价格";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["price.price.priceText", "price.firstLinePrice.priceText"];
+}, {
+    readonly subject: "当前日期价格与库存（仅供余位推算的当前库存输入）";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["sku.data.skuMap.*[].dateRanges", "sku.data.skuMap.*[].firstLinePrice.priceText", "sku.data.skuMap.*[].quantity", "sku.data.skuMap.*[].hasQuantity"];
+}, {
+    readonly subject: "价格与日历价";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["price", "displayPrice", "priceInfo", "calendarPrice", "calendarPrices", "calendar", "datePrices", "salePrice"];
+}, {
+    readonly subject: "余位";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["stock", "inventory", "quantity", "amount", "num", "remaining", "remainingSeats", "availability"];
+}, {
+    readonly subject: "团期与 SKU";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["sku", "skuList", "skus", "skuInfo", "skuBase", "skuCore", "skuInfoDOList", "departures", "departureDate", "departureDates", "startDate", "endDate", "date", "useDate"];
+}, {
+    readonly subject: "下架时间";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["delistTime"];
+}, {
+    readonly subject: "促销";
+    readonly change: "fast";
+    readonly screens: readonly ["first"];
+    readonly fields: readonly ["promotion", "promotions", "discount", "discounts", "coupon", "coupons", "activityPrice"];
+}, {
+    readonly subject: "混合正文与属性";
+    readonly change: "mixed";
+    readonly screens: readonly ["first", "second"];
+    readonly fields: readonly ["description", "desc", "descContent", "wirelessDesc", "wirelessDescription", "wirelessDescDO", "content", "properties", "pvDOList", "features"];
+}];
+/** JSON values already admitted by the CLI result parser. */
+export type ProductFields = NonNullable<CliResult['data']>;
+type Json = ProductFields[string];
+/** @param field - Original field name or declared dotted path. @returns Its declared policy, or undefined for an unclassified field. */
+export declare function productFieldRule(field: string): FieldRule | undefined;
+/**
+ * Select named stable or historical dynamic fields without turning opaque mixed text into stable facts.
+ * @param fields - Original projected product fields.
+ * @param screen - Requested detail screen.
+ * @param change - Collection admits slow fields; historical snapshots admit fast fields.
+ * @returns Original names and values, omitting empty values and unclassified roots.
+ */
+export declare function projectProductFields(fields: ProductFields, screen: string, change: 'slow' | 'fast'): ProductFields;
+/** @param value - Projected JSON. @returns Whether it contains a nonempty business value; zero and false remain recorded facts. */
+export declare function productValuePresent(value: Json | undefined): boolean;
+/** @param value - Parsed CLI JSON. @returns Its object fields, excluding arrays and scalars. */
+export declare function productObject(value: Json | undefined): ProductFields | undefined;
+export {};

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

@@ -0,0 +1,21 @@
+/** Per-case cost estimates shared by the start page and production admission checks. */
+/** Remaining model work; completed data submissions and attached scripts have zero remaining units. */
+export interface ProductionWork {
+    readonly data: number;
+    readonly scripts: number;
+    readonly evaluation: number;
+}
+/** Resolved deployment estimates for each kind of model task. */
+export interface ProductionPrices {
+    readonly estimatedDataTokensPerCase: number;
+    readonly estimatedDataCostUsdPerCase: number;
+    readonly estimatedScriptTokensPerCase: number;
+    readonly estimatedScriptCostUsdPerCase: number;
+    readonly estimatedTokensPerCase: number;
+    readonly estimatedCostUsdPerCase: number;
+}
+/** @param work - Remaining task counts. @param prices - Configured per-case estimates. @returns Total estimated tokens and USD. */
+export declare function productionEstimate(work: ProductionWork, prices: ProductionPrices): {
+    tokens: number;
+    costUsd: number;
+};

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

@@ -0,0 +1,20 @@
+/** Formal-message buyer discovery with one fixed server window across cursor pages. */
+import type { MerchantAccount } from '@gestaltrun/dsh-merchant-account';
+/** Fixed formal-message interval requested by the Host. */
+export interface ProductionWindow {
+    readonly from: string;
+    readonly to: string;
+}
+/** Distinct buyers found within the fixed Host interval. */
+export interface ProductionBuyers extends ProductionWindow {
+    readonly buyers: readonly string[];
+}
+/**
+ * Enumerate formal-message buyers independently of local IM history and existing cases.
+ * @param account - Tenant-bound merchant request capability.
+ * @param window - Fixed Host interval sent on every page; the server must return the same timestamps.
+ * @param signal - Shop and caller lifetime; late responses are discarded.
+ * @returns Every distinct buyer in the requested window after the terminal cursor.
+ * @throws ProductionFailure on refusal, a stalled cursor or a changed window; no partial list is returned.
+ */
+export declare function readProductionBuyers(account: Pick<MerchantAccount, 'request'>, window: ProductionWindow, signal: AbortSignal): Promise<ProductionBuyers>;