@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/agentic-capabilities-protocol.test.js

@@ -0,0 +1,570 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Schema } from "effect";
+import { AgenticCapabilityRequestV1, agenticDigestV1, agenticCapabilityRequestJsonSchemaV1, agenticSemanticOperationDigestV1, assertAgenticArtifactPrerequisitesV1, assertAgenticCandidateTransitionV1, assertAgenticEvidenceInputsV1, decodeAgenticAcceptedArtifactV1, decodeAgenticCandidateV1, decodeAgenticCapabilityRequestV1, decodeAgenticCapabilityResultV1, decodeAgenticEnvironmentPlanV1, decodeAgenticQualityScorecardV1, decodeAgenticScientificProgressReceiptV1, decodeAgenticTrustedInvocationV1, makeAgenticProgressFingerprintV1 } from "../agentic-capabilities-protocol.js";
+const sha = "a".repeat(64);
+const otherSha = "b".repeat(64);
+const at = "2026-09-15T12:00:00.000Z";
+const inputs = {
+    sourceDigest: sha,
+    environmentDigest: sha,
+    specificationDigest: sha,
+    oracleDigest: sha,
+    controlsDigest: sha,
+    policyDigest: sha,
+    modelPlanDigest: sha
+};
+const candidate = {
+    version: 1,
+    candidate: "candidate",
+    revision: "revision",
+    coverageCell: "cell",
+    sourceDigest: sha,
+    proposal: "proposal",
+    createdAt: at
+};
+const artifact = (handle, kind, extra = {}) => decodeAgenticAcceptedArtifactV1({
+    handle,
+    candidate: "candidate",
+    revision: "revision",
+    kind,
+    contentDigest: sha,
+    state: "reference_qualified",
+    dependencies: inputs,
+    gradeExecuted: true,
+    ...extra
+});
+const qualified = decodeAgenticCandidateV1({
+    ...candidate,
+    state: "reference_qualified",
+    environment: "environment",
+    referenceQualification: "reference"
+});
+const frozen = decodeAgenticCandidateV1({
+    ...qualified,
+    state: "frozen",
+    specification: "spec",
+    oracle: "oracle",
+    controls: ["valid", "wrong"],
+    tournament: "tournament",
+    inputs,
+    frozenAt: at
+});
+const admitted = decodeAgenticCandidateV1({
+    ...frozen,
+    state: "admitted",
+    challenge: "challenge",
+    admission: "admission"
+});
+const records = [
+    artifact("environment", "environment"),
+    artifact("reference", "reference_qualification"),
+    artifact("spec", "specification"),
+    artifact("oracle", "oracle"),
+    artifact("valid", "valid_controls"),
+    artifact("wrong", "wrong_controls"),
+    artifact("tournament", "tournament"),
+    artifact("challenge", "held_out_challenge", { fresh: true }),
+    artifact("admission", "admission")
+];
+test("canonical tool guidance explains cumulative controls even when schema annotations are absent", () => {
+    const rendered = agenticCapabilityRequestJsonSchemaV1({
+        anyOf: [{
+                properties: {
+                    tool: { enum: ["evaluate_oracle"] },
+                    args: { properties: { controls: { type: "array", description: "" } } }
+                }
+            }]
+    });
+    const description = rendered.anyOf[0].properties.args.properties.controls.description;
+    assert.match(description, /one-element list.*latest cumulative controls checkpoint/u);
+    assert.match(description, /supersedes earlier snapshots/u);
+    assert.match(description, /do not combine old and new handles/u);
+});
+test("source-first drafts require no invented seed or execution evidence", () => {
+    assert.equal(decodeAgenticCandidateV1({ ...candidate, state: "draft" }).state, "draft");
+    assert.deepEqual(decodeAgenticCapabilityRequestV1({ tool: "inspect_repository", args: {} }), {
+        tool: "inspect_repository",
+        args: {}
+    });
+    assert.deepEqual(decodeAgenticCapabilityRequestV1({
+        tool: "draft_specification",
+        args: { candidate: "candidate" }
+    }), { tool: "draft_specification", args: { candidate: "candidate" } });
+    assert.throws(() => decodeAgenticCandidateV1({ ...candidate, state: "reference_qualified" }));
+    assert.throws(() => decodeAgenticCandidateV1({ ...candidate, state: "admitted", admission: "model-says-approved" }));
+});
+test("every tool decodes its normative domain arguments but not trusted authority", () => {
+    const requests = [
+        { tool: "list_candidates", args: { coverageCell: "cell", limit: 50 } },
+        {
+            tool: "read_source",
+            args: { source: "source", path: "src/main.ts", offset: 0, length: 120_000 }
+        },
+        { tool: "search_source", args: { source: "source", query: "export" } },
+        {
+            tool: "plan_environment",
+            args: {
+                candidate: "candidate",
+                recipeIds: ["test"],
+                executionMode: "source",
+                targetRoots: ["src"],
+                requiredArtifacts: [],
+                justification: "The actual test recipe runs TypeScript source."
+            }
+        },
+        {
+            tool: "probe_fixture",
+            args: { candidate: "candidate", environment: "environment", fixtureDraft: "fixture" }
+        },
+        { tool: "qualify_reference", args: { candidate: "candidate", environment: "environment" } },
+        { tool: "author_oracle", args: { candidate: "candidate", specification: "spec" } },
+        {
+            tool: "generate_controls",
+            args: {
+                candidate: "candidate",
+                specification: "spec",
+                environment: "environment",
+                kind: "wrong"
+            }
+        },
+        {
+            tool: "evaluate_oracle",
+            args: { candidate: "candidate", oracle: "oracle", controls: ["controls"] }
+        },
+        {
+            tool: "repair_oracle",
+            args: { candidate: "candidate", oracle: "oracle", findings: "findings" }
+        },
+        { tool: "freeze_candidate", args: { candidate: "candidate", revision: "revision" } },
+        { tool: "run_held_out_challenge", args: { frozenCandidate: "frozen" } },
+        {
+            tool: "request_admission",
+            args: { frozenCandidate: "frozen", qualification: "qualification" }
+        },
+        { tool: "get_progress", args: {} },
+        { tool: "read_diagnostics", args: { operation: "operation", maximumBytes: 65_536 } },
+        {
+            tool: "reject_candidate",
+            args: { candidate: "candidate", reason: "Not discriminating", evidence: [] }
+        },
+        { tool: "finish_campaign", args: { reason: "Coverage complete" } }
+    ];
+    for (const request of requests) {
+        assert.equal(decodeAgenticCapabilityRequestV1(request).tool, request.tool);
+        assert.throws(() => decodeAgenticCapabilityRequestV1({ ...request, orgId: "other-org" }));
+        assert.throws(() => Schema.decodeUnknownSync(AgenticCapabilityRequestV1)({
+            ...request,
+            args: { ...request.args, reservation: "mine" }
+        }));
+    }
+});
+test("tool arguments enforce UTF-8 bytes, bounded arrays and normalized source paths", () => {
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "search_source",
+        args: { source: "source", query: "🧪".repeat(129) }
+    }));
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "list_candidates",
+        args: { coverageCell: "cell", limit: 51 }
+    }));
+    for (const path of [
+        "../secret",
+        "/etc/passwd",
+        "C:/file",
+        "a/../file",
+        "a\\file",
+        "a//file",
+        "a/./file",
+        "a\u0000file"
+    ]) {
+        assert.throws(() => decodeAgenticCapabilityRequestV1({
+            tool: "read_source",
+            args: { source: "source", path, offset: 0, length: 10 }
+        }));
+    }
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "evaluate_oracle",
+        args: { candidate: "c", oracle: "o", controls: Array.from({ length: 33 }, () => "control") }
+    }));
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "evaluate_oracle",
+        args: { candidate: "c", oracle: "o", controls: [] }
+    }));
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "plan_environment",
+        args: {
+            candidate: "candidate",
+            recipeIds: [],
+            executionMode: "source",
+            targetRoots: ["."],
+            requiredArtifacts: [],
+            justification: "A deliberately invalid empty recipe selection."
+        }
+    }));
+    assert.throws(() => decodeAgenticCapabilityRequestV1({
+        tool: "plan_environment",
+        args: {
+            candidate: "candidate",
+            recipeIds: ["test"],
+            executionMode: "source",
+            targetRoots: [],
+            requiredArtifacts: [],
+            justification: "A deliberately invalid empty target-root selection."
+        }
+    }));
+});
+test("trusted invocation is strict and semantic identity survives transcript tool-call changes", () => {
+    const request = decodeAgenticCapabilityRequestV1({ tool: "inspect_repository", args: {} });
+    const invocation = {
+        orgId: "org",
+        campaignId: "campaign",
+        executionId: "execution",
+        epoch: 1,
+        operationId: "operation",
+        inputDigest: sha,
+        actorRole: "eval-orchestrator",
+        modelBinding: "model",
+        reservation: "reservation",
+        deadlineAt: at,
+        toolBundleDigest: sha,
+        request
+    };
+    assert.equal(decodeAgenticTrustedInvocationV1(invocation).epoch, 1);
+    assert.deepEqual(decodeAgenticTrustedInvocationV1({
+        ...invocation,
+        maximumModelCalls: 12,
+        maximumWallTimeMs: 420_000
+    }), { ...invocation, maximumModelCalls: 12, maximumWallTimeMs: 420_000 });
+    assert.throws(() => decodeAgenticTrustedInvocationV1({ ...invocation, maximumModelCalls: 0 }));
+    assert.throws(() => decodeAgenticTrustedInvocationV1({ ...invocation, maximumWallTimeMs: 0 }));
+    assert.throws(() => decodeAgenticTrustedInvocationV1({ ...invocation, epoch: 0 }));
+    assert.throws(() => decodeAgenticTrustedInvocationV1({
+        ...invocation,
+        traceparent: `00-${"0".repeat(32)}-${"1".repeat(16)}-01`
+    }));
+    const first = agenticSemanticOperationDigestV1(invocation);
+    assert.equal(first, agenticSemanticOperationDigestV1({ ...invocation, request: structuredClone(request) }));
+    assert.notEqual(first, agenticSemanticOperationDigestV1({ ...invocation, campaignId: "different" }));
+    assert.equal(agenticDigestV1({ a: 1, b: 2 }), agenticDigestV1({ b: 2, a: 1 }));
+});
+test("environment plan is lazy and specific to the real repository recipe", () => {
+    const plan = {
+        version: 1,
+        planId: "env",
+        candidate: "candidate",
+        revision: "revision",
+        sourceDigest: sha,
+        commitSha: "c".repeat(40),
+        recipeIds: ["unit"],
+        executionMode: "source",
+        targetRoots: ["src"],
+        dependencyClosure: [],
+        requiredArtifacts: [],
+        lockfileDigest: null,
+        packageManager: null,
+        runtime: { name: "node", version: "24.17.0", platform: "linux", architecture: "x64" },
+        commands: [
+            {
+                id: "probe",
+                purpose: "probe",
+                executable: "node",
+                args: ["--test", "src/example.test.ts"],
+                cwd: null,
+                timeoutMs: 120_000
+            }
+        ],
+        expectedCost: { wallTimeMs: 1000, spendUsd: "0" },
+        justification: "Run source-native test recipe without build.",
+        justificationEvidence: ["recipe"]
+    };
+    assert.equal(decodeAgenticEnvironmentPlanV1(plan).commands[0]?.purpose, "probe");
+    assert.deepEqual(decodeAgenticEnvironmentPlanV1({
+        ...plan,
+        targetRoots: ["."],
+        dependencyClosure: [".", "packages/shared"]
+    }).targetRoots, ["."]);
+    const rootWorkspacePlan = {
+        ...plan,
+        targetRoots: ["."],
+        dependencyClosure: Array.from({ length: 36 }, (_, index) => `packages/p${index}`),
+        commands: Array.from({ length: 38 }, (_, index) => ({
+            ...plan.commands[0],
+            id: `command-${index}`,
+            cwd: `packages/p${index % 36}`
+        }))
+    };
+    assert.equal(decodeAgenticEnvironmentPlanV1(rootWorkspacePlan).commands.length, 38);
+    assert.throws(() => decodeAgenticEnvironmentPlanV1({
+        ...rootWorkspacePlan,
+        dependencyClosure: Array.from({ length: 65 }, (_, index) => `packages/p${index}`)
+    }));
+    assert.throws(() => decodeAgenticEnvironmentPlanV1({
+        ...rootWorkspacePlan,
+        commands: Array.from({ length: 65 }, (_, index) => ({
+            ...plan.commands[0],
+            id: `command-${index}`
+        }))
+    }));
+    const rootRequest = decodeAgenticCapabilityRequestV1({
+        tool: "plan_environment",
+        args: {
+            candidate: "candidate",
+            recipeIds: ["unit"],
+            executionMode: "source",
+            targetRoots: ["."],
+            requiredArtifacts: [],
+            justification: "The selected package is the repository root."
+        }
+    });
+    assert.ok(rootRequest.tool === "plan_environment");
+    assert.deepEqual(rootRequest.args.targetRoots, ["."]);
+    for (const invalid of ["..", "./src", "packages/../shared", "/tmp", "C:\\repo"]) {
+        assert.throws(() => decodeAgenticEnvironmentPlanV1({ ...plan, targetRoots: [invalid] }));
+    }
+    assert.throws(() => decodeAgenticEnvironmentPlanV1({ ...plan, requiredArtifacts: ["."] }));
+    assert.throws(() => decodeAgenticEnvironmentPlanV1({
+        ...plan,
+        commands: [{ ...plan.commands[0], timeoutMs: 600_001 }]
+    }));
+    assert.throws(() => decodeAgenticEnvironmentPlanV1({
+        ...plan,
+        runtime: { ...plan.runtime, approvalPolicy: "none" }
+    }));
+});
+test("environment failure is not a grade; useful diagnostic results remain bounded", () => {
+    const result = {
+        outcome: "environment_blocked",
+        operation: "op",
+        inputDigest: sha,
+        accepted: [],
+        evidenceSummary: "Package installation failed; no oracle ran.",
+        gradeExecuted: false,
+        diagnostics: "full-log",
+        usage: { receivedCalls: 0, spendKnownUsd: "0", spendUnknown: false },
+        allowedNext: ["plan_environment", "read_diagnostics"]
+    };
+    assert.equal(decodeAgenticCapabilityResultV1(result).gradeExecuted, false);
+    assert.throws(() => decodeAgenticCapabilityResultV1({ ...result, gradeExecuted: true }));
+    assert.throws(() => decodeAgenticCapabilityResultV1({ ...result, gradeExecuted: undefined }));
+    assert.throws(() => decodeAgenticCapabilityResultV1({ ...result, evidenceSummary: "🧪".repeat(2049) }));
+    assert.throws(() => decodeAgenticCapabilityResultV1({ ...result, usage: { ...result.usage, spendKnownUsd: "NaN" } }));
+});
+test("accepted handles are revision bound; changed ancestors invalidate downstream evidence", () => {
+    const evidence = artifact("challenge", "held_out_challenge", { fresh: true });
+    assert.doesNotThrow(() => assertAgenticEvidenceInputsV1(evidence, inputs));
+    assert.throws(() => assertAgenticEvidenceInputsV1({ ...evidence, dependencies: {} }, inputs));
+    for (const key of Object.keys(inputs))
+        assert.throws(() => assertAgenticEvidenceInputsV1(evidence, { ...inputs, [key]: otherSha }));
+    const request = {
+        candidate: "candidate",
+        revision: "revision",
+        handles: ["challenge"],
+        accepted: [evidence],
+        inputs,
+        requireGrade: true,
+        requireFresh: true
+    };
+    assert.doesNotThrow(() => assertAgenticArtifactPrerequisitesV1(request));
+    assert.throws(() => assertAgenticArtifactPrerequisitesV1({ ...request, revision: "other-revision" }));
+    assert.throws(() => assertAgenticArtifactPrerequisitesV1({ ...request, accepted: [] }));
+    assert.throws(() => assertAgenticArtifactPrerequisitesV1({ ...request, accepted: [{ ...evidence, fresh: false }] }));
+    assert.throws(() => assertAgenticArtifactPrerequisitesV1({
+        ...request,
+        accepted: [{ ...evidence, gradeExecuted: false }]
+    }));
+    assert.throws(() => assertAgenticArtifactPrerequisitesV1({
+        ...request,
+        accepted: [{ ...evidence, state: "superseded" }]
+    }));
+});
+test("draft to admitted is impossible; real accepted scientific records enable monotonic qualification", () => {
+    const draft = decodeAgenticCandidateV1({ ...candidate, state: "draft" });
+    assert.throws(() => assertAgenticCandidateTransitionV1(draft, admitted, records, inputs));
+    assert.throws(() => assertAgenticCandidateTransitionV1(draft, qualified, [], inputs));
+    assert.doesNotThrow(() => assertAgenticCandidateTransitionV1(draft, qualified, records, inputs));
+    assert.doesNotThrow(() => assertAgenticCandidateTransitionV1(qualified, frozen, records));
+    assert.doesNotThrow(() => assertAgenticCandidateTransitionV1(frozen, admitted, records));
+    assert.doesNotThrow(() => assertAgenticCandidateTransitionV1(admitted, admitted, records));
+    assert.throws(() => assertAgenticCandidateTransitionV1(admitted, draft, records));
+    assert.throws(() => assertAgenticCandidateTransitionV1(qualified, frozen, records.map((entry) => entry.handle === "valid" ? { ...entry, kind: "wrong_controls" } : entry)));
+    assert.throws(() => assertAgenticCandidateTransitionV1(qualified, frozen, records.map((entry) => (entry.handle === "spec" ? { ...entry, state: "draft" } : entry))));
+    assert.throws(() => assertAgenticCandidateTransitionV1(frozen, admitted, records.map((entry) => (entry.handle === "challenge" ? { ...entry, fresh: false } : entry))));
+    assert.throws(() => assertAgenticCandidateTransitionV1(frozen, { ...admitted, oracle: "another-oracle" }, [...records, artifact("another-oracle", "oracle")]));
+});
+test("quality scorecards are measured criteria, not an agent-provided quality number", () => {
+    // For wrong/held-out controls, passed means the discrimination criterion passed, not that a wrong solution was accepted.
+    const measured = { passed: 2, failed: 0, missing: 0, evidence: ["observation"] };
+    const score = {
+        version: 1,
+        candidate: "candidate",
+        revision: "revision",
+        reference: measured,
+        validControls: measured,
+        wrongControls: measured,
+        heldOut: measured,
+        coverage: [{ cell: "cell", observed: true, evidence: ["coverage"] }],
+        disposition: "admitted",
+        reasons: [],
+        missingEvidence: [],
+        usage: { elapsedMs: 1000, receivedCalls: 4, spendKnownUsd: "0.1", spendUnknown: false },
+        admission: "admission"
+    };
+    assert.equal(decodeAgenticQualityScorecardV1(score).disposition, "admitted");
+    assert.throws(() => decodeAgenticQualityScorecardV1({ ...score, quality: 0.99 }));
+    assert.throws(() => decodeAgenticQualityScorecardV1({ ...score, admission: null }));
+    assert.throws(() => decodeAgenticQualityScorecardV1({ ...score, heldOut: { ...measured, missing: 1 } }));
+    assert.throws(() => decodeAgenticQualityScorecardV1({ ...score, missingEvidence: ["held-out"] }));
+});
+test("progress fingerprints depend only on accepted scientific state", () => {
+    const scientific = {
+        acceptedEvidence: [
+            { handle: "specification", contentDigest: sha, kind: "specification" },
+            { handle: "reference", contentDigest: otherSha, kind: "reference_qualification" }
+        ],
+        completedGates: ["reference_qualified", "specification_accepted"],
+        environmentDigest: sha
+    };
+    const first = makeAgenticProgressFingerprintV1(scientific);
+    const reordered = makeAgenticProgressFingerprintV1({
+        ...scientific,
+        acceptedEvidence: [...scientific.acceptedEvidence].reverse(),
+        completedGates: [...scientific.completedGates].reverse()
+    });
+    assert.deepEqual(first, reordered);
+    // Candidate IDs, revisions, phase labels, timestamps, prose and tool-call IDs
+    // belong on surrounding receipts/events and are not accepted fingerprint inputs.
+    const activityOnlyChanges = {
+        candidateId: "another-candidate",
+        candidateRevision: "revision-999",
+        phase: "another-phase",
+        recordedAt: "2099-01-01T00:00:00.000Z",
+        modelProse: "I made progress",
+        toolCallId: "call-999"
+    };
+    assert.deepEqual(makeAgenticProgressFingerprintV1({
+        ...scientific,
+        ...activityOnlyChanges,
+        acceptedEvidence: scientific.acceptedEvidence.map((entry, index) => ({
+            ...entry,
+            handle: `different-handle-${index}`
+        }))
+    }), first);
+    assert.notDeepEqual(makeAgenticProgressFingerprintV1({
+        ...scientific,
+        acceptedEvidence: [
+            ...scientific.acceptedEvidence,
+            { handle: "oracle", contentDigest: sha, kind: "oracle" }
+        ]
+    }), first);
+});
+test("continuation evidence changes progress without completing a scientific gate", () => {
+    const base = {
+        acceptedEvidence: [{ handle: "frozen", contentDigest: sha, kind: "frozen_candidate" }],
+        completedGates: ["candidate_frozen"],
+        environmentDigest: sha
+    };
+    const before = makeAgenticProgressFingerprintV1(base);
+    const after = makeAgenticProgressFingerprintV1({
+        ...base,
+        acceptedEvidence: [
+            ...base.acceptedEvidence,
+            { handle: "partial", contentDigest: otherSha, kind: "continuation_progress" }
+        ]
+    });
+    assert.equal(after.acceptedEvidenceDigest, before.acceptedEvidenceDigest);
+    assert.equal(after.completedGateDigest, before.completedGateDigest);
+    assert.notEqual(after.continuationProgressDigest, before.continuationProgressDigest);
+    assert.deepEqual(makeAgenticProgressFingerprintV1(base), before);
+});
+test("progress receipts attribute revisions, phase, consumption and downstream reserve", () => {
+    const fingerprint = makeAgenticProgressFingerprintV1({
+        acceptedEvidence: [{ handle: "specification", contentDigest: sha, kind: "specification" }],
+        completedGates: ["specification_accepted"],
+        environmentDigest: null
+    });
+    const receipt = decodeAgenticScientificProgressReceiptV1({
+        version: 1,
+        receiptId: "progress-1",
+        operationId: "operation-1",
+        capability: "draft_specification",
+        scientificRole: "specification-author",
+        phase: "drafting",
+        inputRevision: "revision-1",
+        outputRevision: "revision-2",
+        acceptedEvidenceDigest: fingerprint.acceptedEvidenceDigest,
+        previousFingerprint: null,
+        resultingFingerprint: fingerprint,
+        acceptedEvidenceAdded: ["specification"],
+        acceptedEvidenceRemoved: [],
+        gatesCompleted: ["specification_accepted"],
+        gatesInvalidated: [],
+        sameFingerprintCount: 0,
+        consumption: {
+            wallTimeMs: 1000,
+            receivedCalls: 1,
+            spendKnownUsd: "0.01",
+            spendUnknown: false
+        },
+        remaining: {
+            phaseCalls: 2,
+            phaseSpendUsd: "0.25",
+            phaseWallTimeMs: 30_000,
+            phaseAttempts: 1,
+            downstreamCalls: 8,
+            downstreamSpendUsd: "1.5",
+            downstreamWallTimeMs: 300_000,
+            downstreamAttempts: 6
+        },
+        recordedAt: at
+    });
+    assert.equal(receipt.sameFingerprintCount, 0);
+    assert.equal(receipt.remaining.downstreamCalls, 8);
+    const result = decodeAgenticCapabilityResultV1({
+        outcome: "progress",
+        operation: "operation-1",
+        inputDigest: sha,
+        candidateRevision: "revision-2",
+        accepted: ["specification"],
+        evidenceSummary: "Accepted a specification revision.",
+        progressReceipt: receipt,
+        usage: { receivedCalls: 1, spendKnownUsd: "0.01", spendUnknown: false },
+        allowedNext: ["plan_environment"]
+    });
+    assert.equal(result.progressReceipt?.receiptId, "progress-1");
+    const reconciled = decodeAgenticCapabilityResultV1({
+        ...result,
+        reconciliation: {
+            kind: "scientific_progress_stale",
+            latestProgressReceipt: "progress-authoritative",
+            recoveryAction: "get_progress"
+        }
+    });
+    assert.equal(reconciled.reconciliation?.kind, "scientific_progress_stale");
+    assert.equal(reconciled.reconciliation?.latestProgressReceipt, "progress-authoritative");
+    assert.throws(() => decodeAgenticCapabilityResultV1({
+        ...result,
+        reconciliation: {
+            kind: "scientific_progress_stale",
+            latestProgressReceipt: "progress-authoritative",
+            recoveryAction: "retry_same_action"
+        }
+    }));
+    assert.throws(() => decodeAgenticScientificProgressReceiptV1({
+        ...receipt,
+        acceptedEvidenceDigest: otherSha
+    }));
+    assert.throws(() => decodeAgenticCapabilityResultV1({
+        ...result,
+        progressReceipt: { ...receipt, acceptedEvidenceDigest: otherSha }
+    }));
+    const largeHandles = Array.from({ length: 128 }, (_, index) => `${String(index).padStart(3, "0")}-${"x".repeat(245)}`);
+    assert.throws(() => decodeAgenticCapabilityResultV1({
+        ...result,
+        progressReceipt: {
+            ...receipt,
+            acceptedEvidenceAdded: largeHandles,
+            acceptedEvidenceRemoved: largeHandles
+        }
+    }));
+});

package/dist/test/agentic-capabilities.test.d.ts

@@ -0,0 +1 @@
+export {};