project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/lib/design-md-tool-normalization.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { stableJson } from "./stable-json.js";
+export function loadDesignMdToolIdentity() {
+    let directory = path.dirname(fileURLToPath(import.meta.resolve("@google/design.md")));
+    for (let depth = 0; depth < 4; depth += 1) {
+        const packagePath = path.join(directory, "package.json");
+        if (existsSync(packagePath)) {
+            const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+            if (parsed.name === "@google/design.md" &&
+                typeof parsed.version === "string") {
+                return {
+                    package_name: "@google/design.md",
+                    package_version: parsed.version,
+                    api_surface: "@google/design.md/linter",
+                };
+            }
+        }
+        directory = path.dirname(directory);
+    }
+    throw new Error("unable to resolve @google/design.md package identity");
+}
+export function normalizeDesignMdFinding(finding) {
+    return {
+        severity: finding.severity,
+        ...(finding.path ? { path: finding.path } : {}),
+        message: finding.message,
+        ...(finding.rule ? { rule: finding.rule } : {}),
+    };
+}
+export function snapshotDesignSystem(state) {
+    return {
+        ...(state.name ? { name: state.name } : {}),
+        ...(state.description ? { description: state.description } : {}),
+        colors: mapToRecord(state.colors),
+        typography: mapToRecord(state.typography),
+        rounded: mapToRecord(state.rounded),
+        spacing: mapToRecord(state.spacing),
+        components: Object.fromEntries([...state.components.entries()]
+            .sort(([left], [right]) => compareText(left, right))
+            .map(([key, component]) => [
+            key,
+            {
+                properties: mapToRecord(component.properties),
+                unresolved_refs: [...component.unresolvedRefs].sort(compareText),
+            },
+        ])),
+        sections: [...(state.sections ?? [])],
+        unknown_keys: [...(state.unknownKeys ?? [])].sort(compareText),
+    };
+}
+export function componentProperties(components) {
+    return Object.fromEntries(Object.entries(components).map(([key, component]) => [
+        key,
+        component.properties,
+    ]));
+}
+export function diffDesignMdRecords(before, after) {
+    const beforeKeys = Object.keys(before).sort(compareText);
+    const afterKeys = Object.keys(after).sort(compareText);
+    return {
+        added: afterKeys.filter((key) => !(key in before)),
+        removed: beforeKeys.filter((key) => !(key in after)),
+        modified: afterKeys.filter((key) => key in before && stableJson(before[key]) !== stableJson(after[key])),
+    };
+}
+function mapToRecord(map) {
+    return Object.fromEntries([...map.entries()]
+        .sort(([left], [right]) => compareText(left, right))
+        .map(([key, value]) => [key, toJsonValue(value)]));
+}
+function toJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/lib/design-md-tool-types.d.ts

@@ -0,0 +1,99 @@
+export declare const DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION = 1;
+export declare const DESIGN_MD_EXPORT_FORMATS: readonly ["json-tailwind", "css-tailwind", "tailwind", "dtcg", "css-vars"];
+export type DesignMdExportFormat = (typeof DESIGN_MD_EXPORT_FORMATS)[number];
+export type DesignMdValidationMode = "parse-validate" | "lint";
+export type DesignMdFindingSeverity = "error" | "warning" | "info";
+export interface DesignMdToolIdentity {
+    package_name: "@google/design.md";
+    package_version: string;
+    api_surface: "@google/design.md/linter";
+}
+export interface DesignMdFinding {
+    severity: DesignMdFindingSeverity;
+    path?: string;
+    message: string;
+    rule?: string;
+}
+export interface DesignMdFindingSummary {
+    errors: number;
+    warnings: number;
+    infos: number;
+}
+export interface DesignMdComponentSnapshot {
+    properties: Record<string, unknown>;
+    unresolved_refs: string[];
+}
+export interface DesignMdSystemSnapshot {
+    name?: string;
+    description?: string;
+    colors: Record<string, unknown>;
+    typography: Record<string, unknown>;
+    rounded: Record<string, unknown>;
+    spacing: Record<string, unknown>;
+    components: Record<string, DesignMdComponentSnapshot>;
+    sections: string[];
+    unknown_keys: string[];
+}
+export interface DesignMdValidationResult {
+    schema_version: typeof DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION;
+    mode: DesignMdValidationMode;
+    tool: DesignMdToolIdentity;
+    valid: boolean;
+    findings: DesignMdFinding[];
+    summary: DesignMdFindingSummary;
+    design_system: DesignMdSystemSnapshot | null;
+}
+export interface DesignMdExportSuccess {
+    success: true;
+    format: DesignMdExportFormat;
+    media_type: "application/json" | "text/css";
+    content: string;
+    options: DesignMdExportOptions;
+    validation: DesignMdValidationResult;
+}
+export interface DesignMdExportFailure {
+    success: false;
+    format: DesignMdExportFormat;
+    error: string;
+    options: DesignMdExportOptions;
+    validation: DesignMdValidationResult;
+}
+export interface DesignMdExportOptions {
+    css_variable_prefix?: string;
+}
+export type DesignMdExportResult = DesignMdExportSuccess | DesignMdExportFailure;
+export interface DesignMdTokenChangeSet {
+    added: string[];
+    removed: string[];
+    modified: string[];
+}
+export interface DesignMdDiffSuccess {
+    success: true;
+    tool: DesignMdToolIdentity;
+    tokens: {
+        colors: DesignMdTokenChangeSet;
+        typography: DesignMdTokenChangeSet;
+        rounded: DesignMdTokenChangeSet;
+        spacing: DesignMdTokenChangeSet;
+        components: DesignMdTokenChangeSet;
+    };
+    findings: {
+        before: DesignMdFindingSummary;
+        after: DesignMdFindingSummary;
+        delta: {
+            errors: number;
+            warnings: number;
+        };
+    };
+    regression: boolean;
+    before_validation: DesignMdValidationResult;
+    after_validation: DesignMdValidationResult;
+}
+export interface DesignMdDiffFailure {
+    success: false;
+    tool: DesignMdToolIdentity;
+    error: string;
+    before_validation: DesignMdValidationResult;
+    after_validation: DesignMdValidationResult;
+}
+export type DesignMdDiffResult = DesignMdDiffSuccess | DesignMdDiffFailure;

package/dist/lib/design-md-tool-types.js

@@ -0,0 +1,8 @@
+export const DESIGN_MD_TOOL_ADAPTER_SCHEMA_VERSION = 1;
+export const DESIGN_MD_EXPORT_FORMATS = [
+    "json-tailwind",
+    "css-tailwind",
+    "tailwind",
+    "dtcg",
+    "css-vars",
+];

package/dist/lib/design-resource-handoff-input-types.d.ts

@@ -1,6 +1,6 @@
 import type { DesignResourceHandoffV1 } from "./design-resource-handoff-types.js";
 import type { DesignResourceHandoffV2, ParsedDesignResourceHandoffV2 } from "./design-resource-symbolic-fact-types.js";
-export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "technical_feasibility_inputs" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
+export type DesignResourceHandoffManifestBackedV1 = Pick<DesignResourceHandoffV1, "schema_version" | "intent" | "scope" | "provenance" | "project_design_authority" | "technical_feasibility_inputs" | "resources" | "targets" | "resource_fact_closure" | "coverage" | "proposal"> & {
     representation: "manifest_backed";
 };
 export type DesignResourceHandoffInputV1 = DesignResourceHandoffV1 | DesignResourceHandoffManifestBackedV1;

package/dist/lib/design-resource-handoff-manifest-projection.js

@@ -11,6 +11,9 @@ export function hydrateManifestBackedDesignResourceHandoff(descriptor, manifests
         intent: descriptor.intent,
         scope: descriptor.scope,
         provenance: descriptor.provenance,
+        ...(descriptor.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: descriptor.project_design_authority }),
         technical_feasibility_inputs: descriptor.technical_feasibility_inputs,
         resources: descriptor.resources,
         axis_dispositions: manifest.axis_dispositions,

package/dist/lib/design-resource-handoff-shape.js

@@ -1,5 +1,6 @@
 import { parseDesignResourceSymbolicHandoffShape } from "./design-resource-symbolic-fact-shape.js";
 import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
+import { parseDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 import { parseDesignResourceAssetBindings, parseDesignResourceAxisDispositions, parseDesignResourceConditionExclusions, parseDesignResourceEnvironments, parseDesignResourceFactCells, parseDesignResourceLineageNodes, parseDesignResourceOracles, parseDesignResourceProofObligations, parseDesignResourceProperties, parseDesignResourceVariationAxisDispositions, parseDesignResourceVariationExclusions, parseDesignResourceVariations, } from "./design-resource-fact-manifest-shape.js";
 import { parseDesignResourceHandoffBlockers, parseDesignResourceHandoffCoverage, parseDesignResourceHandoffEvidence, parseDesignResourceHandoffFacts, parseDesignResourceHandoffResourceFactClosure, } from "./design-resource-handoff-shape-evidence.js";
 import { contractKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
@@ -50,7 +51,7 @@ export function parseDesignResourceHandoffShape(value) {
         "coverage",
         "acceptance_blockers",
         "proposal",
-    ], ["technical_feasibility_inputs"]);
+    ], ["technical_feasibility_inputs", "project_design_authority"]);
     const scope = object(root.scope, "design_resource_handoff.scope", [
         "key",
         "style_dependency",
@@ -93,6 +94,11 @@ export function parseDesignResourceHandoffShape(value) {
             model: string(provenance.model, "design_resource_handoff.provenance.model"),
             design_system_id: string(provenance.design_system_id, "design_resource_handoff.provenance.design_system_id"),
         },
+        ...(root.project_design_authority === undefined
+            ? {}
+            : {
+                project_design_authority: parseDesignAuthorityHandoffBinding(root.project_design_authority, "design_resource_handoff.project_design_authority"),
+            }),
         technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? []),
         resources: parseDesignResourceHandoffResources(root.resources),
         axis_dispositions: parseDesignResourceAxisDispositions(root.axis_dispositions),
@@ -134,12 +140,15 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         "resource_fact_closure",
         "coverage",
         "proposal",
-    ], ["technical_feasibility_inputs"]);
+    ], ["technical_feasibility_inputs", "project_design_authority"]);
     const parsed = parseDesignResourceHandoffShape({
         schema_version: root.schema_version,
         intent: root.intent,
         scope: root.scope,
         provenance: root.provenance,
+        ...(root.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: root.project_design_authority }),
         technical_feasibility_inputs: root.technical_feasibility_inputs ?? [],
         resources: root.resources,
         axis_dispositions: [],
@@ -170,6 +179,9 @@ function parseManifestBackedDesignResourceHandoffShape(value) {
         intent: parsed.intent,
         scope: parsed.scope,
         provenance: parsed.provenance,
+        ...(parsed.project_design_authority === undefined
+            ? {}
+            : { project_design_authority: parsed.project_design_authority }),
         technical_feasibility_inputs: parsed.technical_feasibility_inputs,
         resources: parsed.resources,
         targets: parsed.targets,

package/dist/lib/design-resource-handoff-types.d.ts

@@ -1,6 +1,7 @@
 import type { ExecutionTargetCapabilityV2 } from "./execution-target-capabilities.js";
 import type { DesignResourceAssetBindingV1, DesignResourceAxisDispositionV1, DesignResourceConditionCombinationDispositionV1, DesignResourceEnvironmentV1, DesignResourceFactCellV1, DesignResourceFactV1, DesignResourceLineageNodeV1, DesignResourceManifestCollectionName, DesignResourceOracleV1, DesignResourcePropertyDefinitionV1, DesignResourceProofObligationV1, DesignResourceRelationEndpointV1, DesignResourceSubjectKind, DesignResourceSubjectPresenceKind, DesignResourceSubjectVariationV1, DesignResourceVariationAxisDispositionV1, DesignResourceVariationCombinationDispositionV1 } from "./design-resource-fact-manifest-types.js";
 import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignAuthorityHandoffBinding, DesignAuthorityHandoffResolution } from "./design-authority-types.js";
 export declare const DESIGN_RESOURCE_DIMENSIONS: readonly ["surface_flow", "visual_content", "component_control", "state_interaction", "motion", "adaptation_input", "accessibility", "assets"];
 export type DesignResourceDimension = (typeof DESIGN_RESOURCE_DIMENSIONS)[number];
 export declare const DESIGN_RESOURCE_EVIDENCE_KINDS: readonly ["frame", "component_variant", "prototype_state", "prototype_transition", "motion_spec", "motion_capture", "responsive_spec", "input_spec", "accessibility_spec", "semantic_tree", "token_spec", "asset", "annotation", "localization_spec", "system_ui_spec", "haptic_spec", "sound_spec", "sound_capture", "render_environment", "relation_spec"];
@@ -31,6 +32,7 @@ export interface DesignResourceHandoffV1 {
         model: string;
         design_system_id: string;
     };
+    project_design_authority?: DesignAuthorityHandoffBinding;
     technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     axis_dispositions: DesignResourceAxisDispositionV1[];
@@ -221,6 +223,7 @@ export interface ParsedDesignResourceHandoffV1 {
 export interface DesignResourceHandoffPreflightV1 extends ParsedDesignResourceHandoffV1 {
     schema_version: "design-resource-handoff-preflight-v1";
     status: "ready";
+    project_design_authority_resolution: DesignAuthorityHandoffResolution;
     resource_hashes: Record<string, string>;
     technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];
     technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];

package/dist/lib/design-resource-handoff-validation.js

@@ -14,6 +14,7 @@ import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { assertDesignResourceV1HandoffCapacity } from "./design-resource-v1-capacity.js";
 import { createV1ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
 import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
+import { resolveDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 export async function preflightDesignResourceHandoff(repository, handoffPath) {
     const handoffFile = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...handoffPath.split("/")), "design_resource_handoff");
     await assertDesignResourceV1HandoffCapacity(handoffFile);
@@ -30,6 +31,11 @@ function isParsedSymbolicHandoff(parsed) {
 }
 export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     const inputHandoff = parsed.handoff;
+    const authorityResolution = await resolveDesignAuthorityHandoffBinding({
+        repository,
+        style_dependency: inputHandoff.scope.style_dependency,
+        binding: inputHandoff.project_design_authority,
+    });
     if (isManifestBacked(inputHandoff) && inputHandoff.targets.length !== 1)
         invalidDesignResourceHandoff("manifest_backed_one_target_required", String(inputHandoff.targets.length));
     if (!isManifestBacked(inputHandoff))
@@ -55,14 +61,20 @@ export async function preflightParsedDesignResourceHandoff(repository, parsed) {
     return {
         schema_version: "design-resource-handoff-preflight-v1",
         status: "ready",
+        project_design_authority_resolution: authorityResolution,
         ...normalized,
         resource_hashes: snapshot.hashes,
         technical_feasibility_documents: feasibility.map((item) => item.document),
         technical_feasibility_identities: feasibility.map((item) => item.identity),
-        limitations: handoff.targets.some((target) => target.source_profile.kind !== "reference" &&
-            !feasibility.some((item) => item.index.target_ref === target.key))
-            ? ["technical feasibility not declared"]
-            : [],
+        limitations: [
+            ...(authorityResolution.compatibility_derived
+                ? ["project Design Authority identity derived from legacy DESIGN.md"]
+                : []),
+            ...(handoff.targets.some((target) => target.source_profile.kind !== "reference" &&
+                !feasibility.some((item) => item.index.target_ref === target.key))
+                ? ["technical feasibility not declared"]
+                : []),
+        ],
         manifest_identities: handoff.targets.map((target) => {
             const resourceRef = target.source_profile.fact_manifest_resource_ref;
             const resource = resources.get(resourceRef);

package/dist/lib/design-resource-implementation-feasibility-validation-support.js

@@ -5,7 +5,7 @@ const EXACT_VISUAL_VALUE_PATTERNS = [
     /\b(?:color|background|font(?:-family|-size|-weight)?|line-height|border-radius|radius|padding|margin|gap|width|height|opacity|duration|easing|shadow)\s*[:=]\s*\S+/iu,
     /--[a-z0-9_-]+\s*:\s*\S+/iu,
 ];
-const TIME_VALUE_PATTERN = /\b\d+(?:\.\d+)?(?:ms|s)\b/giu;
+const TIME_VALUE_PATTERN = /\b\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|sec|s)\b/giu;
 const MOTION_TIME_CONTEXT = /\b(?:animation|transition|motion|duration|delay|easing|timeline|keyframes?|fade|spring|stagger|enter|exit|hover|press|ease(?:-in|-out|-in-out)?)\b/iu;
 const TECHNICAL_TIME_CONTEXT = /\b(?:build|compile|bundle|generation|ci|tests?|startup|initialization|latency|timeout|network|benchmark|runtime\s+cost|render\s+cost|benchmark\s+execution)\b/iu;
 const TIME_CONTEXT_RADIUS = 80;

package/dist/lib/design-resource-recovery-current.js

@@ -4,6 +4,8 @@ import { validateDesignResourceRecoverySemantics } from "./design-resource-recov
 import { decodeDesignResourceText } from "./design-resource-recovery-text.js";
 import { validateDesignResourceAuthoritySourceItems } from "./design-resource-recovery-source-authority.js";
 import { validateSelectedResourceRepositoryBindings } from "./design-resource-recovery-repository-bindings.js";
+import { inspectDesignAuthorityClosure, loadCurrentDesignAuthorityClosure, } from "./design-authority-closure.js";
+import { DESIGN_AUTHORITY_ENTRY_PATH } from "./design-authority-types.js";
 export async function loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId, options = {}) {
     const snapshot = await readRecoveryCheckpointFile(repository, sessionId);
     const checkpoint = parseDesignResourceRecoveryCheckpoint(snapshot.bytes.toString("utf8"));
@@ -27,8 +29,28 @@ export async function loadCurrentDesignResourceRecoveryCheckpoint(repository, se
     };
 }
 export async function validateDesignResourceRepositoryAuthority(repository, authority) {
+    if (authority.kind === "repository-closure") {
+        const current = await loadCurrentDesignAuthorityClosure(repository);
+        for (const field of [
+            "format_version",
+            "entry_path",
+            "manifest_path",
+            "closure_digest",
+            "revision",
+        ])
+            if (current.identity[field] !== authority[field])
+                invalid(`design_authority_closure_mismatch:${field}:${String(authority[field])}:${String(current.identity[field])}`);
+        return;
+    }
     if (authority.kind !== "repository-file")
         return;
+    if (authority.locator !== DESIGN_AUTHORITY_ENTRY_PATH)
+        invalid(`legacy_design_authority_locator:${authority.locator}`);
+    const inspection = await inspectDesignAuthorityClosure(repository);
+    if (inspection.status !== "valid")
+        invalid("legacy_design_authority_invalid");
+    if (inspection.mode !== "legacy")
+        invalid("legacy_design_authority_bundle_not_allowed");
     const snapshot = await readRecoveryRepositoryFile(repository, authority.locator, "design_resource_recovery_design_authority");
     assertDigest("design_authority", snapshot.raw_byte_digest, authority.raw_byte_digest);
 }

package/dist/lib/design-resource-recovery-shape.js

@@ -1,4 +1,5 @@
-import { arrayOf, digest, integer, object, oneOf, stringSet, text, unknownSemantics, } from "./design-resource-recovery-codec-primitives.js";
+import { arrayOf, digest, integer, literal, object, oneOf, stringSet, text, unknownSemantics, } from "./design-resource-recovery-codec-primitives.js";
+import { DESIGN_AUTHORITY_ENTRY_PATH, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, DESIGN_AUTHORITY_MANIFEST_PATH, isDesignAuthorityDigest, } from "./design-authority-types.js";
 export const DESIGN_RESOURCE_ORIGINS = [
     "user-direct",
     "necessary-derived",
@@ -156,24 +157,80 @@ export function parseDelta(value, label) {
     };
 }
 export function parseAuthorityIdentity(value, label) {
-    const first = object(value, label, ["kind"], ["locator", "raw_byte_digest", "rationale"]);
-    const kind = oneOf(first.kind, ["repository-file", "external-immutable", "not-applicable"], `${label}.kind`);
+    const first = object(value, label, ["kind"], [
+        "locator",
+        "raw_byte_digest",
+        "rationale",
+        "format_version",
+        "entry_path",
+        "manifest_path",
+        "closure_digest",
+        "revision",
+    ]);
+    const kind = oneOf(first.kind, [
+        "repository-closure",
+        "repository-file",
+        "external-immutable",
+        "not-applicable",
+    ], `${label}.kind`);
+    if (kind === "repository-closure") {
+        rejectFields(first, label, ["locator", "raw_byte_digest", "rationale"]);
+        literal(first.format_version, DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION, `${label}.format_version`);
+        literal(first.entry_path, DESIGN_AUTHORITY_ENTRY_PATH, `${label}.entry_path`);
+        const manifestPath = parseNullableManifestPath(first.manifest_path, `${label}.manifest_path`);
+        if (!isDesignAuthorityDigest(first.closure_digest))
+            throw new Error(`design_resource_recovery_invalid:${label}.closure_digest:sha256_required`);
+        const revision = first.revision === null
+            ? null
+            : text(first.revision, `${label}.revision`);
+        return {
+            kind,
+            format_version: DESIGN_AUTHORITY_IDENTITY_FORMAT_VERSION,
+            entry_path: DESIGN_AUTHORITY_ENTRY_PATH,
+            manifest_path: manifestPath,
+            closure_digest: first.closure_digest,
+            revision,
+        };
+    }
     if (kind === "not-applicable") {
-        if ("locator" in first || "raw_byte_digest" in first)
-            throw new Error(`design_resource_recovery_invalid:${label}:not_applicable_identity_fields`);
+        rejectFields(first, label, [
+            "locator",
+            "raw_byte_digest",
+            "format_version",
+            "entry_path",
+            "manifest_path",
+            "closure_digest",
+            "revision",
+        ]);
         return {
             kind,
             rationale: text(first.rationale, `${label}.rationale`),
         };
     }
-    if ("rationale" in first)
-        throw new Error(`design_resource_recovery_invalid:${label}:unexpected_rationale`);
+    rejectFields(first, label, [
+        "rationale",
+        "format_version",
+        "entry_path",
+        "manifest_path",
+        "closure_digest",
+        "revision",
+    ]);
     return {
         kind,
         locator: text(first.locator, `${label}.locator`),
         raw_byte_digest: digest(first.raw_byte_digest, `${label}.raw_byte_digest`),
     };
 }
+function parseNullableManifestPath(value, label) {
+    if (value === null)
+        return null;
+    return literal(value, DESIGN_AUTHORITY_MANIFEST_PATH, label);
+}
+function rejectFields(row, label, fields) {
+    for (const field of fields)
+        if (Object.hasOwn(row, field))
+            throw new Error(`design_resource_recovery_invalid:${label}:unexpected_field:${field}`);
+}
 export function parseDecisionAuthority(value, label) {
     const result = text(value, label);
     if (result === "explicit-user" || result === "none")

package/dist/lib/design-resource-recovery-types.d.ts

@@ -1,6 +1,7 @@
 import { DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA, DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA, DESIGN_RESOURCE_RECOVERY_SCHEMA } from "./design-resource-recovery-schema.js";
 import type { DesignResourceRecoveryWriteback, DesignResourceWritebackInput } from "./design-resource-recovery-patch-types.js";
 import type { SourceItemKind } from "./long-task-source-authority-types.js";
+import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
 export type DesignResourceDecisionOrigin = "user-direct" | "necessary-derived" | "repository-evidence-backed" | "provider-suggested";
 export type DesignResourceDecisionStatus = "accepted" | "rejected" | "unresolved";
 export type DesignResourceDecisionAuthority = "explicit-user" | "none" | `delegated:${string}`;
@@ -71,7 +72,9 @@ export interface DesignResourceDelta {
     explicitly_unchanged_keys: string[];
     status: DesignResourceDecisionStatus;
 }
-export type DesignResourceAuthorityIdentity = {
+export type DesignResourceAuthorityIdentity = ({
+    kind: "repository-closure";
+} & DesignAuthorityIdentityV1) | {
     kind: "repository-file" | "external-immutable";
     locator: string;
     raw_byte_digest: string;

package/dist/lib/design-resource-symbolic-fact-shape.js

@@ -1,6 +1,7 @@
 import { parseDesignResourceHandoffResources } from "./design-resource-handoff-shape-structure.js";
 import { contractKey, sourceItemKeys, stableKey, stableKeys, } from "./design-resource-handoff-shape-primitives.js";
 import { parseDesignResourceTechnicalFeasibilityInputs } from "./design-resource-implementation-feasibility-shape.js";
+import { parseDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 import { array, literal, object, repositoryFile, string, strings, } from "./long-task-shape-primitives.js";
 export { parseDesignResourceObservableRuleManifestJson, parseDesignResourceObservableRuleManifestShape, } from "./design-resource-symbolic-manifest-shape.js";
 export function parseDesignResourceSymbolicHandoffShape(value) {
@@ -15,13 +16,18 @@ export function parseDesignResourceSymbolicHandoffShape(value) {
         "targets",
         "coverage",
         "proposal",
-    ], ["technical_feasibility_inputs"]);
+    ], ["technical_feasibility_inputs", "project_design_authority"]);
     return {
         schema_version: literal(root.schema_version, ["design-resource-handoff-v2"], `${label}.schema_version`),
         representation: literal(root.representation, ["symbolic_rules_v2"], `${label}.representation`),
         intent: literal(root.intent, ["implementation_handoff"], `${label}.intent`),
         scope: parseScope(root.scope, label),
         provenance: parseProvenance(root.provenance, label),
+        ...(root.project_design_authority === undefined
+            ? {}
+            : {
+                project_design_authority: parseDesignAuthorityHandoffBinding(root.project_design_authority, `${label}.project_design_authority`),
+            }),
         technical_feasibility_inputs: parseDesignResourceTechnicalFeasibilityInputs(root.technical_feasibility_inputs ?? [], `${label}.technical_feasibility_inputs`),
         resources: parseDesignResourceHandoffResources(root.resources),
         targets: parseTargets(root.targets, label),

package/dist/lib/design-resource-symbolic-fact-types.d.ts

@@ -4,6 +4,7 @@ import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffResourceV1, D
 import type { CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationDisposition, SymbolicDenotationPredicate, SymbolicExtensionalPointV1 } from "./symbolic-denotation-types.js";
 import type { DesignResourceSymbolicNoninterferenceCertificateV2 } from "./design-resource-symbolic-noninterference-types.js";
 import type { DesignResourceImplementationFeasibilityIdentityV1, DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalFeasibilityInputV1 } from "./design-resource-implementation-feasibility-types.js";
+import type { DesignAuthorityHandoffBinding, DesignAuthorityHandoffResolution } from "./design-authority-types.js";
 export type { DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceEquivalenceCaseV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofMethodV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicStaticDependencyNodeV2, DesignResourceSymbolicStaticDependencyRootV2, } from "./design-resource-symbolic-noninterference-types.js";
 export interface DesignResourceSymbolicPopulationV2 {
     key: string;
@@ -176,6 +177,7 @@ export interface DesignResourceHandoffV2 {
         model: string;
         design_system_id: string;
     };
+    project_design_authority?: DesignAuthorityHandoffBinding;
     technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     targets: DesignResourceSymbolicHandoffTargetV2[];
@@ -199,6 +201,7 @@ export interface DesignResourceSymbolicRuleProjectionV2 {
 export interface DesignResourceHandoffPreflightV2 extends ParsedDesignResourceHandoffV2 {
     preflight_schema_version: "design-resource-handoff-preflight-v2";
     status: "ready";
+    project_design_authority_resolution: DesignAuthorityHandoffResolution;
     manifest: DesignResourceObservableRuleManifestV2;
     resource_hashes: Record<string, string>;
     technical_feasibility_documents: DesignResourceImplementationFeasibilityV1[];

package/dist/lib/design-resource-symbolic-fact-validation.js

@@ -9,10 +9,16 @@ import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { sha256Hex } from "./strict-codec.js";
 import { createV2ImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
 import { readAndValidateDesignResourceImplementationFeasibility } from "./design-resource-implementation-feasibility-validation.js";
+import { resolveDesignAuthorityHandoffBinding } from "./design-authority-binding.js";
 export { designResourceSymbolicCertificateKey, designResourceSymbolicCombinedRuleDigest, designResourceSymbolicDependencyEdge, designResourceSymbolicNoninterferenceProofDigest, designResourceSymbolicObligationKey, designResourceSymbolicRuleKey, } from "./design-resource-symbolic-validation-support.js";
 const V2_MANIFEST_MAX_BYTES = 8_388_608;
 export async function preflightParsedDesignResourceSymbolicHandoff(repository, parsed) {
     const { handoff } = parsed;
+    const authorityResolution = await resolveDesignAuthorityHandoffBinding({
+        repository,
+        style_dependency: handoff.scope.style_dependency,
+        binding: handoff.project_design_authority,
+    });
     validateHandoffIdentities(handoff);
     if (handoff.targets.length !== 1)
         invalid("v2_one_target_required", String(handoff.targets.length));
@@ -49,13 +55,19 @@ export async function preflightParsedDesignResourceSymbolicHandoff(repository, p
         ...parsed,
         preflight_schema_version: "design-resource-handoff-preflight-v2",
         status: "ready",
+        project_design_authority_resolution: authorityResolution,
         manifest,
         resource_hashes: resourceHashes,
         technical_feasibility_documents: feasibility.map((item) => item.document),
         technical_feasibility_identities: feasibility.map((item) => item.identity),
-        limitations: target.source_profile.kind !== "reference" && !feasibility.length
-            ? ["technical feasibility not declared"]
-            : [],
+        limitations: [
+            ...(authorityResolution.compatibility_derived
+                ? ["project Design Authority identity derived from legacy DESIGN.md"]
+                : []),
+            ...(target.source_profile.kind !== "reference" && !feasibility.length
+                ? ["technical feasibility not declared"]
+                : []),
+        ],
         rule_projections: validated.ruleProjections,
         metrics: validated.metrics,
     };

package/dist/lib/doctor.d.ts

@@ -1,6 +1,7 @@
+import type { ContextDoctorOptions } from "./context-doctor/context-doctor-types.js";
 export interface DoctorReport {
     info: string[];
     warnings: string[];
     errors: string[];
 }
-export declare function runDoctor(projectRoot: string): Promise<DoctorReport>;
+export declare function runDoctor(projectRoot: string, options?: ContextDoctorOptions): Promise<DoctorReport>;