@tryvitris/website-harness 0.0.0-stage → 0.1.0-beta.5

package/bin/types/src/agent/jev/calibration.d.ts

@@ -0,0 +1,131 @@
+import type { JevMode } from "./types.ts";
+/**
+ * Kernel-controlled calibration. Site-authored `eligible:true` in agent/jev.json
+ * never authorizes delegation. Eligibility is derived only from these artifacts
+ * plus trusted runtime pilot context issued by kernel code.
+ */
+export declare const CALIBRATION_SCHEMA_VERSION: 1;
+export declare const CALIBRATION_ISSUER: "vitris-kernel";
+export declare const DATASET_VERSION = "2026-09-18.1";
+export declare const MODEL_FAMILY = "jev-1.13";
+export type DelegationDenialReason = "work_ownership_not_delegated" | "global_mode_off" | "global_mode_shadow" | "global_mode_not_assist" | "capability_not_assist" | "site_authored_eligible_ignored" | "registry_delegation_flag_ignored" | "no_kernel_calibration" | "calibration_expired" | "calibration_task_version_mismatch" | "calibration_question_semantics_mismatch" | "calibration_model_family_mismatch" | "calibration_dataset_mismatch" | "calibration_sample_size_insufficient" | "calibration_metrics_below_threshold" | "calibration_ineligible" | "pilot_context_required" | "pilot_context_invalid" | "pilot_context_expired" | "pilot_context_task_not_allowed" | "task_not_applicable" | "subject_missing" | "candidate_coverage_incomplete" | "evidence_missing" | "evidence_conflicting" | "evidence_stale" | "manifest_missing" | "manifest_stale" | "budget_exhausted" | "execution_failed" | "execution_uncertain" | "execution_incomplete" | "execution_unavailable";
+export declare const ALL_DELEGATION_DENIAL_REASONS: DelegationDenialReason[];
+/**
+ * Initial delegation order: earlier token savings, high-subjectivity last.
+ * Uncalibrated tasks remain agent-owned even if listed.
+ */
+export declare const DELEGATION_PRIORITY_ORDER: readonly ["business-source-selection", "business-review-grounding", "narrative-review-grounding", "copy-review-grounding", "cta-fidelity-check", "claim-strengthening-check", "cross-stage-consistency-check", "intent-coverage-check", "creative-dimension-scoring", "media-fit-scoring", "component-fit-check"];
+export interface CalibrationMetrics {
+    n: number;
+    truePositives: number;
+    falsePositives: number;
+    trueNegatives: number;
+    falseNegatives: number;
+    precision: number;
+    recall: number;
+    accuracy: number;
+    precisionCi?: [number, number];
+    recallCi?: [number, number];
+    /** False-pass rate (FP / (FP+TN)) — calibrated against extra-agent-review cost. */
+    falsePassRate: number;
+    maxAllowedFalsePassRate: number;
+    minSampleSize: number;
+}
+export interface KernelCalibrationArtifact {
+    schemaVersion: typeof CALIBRATION_SCHEMA_VERSION;
+    issuer: typeof CALIBRATION_ISSUER;
+    taskId: string;
+    taskVersion: string;
+    questionSemanticsHash: string;
+    policyVersion: string;
+    modelFamily: string;
+    datasetVersion: string;
+    sampleSize: number;
+    metrics: CalibrationMetrics;
+    thresholds: {
+        grounding: number;
+        routing: number;
+    };
+    eligible: boolean;
+    /** Pilot-only artifacts require trusted runtime pilot context. */
+    pilotOnly: boolean;
+    expiresAt: string;
+    revalidation: {
+        afterDays: number;
+        requiresHeldoutRerun: boolean;
+    };
+    notes: string;
+}
+export interface TrustedPilotContext {
+    schemaVersion: 1;
+    issuer: typeof CALIBRATION_ISSUER;
+    trialId: string;
+    kernelRevision: string;
+    issuedAt: string;
+    expiresAt: string;
+    allowedTaskIds: string[];
+    integrityHash: string;
+}
+export interface CoverageAssessment {
+    complete: boolean;
+    candidateCount: number;
+    evaluatedCount: number;
+    coveredObligationIds: string[];
+    retainedObligationIds: string[];
+    missingEvidenceIds: string[];
+    conflictingClaimIds: string[];
+    staleEvidence: boolean;
+}
+export interface RemainingBudget {
+    transportAttempts: number;
+    inputTokens: number;
+}
+export interface ManifestCheck {
+    present: boolean;
+    current: boolean;
+    expectedModel?: string;
+    expectedQuestionSemantics?: string;
+    batchStateHashes?: string[];
+    subjectHash?: string;
+}
+export declare function computeCalibrationMetrics(opts: {
+    tp: number;
+    fp: number;
+    tn: number;
+    fn: number;
+    maxAllowedFalsePassRate: number;
+    minSampleSize: number;
+}): CalibrationMetrics;
+/** Test-only overlay. Production callers never use this. */
+export declare function replaceCalibrationRegistryForTests(artifacts: KernelCalibrationArtifact[]): () => void;
+export declare function getKernelCalibration(taskId: string): KernelCalibrationArtifact | undefined;
+export declare function allKernelCalibrations(): KernelCalibrationArtifact[];
+export declare function issueTrustedPilotContext(opts: {
+    trialId: string;
+    kernelRevision: string;
+    allowedTaskIds: string[];
+    ttlMs?: number;
+    now?: Date;
+}): TrustedPilotContext;
+export declare function verifyTrustedPilotContext(ctx: TrustedPilotContext | undefined, opts: {
+    now?: Date;
+    expectedKernelRevision?: string;
+    taskId: string;
+}): {
+    ok: boolean;
+    reason?: DelegationDenialReason;
+};
+export declare function validateKernelCalibration(artifact: KernelCalibrationArtifact | undefined, opts: {
+    taskId: string;
+    taskVersion: string;
+    questionSemanticsHash: string;
+    modelFamily: string;
+    datasetVersion: string;
+    now?: Date;
+}): {
+    ok: boolean;
+    reasons: DelegationDenialReason[];
+};
+export declare function modelFamilyOf(model: string): string;
+export declare function capabilityForTask(taskId: string): "grounding" | "ctaFidelity" | "claimStrengthening" | "crossStageContinuity" | "coverageCheck" | "creativeScoring" | "sourceSelection" | "retrievalRanking" | "repairAssistance" | "componentSelection";
+export declare function effectiveModeName(mode: JevMode): DelegationDenialReason | undefined;

package/bin/types/src/agent/jev/client.d.ts

@@ -0,0 +1,52 @@
+import { type Questions, type SystemOneResult } from "@typesafe-ai/sdk";
+import type { JevConfig, JevReceipt, JevTransport } from "./types.ts";
+/** Inference cache identity is independent of POLICY_VERSION. */
+export declare const INFERENCE_CACHE_SCHEMA: 2;
+export declare class JevClient {
+    private client;
+    private root;
+    private config;
+    private activeRequests;
+    private requestQueue;
+    private sessionCalls;
+    private sessionInputTokens;
+    private sessionOutputTokens;
+    private sessionDurationMs;
+    getSessionUsage(): {
+        calls: number;
+        inputTokens: number;
+        outputTokens: number;
+        durationMs: number;
+    };
+    get model(): string;
+    constructor(opts: {
+        root: string;
+        apiKey?: string;
+        config?: Partial<JevConfig>;
+        fetch?: JevTransport;
+    });
+    private acquireConcurrencySlot;
+    /** Compute deterministic SHA256 cache key. Policy version is intentionally excluded. */
+    cacheKey(model: string, questions: Questions, state: unknown): string;
+    /** Validates that result answers match question criteria, bounds, and probability sums. */
+    validateResult<Q extends Questions>(questions: Q, result: SystemOneResult<Q>): void;
+    writeReceipt(receipt: JevReceipt): string;
+    private writeCache;
+    private readCachedResult;
+    /** Run a bounded, validated System One evaluation with disk cache, timeout, and receipts. */
+    evaluate<Q extends Questions>(opts: {
+        taskType: JevReceipt["taskType"];
+        nodeId?: string;
+        questions: Q;
+        state: unknown;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        taskDeadlineMs?: number;
+        useCache?: boolean;
+    }): Promise<{
+        result: SystemOneResult<Q>;
+        receiptPath: string;
+        cached: boolean;
+        durationMs: number;
+    }>;
+}

package/bin/types/src/agent/jev/component-select.d.ts

@@ -0,0 +1,102 @@
+import type { JevClient } from "./client.ts";
+import { partitionBatchItems } from "./batching.ts";
+import { type ComponentFitDimension } from "./questions.ts";
+import { loadBlockLibrary, type BlockRecord, type SectionState } from "./block-catalog.ts";
+export declare const COMPONENT_FIT_WEIGHTS: Record<ComponentFitDimension, number>;
+export declare const CUSTOM_CANDIDATE_ID = "custom";
+export interface ComponentRecommendation {
+    id: string;
+    score: number;
+    scoreState?: "observed" | "partial" | "unavailable";
+    reasonCodes: string[];
+    adaptations: string[];
+    exampleHandle: string;
+    previewEvidence?: BlockRecord["previewEvidence"];
+    custom: boolean;
+}
+export interface ComponentSelectResult {
+    libraryProfile?: string;
+    libraryReleaseIdentity?: string;
+    ranked: ComponentRecommendation[];
+    routeToAgent: boolean;
+    reason?: string;
+    cacheKey: string;
+    raw: Record<string, unknown>;
+    receiptIds?: string[];
+    cacheHit?: boolean;
+    provenance?: ComponentCacheProvenance;
+    discovery?: {
+        eligibleIds: string[];
+        rejected: Array<{
+            id: string;
+            reason: string;
+        }>;
+        shortlistIds: string[];
+    };
+}
+export interface ComponentCacheProvenance {
+    libraryProfile?: string;
+    libraryReleaseIdentity?: string;
+    preparationId: string;
+    cacheKey: string;
+    libraryHash: string;
+    stateHash: string;
+    model: string;
+    policy: string;
+    questionSemantics: string;
+    receiptIds: string[];
+}
+export declare function cacheKeyForSelection(opts: {
+    state: SectionState;
+    libraryHash: string;
+    model: string;
+    policy: string;
+    questionSemantics?: string;
+    profile?: string;
+}): string;
+export declare function componentStateHash(state: SectionState): string;
+export declare function planComponentQuestions(state: SectionState, lib: ReturnType<typeof loadBlockLibrary>): {
+    questionIds: string[];
+    partitions: ReturnType<typeof partitionBatchItems>["partitions"];
+    stateHash: string;
+    candidates: BlockRecord[];
+    discovery: NonNullable<ComponentSelectResult["discovery"]>;
+};
+export declare function verifyComponentCacheHit(opts: {
+    root: string;
+    cached: ComponentSelectResult;
+    state: SectionState;
+    libraryHash: string;
+    model: string;
+    policy?: string;
+    profile?: string;
+}): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function recommendComponents(opts: {
+    root: string;
+    kernel: string;
+    client: JevClient;
+    state: SectionState;
+    preparationId?: string;
+    nodeId?: string;
+    signal?: AbortSignal;
+}): Promise<ComponentSelectResult>;
+export declare function draftAuthoringSnippet(block: BlockRecord, copy: {
+    heading?: string;
+    body?: string;
+    cta?: string;
+    mediaId?: string;
+}): string;
+export declare function attachComponentRecommendations(opts: {
+    root: string;
+    kernel: string;
+    client: JevClient;
+    nodeId: string;
+    preparationId: string;
+    inputHash?: string;
+    signal?: AbortSignal;
+}): Promise<string>;

package/bin/types/src/agent/jev/config.d.ts

@@ -0,0 +1,52 @@
+import type { JevCapabilityConfig, JevConfig, JevMode, JevWorkOwnership } from "./types.ts";
+export type { JevCapabilityConfig, JevConfig, JevMode, JevWorkOwnership };
+export declare const DEFAULT_JEV_MODEL = "jev-1.13.0";
+export declare const DEFAULT_ROUTING_CONFIDENCE_THRESHOLD = 0.8;
+export declare const DEFAULT_GROUNDING_CONFIDENCE_THRESHOLD = 0.85;
+export declare const DEFAULT_JEV_CONFIG: JevConfig;
+/** Default capabilities — all off. Includes WS5 and WS7 additions. */
+export declare const DEFAULT_JEV_CAPABILITIES: JevCapabilityConfig;
+/** Advisory design checks. Does not enable delegation or override an explicit off. */
+export declare const DESIGN_ASSIST_CAPABILITIES: readonly ["creativeScoring", "componentSelection", "compositionCheck", "mediaClassification", "mediaSelection", "mediaSetReview", "mediaProvenance"];
+/** Creative efficiency routes optional context and repair hints; it never delegates work. */
+export declare const CREATIVE_EFFICIENCY_CAPABILITIES: readonly ["retrievalRanking", "repairAssistance"];
+/** Default pilot budget. Stop Jev and restore agent obligations at the ceiling. */
+export declare const DEFAULT_PILOT_BUDGET: {
+    maxTransportAttempts: number;
+    maxInputTokens: number;
+};
+/** Safely resolve the TypeSafe API key from process.env or .dev.vars without ever logging or leaking it. */
+export declare function resolveApiKey(searchDirs?: string[]): string | undefined;
+export declare function loadJevConfig(root: string, argv?: string[], env?: NodeJS.ProcessEnv): JevConfig;
+/** Resolve CLI > environment > file payload without reading or writing agent/jev.json. */
+export declare function mergeJevConfig(fileConfig: Partial<JevConfig>, argv?: string[], env?: NodeJS.ProcessEnv, root?: string): JevConfig;
+/**
+ * Validates all enum/numeric values in a JevConfig. Throws with a descriptive error on invalid values.
+ * Call after loading config before any usage.
+ */
+export declare function validateJevConfig(config: JevConfig): void;
+/** Returns the effective mode for a capability, clamped to the global mode ceiling. */
+export declare function resolveCapability(config: JevConfig, capability: keyof JevCapabilityConfig): JevMode;
+/** Checks whether a capability is active at the required mode level or above. */
+export declare function isCapabilityActive(config: JevConfig, capability: keyof JevCapabilityConfig, requiredMode?: JevMode): boolean;
+/**
+ * Resolves all capability modes clamped to the global mode ceiling.
+ * Includes WS5 and WS7 capabilities.
+ */
+export declare function resolveEffectiveCapabilities(config: JevConfig): JevCapabilityConfig;
+/** Callers that would actually invoke Jev given the effective (mode-clamped) capabilities. */
+export declare function enabledJevCallers(config: JevConfig): string[];
+export declare function capabilitiesFullyOff(caps: JevCapabilityConfig): boolean;
+export declare function jevClientRequired(config: JevConfig): boolean;
+export declare function nonTreatmentFingerprint(config: JevConfig): string;
+/**
+ * Returns the effective configuration without secrets (no API key, no tokens).
+ * Suitable for logging, snapshotting in preparations, and debugging.
+ * Endpoint intentionally omitted as it may reveal internal routing.
+ */
+export declare function exposeEffectiveConfig(config: JevConfig): Record<string, unknown>;
+/**
+ * Returns a snapshot of effective capabilities (clamped to global mode) plus workOwnership,
+ * suitable for storing in StagePreparation.capabilitiesSnapshot.
+ */
+export declare function snapshotEffectiveConfig(config: JevConfig): Record<string, string>;

package/bin/types/src/agent/jev/consistency.d.ts

@@ -0,0 +1,105 @@
+import { type Business, type Storyboard } from "../artifacts.ts";
+import { type EvidenceLedger } from "./ledger.ts";
+export interface CrossPageContradiction {
+    type: "hours" | "phone" | "pricing" | "email";
+    pages: string[];
+    description: string;
+    values: string[];
+}
+export interface NarrativeContinuityReport {
+    continuityScore: number;
+    coveredCoreFacts: string[];
+    droppedCoreFacts: string[];
+    narrativeFlowValid: boolean;
+    notes: string[];
+}
+export interface SemanticDriftReport {
+    driftDetected: boolean;
+    driftScore: number;
+    unsupportedTopics: string[];
+    notes: string[];
+}
+export interface ConsistencyCheckReport {
+    ok: boolean;
+    violations: string[];
+    narrativeContinuity: NarrativeContinuityReport;
+    semanticDrift: SemanticDriftReport;
+    contradictions: CrossPageContradiction[];
+}
+export declare function defaultConsistencyReportPath(root: string): string;
+/**
+ * Validates cross-stage semantic consistency:
+ * 1. Narrative arc continuity from business.json into storyboard.json and copy-plan.json.
+ * 2. Semantic drift detection (dropped value propositions, invented themes).
+ * 3. Cross-page contradictions (conflicting business hours, phone numbers, or pricing across pages).
+ */
+export declare function checkCrossStageConsistency(opts: {
+    root: string;
+    business?: Business;
+    storyboard?: Storyboard;
+    copyPlan?: {
+        pages?: Array<{
+            path: string;
+            sections?: Array<{
+                id: string;
+                heading?: string;
+                body?: string;
+                factIds?: string[];
+            }>;
+        }>;
+    };
+}): ConsistencyCheckReport;
+export interface ClaimLineageNode {
+    stage: "source" | "claim" | "section" | "artifact";
+    id: string;
+    location: string;
+    hash?: string;
+    text?: string;
+}
+export interface ClaimLineageTrace {
+    claimId: string;
+    claimText: string;
+    sourceNodes: ClaimLineageNode[];
+    claimNode?: ClaimLineageNode;
+    sectionNodes: ClaimLineageNode[];
+    artifactNodes: ClaimLineageNode[];
+    broken: boolean;
+    brokenReasons: string[];
+}
+export interface ClaimLineageReport {
+    ok: boolean;
+    traces: ClaimLineageTrace[];
+    brokenTraces: ClaimLineageTrace[];
+    summary: {
+        totalClaims: number;
+        intactClaims: number;
+        brokenClaims: number;
+    };
+}
+/**
+ * Traces claim lineage across stages:
+ * source -> claim -> section -> artifact -> node
+ * Validates that every assertion in downstream copy/pages maps to an unbroken upstream lineage.
+ */
+export declare function traceClaimLineage(opts: {
+    root: string;
+    business?: Business;
+    storyboard?: Storyboard;
+    copyPlan?: {
+        pages?: Array<{
+            path: string;
+            sections?: Array<{
+                id: string;
+                heading?: string;
+                body?: string;
+                factIds?: string[];
+                facts?: string[];
+            }>;
+        }>;
+    };
+    ledger?: EvidenceLedger;
+}): ClaimLineageReport;
+/**
+ * Filters broken claim traces and produces structured lineage failure descriptions.
+ */
+export declare function detectBrokenLineage(traces: ClaimLineageTrace[]): string[];

package/bin/types/src/agent/jev/content-checks.d.ts

@@ -0,0 +1,121 @@
+import type { JevClient } from "./client.ts";
+import { type BatchableQuestion } from "./batching.ts";
+import { type CriticDisposition, type Finding, type Review } from "../artifacts.ts";
+import type { JevCapabilityConfig } from "./types.ts";
+export declare const QUALITY_NOUL_ACCEPT = 0.85;
+export declare const QUALITY_NOUL_REJECT = 0.15;
+export declare const QUALITY_TASK_BUDGET: Record<string, number>;
+export declare const QUALITY_TASK_SEMANTICS: Record<string, string>;
+export interface QualityFinding {
+    id: string;
+    taskId: string;
+    subjectId: string;
+    location: string;
+    evidenceSpan?: string;
+    kind: string;
+    severity: "error" | "warning";
+    raw?: Record<string, unknown>;
+    policyDecision: "escalate" | "pass" | "uncertain";
+    policyVersion: string;
+    verification: string;
+    author: string;
+    subjectHash?: string;
+    sourceHash?: string;
+    status: "open" | "resolved" | "uncertain";
+}
+export interface QualityTaskRecord {
+    taskId: string;
+    status: "completed" | "partial" | "unavailable" | "no_candidates";
+    questionIds: string[];
+    skippedIds: string[];
+    findings: string[];
+}
+export type ObligationStatus = "judged" | "cached" | "skipped" | "overflow" | "unavailable";
+export interface QualityObligation {
+    questionId: string;
+    obligationId: string;
+    taskId: string;
+    cacheKey: string;
+    status: ObligationStatus;
+    decision?: string;
+    subjectHash?: string;
+    /** Preparation that originally judged a cached pass. */
+    priorPreparationId?: string;
+}
+export interface QualityCheckResult {
+    findings: QualityFinding[];
+    standardFindings: Finding[];
+    status: "completed" | "partial" | "unavailable" | "no_candidates";
+    overflowObligation?: string;
+    overflowIds?: string[];
+    tasks: QualityTaskRecord[];
+    obligations?: QualityObligation[];
+}
+export declare function obligationCacheKey(opts: {
+    questionId: string;
+    assertionHash: string;
+    evidenceHash: string;
+    model: string;
+    policyHash: string;
+}): string;
+export declare const POLICY_HASH: string;
+export declare function extractCopyAssertions(root: string): Array<{
+    id: string;
+    text: string;
+    location: string;
+    evidence: string;
+}>;
+export declare function extractCtaPairs(root: string): Array<{
+    id: string;
+    label: string;
+    behavior: string;
+    location: string;
+}>;
+export declare function nearDuplicatePairs(texts: Array<{
+    id: string;
+    text: string;
+    location: string;
+}>): Array<{
+    a: typeof texts[0];
+    b: typeof texts[0];
+}>;
+export declare function qualityPath(root: string, preparationId: string): string;
+export declare function loadQualityResult(root: string, preparationId: string): QualityCheckResult | undefined;
+export declare function loadLatestQualityResult(root: string, nodeId?: string): QualityCheckResult | undefined;
+export declare function partitionQuestionsByClaim(items: BatchableQuestion[], budget: number): {
+    kept: BatchableQuestion[];
+    overflow: BatchableQuestion[];
+};
+export declare function runQualityChecks(opts: {
+    root: string;
+    client: JevClient;
+    nodeId: string;
+    preparationId: string;
+    inputHash?: string;
+    signal?: AbortSignal;
+    capabilities?: Partial<JevCapabilityConfig>;
+    skipUnchanged?: boolean;
+}): Promise<QualityCheckResult>;
+export declare function formatQualityFindings(findings: QualityFinding[]): string;
+export declare const MAJOR_DISPOSITION_KINDS: Set<string>;
+export declare function verifyQualityTaskReceipts(opts: {
+    root: string;
+    preparationId: string;
+    nodeId: string;
+    taskId: string;
+    expectedModel?: string;
+}): {
+    ok: boolean;
+    reason?: string;
+};
+export declare function independentCitedSource(evidence: string): boolean;
+export declare function criticDispositionMatches(entry: CriticDisposition | undefined, findingId: string, subjectHash?: string): boolean;
+export declare function dispositionAllowedForFinding(entry: CriticDisposition, finding: QualityFinding): string | undefined;
+export declare function criticDisposedFinding(review: Review | undefined, finding: QualityFinding): boolean;
+export declare function overflowIdsDisposed(review: Review | undefined, overflowIds: string[]): boolean;
+export declare function reconcileQualityWithReview(opts: {
+    root: string;
+    preparationId: string;
+    nodeId: string;
+    assist: boolean;
+}): string[];

package/bin/types/src/agent/jev/creative.d.ts

@@ -0,0 +1,81 @@
+import type { JevClient } from "./client.ts";
+import { type CreativeDimension } from "./questions.ts";
+import type { Storyboard } from "../artifacts.ts";
+export declare const CREATIVE_DIMENSIONS: CreativeDimension[];
+export declare const DEFAULT_CREATIVE_WEIGHTS: Record<CreativeDimension, number>;
+export type ObservationState = "observed" | "insufficient_evidence" | "unavailable" | "invalid";
+export interface DimensionObservation {
+    state: ObservationState;
+    score?: number;
+    probabilities?: Record<string, number>;
+    reason?: string;
+}
+export interface CreativeCandidateScore {
+    id: string;
+    proposal: string;
+    dimensions: Record<string, DimensionObservation>;
+    coverage: {
+        observed: number;
+        total: number;
+    };
+    status: "complete" | "partial" | "unavailable";
+    combined?: number;
+    factualGateFailed: boolean;
+    retrievalMethod: "jev_score";
+}
+export declare function scoreCreativeCandidates(opts: {
+    client: JevClient;
+    nodeId: string;
+    context: string;
+    candidates: Array<{
+        id: string;
+        proposal: string;
+    }>;
+    factualGate?: (proposal: string) => boolean;
+    weights?: Partial<Record<CreativeDimension, number>>;
+    signal?: AbortSignal;
+}): Promise<CreativeCandidateScore[]>;
+export declare function scoreMediaFitFromText(opts: {
+    client: JevClient;
+    nodeId: string;
+    sectionText: string;
+    observations: Array<{
+        id: string;
+        caption: string;
+        provenance: string;
+        agentObservation: string;
+    }>;
+    signal?: AbortSignal;
+}): Promise<Array<{
+    id: string;
+    state: "observed" | "unavailable";
+    score?: number;
+    note: string;
+}>>;
+export declare function scoreDirectionDecisions(opts: {
+    client: JevClient;
+    nodeId: string;
+    context: string;
+    proposal: string;
+    signal?: AbortSignal;
+}): Promise<Array<{
+    id: string;
+    state: ObservationState;
+    choice?: string;
+    reason?: string;
+}>>;
+export type CompositionRepetitionFinding = {
+    id: string;
+    page: string;
+    state: "observed" | "unavailable" | "insufficient_evidence" | "invalid";
+    choice?: string;
+    evidence: string;
+    uncertainty?: string;
+};
+export declare function scoreCompositionRepetition(opts: {
+    client: JevClient;
+    nodeId: string;
+    story: Storyboard;
+    mediaSummary?: string;
+    signal?: AbortSignal;
+}): Promise<CompositionRepetitionFinding[]>;