project-tiny-context-harness 0.8.10 → 0.8.12

package/dist/lib/symbolic-denotation-engine.js

@@ -0,0 +1,140 @@
+import { DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY } from "./design-resource-symbolic-fact-policy.js";
+import { SymbolicDecisionDagBuilder } from "./symbolic-denotation-dag-builder.js";
+import { validateSymbolicDomains, validateSymbolicLimits, } from "./symbolic-denotation-domain-validation.js";
+import { buildSymbolicRuntimeAxes, symbolicEdgeMatches, } from "./symbolic-denotation-runtime.js";
+import { compareText, domainCardinality, invalid, sha256, stableJson, } from "./symbolic-denotation-support.js";
+import { validateSymbolicPredicate, } from "./symbolic-denotation-validation.js";
+export const DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS = {
+    max_predicate_depth: 32,
+    max_input_predicate_nodes: 4_096,
+    max_canonical_dag_nodes: 8_192,
+    max_partition_edges: 65_536,
+    max_canonical_bytes: 4_194_304,
+};
+export function compileSymbolicDenotation(domainsInput, predicateInput, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+    return createSymbolicDenotationCompilationSession(domainsInput, [predicateInput], limits).compile(predicateInput);
+}
+export class SymbolicDenotationCompilationSession {
+    limits;
+    domains;
+    domainIndex;
+    numberCuts = new Map();
+    builder;
+    compiled = new Map();
+    theoreticalGroundCardinality;
+    compileRequests = 0;
+    compileCacheHits = 0;
+    constructor(domainsInput, seedPredicates, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+        if (!seedPredicates.length)
+            invalid("compilation_session_seeds_required", "");
+        this.limits = validateSymbolicLimits(limits);
+        this.domains = validateSymbolicDomains(domainsInput);
+        this.domainIndex = new Map(this.domains.map((domain, index) => [domain.key, index]));
+        const uniqueSeeds = new Map(seedPredicates.map((predicate) => [stableJson(predicate), predicate]));
+        for (const predicate of uniqueSeeds.values())
+            mergeNumberCuts(this.numberCuts, this.inspect(predicate).number_cuts);
+        const axes = buildSymbolicRuntimeAxes(this.domains, this.numberCuts);
+        this.builder = new SymbolicDecisionDagBuilder(axes, this.limits);
+        this.theoreticalGroundCardinality = this.domains
+            .reduce((total, domain) => total * domainCardinality(domain), 1n)
+            .toString();
+    }
+    compile(predicateInput) {
+        this.compileRequests += 1;
+        const inspection = this.inspect(predicateInput);
+        assertKnownNumberCuts(this.numberCuts, inspection.number_cuts);
+        const predicate = validateSymbolicPredicate(predicateInput, this.domains, this.domainIndex, { input_nodes: 0, number_cuts: new Map() }, 1, this.limits);
+        const memoKey = stableJson(predicate);
+        const cached = this.compiled.get(memoKey);
+        if (cached) {
+            this.compileCacheHits += 1;
+            return cached;
+        }
+        const rootId = this.builder.predicate(predicate, this.domainIndex);
+        const canonicalDag = this.builder.canonicalize(rootId);
+        const canonicalJson = stableJson(canonicalDag);
+        const canonicalBytes = Buffer.byteLength(canonicalJson, "utf8");
+        checkCanonicalBytes(canonicalBytes, this.limits.max_canonical_bytes);
+        const partitionEdges = canonicalDag.nodes.reduce((total, node) => total + node.edges.length, 0);
+        const referencedAxisRefs = [
+            ...new Set(canonicalDag.nodes.map((node) => node.axis_ref)),
+        ].sort(compareText);
+        const referenced = new Set(referencedAxisRefs);
+        const result = {
+            canonical_dag: canonicalDag,
+            canonical_sha256: sha256(canonicalJson),
+            canonical_bytes: canonicalBytes,
+            referenced_axis_refs: referencedAxisRefs,
+            omitted_axis_refs: this.domains
+                .map((domain) => domain.key)
+                .filter((axisRef) => !referenced.has(axisRef)),
+            theoretical_ground_cardinality: this.theoreticalGroundCardinality,
+            metrics: {
+                input_predicate_nodes: inspection.input_nodes,
+                canonical_dag_nodes: canonicalDag.nodes.length,
+                partition_edges: partitionEdges,
+                canonical_bytes: canonicalBytes,
+            },
+        };
+        this.compiled.set(memoKey, result);
+        return result;
+    }
+    statistics() {
+        return {
+            axis_partition_builds: 1,
+            compile_requests: this.compileRequests,
+            compile_cache_hits: this.compileCacheHits,
+            unique_compiled_predicates: this.compiled.size,
+        };
+    }
+    inspect(predicate) {
+        const inspection = {
+            input_nodes: 0,
+            number_cuts: new Map(),
+        };
+        validateSymbolicPredicate(predicate, this.domains, this.domainIndex, inspection, 1, this.limits);
+        return inspection;
+    }
+}
+export function createSymbolicDenotationCompilationSession(domains, seedPredicates, limits = DEFAULT_SYMBOLIC_DENOTATION_COMPLEXITY_LIMITS) {
+    return new SymbolicDenotationCompilationSession(domains, seedPredicates, limits);
+}
+function mergeNumberCuts(target, source) {
+    for (const [axisRef, cuts] of source) {
+        const values = target.get(axisRef) ?? new Set();
+        cuts.forEach((cut) => values.add(cut));
+        target.set(axisRef, values);
+    }
+}
+function assertKnownNumberCuts(known, actual) {
+    for (const [axisRef, cuts] of actual)
+        for (const cut of cuts)
+            if (!known.get(axisRef)?.has(cut))
+                invalid("compilation_session_axis_partition_stale", `${axisRef}:${cut}`);
+}
+function checkCanonicalBytes(actual, limit) {
+    if (actual > limit)
+        invalid("canonical_byte_limit_exceeded", `actual=${actual}:limit=${limit}`);
+}
+export function evaluateCanonicalSymbolicDenotation(dag, assignment) {
+    const nodes = new Map(dag.nodes.map((node) => [node.key, node]));
+    let current = dag.root_ref;
+    const visited = new Set();
+    while (current !== "terminal.true" && current !== "terminal.false") {
+        if (visited.has(current))
+            invalid("canonical_dag_cycle", current);
+        visited.add(current);
+        const node = nodes.get(current);
+        if (!node)
+            invalid("canonical_dag_node_unknown", current);
+        const value = assignment[node.axis_ref];
+        if (value === undefined)
+            invalid("canonical_dag_assignment_missing", node.axis_ref);
+        const matches = node.edges.filter((edge) => symbolicEdgeMatches(edge, value));
+        if (matches.length !== 1)
+            invalid("canonical_dag_assignment_partition_invalid", `${node.axis_ref}:matches=${matches.length}`);
+        current = matches[0].child_ref;
+    }
+    return current === "terminal.true";
+}
+void DESIGN_RESOURCE_SYMBOLIC_FACT_POLICY.symbolic_denotation_efficiency_delivery;

package/dist/lib/symbolic-denotation-public.d.ts

@@ -0,0 +1,11 @@
+import { denoteDesignResourceSymbolicPoint } from "./design-resource-symbolic-denotation.js";
+import { compileSymbolicDenotation, evaluateCanonicalSymbolicDenotation } from "./symbolic-denotation-engine.js";
+export declare const symbolicDenotation: Readonly<{
+    compile: typeof compileSymbolicDenotation;
+    evaluate: typeof evaluateCanonicalSymbolicDenotation;
+    denoteDesignPoint: typeof denoteDesignResourceSymbolicPoint;
+    sourceIr: Readonly<{
+        mediaType: "application/vnd.ty-context.symbolic-source-ir+json";
+        schemaVersion: "design-resource-symbolic-source-ir-v1";
+    }>;
+}>;

package/dist/lib/symbolic-denotation-public.js

@@ -0,0 +1,12 @@
+import { denoteDesignResourceSymbolicPoint } from "./design-resource-symbolic-denotation.js";
+import { compileSymbolicDenotation, evaluateCanonicalSymbolicDenotation, } from "./symbolic-denotation-engine.js";
+import { DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE, DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_SCHEMA_VERSION, } from "./design-resource-symbolic-source-ir-types.js";
+export const symbolicDenotation = Object.freeze({
+    compile: compileSymbolicDenotation,
+    evaluate: evaluateCanonicalSymbolicDenotation,
+    denoteDesignPoint: denoteDesignResourceSymbolicPoint,
+    sourceIr: Object.freeze({
+        mediaType: DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_MEDIA_TYPE,
+        schemaVersion: DESIGN_RESOURCE_SYMBOLIC_SOURCE_IR_SCHEMA_VERSION,
+    }),
+});

package/dist/lib/symbolic-denotation-runtime.d.ts

@@ -0,0 +1,20 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationCanonicalEdgeV1, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+interface EnumSegment {
+    kind: "enum";
+    values: string[];
+}
+interface NumberSegment {
+    kind: "number";
+    minimum: number;
+    maximum: number;
+}
+export type SymbolicAxisSegment = EnumSegment | NumberSegment;
+export interface SymbolicRuntimeAxis {
+    domain: SymbolicDenotationAxisDomain;
+    segments: SymbolicAxisSegment[];
+}
+export declare function buildSymbolicRuntimeAxes(domains: SymbolicDenotationAxisDomain[], numberCuts: ReadonlyMap<string, Set<number>>): SymbolicRuntimeAxis[];
+export declare function canonicalSymbolicEdges(axis: SymbolicRuntimeAxis, childRefs: string[]): SymbolicDenotationCanonicalEdgeV1[];
+export declare function symbolicEdgeMatches(edge: SymbolicDenotationCanonicalEdgeV1, value: SymbolicDenotationScalar): boolean;
+export declare function symbolicSegmentMatches(segment: SymbolicAxisSegment, matches: (value: SymbolicDenotationScalar) => boolean): boolean;
+export {};

package/dist/lib/symbolic-denotation-runtime.js

@@ -0,0 +1,90 @@
+import { compareText, invalid } from "./symbolic-denotation-support.js";
+export function buildSymbolicRuntimeAxes(domains, numberCuts) {
+    return domains.map((domain) => {
+        if (domain.kind === "enum")
+            return {
+                domain,
+                segments: domain.values.map((value) => ({
+                    kind: "enum",
+                    values: [value],
+                })),
+            };
+        return { domain, segments: buildNumberSegments(domain, numberCuts) };
+    });
+}
+function buildNumberSegments(domain, numberCuts) {
+    const cuts = new Set([
+        domain.minimum,
+        domain.maximum + 1,
+        ...(numberCuts.get(domain.key) ?? []),
+    ]);
+    const sorted = [...cuts]
+        .filter((value) => value >= domain.minimum && value <= domain.maximum + 1)
+        .sort((left, right) => left - right);
+    const segments = [];
+    for (let index = 0; index < sorted.length - 1; index += 1) {
+        const minimum = sorted[index];
+        const maximum = sorted[index + 1] - 1;
+        if (minimum <= maximum)
+            segments.push({ kind: "number", minimum, maximum });
+    }
+    return segments;
+}
+export function canonicalSymbolicEdges(axis, childRefs) {
+    return axis.domain.kind === "enum"
+        ? canonicalEnumEdges(axis, childRefs)
+        : canonicalNumberEdges(axis, childRefs);
+}
+function canonicalEnumEdges(axis, childRefs) {
+    const groups = new Map();
+    axis.segments.forEach((segment, index) => {
+        const values = groups.get(childRefs[index]) ?? [];
+        values.push(...segment.values);
+        groups.set(childRefs[index], values);
+    });
+    return [...groups.entries()]
+        .map(([child_ref, values]) => ({
+        region: { kind: "enum_set", values },
+        child_ref,
+    }))
+        .sort((left, right) => compareText(left.region.values[0], right.region.values[0]));
+}
+function canonicalNumberEdges(axis, childRefs) {
+    const edges = [];
+    axis.segments.forEach((segment, index) => {
+        const numeric = segment;
+        const previous = edges.at(-1);
+        if (previous?.region.kind === "integer_range" &&
+            previous.child_ref === childRefs[index] &&
+            previous.region.maximum + 1 === numeric.minimum) {
+            previous.region.maximum = numeric.maximum;
+            return;
+        }
+        edges.push({
+            region: {
+                kind: "integer_range",
+                minimum: numeric.minimum,
+                maximum: numeric.maximum,
+            },
+            child_ref: childRefs[index],
+        });
+    });
+    return edges;
+}
+export function symbolicEdgeMatches(edge, value) {
+    if (edge.region.kind === "enum_set")
+        return typeof value === "string" && edge.region.values.includes(value);
+    return (typeof value === "number" &&
+        Number.isSafeInteger(value) &&
+        value >= edge.region.minimum &&
+        value <= edge.region.maximum);
+}
+export function symbolicSegmentMatches(segment, matches) {
+    if (segment.kind === "enum")
+        return matches(segment.values[0]);
+    const atMinimum = matches(segment.minimum);
+    const atMaximum = matches(segment.maximum);
+    if (atMinimum !== atMaximum)
+        invalid("numeric_partition_not_theory_complete", `${segment.minimum}:${segment.maximum}`);
+    return atMinimum;
+}

package/dist/lib/symbolic-denotation-support.d.ts

@@ -0,0 +1,11 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationScalar } from "./symbolic-denotation-types.js";
+export declare function exactKeys(value: object, expected: string[], label: string): void;
+export declare function stableKey(value: unknown, label: string): asserts value is string;
+export declare function stableJson(value: unknown): string;
+export declare function sha256(value: string): string;
+export declare function compareText(left: string, right: string): number;
+export declare function compareScalar(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): number;
+export declare function scalarEqual(left: SymbolicDenotationScalar, right: SymbolicDenotationScalar): boolean;
+export declare function domainCardinality(domain: SymbolicDenotationAxisDomain): bigint;
+export declare function neverValue(value: never): string;
+export declare function invalid(code: string, detail: string): never;

package/dist/lib/symbolic-denotation-support.js

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+export function exactKeys(value, expected, label) {
+    const actual = Object.keys(value).sort(compareText);
+    const required = [...expected].sort(compareText);
+    if (actual.length !== required.length ||
+        actual.some((key, index) => key !== required[index]))
+        invalid("shape_keys_invalid", `${label}:actual=${actual.join(",")}:expected=${required.join(",")}`);
+}
+export function stableKey(value, label) {
+    if (typeof value !== "string" || !/^[a-z0-9][a-z0-9._-]*$/u.test(value))
+        invalid("stable_key_invalid", `${label}:${String(value)}`);
+}
+export function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => compareText(left, right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}
+export function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+export function compareScalar(left, right) {
+    if (typeof left !== typeof right)
+        return typeof left === "number" ? -1 : 1;
+    return typeof left === "number"
+        ? left - right
+        : compareText(left, right);
+}
+export function scalarEqual(left, right) {
+    return typeof left === typeof right && left === right;
+}
+export function domainCardinality(domain) {
+    return domain.kind === "enum"
+        ? BigInt(domain.values.length)
+        : BigInt(domain.maximum) - BigInt(domain.minimum) + 1n;
+}
+export function neverValue(value) {
+    return String(value);
+}
+export function invalid(code, detail) {
+    throw new Error(`symbolic_denotation_invalid:${code}:${detail}`);
+}

package/dist/lib/symbolic-denotation-types.d.ts

@@ -0,0 +1,133 @@
+export type SymbolicDenotationScalar = string | number;
+export type SymbolicDenotationAxisDomain = {
+    key: string;
+    kind: "enum";
+    values: string[];
+} | {
+    key: string;
+    kind: "bounded_number";
+    minimum: number;
+    maximum: number;
+    integer: true;
+};
+export type SymbolicDenotationPredicate = {
+    op: "eq";
+    axis_ref: string;
+    value: SymbolicDenotationScalar;
+} | {
+    op: "in";
+    axis_ref: string;
+    values: SymbolicDenotationScalar[];
+} | {
+    op: "range";
+    axis_ref: string;
+    minimum: number;
+    maximum: number;
+    minimum_inclusive: boolean;
+    maximum_inclusive: boolean;
+} | {
+    op: "all" | "any";
+    predicates: SymbolicDenotationPredicate[];
+} | {
+    op: "not";
+    predicate: SymbolicDenotationPredicate;
+};
+export interface SymbolicDenotationComplexityLimits {
+    max_predicate_depth: number;
+    max_input_predicate_nodes: number;
+    max_canonical_dag_nodes: number;
+    max_partition_edges: number;
+    max_canonical_bytes: number;
+}
+export interface SymbolicDenotationCanonicalDagV1 {
+    schema_version: "symbolic-denotation-canonical-dag-v1";
+    root_ref: string;
+    nodes: SymbolicDenotationCanonicalNodeV1[];
+}
+export interface SymbolicDenotationCanonicalNodeV1 {
+    key: string;
+    axis_ref: string;
+    edges: SymbolicDenotationCanonicalEdgeV1[];
+}
+export type SymbolicDenotationCanonicalEdgeV1 = {
+    region: {
+        kind: "enum_set";
+        values: string[];
+    };
+    child_ref: string;
+} | {
+    region: {
+        kind: "integer_range";
+        minimum: number;
+        maximum: number;
+    };
+    child_ref: string;
+};
+export interface CompiledSymbolicDenotationV1 {
+    canonical_dag: SymbolicDenotationCanonicalDagV1;
+    canonical_sha256: string;
+    canonical_bytes: number;
+    referenced_axis_refs: string[];
+    omitted_axis_refs: string[];
+    theoretical_ground_cardinality: string;
+    metrics: {
+        input_predicate_nodes: number;
+        canonical_dag_nodes: number;
+        partition_edges: number;
+        canonical_bytes: number;
+    };
+}
+export declare const SYMBOLIC_DENOTATION_DISPOSITIONS: readonly ["specified", "not_applicable", "excluded", "decision_required", "unavailable", "blocking"];
+export type SymbolicDenotationDisposition = (typeof SYMBOLIC_DENOTATION_DISPOSITIONS)[number];
+export declare const SYMBOLIC_DENOTATION_QUANTIFIERS: readonly ["one", "all", "any", "none", "exactly", "at_least", "at_most", "range"];
+export type SymbolicDenotationQuantifier = (typeof SYMBOLIC_DENOTATION_QUANTIFIERS)[number];
+export interface SymbolicExtensionalPointV1 {
+    subject_or_relation_ref: string;
+    target_ref: string;
+    condition_assignment: Record<string, SymbolicDenotationScalar>;
+    variation_assignment: Record<string, SymbolicDenotationScalar>;
+    property_ref: string;
+    population_ref: string | null;
+    quantifier: {
+        kind: SymbolicDenotationQuantifier;
+        minimum: number | null;
+        maximum: number | null;
+    };
+}
+export interface SymbolicExpectedSemanticsV1 {
+    value_type: string;
+    expected: {
+        locator: {
+            resource_ref: string;
+            kind: string;
+            value: string;
+        };
+        sha256: string;
+    };
+    provenance_ref: string;
+    sensitivity: string;
+    population_ref: string | null;
+    quantifier: SymbolicExtensionalPointV1["quantifier"];
+    lineage: unknown;
+}
+export interface SymbolicProofObligationDenotationV1 {
+    method: string;
+    proof_surface: string;
+    observation_boundary: string;
+    comparison: {
+        comparator: string;
+        mode: "exact" | "tolerance";
+        parameters: unknown;
+        tolerance: unknown;
+        mask: unknown;
+    };
+    oracle: unknown;
+    environment: unknown;
+    protected_value_policy: string;
+    completion_effect: string;
+}
+export interface SymbolicPointDenotationV1 {
+    disposition: SymbolicDenotationDisposition;
+    expected_semantics: SymbolicExpectedSemanticsV1 | null;
+    proof_obligations: SymbolicProofObligationDenotationV1[];
+}

package/dist/lib/symbolic-denotation-types.js

@@ -0,0 +1,18 @@
+export const SYMBOLIC_DENOTATION_DISPOSITIONS = [
+    "specified",
+    "not_applicable",
+    "excluded",
+    "decision_required",
+    "unavailable",
+    "blocking",
+];
+export const SYMBOLIC_DENOTATION_QUANTIFIERS = [
+    "one",
+    "all",
+    "any",
+    "none",
+    "exactly",
+    "at_least",
+    "at_most",
+    "range",
+];

package/dist/lib/symbolic-denotation-validation.d.ts

@@ -0,0 +1,6 @@
+import type { SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate } from "./symbolic-denotation-types.js";
+export interface SymbolicPredicateInspection {
+    input_nodes: number;
+    number_cuts: Map<string, Set<number>>;
+}
+export declare function validateSymbolicPredicate(input: SymbolicDenotationPredicate, domains: SymbolicDenotationAxisDomain[], domainIndex: ReadonlyMap<string, number>, inspection: SymbolicPredicateInspection, depth: number, limits: SymbolicDenotationComplexityLimits): SymbolicDenotationPredicate;

package/dist/lib/symbolic-denotation-validation.js

@@ -0,0 +1,126 @@
+import { compareScalar, exactKeys, invalid, } from "./symbolic-denotation-support.js";
+export function validateSymbolicPredicate(input, domains, domainIndex, inspection, depth, limits) {
+    inspectPredicateNode(input, depth, inspection, limits);
+    switch (input.op) {
+        case "eq":
+            return validateEq(input, domains, domainIndex, inspection);
+        case "in":
+            return validateIn(input, domains, domainIndex, inspection);
+        case "range":
+            return validateRange(input, domains, domainIndex, inspection);
+        case "all":
+        case "any":
+            return validateGroup(input, domains, domainIndex, inspection, depth, limits);
+        case "not":
+            return validateNot(input, domains, domainIndex, inspection, depth, limits);
+        default:
+            return invalid("predicate_operator_unknown", String(input.op));
+    }
+}
+function inspectPredicateNode(input, depth, inspection, limits) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        invalid("predicate_invalid", "not_object");
+    if (depth > limits.max_predicate_depth)
+        invalid("predicate_depth_limit_exceeded", `actual=${depth}:limit=${limits.max_predicate_depth}`);
+    inspection.input_nodes += 1;
+    if (inspection.input_nodes > limits.max_input_predicate_nodes)
+        invalid("predicate_node_limit_exceeded", `actual=${inspection.input_nodes}:limit=${limits.max_input_predicate_nodes}`);
+}
+function validateEq(input, domains, domainIndex, inspection) {
+    exactKeys(input, ["op", "axis_ref", "value"], "predicate:eq");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    validateScalar(domain, input.value);
+    addNumberCuts(domain, [input.value], inspection);
+    return { ...input };
+}
+function validateIn(input, domains, domainIndex, inspection) {
+    exactKeys(input, ["op", "axis_ref", "values"], "predicate:in");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    if (!Array.isArray(input.values) || !input.values.length)
+        invalid("predicate_in_values_required", input.axis_ref);
+    const values = input.values.map((value) => {
+        validateScalar(domain, value);
+        return value;
+    });
+    if (new Set(values.map((value) => `${typeof value}:${value}`)).size !==
+        values.length)
+        invalid("predicate_in_value_duplicate", input.axis_ref);
+    addNumberCuts(domain, values, inspection);
+    return { ...input, values: [...values].sort(compareScalar) };
+}
+function validateRange(input, domains, domainIndex, inspection) {
+    exactKeys(input, [
+        "op",
+        "axis_ref",
+        "minimum",
+        "maximum",
+        "minimum_inclusive",
+        "maximum_inclusive",
+    ], "predicate:range");
+    const domain = predicateDomain(input.axis_ref, domains, domainIndex);
+    validateRangeBounds(input, domain);
+    const effectiveMinimum = input.minimum + (input.minimum_inclusive ? 0 : 1);
+    const effectiveMaximum = input.maximum - (input.maximum_inclusive ? 0 : 1);
+    if (effectiveMinimum > effectiveMaximum)
+        invalid("predicate_range_empty", input.axis_ref);
+    addCuts(inspection, domain.key, effectiveMinimum, effectiveMaximum + 1);
+    return { ...input };
+}
+function validateRangeBounds(input, domain) {
+    if (domain.kind !== "bounded_number" ||
+        !Number.isSafeInteger(input.minimum) ||
+        !Number.isSafeInteger(input.maximum) ||
+        typeof input.minimum_inclusive !== "boolean" ||
+        typeof input.maximum_inclusive !== "boolean" ||
+        input.minimum < domain.minimum ||
+        input.maximum > domain.maximum ||
+        input.minimum > input.maximum)
+        invalid("predicate_range_invalid", input.axis_ref);
+}
+function validateGroup(input, domains, domainIndex, inspection, depth, limits) {
+    exactKeys(input, ["op", "predicates"], `predicate:${input.op}`);
+    if (!Array.isArray(input.predicates) || !input.predicates.length)
+        invalid("predicate_children_required", input.op);
+    return {
+        op: input.op,
+        predicates: input.predicates.map((predicate) => validateSymbolicPredicate(predicate, domains, domainIndex, inspection, depth + 1, limits)),
+    };
+}
+function validateNot(input, domains, domainIndex, inspection, depth, limits) {
+    exactKeys(input, ["op", "predicate"], "predicate:not");
+    return {
+        op: "not",
+        predicate: validateSymbolicPredicate(input.predicate, domains, domainIndex, inspection, depth + 1, limits),
+    };
+}
+function predicateDomain(axisRef, domains, domainIndex) {
+    if (typeof axisRef !== "string")
+        invalid("predicate_axis_invalid", "");
+    const index = domainIndex.get(axisRef);
+    if (index === undefined)
+        invalid("predicate_axis_unknown", axisRef);
+    return domains[index];
+}
+function validateScalar(domain, value) {
+    if (domain.kind === "enum") {
+        if (typeof value !== "string" || !domain.values.includes(value))
+            invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
+        return;
+    }
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < domain.minimum ||
+        value > domain.maximum)
+        invalid("predicate_value_outside_domain", `${domain.key}:${String(value)}`);
+}
+function addNumberCuts(domain, values, inspection) {
+    if (domain.kind !== "bounded_number")
+        return;
+    for (const value of values)
+        addCuts(inspection, domain.key, value, value + 1);
+}
+function addCuts(inspection, axisRef, ...cuts) {
+    const values = inspection.number_cuts.get(axisRef) ?? new Set();
+    cuts.forEach((cut) => values.add(cut));
+    inspection.number_cuts.set(axisRef, values);
+}

package/dist/lib/sync-engine.d.ts

@@ -2,6 +2,7 @@ export interface SyncReport {
     changed: string[];
     skipped: string[];
     blocked: string[];
+    notices?: string[];
 }
 export declare function emptySyncReport(): SyncReport;
 export declare function runSync(projectRoot: string): Promise<SyncReport>;

package/dist/lib/sync-engine.js

@@ -7,6 +7,7 @@ import { AGENTS_BLOCK_MARKERS, GITHUB_WORKFLOW_BLOCK_END, GITHUB_WORKFLOW_BLOCK_
 import { packageAssetPath } from "./paths.js";
 import { assertSupportedSchema } from "./schema-guard.js";
 import { installLongTaskHooks, uninstallLongTaskHooks, } from "./long-task-hook-install.js";
+import { syncLongTaskCodexAgentProfile } from "./long-task-codex-agent-profile.js";
 import { enabledManagedSkillNames, isProfileEnabled } from "./profiles.js";
 export function emptySyncReport() {
     return {
@@ -27,7 +28,9 @@ export async function runSync(projectRoot) {
     for (const managedFile of config.managed_files) {
         await syncManagedFile(projectRoot, root, managedFile, report, config);
     }
-    if (isProfileEnabled(config, "long-task")) {
+    const longTaskEnabled = isProfileEnabled(config, "long-task");
+    await syncLongTaskCodexAgentProfile(projectRoot, root, longTaskEnabled, report);
+    if (longTaskEnabled) {
         await installLongTaskHooks(projectRoot, report);
     }
     else {

package/dist/lib/upgrade.js

@@ -42,6 +42,7 @@ export async function runUpgradeReport(projectRoot) {
     for (const skipped of syncReport.skipped.filter((line) => line.includes("customized"))) {
         lines.push(`sync skipped: ${skipped}`);
     }
+    lines.push(...(syncReport.notices ?? []));
     const doctor = await runDoctor(projectRoot);
     lines.push(`doctor warnings=${doctor.warnings.length} errors=${doctor.errors.length}`);
     const blocked = migrationReport.manualRequired.length > 0 ||