project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/legacy-sdlc-migration.js

@@ -1,199 +0,0 @@
-import path from "node:path";
-import { LEGACY_HARNESS_JSON_CONFIG_PATH, readHarnessRootConfigCandidates, } from "./harness-root.js";
-import { pathExists, readText, writeTextIfChanged } from "./fs.js";
-import { detectLegacyManagedDirectory } from "./legacy-managed-scan.js";
-import { HARNESS_JSON_CONFIG_PATH } from "./paths.js";
-const LEGACY_MANAGED_ROOT = "pjsdlc_managed";
-const CURRENT_MANAGED_ROOT = "ty-context-managed";
-const LEGACY_MAKEFILE = "sdlc-harness.mk";
-const CURRENT_MAKEFILE = "ty-context.mk";
-export const legacySdlcHarnessMigration = {
-    id: "legacy-sdlc-harness-rename",
-    introducedIn: "0.2.54",
-    description: "Rename legacy sdlc-harness configuration and pjsdlc_managed package-managed paths.",
-    scope: "package.json, sdlc-harness.config.json, <harnessRoot>/config.yaml, old managed markers and pjsdlc_managed/**",
-    risk: "safe",
-    manualMessage: "Resolve legacy sdlc-harness conflicts or move old override rules into standalone project-local Skills.",
-    detect: detectLegacySdlcHarness,
-    apply: migrateLegacySdlcHarness,
-    verify: async () => undefined,
-};
-async function detectLegacySdlcHarness(projectRoot, root, migration) {
-    const items = [];
-    const candidates = await readHarnessRootConfigCandidates(projectRoot);
-    const currentCandidates = candidates.filter((candidate) => !candidate.legacy);
-    const legacyCandidates = candidates.filter((candidate) => candidate.legacy);
-    const currentRoot = currentCandidates[0]?.harnessFolderName;
-    const distinctLegacyRoots = Array.from(new Set(legacyCandidates.map((candidate) => candidate.harnessFolderName)));
-    if (currentRoot &&
-        distinctLegacyRoots.some((legacyRoot) => legacyRoot !== currentRoot)) {
-        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Current ty-context and legacy sdlc-harness root configuration disagree; choose the harness root manually before upgrade."));
-    }
-    else if (!currentRoot && distinctLegacyRoots.length > 1) {
-        items.push(item(migration, "blocked", rootConflictPath(currentCandidates, legacyCandidates), "Legacy sdlc-harness root sources disagree; choose one harness root manually before upgrade."));
-    }
-    items.push(...(await detectLegacyManagedDirectory(projectRoot, root, legacySdlcHarnessMigration)));
-    if (items.some((entry) => entry.status === "blocked")) {
-        return items;
-    }
-    if (await needsLegacySafeMigration(projectRoot, root, legacyCandidates.length > 0)) {
-        items.unshift(item(migration, "safe_pending", "legacy sdlc-harness surfaces", "Legacy sdlc-harness naming can be copied to ty-context configuration and refreshed by sync."));
-    }
-    return items;
-}
-async function migrateLegacySdlcHarness(projectRoot, root, report) {
-    await migratePackageJsonConfig(projectRoot, report);
-    await migrateJsonConfig(projectRoot, report);
-    await migrateConfigYamlPaths(projectRoot, root, report);
-}
-async function needsLegacySafeMigration(projectRoot, root, hasLegacyRootConfig) {
-    if (hasLegacyRootConfig &&
-        (await legacyPackageConfigNeedsCopy(projectRoot))) {
-        return true;
-    }
-    if (await legacyJsonConfigNeedsCopy(projectRoot)) {
-        return true;
-    }
-    if (await configYamlHasLegacyManagedPaths(projectRoot, root)) {
-        return true;
-    }
-    if (await hasLegacyManagedMarkers(projectRoot)) {
-        return true;
-    }
-    return false;
-}
-async function legacyPackageConfigNeedsCopy(projectRoot) {
-    const packagePath = path.join(projectRoot, "package.json");
-    if (!(await pathExists(packagePath))) {
-        return false;
-    }
-    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
-    return (isJsonRecord(packageJson.sdlcHarness) &&
-        !isJsonRecord(packageJson.tyContext));
-}
-async function legacyJsonConfigNeedsCopy(projectRoot) {
-    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
-    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
-    return (await pathExists(legacyPath)) && !(await pathExists(currentPath));
-}
-async function configYamlHasLegacyManagedPaths(projectRoot, root) {
-    const configPath = path.join(projectRoot, root, "config.yaml");
-    if (!(await pathExists(configPath))) {
-        return false;
-    }
-    return hasLegacyManagedPath(await readText(configPath));
-}
-async function hasLegacyManagedMarkers(projectRoot) {
-    for (const relative of [
-        "AGENTS.md",
-        "Makefile",
-        ".github/workflows/harness.yml",
-    ]) {
-        const target = path.join(projectRoot, ...relative.split("/"));
-        if ((await pathExists(target)) && hasLegacyMarker(await readText(target))) {
-            return true;
-        }
-    }
-    return false;
-}
-async function migratePackageJsonConfig(projectRoot, report) {
-    const packagePath = path.join(projectRoot, "package.json");
-    if (!(await pathExists(packagePath))) {
-        report.skipped.push("package.json#sdlcHarness");
-        return;
-    }
-    const packageJson = parseJsonRecord(await readText(packagePath), "package.json");
-    if (!isJsonRecord(packageJson.sdlcHarness) ||
-        isJsonRecord(packageJson.tyContext)) {
-        report.skipped.push("package.json#sdlcHarness");
-        return;
-    }
-    packageJson.tyContext = { ...packageJson.sdlcHarness };
-    if (await writeTextIfChanged(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`)) {
-        report.changed.push("package.json#tyContext");
-    }
-    else {
-        report.skipped.push("package.json#tyContext");
-    }
-}
-async function migrateJsonConfig(projectRoot, report) {
-    const legacyPath = path.join(projectRoot, LEGACY_HARNESS_JSON_CONFIG_PATH);
-    const currentPath = path.join(projectRoot, HARNESS_JSON_CONFIG_PATH);
-    if (!(await pathExists(legacyPath))) {
-        report.skipped.push(LEGACY_HARNESS_JSON_CONFIG_PATH);
-        return;
-    }
-    if (await pathExists(currentPath)) {
-        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
-        return;
-    }
-    if (await writeTextIfChanged(currentPath, await readText(legacyPath))) {
-        report.changed.push(HARNESS_JSON_CONFIG_PATH);
-    }
-    else {
-        report.skipped.push(HARNESS_JSON_CONFIG_PATH);
-    }
-}
-async function migrateConfigYamlPaths(projectRoot, root, report) {
-    const relative = `${root}/config.yaml`;
-    const configPath = path.join(projectRoot, root, "config.yaml");
-    if (!(await pathExists(configPath))) {
-        report.skipped.push(relative);
-        return;
-    }
-    const original = await readText(configPath);
-    const next = rewriteLegacyManagedPaths(original);
-    if (next === original) {
-        report.skipped.push(relative);
-        return;
-    }
-    if (await writeTextIfChanged(configPath, next)) {
-        report.changed.push(`${relative}#legacy-managed-paths`);
-    }
-    else {
-        report.skipped.push(`${relative}#legacy-managed-paths`);
-    }
-}
-function rewriteLegacyManagedPaths(content) {
-    return content
-        .replaceAll(LEGACY_MANAGED_ROOT, CURRENT_MANAGED_ROOT)
-        .replaceAll(LEGACY_MAKEFILE, CURRENT_MAKEFILE);
-}
-function hasLegacyManagedPath(content) {
-    return (content.includes(LEGACY_MANAGED_ROOT) || content.includes(LEGACY_MAKEFILE));
-}
-function hasLegacyMarker(content) {
-    return [
-        "<!-- pjsdlc:sdlc-harness:begin -->",
-        "<!-- sdlc-harness:begin -->",
-        "# pjsdlc:sdlc-harness:make:begin",
-        "# sdlc-harness:make:begin",
-        "# pjsdlc:sdlc-harness:github-workflow:begin",
-    ].some((marker) => content.includes(marker));
-}
-function rootConflictPath(currentCandidates, legacyCandidates) {
-    return [...currentCandidates, ...legacyCandidates]
-        .map((candidate) => `${candidate.source}=${candidate.harnessFolderName}`)
-        .join(", ");
-}
-function item(migrationId, status, pathLabel, message) {
-    return {
-        id: legacySdlcHarnessMigration.id,
-        introducedIn: legacySdlcHarnessMigration.introducedIn,
-        description: legacySdlcHarnessMigration.description,
-        scope: legacySdlcHarnessMigration.scope,
-        status,
-        path: pathLabel,
-        message,
-    };
-}
-function parseJsonRecord(content, pathLabel) {
-    const parsed = JSON.parse(content);
-    if (!isJsonRecord(parsed)) {
-        throw new Error(`${pathLabel} must contain a JSON object`);
-    }
-    return parsed;
-}
-function isJsonRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}

package/dist/lib/long-task-acceptance-reachability-claims.d.ts

@@ -1,2 +0,0 @@
-import type { AcceptanceObligationReachabilityV1, AcceptanceReachabilityInputV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
-export declare function compileClaimReachability(input: AcceptanceReachabilityInputV1, rows: AcceptanceObligationReachabilityV1[], external: ExpectedExternalObligation[]): void;

package/dist/lib/long-task-acceptance-reachability-claims.js

@@ -1,279 +0,0 @@
-import { externalClaimCapabilityFloor } from "./long-task-proof-adequacy.js";
-import { claimSemanticCapabilityFloor } from "./long-task-claim-semantic-proof-floor.js";
-import { resolveObligationAuthority } from "./long-task-obligation-authority-resolution.js";
-import { claimObligationRef, claimProofMethod, externalConfirmationSessionMatchesApplicability, objectiveMachineClaimActualAuthority, pendingExternalRow, resolveObjectiveExternalClaimActualAuthority, selectOptionalSurface, } from "./long-task-acceptance-reachability-helpers.js";
-import { objectiveClaimSemanticIdentity } from "./long-task-obligation-semantic-identity.js";
-export function compileClaimReachability(input, rows, external) {
-    compileGlobalClaimReachability(input, rows, external);
-    compileOutcomeClaimReachability(input, rows, external);
-}
-function compileGlobalClaimReachability(input, rows, external) {
-    for (const claim of input.claims.by_global) {
-        const summary = input.claims.summary.claims_by_global[claim.local_key];
-        for (const applicabilityRef of claim.applicability_refs)
-            addClaimObligation(input, rows, external, null, claim.local_key, claim.id, applicabilityRef, summary?.proofs ?? [], [], claim.required_polarity);
-    }
-}
-function compileOutcomeClaimReachability(input, rows, external) {
-    for (const [outcomeKey, claims] of Object.entries(input.claims.by_outcome))
-        for (const claim of claims) {
-            if (claim.kind === "semantic_fact")
-                continue;
-            const summary = input.claims.summary.claims_by_outcome[outcomeKey]?.[claim.local_key];
-            for (const applicabilityRef of claim.applicability_refs)
-                addClaimObligation(input, rows, external, outcomeKey, claim.local_key, claim.id, applicabilityRef, summary?.proofs ?? [], claim.required_proof_surfaces, claim.required_polarity);
-        }
-}
-function addClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, proofs, requiredSurfaces, requiredPolarity) {
-    const matching = proofs.filter((proof) => proof.applicability_ref === applicabilityRef &&
-        proof.polarity === requiredPolarity);
-    if (!requiredSurfaces.length) {
-        addOptionalClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, requiredPolarity);
-        return;
-    }
-    for (const surface of requiredSurfaces)
-        addClaimSurfaceObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity);
-}
-function addOptionalClaimObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, requiredPolarity) {
-    const surfaces = [...new Set(matching.map((proof) => proof.proof_surface))];
-    if (!surfaces.length)
-        surfaces.push("runtime_behavior");
-    const profiles = surfaces.map((surface) => claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity));
-    const selectedSurface = selectOptionalSurface(matching);
-    const selectedProfile = profiles.find((profile) => profile.surface === selectedSurface) ??
-        profiles[0];
-    const resolution = resolveObligationAuthority({
-        source_obligation_ref: selectedProfile.sourceObligationRef,
-        proof_surface_selection: "optional",
-        machine_candidates: profiles.flatMap((profile) => profile.machineCandidates),
-        external_candidates: profiles.flatMap((profile) => profile.externalCandidates),
-    });
-    const resolvedSurface = resolution.status === "machine_admitted"
-        ? resolution.machine.proof_surface
-        : resolution.status === "external_candidate"
-            ? resolution.external.proof_surface
-            : selectedProfile.surface;
-    if (resolution.status === "machine_admitted") {
-        const machineProfile = profiles.find((profile) => profile.surface === resolution.machine.proof_surface) ?? selectedProfile;
-        for (const profile of profiles)
-            for (const route of profile.externalCandidates) {
-                if (!route.expected_authority_ref)
-                    continue;
-                external.push({
-                    source_obligation_ref: profile.sourceObligationRef,
-                    outcome_key: outcomeKey,
-                    claim_ref: fullClaim,
-                    local_claim_ref: localClaim,
-                    applicability_ref: applicabilityRef,
-                    fact_ref: null,
-                    proof_ref: null,
-                    method: route.method ?? profile.method,
-                    proof_surface: route.proof_surface,
-                    evidence_capabilities: [
-                        ...(route.required_evidence_capabilities ?? []),
-                    ].sort(),
-                    expected_authority_ref: route.expected_authority_ref,
-                    confirmation_ref: route.confirmation_ref,
-                    required_polarity: requiredPolarity,
-                    completion_role: "advisory",
-                    acceptance_effect: "none",
-                    semantic_identity: route.semantic_identity ?? null,
-                    machine_obligation_ref: machineProfile.sourceObligationRef,
-                });
-            }
-    }
-    emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profiles.find((profile) => profile.surface === resolvedSurface) ??
-        selectedProfile, resolution, requiredPolarity);
-}
-function addClaimSurfaceObligation(input, rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity) {
-    const profile = claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity);
-    const resolution = resolveObligationAuthority({
-        source_obligation_ref: profile.sourceObligationRef,
-        proof_surface_selection: "required",
-        machine_candidates: profile.machineCandidates,
-        external_candidates: profile.externalCandidates,
-    });
-    emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profile, resolution, requiredPolarity);
-}
-function claimSurfaceAuthorityProfile(input, outcomeKey, localClaim, fullClaim, applicabilityRef, matching, surface, requiredPolarity) {
-    const capabilityFloorSet = externalClaimCapabilityFloor(input.contract, outcomeKey, localClaim, surface, applicabilityRef);
-    for (const capability of claimSemanticCapabilityFloor(input.contract, input.manifest, outcomeKey, localClaim, applicabilityRef))
-        capabilityFloorSet.add(capability);
-    const capabilityFloor = [...capabilityFloorSet].sort();
-    const method = claimProofMethod(capabilityFloor);
-    const candidates = matching.filter((proof) => proof.proof_surface === surface);
-    const sourceObligationRef = claimObligationRef(fullClaim, applicabilityRef, surface);
-    const machineCandidates = candidates.flatMap((proof) => {
-        if (!proof.assertion_key)
-            return [];
-        const check = input.compiled_checks.find((item) => item.outcome_key === outcomeKey && item.key === proof.check_key);
-        if (!check)
-            return [];
-        const authority = objectiveMachineClaimActualAuthority(input.compiled_checks, outcomeKey, proof.check_key, proof.assertion_key, localClaim);
-        if (!authority)
-            return [];
-        const requiredCapabilities = check.required_evidence_capabilities[proof.assertion_key] ?? [];
-        const expectedAuthorityRef = check.expected_authority_refs?.[proof.assertion_key];
-        if (!expectedAuthorityRef)
-            return [];
-        return [
-            {
-                check_key: proof.check_key,
-                assertion_key: proof.assertion_key,
-                proof_surface: proof.proof_surface,
-                method,
-                required_evidence_capabilities: requiredCapabilities,
-                semantic_identity: objectiveClaimSemanticIdentity({
-                    contract: input.contract,
-                    outcome_key: outcomeKey,
-                    claim_ref: fullClaim,
-                    local_claim_ref: localClaim,
-                    applicability_ref: applicabilityRef,
-                    required_polarity: requiredPolarity,
-                    expected_authority_ref: expectedAuthorityRef,
-                    method,
-                    required_evidence_capabilities: requiredCapabilities,
-                    observation_authority: authority,
-                }),
-            },
-        ];
-    });
-    const externalCandidates = candidates
-        .filter((proof) => proof.check_key.startsWith("EXTERNAL."))
-        .flatMap((proof) => {
-        const confirmationRef = proof.check_key.slice("EXTERNAL.".length);
-        const confirmation = input.contract.global.acceptance.external_confirmations.find((row) => row.key === confirmationRef);
-        if (!confirmation)
-            return [];
-        return (confirmation.obligations ?? [])
-            .filter((obligation) => obligation.claim_ref === fullClaim &&
-            obligation.applicability_ref === applicabilityRef &&
-            obligation.proof_surface === surface &&
-            obligation.fact_ref === null &&
-            obligation.proof_ref === null)
-            .map((obligation) => {
-            const authorityResolution = resolveObjectiveExternalClaimActualAuthority(input.compiled_checks, {
-                source_obligation_ref: sourceObligationRef,
-                outcome_key: outcomeKey,
-                claim_ref: fullClaim,
-                local_claim_ref: localClaim,
-                fact_ref: null,
-                proof_ref: null,
-                method: obligation.method,
-                proof_surface: obligation.proof_surface,
-            });
-            const authority = authorityResolution.status === "resolved"
-                ? authorityResolution.authority
-                : null;
-            const compiledExpectedAuthorityRef = authorityResolution.status === "resolved"
-                ? authorityResolution.expected_authority_ref
-                : null;
-            const expectedAuthorityMatches = compiledExpectedAuthorityRef !== null &&
-                obligation.expected_authority_ref === compiledExpectedAuthorityRef;
-            const objectiveActual = obligation.result_kind === "actual" &&
-                obligation.judgment_basis === undefined;
-            const semanticIdentity = authority && expectedAuthorityMatches
-                ? objectiveClaimSemanticIdentity({
-                    contract: input.contract,
-                    outcome_key: outcomeKey,
-                    claim_ref: fullClaim,
-                    local_claim_ref: localClaim,
-                    applicability_ref: applicabilityRef,
-                    required_polarity: requiredPolarity,
-                    expected_authority_ref: compiledExpectedAuthorityRef,
-                    method: obligation.method,
-                    required_evidence_capabilities: obligation.evidence_capabilities,
-                    observation_authority: authority,
-                })
-                : null;
-            return {
-                confirmation_ref: confirmationRef,
-                obligation_key: obligation.key,
-                proof_surface: obligation.proof_surface,
-                method: obligation.method,
-                required_evidence_capabilities: [
-                    ...obligation.evidence_capabilities,
-                ].sort(),
-                authority_ambiguous: authorityResolution.status === "ambiguous",
-                authority_unresolved: objectiveActual &&
-                    (authorityResolution.status !== "resolved" ||
-                        !expectedAuthorityMatches),
-                expected_authority_ref: objectiveActual
-                    ? (compiledExpectedAuthorityRef ?? undefined)
-                    : obligation.expected_authority_ref,
-                semantic_identity: semanticIdentity,
-                advisory_to_machine: semanticIdentity !== null &&
-                    expectedAuthorityMatches &&
-                    objectiveActual &&
-                    externalConfirmationSessionMatchesApplicability(input.contract, outcomeKey, applicabilityRef, confirmation),
-            };
-        });
-    });
-    return {
-        surface,
-        sourceObligationRef,
-        method,
-        capabilityFloor,
-        machineCandidates,
-        externalCandidates,
-    };
-}
-function emitClaimAuthorityResolution(rows, external, outcomeKey, localClaim, fullClaim, applicabilityRef, profile, resolution, requiredPolarity) {
-    const { sourceObligationRef, method, surface, capabilityFloor } = profile;
-    if (resolution.status === "external_candidate") {
-        const confirmationRef = resolution.external.confirmation_ref;
-        const expectedAuthorityRef = resolution.external.expected_authority_ref;
-        if (!expectedAuthorityRef) {
-            rows.push(pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, resolution.external.proof_surface, capabilityFloor, confirmationRef));
-            return;
-        }
-        external.push({
-            source_obligation_ref: sourceObligationRef,
-            outcome_key: outcomeKey,
-            claim_ref: fullClaim,
-            local_claim_ref: localClaim,
-            applicability_ref: applicabilityRef,
-            fact_ref: null,
-            proof_ref: null,
-            method,
-            proof_surface: resolution.external.proof_surface,
-            evidence_capabilities: capabilityFloor,
-            expected_authority_ref: expectedAuthorityRef,
-            confirmation_ref: confirmationRef,
-            required_polarity: requiredPolarity,
-            completion_role: "blocking",
-            acceptance_effect: "required",
-            semantic_identity: resolution.external.semantic_identity ?? null,
-            machine_obligation_ref: null,
-        });
-        rows.push(pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, resolution.external.proof_surface, capabilityFloor, confirmationRef));
-        return;
-    }
-    if (resolution.status === "machine_admitted") {
-        const machine = resolution.machine;
-        rows.push({
-            obligation_ref: sourceObligationRef,
-            source_obligation_ref: sourceObligationRef,
-            outcome_key: outcomeKey,
-            claim_ref: fullClaim,
-            applicability_ref: applicabilityRef,
-            fact_ref: null,
-            proof_ref: null,
-            method,
-            proof_surface: machine.proof_surface,
-            required_evidence_capabilities: machine.required_evidence_capabilities,
-            authority: "machine",
-            confirmation_ref: null,
-            status: "machine_admitted",
-            reason: null,
-            session_group: null,
-        });
-        return;
-    }
-    rows.push({
-        ...pendingExternalRow(sourceObligationRef, outcomeKey, fullClaim, applicabilityRef, null, null, method, surface, capabilityFloor, null),
-        authority: "none",
-        status: "unreachable",
-        reason: resolution.reason,
-    });
-}

package/dist/lib/long-task-acceptance-reachability-design.d.ts

@@ -1,2 +0,0 @@
-import type { AcceptanceObligationReachabilityV1, AcceptanceReachabilityInputV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
-export declare function compileDesignFactReachability(input: AcceptanceReachabilityInputV1, rows: AcceptanceObligationReachabilityV1[], external: ExpectedExternalObligation[]): void;

package/dist/lib/long-task-acceptance-reachability-design.js

@@ -1,96 +0,0 @@
-import { designFactObligationDescriptors, externalDesignObligationMatches, } from "./long-task-design-obligation.js";
-import { pendingExternalRow } from "./long-task-acceptance-reachability-helpers.js";
-import { resolveObligationAuthority } from "./long-task-obligation-authority-resolution.js";
-export function compileDesignFactReachability(input, rows, external) {
-    const seen = new Set();
-    for (const descriptor of designFactObligationDescriptors(input.contract)) {
-        if (seen.has(descriptor.source_obligation_ref))
-            throw new Error(`design_obligation_identity_duplicate:${descriptor.source_obligation_ref}`);
-        seen.add(descriptor.source_obligation_ref);
-        const machineCandidates = admittedDesignMachineRoutes(input, descriptor);
-        const externalCandidates = input.contract.global.acceptance.external_confirmations
-            .filter((confirmation) => confirmation.blocks_target &&
-            confirmation.obligations?.some((obligation) => externalDesignObligationMatches(obligation, descriptor)))
-            .map((confirmation) => ({
-            confirmation_ref: confirmation.key,
-            proof_surface: descriptor.proof_surface,
-            method: descriptor.method,
-            required_evidence_capabilities: descriptor.evidence_capabilities,
-        }));
-        const resolution = resolveObligationAuthority({
-            source_obligation_ref: descriptor.source_obligation_ref,
-            proof_surface_selection: "required",
-            machine_candidates: machineCandidates,
-            external_candidates: externalCandidates,
-        });
-        if (resolution.status === "machine_admitted") {
-            rows.push({
-                obligation_ref: descriptor.source_obligation_ref,
-                source_obligation_ref: descriptor.source_obligation_ref,
-                outcome_key: descriptor.outcome_key,
-                claim_ref: descriptor.claim_ref,
-                applicability_ref: descriptor.applicability_ref,
-                fact_ref: descriptor.fact_ref,
-                proof_ref: descriptor.source_obligation_ref,
-                method: descriptor.method,
-                proof_surface: descriptor.proof_surface,
-                required_evidence_capabilities: descriptor.evidence_capabilities,
-                authority: "machine",
-                confirmation_ref: null,
-                status: "machine_admitted",
-                reason: null,
-                session_group: null,
-            });
-            continue;
-        }
-        if (resolution.status === "external_candidate") {
-            const expected = {
-                source_obligation_ref: descriptor.source_obligation_ref,
-                outcome_key: descriptor.outcome_key,
-                claim_ref: descriptor.claim_ref,
-                local_claim_ref: descriptor.local_claim_ref,
-                applicability_ref: descriptor.applicability_ref,
-                fact_ref: descriptor.fact_ref,
-                proof_ref: descriptor.source_obligation_ref,
-                method: descriptor.method,
-                proof_surface: descriptor.proof_surface,
-                evidence_capabilities: descriptor.evidence_capabilities,
-                expected_authority_ref: descriptor.expected_authority_ref,
-                confirmation_ref: resolution.external.confirmation_ref,
-                required_polarity: "positive",
-                completion_role: "blocking",
-                acceptance_effect: "required",
-                semantic_identity: null,
-                machine_obligation_ref: null,
-            };
-            external.push(expected);
-            rows.push(pendingExternalRow(descriptor.source_obligation_ref, descriptor.outcome_key, descriptor.claim_ref, descriptor.applicability_ref, descriptor.fact_ref, descriptor.source_obligation_ref, descriptor.method, descriptor.proof_surface, descriptor.evidence_capabilities, expected.confirmation_ref));
-            continue;
-        }
-        rows.push({
-            ...pendingExternalRow(descriptor.source_obligation_ref, descriptor.outcome_key, descriptor.claim_ref, descriptor.applicability_ref, descriptor.fact_ref, descriptor.source_obligation_ref, descriptor.method, descriptor.proof_surface, descriptor.evidence_capabilities, null),
-            authority: "none",
-            reason: resolution.reason === "no_admitted_proof_route"
-                ? "machine_observer_not_admitted"
-                : resolution.reason,
-        });
-    }
-}
-function admittedDesignMachineRoutes(input, descriptor) {
-    return input.compiled_checks.flatMap((check) => check.outcome_key === descriptor.outcome_key &&
-        check.key === descriptor.check_key &&
-        check.completion_role === "semantic" &&
-        check.observation_authorities.some((authority) => authority.obligation_ref === descriptor.source_obligation_ref &&
-            authority.assertion_ref === descriptor.assertion_ref &&
-            authority.authority !== "external_confirmation")
-        ? [
-            {
-                check_key: check.key,
-                assertion_key: descriptor.assertion_ref,
-                proof_surface: descriptor.proof_surface,
-                method: descriptor.method,
-                required_evidence_capabilities: descriptor.evidence_capabilities,
-            },
-        ]
-        : []);
-}

package/dist/lib/long-task-acceptance-reachability-external.d.ts

@@ -1,9 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-import type { AcceptanceObligationReachabilityV1, ExpectedExternalObligation } from "./long-task-acceptance-reachability-types.js";
-export declare function validateExternalDeclarations(contract: DeliveryContractV2, manifest: SemanticFactManifestV1, expected: ExpectedExternalObligation[], compiledChecks: readonly CompiledCheckV2[]): Map<string, {
-    obligation_key: string;
-    session_group: string;
-}>;
-export declare function addUnboundBlockingConfirmationRows(contract: DeliveryContractV2, rows: AcceptanceObligationReachabilityV1[], expected: ExpectedExternalObligation[]): void;