project-tiny-context-harness 0.7.2 → 0.7.4

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

@@ -0,0 +1,120 @@
+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"));
+        if (!stageGateChecks.length)
+            issue(report, "stage_gate_check_required", `${stage.key}:${gate.key}`);
+        else if (!stageGateChecks.some((check) => provesGate(check, gate)))
+            issue(report, "stage_gate_target_runtime_result_required", `${stage.key}:${gate.key}`);
+        for (const targetRef of 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 (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-status-projection.d.ts

@@ -1,4 +1,4 @@
-import type { CompiledDeliveryContractV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, ProgressRecordV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
+import type { CompiledDeliveryContractV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, ProgressRecordV2, StageStatusV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
 interface StatusProjectionInputV2 {
     compiled: CompiledDeliveryContractV2;
     manifest: WorkspaceManifestV2;
@@ -11,7 +11,10 @@ export type AuditGateStatusV2 = "no_final_gate" | "last_gate_passed" | "last_gat
 export declare function projectDeliveryStatus(input: StatusProjectionInputV2): {
     finalResult: AuditGateStatusV2;
     finalWorkflowStatus: FinalReceiptV2["workflow_status"] | null;
+    targetState: FinalReceiptV2["target_state"];
     outcomes: Record<string, OutcomeStatusV2>;
+    stages: Record<string, StageStatusV2>;
+    readyStages: string[];
     readyOutcomes: string[];
     needsReverify: string[];
     progressPassing: string[];

package/dist/lib/long-task-status-projection.js

@@ -1,13 +1,21 @@
 import { progressRecordFresh } from "./long-task-progress.js";
 export function projectDeliveryStatus(input) {
     const outcomes = projectOutcomes(input);
+    const stages = projectStages(input.compiled, outcomes);
     return {
         finalResult: projectFinalResult(input),
         finalWorkflowStatus: receiptFresh(input)
             ? input.receipt.workflow_status
             : null,
+        targetState: receiptFresh(input)
+            ? (input.receipt.target_state ?? legacyTargetState(input.receipt))
+            : "not_accepted",
         outcomes,
-        readyOutcomes: readyOutcomes(input.compiled, outcomes),
+        stages,
+        readyStages: Object.entries(stages)
+            .filter(([, status]) => status === "ready")
+            .map(([key]) => key),
+        readyOutcomes: readyOutcomes(input.compiled, outcomes, stages),
         needsReverify: Object.entries(outcomes)
             .filter(([, status]) => ["unverified", "progress_stale", "progress_failing"].includes(status))
             .map(([key]) => key),
@@ -88,12 +96,64 @@ function projectFindings(input) {
     }
     return findings;
 }
-function readyOutcomes(compiled, outcomes) {
+function readyOutcomes(compiled, outcomes, stages) {
     return compiled.outcomes
-        .filter((outcome) => outcomes[outcome.key] !== "progress_passing" &&
+        .filter((outcome) => stages[outcome.stage] !== "locked" &&
+        stages[outcome.stage] !== "progress_passing" &&
+        outcomes[outcome.key] !== "progress_passing" &&
         outcome.depends_on.every((dependency) => outcomes[dependency] === "progress_passing"))
         .map((outcome) => outcome.key);
 }
+function legacyTargetState(receipt) {
+    if (receipt.workflow_status === "machine_accepted" ||
+        receipt.workflow_status === "machine_accepted_external_pending")
+        return receipt.target_profile.required_state;
+    return receipt.workflow_status === "blocked_external"
+        ? "blocked_external"
+        : "not_accepted";
+}
+function projectStages(compiled, outcomes) {
+    const result = {};
+    const remaining = new Set(compiled.stages.map((stage) => stage.key));
+    while (remaining.size) {
+        let advanced = false;
+        for (const stage of compiled.stages) {
+            if (!remaining.has(stage.key))
+                continue;
+            if (stage.depends_on.some((dependency) => remaining.has(dependency)))
+                continue;
+            const prerequisitesPassing = stage.depends_on.every((dependency) => result[dependency] === "progress_passing");
+            if (!prerequisitesPassing)
+                result[stage.key] = "locked";
+            else {
+                const owned = compiled.outcomes
+                    .filter((outcome) => outcome.stage === stage.key)
+                    .map((outcome) => outcomes[outcome.key]);
+                const gate = outcomes[stage.gate_outcome];
+                result[stage.key] = owned.includes("progress_failing")
+                    ? "progress_failing"
+                    : owned.includes("blocked_external")
+                        ? "blocked_external"
+                        : owned.includes("progress_stale")
+                            ? "progress_stale"
+                            : gate === "progress_passing" &&
+                                owned.every((status) => status === "progress_passing")
+                                ? "progress_passing"
+                                : owned.every((status) => status === "unverified")
+                                    ? "ready"
+                                    : "unverified";
+            }
+            remaining.delete(stage.key);
+            advanced = true;
+        }
+        if (!advanced) {
+            for (const stage of remaining)
+                result[stage] = "locked";
+            break;
+        }
+    }
+    return result;
+}
 function projectFinalResult(input) {
     if (!input.receipt)
         return "no_final_gate";

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

@@ -1,5 +1,5 @@
 import type { AuthorityRevisionDecisionV2 } from "./long-task-authority-revision-types.js";
-import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2 } from "./long-task-delivery-types.js";
+import type { ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, OutcomeStatusV2, StageStatusV2, TargetProfileV2 } from "./long-task-delivery-types.js";
 import { type AuditGateStatusV2 } from "./long-task-status-projection.js";
 export interface DeliveryStatusV2 {
     schema_version: "long-task-status-v2";
@@ -13,7 +13,11 @@ export interface DeliveryStatusV2 {
     final_result: AuditGateStatusV2;
     final_workflow_status: FinalReceiptV2["workflow_status"] | null;
     external_confirmations: ExternalConfirmationV2[];
+    target_profile: TargetProfileV2;
+    target_state: FinalReceiptV2["target_state"];
     outcomes: Record<string, OutcomeStatusV2>;
+    stages: Record<string, StageStatusV2>;
+    ready_stages: string[];
     ready_outcomes: string[];
     ready_for_implementation: string[];
     needs_reverify: string[];
@@ -31,6 +35,9 @@ export interface StopCheckDeliveryResultV2 {
     reason: string;
     workflow_status?: FinalReceiptV2["workflow_status"];
     external_confirmations?: ExternalConfirmationV2[];
+    target_profile?: TargetProfileV2;
+    target_state?: FinalReceiptV2["target_state"];
+    stage_results?: FinalReceiptV2["stage_results"];
     acceptance_scope?: "declared_machine_authority";
     native_goal_effect?: "none";
     message?: string;
@@ -39,6 +46,9 @@ export interface CloseDeliveryResultV2 {
     status: "closed";
     workflow_status: Extract<FinalReceiptV2["workflow_status"], "machine_accepted" | "machine_accepted_external_pending">;
     external_confirmations: ExternalConfirmationV2[];
+    target_profile: TargetProfileV2;
+    target_state: FinalReceiptV2["target_state"];
+    stage_results: FinalReceiptV2["stage_results"];
     acceptance_scope: "declared_machine_authority";
     closed_scope: "machine_authority";
     native_goal_effect: "none";

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

@@ -53,7 +53,11 @@ async function readDeliveryStatusForAuthority(active) {
         final_result: projection.finalResult,
         final_workflow_status: projection.finalWorkflowStatus,
         external_confirmations: compiled.global.acceptance.external_confirmations,
+        target_profile: compiled.task.target_profile,
+        target_state: projection.targetState,
         outcomes: projection.outcomes,
+        stages: projection.stages,
+        ready_stages: projection.readyStages,
         ready_outcomes: projection.readyOutcomes,
         ready_for_implementation: projection.readyOutcomes,
         needs_reverify: projection.needsReverify,
@@ -89,6 +93,8 @@ export async function resumeDeliveryTask(workdir) {
             id: compiled.task.id,
             title: compiled.task.title,
             goal: compiled.task.goal,
+            target_profile: compiled.task.target_profile,
+            execution_targets: compiled.task.execution_targets,
         },
         contract_identity: compiled.compiled_identity,
         authority_revision: compiled.authority_revision,
@@ -101,7 +107,11 @@ export async function resumeDeliveryTask(workdir) {
         last_gate: status.final_result,
         final_workflow_status: status.final_workflow_status,
         external_confirmations: status.external_confirmations,
+        target_profile: status.target_profile,
+        target_state: status.target_state,
         outcomes: status.outcomes,
+        stages: status.stages,
+        ready_stages: status.ready_stages,
         ready_outcomes: status.ready_outcomes,
         ready_for_implementation: status.ready_for_implementation,
         needs_reverify: status.needs_reverify,
@@ -216,6 +226,9 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
                         reason: "active_authority_changed_after_final_gate",
                         workflow_status: result.workflow_status,
                         external_confirmations: result.external_confirmations,
+                        target_profile: result.target_profile,
+                        target_state: result.target_state,
+                        stage_results: result.stage_results,
                         message: "Active Authority changed after the Live Final Gate; the accepted identity was not cleared.",
                     };
                 throw error;
@@ -225,9 +238,12 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
                 reason: result.workflow_status,
                 workflow_status: result.workflow_status,
                 external_confirmations: result.external_confirmations,
+                target_profile: result.target_profile,
+                target_state: result.target_state,
+                stage_results: result.stage_results,
                 acceptance_scope: "declared_machine_authority",
                 native_goal_effect: "none",
-                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations),
+                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations, result.target_profile),
             };
         }
         return {
@@ -235,6 +251,9 @@ export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
             reason: `live_final_gate_${result.workflow_status}`,
             workflow_status: result.workflow_status,
             external_confirmations: result.external_confirmations,
+            target_profile: result.target_profile,
+            target_state: result.target_state,
+            stage_results: result.stage_results,
             message: messageText ||
                 result.findings.at(-1)?.next_action ||
                 "Repair the failing Check and rerun Stop.",
@@ -274,13 +293,16 @@ export async function closeDeliveryTask(workdir) {
         status: "closed",
         workflow_status: result.workflow_status,
         external_confirmations: result.external_confirmations,
+        target_profile: result.target_profile,
+        target_state: result.target_state,
+        stage_results: result.stage_results,
         acceptance_scope: "declared_machine_authority",
         closed_scope: "machine_authority",
         native_goal_effect: "none",
     };
 }
-function acceptedScopeMessage(workflowStatus, confirmations) {
-    const scope = "Declared machine Authority accepted and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.";
+function acceptedScopeMessage(workflowStatus, confirmations, targetProfile) {
+    const scope = `Declared machine Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
     if (workflowStatus === "machine_accepted")
         return scope;
     const pending = confirmations

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

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

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

@@ -0,0 +1,127 @@
+export function validateExecutionTargets(contract, report) {
+    const targets = indexExecutionTargets(contract, report);
+    const requiredTargetRefs = contract.task.target_profile.required_target_refs;
+    validateRequiredTargetRefs(contract, targets, report);
+    for (const [outcomeKey, check] of allChecks(contract))
+        validateCheckTarget(outcomeKey, check, targets, report);
+    validateCriticalPathTargets(contract, requiredTargetRefs, report);
+}
+function indexExecutionTargets(contract, report) {
+    const targets = new Map();
+    for (const target of contract.task.execution_targets) {
+        if (targets.has(target.key))
+            issue(report, "execution_target_key_duplicate", target.key);
+        targets.set(target.key, target);
+    }
+    if (![...targets.values()].some((target) => target.role === "product"))
+        issue(report, "product_execution_target_required", contract.task.id);
+    return targets;
+}
+function validateRequiredTargetRefs(contract, targets, report) {
+    const required = contract.task.target_profile.required_target_refs;
+    if (!required.length)
+        issue(report, "target_profile_required_target_refs_required", contract.task.id);
+    if (new Set(required).size !== required.length)
+        issue(report, "target_profile_required_target_refs_duplicate", contract.task.id);
+    for (const targetRef of required) {
+        const target = targets.get(targetRef);
+        if (!target)
+            issue(report, "target_profile_required_target_ref_unknown", targetRef);
+        else if (target.role !== "product")
+            issue(report, "target_profile_required_target_must_be_product", targetRef);
+    }
+}
+function validateCheckTarget(outcomeKey, check, targets, report) {
+    const target = targets.get(check.execution_target.target_ref);
+    const label = `${outcomeKey ?? "GLOBAL"}:${check.key}`;
+    if (!target) {
+        issue(report, "check_execution_target_unknown", `${label}:${check.execution_target.target_ref}`);
+        return;
+    }
+    if ((check.runner.type === "playwright_test" ||
+        check.proof_surface === "ui_browser") &&
+        target.runtime_family !== "browser")
+        issue(report, "browser_check_target_mismatch", `${label}:${target.key}`);
+    if (provesTargetRuntime(check) &&
+        target.runtime_family === "browser" &&
+        check.runner.type !== "playwright_test")
+        issue(report, "browser_target_runtime_requires_playwright", `${label}:${target.key}`);
+    if (provesTargetRuntime(check) &&
+        ["native", "desktop"].includes(target.runtime_family) &&
+        check.runner.type !== "project_binary")
+        issue(report, "native_target_runtime_requires_project_binary", `${label}:${target.key}`);
+    validateStageGateTarget(label, check, target, report);
+    validateConformanceTarget(outcomeKey, check, target, report);
+}
+function validateStageGateTarget(label, check, target, report) {
+    if (!check.journey_roles.includes("stage_gate"))
+        return;
+    if (target.role !== "product")
+        issue(report, "stage_gate_product_target_required", `${label}:${target.key}`);
+    if (check.execution_target.entrypoint !== "root")
+        issue(report, "stage_gate_root_entrypoint_required", label);
+}
+function validateConformanceTarget(outcomeKey, check, target, report) {
+    if (!check.journey_roles.includes("conformance"))
+        return;
+    if (outcomeKey !== null)
+        issue(report, "conformance_check_must_be_global", `${outcomeKey}:${check.key}`);
+    if (target.role !== "product" || check.execution_target.entrypoint !== "root")
+        issue(report, "conformance_root_product_target_required", check.key);
+}
+function validateCriticalPathTargets(contract, requiredTargetRefs, report) {
+    for (const outcomeKey of contract.risk.facts.critical_user_path) {
+        const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
+        if (!outcome)
+            continue;
+        for (const targetRef of requiredTargetRefs)
+            if (!outcome.acceptance.checks.some((check) => provesSuccess(check, targetRef)))
+                issue(report, "critical_path_required_target_proof_missing", `${outcome.key}:${targetRef}`);
+    }
+}
+function provesSuccess(check, targetRef) {
+    return (check.execution_target.target_ref === targetRef &&
+        check.journey_roles.includes("success") &&
+        check.execution_target.entrypoint === "root" &&
+        provesTargetRuntime(check));
+}
+function provesTargetRuntime(check) {
+    return [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime"));
+}
+export function validateExternalConfirmationImpacts(contract, claims, report) {
+    const claimRefs = new Set();
+    for (const [outcomeKey, values] of Object.entries(claims.by_outcome))
+        for (const claim of values)
+            claimRefs.add(`${outcomeKey}.${claim.local_key}`);
+    for (const claim of claims.by_global)
+        claimRefs.add(`GLOBAL.${claim.local_key}`);
+    for (const confirmation of contract.global.acceptance
+        .external_confirmations) {
+        if (!confirmation.impact_claims.length)
+            issue(report, "external_confirmation_impact_required", confirmation.key);
+        for (const claim of confirmation.impact_claims)
+            if (!claimRefs.has(claim))
+                issue(report, "external_confirmation_impact_unknown", `${confirmation.key}:${claim}`);
+        if (confirmation.kind === "functional_prerequisite" &&
+            !confirmation.blocks_target)
+            issue(report, "functional_prerequisite_must_block_target", confirmation.key);
+        if (confirmation.kind === "production_release_gate" &&
+            contract.task.target_profile.required_state ===
+                "production_release_ready" &&
+            !confirmation.blocks_target)
+            issue(report, "production_gate_must_block_release_target", confirmation.key);
+    }
+}
+function allChecks(contract) {
+    return [
+        ...contract.global.acceptance.checks.map((check) => [null, check]),
+        ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [outcome.key, check])),
+    ];
+}
+function issue(report, code, detail) {
+    const message = `delivery_contract_invalid:${code}:${detail}`;
+    if (report)
+        report(message);
+    else
+        throw new Error(message);
+}

package/dist/lib/migrations.js

@@ -9,11 +9,22 @@ import { ensureDir, listFiles, pathExists, readText, writeTextIfChanged, } from
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { legacySdlcHarnessMigration } from "./legacy-sdlc-migration.js";
 import { parseYaml, stringifyYaml } from "./yaml.js";
+import { semanticDriftMigrationFields } from "./long-task-semantic-drift-migration.js";
 async function verifyNoop() {
     return;
 }
 export const migrations = [
     legacySdlcHarnessMigration,
+    {
+        id: "long-task-v2-semantic-drift-authority",
+        introducedIn: "0.7.2",
+        description: "Require explicit Stage, target profile/root runtime, journey scenario and evidence-capability authority in V2 Long-Task Contracts.",
+        scope: ".long-task/delivery-contract.yaml",
+        risk: "manual",
+        manualMessage: "These product and proof semantics cannot be inferred safely. Preserve Source, then explicitly author stages, vertical Outcome membership, target profile and execution targets, success/degradation requirements, Given/When scenarios, evidence capabilities and typed external-confirmation impact before recompiling. Historical Progress and Receipts remain audit-only and must not be imported as acceptance.",
+        detect: detectLongTaskSemanticDriftAuthority,
+        verify: verifyNoop,
+    },
     {
         id: "long-task-v1-retirement",
         introducedIn: "0.6.0",
@@ -102,6 +113,24 @@ export const migrations = [
         verify: verifyNoop,
     },
 ];
+async function detectLongTaskSemanticDriftAuthority(projectRoot, _root, migration) {
+    const contract = path.join(projectRoot, ".long-task", "delivery-contract.yaml");
+    if (!(await pathExists(contract)))
+        return [];
+    let decoded;
+    try {
+        decoded = parseYaml(await readText(contract));
+    }
+    catch {
+        return [];
+    }
+    const fields = semanticDriftMigrationFields(decoded);
+    if (!fields.length)
+        return [];
+    return [
+        item(migration, "manual_required", ".long-task/delivery-contract.yaml", `The active/draft V2 Contract predates semantic-drift authority and is missing: ${fields.slice(0, 12).join(", ")}${fields.length > 12 ? `, +${fields.length - 12} more` : ""}. Re-author these meanings from Source; do not synthesize them from old passing evidence.`),
+    ];
+}
 async function detectLongTaskV1Retirement(projectRoot, root, migration) {
     const items = [];
     const hook = path.join(projectRoot, root, "hooks", "long-task-hook.mjs");