assertledger 1.3.1 → 1.5.0

package/README.fr.md

@@ -9,12 +9,12 @@ Vous obtenez un verdict, les observations qui le justifient et un fichier de pre
 
 [Essayer l’exemple](#essayer-lexemple) · [Comprendre le résultat](#comprendre-le-résultat) · [Utiliser votre dépôt](#utiliser-votre-dépôt) · [Documentation](#documentation)
 
-**1.3 · node:test et bun:test · CLI, SDK et MCP · MIT**
+**1.4 · node:test et bun:test · CLI, SDK et MCP · MIT**
 
 Installez l’outil dans votre dépôt avec Node.js 22.15 ou une version ultérieure :
 
 ```sh
-npm install --save-dev assertledger@1.3.1
+npm install --save-dev assertledger@1.5.0
 npx assertledger doctor .
 ```
 
@@ -60,7 +60,7 @@ flowchart LR
 Prérequis : **Git**, **Node.js 22.15+** et **pnpm 11.1.2**. L’exemple utilise l’adaptateur intégré `node:test`.
 
 ```sh
-git clone --branch v1.3.1 https://github.com/hoklims/assertledger.git
+git clone --branch v1.5.0 https://github.com/hoklims/assertledger.git
 cd assertledger
 pnpm install --frozen-lockfile
 pnpm build
@@ -181,6 +181,9 @@ L’adaptateur cible précisément Bun 1.4.2 et attribue les échecs de cet outi
 natifs restent des erreurs d’exécution et ne comptent pas comme détection du défaut. Le
 [guide de migration Bun](docs/migration-verification-v3.md) décrit la requête, l’exécution et le
 rejeu. Ce mode exécute du code local de confiance sans bac à sable.
+Pour vérifier un test `bun:test` existant désigné par son nom, ou rejouer un témoin rouge/vert
+enregistré, utilisez une requête v4 ou `import-witness`, qui s’exécutent aussi en conteneur ou dans un
+mode Windows natif déclaré ; voir le [guide de migration v4](docs/migration-verification-v4.md).
 
 ### Qualifier un test de régression commité
 

package/README.md

@@ -9,12 +9,12 @@ You get a verdict, the observations behind it and an evidence file you can repla
 
 [Try the example](#try-the-example) · [Understand the result](#understand-the-result) · [Use your repository](#use-your-repository) · [Documentation](#documentation)
 
-**1.3 · node:test and bun:test · CLI, SDK and MCP · MIT**
+**1.4 · node:test and bun:test · CLI, SDK and MCP · MIT**
 
 Install in your repository with Node.js 22.15 or later:
 
 ```sh
-npm install --save-dev assertledger@1.3.1
+npm install --save-dev assertledger@1.5.0
 npx assertledger doctor .
 ```
 
@@ -59,7 +59,7 @@ flowchart LR
 You need **Git**, **Node.js 22.15+** and **pnpm 11.1.2**. The example uses the built-in `node:test` adapter.
 
 ```sh
-git clone --branch v1.3.1 https://github.com/hoklims/assertledger.git
+git clone --branch v1.5.0 https://github.com/hoklims/assertledger.git
 cd assertledger
 pnpm install --frozen-lockfile
 pnpm build
@@ -173,6 +173,9 @@ The Bun adapter pins version 1.4.2 and attributes failures from this helper. Nat
 failures remain operational failures and cannot count as target detection. See the
 [Bun migration guide](docs/migration-verification-v3.md) for the request, execution and replay
 contract. The execution mode is explicitly unsandboxed and intended for trusted local code.
+To verify an existing `bun:test` test by name, or to replay a recorded red/green witness, use a v4
+request or `import-witness`, which also run in a container or a declared Windows-native backend; see
+the [v4 migration guide](docs/migration-verification-v4.md).
 
 ### Qualify a committed regression test
 

package/conformance/schema-extensions.json

@@ -27,6 +27,11 @@
       "rawSha256": "sha256:460925ce29c51e47a38e439264f56dac9d444f52a07ec103f38b44e59679adbd",
       "$id": "https://testforge.dev/schemas/evidence-manifest.v3.json"
     },
+    {
+      "path": "schemas/evidence-manifest.v4.json",
+      "rawSha256": "sha256:56bad50457b84864decbe911d98e3257880e4562d69487b4a820f7d516c3d11b",
+      "$id": "https://testforge.dev/schemas/evidence-manifest.v4.json"
+    },
     {
       "path": "schemas/evidence-provider-manifest.v1.json",
       "rawSha256": "sha256:6100995f772cd24b7369e4428fb1aba570f1ba6e1f61295bc42a1f7ce6b5bde3",
@@ -56,6 +61,16 @@
       "path": "schemas/verification-request.v3.json",
       "rawSha256": "sha256:3b88e4c58425aa9a45da330b27f4a48d778c1f9a2494ac2a9a4c01b29728fd77",
       "$id": "https://testforge.dev/schemas/verification-request.v3.json"
+    },
+    {
+      "path": "schemas/verification-request.v4.json",
+      "rawSha256": "sha256:f08389ef40c7d73d7f1c2006aee2efcd2bf53c8b78338883f4bc9f21808db842",
+      "$id": "https://testforge.dev/schemas/verification-request.v4.json"
+    },
+    {
+      "path": "schemas/witness-import-request.v1.json",
+      "rawSha256": "sha256:ec2aa94fd0d50e6dec7ff6f6b9bea294febf8d7ba4598e01fe89177f97348974",
+      "$id": "https://testforge.dev/schemas/witness-import-request.v1.json"
     }
   ]
 }

package/dist/build-info.json

@@ -1,7 +1,7 @@
 {
   "sourceRevision": {
     "status": "RECORDED",
-    "commit": "a0d358248efc7f13556a989bd132da49b46cec36",
+    "commit": "9895fee7350669b65e033c47f6ebe33675fb6f5a",
     "worktree": "CLEAN"
   }
 }

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AASA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMlD,OAAO,EAAgD,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAWlG,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,eAAe,CAAC;IACzC,cAAc,CAAC,EAAE,OAAO,cAAc,CAAC;CACxC;AAkoBD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,EAAE,KAAK,EACT,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,MAAM,CAAC,CAyvBjB"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAcA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOlD,OAAO,EAAgD,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAYlG,MAAM,WAAW,KAAK;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,eAAe,CAAC;IACzC,cAAc,CAAC,EAAE,OAAO,cAAc,CAAC;CACxC;AAkrBD,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,EAAE,KAAK,EACT,YAAY,GAAE,eAAoB,GACjC,OAAO,CAAC,MAAM,CAAC,CAs7BjB"}

package/dist/cli.js

@@ -4,12 +4,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { ContractError } from "./contracts/index.js";
-import { renderDiagnostics, renderRepositoryLinkRefusal } from "./diagnostics.js";
+import { QualificationExpectedDomainSchema } from "./contracts/qualification.js";
+import { quoteRepositoryEntry, renderDiagnostics, renderRepositoryLinkRefusal, } from "./diagnostics.js";
 import { connectClient, disconnectClient } from "./engine/connection.js";
 import { parseContainerRuntimeCommand } from "./engine/container.js";
 import { runFixtureDemo } from "./engine/demo.js";
 import { renderGitRegressionSummary, } from "./engine/git-regression.js";
 import { setupRepository } from "./engine/setup.js";
+import { DEFAULT_WITNESS_ENVIRONMENT_ALLOWLIST } from "./engine/witness-import.js";
 import { AgenticCorpusError, evaluateAgenticCorpusHoldout, evaluateAgenticCorpusPublic, inspectAgenticCorpus, } from "./evaluation/agentic-corpus.js";
 import { createAssertLedgerServer } from "./mcp/index.js";
 import { AssertLedger } from "./sdk/index.js";
@@ -58,9 +60,21 @@ Commands:
           evidence-provider-manifest|evidence-export-request|evidence-export|
           evidence-export-replay-result>
                                                Print a JSON Schema
-  verify [request.json|-] [--container-runtime JSON_ARGV | --allow-unsafe-execution]
-                                               Execute a v2 container or trusted-local campaign
+  verify [request.json|-] [--container-runtime JSON_ARGV | --allow-unsafe-execution
+        | --allow-windows-native-execution]   Execute a v2-v4 container, trusted-local or
+                                               declared Windows-native campaign
+  import-witness [request.json|-] --out DIRECTORY
+        (--container-image NAME@sha256:DIGEST [--container-runtime JSON_ARGV]
+         | --allow-unsafe-execution | --allow-windows-native-execution)
+        [--env NAME ...] [--json]              Replay a recorded red/green witness
   replay [manifest.json|-]                     Verify an evidence digest
+  qualification-plan [plan.json|-]             Seal an operator-owned obligation inventory
+  qualify [request.json|-] --allow-unsafe-execution
+                                               Execute a scoped UNSANDBOXED qualification
+  qualification-replay [receipt.json|-] [--domain domain.json]
+                                               Replay integrity and explicit validity domain
+  qualification-ci [receipt.json|-] --observation observation.json
+                                               Admit an independently signed CI observation
   export [request.json|-]                      Export replay-valid evidence for external consumers
   export-replay [export.json|-]                Replay an evidence export
   provider                                     Describe the evidence provider and its limits
@@ -106,6 +120,10 @@ function authorizeTrustedLocalExecution(request) {
         },
     };
 }
+/** Windows-native execution has its own operator flag; the request value alone never grants it. */
+function authorizeWindowsNativeExecution(request) {
+    return authorizeTrustedLocalExecution(request);
+}
 function authorizeBenchmarkAcquisition(request) {
     if (!isRecord(request) || !isRecord(request.verificationRequest))
         return request;
@@ -565,6 +583,20 @@ const VALIDATION_ERROR_CODES = new Set([
     "UNSUPPORTED_ADAPTER",
     "UNSUPPORTED_ISOLATION",
     "UNSUPPORTED_REPOSITORY_SYMLINK",
+    "REPOSITORY_LINK_IN_TEST_CLOSURE",
+    "REPOSITORY_LINK_ESCAPES_ROOT",
+    "TEST_CLOSURE_UNBOUNDED",
+    "WINDOWS_NATIVE_HOST_REQUIRED",
+    "WINDOWS_NATIVE_EXECUTION_NOT_ACKNOWLEDGED",
+    "DESIGNATED_TEST_OVERLAID",
+    "DESIGNATED_TEST_FILE_MISSING",
+    "REPOSITORY_DEPENDENCIES_EXCLUDED",
+    "WITNESS_REPOSITORY_INVALID",
+    "WITNESS_TARGET_PATH_INVALID",
+    "WITNESS_TARGET_BASE_MISMATCH",
+    "WITNESS_TARGET_UNCHANGED",
+    "WITNESS_OUTPUT_INSIDE_REPOSITORY",
+    "WITNESS_OUTPUT_EXISTS",
     "VERIFICATION_REQUEST_REPOSITORY_MISMATCH",
     "WORLD_BUDGET_EXCEEDED",
     "WORLD_OVERLAY_BYTES_EXCEEDED",
@@ -598,6 +630,19 @@ function classifyError(error) {
     }
     return 5;
 }
+/** Names the link that refused a static diagnostic, or the computed imports that leave the closure
+ * unbounded. Repository paths are untrusted content and are quoted. */
+function renderLinkAssessment(assessment) {
+    if (assessment === undefined)
+        return undefined;
+    if (assessment.refused !== undefined) {
+        return `Link detail: ${quoteRepositoryEntry(assessment.refused.path)} (${assessment.refused.reasonCode})`;
+    }
+    const unbounded = assessment.unbounded
+        .slice(0, 20)
+        .map((edge) => `Unbounded closure: ${quoteRepositoryEntry(edge.file)} (${edge.reason})`);
+    return [`Links outside every test closure: ${assessment.omitted.length}`, ...unbounded].join("\n");
+}
 export async function runCli(argv, io, dependencies = {}) {
     const ledger = new AssertLedger();
     const positional = argv.filter((argument) => !argument.startsWith("--"));
@@ -699,10 +744,17 @@ export async function runCli(argv, io, dependencies = {}) {
                     }
                     return runtimeResult.status === "READY" ? 0 : 3;
                 }
+                let linkAssessment;
                 const result = await ledger.doctor(root, {
                     ...(exclude.length === 0 ? {} : { exclude }),
                     ...(framework === undefined ? {} : { framework }),
+                    onLinkAssessment: (assessment) => {
+                        linkAssessment = assessment;
+                    },
                 });
+                const linkDetail = renderLinkAssessment(linkAssessment);
+                if (linkDetail !== undefined)
+                    io.writeStderr(`${linkDetail}\n`);
                 if (argv.includes("--json")) {
                     writeJson(io, result);
                 }
@@ -894,6 +946,11 @@ export async function runCli(argv, io, dependencies = {}) {
                 return 0;
             }
             case "analyze": {
+                // `--json` stays accepted: the output is always JSON and the documented invocations pass it.
+                if (argv.slice(1).some((argument) => argument.startsWith("-") && argument !== "--json")) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
                 const root = path.resolve(io.cwd, positional[1] ?? ".");
                 writeJson(io, await ledger.analyze(root));
                 return 0;
@@ -1024,6 +1081,75 @@ export async function runCli(argv, io, dependencies = {}) {
                     io.writeStdout(renderGitRegressionSummary(result, options));
                 return decisionExitCode(result);
             }
+            case "import-witness": {
+                const valueFlags = new Set(["--out", "--container-image", "--container-runtime", "--env"]);
+                const booleanFlags = new Set([
+                    "--allow-unsafe-execution",
+                    "--allow-windows-native-execution",
+                    "--json",
+                ]);
+                let input;
+                for (let index = 1; index < argv.length; index += 1) {
+                    const argument = argv[index] ?? "";
+                    if (valueFlags.has(argument)) {
+                        const value = argv[index + 1];
+                        if (value === undefined || value.startsWith("--")) {
+                            io.writeStderr(USAGE);
+                            return 64;
+                        }
+                        index += 1;
+                    }
+                    else if (!booleanFlags.has(argument)) {
+                        if (argument.startsWith("--") || input !== undefined) {
+                            io.writeStderr(USAGE);
+                            return 64;
+                        }
+                        input = argument;
+                    }
+                }
+                const out = optionalFlag(argv, "--out");
+                if (out === undefined) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
+                const allowUnsafeExecution = argv.includes("--allow-unsafe-execution");
+                const allowWindowsNative = argv.includes("--allow-windows-native-execution");
+                const containerImage = optionalFlag(argv, "--container-image");
+                const containerRuntime = optionalFlag(argv, "--container-runtime");
+                const environment = repeatedFlagValues(argv, "--env");
+                const selected = [allowUnsafeExecution, allowWindowsNative, containerImage !== undefined];
+                if (selected.filter(Boolean).length > 1 ||
+                    (containerImage === undefined && containerRuntime !== undefined) ||
+                    (containerImage !== undefined && environment.length > 0)) {
+                    throw new TypeError("ISOLATION_MODE_CONFLICT");
+                }
+                if (!selected.some(Boolean)) {
+                    io.writeStderr("Refusing to replay a witness without an authorized backend: pass --container-image, " +
+                        "--allow-unsafe-execution or --allow-windows-native-execution.\n");
+                    return 4;
+                }
+                const environmentAllowlist = environment.length === 0 ? [...DEFAULT_WITNESS_ENVIRONMENT_ALLOWLIST] : environment;
+                const result = await ledger.importWitness(await readJsonInput(input, io), {
+                    out: path.resolve(io.cwd, out),
+                    isolation: containerImage !== undefined
+                        ? {
+                            kind: "container",
+                            image: containerImage,
+                            ...(containerRuntime === undefined
+                                ? {}
+                                : { runtimeCommand: parseContainerRuntimeCommand(containerRuntime) }),
+                        }
+                        : allowWindowsNative
+                            ? { kind: "windows-native", environmentAllowlist }
+                            : { kind: "trusted-local", environmentAllowlist },
+                });
+                if (argv.includes("--json"))
+                    writeJson(io, result);
+                else {
+                    io.writeStdout(`${await readFile(path.join(path.resolve(io.cwd, out), "summary.md"), "utf8")}`);
+                }
+                return decisionExitCode(result);
+            }
             case "schema": {
                 const name = positional[1];
                 if (name !== "verification-request" &&
@@ -1043,6 +1169,10 @@ export async function runCli(argv, io, dependencies = {}) {
                     name !== "replay-result" &&
                     name !== "agentic-benchmark-request" &&
                     name !== "agentic-benchmark-artifact" &&
+                    name !== "qualification-plan" &&
+                    name !== "qualification-execution-request" &&
+                    name !== "qualification-receipt" &&
+                    name !== "qualification-replay-result" &&
                     name !== "agentic-benchmark-replay-result" &&
                     name !== "agentic-benchmark-acquisition-request" &&
                     name !== "agentic-benchmark-acquisition-result" &&
@@ -1078,22 +1208,43 @@ export async function runCli(argv, io, dependencies = {}) {
             case "verify": {
                 const request = await readJsonInput(positionalArguments(argv, new Set(["--container-runtime"]))[1], io);
                 const allowUnsafeExecution = argv.includes("--allow-unsafe-execution");
+                const allowWindowsNative = argv.includes("--allow-windows-native-execution");
                 const runtimeArgument = optionalFlag(argv, "--container-runtime");
-                const containerRequest = isRecord(request) &&
-                    isRecord(request.isolation) &&
-                    request.isolation.kind === "container";
-                if (containerRequest ? allowUnsafeExecution : runtimeArgument !== undefined) {
+                const isolationKind = isRecord(request) && isRecord(request.isolation) ? request.isolation.kind : undefined;
+                const containerRequest = isolationKind === "container";
+                const windowsNativeRequest = isolationKind === "windows-native";
+                // Each backend has exactly one authorization; another backend's flag never stands in.
+                if ((containerRequest && (allowUnsafeExecution || allowWindowsNative)) ||
+                    (windowsNativeRequest && (allowUnsafeExecution || runtimeArgument !== undefined)) ||
+                    (!containerRequest &&
+                        !windowsNativeRequest &&
+                        (allowWindowsNative || runtimeArgument !== undefined))) {
                     throw new TypeError("ISOLATION_MODE_CONFLICT");
                 }
-                if (!containerRequest && !allowUnsafeExecution) {
+                if (windowsNativeRequest && !allowWindowsNative) {
+                    io.writeStderr("Refusing WINDOWS_NATIVE_UNSANDBOXED execution without --allow-windows-native-execution.\n");
+                    return 4;
+                }
+                if (!containerRequest && !windowsNativeRequest && !allowUnsafeExecution) {
                     io.writeStderr("Refusing trusted-local execution without --allow-unsafe-execution.\n");
                     return 4;
                 }
                 const version2 = isRecord(request) && request.schemaVersion === "2.0.0";
                 const version3 = isRecord(request) && request.schemaVersion === "3.0.0";
+                const version4 = isRecord(request) && request.schemaVersion === "4.0.0";
                 const runtimeOptions = runtimeArgument === undefined
                     ? {}
                     : { containerRuntime: { command: parseContainerRuntimeCommand(runtimeArgument) } };
+                if (version4) {
+                    const authorized = containerRequest
+                        ? request
+                        : windowsNativeRequest
+                            ? authorizeWindowsNativeExecution(request)
+                            : authorizeTrustedLocalExecution(request);
+                    const manifest = await ledger.verifyV4(authorized, runtimeOptions);
+                    writeJson(io, manifest);
+                    return decisionExitCode(manifest);
+                }
                 const result = version3
                     ? await ledger.verifyV3(containerRequest ? request : authorizeTrustedLocalExecution(request), runtimeOptions)
                     : containerRequest || version2
@@ -1102,6 +1253,65 @@ export async function runCli(argv, io, dependencies = {}) {
                 writeJson(io, result);
                 return decisionExitCode(result);
             }
+            case "qualification-plan": {
+                if (argv.slice(1).filter((item) => item !== "--json").length > 1 ||
+                    argv.slice(1).some((item) => item.startsWith("--") && item !== "--json")) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
+                writeJson(io, ledger.sealQualificationPlan(await readJsonInput(positional[1], io)));
+                return 0;
+            }
+            case "qualify": {
+                if (argv
+                    .slice(1)
+                    .some((item) => item.startsWith("--") && item !== "--allow-unsafe-execution" && item !== "--json") ||
+                    positional.length > 2) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
+                if (!argv.includes("--allow-unsafe-execution")) {
+                    io.writeStderr("Refusing UNSANDBOXED qualification without --allow-unsafe-execution.\n");
+                    return 4;
+                }
+                const result = await ledger.qualifyOrchestration(await readJsonInput(positional[1], io), {
+                    allowUnsafeExecution: true,
+                });
+                writeJson(io, result);
+                return result.decision === "QUALIFIED" ? 0 : result.decision === "OPEN" ? 3 : 2;
+            }
+            case "qualification-replay": {
+                const domainPath = optionalFlag(argv, "--domain");
+                const args = positionalArguments(argv, new Set(["--domain"]));
+                if (args.length > 2 ||
+                    argv
+                        .slice(1)
+                        .some((item) => item.startsWith("--") && item !== "--domain" && item !== "--json")) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
+                const domain = domainPath === undefined
+                    ? undefined
+                    : QualificationExpectedDomainSchema.parse(await readJsonInput(domainPath, io));
+                const result = ledger.replayQualification(await readJsonInput(args[1], io), domain);
+                writeJson(io, result);
+                return result.valid ? 0 : 4;
+            }
+            case "qualification-ci": {
+                const observationPath = optionalFlag(argv, "--observation");
+                const args = positionalArguments(argv, new Set(["--observation"]));
+                if (observationPath === undefined ||
+                    args.length > 2 ||
+                    argv
+                        .slice(1)
+                        .some((item) => item.startsWith("--") && item !== "--observation" && item !== "--json")) {
+                    io.writeStderr(USAGE);
+                    return 64;
+                }
+                const result = ledger.admitQualificationCi(await readJsonInput(args[1], io), await readJsonInput(observationPath, io));
+                writeJson(io, result);
+                return result.decision === "QUALIFIED" ? 0 : result.decision === "OPEN" ? 3 : 2;
+            }
             case "replay": {
                 const result = ledger.replay(await readJsonInput(positional[1], io));
                 writeJson(io, result);