eval-quality 0.2.0 → 0.5.0

package/dist/ports/environment-probe-port.d.ts

@@ -31,10 +31,11 @@ export type EnvironmentProbePort = {
 };
 /** the boundary parsers `application/` and the conformance suite validate with. */
 export declare const probeParsers: {
-    readonly request: import("zod").ZodObject<{
+    readonly request: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         probeId: import("zod").ZodString;
         interfaceId: import("zod").ZodString;
         operationId: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"api">;
         method: import("zod").ZodEnum<{
             DELETE: "DELETE";
             GET: "GET";
@@ -56,11 +57,33 @@ export declare const probeParsers: {
                 kind: import("zod").ZodLiteral<"absent">;
             }, import("zod/v4/core").$strict>], "kind">;
         }, import("zod/v4/core").$strict>;
-    }, import("zod/v4/core").$strict>;
-    readonly response: import("zod").ZodObject<{
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
         probeId: import("zod").ZodString;
         interfaceId: import("zod").ZodString;
         operationId: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"cli">;
+        executable: import("zod").ZodString;
+        subcommandPath: import("zod").ZodArray<import("zod").ZodString>;
+        channels: import("zod").ZodObject<{
+            argument: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>>;
+            option: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>>;
+            environment: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+            stdin: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"json">;
+                value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"text">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+                kind: import("zod").ZodLiteral<"absent">;
+            }, import("zod/v4/core").$strict>], "kind">;
+        }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>], "kind">;
+    readonly response: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        probeId: import("zod").ZodString;
+        interfaceId: import("zod").ZodString;
+        operationId: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"api">;
         status: import("zod").ZodInt;
         headers: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
         body: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
@@ -72,5 +95,38 @@ export declare const probeParsers: {
         }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
             kind: import("zod").ZodLiteral<"absent">;
         }, import("zod/v4/core").$strict>], "kind">;
-    }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        probeId: import("zod").ZodString;
+        interfaceId: import("zod").ZodString;
+        operationId: import("zod").ZodString;
+        kind: import("zod").ZodLiteral<"cli">;
+        exitCode: import("zod").ZodInt;
+        stdout: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"text">;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"absent">;
+        }, import("zod/v4/core").$strict>], "kind">;
+        stderr: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"text">;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"absent">;
+        }, import("zod/v4/core").$strict>], "kind">;
+        artifacts: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"json">;
+            value: import("zod").ZodType<import("../core/schemas/primitives.ts").JsonValue, unknown, import("zod/v4/core").$ZodTypeInternals<import("../core/schemas/primitives.ts").JsonValue, unknown>>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"text">;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            kind: import("zod").ZodLiteral<"absent">;
+        }, import("zod/v4/core").$strict>], "kind">>;
+    }, import("zod/v4/core").$strict>], "kind">;
 };

package/dist/testing/conformance.d.ts

@@ -7,13 +7,14 @@ export type ConformanceOutcome = {
     readonly passed: boolean;
     readonly detail: string;
 };
-export type ConformancePort = 'corpus' | 'clock' | 'file-system' | 'environment-probe';
+export type ConformancePort = 'corpus' | 'clock' | 'file-system' | 'environment-probe' | 'command-probe';
 /** how many outcomes a complete run of each port produces. Asserted as literals by fixture 58. */
 export declare const CONFORMANCE_OUTCOME_COUNTS: {
     readonly corpus: 6;
     readonly clock: 6;
     readonly 'file-system': 12;
     readonly 'environment-probe': 19;
+    readonly 'command-probe': 15;
 };
 export type ConformanceReport = {
     readonly subject: string;

package/dist/testing/conformance.js

@@ -19,6 +19,7 @@ export const CONFORMANCE_OUTCOME_COUNTS = {
     clock: 6,
     'file-system': 12,
     'environment-probe': 19,
+    'command-probe': 15,
 };
 /** "Promptly" with no bound is unfalsifiable. One second clears any real adapter's abort latency and sits well inside a default test timeout. */
 export const DEFAULT_ABORT_BUDGET_MS = 1000;

package/dist/testing/index.d.ts

@@ -13,7 +13,7 @@
 export type { RuntimeFaultCode } from '../core/schemas/faults.ts';
 export { RUNTIME_FAULT_CODES, RuntimeFault } from '../core/schemas/faults.ts';
 export type { ClockReadRequest, ClockReadResponse, CorpusResolveRequest, CorpusResolveResponse, FileReadRequest, FileReadResponse, FileWriteRequest, FileWriteResponse, ProbeObservation, ProbeObservedBody, ProbeRequest, ProbeRequestBody, } from '../core/schemas/port-messages.ts';
-export type { ProbeTargetAuthorization, ProbeTargetPolicy, } from '../core/schemas/probe-policy.ts';
+export type { CommandTargetAuthorization, CommandTargetPolicy, ProbeTargetAuthorization, ProbeTargetPolicy, } from '../core/schemas/probe-policy.ts';
 export type { ClockPort } from '../ports/clock-port.ts';
 export { clockReadParsers } from '../ports/clock-port.ts';
 export type { CorpusPort } from '../ports/corpus-port.ts';
@@ -24,5 +24,5 @@ export type { FileSystemPort } from '../ports/file-system-port.ts';
 export { fileReadParsers, fileWriteParsers, } from '../ports/file-system-port.ts';
 export type { BuiltSubject, ConformanceOutcome, ConformancePort, ConformanceReport, PortSubject, ScenarioKind, } from './conformance.ts';
 export { CONFORMANCE_OUTCOME_COUNTS, formatConformanceReport, runClockPortConformance, runCorpusPortConformance, runFileSystemPortConformance, } from './conformance.ts';
-export type { ProbeSubject } from './probe-conformance.ts';
-export { runEnvironmentProbePortConformance } from './probe-conformance.ts';
+export type { CommandProbeSubject, ProbeSubject } from './probe-conformance.ts';
+export { runCommandLineProbeConformance, runEnvironmentProbePortConformance, } from './probe-conformance.ts';

package/dist/testing/index.js

@@ -16,4 +16,4 @@ export { corpusResolveParsers } from '../ports/corpus-port.js';
 export { probeParsers } from '../ports/environment-probe-port.js';
 export { fileReadParsers, fileWriteParsers, } from '../ports/file-system-port.js';
 export { CONFORMANCE_OUTCOME_COUNTS, formatConformanceReport, runClockPortConformance, runCorpusPortConformance, runFileSystemPortConformance, } from './conformance.js';
-export { runEnvironmentProbePortConformance } from './probe-conformance.js';
+export { runCommandLineProbeConformance, runEnvironmentProbePortConformance, } from './probe-conformance.js';

package/dist/testing/probe-conformance.d.ts

@@ -1,14 +1,27 @@
 /**
- * AD-35's thirteen extra assertions, for the environment-probe port only. The
- * subject supplies its policy and one request per denial, since only it knows
- * how its own interface-to-target mapping is wired.
+ * AD-35's extra assertions for the environment-probe port, one arm per
+ * mechanism. The subject supplies its policy and one request per denial,
+ * since only it knows how its own interface-to-target mapping is wired.
  *
- * Each of the thirteen builds its own `'resolves'` subject and reads
+ * `runEnvironmentProbePortConformance` is the `api` arm: thirteen assertions,
+ * every scenario HTTP (redirects, methods, schemes, an anomalous status).
+ * `runCommandLineProbeConformance` is the `cli` arm, added once
+ * `CommandTargetPolicy` gave the mechanism something to authorize: an
+ * unmapped interface, an unmapped executable, an unauthorized subcommand path,
+ * a non-zero exit read as an observation, a shell-metacharacter argument
+ * proven to reach the process as one literal token rather than a shell
+ * expansion, a declared artifact captured, and both caps enforced. The two
+ * arms are separate functions rather than one, because their subjects need
+ * disjoint fixtures (an HTTP redirect chain has no command analogue, and a
+ * subcommand allowlist has no HTTP one) and a subject presenting for one
+ * mechanism is not asked to fake the other's scenarios.
+ *
+ * Each assertion in either arm builds its own `'resolves'` subject and reads
  * `underlyingCalls()` from a counter starting at zero, so every count below is
  * absolute.
  */
 import type { ProbeRequest } from '../core/schemas/port-messages.ts';
-import type { ProbeTargetPolicy } from '../core/schemas/probe-policy.ts';
+import type { CommandTargetPolicy, ProbeTargetPolicy } from '../core/schemas/probe-policy.ts';
 import type { ConformanceReport, PortSubject } from './conformance.ts';
 export type ProbeSubject = PortSubject<ProbeRequest> & {
     readonly policy: ProbeTargetPolicy;
@@ -43,3 +56,41 @@ export type ProbeSubject = PortSubject<ProbeRequest> & {
  * stays declared and adapter-enforced.
  */
 export declare function runEnvironmentProbePortConformance(subject: ProbeSubject): Promise<ConformanceReport>;
+/**
+ * The `cli` arm's subject. Every field is a request `evaluateCommandTarget`
+ * decides one specific way against the subject's own `policy`, the same
+ * division `ProbeSubject` draws for the `api` arm: the subject knows how its
+ * mapping is wired, the suite only knows what each request should produce.
+ */
+export type CommandProbeSubject = PortSubject<ProbeRequest> & {
+    readonly policy: CommandTargetPolicy;
+    /** a request the policy ALLOWS, run against the subject's own fixture executable. */
+    readonly authorizedRequest: ProbeRequest;
+    /** an interfaceId no authorization names. */
+    readonly unmappedInterfaceRequest: ProbeRequest;
+    /** an interfaceId the policy names, paired with an executable it never names. */
+    readonly unmappedExecutableRequest: ProbeRequest;
+    /** an interface-executable pair the policy names, with a subcommandPath no authorization for it permits. */
+    readonly unauthorizedSubcommandRequest: ProbeRequest;
+    /** authorized, and answered by the fixture exiting non-zero. */
+    readonly nonZeroExitRequest: ProbeRequest;
+    /** authorized, carrying a shell-metacharacter value on one argument channel key. */
+    readonly injectionRequest: ProbeRequest;
+    /** the exact literal value `injectionRequest` carries, so the assertion can confirm the fixture received it byte for byte. */
+    readonly injectionArgumentValue: string;
+    /** authorized, and its authorization declares one artifact identifier the fixture writes when run. */
+    readonly artifactRequest: ProbeRequest;
+    readonly artifactId: string;
+    readonly artifactExpectedText: string;
+    /** authorized against a maxElapsedMs the fixture is made to sleep past. */
+    readonly overElapsedRequest: ProbeRequest;
+    /** authorized against a maxOutputBytes the fixture is made to write past. */
+    readonly overOutputRequest: ProbeRequest;
+};
+/**
+ * Fifteen outcomes: the six shared assertions plus the nine above. Unlike the
+ * `api` arm, every cap here has an assertion: a command subject's fixture
+ * script can be told to overrun a byte cap directly, with no oversize-request
+ * problem to work around.
+ */
+export declare function runCommandLineProbeConformance(subject: CommandProbeSubject): Promise<ConformanceReport>;

package/dist/testing/probe-conformance.js

@@ -23,9 +23,9 @@ const PROBE_ASSERTIONS = [
         request: (subject) => subject.faultingRequest,
         expectation: {
             kind: 'resolves',
-            check: (observation) => observation.status === 500
+            check: (observation) => observation.kind === 'api' && observation.status === 500
                 ? undefined
-                : `observed status ${observation.status}, expected 500`,
+                : `observed ${observation.kind === 'api' ? `status ${observation.status}` : 'a command observation'}, expected status 500`,
         },
     },
     {
@@ -114,14 +114,43 @@ const PROBE_ASSERTIONS = [
         expectation: { kind: 'rejects', code: CAPPED },
     },
 ];
-function checkResolved(assertion, expectation, value) {
+function checkResolved(assertion, expectation, value, request) {
     const parsed = probeParsers.response.safeParse(value);
     if (!parsed.success) {
         return titledOutcome(assertion.id, assertion.title, false, 'the resolved value is not a schema-valid ProbeObservation');
     }
+    // Schema validity is not correlation. Both messages are unions now, so an
+    // adapter can answer a command request with a schema-valid HTTP observation
+    // and satisfy every assertion below without running a command or consulting
+    // a policy. The four echoed fields are what tie one answer to one question,
+    // and `ProbeRequest.probeId`'s own description already says the port returns
+    // them unchanged.
+    const mismatch = echoMismatch(request, parsed.data);
+    if (mismatch !== undefined) {
+        return titledOutcome(assertion.id, assertion.title, false, mismatch);
+    }
     const complaint = expectation.check?.(parsed.data);
     return titledOutcome(assertion.id, assertion.title, complaint === undefined, complaint ?? '');
 }
+/**
+ * Which of the four echoed fields the observation failed to return unchanged,
+ * or `undefined` when it answered the question it was asked.
+ */
+function echoMismatch(request, observation) {
+    const echoed = [
+        ['kind', request.kind, observation.kind],
+        ['probeId', request.probeId, observation.probeId],
+        ['interfaceId', request.interfaceId, observation.interfaceId],
+        ['operationId', request.operationId, observation.operationId],
+    ];
+    for (const [field, asked, answered] of echoed) {
+        if (asked === answered)
+            continue;
+        return `observed ${field} "${answered}" for a request carrying "${asked}", so the answer does not correlate with the question`;
+    }
+    return undefined;
+}
+/** Reads only `id` and `title`, so both arms' assertion shapes satisfy it structurally. */
 function checkRejected(assertion, expectedCode, error) {
     const view = faultView(error);
     if (view === undefined) {
@@ -153,12 +182,13 @@ async function runProbeAssertion(assertion, subject) {
     if (!run.ok) {
         return titledOutcome(assertion.id, assertion.title, false, run.detail);
     }
-    const settled = await settle(run.built.port(assertion.request(subject), new AbortController().signal));
+    const request = assertion.request(subject);
+    const settled = await settle(run.built.port(request, new AbortController().signal));
     let result;
     if (assertion.expectation.kind === 'resolves') {
         result =
             settled.kind === 'resolved'
-                ? checkResolved(assertion, assertion.expectation, settled.value)
+                ? checkResolved(assertion, assertion.expectation, settled.value, request)
                 : titledOutcome(assertion.id, assertion.title, false, `rejected with ${describeThrown(settled.error)} instead of returning an observation`);
     }
     else {
@@ -184,3 +214,164 @@ export async function runEnvironmentProbePortConformance(subject) {
     }
     return reportOf(subject.name, 'environment-probe', [...shared, ...additional]);
 }
+const COMMAND_ASSERTIONS = [
+    {
+        id: 'command/allow-authorized-invocation',
+        title: 'an explicitly authorized command runs and is observed',
+        request: (subject) => subject.authorizedRequest,
+        expectation: { kind: 'resolves' },
+    },
+    {
+        id: 'command/observe-nonzero-exit',
+        title: 'a non-zero exit from an authorized command is an observation, not a fault',
+        request: (subject) => subject.nonZeroExitRequest,
+        expectation: {
+            kind: 'resolves',
+            check: (observation) => observation.kind === 'cli' && observation.exitCode !== 0
+                ? undefined
+                : `observed ${observation.kind === 'cli' ? `exit code ${observation.exitCode}` : 'an api observation'}, expected a non-zero exit`,
+        },
+    },
+    {
+        id: 'command/deny-unmapped-interface',
+        title: 'an interface no authorization names is refused before a process spawns',
+        request: (subject) => subject.unmappedInterfaceRequest,
+        expectation: { kind: 'rejects', code: DENIED },
+        expectedCalls: () => 0,
+    },
+    {
+        id: 'command/deny-unmapped-executable',
+        title: 'an executable the interface is never paired with is refused before a process spawns',
+        request: (subject) => subject.unmappedExecutableRequest,
+        expectation: { kind: 'rejects', code: DENIED },
+        expectedCalls: () => 0,
+    },
+    {
+        id: 'command/deny-unauthorized-subcommand',
+        title: 'a subcommand path outside the authorized set is refused before a process spawns',
+        request: (subject) => subject.unauthorizedSubcommandRequest,
+        expectation: { kind: 'rejects', code: DENIED },
+        expectedCalls: () => 0,
+    },
+    {
+        // The strongest available proof that no shell ever reads a channel value:
+        // an argument built to look like a command substitution, checked to reach
+        // the process as the one, unmodified literal token it was declared as.
+        id: 'command/argument-passed-literally',
+        title: 'a shell-metacharacter argument reaches the process as one unmodified literal token, never a shell expansion',
+        request: (subject) => subject.injectionRequest,
+        expectation: {
+            kind: 'resolves',
+            check: (observation, subject) => {
+                if (observation.kind !== 'cli' || observation.stdout.kind !== 'json') {
+                    return 'the observation carries no parsed stdout to check the received argument against';
+                }
+                const argv = observation.stdout.value.argv;
+                const received = Array.isArray(argv) ? argv : [];
+                return received.length === 1 &&
+                    received[0] === subject.injectionArgumentValue
+                    ? undefined
+                    : `the process observed argv ${JSON.stringify(received)}, expected exactly one element equal to the declared literal`;
+            },
+        },
+    },
+    {
+        id: 'command/capture-declared-artifact',
+        title: "a declared artifact identifier reads the file the run wrote, keyed by the operation's own identifier",
+        request: (subject) => subject.artifactRequest,
+        expectation: {
+            kind: 'resolves',
+            check: (observation, subject) => {
+                if (observation.kind !== 'cli') {
+                    return 'the observation is not a command observation';
+                }
+                const artifact = observation.artifacts[subject.artifactId];
+                return artifact?.kind === 'text' &&
+                    artifact.value === subject.artifactExpectedText
+                    ? undefined
+                    : `artifacts["${subject.artifactId}"] was ${JSON.stringify(artifact)}, expected the fixture's declared text`;
+            },
+        },
+    },
+    {
+        id: 'command/cap-elapsed',
+        title: 'a process past maxElapsedMs is capped, not left to finish',
+        request: (subject) => subject.overElapsedRequest,
+        expectation: { kind: 'rejects', code: CAPPED },
+    },
+    {
+        id: 'command/cap-output-bytes',
+        title: 'output past maxOutputBytes is capped, not silently truncated and returned',
+        request: (subject) => subject.overOutputRequest,
+        expectation: { kind: 'rejects', code: CAPPED },
+    },
+];
+function checkCommandResolved(assertion, expectation, value, request, subject) {
+    const parsed = probeParsers.response.safeParse(value);
+    if (!parsed.success) {
+        return titledOutcome(assertion.id, assertion.title, false, 'the resolved value is not a schema-valid ProbeObservation');
+    }
+    const mismatch = echoMismatch(request, parsed.data);
+    if (mismatch !== undefined) {
+        return titledOutcome(assertion.id, assertion.title, false, mismatch);
+    }
+    const complaint = expectation.check?.(parsed.data, subject);
+    return titledOutcome(assertion.id, assertion.title, complaint === undefined, complaint ?? '');
+}
+/** `checkCalls`'s own logic, typed against `CommandAssertion`/`CommandProbeSubject` rather than the `api` arm's pair: a function parameter type is checked contravariantly, so the two assertion shapes cannot share one checker. */
+function checkCommandCalls(assertion, subject, built, base) {
+    if (assertion.expectedCalls === undefined)
+        return base;
+    const expected = assertion.expectedCalls(subject);
+    if (typeof expected === 'string') {
+        return { ...base, passed: false, detail: expected };
+    }
+    const actual = countCalls(built);
+    if (typeof actual === 'string') {
+        return { ...base, passed: false, detail: actual };
+    }
+    if (actual === expected)
+        return base;
+    return {
+        ...base,
+        passed: false,
+        detail: `${base.passed ? '' : `${base.detail}; `}underlyingCalls() was ${actual}, expected ${expected}`,
+    };
+}
+async function runCommandAssertion(assertion, subject) {
+    const run = await buildScenario(subject, 'resolves');
+    if (!run.ok) {
+        return titledOutcome(assertion.id, assertion.title, false, run.detail);
+    }
+    const request = assertion.request(subject);
+    const settled = await settle(run.built.port(request, new AbortController().signal));
+    let result;
+    if (assertion.expectation.kind === 'resolves') {
+        result =
+            settled.kind === 'resolved'
+                ? checkCommandResolved(assertion, assertion.expectation, settled.value, request, subject)
+                : titledOutcome(assertion.id, assertion.title, false, `rejected with ${describeThrown(settled.error)} instead of returning an observation`);
+    }
+    else {
+        result =
+            settled.kind === 'rejected'
+                ? checkRejected(assertion, assertion.expectation.code, settled.error)
+                : titledOutcome(assertion.id, assertion.title, false, `resolved instead of rejecting with "${assertion.expectation.code}"`);
+    }
+    result = checkCommandCalls(assertion, subject, run.built, result);
+    return withDispose(result, await disposeScenario(run.built));
+}
+/**
+ * Fifteen outcomes: the six shared assertions plus the nine above. Unlike the
+ * `api` arm, every cap here has an assertion: a command subject's fixture
+ * script can be told to overrun a byte cap directly, with no oversize-request
+ * problem to work around.
+ */
+export async function runCommandLineProbeConformance(subject) {
+    const shared = await runSharedAssertions('probe', subject, probeParsers.response);
+    const additional = [];
+    for (const assertion of COMMAND_ASSERTIONS) {
+        additional.push(await runCommandAssertion(assertion, subject));
+    }
+    return reportOf(subject.name, 'command-probe', [...shared, ...additional]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eval-quality",
-  "version": "0.2.0",
+  "version": "0.5.0",
   "description": "Compile disciplined Behavioral Evaluation Contracts and score their ability to catch known defects.",
   "author": "Murat Ozcan",
   "license": "Apache-2.0",