project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-compact-projections.js

@@ -1,153 +0,0 @@
-import { compactArray, compactFail, compactInteger, compactLiteral, compactNonemptyString, compactPlainObject, compactRequiredOutcome, compactSha256, compactStableRef, compactStableRefs, } from "./long-task-compact-primitives.js";
-export function prepareLongTaskCompactOutcomeTargets(outcomes) {
-    for (const [index, outcome] of outcomes.entries()) {
-        const label = `outcomes[${index}]`;
-        if (Object.hasOwn(outcome, "semantic_fact_bindings"))
-            compactFail(label, "expanded semantic_fact_bindings cannot coexist");
-        const product = compactPlainObject(outcome.product, `${label}.product`);
-        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
-        for (const field of ["requirements", "non_completing_outcomes"])
-            if (Object.hasOwn(product, field))
-                compactFail(`${label}.product.${field}`, "expanded projection cannot coexist");
-        for (const field of ["obligations", "forbidden_shortcuts"])
-            if (Object.hasOwn(technical, field))
-                compactFail(`${label}.technical.${field}`, "expanded projection cannot coexist");
-        product.requirements = [];
-        product.non_completing_outcomes = [];
-        technical.obligations = [];
-        technical.forbidden_shortcuts = [];
-        outcome.semantic_fact_bindings = {
-            manifest_ref: "",
-            facts: [],
-            proofs: [],
-        };
-    }
-}
-export function materializeLongTaskCompactClaimProjections(projections, claims, outcomes) {
-    for (const [index, projection] of projections.entries()) {
-        const label = `compact_semantic_carrier.claim_projections.rows[${index}]`;
-        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
-        const claimKey = projection.claim_key === null
-            ? null
-            : compactStableRef(projection.claim_key, `${label}.claim_key`);
-        const claim = claimKey ? claims.get(claimKey) : null;
-        if (claimKey && !claim)
-            compactFail(`${label}.claim_key`, `unknown claim: ${claimKey}`);
-        const statement = claim
-            ? compactNonemptyString(claim.statement, `${label}.statement`)
-            : compactNonemptyString(projection.statement, `${label}.statement`);
-        const applicabilityRefs = compactStableRefs(projection.applicability_refs, `${label}.applicability_refs`);
-        const kind = compactLiteral(projection.projection_kind, [
-            "requirement",
-            "obligation",
-            "forbidden_shortcut",
-            "non_completing_outcome",
-        ], `${label}.projection_kind`);
-        const product = compactPlainObject(outcome.product, `${label}.product`);
-        const technical = compactPlainObject(outcome.technical, `${label}.technical`);
-        const base = {
-            key: compactStableRef(projection.projection_key ?? projection.claim_key, `${label}.projection_key`),
-            statement,
-            applicability_refs: applicabilityRefs,
-        };
-        if (kind === "requirement" || kind === "obligation") {
-            const requiredProofSurfaces = compactStableRefs(projection.required_proof_surfaces, `${label}.required_proof_surfaces`);
-            const row = { ...base, required_proof_surfaces: requiredProofSurfaces };
-            if (kind === "requirement")
-                product.requirements.push(row);
-            else
-                technical.obligations.push(row);
-        }
-        else {
-            if (projection.required_proof_surfaces !== null)
-                compactFail(`${label}.required_proof_surfaces`, "must be null for statement-only projection");
-            if (kind === "forbidden_shortcut")
-                technical.forbidden_shortcuts.push(base);
-            else
-                product.non_completing_outcomes.push(base);
-        }
-    }
-}
-export function materializeLongTaskCompactFactBindings(facts, obligations, factByKey, templates, outcomes) {
-    for (const [index, fact] of facts.entries()) {
-        const label = `compact_semantic_carrier.facts[${index}]`;
-        const outcome = compactRequiredOutcome(fact.outcome_ref, outcomes, label);
-        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
-        if (!binding.manifest_ref)
-            binding.manifest_ref = compactStableRef(fact.manifest_ref, `${label}.manifest_ref`);
-        else if (binding.manifest_ref !== fact.manifest_ref)
-            compactFail(`${label}.manifest_ref`, "outcome manifest_ref mismatch");
-        binding.facts.push({
-            fact_ref: compactStableRef(fact.fact_key, `${label}.fact_key`),
-            fact_revision_digest: compactSha256(fact.fact_revision_digest, `${label}.fact_revision_digest`),
-            claim_ref: compactStableRef(fact.claim_ref, `${label}.claim_ref`),
-            applicability_ref: compactStableRef(fact.applicability_ref, `${label}.applicability_ref`),
-        });
-    }
-    for (const [index, obligation] of obligations.entries()) {
-        const label = `compact_semantic_carrier.obligations.rows[${index}]`;
-        const outcome = compactRequiredOutcome(obligation.outcome_ref, outcomes, label);
-        const factKey = compactStableRef(obligation.fact_key, `${label}.fact_key`);
-        if (!factByKey.has(factKey))
-            compactFail(`${label}.fact_key`, `unknown fact: ${factKey}`);
-        const templateRef = compactStableRef(obligation.template_ref, `${label}.template_ref`);
-        const template = templates.get(templateRef);
-        if (!template)
-            compactFail(`${label}.template_ref`, `unknown template: ${templateRef}`);
-        const overrides = compactPlainObject(obligation.overrides, `${label}.overrides`);
-        if (["proof_ref", "fact_ref", "obligation_revision_digest"].some((field) => Object.hasOwn(overrides, field)))
-            compactFail(`${label}.overrides`, "identity fields cannot be overridden");
-        const binding = compactPlainObject(outcome.semantic_fact_bindings, `${label}.semantic_fact_bindings`);
-        binding.proofs.push({
-            ...template,
-            ...overrides,
-            proof_ref: compactStableRef(obligation.obligation_key, `${label}.obligation_key`),
-            obligation_revision_digest: compactSha256(obligation.obligation_revision_digest, `${label}.obligation_revision_digest`),
-            fact_ref: factKey,
-        });
-    }
-}
-export function materializeLongTaskCompactAssertions(assertions, claims, facts, outcomes) {
-    for (const [index, projection] of assertions.entries()) {
-        const label = `compact_semantic_carrier.assertion_projections.rows[${index}]`;
-        const outcome = compactRequiredOutcome(projection.outcome_ref, outcomes, label);
-        const acceptance = compactPlainObject(outcome.acceptance, `${label}.acceptance`);
-        const checkRef = compactStableRef(projection.check_ref, `${label}.check_ref`);
-        const check = compactArray(acceptance.checks, `${label}.checks`)
-            .map((item, checkIndex) => compactPlainObject(item, `${label}.checks[${checkIndex}]`))
-            .find((item) => item.key === checkRef);
-        if (!check)
-            compactFail(`${label}.check_ref`, `unknown check: ${checkRef}`);
-        const criterionKind = compactLiteral(projection.criterion_kind, ["claim_statement", "semantic_fact"], `${label}.criterion_kind`);
-        const criterionRef = compactStableRef(projection.criterion_ref, `${label}.criterion_ref`);
-        let criterion;
-        if (criterionKind === "claim_statement") {
-            const claim = claims.get(criterionRef);
-            if (!claim)
-                compactFail(`${label}.criterion_ref`, `unknown claim: ${criterionRef}`);
-            criterion = compactNonemptyString(claim.statement, `${label}.criterion`);
-        }
-        else {
-            if (!facts.has(criterionRef))
-                compactFail(`${label}.criterion_ref`, `unknown fact: ${criterionRef}`);
-            criterion = `The current candidate satisfies the exact Source Fact ${criterionRef}.`;
-        }
-        const assertion = {
-            key: compactStableRef(projection.key, `${label}.key`),
-            criterion,
-            claims: compactStableRefs(projection.claims, `${label}.claims`),
-            applicability_ref: compactStableRef(projection.applicability_ref, `${label}.applicability_ref`),
-            observation: compactNonemptyString(projection.observation, `${label}.observation`),
-            evidence_capabilities: compactStableRefs(projection.evidence_capabilities, `${label}.evidence_capabilities`),
-            operator: compactNonemptyString(projection.operator, `${label}.operator`),
-            expected: projection.expected,
-        };
-        const positive = compactArray(check.positive_assertions, `${label}.positive_assertions`);
-        if (positive.some((item) => compactPlainObject(item, label).key === assertion.key))
-            compactFail(`${label}.key`, `duplicate assertion: ${assertion.key}`);
-        const position = compactInteger(projection.position, `${label}.position`);
-        if (position > positive.length)
-            compactFail(`${label}.position`, `position exceeds current assertion length: ${position}:${positive.length}`);
-        positive.splice(position, 0, assertion);
-    }
-}

package/dist/lib/long-task-compact-structure-targets.d.ts

@@ -1,2 +0,0 @@
-import type { CompactSharedStructureTarget } from "./compact-shared-structures.js";
-export declare function longTaskCompactSharedStructureTargets(root: Record<string, unknown>, carrier: Record<string, unknown>): CompactSharedStructureTarget[];

package/dist/lib/long-task-compact-structure-targets.js

@@ -1,91 +0,0 @@
-const BASE_STRUCTURE_BOUNDARY_BY_FIELD = {
-    path_globs: "contract.path-set",
-    expected_change_paths: "contract.path-set",
-    input_paths: "contract.check.input-paths",
-    verification_inputs: "contract.check.verification-inputs",
-    scenario: "contract.check.scenario",
-    expected_output_paths: "contract.check.output-paths",
-    mutation: "contract.counterfactual.mutation",
-    execution_target: "contract.check.execution-target",
-    artifact_globs: "contract.check.artifact-globs",
-    journey_roles: "contract.check.journey-roles",
-    carrier_paths: "contract.binding.carrier-paths",
-    preserved_assertions: "contract.counterfactual.preserved-assertions",
-    allowed_fanout_assertions: "contract.counterfactual.allowed-fanout-assertions",
-    expected_assertion_failures: "contract.counterfactual.expected-assertion-failures",
-};
-export function longTaskCompactSharedStructureTargets(root, carrier) {
-    const targets = [];
-    for (const [field, boundary] of [
-        ["claim_catalog", "contract.claim"],
-        ["claim_projections", "contract.claim-projection"],
-        ["obligations", "contract.obligation"],
-        ["assertion_projections", "contract.assertion"],
-    ])
-        addCompactTableTargets(targets, carrier[field], boundary);
-    if (Array.isArray(carrier.fact_sets))
-        for (const factSet of carrier.fact_sets)
-            addCompactTableTargets(targets, factSet, "contract.fact");
-    if (Array.isArray(carrier.proof_templates))
-        for (const template of carrier.proof_templates) {
-            const row = plainRecord(template);
-            if (row && Object.hasOwn(row, "binding"))
-                addTarget(targets, row, "binding", "contract.proof.policy");
-        }
-    for (const [key, value] of Object.entries(root)) {
-        if (key === "compact_semantic_carrier")
-            continue;
-        collectBaseTargets(targets, value);
-    }
-    return targets;
-}
-function collectBaseTargets(targets, value) {
-    if (Array.isArray(value)) {
-        value.forEach((item) => collectBaseTargets(targets, item));
-        return;
-    }
-    const row = plainRecord(value);
-    if (!row)
-        return;
-    for (const [key, child] of Object.entries(row)) {
-        const boundary = BASE_STRUCTURE_BOUNDARY_BY_FIELD[key];
-        if (boundary && child && typeof child === "object") {
-            addTarget(targets, row, key, boundary);
-            continue;
-        }
-        collectBaseTargets(targets, child);
-    }
-}
-function addCompactTableTargets(targets, value, boundary) {
-    const table = plainRecord(value);
-    if (!table || !Array.isArray(table.columns) || !Array.isArray(table.rows))
-        return;
-    const columns = table.columns.map(String);
-    const defaults = plainRecord(table.defaults);
-    if (defaults)
-        for (const key of Object.keys(defaults))
-            if (defaults[key] && typeof defaults[key] === "object")
-                addTarget(targets, defaults, key, `${boundary}.default.${key}`);
-    for (const rowValue of table.rows) {
-        if (!Array.isArray(rowValue) || rowValue.length !== columns.length)
-            continue;
-        for (const [index, column] of columns.entries())
-            if (rowValue[index] && typeof rowValue[index] === "object")
-                addTarget(targets, rowValue, index, `${boundary}.${column}`);
-    }
-}
-function addTarget(targets, parent, key, boundary) {
-    const indexed = parent;
-    targets.push({
-        boundary,
-        read: () => indexed[key],
-        write: (value) => {
-            indexed[key] = value;
-        },
-    });
-}
-function plainRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}

package/dist/lib/long-task-conformance-policy.d.ts

@@ -1,5 +0,0 @@
-import type { CompiledCheckV2, DeliveryContractV2, EffectiveRiskLevel } from "./long-task-delivery-types.js";
-type Reporter = (message: string) => void;
-export declare function semanticConformanceRequired(contract: DeliveryContractV2, _effectiveRisk?: EffectiveRiskLevel): boolean;
-export declare function validateSemanticConformance(contract: DeliveryContractV2, effectiveRisk: EffectiveRiskLevel, compiledChecks: CompiledCheckV2[], report?: Reporter): void;
-export {};

package/dist/lib/long-task-conformance-policy.js

@@ -1,37 +0,0 @@
-import { allOutcomeResultsExternallyBlocked } from "./long-task-claims.js";
-export function semanticConformanceRequired(contract, _effectiveRisk) {
-    const productFamilies = new Set(contract.task.execution_targets
-        .filter((target) => contract.task.target_profile.required_target_refs.includes(target.key))
-        .map((target) => target.runtime_family));
-    return (contract.risk.facts.weak_observability.length > 0 &&
-        (productFamilies.size > 1 || contract.stages.length > 1));
-}
-export function validateSemanticConformance(contract, effectiveRisk, compiledChecks, report) {
-    const declared = contract.global.acceptance.checks.filter((check) => check.journey_roles.includes("conformance"));
-    if (semanticConformanceRequired(contract, effectiveRisk) &&
-        !declared.length &&
-        !allOutcomeResultsExternallyBlocked(contract)) {
-        issue(report, "semantic_conformance_check_required", contract.task.id);
-        return;
-    }
-    for (const check of declared) {
-        if (check.runner.effect !== "read_only")
-            issue(report, "conformance_check_must_be_read_only", check.key);
-        if (![...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime")))
-            issue(report, "conformance_target_runtime_evidence_required", check.key);
-        const compiled = compiledChecks.find((candidate) => candidate.outcome_key === null && candidate.key === check.key);
-        if (!compiled)
-            continue;
-        if (compiledChecks.some((candidate) => candidate.internal_id !== compiled.internal_id &&
-            candidate.outcome_key !== null &&
-            candidate.raw_execution_identity === compiled.raw_execution_identity))
-            issue(report, "conformance_raw_execution_must_be_independent", check.key);
-    }
-}
-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-context-authority-topology.d.ts

@@ -1,7 +0,0 @@
-import type { ContextManifest } from "./context-manifest-schema.js";
-/**
- * Hashes only manifest structure that can change the currently selected
- * durable Context authority. Retrieval aliases and load guidance remain in
- * context.toml for future Agent routing but do not revise an active delivery.
- */
-export declare function contextAuthorityTopologyHash(manifest: ContextManifest, selectedFiles: Iterable<string>): string;

package/dist/lib/long-task-context-authority-topology.js

@@ -1,37 +0,0 @@
-import { canonicalJson, sha256Hex } from "./strict-codec.js";
-/**
- * Hashes only manifest structure that can change the currently selected
- * durable Context authority. Retrieval aliases and load guidance remain in
- * context.toml for future Agent routing but do not revise an active delivery.
- */
-export function contextAuthorityTopologyHash(manifest, selectedFiles) {
-    const selected = new Set([...selectedFiles].map(normalizeRepoPath));
-    const topology = {
-        areas: manifest.areas
-            .filter((area) => selected.has(normalizeRepoPath(area.context)))
-            .map(({ line: _line, default: _default, forbidden_runtime_dependencies, kind, ...area }) => ({
-            ...area,
-            ...(kind === undefined ? {} : { kind }),
-            context: normalizeRepoPath(area.context),
-            forbidden_runtime_dependencies: [
-                ...forbidden_runtime_dependencies,
-            ].sort(),
-        }))
-            .sort((left, right) => left.id.localeCompare(right.id)),
-        contexts: manifest.contexts
-            .filter((context) => selected.has(normalizeRepoPath(context.path)))
-            .map(({ line: _line, read_when: _readWhen, read_policy: _readPolicy, triggers: _triggers, default_children, ...context }) => ({
-            ...context,
-            path: normalizeRepoPath(context.path),
-            default_children: [...default_children]
-                .map(normalizeRepoPath)
-                .filter((child) => selected.has(child))
-                .sort(),
-        }))
-            .sort((left, right) => left.path.localeCompare(right.path)),
-    };
-    return sha256Hex(canonicalJson(topology));
-}
-function normalizeRepoPath(value) {
-    return value.replace(/\\/gu, "/").replace(/^\.\//u, "");
-}

package/dist/lib/long-task-context-authority.d.ts

@@ -1,14 +0,0 @@
-import type { CompiledDeliveryContractV2, ContextAuthoritySnapshotV2 } from "./long-task-delivery-types.js";
-export interface NormalizedContextAuthoritySnapshotV2 extends ContextAuthoritySnapshotV2 {
-    controlling_files: string[];
-    supporting_files: string[];
-}
-export declare function normalizeContextAuthoritySnapshot(snapshot: ContextAuthoritySnapshotV2): NormalizedContextAuthoritySnapshotV2;
-export declare function contextAuthorityProjection(snapshot: ContextAuthoritySnapshotV2): {
-    mode: ContextAuthoritySnapshotV2["mode"];
-    topology_sha256: string;
-    controlling_files: string[];
-    sha256: Record<string, string>;
-};
-export declare function contextAuthorityChanged(previous: ContextAuthoritySnapshotV2, next: ContextAuthoritySnapshotV2): boolean;
-export declare function canRetainProgressForSupportingContextRevision(previous: CompiledDeliveryContractV2, next: CompiledDeliveryContractV2): boolean;

package/dist/lib/long-task-context-authority.js

@@ -1,66 +0,0 @@
-import { canonicalValueJson } from "./strict-codec.js";
-export function normalizeContextAuthoritySnapshot(snapshot) {
-    const files = uniqueSorted(snapshot.files);
-    const available = new Set(files);
-    const declaredAuthority = Array.isArray(snapshot.controlling_files)
-        ? snapshot.controlling_files.filter((file) => available.has(file))
-        : files;
-    const declaredSupporting = Array.isArray(snapshot.supporting_files)
-        ? snapshot.supporting_files.filter((file) => available.has(file))
-        : [];
-    const authority = new Set(declaredAuthority);
-    const supporting = new Set(declaredSupporting.filter((file) => !authority.has(file)));
-    for (const file of files)
-        if (!authority.has(file) && !supporting.has(file))
-            authority.add(file);
-    return {
-        mode: snapshot.mode,
-        topology_sha256: snapshot.topology_sha256,
-        files,
-        sha256: Object.fromEntries(files
-            .filter((file) => file in snapshot.sha256)
-            .map((file) => [file, snapshot.sha256[file]])),
-        controlling_files: [...authority].sort(),
-        supporting_files: [...supporting].sort(),
-    };
-}
-export function contextAuthorityProjection(snapshot) {
-    const normalized = normalizeContextAuthoritySnapshot(snapshot);
-    return {
-        mode: normalized.mode,
-        topology_sha256: normalized.topology_sha256,
-        controlling_files: normalized.controlling_files,
-        sha256: Object.fromEntries(normalized.controlling_files
-            .filter((file) => file in normalized.sha256)
-            .map((file) => [file, normalized.sha256[file]])),
-    };
-}
-export function contextAuthorityChanged(previous, next) {
-    return !same(contextAuthorityProjection(previous), contextAuthorityProjection(next));
-}
-export function canRetainProgressForSupportingContextRevision(previous, next) {
-    const previousContext = normalizeContextAuthoritySnapshot(previous.context_snapshot);
-    const nextContext = normalizeContextAuthoritySnapshot(next.context_snapshot);
-    if (same(previousContext, nextContext))
-        return false;
-    if (contextAuthorityChanged(previousContext, nextContext))
-        return false;
-    return same(progressRetentionProjection(previous), progressRetentionProjection(next));
-}
-function progressRetentionProjection(compiled) {
-    const { compiled_identity: _compiledIdentity, authority_revision: _authorityRevision, context_snapshot: contextSnapshot, authority_materials: authorityMaterials, ...rest } = compiled;
-    return {
-        ...rest,
-        context_snapshot: contextAuthorityProjection(contextSnapshot),
-        authority_materials: {
-            ...authorityMaterials,
-            context_snapshot: contextAuthorityProjection(authorityMaterials.context_snapshot),
-        },
-    };
-}
-function same(left, right) {
-    return canonicalValueJson(left) === canonicalValueJson(right);
-}
-function uniqueSorted(values) {
-    return [...new Set(values)].sort();
-}