project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-source-target-index.js

@@ -1,91 +0,0 @@
-import { controlFieldFacts } from "./long-task-control-fields.js";
-import { normalizeSourceItemText } from "./long-task-source-item-parser.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function buildCanonicalSourceTargetIndex(contract) {
-    const targets = [];
-    for (const executionTarget of contract.task.execution_targets)
-        targets.push({
-            ...target(executionTargetSourceTargetRef(executionTarget.key), "technical_obligation", executionTargetSourceStatement(executionTarget)),
-            execution_target_ref: executionTarget.key,
-        });
-    for (const outcome of contract.outcomes) {
-        targets.push(target(`${outcome.key}.result`, "outcome_result", outcome.product.observable_result, outcome.key));
-        for (const requirement of outcome.product.requirements)
-            targets.push(target(`${outcome.key}.requirement.${requirement.key}`, "requirement", requirement.statement, outcome.key));
-        for (const binding of outcome.semantic_fact_bindings.facts)
-            targets.push(target(`${outcome.key}.${binding.claim_ref}`, "semantic_fact", undefined, outcome.key));
-        for (const control of outcome.product.controls)
-            for (const field of controlFieldFacts(control))
-                targets.push(target(`${outcome.key}.control.${control.key}.${field.claim_field}`, "control", field.statement, outcome.key));
-        if (outcome.product.control_relation_closure.state !== "unresolved")
-            targets.push(target(`${outcome.key}.control_relation_closure`, "control", outcome.product.control_relation_closure.statement, outcome.key));
-        for (const relation of outcome.product.control_relations)
-            targets.push(target(`${outcome.key}.control_relation.${relation.key}`, "control", relation.statement, outcome.key));
-        for (const obligation of outcome.technical.obligations)
-            targets.push(target(`${outcome.key}.obligation.${obligation.key}`, "technical_obligation", obligation.statement, outcome.key));
-        for (const item of outcome.product.non_completing_outcomes)
-            targets.push(target(`${outcome.key}.non_completing.${item.key}`, "non_completing", item.statement, outcome.key));
-        for (const shortcut of outcome.technical.forbidden_shortcuts)
-            targets.push(target(`${outcome.key}.forbidden_shortcut.${shortcut.key}`, "forbidden_shortcut", shortcut.statement, outcome.key));
-        for (const check of outcome.acceptance.checks)
-            for (const assertion of [
-                ...check.positive_assertions,
-                ...check.negative_assertions,
-            ])
-                targets.push(target(`${outcome.key}.${check.key}.${assertion.key}`, "acceptance", assertion.criterion, outcome.key, "outcome"));
-    }
-    for (const item of contract.global.product.non_goals)
-        targets.push(target(`non_goal.${item.key}`, "non_goal", item.statement));
-    for (const item of contract.global.technical.constraints)
-        targets.push(target(`constraint.${item.key}`, "global_constraint", item.statement));
-    for (const item of contract.global.technical.forbidden_shortcuts)
-        targets.push(target(`forbidden_shortcut.${item.key}`, "forbidden_shortcut", item.statement));
-    for (const check of contract.global.acceptance.checks)
-        for (const assertion of [
-            ...check.positive_assertions,
-            ...check.negative_assertions,
-        ])
-            targets.push(target(`GLOBAL.${check.key}.${assertion.key}`, "acceptance", assertion.criterion, undefined, "global"));
-    for (const [fact, outcomes] of Object.entries(contract.risk.facts))
-        for (const outcome of outcomes)
-            targets.push({
-                ref: `${fact}:${outcome}`,
-                kind: "risk_fact",
-                risk_fact: fact,
-                affected_outcome: outcome,
-            });
-    for (const item of contract.global.acceptance.external_confirmations)
-        targets.push(target(item.key, "external_confirmation", item.description));
-    return new Map(targets.map((item) => [item.ref, item]));
-}
-export function executionTargetSourceTargetRef(targetKey) {
-    return `execution_target.${targetKey}`;
-}
-export function executionTargetSourceStatement(targetValue) {
-    return `Execution target authority: ${canonicalValueJson({
-        key: targetValue.key,
-        role: targetValue.role,
-        runtime_family: targetValue.runtime_family,
-        root_entrypoint: targetValue.root_entrypoint,
-        root_argv: [...(targetValue.root_argv ?? [])],
-        capabilities: [...new Set(targetValue.capabilities)].sort(),
-    })}.`;
-}
-function target(ref, kind, text, outcomeKey, scope) {
-    return {
-        ref,
-        kind,
-        ...(text !== undefined
-            ? { normalized_text: normalizeSourceItemText(text) }
-            : {}),
-        ...(outcomeKey ? { outcome_key: outcomeKey } : {}),
-        ...(scope ? { scope } : {}),
-    };
-}
-export function sourceKindForTarget(target) {
-    return target.kind === "global_constraint"
-        ? "technical_obligation"
-        : target.kind === "semantic_fact"
-            ? null
-            : target.kind;
-}

package/dist/lib/long-task-source-validation.d.ts

@@ -1,3 +0,0 @@
-import type { SourceClaimV2 } from "./long-task-delivery-types.js";
-export declare function validateSourceAnchors(repository: string, sourceClaims: SourceClaimV2[]): Promise<void>;
-export declare function markdownAnchors(content: string): Set<string>;

package/dist/lib/long-task-source-validation.js

@@ -1,46 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-export async function validateSourceAnchors(repository, sourceClaims) {
-    const anchorsByFile = new Map();
-    for (const [index, claim] of sourceClaims.entries()) {
-        const [relative, anchor] = claim.source_ref.split("#");
-        if (!anchor)
-            continue;
-        let anchors = anchorsByFile.get(relative);
-        if (!anchors) {
-            const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), `source[${index}]`);
-            anchors = markdownAnchors(await readFile(file, "utf8"));
-            anchorsByFile.set(relative, anchors);
-        }
-        if (!anchors.has(anchor))
-            throw new Error(`source_claim_anchor_not_found:${claim.key}:${claim.source_ref}`);
-    }
-}
-export function markdownAnchors(content) {
-    const anchors = new Set();
-    const slugCounts = new Map();
-    for (const line of content.split(/\r?\n/u)) {
-        const heading = /^(?: {0,3})#{1,6}\s+(.+?)\s*#*\s*$/u.exec(line);
-        if (heading) {
-            const base = githubSlug(heading[1]);
-            if (base) {
-                const count = slugCounts.get(base) ?? 0;
-                anchors.add(count === 0 ? base : `${base}-${count}`);
-                slugCounts.set(base, count + 1);
-            }
-        }
-        for (const match of line.matchAll(/(?:\{#([A-Za-z0-9._:-]+)\}|(?:id|name)=["']([^"']+)["'])/gu))
-            anchors.add(match[1] ?? match[2]);
-    }
-    return anchors;
-}
-function githubSlug(value) {
-    return value
-        .trim()
-        .toLowerCase()
-        .replace(/<[^>]*>/gu, "")
-        .replace(/[^\p{L}\p{N}\s_-]/gu, "")
-        .replace(/\s+/gu, "-")
-        .replace(/-+/gu, "-");
-}

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

@@ -1,4 +0,0 @@
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-type Reporter = (message: string) => void;
-export declare function validateDeliveryStages(contract: DeliveryContractV2, report?: Reporter): void;
-export {};

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

@@ -1,126 +0,0 @@
-import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
-export function validateDeliveryStages(contract, report) {
-    unique(contract.stages.map((stage) => stage.key), "stage_key_duplicate", report);
-    const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
-    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
-    for (const stage of contract.stages) {
-        for (const dependency of stage.depends_on) {
-            if (dependency === stage.key)
-                issue(report, "stage_dependency_self", stage.key);
-            else if (!stages.has(dependency))
-                issue(report, "stage_dependency_unknown", `${stage.key}:${dependency}`);
-        }
-        const gate = outcomes.get(stage.gate_outcome);
-        if (!gate)
-            issue(report, "stage_gate_outcome_unknown", `${stage.key}:${stage.gate_outcome}`);
-        else if (gate.stage !== stage.key)
-            issue(report, "stage_gate_outcome_mismatch", `${stage.key}:${gate.key}`);
-    }
-    for (const outcome of contract.outcomes)
-        if (!stages.has(outcome.stage))
-            issue(report, "outcome_stage_unknown", `${outcome.key}:${outcome.stage}`);
-    validateStageCycles(contract, report);
-    validateStageGateClosure(contract, report);
-}
-function validateStageCycles(contract, report) {
-    const stages = new Map(contract.stages.map((stage) => [stage.key, stage]));
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (key) => {
-        if (visiting.has(key)) {
-            issue(report, "stage_dependency_cycle", key);
-            return;
-        }
-        if (visited.has(key))
-            return;
-        visiting.add(key);
-        for (const dependency of stages.get(key)?.depends_on ?? [])
-            if (stages.has(dependency))
-                visit(dependency);
-        visiting.delete(key);
-        visited.add(key);
-    };
-    for (const stage of stages.keys())
-        visit(stage);
-}
-function validateStageGateClosure(contract, report) {
-    const outcomes = new Map(contract.outcomes.map((outcome) => [outcome.key, outcome]));
-    for (const stage of contract.stages) {
-        const gate = outcomes.get(stage.gate_outcome);
-        if (!gate || gate.stage !== stage.key)
-            continue;
-        for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key && candidate.key !== gate.key))
-            if (!outcomeDependsOn(gate.key, outcome.key, outcomes))
-                issue(report, "stage_gate_missing_outcome_dependency", `${stage.key}:${gate.key}:${outcome.key}`);
-        for (const dependency of stage.depends_on) {
-            const dependencyGate = contract.stages.find((candidate) => candidate.key === dependency)?.gate_outcome;
-            if (!dependencyGate)
-                continue;
-            for (const outcome of contract.outcomes.filter((candidate) => candidate.stage === stage.key))
-                if (!outcomeDependsOn(outcome.key, dependencyGate, outcomes))
-                    issue(report, "stage_outcome_missing_gate_dependency", `${stage.key}:${outcome.key}:${dependencyGate}`);
-        }
-        const stageGateChecks = gate.acceptance.checks.filter((check) => check.journey_roles.includes("stage_gate"));
-        const resultExternallyBlocked = outcomeResultExternallyBlocked(contract, gate.key);
-        if (!stageGateChecks.length && !resultExternallyBlocked)
-            issue(report, "stage_gate_check_required", `${stage.key}:${gate.key}`);
-        else if (!resultExternallyBlocked &&
-            !stageGateChecks.some((check) => provesGate(check, gate)))
-            issue(report, "stage_gate_target_runtime_result_required", `${stage.key}:${gate.key}`);
-        for (const targetRef of resultExternallyBlocked
-            ? []
-            : contract.task.target_profile.required_target_refs)
-            if (!stageGateChecks.some((check) => check.execution_target.target_ref === targetRef &&
-                check.execution_target.entrypoint === "root" &&
-                provesGate(check, gate)))
-                issue(report, "stage_gate_required_target_proof_missing", `${stage.key}:${targetRef}`);
-        const stageOutcomes = contract.outcomes.filter((candidate) => candidate.stage === stage.key);
-        if (!resultExternallyBlocked &&
-            stageOutcomes.length > 1 &&
-            !stageGateChecks.some((check) => [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("cross_surface_consistency"))))
-            issue(report, "stage_gate_cross_surface_consistency_required", `${stage.key}:${stageOutcomes.map((outcome) => outcome.key).join(",")}`);
-    }
-    for (const outcome of contract.outcomes)
-        for (const check of outcome.acceptance.checks)
-            if (check.journey_roles.includes("stage_gate") &&
-                !contract.stages.some((stage) => stage.gate_outcome === outcome.key))
-                issue(report, "stage_gate_role_on_non_gate", `${outcome.key}:${check.key}`);
-}
-function provesGate(check, gate) {
-    const assertions = [
-        ...check.positive_assertions,
-        ...check.negative_assertions,
-    ];
-    const provesResult = assertions.some((assertion) => assertion.claims.includes("result")) ||
-        (gate.acceptance.population?.check_key === check.key &&
-            gate.acceptance.population.claims.includes("result"));
-    return (provesResult &&
-        assertions.some((assertion) => assertion.evidence_capabilities.includes("target_runtime")));
-}
-function outcomeDependsOn(start, target, outcomes) {
-    const seen = new Set();
-    const visit = (key) => {
-        if (key === target)
-            return true;
-        if (seen.has(key))
-            return false;
-        seen.add(key);
-        return (outcomes.get(key)?.depends_on ?? []).some(visit);
-    };
-    return visit(start);
-}
-function unique(values, code, report) {
-    const seen = new Set();
-    for (const value of values) {
-        if (seen.has(value))
-            issue(report, code, value);
-        seen.add(value);
-    }
-}
-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-state.d.ts

@@ -1,79 +0,0 @@
-import type { CompiledDeliveryContractV2, FinalReceiptV2, InitialTaskBaseV2, ProgressRecordV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
-import type { AuthorityRevisionProposalV2 } from "./long-task-authority-revision-types.js";
-export interface ActiveLongTaskAuthorityV3 {
-    schema_version: "active-long-task-authority-v3";
-    task_id: string;
-    repository_root: string;
-    worktree_identity: string;
-    workdir: string;
-    active_authority_identity: string;
-    authority_revision: number;
-    initial_task_base: InitialTaskBaseV2;
-    verifier_identity: VerifierIdentityV2;
-    activated_at: string;
-    authority_snapshot: CompiledDeliveryContractV2;
-    authority_snapshot_sha256: string;
-}
-export type CompiledCacheStatusV3 = "compiled_cache_matching" | "compiled_cache_missing_repairable" | "compiled_cache_mismatched_ignored";
-export interface ActiveAuthorityLoadResultV3 {
-    authority: ActiveLongTaskAuthorityV3 | null;
-    source: "none" | "active_authority_v3";
-    migrated: boolean;
-}
-export type ActiveAuthorityLockOperation = "commit" | "clear" | "abandon" | "migrate";
-export interface ActiveAuthorityIdentityExpectation {
-    task_id: string;
-    authority_revision: number;
-    compiled_identity: string;
-    worktree_identity?: string;
-}
-export interface ClearActiveBindingCasOptions extends ActiveAuthorityIdentityExpectation {
-    repository_root: string;
-    workdir: string;
-}
-export interface StagedCompiledDeliveryContractV2 {
-    publish(): Promise<void>;
-    discard(): Promise<void>;
-}
-export interface PendingAuthorityRevisionV2 extends AuthorityRevisionProposalV2 {
-    schema_version: "long-task-authority-revision-pending-v2";
-    created_at: string;
-}
-export declare function runtimePath(workdir: string, file?: string): string;
-export declare function worktreeIdentity(repositoryRoot: string): string;
-export declare function activeRecordPath(repositoryRoot: string): Promise<string>;
-export declare function activeAuthorityLockPath(repositoryRoot: string): Promise<string>;
-export declare function activeAuthorityLockExists(repositoryRoot: string): Promise<boolean>;
-export declare function withActiveAuthorityLock<T>(repositoryRoot: string, operation: ActiveAuthorityLockOperation, action: () => Promise<T>): Promise<T>;
-export declare function writeCompiledDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<void>;
-export declare function stageCompiledDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<StagedCompiledDeliveryContractV2>;
-export declare function readCompiledDeliveryContract(workdir: string): Promise<CompiledDeliveryContractV2>;
-export declare function loadActiveLongTaskAuthority(repositoryRoot: string, _options?: {
-    migrate_legacy?: boolean;
-}): Promise<ActiveAuthorityLoadResultV3>;
-export declare function loadActiveCompiledAuthority(repositoryRoot: string, workdir?: string, options?: {
-    migrate_legacy?: boolean;
-}): Promise<CompiledDeliveryContractV2 | null>;
-export declare function readActiveLongTaskBinding(repositoryRoot: string): Promise<ActiveLongTaskAuthorityV3 | null>;
-export declare function inspectCompiledCache(authority: ActiveLongTaskAuthorityV3): Promise<CompiledCacheStatusV3>;
-export declare function commitActiveAuthority(options: {
-    candidate: CompiledDeliveryContractV2;
-    expected_previous_identity: string | null;
-}): Promise<ActiveLongTaskAuthorityV3>;
-export declare function activateDeliveryContract(compiled: CompiledDeliveryContractV2): Promise<ActiveLongTaskAuthorityV3>;
-export declare function assertMatchingActiveBinding(compiled: CompiledDeliveryContractV2): Promise<ActiveLongTaskAuthorityV3>;
-export declare function writeProgressRecord(workdir: string, record: ProgressRecordV2): Promise<void>;
-export declare function readProgressRecords(workdir: string): Promise<Record<string, ProgressRecordV2>>;
-export declare function writePendingAuthorityRevision(workdir: string, pending: PendingAuthorityRevisionV2): Promise<void>;
-export declare function readPendingAuthorityRevision(workdir: string): Promise<PendingAuthorityRevisionV2 | null>;
-export declare function approvePendingAuthorityRevision(workdir: string, revision: string): Promise<void>;
-export declare function authorityRevisionApproved(workdir: string, revision: string): Promise<boolean>;
-export declare function clearAuthorityRevision(workdir: string): Promise<void>;
-export declare function invalidateDerivedProgress(workdir: string): Promise<void>;
-export declare function writeFinalReceipt(repositoryRoot: string, workdir: string, unsigned: Omit<FinalReceiptV2, "receipt_sha256">): Promise<FinalReceiptV2>;
-export declare function readFinalReceipt(_repositoryRoot: string, workdir: string): Promise<FinalReceiptV2 | null>;
-export declare function activeAuthorityIdentityMatches(authority: ActiveLongTaskAuthorityV3, expected: ActiveAuthorityIdentityExpectation): boolean;
-export declare function clearActiveBindingCas(options: ClearActiveBindingCasOptions): Promise<boolean>;
-export declare function abandonLongTaskState(repositoryRoot: string, workdir: string): Promise<void>;
-export declare function forceClearCorruptActiveState(repositoryRoot: string, workdir: string): Promise<void>;
-export declare function clearFinalReceipt(repositoryRoot: string, workdir: string): Promise<void>;