project-tiny-context-harness 0.8.0 → 0.8.2

package/dist/lib/long-task-source-item-parser.js

@@ -1,112 +1,158 @@
-import { RISK_FACT_NAMES } from "./long-task-risk-types.js";
-import { sha256Hex } from "./strict-codec.js";
-const KINDS = new Set([
-    "outcome_result",
-    "requirement",
-    "control",
-    "acceptance",
-    "technical_obligation",
-    "non_completing",
-    "non_goal",
-    "forbidden_shortcut",
-    "risk_fact",
-    "external_confirmation",
-    "decision",
-]);
-const RISK_FACTS = new Set(RISK_FACT_NAMES);
-const START = /^\s*<!--\s*ty-source-item:start\s+(.+?)\s*-->\s*$/u;
-const END = /^\s*<!--\s*ty-source-item:end\s*-->\s*$/u;
+import { parseDesignResourceHandoffShape } from "./design-resource-handoff-shape.js";
+import { normalizeSourceItemText, parseSourceBackgroundMarker, parseSourceItemStartMarker, SOURCE_BACKGROUND_END, SOURCE_BACKGROUND_START, SOURCE_ITEM_END, SOURCE_ITEM_START, validateSourceBackgroundLine, } from "./long-task-source-markers.js";
+import { parseStrictYaml, sha256Hex } from "./strict-codec.js";
+const DESIGN_RESOURCE_START = /^\s*```yaml[ \t]+design-resource-handoff-v1[ \t]*$/u;
+const FORMAL_BLOCK_END = /^\s*```[ \t]*$/u;
 export function parseSourceItems(sourcePath, content) {
-    const items = [];
-    const seen = new Set();
-    let open = null;
+    const state = sourceParseState(sourcePath);
     const lines = content.replace(/\r\n?/gu, "\n").split("\n");
-    for (const [index, line] of lines.entries()) {
-        const start = START.exec(line);
-        if (start) {
-            if (open)
-                throw new Error(`source_item_nested_or_overlapping:${sourcePath}:${open.key}:${index + 1}`);
-            const marker = parseStartMarker(sourcePath, index + 1, start[1]);
-            open = { ...marker, lines: [], line: index + 1 };
-            continue;
-        }
-        if (END.test(line)) {
-            if (!open)
-                throw new Error(`source_item_end_without_start:${sourcePath}:${index + 1}`);
-            const normalizedText = normalizeSourceItemText(open.lines.join("\n"));
-            if (!normalizedText)
-                throw new Error(`source_item_empty:${sourcePath}:${open.key}`);
-            if (seen.has(open.key))
-                throw new Error(`source_item_key_duplicate:${open.key}`);
-            seen.add(open.key);
-            items.push({
-                key: open.key,
-                kind: open.kind,
-                source_path: sourcePath,
-                normalized_text: normalizedText,
-                text_sha256: sha256Hex(normalizedText),
-                ...(open.risk_semantics ? { risk_semantics: open.risk_semantics } : {}),
-            });
-            open = null;
-            continue;
-        }
-        if (line.includes("ty-source-item:start") ||
-            line.includes("ty-source-item:end"))
-            throw new Error(`source_item_marker_invalid:${sourcePath}:${index + 1}`);
-        if (open)
-            open.lines.push(line);
-    }
-    if (open)
-        throw new Error(`source_item_unclosed:${sourcePath}:${open.key}:${open.line}`);
-    return items;
+    for (const [index, line] of lines.entries())
+        consumeSourceLine(state, line, index + 1);
+    assertSourceSectionsClosed(state);
+    return state.items;
+}
+function sourceParseState(sourcePath) {
+    return {
+        sourcePath,
+        items: [],
+        seen: new Set(),
+        seenBackground: new Set(),
+        open: null,
+        background: null,
+        formalBlock: null,
+        designResourceBlocks: 0,
+    };
 }
-function parseStartMarker(sourcePath, line, declaration) {
-    const attributes = new Map();
-    for (const token of declaration.trim().split(/\s+/u)) {
-        const match = /^([a-z_]+)=([^\s=]+)$/u.exec(token);
-        if (!match)
-            throw new Error(`source_item_marker_invalid:${sourcePath}:${line}`);
-        if (attributes.has(match[1]))
-            throw new Error(`source_item_marker_attribute_duplicate:${sourcePath}:${line}:${match[1]}`);
-        attributes.set(match[1], match[2]);
+function consumeSourceLine(state, line, lineNumber) {
+    if (consumeOpenFormalBlock(state, line))
+        return;
+    if (startFormalBlock(state, line, lineNumber))
+        return;
+    if (consumeSourceItemBoundary(state, line, lineNumber))
+        return;
+    if (consumeBackgroundBoundary(state, line, lineNumber))
+        return;
+    consumeOwnedText(state, line, lineNumber);
+}
+function consumeOpenFormalBlock(state, line) {
+    if (!state.formalBlock)
+        return false;
+    if (!FORMAL_BLOCK_END.test(line)) {
+        state.formalBlock.lines.push(line);
+        return true;
     }
-    for (const name of attributes.keys())
-        if (!["key", "kind", "fact", "outcome"].includes(name))
-            throw new Error(`source_item_marker_attribute_unknown:${sourcePath}:${line}:${name}`);
-    const key = attributes.get("key") ?? "";
-    const kind = (attributes.get("kind") ?? "");
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(key) || !KINDS.has(kind))
-        throw new Error(`source_item_marker_invalid:${sourcePath}:${line}`);
-    const fact = attributes.get("fact");
-    const outcome = attributes.get("outcome");
-    if (kind !== "risk_fact") {
-        if (fact !== undefined || outcome !== undefined)
-            throw new Error(`source_item_marker_attributes_forbidden:${sourcePath}:${key}:${kind}`);
-        return { key, kind };
+    try {
+        parseDesignResourceHandoffShape(parseStrictYaml(state.formalBlock.lines.join("\n")));
     }
-    if (!fact || !outcome)
-        throw new Error(`source_item_risk_semantics_required:${sourcePath}:${key}`);
-    if (!RISK_FACTS.has(fact))
-        throw new Error(`source_item_risk_fact_invalid:${sourcePath}:${key}:${fact}`);
-    if (!/^[a-z0-9][a-z0-9-]*$/u.test(outcome))
-        throw new Error(`source_item_risk_outcome_invalid:${sourcePath}:${key}:${outcome}`);
-    return {
-        key,
-        kind,
-        risk_semantics: {
-            fact: fact,
-            affected_outcome: outcome,
-        },
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`source_formal_block_invalid:${state.sourcePath}:${state.formalBlock.line}:${message}`);
+    }
+    state.formalBlock = null;
+    return true;
+}
+function startFormalBlock(state, line, lineNumber) {
+    if (!DESIGN_RESOURCE_START.test(line))
+        return false;
+    assertNoOpenOwnedSection(state, lineNumber);
+    state.designResourceBlocks += 1;
+    if (state.designResourceBlocks > 1)
+        throw new Error(`source_formal_block_duplicate:${state.sourcePath}:design-resource-handoff-v1`);
+    state.formalBlock = {
+        owner: "design-resource-handoff-v1",
+        lines: [],
+        line: lineNumber,
     };
+    return true;
+}
+function consumeSourceItemBoundary(state, line, lineNumber) {
+    const start = SOURCE_ITEM_START.exec(line);
+    if (start) {
+        assertNoOpenOwnedSection(state, lineNumber);
+        state.open = {
+            ...parseSourceItemStartMarker(state.sourcePath, lineNumber, start[1]),
+            lines: [],
+            line: lineNumber,
+        };
+        return true;
+    }
+    if (!SOURCE_ITEM_END.test(line))
+        return false;
+    if (!state.open)
+        throw new Error(`source_item_end_without_start:${state.sourcePath}:${lineNumber}`);
+    closeSourceItem(state);
+    return true;
+}
+function closeSourceItem(state) {
+    const open = state.open;
+    const normalizedText = normalizeSourceItemText(open.lines.join("\n"));
+    if (!normalizedText)
+        throw new Error(`source_item_empty:${state.sourcePath}:${open.key}`);
+    if (state.seen.has(open.key))
+        throw new Error(`source_item_key_duplicate:${open.key}`);
+    state.seen.add(open.key);
+    state.items.push({
+        key: open.key,
+        kind: open.kind,
+        ...(open.aspect ? { aspect: open.aspect } : {}),
+        source_path: state.sourcePath,
+        normalized_text: normalizedText,
+        text_sha256: sha256Hex(normalizedText),
+        ...(open.risk_semantics ? { risk_semantics: open.risk_semantics } : {}),
+    });
+    state.open = null;
+}
+function consumeBackgroundBoundary(state, line, lineNumber) {
+    const start = SOURCE_BACKGROUND_START.exec(line);
+    if (start) {
+        assertNoOpenOwnedSection(state, lineNumber);
+        const declaration = parseSourceBackgroundMarker(state.sourcePath, lineNumber, start[1]);
+        if (state.seenBackground.has(declaration.key))
+            throw new Error(`source_background_key_duplicate:${declaration.key}`);
+        state.seenBackground.add(declaration.key);
+        state.background = {
+            ...declaration,
+            substantiveLines: 0,
+            line: lineNumber,
+        };
+        return true;
+    }
+    if (!SOURCE_BACKGROUND_END.test(line))
+        return false;
+    if (!state.background)
+        throw new Error(`source_background_end_without_start:${state.sourcePath}:${lineNumber}`);
+    if (!state.background.substantiveLines)
+        throw new Error(`source_background_empty:${state.sourcePath}:${state.background.key}`);
+    state.background = null;
+    return true;
+}
+function assertNoOpenOwnedSection(state, lineNumber) {
+    if (!state.open && !state.background)
+        return;
+    throw new Error(`source_section_nested_or_overlapping:${state.sourcePath}:${state.open?.key ?? state.background?.key}:${lineNumber}`);
+}
+function consumeOwnedText(state, line, lineNumber) {
+    if (line.includes("ty-source-item:start") ||
+        line.includes("ty-source-item:end") ||
+        line.includes("ty-source-background:start") ||
+        line.includes("ty-source-background:end"))
+        throw new Error(`source_item_marker_invalid:${state.sourcePath}:${lineNumber}`);
+    if (state.open)
+        state.open.lines.push(line);
+    else if (state.background) {
+        validateSourceBackgroundLine(state.sourcePath, state.background.key, state.background.reason, lineNumber, line);
+        if (line.trim())
+            state.background.substantiveLines += 1;
+    }
+    else if (line.trim())
+        throw new Error(`source_text_unclassified:${state.sourcePath}:${lineNumber}`);
 }
-export function normalizeSourceItemText(value) {
-    const lines = value
-        .replace(/\r\n?/gu, "\n")
-        .split("\n")
-        .map((line) => line.replace(/[ \t]+$/gu, ""));
-    while (lines.length && !lines[0].trim())
-        lines.shift();
-    while (lines.length && !lines.at(-1).trim())
-        lines.pop();
-    return lines.join("\n");
+function assertSourceSectionsClosed(state) {
+    if (state.open)
+        throw new Error(`source_item_unclosed:${state.sourcePath}:${state.open.key}:${state.open.line}`);
+    if (state.background)
+        throw new Error(`source_background_unclosed:${state.sourcePath}:${state.background.key}:${state.background.line}`);
+    if (state.formalBlock)
+        throw new Error(`source_formal_block_unclosed:${state.sourcePath}:${state.formalBlock.owner}:${state.formalBlock.line}`);
 }
+export { normalizeSourceItemText } from "./long-task-source-markers.js";

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

@@ -0,0 +1,12 @@
+import type { CompiledSourceItemV2 } from "./long-task-delivery-types.js";
+export declare const SOURCE_ITEM_START: RegExp;
+export declare const SOURCE_ITEM_END: RegExp;
+export declare const SOURCE_BACKGROUND_START: RegExp;
+export declare const SOURCE_BACKGROUND_END: RegExp;
+export declare function parseSourceBackgroundMarker(sourcePath: string, line: number, declaration: string): {
+    key: string;
+    reason: string;
+};
+export declare function parseSourceItemStartMarker(sourcePath: string, line: number, declaration: string): Pick<CompiledSourceItemV2, "key" | "kind" | "aspect" | "risk_semantics">;
+export declare function validateSourceBackgroundLine(sourcePath: string, blockKey: string, reason: string, lineNumber: number, value: string): void;
+export declare function normalizeSourceItemText(value: string): string;

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

@@ -0,0 +1,146 @@
+import { RISK_FACT_NAMES } from "./long-task-risk-types.js";
+const KINDS = new Set([
+    "outcome_result",
+    "requirement",
+    "control",
+    "acceptance",
+    "technical_obligation",
+    "non_completing",
+    "non_goal",
+    "forbidden_shortcut",
+    "risk_fact",
+    "external_confirmation",
+    "decision",
+]);
+const RISK_FACTS = new Set(RISK_FACT_NAMES);
+const BACKGROUND_REASONS = new Set(["markdown-structure", "provenance"]);
+export const SOURCE_ITEM_START = /^\s*<!--\s*ty-source-item:start\s+(.+?)\s*-->\s*$/u;
+export const SOURCE_ITEM_END = /^\s*<!--\s*ty-source-item:end\s*-->\s*$/u;
+export const SOURCE_BACKGROUND_START = /^\s*<!--\s*ty-source-background:start\s+(.+?)\s*-->\s*$/u;
+export const SOURCE_BACKGROUND_END = /^\s*<!--\s*ty-source-background:end\s*-->\s*$/u;
+export function parseSourceBackgroundMarker(sourcePath, line, declaration) {
+    const attributes = markerAttributes(sourcePath, line, declaration, "background");
+    for (const name of attributes.keys())
+        if (!["key", "reason"].includes(name))
+            throw new Error(`source_background_marker_attribute_unknown:${sourcePath}:${line}:${name}`);
+    const key = attributes.get("key") ?? "";
+    const reason = attributes.get("reason") ?? "";
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(key) ||
+        !/^[a-z0-9][a-z0-9-]*$/u.test(reason))
+        throw new Error(`source_background_marker_invalid:${sourcePath}:${line}`);
+    if (!BACKGROUND_REASONS.has(reason))
+        throw new Error(`source_background_reason_unknown:${sourcePath}:${line}:${reason}`);
+    return { key, reason };
+}
+export function parseSourceItemStartMarker(sourcePath, line, declaration) {
+    const attributes = markerAttributes(sourcePath, line, declaration, "item");
+    for (const name of attributes.keys())
+        if (!["key", "kind", "aspect", "fact", "outcome"].includes(name))
+            throw new Error(`source_item_marker_attribute_unknown:${sourcePath}:${line}:${name}`);
+    const key = attributes.get("key") ?? "";
+    const kind = (attributes.get("kind") ?? "");
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(key) || !KINDS.has(kind))
+        throw new Error(`source_item_marker_invalid:${sourcePath}:${line}`);
+    return sourceItemMarkerWithRiskSemantics(sourcePath, key, kind, attributes);
+}
+function markerAttributes(sourcePath, line, declaration, marker) {
+    const attributes = new Map();
+    for (const token of declaration.trim().split(/\s+/u)) {
+        const match = /^([a-z_]+)=([^\s=]+)$/u.exec(token);
+        if (!match)
+            throw new Error(`source_${marker}_marker_invalid:${sourcePath}:${line}`);
+        if (attributes.has(match[1]))
+            throw new Error(`source_${marker}_marker_attribute_duplicate:${sourcePath}:${line}:${match[1]}`);
+        attributes.set(match[1], match[2]);
+    }
+    return attributes;
+}
+function sourceItemMarkerWithRiskSemantics(sourcePath, key, kind, attributes) {
+    const fact = attributes.get("fact");
+    const outcome = attributes.get("outcome");
+    const aspect = attributes.get("aspect");
+    if (aspect !== undefined) {
+        if (kind !== "technical_obligation" || aspect !== "architecture")
+            throw new Error(`source_item_aspect_invalid:${sourcePath}:${key}:${kind}:${aspect}`);
+    }
+    if (kind !== "risk_fact") {
+        if (fact !== undefined || outcome !== undefined)
+            throw new Error(`source_item_marker_attributes_forbidden:${sourcePath}:${key}:${kind}`);
+        return {
+            key,
+            kind,
+            ...(aspect === "architecture" ? { aspect } : {}),
+        };
+    }
+    if (aspect !== undefined)
+        throw new Error(`source_item_marker_attributes_forbidden:${sourcePath}:${key}:${kind}`);
+    if (!fact || !outcome)
+        throw new Error(`source_item_risk_semantics_required:${sourcePath}:${key}`);
+    if (!RISK_FACTS.has(fact))
+        throw new Error(`source_item_risk_fact_invalid:${sourcePath}:${key}:${fact}`);
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(outcome))
+        throw new Error(`source_item_risk_outcome_invalid:${sourcePath}:${key}:${outcome}`);
+    return {
+        key,
+        kind,
+        risk_semantics: {
+            fact: fact,
+            affected_outcome: outcome,
+        },
+    };
+}
+export function validateSourceBackgroundLine(sourcePath, blockKey, reason, lineNumber, value) {
+    if (!value.trim())
+        return;
+    const valid = reason === "markdown-structure"
+        ? isMarkdownStructure(value)
+        : reason === "provenance"
+            ? isStructuredProvenance(value)
+            : false;
+    if (!valid)
+        throw new Error(`source_background_content_invalid:${sourcePath}:${blockKey}:${reason}:${lineNumber}`);
+}
+function isMarkdownStructure(value) {
+    return (/^\s*<a\s+(?:id|name)="[A-Za-z0-9_.:-]+"\s*><\/a>\s*$/u.test(value) ||
+        /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/u.test(value));
+}
+function isStructuredProvenance(value) {
+    const declaration = /^\s*<!--\s*ty-source-provenance\s+(.+?)\s*-->\s*$/u.exec(value)?.[1];
+    if (!declaration)
+        return false;
+    const attributes = new Map();
+    for (const token of declaration.split(/\s+/u)) {
+        const match = /^([a-z][a-z0-9_-]*)=([^\s=>]+)$/u.exec(token);
+        if (!match || attributes.has(match[1]))
+            return false;
+        attributes.set(match[1], match[2]);
+    }
+    if ([...attributes.keys()].some((name) => !["input", "mode", "source", "sha256"].includes(name)))
+        return false;
+    const input = attributes.get("input") ?? "";
+    const mode = attributes.get("mode") ?? "";
+    const source = attributes.get("source");
+    const digest = attributes.get("sha256");
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(input))
+        return false;
+    if (!["direct", "derived", "delegated", "evidence-backed"].includes(mode))
+        return false;
+    if (mode !== "direct" && !source)
+        return false;
+    if (source && !/^[a-z0-9][a-z0-9-]*$/u.test(source))
+        return false;
+    if (digest && !/^[a-f0-9]{64}$/u.test(digest))
+        return false;
+    return true;
+}
+export function normalizeSourceItemText(value) {
+    const lines = value
+        .replace(/\r\n?/gu, "\n")
+        .split("\n")
+        .map((line) => line.replace(/[ \t]+$/gu, ""));
+    while (lines.length && !lines[0].trim())
+        lines.shift();
+    while (lines.length && !lines.at(-1).trim())
+        lines.pop();
+    return lines.join("\n");
+}

package/dist/lib/long-task-source-target-continuity.d.ts

@@ -1,4 +1,4 @@
 import type { CompiledSourceItemV2, DeliveryContractV2 } from "./long-task-delivery-types.js";
-export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): void;
 type ValidationReporter = (message: string) => void;
+export declare function validateSourceTargetContinuity(contract: DeliveryContractV2, items: CompiledSourceItemV2[], report?: ValidationReporter): void;
 export {};

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

@@ -1,71 +1,96 @@
 import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
 import { buildCanonicalSourceTargetIndex, sourceKindForTarget, } from "./long-task-source-target-index.js";
 export function validateSourceTargetContinuity(contract, items, report) {
-    const itemByKey = new Map(items.map((item) => [item.key, item]));
-    const targets = buildCanonicalSourceTargetIndex(contract);
-    const owners = new Map();
-    const sourceBackedOutcomeClaims = new Set();
-    const sourceBackedGlobalClaims = new Set();
-    const acceptanceBindings = [];
-    for (const claim of contract.source_claims) {
-        const item = itemByKey.get(claim.key);
-        if (!item || claim.disposition.type === "decision_required")
-            continue;
-        const refs = dispositionRefs(claim.disposition);
-        if (refs.length !== 1) {
-            issue(report, `source_claim_target_ref_count:${claim.key}:${refs.length}`);
-            continue;
-        }
-        const ref = refs[0];
-        const target = targets.get(ref);
-        if (!target || sourceKindForTarget(target) !== item.kind) {
-            issue(report, `source_target_kind_mismatch:${claim.key}:${item.kind}:${target ? sourceKindForTarget(target) : "unknown"}:${ref}`);
-            continue;
-        }
-        if (item.kind === "risk_fact" &&
-            (target.risk_fact !== item.risk_semantics?.fact ||
-                target.affected_outcome !== item.risk_semantics?.affected_outcome)) {
-            issue(report, `source_risk_target_mismatch:${claim.key}:${item.risk_semantics?.fact ?? "missing"}:${item.risk_semantics?.affected_outcome ?? "missing"}:${ref}`);
-            continue;
-        }
-        if (target.normalized_text !== undefined &&
-            target.normalized_text !== item.normalized_text) {
-            issue(report, `source_target_statement_mismatch:${claim.key}:${ref}`);
-            continue;
-        }
-        const owner = owners.get(ref);
-        if (owner) {
-            issue(report, `source_target_already_owned:${claim.key}:${ref}:${owner}`);
-            continue;
-        }
-        owners.set(ref, claim.key);
-        if (target.outcome_key &&
-            [
-                "requirement",
-                "control",
-                "technical_obligation",
-                "non_completing",
-                "forbidden_shortcut",
-            ].includes(target.kind))
-            sourceBackedOutcomeClaims.add(ref);
-        if (!target.outcome_key &&
-            ["global_constraint", "non_goal", "forbidden_shortcut"].includes(target.kind))
-            sourceBackedGlobalClaims.add(ref);
-        if (target.kind === "acceptance")
-            acceptanceBindings.push({ claim, target });
+    const state = sourceContinuityState(contract, items);
+    for (const claim of contract.source_claims)
+        validateSourceClaimContinuity(claim, state, report);
+    validateAcceptanceBindingContinuity(contract, state, report);
+    validateArchitectureContinuity(state, report);
+}
+function sourceContinuityState(contract, items) {
+    return {
+        itemByKey: new Map(items.map((item) => [item.key, item])),
+        targets: buildCanonicalSourceTargetIndex(contract),
+        owners: new Map(),
+        sourceBackedOutcomeClaims: new Set(),
+        sourceBackedGlobalClaims: new Set(),
+        acceptanceBindings: [],
+        architectureItems: new Set(items
+            .filter((item) => item.aspect === "architecture")
+            .map((item) => item.key)),
+        ownedArchitectureItems: new Set(),
+    };
+}
+function validateSourceClaimContinuity(claim, state, report) {
+    const item = state.itemByKey.get(claim.key);
+    if (!item || claim.disposition.type === "decision_required")
+        return;
+    const refs = dispositionRefs(claim.disposition);
+    if (refs.length !== 1) {
+        issue(report, `source_claim_target_ref_count:${claim.key}:${refs.length}`);
+        return;
+    }
+    const ref = refs[0];
+    const target = state.targets.get(ref);
+    if (!target || sourceKindForTarget(target) !== item.kind) {
+        issue(report, `source_target_kind_mismatch:${claim.key}:${item.kind}:${target ? sourceKindForTarget(target) : "unknown"}:${ref}`);
+        return;
+    }
+    if (item.kind === "risk_fact" &&
+        (target.risk_fact !== item.risk_semantics?.fact ||
+            target.affected_outcome !== item.risk_semantics?.affected_outcome)) {
+        issue(report, `source_risk_target_mismatch:${claim.key}:${item.risk_semantics?.fact ?? "missing"}:${item.risk_semantics?.affected_outcome ?? "missing"}:${ref}`);
+        return;
     }
-    for (const { claim, target } of acceptanceBindings) {
+    if (target.normalized_text !== undefined &&
+        target.normalized_text !== item.normalized_text) {
+        issue(report, `source_target_statement_mismatch:${claim.key}:${ref}`);
+        return;
+    }
+    const owner = state.owners.get(ref);
+    if (owner) {
+        issue(report, `source_target_already_owned:${claim.key}:${ref}:${owner}`);
+        return;
+    }
+    state.owners.set(ref, claim.key);
+    if (state.architectureItems.has(item.key) &&
+        target.kind === "technical_obligation")
+        state.ownedArchitectureItems.add(item.key);
+    if (target.outcome_key &&
+        [
+            "requirement",
+            "control",
+            "technical_obligation",
+            "non_completing",
+            "forbidden_shortcut",
+        ].includes(target.kind))
+        state.sourceBackedOutcomeClaims.add(ref);
+    if (!target.outcome_key &&
+        ["global_constraint", "non_goal", "forbidden_shortcut"].includes(target.kind))
+        state.sourceBackedGlobalClaims.add(ref);
+    if (target.kind === "acceptance")
+        state.acceptanceBindings.push({ claim, target });
+}
+function validateAcceptanceBindingContinuity(contract, state, report) {
+    for (const { claim, target } of state.acceptanceBindings) {
         const resolved = resolveAcceptanceAssertion(contract, target.ref);
         const sourceBacked = resolved?.scope === "outcome" && target.outcome_key
             ? resolved.assertion.claims.some((localKey) => localKey !== "result" &&
-                sourceBackedOutcomeClaims.has(`${target.outcome_key}.${localKey}`))
+                state.sourceBackedOutcomeClaims.has(`${target.outcome_key}.${localKey}`))
             : resolved?.scope === "global"
-                ? resolved.assertion.claims.some((localKey) => sourceBackedGlobalClaims.has(localKey))
+                ? resolved.assertion.claims.some((localKey) => state.sourceBackedGlobalClaims.has(localKey))
                 : false;
         if (!sourceBacked)
             issue(report, `source_acceptance_without_source_backed_claim:${claim.key}:${target.ref}`);
     }
 }
+function validateArchitectureContinuity(state, report) {
+    if (!state.architectureItems.size)
+        issue(report, "source_architecture_obligation_required");
+    for (const key of state.architectureItems)
+        if (!state.ownedArchitectureItems.has(key))
+            issue(report, `source_architecture_obligation_unmapped:${key}`);
+}
 function dispositionRefs(disposition) {
     if (disposition.type === "decision_required")
         return [];

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

@@ -1,3 +1,4 @@
+import { controlFieldFacts } from "./long-task-control-fields.js";
 import { normalizeSourceItemText } from "./long-task-source-item-parser.js";
 export function buildCanonicalSourceTargetIndex(contract) {
     const targets = [];
@@ -6,9 +7,12 @@ export function buildCanonicalSourceTargetIndex(contract) {
         for (const requirement of outcome.product.requirements)
             targets.push(target(`${outcome.key}.requirement.${requirement.key}`, "requirement", requirement.statement, outcome.key));
         for (const control of outcome.product.controls)
-            for (const [field, value] of controlFields(control))
-                if (value.trim())
-                    targets.push(target(`${outcome.key}.control.${control.key}.${field}`, "control", value, outcome.key));
+            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)
@@ -57,32 +61,6 @@ function target(ref, kind, text, outcomeKey, scope) {
         ...(scope ? { scope } : {}),
     };
 }
-function controlFields(control) {
-    return [
-        ["surface", control.surface],
-        ["region", control.region],
-        ["location", control.location],
-        ["control_type", control.control_type],
-        ["label_content", control.label_content],
-        ["user_task", control.user_task],
-        ["visibility", control.visibility],
-        ["availability", control.availability],
-        ["trigger", control.trigger],
-        ["input", control.input],
-        ["validation", control.validation],
-        ["default_value", control.default_value],
-        ["interaction", control.interaction],
-        ["navigation_result", control.navigation_result],
-        ["loading", control.loading_state],
-        ["empty", control.empty_state],
-        ["success", control.success_state],
-        ["failure", control.failure_state],
-        ["recovery", control.recovery],
-        ["permission", control.permission],
-        ["feedback", control.feedback],
-        ["accessibility", control.accessibility],
-    ];
-}
 export function sourceKindForTarget(target) {
     return target.kind === "global_constraint"
         ? "technical_obligation"

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

@@ -19,6 +19,7 @@ export interface DeliveryStatusV2 {
     stages: Record<string, StageStatusV2>;
     ready_stages: string[];
     ready_outcomes: string[];
+    /** Compatibility alias for the advisory acceptance/verification frontier; never an implementation gate. */
     ready_for_implementation: string[];
     needs_reverify: string[];
     progress_passing: string[];