project-tiny-context-harness 0.8.17 → 0.11.0

package/dist/commands/context-inspect.js

@@ -0,0 +1,98 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { inspectContext } from "../lib/context-inspect/context-inspect.js";
+import { renderContextInspectText } from "../lib/context-inspect/context-inspect-render.js";
+export async function contextInspect(args) {
+    const options = parseInspectArgs(args);
+    if (options.help) {
+        console.log(contextInspectHelp());
+        return;
+    }
+    if (!options.target)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "context inspect requires <project_context/file.md>");
+    let result;
+    try {
+        result = await inspectContext({
+            project_root: process.cwd(),
+            context_path: options.target,
+            route_task: options.task,
+            route_paths: options.route_paths,
+            route_terms: options.terms,
+            route_case_sensitive: options.case_sensitive,
+        });
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.internal, `context inspect failed internally: ${message(error)}`, { cause: error });
+    }
+    if (options.format === "json")
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(renderContextInspectText(result));
+    if (result.diagnostics.some((entry) => entry.severity === "error"))
+        process.exitCode = CLI_EXIT_CODES.catalog;
+    else if (result.route && !result.route.complete)
+        process.exitCode = CLI_EXIT_CODES.incomplete;
+}
+function parseInspectArgs(args) {
+    const options = {
+        route_paths: [],
+        terms: [],
+        case_sensitive: false,
+        format: "text",
+        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 === "--json")
+            options.format = "json";
+        else if (argument === "--case-sensitive")
+            options.case_sensitive = true;
+        else if (argument === "--task")
+            index = readValue(args, index, argument, (value) => {
+                options.task = value;
+            });
+        else if (argument === "--route-path")
+            index = readValue(args, index, argument, (value) => {
+                options.route_paths.push(value);
+            });
+        else if (argument === "--term")
+            index = readValue(args, index, argument, (value) => {
+                options.terms.push(value);
+            });
+        else if (argument === "--format")
+            index = readValue(args, index, argument, (value) => {
+                if (value !== "text" && value !== "json")
+                    throw new CliCommandError(CLI_EXIT_CODES.arguments, "context inspect --format must be text or json");
+                options.format = value;
+            });
+        else if (argument.startsWith("--"))
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context inspect argument: ${argument}`);
+        else if (options.target)
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, "context inspect accepts exactly one Context path");
+        else
+            options.target = argument;
+    }
+    return options;
+}
+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, `context inspect ${flag} requires a value`);
+    apply(value);
+    return index + 1;
+}
+function contextInspectHelp() {
+    return `ty-context context inspect <project_context/file.md>
+  [--task <text>] [--route-path <repo-path>] [--term <literal>]
+  [--case-sensitive] [--format text|json]
+
+Reports ownership metadata, default-footprint membership, explicit Markdown
+references, opt-in stable-key declarations and an optional experimental Router
+explanation without modifying Context or Manifest files.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/context-move.d.ts

@@ -0,0 +1 @@
+export declare function contextMove(args: string[]): Promise<void>;

package/dist/commands/context-move.js

@@ -0,0 +1,78 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { renderContextMoveText } from "../lib/context-move/context-move-render.js";
+import { moveContext } from "../lib/context-move/context-move.js";
+export async function contextMove(args) {
+    const options = parseMoveArgs(args);
+    if (options.help) {
+        console.log(contextMoveHelp());
+        return;
+    }
+    if (!options.from || !options.to)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "context move requires --from and --to");
+    let result;
+    try {
+        result = await moveContext({
+            project_root: process.cwd(),
+            from_path: options.from,
+            to_path: options.to,
+            apply: options.apply,
+        });
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.internal, `context move failed internally: ${message(error)}`, { cause: error });
+    }
+    if (options.format === "json")
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(renderContextMoveText(result));
+}
+function parseMoveArgs(args) {
+    const options = {
+        apply: false,
+        format: "text",
+        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 === "--apply")
+            options.apply = true;
+        else if (argument === "--json")
+            options.format = "json";
+        else if (argument === "--from" || argument === "--to") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("--"))
+                throw new CliCommandError(CLI_EXIT_CODES.arguments, `context move ${argument} requires a value`);
+            const key = argument === "--from" ? "from" : "to";
+            if (options[key] !== undefined)
+                throw new CliCommandError(CLI_EXIT_CODES.arguments, `context move ${argument} may be provided only once`);
+            options[key] = value;
+            index += 1;
+        }
+        else if (argument === "--format") {
+            const value = args[index + 1];
+            if (value !== "text" && value !== "json")
+                throw new CliCommandError(CLI_EXIT_CODES.arguments, "context move --format must be text or json");
+            options.format = value;
+            index += 1;
+        }
+        else
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context move argument: ${argument}`);
+    }
+    return options;
+}
+function contextMoveHelp() {
+    return `ty-context context move --from <project_context/file.md> --to <project_context/file.md>
+  [--apply] [--format text|json]
+
+Dry-run is the default. Move losslessly patches the Manifest and explicit local
+Markdown links, reports unstructured exact references, validates a staged
+Catalog, and applies only through the recoverable CAS/journal transaction.
+There is no --force or whole-Manifest rewrite path.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/context-register.d.ts

@@ -0,0 +1 @@
+export declare function contextRegister(args: string[]): Promise<void>;

package/dist/commands/context-register.js

@@ -0,0 +1,110 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { registerContext } from "../lib/context-register/context-register.js";
+import { renderContextRegisterText } from "../lib/context-register/context-register-render.js";
+export async function contextRegister(args) {
+    const options = parseRegisterArgs(args);
+    if (options.help) {
+        console.log(contextRegisterHelp());
+        return;
+    }
+    if (!options.path || !options.role)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "context register requires --path and --role");
+    let result;
+    try {
+        result = await registerContext({
+            project_root: process.cwd(),
+            context_path: options.path,
+            role: options.role,
+            read_policy: options.read_policy,
+            read_when: options.read_when,
+            triggers: options.triggers,
+            default_children: options.default_children,
+            apply: options.apply,
+        });
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.internal, `context register failed internally: ${message(error)}`, { cause: error });
+    }
+    if (options.format === "json")
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(renderContextRegisterText(result));
+}
+function parseRegisterArgs(args) {
+    const options = {
+        triggers: [],
+        default_children: [],
+        apply: false,
+        format: "text",
+        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 === "--apply")
+            options.apply = true;
+        else if (argument === "--json")
+            options.format = "json";
+        else if (argument === "--path")
+            index = readValue(args, index, argument, (value) => {
+                options.path = singleValue(options.path, value, argument);
+            });
+        else if (argument === "--role")
+            index = readValue(args, index, argument, (value) => {
+                options.role = singleValue(options.role, value, argument);
+            });
+        else if (argument === "--read-policy")
+            index = readValue(args, index, argument, (value) => {
+                options.read_policy = singleValue(options.read_policy, value, argument);
+            });
+        else if (argument === "--read-when")
+            index = readValue(args, index, argument, (value) => {
+                options.read_when = singleValue(options.read_when, value, argument);
+            });
+        else if (argument === "--trigger")
+            index = readValue(args, index, argument, (value) => {
+                options.triggers.push(value);
+            });
+        else if (argument === "--default-child")
+            index = readValue(args, index, argument, (value) => {
+                options.default_children.push(value);
+            });
+        else if (argument === "--format")
+            index = readValue(args, index, argument, (value) => {
+                if (value !== "text" && value !== "json")
+                    throw new CliCommandError(CLI_EXIT_CODES.arguments, "context register --format must be text or json");
+                options.format = value;
+            });
+        else
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context register argument: ${argument}`);
+    }
+    return options;
+}
+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, `context register ${flag} requires a value`);
+    apply(value);
+    return index + 1;
+}
+function singleValue(previous, value, flag) {
+    if (previous !== undefined)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `context register ${flag} may be provided only once`);
+    return value;
+}
+function contextRegisterHelp() {
+    return `ty-context context register --path <project_context/file.md> --role <role>
+  [--read-policy default|on-demand] [--read-when <text>]
+  [--trigger <literal>]... [--default-child <context-path>]...
+  [--apply] [--format text|json]
+
+Dry-run is the default. Registration requires an existing unregistered,
+recoverable Context file and a valid staged Catalog. --apply commits through
+the CAS/journal transaction engine; there is no --force bypass.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/context-transaction.d.ts

@@ -0,0 +1 @@
+export declare function contextTransaction(args: string[]): Promise<void>;

package/dist/commands/context-transaction.js

@@ -0,0 +1,84 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { completeContextMutation, contextMutationStatus, rollbackContextMutation, } from "../lib/context-mutation/mutation-recovery.js";
+export async function contextTransaction(args) {
+    const options = parseTransactionArgs(args);
+    if (options.help || options.action === "help") {
+        console.log(contextTransactionHelp());
+        return;
+    }
+    let result;
+    try {
+        if (options.action === "status")
+            result = await contextMutationStatus(process.cwd());
+        else if (options.action === "rollback")
+            result = await rollbackContextMutation(process.cwd());
+        else
+            result = await completeContextMutation(process.cwd());
+    }
+    catch (error) {
+        if (error instanceof CliCommandError)
+            throw error;
+        throw new CliCommandError(CLI_EXIT_CODES.io, `context transaction ${options.action} failed: ${message(error)}`, { cause: error });
+    }
+    if (options.format === "json")
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    else
+        process.stdout.write(renderTransactionStatus(result, options.action));
+}
+function parseTransactionArgs(args) {
+    const [actionInput = "help", ...rest] = args;
+    if (actionInput !== "help" &&
+        actionInput !== "status" &&
+        actionInput !== "rollback" &&
+        actionInput !== "complete")
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context transaction action: ${actionInput}`);
+    const options = {
+        action: actionInput,
+        format: "text",
+        help: false,
+    };
+    for (let index = 0; index < rest.length; index += 1) {
+        const argument = rest[index];
+        if (argument === "--help" || argument === "-h")
+            options.help = true;
+        else if (argument === "--json")
+            options.format = "json";
+        else if (argument === "--format") {
+            const value = rest[index + 1];
+            if (value !== "text" && value !== "json")
+                throw new CliCommandError(CLI_EXIT_CODES.arguments, "context transaction --format must be text or json");
+            options.format = value;
+            index += 1;
+        }
+        else
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context transaction argument: ${argument}`);
+    }
+    return options;
+}
+function renderTransactionStatus(result, action) {
+    if (!result.journal_present)
+        return action === "status"
+            ? "No unfinished Context mutation transaction.\n"
+            : `Context mutation ${action} completed; no journal remains.\n`;
+    const lines = [
+        `Context mutation transaction: ${result.transaction_id}`,
+        `Operation: ${result.operation}`,
+        `Journal state: ${result.state}`,
+    ];
+    for (const directory of result.directories)
+        lines.push(`- ${directory.path}: ${directory.state} (directory)`);
+    for (const file of result.files)
+        lines.push(`- ${file.path}: ${file.state}${file.current_sha256 ? ` (${file.current_sha256})` : ""}`);
+    lines.push("Recovery:", ...result.recovery_commands.map((entry) => `- ${entry}`));
+    return `${lines.join("\n")}\n`;
+}
+function contextTransactionHelp() {
+    return `ty-context context transaction status|rollback|complete [--format text|json]
+
+Reports or resolves the single recoverable Context mutation journal. A new
+register/move transaction is refused until this journal is completed or rolled
+back. Recovery never overwrites a file whose bytes match neither side.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/context.d.ts

@@ -0,0 +1 @@
+export declare function context(args: string[]): Promise<void>;

package/dist/commands/context.js

@@ -0,0 +1,36 @@
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { contextCreate } from "./context-create.js";
+import { contextInspect } from "./context-inspect.js";
+import { contextMove } from "./context-move.js";
+import { contextRegister } from "./context-register.js";
+import { contextTransaction } from "./context-transaction.js";
+export async function context(args) {
+    const [subcommand = "help", ...rest] = args;
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        console.log(contextHelp());
+        return;
+    }
+    if (subcommand === "create")
+        return contextCreate(rest);
+    if (subcommand === "inspect")
+        return contextInspect(rest);
+    if (subcommand === "move")
+        return contextMove(rest);
+    if (subcommand === "register")
+        return contextRegister(rest);
+    if (subcommand === "transaction")
+        return contextTransaction(rest);
+    throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown context subcommand: ${subcommand}`);
+}
+function contextHelp() {
+    return `ty-context context commands:
+  context create --path <project_context/file.md> --role <role> [--format text|json]
+  context inspect <project_context/file.md> [options]
+  context move --from <project_context/file.md> --to <project_context/file.md> [--apply]
+  context register --path <project_context/file.md> --role <role> [--apply] [options]
+  context transaction status|rollback|complete [--format text|json]
+
+Create publishes an unregistered TODO-only scaffold and never edits the
+Manifest. Register and move are dry-run-first and commit only through the
+recoverable CAS/journal transaction engine; neither has a force bypass.`;
+}

package/dist/commands/design-authority-delta.d.ts

@@ -0,0 +1 @@
+export declare function designAuthorityDeltaCommand(args: string[]): Promise<void>;

package/dist/commands/design-authority-delta.js

@@ -0,0 +1,53 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDesignAuthorityDeltaAssessment } from "../lib/design-authority-delta-codec.js";
+import { validateDesignAuthorityDeltaAssessmentCurrent } from "../lib/design-authority-delta-validation.js";
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { normalizeRepositoryFile } from "../lib/long-task-paths.js";
+import { assertProtectedRepositoryFile } from "../lib/repository-path-safety.js";
+import { canonicalJson } from "../lib/strict-codec.js";
+export async function designAuthorityDeltaCommand(args) {
+    const [subcommand = "help", ...rest] = args;
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        console.log(help());
+        return;
+    }
+    if (subcommand !== "validate")
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown authority-delta subcommand: ${subcommand}`);
+    const json = rest.includes("--json");
+    const positional = rest.filter((item) => item !== "--json");
+    if (positional.length !== 1)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "usage: ty-context design-resource authority-delta validate <assessment.json> [--json]");
+    const repository = process.cwd();
+    const relative = normalizeRepositoryFile(positional[0], "design_authority_delta_assessment");
+    try {
+        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...relative.split("/")), "design_authority_delta_assessment");
+        const assessment = parseDesignAuthorityDeltaAssessment(await readFile(file, "utf8"));
+        const result = await validateDesignAuthorityDeltaAssessmentCurrent(repository, assessment);
+        if (json)
+            process.stdout.write(canonicalJson(result));
+        else {
+            console.log(`Authority Delta Assessment: ${result.assessment}`);
+            console.log(`Authority closure current: ${result.authority_identity.closure_digest}`);
+            console.log("Authority adoption: not performed");
+            console.log("Repository writes: none");
+        }
+    }
+    catch (error) {
+        throw new CliCommandError(CLI_EXIT_CODES.catalog, message(error), {
+            cause: error,
+        });
+    }
+}
+function help() {
+    return `ty-context design-resource authority-delta commands:
+  validate <assessment.json> [--json]
+                       Strictly validate a non-authoritative assessment
+                       against the current complete Design Authority closure
+
+Validation is read-only. It does not select, adopt or update Authority and it
+does not start Design System Authoring.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/design-authority.d.ts

@@ -0,0 +1 @@
+export declare function designAuthority(args: string[]): Promise<void>;

package/dist/commands/design-authority.js

@@ -0,0 +1,104 @@
+import { inspectDesignAuthorityClosure, loadCurrentDesignAuthorityClosure, } from "../lib/design-authority-closure.js";
+import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
+import { canonicalJson } from "../lib/strict-codec.js";
+import { projectDesignAuthorityTokensFromEntry } from "../lib/design-authority-tokens.js";
+export async function designAuthority(args) {
+    const [subcommand = "help", ...rest] = args;
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        console.log(help());
+        return;
+    }
+    if (subcommand === "inspect")
+        return inspect(rest);
+    if (subcommand === "tokens")
+        return tokens(rest);
+    throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown design-authority subcommand: ${subcommand}`);
+}
+async function inspect(args) {
+    const format = parseFormat(args, "inspect");
+    const result = await inspectDesignAuthorityClosure(process.cwd());
+    if (format === "json")
+        process.stdout.write(canonicalJson(result));
+    else
+        process.stdout.write(renderInspection(result));
+    if (result.status !== "valid")
+        process.exitCode = CLI_EXIT_CODES.catalog;
+}
+async function tokens(args) {
+    const fromEntry = args.length === 1 && args[0] === "--from-entry";
+    if (args.length && !fromEntry)
+        throw new CliCommandError(CLI_EXIT_CODES.arguments, "design-authority tokens accepts only --from-entry");
+    let projected = null;
+    try {
+        if (fromEntry) {
+            const result = await projectDesignAuthorityTokensFromEntry(process.cwd());
+            if (!result.success)
+                throw new Error(`DESIGN.md is not locally exportable: ${result.error}`);
+            projected = result.content;
+        }
+        else {
+            const closure = await loadCurrentDesignAuthorityClosure(process.cwd());
+            projected = closure.generated_tokens;
+        }
+    }
+    catch (error) {
+        throw new CliCommandError(CLI_EXIT_CODES.catalog, `cannot project Design Authority Tokens: ${message(error)}`, { cause: error });
+    }
+    if (projected === null)
+        throw new CliCommandError(CLI_EXIT_CODES.catalog, "cannot project Design Authority Tokens: DESIGN.md is not locally exportable");
+    process.stdout.write(projected);
+}
+function parseFormat(args, command) {
+    let format = "text";
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === "--json")
+            format = "json";
+        else if (argument === "--format") {
+            const value = args[index + 1];
+            if (value !== "text" && value !== "json")
+                throw new CliCommandError(CLI_EXIT_CODES.arguments, `design-authority ${command} --format must be text or json`);
+            format = value;
+            index += 1;
+        }
+        else
+            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown design-authority ${command} argument: ${argument}`);
+    }
+    return format;
+}
+function renderInspection(result) {
+    const lines = [`Design Authority: ${result.status}`, `Mode: ${result.mode}`];
+    if (result.identity) {
+        lines.push(`Entry: ${result.identity.entry_path}`);
+        lines.push(`Manifest: ${result.identity.manifest_path ?? "none (legacy)"}`);
+        lines.push(`Closure digest: ${result.identity.closure_digest}`);
+        lines.push(`Revision: ${result.identity.revision ?? "not declared"}`);
+        lines.push(`Members: ${result.members.length}`);
+        for (const member of result.members)
+            lines.push(`  - ${member.path} (${member.kind}, ${member.normalized_bytes} bytes)`);
+    }
+    if (result.diagnostics.length) {
+        lines.push("Diagnostics:");
+        for (const diagnostic of result.diagnostics)
+            lines.push(`  - ${diagnostic.severity} ${diagnostic.code}${diagnostic.path ? ` [${diagnostic.path}]` : ""}: ${diagnostic.detail}`);
+    }
+    else
+        lines.push("Diagnostics: none");
+    lines.push("Authority adoption: not performed");
+    return `${lines.join("\n")}\n`;
+}
+function help() {
+    return `ty-context design-authority commands:
+  design-authority inspect [--format text|json]
+                       Validate and explain the current complete closure
+  design-authority tokens [--from-entry]
+                       Print the deterministic DTCG projection from DESIGN.md;
+                       --from-entry permits read-only projection while a bundle
+                       is being revised and its old digest is intentionally stale
+
+Both commands are read-only. They never create a manifest, update a digest,
+select a design direction or adopt a Design Authority revision.`;
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/commands/design-resource.js

@@ -3,6 +3,7 @@ import { preflightDesignResourceHandoff } from "../lib/design-resource-handoff-v
 import { designResourceRecoveryCommand } from "./design-resource-recovery.js";
 import { normalizeRepositoryCwd, normalizeRepositoryFile, } from "../lib/long-task-paths.js";
 import { canonicalJson } from "../lib/strict-codec.js";
+import { designAuthorityDeltaCommand } from "./design-authority-delta.js";
 export async function designResource(args) {
     const [subcommand = "help", ...rest] = args;
     if (subcommand === "help") {
@@ -17,6 +18,10 @@ export async function designResource(args) {
         await designResourceRecoveryCommand(rest);
         return;
     }
+    if (subcommand === "authority-delta") {
+        await designAuthorityDeltaCommand(rest);
+        return;
+    }
     if (subcommand !== "preflight")
         throw new Error(`Unknown design-resource subcommand: ${subcommand}`);
     const json = rest.includes("--json");
@@ -121,5 +126,7 @@ function help() {
   recovery reconcile <session> --audit <audit.json> [--json]
                        Read-only reconciliation for a no-writeback checkpoint
   recovery remove <session> --expected-sha256 <sha256> [--json]
-                       Remove only the digest-matched helper-owned checkpoint`);
+                       Remove only the digest-matched helper-owned checkpoint
+  authority-delta validate <assessment.json> [--json]
+                       Validate one read-only, non-adopting Authority assessment`);
 }

package/dist/commands/doctor.d.ts

@@ -1 +1 @@
-export declare function doctor(): Promise<void>;
+export declare function doctor(args?: string[]): Promise<void>;