project-tiny-context-harness 0.7.3 → 0.7.5

package/dist/lib/long-task-evidence-capability-policy.js

@@ -0,0 +1,147 @@
+import { validateRuntimeEvidenceRecord } from "./long-task-evidence-capability-runtime.js";
+import { checkFinding } from "./long-task-evidence-findings.js";
+export { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-codec.js";
+export function validateEvidenceCapabilityDeclarations(contract, report) {
+    const targets = new Map(contract.task.execution_targets.map((target) => [target.key, target]));
+    for (const [outcomeKey, check] of allChecks(contract)) {
+        unique(check.journey_roles, "journey_role_duplicate", checkLabel(outcomeKey, check.key), report);
+        if (!check.journey_roles.length)
+            issue(report, "journey_role_required", checkLabel(outcomeKey, check.key));
+        validateScenario(check, outcomeKey, report);
+        for (const assertion of [
+            ...check.positive_assertions,
+            ...check.negative_assertions,
+        ]) {
+            const label = `${checkLabel(outcomeKey, check.key)}:${assertion.key}`;
+            unique(assertion.evidence_capabilities, "evidence_capability_duplicate", label, report);
+            if (!assertion.evidence_capabilities.length)
+                issue(report, "evidence_capability_required", label);
+            if (assertion.claims.length &&
+                check.proof_surface !== "implementation_structure" &&
+                assertion.evidence_capabilities.every((capability) => capability === "presence"))
+                issue(report, "presence_cannot_prove_behavior", label);
+            if (assertion.operator === "exists" &&
+                !assertion.evidence_capabilities.includes("presence"))
+                issue(report, "exists_requires_presence_capability", label);
+            if (assertion.evidence_capabilities.includes("visual_render") &&
+                !check.artifact_globs.length)
+                issue(report, "visual_render_artifact_required", label);
+            if (assertion.evidence_capabilities.includes("interaction_trace") &&
+                !check.scenario.when.length)
+                issue(report, "interaction_trace_actions_required", label);
+            if (check.runner.type === "playwright_test" &&
+                assertion.evidence_capabilities.some((capability) => capability !== "presence" &&
+                    capability !== "interaction_trace" &&
+                    capability !== "target_runtime"))
+                issue(report, "playwright_evidence_capability_unsupported", label);
+            if (["boundary_invocation", "external_side_effect"].some((capability) => assertion.evidence_capabilities.includes(capability)) &&
+                targets.get(check.execution_target.target_ref)?.role !== "observer")
+                issue(report, "observer_check_target_required", label);
+        }
+    }
+    validateJourneySeparation(contract, report);
+}
+function validateScenario(check, outcomeKey, report) {
+    const label = checkLabel(outcomeKey, check.key);
+    if (!check.scenario.given.length)
+        issue(report, "scenario_given_required", label);
+    if (!check.scenario.when.length)
+        issue(report, "scenario_when_required", label);
+    unique(check.scenario.given.map((step) => step.key), "scenario_given_key_duplicate", label, report);
+    unique(check.scenario.when.map((step) => step.key), "scenario_when_key_duplicate", label, report);
+}
+function validateJourneySeparation(contract, report) {
+    for (const outcome of contract.outcomes) {
+        for (const check of outcome.acceptance.checks)
+            if (check.journey_roles.includes("success") &&
+                check.journey_roles.includes("degradation"))
+                issue(report, "success_degradation_check_must_be_distinct", `${outcome.key}:${check.key}`);
+        if (outcome.product.success_path_required &&
+            !outcome.acceptance.checks.some((check) => check.journey_roles.includes("success")))
+            issue(report, "success_path_check_required", outcome.key);
+        if (outcome.product.degradation_path_required &&
+            !outcome.acceptance.checks.some((check) => check.journey_roles.includes("degradation")))
+            issue(report, "degradation_path_check_required", outcome.key);
+        for (const check of outcome.acceptance.checks) {
+            const provesResult = [
+                ...check.positive_assertions,
+                ...check.negative_assertions,
+            ].some((assertion) => assertion.claims.includes("result"));
+            if (provesResult && !check.journey_roles.includes("success"))
+                issue(report, "result_claim_requires_success_journey", `${outcome.key}:${check.key}`);
+        }
+    }
+}
+export function evaluateEvidenceCapabilities(check, records, artifactHashes) {
+    const runtimeRecords = records ?? [];
+    const complete = {};
+    const findings = [];
+    const assertions = [
+        ...check.positive_assertions,
+        ...check.negative_assertions,
+    ];
+    const assertionsByKey = new Map(assertions.map((assertion) => [assertion.key, assertion]));
+    for (const record of runtimeRecords) {
+        const assertion = assertionsByKey.get(record.assertion_key);
+        const reason = !assertion
+            ? "assertion_unknown"
+            : !assertion.evidence_capabilities.includes(record.capability)
+                ? "capability_undeclared"
+                : null;
+        if (!reason)
+            continue;
+        findings.push({
+            ...checkFinding(check, "evidence_capability_invalid", `Evidence record ${record.assertion_key}:${record.capability} is not bound to a declared Assertion capability: ${reason}.`, "Emit records only for capabilities declared by Assertions in this Check."),
+            assertion_key: record.assertion_key,
+            claim_keys: assertion?.claims ?? [],
+            expected: "declared_assertion_capability",
+            actual: reason,
+        });
+    }
+    for (const assertion of assertions) {
+        let assertionComplete = true;
+        for (const capability of assertion.evidence_capabilities) {
+            if (capability === "presence")
+                continue;
+            const matches = runtimeRecords.filter((record) => record.assertion_key === assertion.key &&
+                record.capability === capability);
+            const reason = matches.length === 1
+                ? validateRuntimeEvidenceRecord(check, matches[0], artifactHashes)
+                : matches.length === 0
+                    ? "record_missing"
+                    : "record_duplicate";
+            if (!reason)
+                continue;
+            assertionComplete = false;
+            findings.push({
+                ...checkFinding(check, "evidence_capability_invalid", `Assertion ${assertion.key} did not provide valid ${capability} evidence: ${reason}.`, "Make the current Check execution emit one valid typed evidence record for the declared capability."),
+                assertion_key: assertion.key,
+                claim_keys: assertion.claims,
+                expected: capability,
+                actual: reason,
+            });
+        }
+        complete[assertion.key] = assertionComplete;
+    }
+    return { complete, findings };
+}
+function allChecks(contract) {
+    return [
+        ...contract.global.acceptance.checks.map((check) => [null, check]),
+        ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [outcome.key, check])),
+    ];
+}
+function checkLabel(outcomeKey, checkKey) {
+    return `${outcomeKey ?? "GLOBAL"}:${checkKey}`;
+}
+function unique(values, code, detail, report) {
+    if (new Set(values).size !== values.length)
+        issue(report, code, detail);
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}

package/dist/lib/long-task-evidence-capability-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
+export declare function validateRuntimeEvidenceRecord(check: CompiledCheckV2, record: EvidenceCapabilityRecordV2, artifactHashes: Record<string, string>): string | null;

package/dist/lib/long-task-evidence-capability-runtime.js

@@ -0,0 +1,86 @@
+export function validateRuntimeEvidenceRecord(check, record, artifactHashes) {
+    switch (record.capability) {
+        case "interaction_trace":
+            return validateInteractionTrace(check, record);
+        case "state_delta":
+            if (record.before_sha256 === record.after_sha256)
+                return "state_unchanged";
+            if (!record.changed_fields.length)
+                return "changed_fields_empty";
+            return null;
+        case "cross_surface_consistency":
+            return validateCrossSurfaceConsistency(check, record);
+        case "durable_readback":
+            if (record.write_session_id === record.read_session_id)
+                return "independent_session_required";
+            if (record.written_sha256 !== record.read_sha256)
+                return "readback_mismatch";
+            return null;
+        case "boundary_invocation":
+        case "external_side_effect":
+            return validateObserverEvidence(check, record.observer_target_ref);
+        case "failure_injection":
+            return record.failure_observed ? null : "failure_not_observed";
+        case "visual_render":
+            return artifactHashes[record.artifact_path] === record.artifact_sha256
+                ? null
+                : "artifact_hash_mismatch";
+        case "target_runtime":
+            return validateTargetRuntime(check, record);
+        case "input_variation":
+            return validateInputVariation(record);
+    }
+}
+function validateInteractionTrace(check, record) {
+    if (record.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    if (!same(record.given_keys, check.scenario.given.map((step) => step.key)))
+        return "given_trace_mismatch";
+    if (!same(record.action_keys, check.scenario.when.map((step) => step.key)))
+        return "action_trace_mismatch";
+    return null;
+}
+function validateCrossSurfaceConsistency(check, record) {
+    const surfaces = new Set(record.surfaces.map((surface) => surface.surface_ref));
+    const targets = new Set(record.surfaces.map((surface) => surface.target_ref));
+    const states = new Set(record.surfaces.map((surface) => surface.state_sha256));
+    if (surfaces.size < 2)
+        return "two_surfaces_required";
+    if (states.size !== 1)
+        return "state_hash_mismatch";
+    if ([...targets].some((target) => !check.known_execution_targets.some((item) => item.key === target)))
+        return "target_unknown";
+    return null;
+}
+function validateObserverEvidence(check, observerTargetRef) {
+    const observer = check.known_execution_targets.find((target) => target.key === observerTargetRef);
+    if (!observer || observer.role !== "observer")
+        return "observer_target_invalid";
+    if (observer.key !== check.execution_target.target_ref)
+        return "check_must_execute_on_observer";
+    return null;
+}
+function validateTargetRuntime(check, record) {
+    if (record.target_ref !== check.execution_target.target_ref)
+        return "target_mismatch";
+    if (record.root_entrypoint !== check.execution_target_definition.root_entrypoint)
+        return "root_entrypoint_mismatch";
+    if (check.execution_target.entrypoint === "root" && !record.cold_start)
+        return "cold_start_required";
+    return null;
+}
+function validateInputVariation(record) {
+    const inputs = new Set(record.cases.map((item) => item.input_sha256));
+    const outputs = new Set(record.cases.map((item) => item.output_sha256));
+    if (inputs.size < 2)
+        return "distinct_inputs_required";
+    if (outputs.size < 2)
+        return "input_must_reach_output";
+    if (!record.failure_case_observed)
+        return "failure_case_required";
+    return null;
+}
+function same(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}

package/dist/lib/long-task-evidence-capability-types.d.ts

@@ -0,0 +1,74 @@
+import type { EvidenceCapabilityV2 } from "./long-task-semantic-contract-types.js";
+interface EvidenceRecordBaseV2 {
+    assertion_key: string;
+    capability: EvidenceCapabilityV2;
+}
+export interface InteractionTraceEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "interaction_trace";
+    target_ref: string;
+    given_keys: string[];
+    action_keys: string[];
+}
+export interface StateDeltaEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "state_delta";
+    before_sha256: string;
+    after_sha256: string;
+    changed_fields: string[];
+}
+export interface CrossSurfaceConsistencyEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "cross_surface_consistency";
+    surfaces: Array<{
+        surface_ref: string;
+        target_ref: string;
+        state_sha256: string;
+    }>;
+}
+export interface DurableReadbackEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "durable_readback";
+    write_session_id: string;
+    read_session_id: string;
+    written_sha256: string;
+    read_sha256: string;
+}
+export interface BoundaryInvocationEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "boundary_invocation";
+    boundary: string;
+    invocation_id: string;
+    request_sha256: string;
+    observer_target_ref: string;
+}
+export interface ExternalSideEffectEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "external_side_effect";
+    boundary: string;
+    effect_id: string;
+    effect_sha256: string;
+    observer_target_ref: string;
+}
+export interface FailureInjectionEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "failure_injection";
+    fault: string;
+    failure_observed: true;
+    recovery_state_sha256: string;
+}
+export interface VisualRenderEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "visual_render";
+    artifact_path: string;
+    artifact_sha256: string;
+}
+export interface TargetRuntimeEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "target_runtime";
+    target_ref: string;
+    root_entrypoint: string;
+    session_id: string;
+    cold_start: boolean;
+}
+export interface InputVariationEvidenceV2 extends EvidenceRecordBaseV2 {
+    capability: "input_variation";
+    cases: Array<{
+        input_sha256: string;
+        output_sha256: string;
+    }>;
+    failure_case_observed: boolean;
+}
+export type EvidenceCapabilityRecordV2 = InteractionTraceEvidenceV2 | StateDeltaEvidenceV2 | CrossSurfaceConsistencyEvidenceV2 | DurableReadbackEvidenceV2 | BoundaryInvocationEvidenceV2 | ExternalSideEffectEvidenceV2 | FailureInjectionEvidenceV2 | VisualRenderEvidenceV2 | TargetRuntimeEvidenceV2 | InputVariationEvidenceV2;
+export {};

package/dist/lib/long-task-evidence-capability-types.js

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

package/dist/lib/long-task-evidence-findings.js

@@ -19,6 +19,8 @@ export function evaluateAssertionResults(check, observations) {
             passed: evaluation.passed,
             claims: assertion.claims,
             observation: assertion.observation,
+            evidence_capabilities: assertion.evidence_capabilities,
+            evidence_complete: false,
             status: evaluation.status,
             ...(Object.hasOwn(evaluation, "expected")
                 ? { expected: evaluation.expected }
@@ -35,7 +37,9 @@ export function classifyCheckStatus(raw, findings) {
     if (raw.exit_code !== 0 ||
         findings.some((item) => item.code === "test_failed"))
         return "test_failed";
-    if (findings.some((item) => item.code === "invalid_evidence" || item.code === "artifact_missing"))
+    if (findings.some((item) => item.code === "invalid_evidence" ||
+        item.code === "artifact_missing" ||
+        item.code === "evidence_capability_invalid"))
         return "invalid_evidence";
     if (findings.some((item) => item.assertion_key) ||
         findings.some((item) => item.code === "population_coverage_failed"))

package/dist/lib/long-task-evidence-v2.js

@@ -5,28 +5,13 @@ import { executeCheckRunner } from "./long-task-check-runner.js";
 import { createCounterfactualSandbox } from "./long-task-counterfactual-sandbox.js";
 import { assertionFinding, checkFinding, classifyCheckStatus, evaluateAssertionResults, } from "./long-task-evidence-findings.js";
 import { classifyPlaywrightCounterfactual } from "./long-task-playwright-counterfactual-policy.js";
+import { evaluateEvidenceCapabilities } from "./long-task-evidence-capability-policy.js";
 import { resolveInsideRepository } from "./long-task-workspace.js";
 export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
     const artifacts = await collectCheckArtifacts(check, snapshotRoot);
     const assertionResults = evaluateAssertionResults(check, raw.observations);
     const executionCompleted = raw.execution_status === "completed";
-    const findings = [];
-    if (!executionCompleted)
-        findings.push(checkFinding(check, raw.execution_status, raw.error ?? raw.execution_status, raw.execution_status === "blocked_external"
-            ? "Satisfy the declared Environment Requirement and rerun this Check."
-            : "Repair the declared runner or evidence protocol and rerun this Check."));
-    if (executionCompleted && raw.exit_code !== 0)
-        findings.push(checkFinding(check, "test_failed", `command exited ${raw.exit_code}`, "Fix the implementation or declared verification command, then rerun this Check."));
-    if (executionCompleted &&
-        raw.observations["playwright.zero_or_all_skipped"] === true)
-        findings.push(checkFinding(check, "test_failed", "Playwright executed zero tests or skipped every test.", "Make the declared Playwright target execute at least one non-skipped test."));
-    if (executionCompleted) {
-        for (const error of artifacts.errors)
-            findings.push(checkFinding(check, "artifact_missing", error, "Produce the artifact declared for this Check and rerun it."));
-        for (const result of assertionResults)
-            if (!result.passed)
-                findings.push(assertionFinding(check, result, raw.observations, outcome));
-    }
+    const findings = collectExecutionFindings(check, raw, outcome, artifacts, assertionResults);
     const population = outcome?.acceptance.population;
     let populationPassed = true;
     if (executionCompleted && population?.check_key === check.key) {
@@ -42,12 +27,14 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
     }
     const status = classifyCheckStatus(raw, findings);
     const claimProofs = status === "passed"
-        ? assertionResults.flatMap((result) => result.claims.map((claim) => ({
-            check_key: check.key,
-            assertion_key: result.key,
-            polarity: result.polarity,
-            proof_surface: check.proof_surface,
-        })))
+        ? assertionResults.flatMap((result) => result.evidence_complete
+            ? result.claims.map((claim) => ({
+                check_key: check.key,
+                assertion_key: result.key,
+                polarity: result.polarity,
+                proof_surface: check.proof_surface,
+            }))
+            : [])
         : [];
     if (status === "passed" &&
         population &&
@@ -68,6 +55,7 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
         execution_identity: raw.raw_execution_identity,
         assertion_results: assertionResults,
         observations: raw.observations,
+        evidence_records: raw.evidence_records ?? [],
         artifact_hashes: artifacts.hashes,
         claim_proofs: claimProofs,
         findings,
@@ -75,6 +63,33 @@ export async function evaluateCheckEvidence(check, raw, snapshotRoot, outcome) {
         duration_ms: raw.duration_ms,
     };
 }
+function collectExecutionFindings(check, raw, outcome, artifacts, assertionResults) {
+    const findings = [];
+    if (raw.execution_status !== "completed") {
+        findings.push(checkFinding(check, raw.execution_status, raw.error ?? raw.execution_status, raw.execution_status === "blocked_external"
+            ? "Satisfy the declared Environment Requirement and rerun this Check."
+            : "Repair the declared runner or evidence protocol and rerun this Check."));
+        return findings;
+    }
+    if (raw.exit_code !== 0)
+        findings.push(checkFinding(check, "test_failed", `command exited ${raw.exit_code}`, "Fix the implementation or declared verification command, then rerun this Check."));
+    if (raw.observations["playwright.zero_or_all_skipped"] === true)
+        findings.push(checkFinding(check, "test_failed", "Playwright executed zero tests or skipped every test.", "Make the declared Playwright target execute at least one non-skipped test."));
+    for (const error of artifacts.errors)
+        findings.push(checkFinding(check, "artifact_missing", error, "Produce the artifact declared for this Check and rerun it."));
+    for (const result of assertionResults)
+        if (!result.passed)
+            findings.push(assertionFinding(check, result, raw.observations, outcome));
+    const capabilityEvaluation = evaluateEvidenceCapabilities(check, raw.evidence_records, artifacts.hashes);
+    const passedAssertions = new Set(assertionResults
+        .filter((result) => result.passed)
+        .map((result) => result.key));
+    findings.push(...capabilityEvaluation.findings.filter((finding) => !finding.assertion_key || passedAssertions.has(finding.assertion_key)));
+    for (const result of assertionResults)
+        result.evidence_complete =
+            result.passed && capabilityEvaluation.complete[result.key] === true;
+    return findings;
+}
 export async function evaluateOutcomeCounterfactuals(outcome, snapshotRoot, manifest) {
     return evaluateCounterfactualSet(outcome.acceptance.counterfactual_controls.map((control) => ({
         control,

package/dist/lib/long-task-final-v2.js

@@ -74,18 +74,28 @@ export async function runDeliveryFinalGate(workdirInput) {
         const blocked = globalBlocked ||
             Object.values(outcomeResults).includes("blocked_external") ||
             run.findings.some((finding) => finding.code === "blocked_external");
+        const targetBlocked = compiled.global.acceptance.external_confirmations.some((confirmation) => confirmation.blocks_target);
         const workflowStatus = failed
             ? "needs_work"
-            : blocked
+            : blocked || targetBlocked
                 ? "blocked_external"
                 : compiled.global.acceptance.external_confirmations.length
                     ? "machine_accepted_external_pending"
                     : "machine_accepted";
+        const targetState = workflowStatus === "machine_accepted" ||
+            workflowStatus === "machine_accepted_external_pending"
+            ? compiled.task.target_profile.required_state
+            : workflowStatus === "blocked_external"
+                ? "blocked_external"
+                : "not_accepted";
         return writeFinalReceipt(repository, active.workdir, {
             schema_version: "long-task-final-receipt-v2",
             authority_scope: "audit_only",
             reusable_for_acceptance: false,
             workflow_status: workflowStatus,
+            target_profile: compiled.task.target_profile,
+            target_state: targetState,
+            stage_results: projectStages(compiled, outcomeResults),
             compiled_identity: compiled.compiled_identity,
             contract_sha256: compiled.contract_sha256,
             snapshot_sha256: snapshot.manifest.snapshot_sha256,
@@ -107,6 +117,37 @@ export async function runDeliveryFinalGate(workdirInput) {
         await snapshot.dispose();
     }
 }
+function projectStages(compiled, outcomes) {
+    const result = {};
+    const remaining = new Set(compiled.stages.map((stage) => stage.key));
+    while (remaining.size) {
+        let advanced = false;
+        for (const stage of compiled.stages) {
+            if (!remaining.has(stage.key))
+                continue;
+            if (stage.depends_on.some((dependency) => remaining.has(dependency)))
+                continue;
+            const owned = compiled.outcomes
+                .filter((outcome) => outcome.stage === stage.key)
+                .map((outcome) => outcomes[outcome.key]);
+            result[stage.key] = owned.includes("failed")
+                ? "failed"
+                : owned.includes("blocked_external")
+                    ? "blocked_external"
+                    : stage.depends_on.some((dependency) => result[dependency] !== "passed")
+                        ? "blocked_dependency"
+                        : "passed";
+            remaining.delete(stage.key);
+            advanced = true;
+        }
+        if (!advanced) {
+            for (const stage of remaining)
+                result[stage] = "blocked_dependency";
+            break;
+        }
+    }
+    return result;
+}
 function projectOutcomes(outcomeKeys, checks, findings) {
     return Object.fromEntries(outcomeKeys.map((outcomeKey) => {
         const owned = checks.filter((check) => check.outcome_key === outcomeKey);

package/dist/lib/long-task-outcome-parser.js

@@ -1,11 +1,18 @@
 import { parseCheck } from "./long-task-check-shape.js";
 import { normalizeRepositoryFile } from "./long-task-paths.js";
 import { parseRequirements } from "./long-task-requirement-shape.js";
-import { array, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseKeyedStatements, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
+import { array, boolean, key, literal, nullable, object, parseBindings, parseControls, parseCounterfactuals, parseKeyedStatements, parseObligations, parseOwner, parsePopulation, parseRollback, repositoryPatterns, string, strings, } from "./long-task-delivery-shape.js";
 import { parseStrictYaml } from "./strict-codec.js";
+import { assertNoSemanticDriftMigration, semanticDriftOutcomeMigrationFields, } from "./long-task-semantic-drift-migration.js";
 export function parseOutcome(value, label) {
-    const row = object(value, label, ["key", "title", "product", "technical", "acceptance"], ["depends_on"]);
-    const product = object(row.product, `${label}.product`, ["observable_result", "owner"], ["requirements", "owner_surfaces", "controls", "non_completing_outcomes"]);
+    assertNoSemanticDriftMigration(semanticDriftOutcomeMigrationFields(value, label));
+    const row = object(value, label, ["key", "title", "stage", "product", "technical", "acceptance"], ["depends_on"]);
+    const product = object(row.product, `${label}.product`, [
+        "observable_result",
+        "success_path_required",
+        "degradation_path_required",
+        "owner",
+    ], ["requirements", "owner_surfaces", "controls", "non_completing_outcomes"]);
     const technical = object(row.technical, `${label}.technical`, ["expected_change_paths"], [
         "obligations",
         "allowed_support_paths",
@@ -18,11 +25,14 @@ export function parseOutcome(value, label) {
     return {
         key: key(row.key, `${label}.key`),
         title: string(row.title, `${label}.title`),
+        stage: key(row.stage, `${label}.stage`),
         depends_on: Object.hasOwn(row, "depends_on")
             ? strings(row.depends_on, `${label}.depends_on`).map((item, index) => key(item, `${label}.depends_on[${index}]`))
             : [],
         product: {
             observable_result: string(product.observable_result, `${label}.product.observable_result`),
+            success_path_required: boolean(product.success_path_required, `${label}.product.success_path_required`),
+            degradation_path_required: boolean(product.degradation_path_required, `${label}.product.degradation_path_required`),
             owner: parseOwner(product.owner, `${label}.product.owner`),
             requirements: Object.hasOwn(product, "requirements")
                 ? parseRequirements(product.requirements, `${label}.product.requirements`)
@@ -78,6 +88,7 @@ export function parseOutcomeFragment(raw, relative) {
         "outcomes",
         "key",
         "title",
+        "stage",
         "depends_on",
         "product",
         "technical",

package/dist/lib/long-task-playwright-evidence.d.ts

@@ -1,6 +1,7 @@
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+import type { CompiledCheckV2, EvidenceCapabilityRecordV2 } from "./long-task-delivery-types.js";
 export interface PlaywrightEvidence {
     observations: Record<string, unknown>;
+    evidence_records: EvidenceCapabilityRecordV2[];
     error: string | null;
 }
 export declare function extractPlaywrightEvidence(check: CompiledCheckV2, report: Record<string, unknown>, exitCode: number): PlaywrightEvidence;

package/dist/lib/long-task-playwright-evidence.js

@@ -61,7 +61,33 @@ export function extractPlaywrightEvidence(check, report, exitCode) {
         }
     }
     observations["playwright.case_ids"] = cases.map((item) => item.id).sort();
-    return { observations, error: null };
+    const evidenceRecords = [];
+    for (const item of cases) {
+        const assertion = [
+            ...check.positive_assertions,
+            ...check.negative_assertions,
+        ].find((candidate) => candidate.key === item.id);
+        if (assertion?.evidence_capabilities.includes("interaction_trace") &&
+            item.executed)
+            evidenceRecords.push({
+                assertion_key: assertion.key,
+                capability: "interaction_trace",
+                target_ref: check.execution_target.target_ref,
+                given_keys: item.given_keys,
+                action_keys: item.action_keys,
+            });
+        if (assertion?.evidence_capabilities.includes("target_runtime") &&
+            item.executed)
+            evidenceRecords.push({
+                assertion_key: assertion.key,
+                capability: "target_runtime",
+                target_ref: check.execution_target.target_ref,
+                root_entrypoint: check.execution_target_definition.root_entrypoint,
+                session_id: `playwright:${item.id}:${item.project_ids.join(",")}`,
+                cold_start: check.execution_target.entrypoint === "root",
+            });
+    }
+    return { observations, evidence_records: evidenceRecords, error: null };
 }
 function collectCases(report, declaredIds) {
     const cases = [];
@@ -139,6 +165,10 @@ function playwrightCase(id, test) {
         status === "expected" &&
         resultStatuses.length > 0 &&
         resultStatuses.at(-1) === "passed";
+    const traces = results.map((result) => scenarioTrace(result));
+    const givenKeys = traces[0]?.given_keys ?? [];
+    const actionKeys = traces[0]?.action_keys ?? [];
+    const traceConsistent = traces.every((trace) => same(trace.given_keys, givenKeys) && same(trace.action_keys, actionKeys));
     return {
         id,
         project_id: projectId,
@@ -150,6 +180,8 @@ function playwrightCase(id, test) {
         timed_out: timedOut,
         interrupted,
         status,
+        given_keys: traceConsistent ? givenKeys : [],
+        action_keys: traceConsistent ? actionKeys : [],
     };
 }
 function declaredCaseIds(check) {
@@ -227,6 +259,14 @@ function aggregateCases(instances) {
             unexpected_instances: unexpectedInstances,
             timed_out_instances: timedOutInstances,
             interrupted_instances: interruptedInstances,
+            given_keys: rows.length &&
+                rows.every((row) => same(row.given_keys, rows[0].given_keys))
+                ? rows[0].given_keys
+                : [],
+            action_keys: rows.length &&
+                rows.every((row) => same(row.action_keys, rows[0].action_keys))
+                ? rows[0].action_keys
+                : [],
         };
     })
         .sort((left, right) => left.id.localeCompare(right.id));
@@ -239,6 +279,34 @@ function record(value) {
 function integer(value) {
     return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : null;
 }
+function scenarioTrace(result) {
+    const givenKeys = [];
+    const actionKeys = [];
+    const visit = (value) => {
+        if (!Array.isArray(value))
+            return;
+        for (const item of value) {
+            const step = record(item);
+            if (!step)
+                continue;
+            if (typeof step.title === "string") {
+                const given = /^\[given:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
+                const action = /^\[action:([a-z0-9][a-z0-9-]*)\]$/u.exec(step.title);
+                if (given)
+                    givenKeys.push(given[1]);
+                if (action)
+                    actionKeys.push(action[1]);
+            }
+            visit(step.steps);
+        }
+    };
+    visit(result.steps);
+    return { given_keys: givenKeys, action_keys: actionKeys };
+}
+function same(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
 function invalid(error) {
-    return { observations: {}, error };
+    return { observations: {}, evidence_records: [], error };
 }