project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,138 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignResourceImplementationFeasibilityJson } from "./design-resource-implementation-feasibility-shape.js";
+import { loadDesignResourceFeasibilityDecisionSource, } from "./design-resource-implementation-feasibility-source-decision.js";
+import { validateFeasibilityDocument } from "./design-resource-implementation-feasibility-validation-document.js";
+import { invalidFeasibility, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
+import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
+import { sha256Hex } from "./strict-codec.js";
+const FEASIBILITY_MAX_BYTES = 2_097_152;
+const TECHNICAL_SOURCE_MAX_BYTES = 16_777_216;
+export async function readAndValidateDesignResourceImplementationFeasibility(repository, handoffPath, inputs, targetModels, canonicalResourcePaths) {
+    unique(inputs.map((item) => item.key), "input_key_duplicate");
+    unique(inputs.map((item) => item.path), "input_path_duplicate");
+    unique(inputs.map((item) => item.target_ref), "input_target_duplicate");
+    for (const input of inputs)
+        if (!targetModels.has(input.target_ref))
+            invalidFeasibility("input_target_unknown", input.target_ref);
+    validateTargetInputCoverage(inputs, targetModels);
+    const loaded = [];
+    const sourcePathIdentities = new Map();
+    for (const input of inputs) {
+        const model = targetModels.get(input.target_ref);
+        if (!model)
+            invalidFeasibility("input_target_unknown", input.target_ref);
+        if (input.path === handoffPath)
+            invalidFeasibility("input_must_not_be_handoff", input.key);
+        if (canonicalResourcePaths.has(input.path))
+            invalidFeasibility("input_mixed_into_canonical_resources", input.path);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...input.path.split("/")), `design_resource_feasibility:${input.key}`);
+        const size = (await stat(file)).size;
+        if (size > FEASIBILITY_MAX_BYTES)
+            invalidFeasibility("input_byte_limit_exceeded", `${input.key}:bytes=${size}:limit=${FEASIBILITY_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== input.sha256)
+            invalidFeasibility("input_digest_mismatch", `${input.key}:${input.sha256}:${digest}`);
+        const content = bytes.toString("utf8");
+        if (!Buffer.from(content, "utf8").equals(bytes))
+            invalidFeasibility("input_utf8_invalid", input.key);
+        const document = parseDesignResourceImplementationFeasibilityJson(content);
+        if (document.key !== input.key)
+            invalidFeasibility("input_key_mismatch", `${input.key}:${document.key}`);
+        if (document.target_ref !== input.target_ref)
+            invalidFeasibility("input_target_mismatch", `${input.target_ref}:${document.target_ref}`);
+        const decisionSources = await validateTechnicalSourceRecords(repository, handoffPath, input.path, document.source_records, canonicalResourcePaths, sourcePathIdentities);
+        await validateFeasibilityDocument(repository, document, model, decisionSources);
+        loaded.push({
+            index: input,
+            document,
+            identity: {
+                key: input.key,
+                target_ref: input.target_ref,
+                path: input.path,
+                sha256: digest,
+                realization_mode: document.realization_mode,
+                component_family_cells: document.component_family_cells.length,
+                blockers: document.blockers.length,
+            },
+        });
+    }
+    return loaded;
+}
+function validateTargetInputCoverage(inputs, targetModels) {
+    if (!inputs.length)
+        return;
+    const indexedTargets = new Set(inputs.map((item) => item.target_ref));
+    for (const model of targetModels.values())
+        if (model.source_profile_kind !== "reference" &&
+            !indexedTargets.has(model.target_ref))
+            invalidFeasibility("implementation_target_input_missing", model.target_ref);
+}
+async function validateTechnicalSourceRecords(repository, handoffPath, inputPath, records, canonicalResourcePaths, sharedPathIdentities) {
+    const decisionSources = new Map();
+    unique(records.map((item) => item.key), "source_record_key_duplicate");
+    unique(records.map((item) => `${item.path}\0${item.locator.kind}\0${item.locator.value}`), "source_record_locator_duplicate");
+    for (const record of records) {
+        if (!record.roles.length)
+            invalidFeasibility("source_record_roles_required", record.key);
+        unique(record.roles, "source_record_role_duplicate", record.key);
+        if (record.path === handoffPath || record.path === inputPath)
+            invalidFeasibility("source_record_self_reference", `${record.key}:${record.path}`);
+        if (canonicalResourcePaths.has(record.path))
+            invalidFeasibility("technical_source_mixed_into_canonical_resources", record.path);
+        validateSharedSourceIdentity(record, sharedPathIdentities);
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...record.path.split("/")), `design_resource_feasibility_source:${record.key}`);
+        const size = (await stat(file)).size;
+        if (size > TECHNICAL_SOURCE_MAX_BYTES)
+            invalidFeasibility("source_record_byte_limit_exceeded", `${record.key}:bytes=${size}:limit=${TECHNICAL_SOURCE_MAX_BYTES}`);
+        const bytes = await readFile(file);
+        const digest = sha256Hex(bytes);
+        if (digest !== record.sha256)
+            invalidFeasibility("source_record_digest_mismatch", `${record.key}:${record.sha256}:${digest}`);
+        const decisionSource = validateSourceLocator(record, bytes);
+        if (decisionSource)
+            decisionSources.set(record.key, decisionSource);
+    }
+    return decisionSources;
+}
+function validateSharedSourceIdentity(record, sharedPathIdentities) {
+    const identity = `${record.media_type}\0${record.sha256}`;
+    const previous = sharedPathIdentities.get(record.path);
+    if (previous && previous !== identity)
+        invalidFeasibility("source_record_path_identity_conflict", record.path);
+    sharedPathIdentities.set(record.path, identity);
+}
+function validateSourceLocator(record, bytes) {
+    if (record.locator.kind === "whole_resource")
+        return null;
+    const content = bytes.toString("utf8");
+    if (!Buffer.from(content, "utf8").equals(bytes))
+        invalidFeasibility("source_record_utf8_invalid", record.key);
+    if (record.locator.kind === "source_item")
+        return loadDesignResourceFeasibilityDecisionSource(record, content);
+    if (record.locator.kind === "json_pointer") {
+        validateJsonPointer(record, content);
+        return null;
+    }
+    if (!content.includes(record.locator.value))
+        invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+    return null;
+}
+function validateJsonPointer(record, content) {
+    let current;
+    try {
+        current = JSON.parse(content);
+    }
+    catch {
+        invalidFeasibility("source_record_json_invalid", record.key);
+    }
+    for (const raw of record.locator.value.slice(1).split("/")) {
+        const segment = raw.replace(/~1/gu, "/").replace(/~0/gu, "~");
+        if (!current ||
+            typeof current !== "object" ||
+            !Object.hasOwn(current, segment))
+            invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
+        current = current[segment];
+    }
+}

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,5 +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) {
@@ -14,13 +16,19 @@ export function parseDesignResourceSymbolicHandoffShape(value) {
         "targets",
         "coverage",
         "proposal",
-    ]);
+    ], ["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),
         coverage: parseCoverage(root.coverage, label),

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

@@ -3,6 +3,8 @@ import type { DesignResourceEnvironmentV1, DesignResourceFactLineageV1, DesignRe
 import type { DesignResourceHandoffBlockerV1, DesignResourceHandoffResourceV1, DesignResourceHandoffSubjectV1, DesignResourceSourceProfileKind, DesignResourceVerificationMethod } from "./design-resource-handoff-types.js";
 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;
@@ -175,6 +177,8 @@ export interface DesignResourceHandoffV2 {
         model: string;
         design_system_id: string;
     };
+    project_design_authority?: DesignAuthorityHandoffBinding;
+    technical_feasibility_inputs: DesignResourceTechnicalFeasibilityInputV1[];
     resources: DesignResourceHandoffResourceV1[];
     targets: DesignResourceSymbolicHandoffTargetV2[];
     coverage: DesignResourceSymbolicHandoffCoverageV2[];
@@ -197,8 +201,12 @@ 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[];
+    technical_feasibility_identities: DesignResourceImplementationFeasibilityIdentityV1[];
+    limitations: string[];
     rule_projections: DesignResourceSymbolicRuleProjectionV2[];
     metrics: {
         semantic_obligations: number;

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

@@ -7,10 +7,18 @@ import { validateSymbolicCoverage } from "./design-resource-symbolic-region-vali
 import { assertSameSet, invalid, requireExactRefs, unique, } from "./design-resource-symbolic-validation-support.js";
 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));
@@ -37,12 +45,29 @@ export async function preflightParsedDesignResourceSymbolicHandoff(repository, p
         invalid("v2_manifest_identity_mismatch", `${manifest.scope_key}:${manifest.target_key}`);
     const validated = validateDesignResourceSymbolicManifest(manifest, parsed, resources, contents);
     validateSymbolicCoverage(parsed, manifest);
+    const feasibility = await readAndValidateDesignResourceImplementationFeasibility(repository, parsed.handoff_path, handoff.technical_feasibility_inputs, new Map([
+        [
+            target.key,
+            createV2ImplementationFeasibilityTargetModel(target, manifest),
+        ],
+    ]), new Set(handoff.resources.map((resource) => resource.path)));
     return {
         ...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: [
+            ...(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>;

package/dist/lib/doctor.js

@@ -5,12 +5,14 @@ import { readdir } from "node:fs/promises";
 import { DEFAULT_CONTEXT_FILE_SOFT_BUDGET_BYTES, DEFAULT_CONTEXT_TOTAL_SOFT_BUDGET_BYTES, inspectDefaultContextFootprint, } from "./context-default-footprint.js";
 import { readConfig } from "./config.js";
 import { inspectDesignAuthority } from "./design-md.js";
+import { inspectDesignAuthorityClosure } from "./design-authority-closure.js";
 import { harnessConfigPath, harnessRoot } from "./harness-root.js";
 import { pathExists } from "./fs.js";
 import { unsupportedSchemaMessage } from "./schema-guard.js";
+import { inspectContextCatalogHealth } from "./context-doctor/context-doctor.js";
 const require = createRequire(import.meta.url);
 const packageMetadata = require("../../package.json");
-export async function runDoctor(projectRoot) {
+export async function runDoctor(projectRoot, options = {}) {
     const report = { info: [], warnings: [], errors: [] };
     const root = await harnessRoot(projectRoot);
     const relativeConfigPath = await harnessConfigPath(projectRoot);
@@ -63,6 +65,15 @@ export async function runDoctor(projectRoot) {
     catch (error) {
         report.warnings.push(`default Context footprint unavailable: ${error instanceof Error ? error.message : String(error)}`);
     }
+    try {
+        const contextHealth = await inspectContextCatalogHealth(projectRoot, options);
+        report.info.push(...contextHealth.info);
+        report.warnings.push(...contextHealth.warnings);
+        report.errors.push(...contextHealth.errors);
+    }
+    catch (error) {
+        report.warnings.push(`all-Context diagnostics unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const designAuthority = await inspectDesignAuthority(projectRoot);
     if (designAuthority.status === "unconfigured") {
         report.info.push("design authority: unconfigured; DESIGN.md is a starter scaffold and does not authorize material production UI until project-specific tokens and exact-target/constraint/inspiration references are selected");
@@ -84,6 +95,23 @@ export async function runDoctor(projectRoot) {
             }
         }
     }
+    const authorityClosure = await inspectDesignAuthorityClosure(projectRoot);
+    if (authorityClosure.status === "valid" && authorityClosure.identity) {
+        report.info.push(`design authority closure: ${authorityClosure.mode}, ${authorityClosure.members.length} member(s), ${authorityClosure.identity.closure_digest}`);
+    }
+    else if (authorityClosure.status === "invalid") {
+        for (const diagnostic of authorityClosure.diagnostics) {
+            const detail = `design authority closure ${diagnostic.code}${diagnostic.path ? ` (${diagnostic.path})` : ""}: ${diagnostic.detail}`;
+            if (diagnostic.severity === "error")
+                report.errors.push(detail);
+            else
+                report.warnings.push(detail);
+        }
+    }
+    if (authorityClosure.status === "valid")
+        for (const diagnostic of authorityClosure.diagnostics)
+            if (diagnostic.severity === "warning")
+                report.warnings.push(`design authority closure ${diagnostic.code}${diagnostic.path ? ` (${diagnostic.path})` : ""}: ${diagnostic.detail}`);
     report.info.push("surface implementation readiness: not inferred; inspect owning Product Surface/Screen/Control Context, selected target or constraints, authored token source and project-owned verification for each material surface");
     for (const location of await findUserSuperpowersSkills()) {
         report.warnings.push(`user-level using-superpowers Skill detected at ${location}. Tiny Context workflows do not depend on it and doctor will not modify global configuration. To disable it explicitly for Codex, remove/disable that plugin or add a matching [[skills.config]] entry with enabled = false in ${path.join(os.homedir(), ".codex", "config.toml")}.`);

package/dist/lib/fs.js

@@ -27,7 +27,7 @@ export async function listFiles(root) {
     if (!(await pathExists(root))) {
         return [];
     }
-    const entries = await fs.readdir(root, { withFileTypes: true });
+    const entries = (await fs.readdir(root, { withFileTypes: true })).sort((left, right) => Buffer.compare(Buffer.from(left.name, "utf8"), Buffer.from(right.name, "utf8")));
     const files = [];
     for (const entry of entries) {
         const fullPath = path.join(root, entry.name);

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

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