project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-artifacts.d.ts

@@ -1,6 +0,0 @@
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
-export declare function collectCheckArtifacts(check: CompiledCheckV2, snapshotRoot: string): Promise<{
-    hashes: Record<string, string>;
-    errors: string[];
-}>;

package/dist/lib/long-task-artifacts.js

@@ -1,35 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { sha256Hex } from "./strict-codec.js";
-export { JSON_POINTER_EXACT_CAPABILITY, JSON_POINTER_EXACT_LIMITS, JSON_POINTER_EXACT_METHODS, JSON_POINTER_EXACT_ORACLE_IDENTITY, JSON_POINTER_EXACT_ORACLE_VERSION, JSON_POINTER_EXACT_SPEC_SHA256, admittedObservationKey, classifyObservationCarrier, createJsonPointerExactBudget, extractJsonPointerExactObservation, extractJsonPointerExactObservationFromBytes, isJsonPointerExactOracle, jsonPointerExactLocatorForIdentity, observationAdmissionDecision, prepareAdmittedObservations, } from "./long-task-admitted-observation.js";
-export async function collectCheckArtifacts(check, snapshotRoot) {
-    if (!check.artifact_globs.length)
-        return { hashes: {}, errors: [] };
-    const candidates = [];
-    async function visit(directory, relative = "") {
-        for (const entry of await readdir(directory, { withFileTypes: true })) {
-            if (!relative && entry.name === ".git")
-                continue;
-            const next = relative ? `${relative}/${entry.name}` : entry.name;
-            if (entry.isSymbolicLink() || entry.name === "node_modules")
-                continue;
-            if (entry.isDirectory())
-                await visit(path.join(directory, entry.name), next);
-            else if (entry.isFile())
-                candidates.push(next);
-        }
-    }
-    await visit(snapshotRoot);
-    const selected = [
-        ...new Set(check.artifact_globs.flatMap((pattern) => candidates.filter((candidate) => matchesRepoPattern(candidate, pattern)))),
-    ].sort();
-    const hashes = Object.fromEntries(await Promise.all(selected.map(async (relative) => [
-        relative,
-        sha256Hex(await readFile(path.join(snapshotRoot, ...relative.split("/")))),
-    ])));
-    const errors = check.artifact_globs
-        .filter((pattern) => !selected.some((file) => matchesRepoPattern(file, pattern)))
-        .map((pattern) => `artifact_glob_empty:${pattern}`);
-    return { hashes, errors };
-}

package/dist/lib/long-task-assertions-v2.d.ts

@@ -1,22 +0,0 @@
-import type { DeliveryAssertionV2, PopulationRequirementV2 } from "./long-task-delivery-types.js";
-export interface AssertionComparison {
-    comparable: boolean;
-    passed: boolean;
-}
-export interface DeliveryAssertionEvaluation {
-    passed: boolean;
-    status: "passed" | "observation_missing" | "observation_type_mismatch" | "assertion_value_mismatch";
-    expected?: unknown;
-    actual?: unknown;
-}
-export declare function evaluateDeliveryAssertion(assertion: DeliveryAssertionV2, observations: Record<string, unknown>): boolean;
-export declare function evaluateDeliveryAssertionDetailed(assertion: DeliveryAssertionV2, observations: Record<string, unknown>): DeliveryAssertionEvaluation;
-export declare function evaluatePopulation(requirement: PopulationRequirementV2, observations: Record<string, unknown>): {
-    passed: boolean;
-    actual: unknown;
-    reason: string | null;
-};
-export declare function observationValue(observations: Record<string, unknown>, name: string): {
-    found: boolean;
-    value: unknown;
-};

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

@@ -1,220 +0,0 @@
-import { canonicalValueJson } from "./strict-codec.js";
-export function evaluateDeliveryAssertion(assertion, observations) {
-    return evaluateDeliveryAssertionDetailed(assertion, observations).passed;
-}
-export function evaluateDeliveryAssertionDetailed(assertion, observations) {
-    const { found, value } = observationValue(observations, assertion.observation);
-    if (!found)
-        return {
-            passed: false,
-            status: "observation_missing",
-            expected: assertion.expected,
-        };
-    if (assertion.operator === "exists")
-        return { passed: true, status: "passed", actual: value };
-    const expected = assertion.expected;
-    let comparison;
-    switch (assertion.operator) {
-        case "truthy":
-            return result(Boolean(value), true, value);
-        case "falsy":
-            return result(!value, false, value);
-        case "equals":
-            comparison = comparableEquals(value, expected, false);
-            break;
-        case "not_equals":
-            comparison = comparableEquals(value, expected, true);
-            break;
-        case "contains":
-            comparison = contains(value, expected);
-            break;
-        case "not_contains":
-            comparison = contains(value, expected);
-            comparison = {
-                comparable: comparison.comparable,
-                passed: comparison.comparable && !comparison.passed,
-            };
-            break;
-        case "matches":
-            comparison = matches(value, expected);
-            break;
-        case "not_matches":
-            comparison = matches(value, expected);
-            comparison = {
-                comparable: comparison.comparable,
-                passed: comparison.comparable && !comparison.passed,
-            };
-            break;
-        case "greater_than":
-            comparison = numbers(value, expected, (a, b) => a > b);
-            break;
-        case "greater_or_equal":
-            comparison = numbers(value, expected, (a, b) => a >= b);
-            break;
-        case "less_than":
-            comparison = numbers(value, expected, (a, b) => a < b);
-            break;
-        case "less_or_equal":
-            comparison = numbers(value, expected, (a, b) => a <= b);
-            break;
-        case "set_equals":
-            comparison = sets(value, expected, (a, b) => a.size === b.size && [...a].every((item) => b.has(item)));
-            break;
-        case "subset_of":
-            comparison = sets(value, expected, (a, b) => [...a].every((item) => b.has(item)));
-            break;
-        case "superset_of":
-            comparison = sets(value, expected, (a, b) => [...b].every((item) => a.has(item)));
-            break;
-    }
-    if (!comparison.comparable)
-        return {
-            passed: false,
-            status: "observation_type_mismatch",
-            expected,
-            actual: value,
-        };
-    return result(comparison.passed, expected, value);
-}
-export function evaluatePopulation(requirement, observations) {
-    const universe = observationValue(observations, requirement.observations.universe_ids).value;
-    const eligible = observationValue(observations, requirement.observations.eligible_ids).value;
-    const observed = observationValue(observations, requirement.observations.observed_ids).value;
-    const excluded = observationValue(observations, requirement.observations.excluded_items).value;
-    const actual = {
-        universe_ids: universe,
-        eligible_ids: eligible,
-        observed_ids: observed,
-        excluded_items: excluded,
-    };
-    if (!validIds(universe))
-        return failure(actual, "universe_ids_invalid");
-    if (!validIds(eligible))
-        return failure(actual, "eligible_ids_invalid");
-    if (!validIds(observed))
-        return failure(actual, "observed_ids_invalid");
-    if (!Array.isArray(excluded))
-        return failure(actual, "excluded_items_invalid");
-    const eligibleSet = new Set(eligible);
-    const universeSet = new Set(universe);
-    if (universeSet.size !== eligibleSet.size ||
-        [...universeSet].some((id) => !eligibleSet.has(id)))
-        return failure(actual, "eligible_universe_mismatch");
-    const observedSet = new Set(observed);
-    const excludedIds = [];
-    const rules = new Set(requirement.exclusion_rules.map((item) => item.key));
-    for (const item of excluded) {
-        if (!item ||
-            typeof item !== "object" ||
-            Array.isArray(item) ||
-            typeof item.id !== "string" ||
-            !item.id ||
-            typeof item.rule !== "string")
-            return failure(actual, "excluded_item_invalid");
-        const id = item.id;
-        const rule = item.rule;
-        if (!rules.has(rule))
-            return failure(actual, `exclusion_rule_unknown:${rule}`);
-        excludedIds.push(id);
-    }
-    if (new Set(excludedIds).size !== excludedIds.length)
-        return failure(actual, "excluded_ids_duplicate");
-    const excludedSet = new Set(excludedIds);
-    if (![...observedSet].every((id) => eligibleSet.has(id)))
-        return failure(actual, "observed_not_eligible_subset");
-    if (![...excludedSet].every((id) => eligibleSet.has(id)))
-        return failure(actual, "excluded_not_eligible_subset");
-    if ([...observedSet].some((id) => excludedSet.has(id)))
-        return failure(actual, "observed_excluded_overlap");
-    const covered = new Set([...observedSet, ...excludedSet]);
-    if (covered.size !== eligibleSet.size ||
-        [...eligibleSet].some((id) => !covered.has(id)))
-        return failure(actual, "eligible_population_incomplete");
-    return {
-        passed: true,
-        actual: { ...actual, coverage_percent: 100 },
-        reason: null,
-    };
-}
-export function observationValue(observations, name) {
-    if (Object.hasOwn(observations, name))
-        return { found: true, value: observations[name] };
-    let current = observations;
-    for (const part of name.split(".")) {
-        if (!current ||
-            typeof current !== "object" ||
-            Array.isArray(current) ||
-            !Object.hasOwn(current, part))
-            return { found: false, value: undefined };
-        current = current[part];
-    }
-    return { found: true, value: current };
-}
-function validIds(value) {
-    return (Array.isArray(value) &&
-        value.every((item) => typeof item === "string" && item.length > 0) &&
-        new Set(value).size === value.length);
-}
-function failure(actual, reason) {
-    return { passed: false, actual, reason };
-}
-function contains(value, expected) {
-    if (typeof value === "string" && typeof expected === "string")
-        return { comparable: true, passed: value.includes(expected) };
-    if (Array.isArray(value))
-        return {
-            comparable: true,
-            passed: value.some((item) => canonicalValueJson(item) === canonicalValueJson(expected)),
-        };
-    return { comparable: false, passed: false };
-}
-function comparableEquals(value, expected, negate) {
-    if (valueKind(value) !== valueKind(expected))
-        return { comparable: false, passed: false };
-    const equal = canonicalValueJson(value) === canonicalValueJson(expected);
-    return { comparable: true, passed: negate ? !equal : equal };
-}
-function matches(value, expected) {
-    if (typeof value !== "string" || typeof expected !== "string")
-        return { comparable: false, passed: false };
-    try {
-        return {
-            comparable: true,
-            passed: new RegExp(expected, "u").test(value),
-        };
-    }
-    catch {
-        return { comparable: false, passed: false };
-    }
-}
-function numbers(left, right, compare) {
-    if (typeof left !== "number" ||
-        typeof right !== "number" ||
-        !Number.isFinite(left) ||
-        !Number.isFinite(right))
-        return { comparable: false, passed: false };
-    return { comparable: true, passed: compare(left, right) };
-}
-function sets(left, right, compare) {
-    if (!Array.isArray(left) || !Array.isArray(right))
-        return { comparable: false, passed: false };
-    return {
-        comparable: true,
-        passed: compare(new Set(left.map(canonicalValueJson)), new Set(right.map(canonicalValueJson))),
-    };
-}
-function result(passed, expected, actual) {
-    return {
-        passed,
-        status: passed ? "passed" : "assertion_value_mismatch",
-        expected,
-        actual,
-    };
-}
-function valueKind(value) {
-    if (value === null)
-        return "null";
-    if (Array.isArray(value))
-        return "array";
-    return typeof value;
-}

package/dist/lib/long-task-authoring-authority-preview.d.ts

@@ -1,5 +0,0 @@
-import type { AuthoringPreflightDiagnosticV1, AuthoringRevisionPreviewV1 } from "./long-task-authoring-preflight-types.js";
-import type { ContextAuthoritySnapshotV2, CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-import { type ActiveLongTaskAuthorityV3 } from "./long-task-state.js";
-export declare function loadAuthoringActiveAuthority(repository: string, workdir: string, diagnostics: AuthoringPreflightDiagnosticV1[]): Promise<ActiveLongTaskAuthorityV3 | null>;
-export declare function authoringRevisionPreview(contract: DeliveryContractV2, sourceHashes: Record<string, string> | null, sourceItems: CompiledSourceItemV2[] | null, context: ContextAuthoritySnapshotV2 | null, active: ActiveLongTaskAuthorityV3 | null): AuthoringRevisionPreviewV1;

package/dist/lib/long-task-authoring-authority-preview.js

@@ -1,87 +0,0 @@
-import { computeAuthorityHashes } from "./long-task-authority.js";
-import { computeAuthorityMaterials, compiledAuthorityMaterials, } from "./long-task-authority-materials.js";
-import { addDiagnosticError } from "./long-task-authoring-preflight-diagnostics.js";
-import { loadActiveLongTaskAuthority, } from "./long-task-state.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export async function loadAuthoringActiveAuthority(repository, workdir, diagnostics) {
-    try {
-        const active = (await loadActiveLongTaskAuthority(repository)).authority;
-        if (active && active.workdir !== workdir)
-            diagnostics.push({
-                level: "error",
-                code: "active_task_exists",
-                message: `Another workdir owns Active Authority: ${active.workdir}`,
-            });
-        return active;
-    }
-    catch (error) {
-        addDiagnosticError(diagnostics, error);
-        return null;
-    }
-}
-export function authoringRevisionPreview(contract, sourceHashes, sourceItems, context, active) {
-    if (!active)
-        return {
-            active: false,
-            authority_revision: null,
-            contract_changed: false,
-            source_or_context_changed: false,
-            declared_authority_sections_changed: [],
-        };
-    const hashes = computeAuthorityHashes(contract);
-    const previousDeclaredHashes = computeAuthorityHashes({
-        schema_version: "long-task-delivery-v2",
-        semantic_fact_manifest: active.authority_snapshot.semantic_fact_manifest,
-        task: active.authority_snapshot.task,
-        source_claims: active.authority_snapshot.source_claims,
-        stages: active.authority_snapshot.stages,
-        risk: active.authority_snapshot.risk,
-        global: active.authority_snapshot.global,
-        outcomes: active.authority_snapshot.outcomes,
-    });
-    const declaredChanged = new Set(Object.keys(hashes)
-        .filter((key) => hashes[key] !== previousDeclaredHashes[key])
-        .map((key) => key.replace(/_authority_hash$/u, "")));
-    let sourceChanged = false;
-    let contextChanged = false;
-    if (sourceHashes && sourceItems && context) {
-        const next = computeAuthorityMaterials(contract, sourceHashes, sourceItems, context);
-        const previous = compiledAuthorityMaterials(active.authority_snapshot);
-        sourceChanged =
-            canonicalValueJson({
-                source_hashes: next.source_hashes,
-                source_items: next.source_items,
-            }) !==
-                canonicalValueJson({
-                    source_hashes: previous.source_hashes,
-                    source_items: previous.source_items,
-                });
-        contextChanged =
-            canonicalValueJson({
-                context_snapshot: next.context_snapshot,
-            }) !==
-                canonicalValueJson({
-                    context_snapshot: previous.context_snapshot,
-                });
-        if (sourceChanged)
-            declaredChanged.add("source");
-        if (contextChanged)
-            declaredChanged.add("context");
-    }
-    const sectionOrder = [
-        "source",
-        "product",
-        "technical",
-        "acceptance",
-        "risk",
-        "context",
-    ];
-    return {
-        active: true,
-        authority_revision: active.authority_revision,
-        contract_changed: sha256Hex(canonicalValueJson(contract)) !==
-            active.authority_snapshot.contract_sha256,
-        source_or_context_changed: sourceChanged || contextChanged,
-        declared_authority_sections_changed: sectionOrder.filter((section) => declaredChanged.has(section)),
-    };
-}

package/dist/lib/long-task-authoring-preflight-diagnostics.d.ts

@@ -1,8 +0,0 @@
-import type { ParsedDeliveryContractV2 } from "./long-task-delivery-parser.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { AuthoringPreflightDiagnosticV1, SourceCoverageV1 } from "./long-task-authoring-preflight-types.js";
-export declare function addAuthoringDiagnostics(contract: DeliveryContractV2, parsed: ParsedDeliveryContractV2, diagnostics: AuthoringPreflightDiagnosticV1[]): void;
-export declare function sourceCoverage(contract: DeliveryContractV2): SourceCoverageV1;
-export declare function captureDiagnostic(diagnostics: AuthoringPreflightDiagnosticV1[], action: () => Promise<unknown>): Promise<void>;
-export declare function addDiagnosticError(diagnostics: AuthoringPreflightDiagnosticV1[], error: unknown, outcomeKey?: string | null, checkKey?: string): void;
-export declare function normalizeAuthoringDiagnostics(diagnostics: AuthoringPreflightDiagnosticV1[]): AuthoringPreflightDiagnosticV1[];

package/dist/lib/long-task-authoring-preflight-diagnostics.js

@@ -1,191 +0,0 @@
-import { applyDiagnosticRepairOrder } from "./long-task-authoring-preflight-repair-order.js";
-export function addAuthoringDiagnostics(contract, parsed, diagnostics) {
-    if (parsed.outcome_files.length)
-        diagnostics.push({
-            level: "warning",
-            code: "outcome_files_compatibility_only",
-            message: "outcome_files is supported only as physical compatibility; new authoring should use inline Outcomes.",
-            repair_hint: "Keep compatibility files only when required; use inline Outcomes for new authoring.",
-        });
-    for (const claim of contract.source_claims)
-        if (claim.disposition.type === "decision_required")
-            diagnostics.push({
-                level: "decision_required",
-                code: "source_claim_decision_required",
-                message: `${claim.key}: ${claim.disposition.reason}`,
-                refs: [claim.key],
-                repair_hint: "Resolve this product decision from the user or an authoritative Source before Compile; do not infer it from implementation convenience.",
-            });
-}
-export function sourceCoverage(contract) {
-    const counts = {
-        claim: 0,
-        acceptance: 0,
-        outcome_result: 0,
-        global_constraint: 0,
-        risk_fact: 0,
-        external_confirmation: 0,
-        decision_required: 0,
-    };
-    for (const item of contract.source_claims)
-        counts[item.disposition.type] += 1;
-    return {
-        total: contract.source_claims.length,
-        resolved: contract.source_claims.length - counts.decision_required,
-        mapped_to_product_claims: counts.claim,
-        mapped_to_acceptance: counts.acceptance,
-        mapped_to_outcome_results: counts.outcome_result,
-        mapped_to_global_constraints: counts.global_constraint,
-        mapped_to_risk_facts: counts.risk_fact,
-        mapped_to_external_confirmations: counts.external_confirmation,
-        decision_required: counts.decision_required,
-        unresolved: contract.source_claims
-            .filter((item) => item.disposition.type === "decision_required")
-            .map((item) => item.key),
-    };
-}
-export async function captureDiagnostic(diagnostics, action) {
-    try {
-        await action();
-    }
-    catch (error) {
-        addDiagnosticError(diagnostics, error);
-    }
-}
-export function addDiagnosticError(diagnostics, error, outcomeKey, checkKey) {
-    const message = error instanceof Error ? error.message : String(error);
-    const rows = message.startsWith("delivery_contract_preflight_failed:\n")
-        ? message.split(/\r?\n/u).slice(1)
-        : [message];
-    for (const row of rows) {
-        const code = diagnosticCode(row);
-        const refs = diagnosticRefs(code, row);
-        const repairHint = diagnosticRepairHint(code);
-        diagnostics.push({
-            level: "error",
-            code,
-            message: row,
-            ...(outcomeKey ? { outcome_key: outcomeKey } : {}),
-            ...(checkKey ? { check_key: checkKey } : {}),
-            ...(refs.length ? { refs } : {}),
-            ...(repairHint ? { repair_hint: repairHint } : {}),
-        });
-    }
-}
-export function normalizeAuthoringDiagnostics(diagnostics) {
-    const normalized = [];
-    const positions = new Map();
-    for (const diagnostic of diagnostics) {
-        const refs = diagnostic.refs?.length
-            ? [...new Set(diagnostic.refs)].sort()
-            : undefined;
-        const next = {
-            ...diagnostic,
-            ...(refs ? { refs } : {}),
-        };
-        delete next.occurrences;
-        delete next.diagnostic_id;
-        delete next.repair_group;
-        delete next.repair_priority;
-        delete next.blocked_by;
-        const key = JSON.stringify([
-            next.level,
-            next.code,
-            next.message,
-            next.outcome_key ?? null,
-            next.check_key ?? null,
-            next.refs ?? [],
-            next.repair_hint ?? null,
-        ]);
-        const position = positions.get(key);
-        if (position === undefined) {
-            positions.set(key, normalized.length);
-            normalized.push(next);
-            continue;
-        }
-        const existing = normalized[position];
-        existing.occurrences = (existing.occurrences ?? 1) + 1;
-    }
-    return applyDiagnosticRepairOrder(normalized);
-}
-function diagnosticCode(message) {
-    if (message.startsWith("delivery_contract_invalid:"))
-        return message.split(":")[1] || "delivery_contract_invalid";
-    return message.split(":")[0] || "authoring_preflight_error";
-}
-function diagnosticPayload(code, message) {
-    const parts = message.split(":");
-    if (message.startsWith("delivery_contract_invalid:"))
-        return parts.slice(2);
-    if (parts[0] === code)
-        return parts.slice(1);
-    return parts.slice(1);
-}
-function diagnosticRefs(code, message) {
-    const payload = diagnosticPayload(code, message).filter(Boolean);
-    switch (code) {
-        case "owner_context_ref_unknown":
-        case "path_outside_owner_boundary":
-        case "source_claim_anchor_not_found":
-        case "binding_carrier_path_not_found":
-        case "binding_carrier_outside_change_paths":
-        case "binding_target_not_found":
-        case "binding_target_outside_carrier":
-            return payload.slice(0, 2);
-        case "requirement_key_duplicate":
-        case "binding_key_duplicate":
-        case "control_key_duplicate":
-        case "obligation_key_duplicate":
-        case "forbidden_shortcut_key_duplicate":
-            return payload.slice(0, 2);
-        case "owner_path_globs_empty":
-            return payload.slice(0, 1);
-        case "workspace_path_forbidden":
-        case "workspace_path_unclassified":
-            return payload.slice(0, 1);
-        case "product_claim_uncovered":
-        case "global_claim_uncovered":
-        case "source_claim_decision_required":
-            return payload.flatMap((value) => value.split(",")).filter(Boolean);
-        case "product_claim_required_surfaces_missing":
-            return payload.length >= 2
-                ? [`${payload[0]}.${payload[1]}`, ...payload.slice(2)]
-                : payload;
-        case "assertion_criterion_required":
-            return payload.length ? [payload.join(":")] : [];
-        default:
-            if (code.endsWith("_path_not_found"))
-                return payload.slice(0, 2);
-            return [];
-    }
-}
-function diagnosticRepairHint(code) {
-    switch (code) {
-        case "owner_context_ref_unknown":
-            return "Add the existing Context path to task.context_refs or correct owner.context_refs; do not invent a Context owner.";
-        case "requirement_key_duplicate":
-        case "binding_key_duplicate":
-        case "control_key_duplicate":
-        case "obligation_key_duplicate":
-        case "forbidden_shortcut_key_duplicate":
-            return "Remove an accidental duplicate or assign distinct stable keys while preserving each distinct semantic item.";
-        case "product_claim_uncovered":
-        case "product_claim_required_surfaces_missing":
-        case "global_claim_uncovered":
-            return "Add claim-bearing Assertion coverage for every required proof surface or correct the Claim mapping; do not weaken or delete the uncovered Claim.";
-        case "assertion_criterion_required":
-            return "Add a named falsifiable criterion that states what the Assertion accepts.";
-        case "source_claim_anchor_not_found":
-            return "Correct source_ref or add the matching non-rendering Source marker/anchor without rewriting the Source statement.";
-        case "source_claim_decision_required":
-            return "Resolve the stated product decision from the user or authoritative Source before Compile.";
-        case "workspace_path_forbidden":
-            return "Revert or relocate the forbidden workspace change, or revise the owning Source/Contract boundary through the appropriate authority path.";
-        case "workspace_path_unclassified":
-            return "Declare the file under the owning Outcome's expected_change_paths or allowed_support_paths, or remove the unrelated workspace change before Compile.";
-        default:
-            if (code.endsWith("_path_not_found"))
-                return "Create or correct the declared repository path, runner target or Binding carrier, then rerun Preflight.";
-            return null;
-    }
-}

package/dist/lib/long-task-authoring-preflight-repair-order.d.ts

@@ -1,8 +0,0 @@
-import type { AuthoringPreflightDiagnosticV1 } from "./long-task-authoring-preflight-types.js";
-/**
- * Adds repair-order metadata only when a structural duplicate makes the
- * identity of an uncovered Claim ambiguous. The structural diagnostic must be
- * reviewed first, but the coverage finding is never treated as automatically
- * resolved. No diagnostic is hidden, merged, reclassified or removed.
- */
-export declare function applyDiagnosticRepairOrder(diagnostics: AuthoringPreflightDiagnosticV1[]): AuthoringPreflightDiagnosticV1[];