project-tiny-context-harness 0.11.0 → 0.12.1

package/dist/lib/context-controlling-source.js

@@ -0,0 +1,106 @@
+import { readFile, realpath } from "node:fs/promises";
+import { TextDecoder } from "node:util";
+import { compareUtf8Paths, normalizeContextPath, repositoryRelativePathSpelling, } from "./context-catalog/catalog-paths.js";
+import { normalizeRepositoryFile } from "./repository-path-safety.js";
+import { assertSafeRepositoryFilePath } from "./repository-path-safety.js";
+export async function resolveContextControllingSourceDeclaration(projectRoot, declaration) {
+    let targetPath;
+    try {
+        targetPath = canonicalControllingSourcePath(declaration.declared_path);
+    }
+    catch (error) {
+        return invalidDeclaration(declaration, null, error);
+    }
+    try {
+        const safe = await assertSafeRepositoryFilePath(projectRoot, targetPath, `context_controlling_source:${declaration.source_path}:${declaration.line}`);
+        const physicalPath = normalizeContextPath(repositoryRelativePathSpelling(safe.repository, await realpath(safe.absolute)));
+        if (physicalPath !== targetPath)
+            return {
+                ...declaration,
+                target_path: targetPath,
+                status: "invalid",
+                detail: `declared path casing or spelling differs from the physical repository path ${physicalPath}`,
+            };
+        const decoded = decodeStrictUtf8(await readFile(safe.absolute));
+        if (decoded === null)
+            return {
+                ...declaration,
+                target_path: targetPath,
+                status: "invalid",
+                detail: "declared controlling Source must be a non-NUL strict UTF-8 file",
+            };
+        return {
+            ...declaration,
+            target_path: targetPath,
+            status: "valid",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = message.includes("not_found") ? "missing" : "invalid";
+        return {
+            ...declaration,
+            target_path: targetPath,
+            status,
+            detail: message,
+        };
+    }
+}
+export function contextControllingSourceConflicts(declarations) {
+    const byTarget = new Map();
+    for (const declaration of declarations) {
+        if (declaration.status !== "valid" || !declaration.target_path)
+            continue;
+        const rows = byTarget.get(declaration.target_path) ?? [];
+        rows.push(declaration);
+        byTarget.set(declaration.target_path, rows);
+    }
+    const conflicts = [];
+    for (const [targetPath, rows] of byTarget) {
+        if (rows.length < 2)
+            continue;
+        const domains = [...new Set(rows.map((row) => row.domain))].sort();
+        conflicts.push({
+            kind: domains.length === 1 ? "duplicate" : "domain_conflict",
+            target_path: targetPath,
+            domains,
+            owners: rows
+                .map((row) => ({
+                source_path: row.source_path,
+                line: row.line,
+                domain: row.domain,
+            }))
+                .sort((left, right) => compareUtf8Paths(left.source_path, right.source_path) ||
+                left.line - right.line ||
+                left.domain.localeCompare(right.domain)),
+        });
+    }
+    return conflicts.sort((left, right) => compareUtf8Paths(left.target_path, right.target_path));
+}
+export function canonicalControllingSourcePath(value) {
+    if (value !== value.normalize("NFC") || value !== value.trim())
+        throw new Error(`context_controlling_source_path_noncanonical:${value}`);
+    if (value.includes("\\") || /[?#]/u.test(value))
+        throw new Error(`context_controlling_source_path_noncanonical:${value}`);
+    const normalized = normalizeRepositoryFile(value, "context_controlling_source");
+    if (normalized !== value)
+        throw new Error(`context_controlling_source_path_noncanonical:${value}`);
+    return normalized;
+}
+function invalidDeclaration(declaration, targetPath, error) {
+    return {
+        ...declaration,
+        target_path: targetPath,
+        status: "invalid",
+        detail: error instanceof Error ? error.message : String(error),
+    };
+}
+function decodeStrictUtf8(bytes) {
+    try {
+        const value = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        return value.includes("\0") ? null : value;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/context-create/context-create.js

@@ -1,4 +1,5 @@
 import { CLI_EXIT_CODES, CliCommandError } from "../cli-exit.js";
+import { assertSupportedSchema } from "../schema-guard.js";
 import { loadContextCatalog } from "../context-catalog/catalog-load.js";
 import { normalizeContextPath } from "../context-catalog/catalog-paths.js";
 import { CONTEXT_ROLES, normalizeContextRole, } from "../context-catalog/catalog-portable-contract.js";
@@ -6,6 +7,7 @@ import { normalizeContextCreatePath } from "./context-create-path.js";
 import { renderContextCreateScaffold } from "./context-create-template.js";
 import { publishContextScaffold } from "./context-create-write.js";
 export async function createContextScaffold(input) {
+    await assertSupportedSchema(input.project_root, "context create");
     const contextPath = normalizeContextCreatePath(input.context_path);
     const role = normalizeContextRole(input.role);
     if (!role)

package/dist/lib/context-default-footprint.js

@@ -70,6 +70,8 @@ function physicalDefaultPaths(manifest) {
         addOwner(core);
     for (const area of manifest.areas)
         addOwner(area.context);
+    for (const file of manifest.default_files ?? [])
+        addOwner(file);
     for (const context of manifest.contexts)
         addOwner(context.path);
     for (const context of manifest.contexts)

package/dist/lib/context-doctor/context-doctor-types.d.ts

@@ -1,16 +1,6 @@
 export declare const CONTEXT_DOCTOR_DEFAULTS: Readonly<{
     context_file_soft_budget_bytes: number;
-    long_line_code_points: 1000;
-    trigger_fanout_contexts: 4;
 }>;
 export interface ContextDoctorOptions {
     context_file_soft_budget_bytes?: number;
-    long_line_code_points?: number;
-    trigger_fanout_contexts?: number;
 }
-export interface ContextDoctorAnalysis {
-    info: string[];
-    warnings: string[];
-    errors: string[];
-}
-export declare function resolveContextDoctorOptions(options?: ContextDoctorOptions): Required<ContextDoctorOptions>;

package/dist/lib/context-doctor/context-doctor-types.js

@@ -1,15 +1,3 @@
 export const CONTEXT_DOCTOR_DEFAULTS = Object.freeze({
     context_file_soft_budget_bytes: 64 * 1024,
-    long_line_code_points: 1_000,
-    trigger_fanout_contexts: 4,
 });
-export function resolveContextDoctorOptions(options = {}) {
-    return {
-        context_file_soft_budget_bytes: options.context_file_soft_budget_bytes ??
-            CONTEXT_DOCTOR_DEFAULTS.context_file_soft_budget_bytes,
-        long_line_code_points: options.long_line_code_points ??
-            CONTEXT_DOCTOR_DEFAULTS.long_line_code_points,
-        trigger_fanout_contexts: options.trigger_fanout_contexts ??
-            CONTEXT_DOCTOR_DEFAULTS.trigger_fanout_contexts,
-    };
-}

package/dist/lib/context-export.js

@@ -3,8 +3,11 @@ import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
-import { ensureDir, listFiles, pathExists, readText, writeTextIfChanged, } from "./fs.js";
+import { listFiles, pathExists, readText, } from "./fs.js";
 import { harnessRoot } from "./harness-root.js";
+import { assertSupportedSchema } from "./schema-guard.js";
+import { withMaintenanceLock } from "./maintenance-lock.js";
+import { writeMaintenanceText } from "./maintenance-write.js";
 import { SAFE_EXAMPLE_FILE_NAMES, shouldExcludeRelativePath, shouldIncludeCodeFile, toPosix, } from "./source-files.js";
 const execFileAsync = promisify(execFile);
 const EXPORT_HEADER = "Export artifact. Do not reference from project_context/context.toml.";
@@ -16,14 +19,21 @@ const GIT_LS_MAX_BUFFER = 64 * 1024 * 1024;
 const APPROX_TEXT_TOKEN_LIMIT_CHARS = 8_000_000;
 const SENSITIVE_ASSIGNMENT_PATTERN = /^(\s*(?:[-*]\s*)?(?:[`"']?[\w.-]*(?:secret|token|cookie|password|api[_-]?key)[\w.-]*[`"']?\s*[:=]\s*))(.+?)\s*$/i;
 export async function runExportContext(projectRoot, options = {}) {
+    if (!options.check)
+        await assertSupportedSchema(projectRoot, "export-context");
     const requestedModeCount = Number(options.full === true) + Number(options.code === true);
     if (requestedModeCount !== 1) {
         throw new Error("export-context requires exactly one of --full or --code");
     }
-    if (options.code) {
-        return runCodeImplementationExport(projectRoot, options);
-    }
-    return runFullContextExport(projectRoot, options);
+    const execute = () => options.code
+        ? runCodeImplementationExport(projectRoot, options)
+        : runFullContextExport(projectRoot, options);
+    if (options.check)
+        return execute();
+    return withMaintenanceLock(projectRoot, "export", async () => {
+        await assertSupportedSchema(projectRoot, "export-context");
+        return execute();
+    });
 }
 async function runFullContextExport(projectRoot, options) {
     const outputPath = resolveOutputPath(projectRoot, options.output, options.now, "full");
@@ -93,8 +103,7 @@ async function runFullContextExport(projectRoot, options) {
         "",
     ].join("\n");
     if (!options.check) {
-        await ensureDir(path.dirname(outputPath));
-        await writeTextIfChanged(outputPath, content);
+        await writeMaintenanceText(projectRoot, outputRelativePath, content);
     }
     return {
         mode: "full",
@@ -171,8 +180,7 @@ async function runCodeImplementationExport(projectRoot, options) {
         "",
     ].join("\n");
     if (!options.check) {
-        await ensureDir(path.dirname(outputPath));
-        await writeTextIfChanged(outputPath, content);
+        await writeMaintenanceText(projectRoot, outputRelativePath, content);
     }
     return {
         mode: "code",

package/dist/lib/context-inspect/context-inspect-projection.d.ts

@@ -1,9 +1,8 @@
 import type { ContextCatalog } from "../context-catalog/catalog-types.js";
 import type { ContextMarkdownCatalogAnalysis } from "../context-markdown/context-markdown-types.js";
-import type { ContextInspectResult, ContextInspectRoute } from "./context-inspect-types.js";
+import type { ContextInspectResult } from "./context-inspect-types.js";
 export declare function projectContextInspection(input: {
     catalog: ContextCatalog;
     markdown: ContextMarkdownCatalogAnalysis;
     context_path: string;
-    route: ContextInspectRoute | null;
 }): ContextInspectResult;

package/dist/lib/context-inspect/context-inspect-projection.js

@@ -35,7 +35,6 @@ export function projectContextInspection(input) {
         references: [...fileAnalysis.references].sort(referenceOrder),
         stable_key_declarations: fileAnalysis.declarations,
         stable_key_conflicts: input.markdown.declaration_conflicts.filter((conflict) => declarationKeys.has(`${conflict.type}\0${conflict.id}`)),
-        route: input.route,
         diagnostics: input.catalog.diagnostics.filter((diagnostic) => diagnostic.severity === "error" ||
             diagnostic.path === undefined ||
             diagnostic.path === input.context_path),

package/dist/lib/context-inspect/context-inspect-render.js

@@ -15,14 +15,6 @@ export function renderContextInspectText(result) {
     for (const reference of result.references)
         lines.push(`  ${reference.line}:${reference.column} ${reference.status} ${reference.target_path ?? reference.destination}`);
     lines.push(`stable_key_declarations=${result.stable_key_declarations.length} conflicts=${result.stable_key_conflicts.length}`);
-    if (result.route) {
-        lines.push(`route complete=${result.route.complete} catalog_valid=${result.route.catalog_valid} selected=${result.route.selected}`);
-        if (result.route.candidate)
-            for (const reason of result.route.candidate.reasons)
-                lines.push(`  ${reason.kind}: ${reason.input} — ${reason.detail}`);
-        else
-            lines.push("  no path, trigger, bounded literal or manual selection reason matched this Context");
-    }
     for (const diagnostic of result.diagnostics)
         lines.push(`${diagnostic.severity}: ${diagnostic.code}: ${diagnostic.message}`);
     return `${lines.join("\n")}\n`;

package/dist/lib/context-inspect/context-inspect-types.d.ts

@@ -2,15 +2,6 @@ import type { CatalogDiagnostic } from "../context-catalog/catalog-types.js";
 import type { ContextRole } from "../context-catalog/catalog-portable-contract.js";
 import type { DefaultContextSelectionReason } from "../context-catalog/catalog-default-footprint.js";
 import type { ContextMarkdownReference, ContextStableKeyConflict, ContextStableKeyDeclaration } from "../context-markdown/context-markdown-types.js";
-import type { ContextRouteAmbiguity, ContextRouteCandidate, ContextRouteUnresolved } from "../context-router/context-route-types.js";
-export interface ContextInspectRoute {
-    complete: boolean;
-    catalog_valid: boolean;
-    selected: boolean;
-    candidate: ContextRouteCandidate | null;
-    ambiguous: ContextRouteAmbiguity[];
-    unresolved: ContextRouteUnresolved[];
-}
 export interface ContextInspectResult {
     schema_version: 1;
     path: string;
@@ -30,14 +21,9 @@ export interface ContextInspectResult {
     references: ContextMarkdownReference[];
     stable_key_declarations: ContextStableKeyDeclaration[];
     stable_key_conflicts: ContextStableKeyConflict[];
-    route: ContextInspectRoute | null;
     diagnostics: CatalogDiagnostic[];
 }
 export interface ContextInspectInput {
     project_root: string;
     context_path: string;
-    route_task?: string;
-    route_paths?: string[];
-    route_terms?: string[];
-    route_case_sensitive?: boolean;
 }

package/dist/lib/context-inspect/context-inspect.js

@@ -4,7 +4,6 @@ import { CLI_EXIT_CODES, CliCommandError } from "../cli-exit.js";
 import { loadContextCatalog } from "../context-catalog/catalog-load.js";
 import { isPathWithin, normalizeContextPath, } from "../context-catalog/catalog-paths.js";
 import { analyzeContextMarkdownCatalog } from "../context-markdown/context-markdown-analysis.js";
-import { routeContext } from "../context-router/context-route.js";
 import { projectContextInspection } from "./context-inspect-projection.js";
 export async function inspectContext(input) {
     const projectRoot = path.resolve(input.project_root);
@@ -38,37 +37,11 @@ export async function inspectContext(input) {
     catch (error) {
         throw new CliCommandError(CLI_EXIT_CODES.io, `unable to analyze Context Markdown: ${message(error)}`, { cause: error });
     }
-    const routeRequested = input.route_task !== undefined ||
-        (input.route_paths?.length ?? 0) > 0 ||
-        (input.route_terms?.length ?? 0) > 0;
-    let route = null;
-    if (routeRequested) {
-        const routed = await routeContext({
-            project_root: projectRoot,
-            task: input.route_task ?? "",
-            paths: input.route_paths ?? [],
-            explicit_terms: input.route_terms ?? [],
-            case_sensitive: input.route_case_sensitive,
-        });
-        const candidate = [
-            ...routed.candidates,
-            ...routed.unregistered_matches,
-        ].find((entry) => entry.path === contextPath);
-        route = {
-            complete: routed.complete,
-            catalog_valid: routed.catalog_valid,
-            selected: Boolean(candidate),
-            candidate: candidate ?? null,
-            ambiguous: routed.ambiguous,
-            unresolved: routed.unresolved,
-        };
-    }
     try {
         return projectContextInspection({
             catalog,
             markdown,
             context_path: contextPath,
-            route,
         });
     }
     catch (error) {

package/dist/lib/context-manifest-schema.d.ts

@@ -18,6 +18,7 @@ export interface ContextNodeEntry {
     default_children: string[];
 }
 export interface ContextManifest {
+    default_files?: string[];
     areas: ContextAreaEntry[];
     contexts: ContextNodeEntry[];
 }

package/dist/lib/context-manifest-schema.js

@@ -62,7 +62,8 @@ export function parseContextManifest(content, file = "project_context/context.to
             });
         }
     }
-    return { manifest: { areas, contexts }, errors };
+    const default_files = optionalStringArray(parsed, "default_files", file, errors);
+    return { manifest: { areas, contexts, default_files }, errors };
 }
 function tableArray(value, label, file, errors) {
     if (value === undefined) {

package/dist/lib/context-manifest.js

@@ -2,47 +2,7 @@ import path from "node:path";
 import { listFiles } from "./fs.js";
 export const CONTEXT_MANIFEST_PATH = "project_context/context.toml";
 export function defaultContextManifestTemplate() {
-    return [
-        "# Schema v4 Minimal Context graph manifest.",
-        "# Keep the default product/domain area for ordinary projects. Role context nodes",
-        "# are read-purpose slices owned by an area or, only when cross-domain, by the project root.",
-        "# A monorepo may place only Context-bearing implementation workspaces under",
-        "# project_context/workspaces/<workspace-id>/**. Each represented Context workspace",
-        "# maps one code root through existing area root/context fields and may contain several Areas.",
-        "# Keep cross-workspace Areas under project_context/areas/**; do not create empty",
-        "# Context directories for code workspaces with no durable facts.",
-        "# Prefer a small top-level repository-common default Area; keep workspace-local",
-        "# Context on-demand unless its facts are genuinely near-universal.",
-        "# Default/on-demand selection defines the starting read set, not a maximum;",
-        "# widen to any relevant area/shared Context when task dependencies require it.",
-        "# This optional sparse mirror adds no workspace schema or read/edit ACL. Use",
-        "# project-owned scope checks for task-local intended/supporting changed paths.",
-        "# When migrating deep files under project_context/areas/**, refine obvious",
-        "# contract/foundation/subdomain/verification/deployment/implementation-index/",
-        "# decision-rationale/archive files into [[context]] entries instead of keeping",
-        "# every Markdown file as an [[areas]] product owner.",
-        "",
-        "[[areas]]",
-        'id = "main"',
-        'root = "."',
-        'context = "project_context/areas/main.md"',
-        'kind = "app"',
-        "default = true",
-        "",
-        "[[context]]",
-        'path = "project_context/areas/main/verification.md"',
-        'role = "verification"',
-        'read_policy = "default"',
-        'triggers = ["test", "verify", "verification", "smoke", "ci"]',
-        "",
-        "# Example optional node:",
-        "# [[context]]",
-        '# path = "project_context/areas/main/deployment.md"',
-        '# role = "deployment"',
-        '# read_policy = "on-demand"',
-        '# triggers = ["deploy", "deployment", "runtime", "cloud", "docker"]',
-        "",
-    ].join("\n");
+    return '# Tiny Context routing. global.md is always read.\n# Add optional [[areas]] or [[context]] nodes only when useful.\n# read_policy = "default" traverses default_children; default_files selects files only.\n';
 }
 export async function contextManifestFromExistingAreas(projectRoot) {
     const areasRoot = path.join(projectRoot, "project_context", "areas");

package/dist/lib/context-markdown/context-markdown-analysis.js

@@ -2,6 +2,7 @@ import { lstat, readFile, realpath } from "node:fs/promises";
 import path from "node:path";
 import { compareUtf8Paths, isPathWithin, normalizeContextPath, } from "../context-catalog/catalog-paths.js";
 import { extractContextMarkdown } from "./context-markdown-extract.js";
+import { contextControllingSourceConflicts, resolveContextControllingSourceDeclaration, } from "../context-controlling-source.js";
 export async function analyzeContextMarkdownCatalog(input) {
     const files = [];
     const catalogFiles = new Map(input.files.map((file) => [file.path, file]));
@@ -14,9 +15,12 @@ export async function analyzeContextMarkdownCatalog(input) {
             file_overrides: input.file_overrides,
         }));
     const declarations = files.flatMap((file) => file.declarations);
+    const controllingSources = files.flatMap((file) => file.controlling_sources);
     return {
         files,
         references: files.flatMap((file) => file.references),
+        controlling_sources: controllingSources,
+        controlling_source_conflicts: contextControllingSourceConflicts(controllingSources),
         declarations,
         invalid_declarations: files.flatMap((file) => file.invalid_declarations),
         declaration_conflicts: declarationConflicts(declarations),
@@ -35,12 +39,16 @@ export async function analyzeContextMarkdownFile(input) {
         if (resolved)
             references.push(resolved);
     }
+    const controllingSources = [];
+    for (const declaration of extracted.controlling_sources)
+        controllingSources.push(await resolveContextControllingSourceDeclaration(input.project_root, declaration));
     return {
         path: input.file.path,
         bytes: Buffer.byteLength(content, "utf8"),
         max_line_code_points: lengths.maximum,
         long_lines: lengths.long,
         references,
+        controlling_sources: controllingSources,
         declarations: extracted.declarations,
         invalid_declarations: extracted.invalid_declarations,
     };

package/dist/lib/context-markdown/context-markdown-extract.d.ts

@@ -1,6 +1,7 @@
-import type { ContextInvalidDeclaration, ContextMarkdownRawReference, ContextStableKeyDeclaration } from "./context-markdown-types.js";
+import type { ContextControllingSourceRawDeclaration, ContextInvalidDeclaration, ContextMarkdownRawReference, ContextStableKeyDeclaration } from "./context-markdown-types.js";
 export interface ContextMarkdownExtraction {
     references: ContextMarkdownRawReference[];
+    controlling_sources: ContextControllingSourceRawDeclaration[];
     declarations: ContextStableKeyDeclaration[];
     invalid_declarations: ContextInvalidDeclaration[];
 }

package/dist/lib/context-markdown/context-markdown-extract.js

@@ -1,8 +1,10 @@
 import { fromMarkdown } from "mdast-util-from-markdown";
 const DECLARATION = /^<!--\s*ty-context-declare\s+([A-Z][A-Za-z0-9]*-ID):\s*([A-Z][A-Z0-9]*(?:-[A-Z0-9]+)+)\s*-->$/u;
+const CONTROLLING_SOURCE_DECLARATION = /^<!-- ty-context-controlling-source domain="(product|technical|design|acceptance|external)" path="([^"]+)" -->$/u;
 export function extractContextMarkdown(content, sourcePath) {
     const tree = fromMarkdown(content);
     const references = [];
+    const controllingSources = [];
     const declarations = [];
     const invalidDeclarations = [];
     walk(tree, (node) => {
@@ -41,6 +43,7 @@ export function extractContextMarkdown(content, sourcePath) {
         else if (node.type === "html") {
             const raw = node.value.trim();
             const declaration = DECLARATION.exec(raw);
+            const controllingSource = CONTROLLING_SOURCE_DECLARATION.exec(raw);
             if (declaration)
                 declarations.push({
                     type: declaration[1],
@@ -49,6 +52,22 @@ export function extractContextMarkdown(content, sourcePath) {
                     line,
                     column,
                 });
+            else if (controllingSource)
+                controllingSources.push({
+                    domain: controllingSource[1],
+                    declared_path: controllingSource[2],
+                    source_path: sourcePath,
+                    line,
+                    column,
+                });
+            else if (raw.includes("ty-context-controlling-source"))
+                invalidDeclarations.push({
+                    path: sourcePath,
+                    raw,
+                    line,
+                    column,
+                    reason: 'controlling Source declaration must exactly match <!-- ty-context-controlling-source domain="product|technical|design|acceptance|external" path="repository/file" --> with this attribute order',
+                });
             else if (raw.includes("ty-context-declare"))
                 invalidDeclarations.push({
                     path: sourcePath,
@@ -71,6 +90,7 @@ export function extractContextMarkdown(content, sourcePath) {
     });
     return {
         references,
+        controlling_sources: controllingSources,
         declarations,
         invalid_declarations: invalidDeclarations,
     };

package/dist/lib/context-markdown/context-markdown-types.d.ts

@@ -1,5 +1,6 @@
 export type ContextMarkdownReferenceKind = "inline" | "image" | "definition" | "angle";
 export type ContextMarkdownReferenceStatus = "valid" | "missing" | "outside_repository" | "invalid";
+export type ContextControllingSourceDomain = "product" | "technical" | "design" | "acceptance" | "external";
 export interface ContextMarkdownRawReference {
     destination: string;
     kind: ContextMarkdownReferenceKind;
@@ -13,6 +14,28 @@ export interface ContextMarkdownReference extends ContextMarkdownRawReference {
     status: ContextMarkdownReferenceStatus;
     detail?: string;
 }
+export interface ContextControllingSourceRawDeclaration {
+    domain: ContextControllingSourceDomain;
+    declared_path: string;
+    source_path: string;
+    line: number;
+    column: number;
+}
+export interface ContextControllingSourceDeclaration extends ContextControllingSourceRawDeclaration {
+    target_path: string | null;
+    status: ContextMarkdownReferenceStatus;
+    detail?: string;
+}
+export interface ContextControllingSourceConflict {
+    kind: "duplicate" | "domain_conflict";
+    target_path: string;
+    domains: ContextControllingSourceDomain[];
+    owners: Array<{
+        source_path: string;
+        line: number;
+        domain: ContextControllingSourceDomain;
+    }>;
+}
 export interface ContextStableKeyDeclaration {
     type: string;
     id: string;
@@ -37,6 +60,7 @@ export interface ContextMarkdownFileAnalysis {
     max_line_code_points: number;
     long_lines: ContextLongLine[];
     references: ContextMarkdownReference[];
+    controlling_sources: ContextControllingSourceDeclaration[];
     declarations: ContextStableKeyDeclaration[];
     invalid_declarations: ContextInvalidDeclaration[];
 }
@@ -51,6 +75,8 @@ export interface ContextStableKeyConflict {
 export interface ContextMarkdownCatalogAnalysis {
     files: ContextMarkdownFileAnalysis[];
     references: ContextMarkdownReference[];
+    controlling_sources: ContextControllingSourceDeclaration[];
+    controlling_source_conflicts: ContextControllingSourceConflict[];
     declarations: ContextStableKeyDeclaration[];
     invalid_declarations: ContextInvalidDeclaration[];
     declaration_conflicts: ContextStableKeyConflict[];

package/dist/lib/context-move/context-move.js

@@ -2,7 +2,6 @@ import { captureMutationFileState } from "../context-mutation/mutation-cas.js";
 import { resolveCatalogFile } from "../context-catalog/catalog-paths.js";
 import { assertMutationCatalogValid, assertNoUnfinishedContextMutation, decodeMutationUtf8, loadMutationCatalog, mutationCatalogFailure, mutationIoFailure, mutationMessage, mutationStateBytes, } from "../context-mutation/mutation-command-support.js";
 import { executeContextMutationPlan } from "../context-mutation/mutation-commit.js";
-import { assertContextMutationOutsideActiveLongTask, contextMutationAffectedPaths, } from "../context-mutation/mutation-long-task-guard.js";
 import { replaceContextManifestPath, } from "../context-mutation/manifest-lossless-patch.js";
 import { contextFootprintState, stagedFileOverrides, } from "../context-mutation/mutation-staged-fs.js";
 import { validateContextContentForRole } from "../validators.js";
@@ -14,15 +13,17 @@ import { validateStagedContextMoveReferences } from "./context-move-reference-va
 import { assertContextMoveEndpoints, assertStagedContextMoveOwner, missingContextMoveDirectories, readContextMoveMarkdown, } from "./context-move-support.js";
 import { buildContextMoveTransactionPlan } from "./context-move-transaction-plan.js";
 import { CliCommandError } from "../cli-exit.js";
+import { assertSupportedSchema } from "../schema-guard.js";
 const MANIFEST_PATH = "project_context/context.toml";
 export async function moveContext(input) {
+    if (input.apply)
+        await assertSupportedSchema(input.project_root, "context move");
     const planned = await planContextMove(input);
     if (!input.apply)
         return planned.result;
     // Preserve the established fail-fast diagnostic before evaluating a
     // potentially inapplicable move. executeContextMutationPlan repeats this
     // guard while holding the shared Authority interlock to close the race.
-    await assertContextMutationOutsideActiveLongTask(input.project_root, contextMutationAffectedPaths(planned.plan));
     if (!planned.result.can_apply)
         mutationCatalogFailure("context move cannot apply until every reported unresolved reference and scan limit is cleared");
     try {

package/dist/lib/context-mutation/manifest-lossless-patch.js

@@ -20,6 +20,13 @@ export function replaceContextManifestPath(manifestContent, fromPathInput, toPat
     const owners = [];
     const children = [];
     for (const node of ast.body[0].body) {
+        if (node.type === "TOMLKeyValue" && staticKey(node) === "default_files") {
+            if (node.value.type !== "TOMLArray")
+                invalid("default_files_array_required");
+            for (const element of node.value.elements)
+                collectExactString(element, fromPath, children);
+            continue;
+        }
         if (node.type !== "TOMLTable" ||
             node.kind !== "array" ||
             node.key.keys.length !== 1)
@@ -176,6 +183,10 @@ function manifestHasExactOwnerPath(ast, expected) {
 }
 function manifestHasExactManifestPath(ast, expected) {
     for (const node of ast.body[0].body) {
+        if (node.type === "TOMLKeyValue" &&
+            staticKey(node) === "default_files" &&
+            containsExactString(node.value, expected))
+            return true;
         if (node.type !== "TOMLTable" ||
             node.kind !== "array" ||
             node.key.keys.length !== 1)

package/dist/lib/context-mutation/mutation-commit.js

@@ -1,10 +1,10 @@
 import { applyMutationChangeForward, assertMutationChangesCurrent, assertMutationChangesContentState, cleanupMutationTemporary, mutationChangeDisposition, prepareMutationTemporaryForRecovery, stageMutationTemporary, } from "./mutation-cas.js";
 import { assertMutationDirectoriesAbsent, prepareMutationDirectories, } from "./mutation-directories.js";
 import { createContextMutationJournal, removeContextMutationJournal, updateContextMutationJournal, } from "./mutation-journal.js";
-import { contextMutationAffectedPaths, withContextMutationAuthorityInterlock, } from "./mutation-long-task-guard.js";
+import { withContextMutationInterlock } from "./mutation-interlock.js";
 import { validateLiveContextMutation } from "./mutation-live-validation.js";
 export async function executeContextMutationPlan(repository, plan, options = {}) {
-    await withContextMutationAuthorityInterlock(repository, contextMutationAffectedPaths(plan), async () => executeContextMutationPlanLocked(repository, plan, options));
+    await withContextMutationInterlock(repository, async () => executeContextMutationPlanLocked(repository, plan, options));
 }
 async function executeContextMutationPlanLocked(repository, plan, options) {
     await assertMutationDirectoriesAbsent(repository, plan.directories);

package/dist/lib/context-mutation/mutation-interlock.d.ts

@@ -0,0 +1 @@
+export declare function withContextMutationInterlock<T>(repository: string, action: () => Promise<T>): Promise<T>;

package/dist/lib/context-mutation/mutation-interlock.js

@@ -0,0 +1,9 @@
+import { assertSupportedSchema } from "../schema-guard.js";
+import { withMaintenanceLock } from "../maintenance-lock.js";
+export async function withContextMutationInterlock(repository, action) {
+    await assertSupportedSchema(repository, "context mutation/recovery");
+    return withMaintenanceLock(repository, "context_mutation", async () => {
+        await assertSupportedSchema(repository, "context mutation/recovery");
+        return action();
+    });
+}