@lcv-ideas-software/cross-review 4.0.0

package/dist/src/core/orchestrator.d.ts

@@ -0,0 +1,199 @@
+import type { AppConfig, Confidence, CostEstimate, PeerAdapter, PeerId, PeerProbeResult, ReasoningEffort, ReviewRound, ReviewStatus, RuntimeEvent, SessionMeta, TokenUsage } from "./types.js";
+import { SessionStore } from "./session-store.js";
+export interface AskPeersInput {
+    session_id?: string;
+    task: string;
+    review_focus?: string;
+    draft: string;
+    petitioner?: PeerId | "operator";
+    caller?: PeerId | "operator";
+    lead_peer?: PeerId;
+    caller_status?: ReviewStatus;
+    peers?: PeerId[];
+    signal?: AbortSignal;
+    reasoning_effort_overrides?: Partial<Record<PeerId, ReasoningEffort>>;
+}
+export interface AskPeersOutput {
+    session: SessionMeta;
+    round: ReviewRound;
+    converged: boolean;
+}
+export interface RunUntilUnanimousInput {
+    session_id?: string;
+    task: string;
+    review_focus?: string;
+    initial_draft?: string;
+    lead_peer?: PeerId;
+    peers?: PeerId[];
+    max_rounds?: number;
+    until_stopped?: boolean;
+    max_cost_usd?: number;
+    signal?: AbortSignal;
+    reasoning_effort_overrides?: Partial<Record<PeerId, ReasoningEffort>>;
+    caller?: PeerId | "operator";
+    mode?: import("./types.js").SessionMode;
+    evidence?: string;
+}
+export interface RunUntilUnanimousOutput {
+    session: SessionMeta;
+    final_text?: string;
+    converged: boolean;
+    rounds: number;
+}
+export interface FabricationDetectionResult {
+    fabricated: boolean;
+    net_new_hex_count: number;
+    net_new_hex_sample: string[];
+    suspicious_assertion_count: number;
+    suspicious_assertion_sample: Array<{
+        label: string;
+        match: string;
+    }>;
+}
+export interface FabricationDetectionCorpus {
+    /**
+     * PROVENANCE-GRADE corpus. Raw command/tool output persisted via
+     * `session_attach_evidence`.
+     */
+    provenanceCorpus: string;
+    /**
+     * PRIOR-ARTIFACT corpus. The prior round's draft / the caller's
+     * `initial_draft` — i.e. the artifact the relator is revising.
+     * v3.7.4 (Codex v3.7.3 parecer follow-up): an operational assertion
+     * the relator PRESERVES from the artifact it was handed is NOT
+     * fabrication — the relator invented nothing. The documented process
+     * REQUIRES callers to embed the verbatim diff + raw gate output in
+     * `initial_draft`; punishing a relator for faithfully carrying that
+     * forward was a self-contradiction (session 506f006a). So the prior
+     * artifact, alongside attached evidence, is a legitimate provenance
+     * source for operational assertions.
+     */
+    priorDraftCorpus: string;
+    /**
+     * NARRATIVE corpus. The caller's task body ONLY (prose framing /
+     * instructions) — NOT the draft. An operational assertion that
+     * appears only here, promoted by the relator into the artifact, is
+     * still flagged: a claim narrated in the task body is not evidence
+     * (the eee886d3 case, operator directive 2026-05-10). Combined with
+     * the other two corpora ONLY for hex-token validation, since
+     * SHAs/IDs/file paths can be referenced as identifiers in narrative
+     * without being claimed as command-output evidence.
+     */
+    narrativeCorpus: string;
+}
+export declare function detectFabricatedEvidence(revisionText: string, corpus: FabricationDetectionCorpus): FabricationDetectionResult;
+export interface MetaAuditDetectionResult {
+    fabricated: boolean;
+    placeholder_count: number;
+    placeholder_sample: string[];
+    section_count: number;
+    section_sample: string[];
+}
+export declare function detectMetaAuditFabrication(revisionText: string): MetaAuditDetectionResult;
+export interface EvidencePreflightResult {
+    pass: boolean;
+    reason: string;
+    completed_work_claim_matched: boolean;
+    evidence_marker_found: boolean;
+    structured_evidence_supplied: boolean;
+    attachments_present: boolean;
+}
+export declare function evidencePreflight(params: {
+    task: string;
+    initialDraft?: string;
+    structuredEvidence?: string;
+    attachmentsPresent: boolean;
+}): EvidencePreflightResult;
+export declare class PeerDisabledError extends Error {
+    constructor(peer: PeerId);
+}
+export declare class InsufficientEnabledPeersError extends Error {
+    constructor(enabled: PeerId[]);
+}
+export declare class CrossReviewOrchestrator {
+    readonly config: AppConfig;
+    private readonly emit;
+    readonly store: SessionStore;
+    adapters: Record<PeerId, PeerAdapter>;
+    constructor(config: AppConfig, emit?: (event: RuntimeEvent) => void);
+    probeAll(): Promise<PeerProbeResult[]>;
+    runEvidenceChecklistJudgeConsensusPass(params: {
+        session_id: string;
+        judge_peers: PeerId[];
+        draft: string;
+        item_ids?: string[];
+        round?: number;
+        review_focus?: string;
+        mode?: "active" | "shadow";
+        signal?: AbortSignal;
+    }): Promise<{
+        promoted: Array<{
+            item_id: string;
+            rationales: Record<string, string>;
+        }>;
+        skipped: Array<{
+            item_id: string;
+            reason: "not_open" | "consensus_disagreement" | "satisfied_but_unverified" | "not_satisfied" | "judge_failed";
+            per_peer: Record<string, {
+                satisfied?: boolean;
+                confidence?: Confidence;
+                rationale_empty?: boolean;
+                parser_warnings?: string[];
+                error?: string;
+            }>;
+        }>;
+        consensus_decisions: Array<{
+            item_id: string;
+            unanimous_verified_satisfied: boolean;
+            per_peer_verdict: Record<string, "verified_satisfied" | "disagree" | "failed">;
+        }>;
+        judged_count: number;
+        capped: boolean;
+    }>;
+    runEvidenceChecklistJudgePass(params: {
+        session_id: string;
+        judge_peer: PeerId;
+        draft: string;
+        item_ids?: string[];
+        round?: number;
+        review_focus?: string;
+        mode?: "active" | "shadow";
+        signal?: AbortSignal;
+    }): Promise<{
+        promoted: Array<{
+            item_id: string;
+            rationale: string;
+            usage?: TokenUsage;
+            cost?: CostEstimate;
+        }>;
+        skipped: Array<{
+            item_id: string;
+            reason: "not_open" | "satisfied_but_unverified" | "not_satisfied" | "judge_failed";
+            satisfied?: boolean;
+            confidence?: Confidence;
+            message?: string;
+        }>;
+        shadow_decisions: Array<{
+            item_id: string;
+            would_promote: boolean;
+            satisfied: boolean;
+            confidence: Confidence;
+            parser_warnings: string[];
+            rationale_empty: boolean;
+            rationale: string;
+        }>;
+        judged_count: number;
+        capped: boolean;
+        mode: "active" | "shadow";
+    }>;
+    initSession(task: string, caller?: PeerId | "operator", reviewFocus?: string): Promise<SessionMeta>;
+    private isCancelled;
+    private fallbackAdapters;
+    private recordFallback;
+    private recordCacheTelemetry;
+    private checkBudgetWarning;
+    private callPeerForReview;
+    askPeers(input: AskPeersInput): Promise<AskPeersOutput>;
+    private runCircularLoop;
+    runUntilUnanimous(input: RunUntilUnanimousInput): Promise<RunUntilUnanimousOutput>;
+}