project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/commands/init.js

@@ -1,114 +1,32 @@
-import { stdin as input, stdout as output } from "node:process";
-import * as readline from "node:readline/promises";
 import { runInit } from "../lib/init.js";
-import { normalizeHarnessFolderName, readHarnessRootConfig, } from "../lib/harness-root.js";
+import { normalizeHarnessFolderName } from "../lib/harness-root.js";
 import { writePackageHarnessRoot } from "../lib/package-json-config.js";
-import { DEFAULT_HARNESS_ROOT } from "../lib/paths.js";
-const AGENT_HARNESS_OPTIONS = [
-    { key: "codex", label: "Codex", harnessFolderName: ".codex" },
-    { key: "claude", label: "Claude Code", harnessFolderName: ".claude" },
-    { key: "cursor", label: "Cursor", harnessFolderName: ".cursor" },
-    { key: "cline", label: "Cline", harnessFolderName: ".cline" },
-    { key: "roo", label: "Roo Code", harnessFolderName: ".roo" },
-    { key: "gemini", label: "Gemini CLI", harnessFolderName: ".gemini" },
-    { key: "other", label: "Other" },
-];
+import { assertSupportedSchema } from "../lib/schema-guard.js";
 export async function init(args) {
-    const adopt = args.includes("--adopt");
-    const force = args.includes("--force");
     const projectRoot = process.cwd();
-    const configuredRoot = await resolveInitHarnessRoot(projectRoot, args);
-    if (configuredRoot) {
-        await writePackageHarnessRoot(projectRoot, configuredRoot);
-        console.log(`configured package.json tyContext.harnessFolderName=${JSON.stringify(configuredRoot)}`);
-    }
-    const report = await runInit(projectRoot, { adopt, force });
-    for (const line of report) {
-        console.log(line);
-    }
-}
-export async function resolveInitHarnessRoot(projectRoot, args) {
-    const argRoot = valueForArg(args, "--harness-folder") ??
-        valueForArg(args, "--harnessFolderName");
-    if (argRoot) {
-        return normalizeHarnessFolderName(argRoot);
-    }
-    const current = await readHarnessRootConfig(projectRoot);
-    if (current.source !== "default") {
-        return undefined;
-    }
-    return promptAgentHarnessRoot();
-}
-async function promptAgentHarnessRoot() {
-    if (!input.isTTY || !output.isTTY) {
-        return resolveAgentHarnessFolderName("");
-    }
-    const rl = readline.createInterface({ input, output });
-    try {
-        const agent = await questionUntilValid(rl, `${formatAgentChoices()}\nTarget agent (default 1 Codex): `);
-        const option = agentOptionForAnswer(agent);
-        if (option?.harnessFolderName) {
-            return normalizeHarnessFolderName(option.harnessFolderName);
-        }
-        const folder = await rl.question(`Harness folder name (default ${DEFAULT_HARNESS_ROOT}; press Enter to use default): `);
-        return normalizeHarnessFolderName(folder.trim() || DEFAULT_HARNESS_ROOT);
-    }
-    finally {
-        rl.close();
-    }
-}
-async function questionUntilValid(rl, query) {
-    while (true) {
-        const answer = await rl.question(query);
-        if (agentOptionForAnswer(answer)) {
-            return answer;
+    await assertSupportedSchema(projectRoot, "init");
+    let folder;
+    const flags = new Set();
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--adopt" || arg === "--force")
+            flags.add(arg);
+        else if (arg === "--harness-folder" || arg === "--harnessFolderName") {
+            folder = args[++i];
+            if (!folder || folder.startsWith("--"))
+                throw new Error("--harness-folder requires a directory");
         }
-        console.log("Unknown agent choice. Enter a number, agent name, or Other.");
-    }
-}
-function formatAgentChoices() {
-    const lines = ["Choose target agent:"];
-    AGENT_HARNESS_OPTIONS.forEach((option, index) => {
-        const folder = option.harnessFolderName
-            ? ` -> ${option.harnessFolderName}`
-            : "";
-        lines.push(`${index + 1}) ${option.label}${folder}`);
-    });
-    return lines.join("\n");
-}
-export function resolveAgentHarnessFolderName(agentAnswer, customFolderAnswer = "") {
-    const option = agentOptionForAnswer(agentAnswer);
-    if (!option) {
-        throw new Error("Unknown agent choice");
-    }
-    return normalizeHarnessFolderName(option.harnessFolderName ??
-        (customFolderAnswer.trim() || DEFAULT_HARNESS_ROOT));
-}
-function agentOptionForAnswer(answer) {
-    const normalized = answer.trim().toLowerCase();
-    if (!normalized) {
-        return AGENT_HARNESS_OPTIONS[0];
-    }
-    const index = Number.parseInt(normalized, 10);
-    if (Number.isInteger(index) && String(index) === normalized) {
-        return AGENT_HARNESS_OPTIONS[index - 1];
-    }
-    return AGENT_HARNESS_OPTIONS.find((option) => {
-        const label = option.label.toLowerCase();
-        return (option.key === normalized ||
-            label === normalized ||
-            label.replace(/\s+/g, "-") === normalized);
-    });
-}
-function valueForArg(args, name) {
-    const prefix = `${name}=`;
-    const inline = args.find((arg) => arg.startsWith(prefix));
-    if (inline) {
-        return inline.slice(prefix.length);
-    }
-    const index = args.indexOf(name);
-    if (index >= 0) {
-        return args[index + 1];
-    }
-    return undefined;
+        else if (arg.startsWith("--harness-folder=") ||
+            arg.startsWith("--harnessFolderName="))
+            folder = arg.slice(arg.indexOf("=") + 1);
+        else
+            throw new Error("Unknown init argument: " + arg);
+    }
+    if (folder !== undefined)
+        await writePackageHarnessRoot(projectRoot, normalizeHarnessFolderName(folder));
+    for (const line of await runInit(projectRoot, {
+        adopt: flags.has("--adopt"),
+        force: flags.has("--force"),
+    }))
+        console.log(line);
 }

package/dist/commands/upgrade.js

@@ -21,7 +21,9 @@ export async function upgrade(args = []) {
         }
         return;
     }
-    const report = await runUpgradeReport(process.cwd());
+    const report = await runUpgradeReport(process.cwd(), {
+        sessions_stopped: options.sessions_stopped,
+    });
     if (options.json) {
         console.log(JSON.stringify(report, null, 2));
         if (report.blocked) {
@@ -37,7 +39,12 @@ export async function upgrade(args = []) {
     }
 }
 function parseArgs(args) {
-    const options = { check: false, json: false, help: false };
+    const options = {
+        check: false,
+        json: false,
+        help: false,
+        sessions_stopped: false,
+    };
     for (const arg of args) {
         if (arg === "--check") {
             options.check = true;
@@ -48,6 +55,9 @@ function parseArgs(args) {
         else if (arg === "--help" || arg === "-h") {
             options.help = true;
         }
+        else if (arg === "--sessions-stopped") {
+            options.sessions_stopped = true;
+        }
         else {
             throw new Error(`unknown upgrade argument: ${arg}`);
         }
@@ -60,6 +70,8 @@ function printHelp() {
   upgrade --check      Print the upgrade plan without writing files
   upgrade --check --json
                        Print the upgrade plan as JSON
+  upgrade --sessions-stopped
+                       Retire schema 4 or resume after stopping relevant old host sessions
 
 Update modes:
   sync-only            No migrations are pending

package/dist/commands/validate.js

@@ -1,6 +1,6 @@
 import { runValidator } from "../lib/validators.js";
 export async function validate(args) {
-    const gate = args[0] ?? "validate-harness";
+    const gate = args[0] ?? "validate-context";
     const report = await runValidator(process.cwd(), gate, args.slice(1));
     for (const line of report.info) {
         console.log(line);

package/dist/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./public-api-core.js";
-export * from "./public-api-long-task.js";
 export * from "./public-types.js";

package/dist/index.js

@@ -1,3 +1,2 @@
 export * from "./public-api-core.js";
-export * from "./public-api-long-task.js";
 export * from "./public-types.js";

package/dist/lib/config.js

@@ -1,36 +1,17 @@
 import path from "node:path";
 import { CANONICAL_CORE_PACKAGE, CURRENT_SCHEMA_VERSION } from "./constants.js";
-import { harnessConfigPath, harnessPath, harnessRoot } from "./harness-root.js";
-import { pathExists, readText, writeTextIfChanged } from "./fs.js";
+import { harnessConfigPath, harnessRoot } from "./harness-root.js";
+import { pathExists, readText } from "./fs.js";
 import { parseYaml, stringifyYaml } from "./yaml.js";
+import { captureMutationFileState } from "./context-mutation/mutation-file-state.js";
+import { writeMaintenanceText } from "./maintenance-write.js";
 export function defaultConfig(root) {
     return {
         core: {
             package: CANONICAL_CORE_PACKAGE,
             schema_version: CURRENT_SCHEMA_VERSION,
         },
-        profiles: {
-            enabled: ["core-portable", "workflow-default"],
-        },
-        modularity: {
-            limit: 300,
-            policy: "strict_except_generated",
-        },
-        managed_files: [
-            { path: "AGENTS.md", strategy: "merge-block" },
-            { path: "Makefile", strategy: "merge-block" },
-            { path: harnessPath(root, "skills"), strategy: "managed" },
-            {
-                path: harnessPath(root, "ty-context-managed", "context_templates"),
-                strategy: "managed",
-            },
-            {
-                path: harnessPath(root, "ty-context-managed", "make", "ty-context.mk"),
-                strategy: "managed",
-            },
-            { path: "tools", strategy: "managed" },
-            { path: ".github/workflows/harness.yml", strategy: "create-if-missing" },
-        ],
+        managed_files: [{ path: "AGENTS.md", strategy: "merge-block" }],
         never_overwrite: ["project_context/**", "DESIGN.md", "src/**", "tests/**"],
     };
 }
@@ -45,39 +26,27 @@ export async function readConfig(projectRoot) {
 }
 export async function writeConfigIfMissing(projectRoot) {
     const root = await harnessRoot(projectRoot);
-    const configPath = path.join(projectRoot, await harnessConfigPath(projectRoot));
-    if (await pathExists(configPath)) {
+    const configPath = await harnessConfigPath(projectRoot);
+    const before = await captureMutationFileState(projectRoot, configPath);
+    if (before.exists) {
         return false;
     }
-    await writeTextIfChanged(configPath, stringifyYaml(defaultConfig(root)));
+    await writeMaintenanceText(projectRoot, configPath, stringifyYaml(defaultConfig(root)), before);
     return true;
 }
 export function normalizeConfig(value, root = ".agent") {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("invalid harness config object");
+    if (String(value.core?.schema_version) === CURRENT_SCHEMA_VERSION &&
+        ("profiles" in value || "modularity" in value))
+        throw new Error("retired_config_fields: schema 5 does not support profiles or modularity; preserve the file and reconcile changes from old CLI use");
     const fallback = defaultConfig(root);
     return {
         core: {
             package: value.core?.package ?? fallback.core.package,
             schema_version: value.core?.schema_version ?? fallback.core.schema_version,
         },
-        profiles: {
-            enabled: normalizeProfiles(value.profiles?.enabled),
-        },
-        modularity: value.modularity,
         managed_files: value.managed_files ?? fallback.managed_files,
         never_overwrite: value.never_overwrite ?? fallback.never_overwrite,
     };
 }
-const VALID_PROFILES = new Set([
-    "core-portable",
-    "workflow-default",
-    "long-task",
-]);
-function normalizeProfiles(value) {
-    const source = value ?? ["core-portable", "workflow-default"];
-    const enabled = source.filter((profile) => VALID_PROFILES.has(profile));
-    for (const required of ["core-portable", "workflow-default"]) {
-        if (!enabled.includes(required))
-            enabled.push(required);
-    }
-    return [...new Set(enabled)];
-}

package/dist/lib/constants.d.ts

@@ -1,3 +1,3 @@
 export declare const CANONICAL_CORE_PACKAGE = "project-tiny-context-harness";
-export declare const CURRENT_SCHEMA_VERSION = "4";
+export declare const CURRENT_SCHEMA_VERSION = "5";
 export declare const CANONICAL_NPX_COMMAND = "npx --yes --package project-tiny-context-harness@latest ty-context";

package/dist/lib/constants.js

@@ -1,3 +1,3 @@
 export const CANONICAL_CORE_PACKAGE = "project-tiny-context-harness";
-export const CURRENT_SCHEMA_VERSION = "4";
+export const CURRENT_SCHEMA_VERSION = "5";
 export const CANONICAL_NPX_COMMAND = `npx --yes --package ${CANONICAL_CORE_PACKAGE}@latest ty-context`;

package/dist/lib/context-catalog/catalog-default-footprint.d.ts

@@ -1,3 +1,3 @@
 import type { ContextManifest } from "../context-manifest-schema.js";
-export type DefaultContextSelectionReason = "core" | "default_area" | "default_role" | "default_child";
+export type DefaultContextSelectionReason = "core" | "default_file" | "default_area" | "default_role" | "default_child";
 export declare function selectDefaultContextPaths(manifest: ContextManifest): Map<string, Set<DefaultContextSelectionReason>>;

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

@@ -9,13 +9,11 @@ export function selectDefaultContextPaths(manifest) {
         reasons.add(reason);
         selected.set(normalized, reasons);
     };
-    for (const core of [
-        "project_context/context.toml",
-        "project_context/global.md",
-        "project_context/architecture.md",
-    ]) {
-        add(core, "core");
-    }
+    add("project_context/global.md", "core");
+    // Direct selections do not seed child traversal. In particular, migration can
+    // preserve an implicit core file without activating its previously inert edges.
+    for (const file of manifest.default_files ?? [])
+        add(file, "default_file");
     for (const area of manifest.areas) {
         if (area.default)
             add(area.context, "default_area");

package/dist/lib/context-catalog/catalog-load.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { CONTEXT_MANIFEST_PATH } from "../context-manifest.js";
 import { parseContextManifest } from "../context-manifest-schema.js";
 import { pathExists } from "../fs.js";
+import { rawSchemaVersion } from "../schema-guard.js";
 import { selectDefaultContextPaths } from "./catalog-default-footprint.js";
 import { catalogDiagnostic, sortCatalogDiagnostics, } from "./catalog-diagnostics.js";
 import { discoverContextMarkdownFiles } from "./catalog-discovery.js";
@@ -85,6 +86,23 @@ export async function loadContextCatalog(projectRootInput, options = {}) {
     ]);
     const unregisteredContextFiles = contextFiles.filter((entry) => !registeredPaths.has(entry.path));
     addUnregisteredDiagnostics(diagnostics, unregisteredContextFiles);
+    let defaults = parsed.manifest;
+    try {
+        const version = await rawSchemaVersion(projectRoot);
+        if (version !== undefined && Number(version) < 5)
+            defaults = {
+                ...defaults,
+                default_files: [
+                    ...new Set([
+                        ...(defaults.default_files ?? []),
+                        "project_context/architecture.md",
+                    ]),
+                ],
+            };
+    }
+    catch (error) {
+        diagnostics.push(catalogDiagnostic("config_invalid", "error", String(error)));
+    }
     return {
         project_root: projectRoot,
         manifest_path: manifestPath,
@@ -94,7 +112,7 @@ export async function loadContextCatalog(projectRootInput, options = {}) {
         registered_contexts: projectRegisteredContexts(validation.registered_contexts),
         context_files: contextFiles,
         unregistered_context_files: unregisteredContextFiles,
-        default_footprint: selectDefaultContextPaths(parsed.manifest),
+        default_footprint: selectDefaultContextPaths(defaults),
         roles_by_path: sortedContextMap(validation.roles_by_path),
         read_policies_by_path: sortedContextMap(validation.read_policies_by_path),
         diagnostics: sortCatalogDiagnostics(diagnostics),

package/dist/lib/context-catalog/catalog-path-validation.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { realpath } from "node:fs/promises";
 import { pathExists } from "../fs.js";
+import { assertSafeRepositoryFilePath } from "../repository-path-safety.js";
 import { assertCatalogStagedFilePath } from "./catalog-staged-path-safety.js";
 import { isPathWithin, normalizeContextPath } from "./catalog-paths.js";
 const EXPORT_ARTIFACT_NAME_PATTERNS = [
@@ -52,6 +53,15 @@ export async function validateCatalogManifestPath(projectRoot, rawPath, allowedR
         addError("manifest_path_symlink_escape", `project_context/context.toml ${source} resolves through a symbolic link outside its allowed root: ${rawPath}`);
         return false;
     }
+    if (allowFile) {
+        try {
+            await assertSafeRepositoryFilePath(projectRoot, physicalRelative, `catalog_file:${source}`);
+        }
+        catch (error) {
+            addError("manifest_path_unsafe_file", `Unsafe declared Context file ${rawPath}: ${message(error)}`);
+            return false;
+        }
+    }
     return true;
 }
 function message(error) {

package/dist/lib/context-catalog/catalog-validation.js

@@ -14,17 +14,25 @@ export async function validateCatalogManifest(projectRoot, manifest, fileOverrid
     const addWarning = (code, message, location = {}) => {
         diagnostics.push(catalogDiagnostic(code, "warning", message, location));
     };
-    if (manifest.areas.length === 0) {
-        addError("manifest_area_missing", "project_context/context.toml must declare at least one [[areas]] entry");
-    }
     const areaIds = new Map();
     const registeredPaths = new Set();
     const filesByPath = new Map(contextFiles.map((file) => [file.path, file]));
     const registeredPathSpellings = new Map();
     const registeredPathCases = new Map();
     const defaultAreas = manifest.areas.filter((area) => area.default);
-    if (manifest.areas.length > 0 && defaultAreas.length !== 1) {
-        addError("manifest_default_area_count", `project_context/context.toml must mark exactly one [[areas]] entry with default = true; found ${defaultAreas.length}`);
+    if (defaultAreas.length > 1) {
+        addError("manifest_default_area_count", `project_context/context.toml may mark at most one [[areas]] entry with default = true; found ${defaultAreas.length}`);
+    }
+    const directDefaults = new Set();
+    for (const file of [
+        "project_context/global.md",
+        ...(manifest.default_files ?? []),
+    ]) {
+        const key = normalizeContextPath(file);
+        if (directDefaults.has(key))
+            addError("manifest_default_file_duplicate", `Duplicate default file: ${file}`);
+        directDefaults.add(key);
+        await validateCatalogManifestPath(projectRoot, file, path.join(projectRoot, "project_context"), "default file", true, addError, fileOverrides, directoryOverrides, filesByPath);
     }
     for (const area of manifest.areas) {
         const canonicalAreaId = area.id.normalize("NFC");

package/dist/lib/context-controlling-source.d.ts

@@ -0,0 +1,4 @@
+import type { ContextControllingSourceConflict, ContextControllingSourceDeclaration, ContextControllingSourceRawDeclaration } from "./context-markdown/context-markdown-types.js";
+export declare function resolveContextControllingSourceDeclaration(projectRoot: string, declaration: ContextControllingSourceRawDeclaration): Promise<ContextControllingSourceDeclaration>;
+export declare function contextControllingSourceConflicts(declarations: readonly ContextControllingSourceDeclaration[]): ContextControllingSourceConflict[];
+export declare function canonicalControllingSourcePath(value: string): string;

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,
-    };
-}