assertledger 1.0.0

package/dist/sdk/index.js

@@ -0,0 +1,224 @@
+import { agenticBenchmarkAcquisitionReplayResultJsonSchema, agenticBenchmarkAcquisitionRequestJsonSchema, agenticBenchmarkAcquisitionResultJsonSchema, agenticBenchmarkArtifactJsonSchema, agenticBenchmarkReplayResultJsonSchema, agenticBenchmarkRequestJsonSchema, agenticCorpusAllocationCommitmentJsonSchema, agenticCorpusAllocationCommitmentReplayResultJsonSchema, agenticCorpusAllocationJsonSchema, agenticCorpusAllocationReplayResultJsonSchema, agenticCorpusAllocationRequestJsonSchema, agenticCorpusAllocationRevealJsonSchema, agenticCorpusExperimentArtifactJsonSchema, agenticCorpusExperimentPlanJsonSchema, agenticCorpusExperimentPlanReplayResultJsonSchema, agenticCorpusExperimentReplayRequestJsonSchema, agenticCorpusExperimentReplayResultJsonSchema, agenticCorpusExperimentRequestJsonSchema, agenticProfileReplayResultJsonSchema, agenticProfileReplayResultV2JsonSchema, agenticProfileReportJsonSchema, agenticProfileReportV2JsonSchema, agenticProfileRequestJsonSchema, agenticProfileRequestV2JsonSchema, evidenceManifestJsonSchema, parseAgenticBenchmarkAcquisitionReplayResult, parseAgenticBenchmarkAcquisitionRequest, parseAgenticBenchmarkAcquisitionResult, parseAgenticBenchmarkArtifact, parseAgenticBenchmarkReplayResult, parseAgenticBenchmarkRequest, parseAgenticCorpusAllocation, parseAgenticCorpusAllocationCommitmentReplayResult, parseAgenticCorpusAllocationReplayResult, parseAgenticCorpusAllocationRequest, parseAgenticCorpusExperimentArtifact, parseAgenticCorpusExperimentPlan, parseAgenticCorpusExperimentReplayResult, parseAgenticCorpusExperimentRequest, parseAgenticProfileReplayResult, parseAgenticProfileReplayResultV2, parseAgenticProfileReport, parseAgenticProfileReportV2, parseAgenticProfileRequest, parseAgenticProfileRequestV2, parseEvidenceManifest, parseReplayResult, parseRepositoryAnalysis, parseRepositoryAudit, parseRepositoryInitResult, parseVerificationRequest, replayResultJsonSchema, repositoryAnalysisJsonSchema, repositoryAuditJsonSchema, repositoryInitConfigJsonSchema, repositoryInitLockJsonSchema, repositoryInitResultJsonSchema, verificationRequestJsonSchema, } from "../contracts/index.js";
+import { parseRuntimeDoctorResult } from "../contracts/runtime-doctor.js";
+import { createAgenticBenchmark, createAgenticCorpusAllocation, createAgenticCorpusExperimentArtifact, createAgenticProfile, createAgenticProfileV2, replayAgenticBenchmark, replayAgenticBenchmarkAcquisition, replayAgenticCorpusAllocation, replayAgenticCorpusAllocationCommitment, replayAgenticCorpusExperimentArtifact, replayAgenticProfile, replayAgenticProfileV2, replayEvidenceManifest, } from "../core/index.js";
+import { explainReasonCodes } from "../diagnostics.js";
+import { qualifyGitRegression } from "../engine/git-regression.js";
+import { acquireAgenticBenchmark, analyzeRepository, auditRepository, doctorRepositoryRuntime, initializeRepository, verifyCampaign, } from "../engine/index.js";
+import { replayAgenticCorpusProvenance, verifyAgenticCorpusAllocationCommitmentSignatures, } from "../evaluation/agentic-corpus.js";
+/** Provider-neutral programmatic facade over AssertLedger's deterministic components. */
+export class AssertLedger {
+    explain(codes) {
+        return explainReasonCodes(codes);
+    }
+    async analyze(root) {
+        return parseRepositoryAnalysis(await analyzeRepository(root));
+    }
+    async audit(root, options = {}) {
+        return parseRepositoryAudit(await auditRepository(root, options));
+    }
+    async init(root, options = {}) {
+        return parseRepositoryInitResult(await initializeRepository(root, options));
+    }
+    async doctor(root) {
+        return this.init(root, { dryRun: true });
+    }
+    async doctorRuntime(root, options) {
+        return parseRuntimeDoctorResult(await doctorRepositoryRuntime(root, options));
+    }
+    async verify(request) {
+        return parseEvidenceManifest(await verifyCampaign(parseVerificationRequest(request)));
+    }
+    async checkGitRegression(options) {
+        return qualifyGitRegression(options);
+    }
+    replay(manifest) {
+        let parsedManifest;
+        try {
+            parsedManifest = parseEvidenceManifest(manifest);
+        }
+        catch {
+            return parseReplayResult({
+                valid: false,
+                schemaValid: false,
+                decisionDigestValid: false,
+                artifactDigestValid: false,
+                decisionSemanticsValid: false,
+            });
+        }
+        return parseReplayResult({ ...replayEvidenceManifest(parsedManifest), schemaValid: true });
+    }
+    profile(request) {
+        return parseAgenticProfileReport(createAgenticProfile(parseAgenticProfileRequest(request)));
+    }
+    replayProfile(report) {
+        try {
+            return parseAgenticProfileReplayResult(replayAgenticProfile(parseAgenticProfileReport(report)));
+        }
+        catch {
+            return parseAgenticProfileReplayResult({
+                valid: false,
+                schemaValid: false,
+                sourceManifestValid: false,
+                policyDigestValid: false,
+                reportDigestValid: false,
+                semanticsValid: false,
+            });
+        }
+    }
+    benchmark(request) {
+        return parseAgenticBenchmarkArtifact(createAgenticBenchmark(parseAgenticBenchmarkRequest(request)));
+    }
+    replayBenchmark(artifact) {
+        try {
+            return parseAgenticBenchmarkReplayResult(replayAgenticBenchmark(parseAgenticBenchmarkArtifact(artifact)));
+        }
+        catch {
+            return parseAgenticBenchmarkReplayResult({
+                valid: false,
+                schemaValid: false,
+                sourceManifestValid: false,
+                sourceBindingValid: false,
+                policyDigestValid: false,
+                protocolDigestValid: false,
+                fingerprintDigestValid: false,
+                comparisonScopeDigestValid: false,
+                artifactDigestValid: false,
+                summarySemanticsValid: false,
+            });
+        }
+    }
+    async acquireBenchmark(request) {
+        return parseAgenticBenchmarkAcquisitionResult(await acquireAgenticBenchmark(parseAgenticBenchmarkAcquisitionRequest(request)));
+    }
+    replayBenchmarkAcquisition(result) {
+        return parseAgenticBenchmarkAcquisitionReplayResult(replayAgenticBenchmarkAcquisition(result));
+    }
+    profileV2(request) {
+        return parseAgenticProfileReportV2(createAgenticProfileV2(parseAgenticProfileRequestV2(request)));
+    }
+    replayProfileV2(report) {
+        try {
+            return parseAgenticProfileReplayResultV2(replayAgenticProfileV2(parseAgenticProfileReportV2(report)));
+        }
+        catch {
+            return parseAgenticProfileReplayResultV2({
+                valid: false,
+                schemaValid: false,
+                sourceBenchmarkValid: false,
+                sourceBindingValid: false,
+                policyDigestValid: false,
+                reportDigestValid: false,
+                semanticsValid: false,
+            });
+        }
+    }
+    allocateCorpus(request) {
+        return parseAgenticCorpusAllocation(createAgenticCorpusAllocation(parseAgenticCorpusAllocationRequest(request)));
+    }
+    replayCorpusAllocation(allocation) {
+        try {
+            return parseAgenticCorpusAllocationReplayResult(replayAgenticCorpusAllocation(parseAgenticCorpusAllocation(allocation)));
+        }
+        catch {
+            return parseAgenticCorpusAllocationReplayResult({
+                valid: false,
+                schemaValid: false,
+                allocationDigestValid: false,
+                sourceCaseIdsValid: false,
+                assignmentScoresValid: false,
+                partitionSemanticsValid: false,
+            });
+        }
+    }
+    corpusExperiment(request, plan) {
+        return parseAgenticCorpusExperimentArtifact(createAgenticCorpusExperimentArtifact(parseAgenticCorpusExperimentRequest(request), parseAgenticCorpusExperimentPlan(plan)));
+    }
+    replayCorpusExperiment(artifact, options) {
+        return parseAgenticCorpusExperimentReplayResult(replayAgenticCorpusExperimentArtifact({ artifact }, {
+            ...options,
+            replayProvenance: replayAgenticCorpusProvenance,
+            verifyCommitmentSignatures: verifyAgenticCorpusAllocationCommitmentSignatures,
+        }));
+    }
+    replayCorpusAllocationCommitment(input) {
+        return parseAgenticCorpusAllocationCommitmentReplayResult(replayAgenticCorpusAllocationCommitment(input, {
+            verifySignatures: verifyAgenticCorpusAllocationCommitmentSignatures,
+        }));
+    }
+    schema(name) {
+        switch (name) {
+            case "agentic-corpus-allocation-request":
+                return agenticCorpusAllocationRequestJsonSchema();
+            case "agentic-corpus-allocation":
+                return agenticCorpusAllocationJsonSchema();
+            case "agentic-corpus-allocation-replay-result":
+                return agenticCorpusAllocationReplayResultJsonSchema();
+            case "agentic-corpus-allocation-commitment":
+                return agenticCorpusAllocationCommitmentJsonSchema();
+            case "agentic-corpus-allocation-reveal":
+                return agenticCorpusAllocationRevealJsonSchema();
+            case "agentic-corpus-allocation-commitment-replay-result":
+                return agenticCorpusAllocationCommitmentReplayResultJsonSchema();
+            case "agentic-corpus-experiment-plan":
+                return agenticCorpusExperimentPlanJsonSchema();
+            case "agentic-corpus-experiment-plan-replay-result":
+                return agenticCorpusExperimentPlanReplayResultJsonSchema();
+            case "agentic-corpus-experiment-request":
+                return agenticCorpusExperimentRequestJsonSchema();
+            case "agentic-corpus-experiment-artifact":
+                return agenticCorpusExperimentArtifactJsonSchema();
+            case "agentic-corpus-experiment-replay-request":
+                return agenticCorpusExperimentReplayRequestJsonSchema();
+            case "agentic-corpus-experiment-replay-result":
+                return agenticCorpusExperimentReplayResultJsonSchema();
+            case "agentic-benchmark-request":
+                return agenticBenchmarkRequestJsonSchema();
+            case "agentic-benchmark-artifact":
+                return agenticBenchmarkArtifactJsonSchema();
+            case "agentic-benchmark-replay-result":
+                return agenticBenchmarkReplayResultJsonSchema();
+            case "agentic-benchmark-acquisition-request":
+                return agenticBenchmarkAcquisitionRequestJsonSchema();
+            case "agentic-benchmark-acquisition-result":
+                return agenticBenchmarkAcquisitionResultJsonSchema();
+            case "agentic-benchmark-acquisition-replay-result":
+                return agenticBenchmarkAcquisitionReplayResultJsonSchema();
+            case "agentic-profile-request":
+                return agenticProfileRequestJsonSchema();
+            case "agentic-profile-report":
+                return agenticProfileReportJsonSchema();
+            case "agentic-profile-replay-result":
+                return agenticProfileReplayResultJsonSchema();
+            case "agentic-profile-request-v2":
+                return agenticProfileRequestV2JsonSchema();
+            case "agentic-profile-report-v2":
+                return agenticProfileReportV2JsonSchema();
+            case "agentic-profile-replay-result-v2":
+                return agenticProfileReplayResultV2JsonSchema();
+            case "verification-request":
+                return verificationRequestJsonSchema();
+            case "repository-analysis":
+                return repositoryAnalysisJsonSchema();
+            case "repository-audit":
+                return repositoryAuditJsonSchema();
+            case "repository-init-config":
+                return repositoryInitConfigJsonSchema();
+            case "repository-init-lock":
+                return repositoryInitLockJsonSchema();
+            case "repository-init-result":
+                return repositoryInitResultJsonSchema();
+            case "evidence-manifest":
+                return evidenceManifestJsonSchema();
+            case "replay-result":
+                return replayResultJsonSchema();
+        }
+    }
+}
+/** @deprecated Use `AssertLedger`. Alias retained for v1 compatibility. */
+export class TestForge extends AssertLedger {
+}
+export { parseVerificationRequest, verificationRequestJsonSchema } from "../contracts/index.js";
+export { createAgenticBenchmark, createAgenticCorpusAllocation, createAgenticCorpusExperimentArtifact, createAgenticProfile, createAgenticProfileV2, replayAgenticBenchmark, replayAgenticBenchmarkAcquisition, replayAgenticCorpusAllocation, replayAgenticCorpusExperimentArtifact, replayAgenticProfile, replayAgenticProfileV2, replayEvidenceManifest, verifyDecisionDigest, verifyManifestIntegrity, } from "../core/index.js";
+export { qualifyGitRegression } from "../engine/git-regression.js";
+export { acquireAgenticBenchmark, analyzeRepository, auditRepository, doctorRepositoryRuntime, initializeRepository, verifyCampaign, } from "../engine/index.js";
+//# sourceMappingURL=index.js.map

package/dist/sdk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"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"}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const ASSERTLEDGER_VERSION: string;
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,QAAuB,CAAC"}

package/dist/version.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+function readPackageVersion() {
+    const document = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    if (typeof document.version !== "string" || document.version.length === 0) {
+        throw new Error("PACKAGE_VERSION_INVALID");
+    }
+    return document.version;
+}
+export const ASSERTLEDGER_VERSION = readPackageVersion();
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,SAAS,kBAAkB;IACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CACzB,YAAY,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CACzC,CAAC;IAC3B,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1E,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,QAAQ,CAAC,OAAO,CAAC;AAC1B,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,kBAAkB,EAAE,CAAC"}

package/docs/adapter-protocol.md

@@ -0,0 +1,196 @@
+# Test adapters
+
+Adapters translate a test runner's behavior into AssertLedger's normalized observation taxonomy. They
+do not decide candidate eligibility, target credit, campaign status, or selection.
+
+## Built-in `node:test` adapter
+
+Configure the built-in adapter in a verification request:
+
+```json
+{
+  "kind": "node-test",
+  "executable": "node",
+  "baseTestFiles": ["tests/base.test.js"]
+}
+```
+
+For each execution, AssertLedger invokes the executable with an argument array equivalent to:
+
+```text
+--test
+--test-reporter=<AssertLedger reporter URL>
+--test-reporter-destination=<bounded result file>
+--
+<baseTestFiles...>
+<candidateFiles...>
+```
+
+The engine adds an AssertLedger-owned `node:test` reporter and destination to the command and uses
+`shell: false`. The reporter consumes runtime events, counts dequeued tests, normalizes each event's
+file path, and compares it with the resolved candidate file set. It also separates candidate from
+non-candidate failures. Assertion attribution is intentionally shallow: only an immediate
+`data.details.error.cause.code === "ERR_ASSERTION"` under Node's structured
+`failureType === "testCodeFailure"` wrapper is accepted. Nested causes are never traversed.
+
+The child receives the configured environment allowlist plus
+`TESTFORGE_NODE_CANDIDATE_FILES`, a JSON array of resolved candidate paths used by the reporter.
+Allowlist entries cannot be `NODE_OPTIONS` or begin with `TESTFORGE_` or `NODE_TEST_`, compared
+case-insensitively.
+
+The engine admits `ASSERTION_FAILURE` only when every candidate failure has that immediate Node.js
+assertion cause, no non-candidate test failed, and at least one candidate test was discovered.
+Assertion libraries that do not expose this code are not admitted as assertion evidence. A generic
+error whose nested cause is an `AssertionError` is deliberately rejected. On supported Node 22
+runtimes, structured reporter events do not preserve a faithful `SyntaxError` identity for parse,
+import, or load failures. Those failures therefore remain non-attributed `PROCESS_CRASH`, as do all
+other non-assertion failures. The official profile declares both `detectsCompileFailure: false` and
+`detectsCollectionFailure: false`; it never infers either outcome from stderr, messages, or stacks. A
+missing or malformed report, or a report larger than 64 KiB, becomes `INFRA_ERROR`.
+
+To preserve reporter custody and a complete execution plan, `extraArguments` must be absent or an
+empty array. AssertLedger inserts `--` before all base-test and candidate paths so path tokens cannot be
+parsed as Node.js options.
+
+Before execution, AssertLedger probes the requested executable, resolves the reported `process.execPath`
+to a file real path, then probes that resolved file again. Both probes must report the same supported
+Node.js version (22.15 or newer). The manifest records the requested executable, resolved path,
+version, and executable SHA-256 digest.
+
+Executable and runtime qualification probes cap captured stdout and stderr at the smaller of
+`maximumOutputBytes` and 64 KiB. A truncated executable identity report fails closed with
+`NODE_TEST_EXECUTABLE_PROBE_FAILED`; increase the explicit capture budget if a long runtime path
+cannot fit. Controlled reporter files retain their separate 64 KiB limit.
+
+Before creating a campaign workspace, AssertLedger also runs an uncached runtime preflight against
+that resolved executable and the exact bundled reporter. It uses the engine's central bounded
+process runner, including its process-tree termination and `shell: false` guarantees. Each probe
+respects `timeoutMsPerExecution`, capped at 5 seconds, and includes one passing
+non-candidate control plus one candidate test. The report must contain exactly two discovered tests,
+one candidate discovery, one candidate failure, zero non-candidate failures, zero syntax claims, and
+a non-zero exit. The direct Node assertion must classify as attributed `ASSERTION_FAILURE`; a generic
+error carrying a nested assertion cause must remain non-attributed `PROCESS_CRASH`. A missing,
+malformed, contradictory, or timed-out probe fails closed with
+`NODE_TEST_PROFILE_PREFLIGHT_FAILED`; no candidate execution starts. Successful evidence records
+these deterministic facts without a timestamp under
+`evidenceContext.adapter.configuration.runtimePreflight`.
+
+File-based runtime attribution is stronger than source scanning, but it is not authenticated. The
+Node.js runner, reporter events, candidate code, dependencies, and host remain trusted inputs.
+
+## Structured command adapter protocol v1
+
+The legacy wire identifier `testforge-command` lets any framework participate without moving gate logic into the
+integration.
+
+Configure an executable and an argument array:
+
+```json
+{
+  "kind": "testforge-command",
+  "executable": "node",
+  "arguments": ["tools/assertledger-reporter.mjs"],
+  "protocolVersion": "1.0.0"
+}
+```
+
+### Invocation
+
+AssertLedger spawns the command with `shell: false` in a fresh execution workspace. The child receives
+only environment variables named in `isolation.environmentAllowlist`, plus two reserved variables
+injected by AssertLedger:
+
+- `TESTFORGE_RESULT_FILE`: absolute path where the adapter must write one UTF-8 JSON result;
+- `TESTFORGE_CANDIDATE_FILES`: JSON array of candidate file paths, empty for a control run.
+
+AssertLedger does not expose the world ID or expected outcome through reserved variables. The adapter
+can still inspect the workspace and infer changes. This omission discourages accidental gaming; it
+does not defend against hostile code.
+
+### Result contract
+
+The adapter must write this strict JSON shape to `TESTFORGE_RESULT_FILE`:
+
+```json
+{
+  "protocolVersion": "1.0.0",
+  "outcome": "ASSERTION_FAILURE",
+  "testsDiscovered": 12,
+  "candidateTestsDiscovered": 1,
+  "attributed": true
+}
+```
+
+Rules:
+
+- `protocolVersion` must equal `1.0.0`;
+- `outcome` must be one of the documented normalized outcomes;
+- both counts must be non-negative integers;
+- `candidateTestsDiscovered` must not exceed `testsDiscovered`;
+- a control must report `candidateTestsDiscovered: 0` and `attributed: false` to pass control gates;
+- `attributed: true` is only valid when `outcome` is `PASS` or `ASSERTION_FAILURE` and
+  `candidateTestsDiscovered` is at least `1`; every other `outcome`/`attributed: true` combination,
+  including a zero candidate-discovery count, is rejected;
+- `PASS` requires process exit code `0`;
+- every non-`PASS` report requires a non-zero process exit code;
+- `TIMEOUT` is engine-authoritative: an adapter process that finishes and writes `TIMEOUT` produces
+  `INFRA_ERROR`; only expiry of the configured engine deadline produces a timeout observation;
+- the report file must not exceed the fixed 64 KiB structured-report limit;
+- a missing, malformed, oversized, attribution-contradictory, or process-contradictory report becomes
+  `INFRA_ERROR`;
+- only attributed `ASSERTION_FAILURE` can kill a target in policy v1.
+
+### Protocol v1 compatibility note
+
+This validation is a fail-closed correction within protocol `1.0.0`, not a new wire shape. Conforming
+v1 adapters require no migration. Adapters that previously emitted `attributed: true` without a
+discovered candidate test, attributed an operational outcome, or self-declared `TIMEOUT` must stop
+doing so; those contradictory reports now become `INFRA_ERROR`.
+
+New node:test manifests also record an official profile version, capabilities, the SHA-256 digest of
+the bundled reporter, and deterministic `runtimePreflight` evidence. The shallow assertion rule and
+the corrected `detectsCompileFailure: false` capability change the reporter/profile metadata, so new
+campaign decision and artifact digests change because the evidence context is decision-bound. Legacy
+v1 manifests without this optional metadata remain schema-valid and replayable; they are not silently
+resealed.
+
+The 64 KiB report limit is independent of `maximumOutputBytes`, which caps each execution's captured
+stdout and stderr. A small log budget therefore does not truncate controlled report evidence.
+
+The adapter is trusted to report discovery, attribution, and outcome accurately. AssertLedger binds the
+configured executable and arguments, protocol version, and normalized observations into manifest
+integrity data. Reproducible deployments should pin the adapter and its resolved dependencies and
+record verifiable provenance outside the free-form provenance label when authenticity matters.
+
+### H3 structured-result consistency
+
+The separate `TESTFORGE_H3_STRUCTURED_RESULT_V1` replay path binds each canonical result to its run
+receipt. `PASS` requires a zero exit code without timeout; `PROCESS_CRASH` requires a null exit code
+without timeout; `TIMEOUT` requires the timeout flag; and `ASSERTION_FAILURE`, `COMPILE_FAILURE`,
+`COLLECTION_FAILURE`, `INFRA_ERROR`, and `NO_TEST_DISCOVERED` require a nonzero, non-null exit code
+without timeout. A mismatch is invalid structured evidence and cannot become an H3 detection or a
+merely insufficient run.
+
+## Strict phase-aware benchmark mode
+
+`benchmark-acquire` reuses the same executable and argument array with `shell: false`, but injects
+a distinct contract: `TESTFORGE_BENCHMARK_RESULT_FILE`, `TESTFORGE_CANDIDATE_FILES`,
+`TESTFORGE_BENCHMARK_CACHE_DIR`, `TESTFORGE_BENCHMARK_REGIME`,
+`TESTFORGE_BENCHMARK_ROLE`, and `TESTFORGE_BENCHMARK_ORDINAL`.
+
+Successful reports use protocol `1.0.0`, outcome `PASS`, positive candidate discovery with
+attribution, nullable non-negative CPU microseconds, and exactly ordered `STARTUP`,
+`COMPILE_OR_COLLECTION`, and `EXECUTION` safe-integer microseconds. AssertLedger measures
+`PREPARATION` around the fresh repository copy plus REFERENCE and candidate overlays.
+`STARTUP` is adapter-observed initialization, not operating-system spawn latency.
+
+Missing, malformed, contradictory, timed-out, non-PASS, or overflowing reports become
+`INCOMPLETE` runs with null timings. They never count as target kills and cannot alter the source
+decision. The phase adapter belongs to the trusted computing base and may ignore the supplied cache
+directory.
+
+The runnable
+[`structured-phase-adapter-fixture.mjs`](../examples/agentic-benchmark/structured-phase-adapter-fixture.mjs)
+demonstrates both wire modes with illustrative fixed durations. Real adapters must measure their
+own boundaries. `node-test` is deliberately unsupported because Node 22 and 24 expose no faithful
+public compilation/collection timing boundary.

package/docs/agentic-benchmark.md

@@ -0,0 +1,118 @@
+# Agentic Benchmark Artifact v1
+
+The Agentic Benchmark Artifact is a deterministic, self-contained cost-evidence document for
+agentic test loops. It records cold and warm measurements separately and publishes phase-level
+wall time plus optional CPU time. It is deliberately separate from the evidence manifest and the
+Agentic Test Profile.
+
+## Safety boundary
+
+A benchmark can neither create nor remove a `VERIFIED` decision. Creation requires a replay-valid
+source manifest whose decision is already `VERIFIED`, a required reference world, and selected
+`ELIGIBLE` candidates. Failed or incomplete benchmark runs remain visible and never enter
+quantiles.
+
+The artifact proves deterministic aggregation and binding of declared measurements. It does not
+authenticate the machine, tools, cache reset, phase reporter, or raw timings. Those remain producer
+and attestation responsibilities.
+
+## Acquisition from a fresh campaign
+
+`assertledger benchmark-acquire request.json --allow-unsafe-execution --json` embeds a Verification
+Request v1, the fixed Benchmark v1 policy and protocol, a required REFERENCE world, resource
+declarations, and phase-adapter/dependency identity paths.
+
+AssertLedger creates one immutable acquisition snapshot. A normal isolated verification campaign runs
+from it. Benchmark processes start only when the fresh manifest is replay-valid and `VERIFIED`, and
+only for source-selected `ELIGIBLE` candidates. Every timing run uses a fresh workspace and process.
+Each COLD run receives a unique empty cache directory; each candidate receives a private, initially
+empty WARM directory retained across its warmups and measurements.
+
+The result embeds the untouched source manifest, a nullable Benchmark Artifact v1, snapshot,
+executable, argument, adapter-identity and dependency digests, the cache policy, and canonical
+request/result digests. Timing failures cannot rewrite the embedded decision or its source digests.
+
+`benchmark-acquire-replay` recomputes the result digest and independently checks schema validity,
+source-manifest replay, exact source/artifact binding, artifact replay, context/fingerprint binding,
+and exact status precedence and reason codes. Re-digesting a modified status, context, source, or
+artifact does not make the acquisition result valid.
+
+The phase-adapter fingerprint binds the declared identity-file path together with the adapter
+arguments and identity digest. Changing only `identityFilePath` and recomputing `resultDigest`
+therefore fails context replay.
+
+`SOURCE_NOT_VERIFIED` results intentionally have no Benchmark Artifact or fingerprint. Their source
+manifest, status semantics, and result digest can replay independently, but adapter/dependency
+identity digests have no independent anchor. `contextBindingValid` and aggregate `valid` are
+therefore false. This does not change or invalidate the embedded source campaign decision; it avoids
+claiming identity authentication that the null-artifact result cannot provide.
+
+The acquisition schemas are additive. Existing hand-authored Benchmark Request/Artifact v1 flows
+remain compatible. There is no automatic migration because acquisition requires unsafe-execution
+authority and explicit identity paths.
+
+## Fixed protocol
+
+Version 1 uses:
+
+- a monotonic clock;
+- safe-integer microseconds;
+- nearest-rank quantiles without interpolation;
+- four ordered phases: `PREPARATION`, `STARTUP`, `COMPILE_OR_COLLECTION`, and `EXECUTION`;
+- cold runs in a fresh workspace and process after resetting declared caches; and
+- warm runs in a fresh workspace and process while retaining declared caches, after at least one
+  recorded warmup.
+
+"Declared caches" excludes implicit operating-system caches. AssertLedger never claims to purge or
+control them.
+
+## Fingerprint and comparison scope
+
+The request declares an opaque portable `environmentId`, OS and CPU descriptors, optional resource
+limits, tool digests, dependency graph digest, and phase-reporter digest. Hostnames, serial numbers,
+absolute paths, and environment values are outside the contract.
+
+The artifact binds a `comparisonScopeDigest` over the environment fingerprint, protocol, source
+decision, and required reference world. Two artifacts are comparable only when this digest is
+identical. Matching labels or apparently similar machines are not enough.
+
+## Run plan
+
+The policy declares exact counts for cold measurements, warmups, and warm measurements. Ordinals
+are contiguous per candidate, regime, and role. A complete run must pass and its total must equal
+the exact sum of all four phases. An incomplete run preserves its non-pass outcome with null timing.
+
+For each candidate and regime, the artifact reports:
+
+- `MEASURED`, `INSUFFICIENT_SAMPLES`, or `OBSERVED_RUN_FAILURE`;
+- planned, recorded, accepted, failed, and warmup counts;
+- min, p50, p95, and max for total wall time and every phase; and
+- CPU availability as `UNAVAILABLE`, `PARTIAL`, or `COMPLETE`.
+
+CPU quantiles exist only when every accepted measurement has CPU time. Missing CPU evidence is not
+converted to zero.
+
+## Interfaces
+
+```sh
+assertledger benchmark benchmark-request.json --json
+assertledger benchmark-replay benchmark-artifact.json --json
+```
+
+The SDK exposes `AssertLedger.benchmark()` and `AssertLedger.replayBenchmark()`. The read-only MCP server
+exposes the preferred `assertledger_benchmark` and `assertledger_benchmark_replay` tools alongside the
+legacy `testforge_benchmark` and `testforge_benchmark_replay` aliases.
+
+Exit code `0` means every regime is `MEASURED`; `2` means at least one observed run failure; `3`
+means timing evidence is insufficient; `4` means invalid input or replay.
+
+The built-in `node:test` reporter does not currently emit trustworthy phase markers. AssertLedger can
+therefore consume a correctly attributed request from an external phase reporter, but it does not
+yet acquire this artifact automatically from `node:test`. Unsupported acquisition must fail closed;
+it must never synthesize phases from the existing process wall time.
+
+## Replay rails
+
+Replay independently checks schema validity, source replay, source binding, policy, protocol and
+fingerprint digests, comparison scope, artifact digest, and recomputed summary semantics. A replay-
+valid artifact may still contain insufficient samples or observed failures.