resolver.ts

// The pure-code Resolver. No LLM. No network. No randomness.
// Same artifact + same evidence chain => same resolutions, every time.

import { runGates, type Gate } from "./gates";
import type {
    DialecticArtifact,
    DialecticReceipt,
    EvidenceChainItem,
    Objection,
    ObjectionSeverity,
    Resolution,
    ResolverConfig,
    ResolverResult,
    SourceKind,
} from "./types";

const SEVERITY_ORDER: Record<ObjectionSeverity, number> = {
    BLOCKING: 0,
    HIGH: 1,
    MEDIUM: 2,
    LOW: 3,
};

const FRESHNESS_OK_FOR_FRESH_RESEARCH = new Set(["live", "recent"]);

const RESOLVED_ACTIONS = new Set([
    "accepted-revision",
    "evidence-upgraded",
    "rejected-with-reason",
    "deferred",
]);

function bySeverity(a: Objection, b: Objection): number {
    return SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
}

function hashJson(value: unknown): string {
    // Cheap stable hash; fine for receipt inputHash. Swap for a real hash in prod.
    const s = JSON.stringify(value, Object.keys(value as object).sort());
    let h = 0;
    for (let i = 0; i < s.length; i++) {
        h = (h * 31 + s.charCodeAt(i)) | 0;
    }
    return `h${(h >>> 0).toString(16)}`;
}

function makeReceipt(
    kind: DialecticReceipt["receiptKind"],
    artifact: DialecticArtifact,
    payload: Record<string, unknown>,
): DialecticReceipt {
    return {
        receiptId: `r_${Date.now().toString(36)}_${Math.random()
            .toString(36)
            .slice(2, 8)}`,
        receiptKind: kind,
        artifactId: artifact.artifactId,
        stage: artifact.stage,
        timestamp: new Date().toISOString(),
        inputHash: hashJson({
            proposal: artifact.proposal,
            objections: artifact.objections,
            evidenceChain: artifact.evidenceChain,
        }),
        payload,
    };
}

function replaceOrPush(arr: Resolution[], r: Resolution): void {
    const i = arr.findIndex(x => x.objectionId === r.objectionId);
    if (i >= 0) arr[i] = r;
    else arr.push(r);
}

function authorityRankOf(
    kind: SourceKind,
    config: ResolverConfig,
): number {
    return config.authorityRank[kind];
}

/** Step 1: Did the latest Proposer revision touch the data path the objection targets? */
function tryAcceptedRevision(
    objection: Objection,
    artifact: DialecticArtifact,
): Resolution | null {
    if (!objection.targetFieldPath) return null;
    const field = artifact.proposal.fields[objection.targetFieldPath];
    if (!field) return null;
    // If the proposal is a revision and the target field exists, accept.
    // Domains can override this with a smarter "was the field actually touched" check.
    if (artifact.proposal.revisionOf) {
        return {
            objectionId: objection.objectionId,
            action: "accepted-revision",
            note: `Proposer revision updated field "${objection.targetFieldPath}".`,
            revisionDelta: { [objection.targetFieldPath]: field.value },
        };
    }
    return null;
}

/** Step 2: Has new evidence cleared the threshold for this objection? */
function tryEvidenceUpgraded(
    objection: Objection,
    artifact: DialecticArtifact,
    evidenceChain: EvidenceChainItem[],
    config: ResolverConfig,
): Resolution | null {
    const threshold = config.thresholdsByCategory[objection.category];
    if (threshold == null) return null; // unknown category — be conservative, hold

    const allowedKinds = new Set(config.minSourceKindForSeverity[objection.severity]);

    // Evidence that targets either the objection's evidenceRefs OR the field path.
    const candidates = evidenceChain.filter(e => {
        const refsObjection =
            objection.evidenceRefs.includes(e.id) ||
            (objection.targetFieldPath
                ? artifact.proposal.fields[objection.targetFieldPath]?.evidenceRefs.includes(e.id)
                : false);
        return refsObjection && allowedKinds.has(e.sourceKind);
    });

    // Rank candidates: highest authority first (lowest rank number), then highest confidence.
    candidates.sort((a, b) => {
        const ra = authorityRankOf(a.sourceKind, config);
        const rb = authorityRankOf(b.sourceKind, config);
        if (ra !== rb) return ra - rb;
        return b.confidence - a.confidence;
    });

    for (const e of candidates) {
        if (e.confidence < threshold) continue;
        if (e.sourceKind === "fresh-research" && !FRESHNESS_OK_FOR_FRESH_RESEARCH.has(e.freshness)) {
            continue;
        }
        if (e.sourceKind === "llm-inference") continue; // never resolves anything alone
        if (e.sourceKind === "modeled-fallback" && objection.severity === "BLOCKING") continue;

        return {
            objectionId: objection.objectionId,
            action: "evidence-upgraded",
            note: `Evidence ${e.id} (${e.sourceKind}, conf ${e.confidence.toFixed(2)}) cleared threshold ${threshold} for category "${objection.category}".`,
            triggeringEvidenceId: e.id,
        };
    }
    return null;
}

/** Step 3: Non-blocking, deferred to a later stage by the proposal. */
function tryDeferred(
    objection: Objection,
    artifact: DialecticArtifact,
): Resolution | null {
    if (objection.severity === "BLOCKING") return null;
    if (!objection.targetFieldPath) return null;
    const deferral = artifact.proposal.defersToStage?.[objection.targetFieldPath];
    if (!deferral) return null;
    return {
        objectionId: objection.objectionId,
        action: "deferred",
        note: `Proposal defers field "${objection.targetFieldPath}" to stage "${deferral}".`,
    };
}

/** Step 4: Proposer cited contradicting evidence that outranks the objection's evidence. */
function tryRejectedWithReason(
    objection: Objection,
    artifact: DialecticArtifact,
    evidenceChain: EvidenceChainItem[],
    config: ResolverConfig,
): Resolution | null {
    if (!objection.targetFieldPath) return null;
    const field = artifact.proposal.fields[objection.targetFieldPath];
    if (!field) return null;

    const objectionEvidence = evidenceChain.filter(e =>
        objection.evidenceRefs.includes(e.id),
    );
    if (objectionEvidence.length === 0) return null;
    const bestObjectionRank = Math.min(
        ...objectionEvidence.map(e => authorityRankOf(e.sourceKind, config)),
    );

    const proposalEvidence = evidenceChain.filter(e =>
        field.evidenceRefs.includes(e.id),
    );
    const contradicting = proposalEvidence.find(
        e =>
            authorityRankOf(e.sourceKind, config) < bestObjectionRank &&
            e.sourceKind !== "llm-inference",
    );
    if (!contradicting) return null;

    return {
        objectionId: objection.objectionId,
        action: "rejected-with-reason",
        note: `Proposal cites ${contradicting.sourceKind} evidence "${contradicting.id}" which outranks the objection's evidence in the Authority Hierarchy.`,
        triggeringEvidenceId: contradicting.id,
    };
}

function tryResolve(
    objection: Objection,
    artifact: DialecticArtifact,
    evidenceChain: EvidenceChainItem[],
    config: ResolverConfig,
): Resolution | null {
    // Order matters. Prefer the verdict that names the *actual* reason the
    // objection cleared. Evidence beats a revision-shape match.
    return (
        tryEvidenceUpgraded(objection, artifact, evidenceChain, config) ||
        tryRejectedWithReason(objection, artifact, evidenceChain, config) ||
        tryAcceptedRevision(objection, artifact) ||
        tryDeferred(objection, artifact) ||
        null
    );
}

export interface RunDialecticResolverInput {
    artifact: DialecticArtifact;
    evidenceChain: EvidenceChainItem[];
    config: ResolverConfig;
    gates?: Gate[];
}

export function runDialecticResolver(
    input: RunDialecticResolverInput,
): ResolverResult {
    const out: DialecticArtifact = structuredClone(input.artifact);
    out.evidenceChain = input.evidenceChain;
    out.revisedAt = new Date().toISOString();

    const receipts: DialecticReceipt[] = [];

    for (const objection of [...out.objections].sort(bySeverity)) {
        const existing = out.resolutions.find(
            r => r.objectionId === objection.objectionId,
        );
        if (existing && RESOLVED_ACTIONS.has(existing.action)) continue;

        const resolution = tryResolve(
            objection,
            out,
            input.evidenceChain,
            input.config,
        );
        if (resolution) {
            replaceOrPush(out.resolutions, resolution);
            receipts.push(
                makeReceipt("resolution-applied", out, {
                    objectionId: objection.objectionId,
                    action: resolution.action,
                    triggeringEvidenceId: resolution.triggeringEvidenceId ?? null,
                }),
            );
        }
    }

    out.validation = runGates(out, input.evidenceChain, input.gates);

    const stillBlocking = out.objections.some(o => {
        if (o.severity !== "BLOCKING") return false;
        const r = out.resolutions.find(x => x.objectionId === o.objectionId);
        return !r || !RESOLVED_ACTIONS.has(r.action) || r.action === "deferred";
    });

    if (!out.validation.readyToAdvance) {
        receipts.push(
            makeReceipt("gate-failed", out, {
                gatesFailed: out.validation.gatesFailed,
                blockingObjectionsOpen: out.validation.blockingObjectionsOpen,
            }),
        );
    }

    const roundsSoFar = out.roundsSoFar ?? 0;
    const needsAnotherRound = stillBlocking && roundsSoFar < input.config.maxRounds;

    if (stillBlocking && !needsAnotherRound) {
        receipts.push(
            makeReceipt("escalation", out, {
                reason: "Blocking objections remain after maxRounds. Routing to human review.",
            }),
        );
    }

    receipts.unshift(
        makeReceipt("dialectic-pass", out, {
            roundsSoFar,
            resolutionsApplied: receipts.filter(r => r.receiptKind === "resolution-applied").length,
        }),
    );

    return {
        artifact: out,
        receipts,
        needsAnotherRound,
    };
}