project-tiny-context-harness 0.8.16 → 0.11.0

package/dist/commands/doctor.js

@@ -1,6 +1,12 @@
 import { runDoctor } from "../lib/doctor.js";
-export async function doctor() {
-    const report = await runDoctor(process.cwd());
+import { CONTEXT_DOCTOR_DEFAULTS } from "../lib/context-doctor/context-doctor-types.js";
+export async function doctor(args = []) {
+    const options = parseDoctorArgs(args);
+    if (options.help) {
+        console.log(doctorHelp());
+        return;
+    }
+    const report = await runDoctor(process.cwd(), options);
     for (const line of report.info) {
         console.log(line);
     }
@@ -10,7 +16,59 @@ export async function doctor() {
     for (const error of report.errors) {
         console.error(`error: ${error}`);
     }
-    if (report.errors.length > 0) {
+    if (report.errors.length > 0 ||
+        (options.strict && report.warnings.length > 0)) {
         process.exitCode = 1;
     }
 }
+function parseDoctorArgs(args) {
+    const options = {
+        strict: false,
+        help: false,
+        context_file_soft_budget_bytes: CONTEXT_DOCTOR_DEFAULTS.context_file_soft_budget_bytes,
+        long_line_code_points: CONTEXT_DOCTOR_DEFAULTS.long_line_code_points,
+        trigger_fanout_contexts: CONTEXT_DOCTOR_DEFAULTS.trigger_fanout_contexts,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--strict")
+            options.strict = true;
+        else if (argument === "--help" || argument === "-h")
+            options.help = true;
+        else if (argument === "--max-line-length")
+            index = readPositiveInteger(args, index, argument, (value) => {
+                options.long_line_code_points = value;
+            });
+        else if (argument === "--context-file-soft-budget")
+            index = readPositiveInteger(args, index, argument, (value) => {
+                options.context_file_soft_budget_bytes = value;
+            });
+        else if (argument === "--trigger-fanout-threshold")
+            index = readPositiveInteger(args, index, argument, (value) => {
+                options.trigger_fanout_contexts = value;
+            });
+        else
+            throw new Error(`unknown doctor argument: ${argument}`);
+    }
+    return options;
+}
+function readPositiveInteger(args, index, flag, apply) {
+    const raw = args[index + 1];
+    if (!raw)
+        throw new Error(`doctor ${flag} requires a positive integer`);
+    const parsed = Number(raw);
+    if (!Number.isSafeInteger(parsed) || parsed < 1 || String(parsed) !== raw)
+        throw new Error(`doctor ${flag} requires a positive integer`);
+    apply(parsed);
+    return index + 1;
+}
+function doctorHelp() {
+    return `ty-context doctor [--strict]
+  [--max-line-length <code-points>]
+  [--context-file-soft-budget <bytes>]
+  [--trigger-fanout-threshold <contexts>]
+
+All new size, line, fan-out, unregistered-file, explicit-link and stable-key
+findings are advisory by default. --strict is opt-in and exits nonzero when a
+warning exists; projects must adopt it explicitly before using it in CI.`;
+}

package/dist/commands/index.js

@@ -4,6 +4,7 @@ import { compositeCampaign } from "./composite-campaign.js";
 import { longTask } from "./long-task.js";
 import { deliverySet } from "./delivery-set.js";
 import { designResource } from "./design-resource.js";
+import { designAuthority } from "./design-authority.js";
 import { doctor } from "./doctor.js";
 import { exportContext } from "./export-context.js";
 import { enable } from "./enable.js";
@@ -13,6 +14,8 @@ import { packageSource } from "./package-source.js";
 import { sync } from "./sync.js";
 import { upgrade } from "./upgrade.js";
 import { validate } from "./validate.js";
+import { route } from "./route.js";
+import { context } from "./context.js";
 import { assertHarnessProfileEnabled } from "../lib/profiles.js";
 export const commands = {
     help,
@@ -22,6 +25,8 @@ export const commands = {
     sync,
     upgrade,
     doctor,
+    route,
+    context,
     "check-modularity": checkModularity,
     "export-context": exportContext,
     validate,
@@ -30,6 +35,7 @@ export const commands = {
     "validate-harness": (args) => validate(["validate-harness", ...args]),
     "long-task": (args) => withLongTaskProfile(args, longTask),
     "design-resource": designResource,
+    "design-authority": designAuthority,
     "delivery-set": deliverySet,
     "composite-long-task": compositeLongTask,
     "composite-campaign": compositeCampaign,
@@ -44,7 +50,16 @@ export function help() {
   sync                 Refresh managed assets; does not run migrations
   upgrade [--check] [--json]
                        Run safe migrations, sync managed assets and doctor
-  doctor               Diagnose project configuration and drift
+  doctor [--strict]    Diagnose project configuration and all Context files; new findings are advisory
+  route --task <text>  Experimentally route to read-only Context candidates
+  context inspect <path>
+                       Inspect one Context owner, references and optional route explanation
+  context register --path <path> --role <role> [--apply]
+                       Dry-run or transactionally register one recoverable Context
+  context move --from <path> --to <path> [--apply]
+                       Dry-run or transactionally move one registered Context
+  context transaction status|rollback|complete
+                       Inspect or resolve an unfinished Context mutation journal
   check-modularity --touched|--file <path>|--base <ref> [--limit 300] [--fail-on-warning]
                        Warn when selected handwritten source files exceed a line-count limit
   export-context --full|--code|--all|--source-pack|--code-index|--task-context
@@ -55,7 +70,9 @@ export function help() {
                        Enforce touched handwritten source file modularity
   validate-harness     Run validate-context and validate-code-modularity
   design-resource <subcommand>
-                       Validate handoffs or operate explicit DRA recovery
+                       Validate handoffs, Authority assessments, or explicit DRA recovery
+  design-authority inspect|tokens
+                       Inspect the complete authority closure or project Tokens; read-only
   long-task <subcommand>
                        Manage one Canonical Delivery Contract in the current workspace
   delivery-set <subcommand>

package/dist/commands/long-task-authoring.js

@@ -34,6 +34,7 @@ task:
     description: The declared product target is usable from its root entrypoint.
     required_state: target_profile_usable
     required_target_refs: [replace-runtime]
+    completion_authority: machine_only
   execution_targets:
     - key: replace-runtime
       description: The product runtime used by the acceptance oracle.
@@ -83,6 +84,7 @@ outcomes:
         - fact_ref: replace.result.observable
           claim_ref: semantic_fact.replace.result.observable
           applicability_ref: root-success
+        - {fact_ref: replace.architecture.boundary, claim_ref: semantic_fact.replace.architecture.boundary, applicability_ref: root-success}
       proofs:
         - proof_ref: replace.result.observable.runtime
           fact_ref: replace.result.observable
@@ -92,6 +94,14 @@ outcomes:
           authority: machine
           check_ref: replace-check
           assertion_ref: replace-semantic-fact
+        - proof_ref: replace.architecture.boundary.runtime
+          fact_ref: replace.architecture.boundary
+          method: exact_value
+          proof_surface: runtime_behavior
+          evidence_capabilities: [semantic_fact]
+          authority: machine
+          check_ref: replace-check
+          assertion_ref: replace-architecture-semantic-fact
     product:
       observable_result: Describe what a user or system can observe.
       result_applicability_refs: [root-success]
@@ -157,6 +167,14 @@ outcomes:
               evidence_capabilities: [semantic_fact]
               operator: equals
               expected: true
+            - key: replace-architecture-semantic-fact
+              criterion: The exact Source-indexed architecture Fact passes its frozen comparison on the current target.
+              claims: [semantic_fact.replace.architecture.boundary]
+              applicability_ref: root-success
+              observation: semantic_fact_replace_architecture_boundary
+              evidence_capabilities: [semantic_fact]
+              operator: equals
+              expected: true
             - key: replace-requirement
               criterion: The atomic Source requirement is observable.
               claims: [requirement.replace-requirement]
@@ -192,14 +210,14 @@ outcomes:
       counterfactual_controls:
         - key: replace-semantic-carrier
           binding_key: replace-carrier
-          claims: [result, requirement.replace-requirement, obligation.architecture, semantic_fact.replace.result.observable]
+          claims: [result, requirement.replace-requirement, obligation.architecture, semantic_fact.replace.result.observable, semantic_fact.replace.architecture.boundary]
           check_key: replace-check
           mutation:
             type: replace_text
             path: src/replace-me.ts
             match: IMPLEMENTED_STATE
             replacement: SEMANTIC_FAILURE_STATE
-          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture, replace-semantic-fact]
+          expected_assertion_failures: [replace-result, replace-requirement, replace-architecture, replace-semantic-fact, replace-architecture-semantic-fact]
           preserved_assertions: [replace-liveness]
         - key: replace-relation-applicability
           binding_key: replace-carrier

package/dist/commands/long-task-workdir.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveLongTaskCommandWorkdir(subcommand: string, workdirArgument: string | undefined): Promise<string>;
+export declare function canonicalLongTaskCommandWorkdir(workdir: string, allowMissing: boolean): Promise<string>;

package/dist/commands/long-task-workdir.js

@@ -0,0 +1,23 @@
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+export async function resolveLongTaskCommandWorkdir(subcommand, workdirArgument) {
+    if (!workdirArgument)
+        throw new Error(`${subcommand} requires <workdir>`);
+    const lexicalWorkdir = path.resolve(process.cwd(), workdirArgument);
+    if (subcommand === "init")
+        return lexicalWorkdir;
+    return canonicalLongTaskCommandWorkdir(lexicalWorkdir, subcommand === "abandon");
+}
+export async function canonicalLongTaskCommandWorkdir(workdir, allowMissing) {
+    try {
+        return await realpath(workdir);
+    }
+    catch (error) {
+        if (allowMissing &&
+            error instanceof Error &&
+            "code" in error &&
+            error.code === "ENOENT")
+            return workdir;
+        throw error;
+    }
+}

package/dist/commands/long-task.js

@@ -8,15 +8,16 @@ import { initializeLongTask, preflightLongTask, } from "./long-task-authoring.js
 import { flag, option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
 import { explainLongTask } from "./long-task-explain.js";
 import { handleLongTaskRevisionCommand } from "./long-task-revision.js";
+import { canonicalLongTaskCommandWorkdir, resolveLongTaskCommandWorkdir, } from "./long-task-workdir.js";
 import { previewVerificationExecution } from "../lib/long-task-verification-preview.js";
+import { externalConfirmationStatus, prepareExternalConfirmations, revokeExternalConfirmation, rotateExternalConfirmation, submitExternalConfirmation, } from "../lib/long-task-external-confirmation-plan.js";
 export async function longTask(args) {
     const subcommand = args[0] ?? "help";
     if (subcommand === "help")
         return help();
-    const workdirArgument = args[1];
-    if (!workdirArgument)
-        throw new Error(`${subcommand} requires <workdir>`);
-    const workdir = path.resolve(process.cwd(), workdirArgument);
+    if (subcommand === "external")
+        return external(args.slice(1));
+    const workdir = await resolveLongTaskCommandWorkdir(subcommand, args[1]);
     if (subcommand === "init") {
         rejectUnknown(args.slice(2), []);
         await initializeLongTask(workdir);
@@ -69,6 +70,7 @@ export async function longTask(args) {
             workdir,
             workflow_status: result.workflow_status,
             external_confirmations: result.external_confirmations,
+            external_confirmation_results: result.external_confirmation_results,
             target_profile: result.target_profile,
             target_state: result.target_state,
             stage_results: result.stage_results,
@@ -116,13 +118,75 @@ async function finalGate(workdir, args) {
     const result = await runDeliveryFinalGate(workdir);
     console.log(JSON.stringify({
         ...result,
-        acceptance_scope: "declared_machine_authority",
+        acceptance_scope: "declared_delivery_authority",
         native_goal_effect: "none",
     }));
     if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "machine_accepted_external_pending")
+        result.workflow_status !== "delivery_accepted")
         process.exitCode = 1;
 }
+async function external(args) {
+    const action = args[0];
+    const workdirArgument = args[1];
+    if (!action)
+        throw new Error("external requires prepare|submit|status|rotate|revoke");
+    if (!workdirArgument)
+        throw new Error(`external ${action} requires <workdir>`);
+    const workdir = await canonicalLongTaskCommandWorkdir(path.resolve(process.cwd(), workdirArgument), false);
+    const commandArgs = args.slice(2);
+    if (action === "prepare") {
+        const confirmation = option(commandArgs, "--confirmation");
+        rejectOptions(commandArgs, ["--confirmation"]);
+        console.log(JSON.stringify(await prepareExternalConfirmations(workdir, confirmation), null, 2));
+        return;
+    }
+    if (action === "submit") {
+        const confirmation = option(commandArgs, "--confirmation");
+        const record = option(commandArgs, "--record");
+        rejectOptions(commandArgs, ["--confirmation", "--record"]);
+        if (!confirmation)
+            throw new Error("--confirmation requires a value");
+        if (!record)
+            throw new Error("--record requires a value");
+        const result = await submitExternalConfirmation({
+            workdir,
+            confirmation_ref: confirmation,
+            record_path: path.resolve(process.cwd(), record),
+        });
+        console.log(JSON.stringify(result, null, 2));
+        if (result.state !== "fulfilled")
+            process.exitCode = 1;
+        return;
+    }
+    if (action === "status") {
+        rejectUnknown(commandArgs, []);
+        console.log(JSON.stringify(await externalConfirmationStatus(workdir), null, 2));
+        return;
+    }
+    if (action === "revoke") {
+        const confirmation = option(commandArgs, "--confirmation");
+        rejectOptions(commandArgs, ["--confirmation"]);
+        if (!confirmation)
+            throw new Error("--confirmation requires a value");
+        console.log(JSON.stringify(await revokeExternalConfirmation({
+            workdir,
+            confirmation_ref: confirmation,
+        }), null, 2));
+        return;
+    }
+    if (action === "rotate") {
+        const confirmation = option(commandArgs, "--confirmation");
+        rejectOptions(commandArgs, ["--confirmation"]);
+        if (!confirmation)
+            throw new Error("--confirmation requires a value");
+        console.log(JSON.stringify(await rotateExternalConfirmation({
+            workdir,
+            confirmation_ref: confirmation,
+        }), null, 2));
+        return;
+    }
+    throw new Error(`Unknown long-task external subcommand: ${action}`);
+}
 function help() {
     console.log(`ty-context long-task commands:
   init <workdir>
@@ -137,6 +201,11 @@ function help() {
   resume <workdir>
   doctor <workdir>
   final-gate <workdir>
+  external prepare <workdir> [--confirmation <key>]
+  external submit <workdir> --confirmation <key> --record <path>
+  external status <workdir>
+  external rotate <workdir> --confirmation <key>
+  external revoke <workdir> --confirmation <key>
   stop-check <workdir> [--message <text>]
   close <workdir>
   abandon <workdir> [--force-corrupt-state]`);

package/dist/commands/route.d.ts

@@ -0,0 +1,15 @@
+interface RouteOptions {
+    task?: string;
+    paths: string[];
+    terms: string[];
+    includes: string[];
+    format: "text" | "json";
+    explain: boolean;
+    case_sensitive: boolean;
+    max_search_results: number;
+    help: boolean;
+}
+export declare function route(args: string[]): Promise<void>;
+export declare function parseRouteArgs(args: string[]): RouteOptions;
+export declare function routeHelp(): string;
+export {};

package/dist/commands/route.js

@@ -0,0 +1,142 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { CONTEXT_ROUTE_BUDGETS } from "../lib/context-router/context-route-budget.js";
+import { renderContextRouteText } from "../lib/context-router/context-route-render.js";
+import { routeContext } from "../lib/context-router/context-route.js";
+export async function route(args) {
+    let options;
+    try {
+        options = parseRouteArgs(args);
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, error instanceof Error ? error.message : String(error), { cause: error });
+    }
+    if (options.help) {
+        console.log(routeHelp());
+        return;
+    }
+    if (options.task === undefined)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "route requires --task <text>");
+    let result;
+    try {
+        result = await routeContext({
+            project_root: process.cwd(),
+            task: options.task,
+            paths: options.paths,
+            explicit_terms: options.terms,
+            includes: options.includes,
+            case_sensitive: options.case_sensitive,
+            max_search_results: options.max_search_results,
+        });
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.internal, `route failed internally: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (options.format === "json")
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(renderContextRouteText(result, options.explain));
+    if (!result.catalog_valid)
+        process.exitCode = CLI_EXIT_CODES.catalog;
+    else if (!result.complete)
+        process.exitCode = CLI_EXIT_CODES.incomplete;
+}
+export function parseRouteArgs(args) {
+    const options = {
+        paths: [],
+        terms: [],
+        includes: [],
+        format: "text",
+        explain: false,
+        case_sensitive: false,
+        max_search_results: CONTEXT_ROUTE_BUDGETS.output_matches,
+        help: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--help" || argument === "-h")
+            options.help = true;
+        else if (argument === "--explain")
+            options.explain = true;
+        else if (argument === "--case-sensitive")
+            options.case_sensitive = true;
+        else if (argument === "--json")
+            options.format = "json";
+        else if (argument === "--task")
+            index = readValue(args, index, "--task", (value) => (options.task = value));
+        else if (argument.startsWith("--task="))
+            options.task = inlineValue(argument, "--task");
+        else if (argument === "--path")
+            index = readValue(args, index, "--path", (value) => options.paths.push(value));
+        else if (argument.startsWith("--path="))
+            options.paths.push(inlineValue(argument, "--path"));
+        else if (argument === "--term")
+            index = readValue(args, index, "--term", (value) => options.terms.push(value));
+        else if (argument.startsWith("--term="))
+            options.terms.push(inlineValue(argument, "--term"));
+        else if (argument === "--include")
+            index = readValue(args, index, "--include", (value) => options.includes.push(value));
+        else if (argument.startsWith("--include="))
+            options.includes.push(inlineValue(argument, "--include"));
+        else if (argument === "--format")
+            index = readValue(args, index, "--format", (value) => (options.format = parseFormat(value)));
+        else if (argument.startsWith("--format="))
+            options.format = parseFormat(inlineValue(argument, "--format"));
+        else if (argument === "--max-search-results")
+            index = readValue(args, index, "--max-search-results", (value) => (options.max_search_results = parseMaximum(value)));
+        else if (argument.startsWith("--max-search-results="))
+            options.max_search_results = parseMaximum(inlineValue(argument, "--max-search-results"));
+        else
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown route argument: ${argument}`);
+    }
+    return options;
+}
+export function routeHelp() {
+    return `ty-context route (experimental, read-only):
+  route --task <text> [--path <repo-path>] [--term <literal>]
+        [--include <project_context/file.md>] [--case-sensitive]
+        [--max-search-results <1-${CONTEXT_ROUTE_BUDGETS.output_matches}>]
+        [--explain] [--format text|json]
+
+The Router scans registered and unregistered Context Markdown with literal,
+versioned budgets. It does not establish Authority, participate in the default
+footprint, or replace the Workflow-required bounded Context search.
+
+JSON schema v1 budgets: task=8192 UTF-8 bytes; automatic terms=32; explicit
+terms=32; term length=2-128 automatic/1-128 explicit Unicode code points;
+files=4096; per-file scan=1048576 bytes; aggregate scan=33554432 bytes;
+output matches=200 total/20 per file.
+
+Exit codes: 0 complete (warnings/ambiguity/unresolved allowed), 2 arguments,
+3 blocking Catalog, 4 incomplete budget, 5 I/O or path safety, 6 internal.`;
+}
+function readValue(args, index, flag, apply) {
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--") || value.length === 0)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route ${flag} requires a value`);
+    apply(value);
+    return index + 1;
+}
+function inlineValue(argument, flag) {
+    const value = argument.slice(`${flag}=`.length);
+    if (!value)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route ${flag} requires a value`);
+    return value;
+}
+function parseFormat(value) {
+    if (value === "text" || value === "json")
+        return value;
+    throw new CliCommandError(CLI_EXIT_CODES.arguments, "route --format must be text or json");
+}
+function parseMaximum(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) ||
+        parsed < 1 ||
+        parsed > CONTEXT_ROUTE_BUDGETS.output_matches ||
+        String(parsed) !== value.trim())
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route --max-search-results must be an integer from 1 to ${CONTEXT_ROUTE_BUDGETS.output_matches}`);
+    return parsed;
+}

package/dist/index.d.ts

@@ -1,13 +1,3 @@
-export { commands } from "./commands/index.js";
-export { compileDeliveryContract, type CompileDeliveryOptionsV2, } from "./lib/long-task-delivery-compiler.js";
-export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
-export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
-export { publishDesignResourceHandoffBundle } from "./lib/design-resource-handoff-bundle.js";
-export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
-export { symbolicDenotation } from "./lib/symbolic-denotation-public.js";
-export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
-export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
-export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
-export { closeDeliveryTask, type DeliveryStatusV2, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
-export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
-export type { BoundaryCheckDecisionV2, BoundaryCheckInputV2, CheckExecutionResultV2, CompiledDeliveryContractV2, DesignResourceHandoffBundleOptions, DesignResourceHandoffBundleResult, DesignResourceHandoffPreflightV1, DesignResourceHandoffPreflightV2, DesignResourceHandoffV1, DesignResourceHandoffV2, DesignResourceObservableRuleManifestV2, DesignResourceSymbolicFactRuleV2, DesignResourceSymbolicNoninterferenceArtifactV2, DesignResourceSymbolicNoninterferenceCertificateV2, DesignResourceSymbolicNoninterferenceDerivedResultV2, DesignResourceSymbolicNoninterferenceFailureWitnessV1, DesignResourceSymbolicNoninterferenceInputBindingV2, DesignResourceSymbolicNoninterferenceProofV2, DesignResourceSymbolicProofObligationV2, DesignResourceSymbolicSourceIrCertificateScopeV1, DesignResourceSymbolicSourceIrRegionV1, DesignResourceSymbolicSourceIrV1, CompiledSymbolicDenotationV1, SymbolicDenotationAxisDomain, SymbolicDenotationComplexityLimits, SymbolicDenotationPredicate, SymbolicExtensionalPointV1, SymbolicPointDenotationV1, DeliveryAssertionV2, DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, EffectiveRiskLevel, ExternalConfirmationV2, FinalReceiptV2, LongTaskFindingV2, LongTaskRiskFacts, ProofSurface, ProgressRecordV2, RequestedRiskLevel, RunnerType, SourceClaimV2, TargetedVerificationResultV2, HarnessConfig, HarnessProfile, ManagedFile, SourceMapping, } from "./public-types.js";
+export * from "./public-api-core.js";
+export * from "./public-api-long-task.js";
+export * from "./public-types.js";

package/dist/index.js

@@ -1,12 +1,3 @@
-export { commands } from "./commands/index.js";
-export { compileDeliveryContract, } from "./lib/long-task-delivery-compiler.js";
-export { DELIVERY_CONTRACT_FILE, parseDeliveryContract, parseDeliveryContractBundle, } from "./lib/long-task-delivery-parser.js";
-export { evaluateContractBoundary } from "./lib/long-task-boundary-check.js";
-export { publishDesignResourceHandoffBundle } from "./lib/design-resource-handoff-bundle.js";
-export { preflightDesignResourceHandoff } from "./lib/design-resource-handoff-validation.js";
-export { symbolicDenotation } from "./lib/symbolic-denotation-public.js";
-export { classifyLongTaskRisk, validateRiskProof, } from "./lib/long-task-risk.js";
-export { verifyDeliveryContract } from "./lib/long-task-verifier-v2.js";
-export { runDeliveryFinalGate } from "./lib/long-task-final-v2.js";
-export { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "./lib/long-task-status-v2.js";
-export { readActiveLongTaskBinding, readCompiledDeliveryContract, readFinalReceipt, } from "./lib/long-task-state.js";
+export * from "./public-api-core.js";
+export * from "./public-api-long-task.js";
+export * from "./public-types.js";

package/dist/lib/cli-exit.d.ts

@@ -0,0 +1,14 @@
+export declare const CLI_EXIT_CODES: {
+    readonly success: 0;
+    readonly arguments: 2;
+    readonly catalog: 3;
+    readonly incomplete: 4;
+    readonly io: 5;
+    readonly internal: 6;
+};
+export type CliExitCode = (typeof CLI_EXIT_CODES)[keyof typeof CLI_EXIT_CODES];
+export declare class CliCommandError extends Error {
+    readonly exit_code: CliExitCode;
+    constructor(exitCode: CliExitCode, message: string, options?: ErrorOptions);
+}
+export declare function cliExitCode(error: unknown): CliExitCode | null;

package/dist/lib/cli-exit.js

@@ -0,0 +1,19 @@
+export const CLI_EXIT_CODES = {
+    success: 0,
+    arguments: 2,
+    catalog: 3,
+    incomplete: 4,
+    io: 5,
+    internal: 6,
+};
+export class CliCommandError extends Error {
+    exit_code;
+    constructor(exitCode, message, options) {
+        super(message, options);
+        this.name = "CliCommandError";
+        this.exit_code = exitCode;
+    }
+}
+export function cliExitCode(error) {
+    return error instanceof CliCommandError ? error.exit_code : null;
+}

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

@@ -0,0 +1,3 @@
+import type { ContextManifest } from "../context-manifest-schema.js";
+export type DefaultContextSelectionReason = "core" | "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

@@ -0,0 +1,53 @@
+import { compareUtf8Paths, normalizeContextPath, sortedContextMap, } from "./catalog-paths.js";
+// This is the advisory startup set only. It does not restrict later reads or
+// turn default Area/read-policy selection into a Context or edit permission.
+export function selectDefaultContextPaths(manifest) {
+    const selected = new Map();
+    const add = (value, reason) => {
+        const normalized = normalizeContextPath(value);
+        const reasons = selected.get(normalized) ?? new Set();
+        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");
+    }
+    for (const area of manifest.areas) {
+        if (area.default)
+            add(area.context, "default_area");
+    }
+    const children = new Map(manifest.contexts.map((context) => [
+        normalizeContextPath(context.path),
+        context.default_children.map(normalizeContextPath),
+    ]));
+    const queue = [];
+    const queued = new Set();
+    const enqueue = (contextPath) => {
+        if (queued.has(contextPath))
+            return;
+        queued.add(contextPath);
+        queue.push(contextPath);
+    };
+    for (const context of manifest.contexts) {
+        if (context.read_policy !== "default")
+            continue;
+        const normalized = normalizeContextPath(context.path);
+        add(normalized, "default_role");
+        enqueue(normalized);
+    }
+    while (queue.length > 0) {
+        const parent = queue.shift();
+        for (const child of children.get(parent) ?? []) {
+            add(child, "default_child");
+            enqueue(child);
+        }
+    }
+    return sortedContextMap([...selected].map(([contextPath, reasons]) => [
+        contextPath,
+        new Set([...reasons].sort(compareUtf8Paths)),
+    ]));
+}

package/dist/lib/context-catalog/catalog-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { CatalogDiagnostic, CatalogDiagnosticSeverity } from "./catalog-types.js";
+export declare function catalogDiagnostic(code: string, severity: CatalogDiagnosticSeverity, message: string, location?: {
+    path?: string;
+    line?: number;
+}): CatalogDiagnostic;
+export declare function catalogErrors(diagnostics: CatalogDiagnostic[]): string[];
+export declare function catalogWarnings(diagnostics: CatalogDiagnostic[]): string[];
+export declare function compareCatalogDiagnostics(left: CatalogDiagnostic, right: CatalogDiagnostic): number;
+export declare function sortCatalogDiagnostics(diagnostics: readonly CatalogDiagnostic[]): CatalogDiagnostic[];