nawabari 0.7.1 → 0.9.2

package/dist/cli.js

@@ -4,6 +4,7 @@ import { DomainError, EXIT_CODES, failure } from "./domain/errors.js";
 import { MAX_SESSION_LIST_LIMIT, } from "./domain/session.js";
 import { EVIDENCE_MAX_DIFF_BYTES, EVIDENCE_MAX_DIFF_HUNKS, EVIDENCE_MAX_DIFF_PATHS } from "./repository-evidence.js";
 import { isResourceClaimMode } from "./resource-claims.js";
+import { OPERATION_VOCABULARY } from "./operation-authorization.js";
 import { createLocalSessionBackend } from "./domain/session-backend.js";
 import { defaultCliIO, renderFailure, renderSuccess } from "./presentation.js";
 import { MACHINE_CONTRACT_ID, MACHINE_CONTRACT_SCHEMA_VERSION, machineContract } from "./contract.js";
@@ -11,521 +12,173 @@ import { resolveSandboxExecutionRequest, runSandboxedCommand, } from "./domain/s
 const CLI_NAME = "nawabari";
 const packageMetadata = createRequire(import.meta.url)("../package.json");
 const VERSION = packageMetadata.version;
-const GLOBAL_HELP_OPTIONS = [
-    { name: "--json", description: "Emit one stable JSON document on stdout" },
-    { name: "--help", description: "Show command-specific help" },
-    { name: "--version", description: "Print the installed version" },
-];
-const option = (name, description, options = {}) => ({ name, description, ...options });
-const HELP_COMMANDS = [
-    {
-        name: "session create",
-        summary: "Request a new Nawabari session",
-        usage: `${CLI_NAME} session create [options]`,
-        options: [
-            option("--branch", "Branch to create; omitted uses the generated session branch", {
-                value: "<name>",
-                default: "nawabari/session/<session_id>",
-            }),
-            option("--worktree", "Exact managed worktree path override; mutually exclusive with --worktree-root", {
-                value: "<path>",
-                default: "<managed_worktree_root>/<repository>-<session_id>",
-            }),
-            option("--worktree-root", "Managed root to place the worktree under; Nawabari derives the final path. Mutually exclusive with --worktree", { value: "<path>", default: "resolved repository-local root" }),
-            option("--base", "Commit-resolving base ref for the new worktree", { value: "<ref>", default: "HEAD" }),
-            option("--label", "Optional display label; never used as an identity", { value: "<text>", default: "omitted" }),
-        ],
-        notes: [
-            "All create options are optional. Use status --json to discover managed_worktree_root.",
-            "--worktree and --worktree-root cannot be combined.",
-        ],
-    },
-    {
-        name: "session id",
-        summary: "Resolve the current session identity",
-        usage: `${CLI_NAME} session id`,
-        options: [],
-    },
-    {
-        name: "session show",
-        summary: "Show the current or selected session",
-        usage: `${CLI_NAME} session show [<session-id>|--session <id>]`,
-        options: [option("--session", "Select a session instead of the current worktree owner", { value: "<id>" })],
-        notes: [
-            "Target grammar is consistent: an optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session inspect",
-        summary: "Report side-effect-free close/cleanup readiness for a session",
-        usage: `${CLI_NAME} session inspect [<session-id>|--session <id>] [--integrated-revision <rev>]`,
-        options: [
-            option("--session", "Select a session instead of the current worktree owner", { value: "<id>" }),
-            option("--integrated-revision", "Externally evidenced revision to test for non-ancestry (squash/rebase) integration; independently re-verified via exact Git tree-object equivalence, never trusted blindly", { value: "<rev>" }),
-        ],
-        notes: [
-            "Read-only: never mutates session, claim, Git, worktree, branch, or registry state. Repeated calls are idempotent.",
-            "Derived from the same authoritative close/cleanup Git evidence as session close; does not duplicate or diverge from that logic.",
-            "Nawabari never queries GitHub or any remote provider; --integrated-revision only names a local revision for Nawabari to independently verify.",
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session run",
-        summary: "Run one command inside the protected session sandbox",
-        usage: `${CLI_NAME} session run [--session <id>] -- <command> [args...]`,
-        options: [option("--session", "Select the active owned session", { value: "<id>" })],
-        notes: [
-            "The -- terminator is mandatory. The command is passed as argv without a shell, and protected execution is fail-closed.",
-            "session exec is an alias.",
-        ],
-    },
-    {
-        name: "session list",
-        summary: "List bounded repository session records",
-        usage: `${CLI_NAME} session list [--all|--history]`,
-        options: [
-            option("--all", "Include closed history; explicit unbounded history view"),
-            option("--history", "Alias for --all"),
-        ],
-        notes: ["Default output excludes closed records and is limited to 64 records."],
-    },
-    {
-        name: "session claim",
-        summary: "Add a canonical resource claim",
-        usage: `${CLI_NAME} session claim [<session-id>] --resource <path-or-glob> --mode <read|write|exclusive-write>`,
-        options: [
-            option("--resource", "Repository-relative resource", { value: "<path-or-glob>", required: true }),
-            option("--mode", "Granted claim mode", { value: "<read|write|exclusive-write>", required: true }),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session update",
-        summary: "Atomically replace a session's complete resource claim set",
-        usage: `${CLI_NAME} session update [<session-id>] --resource <path-or-glob> --mode <read|write|exclusive-write> [--resource <path-or-glob> --mode <read|write|exclusive-write> ...]`,
-        options: [
-            option("--resource", "Repository-relative resource; repeatable, each paired with the --mode immediately after it", {
-                value: "<path-or-glob>",
-                required: true,
-            }),
-            option("--mode", "Mode for the --resource immediately before it; repeatable", {
-                value: "<read|write|exclusive-write>",
-                required: true,
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-integer>",
-            }),
-            option("--force", "Explicitly permit unconditional complete replacement; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "The desired claim set is a full replacement performed atomically in one updateClaims() transaction; " +
-                "use exactly one concurrency intent: --if-generation <non-negative-integer> for claim-set generation CAS, " +
-                "or explicit --force for unconditional replacement. On any invalid, conflicting, or stale claim the prior set is left unchanged.",
-            "Each --resource must be immediately followed by its own --mode; pairing is positional adjacency, not flag order.",
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session mutate",
-        summary: "Atomically apply exact-resource claim additions, changes, and releases",
-        usage: `${CLI_NAME} session mutate [<session>|--session <id>] [--repository <id>] ` +
-            `(--upsert-resource <path-or-glob> --mode <read|write|exclusive-write> | --release-resource <path-or-glob>)+ ` +
-            `(--if-generation <non-negative-safe-int> | --force)`,
-        options: [
-            option("--upsert-resource", "Exact repository-relative resource to add or change; each occurrence must be immediately followed by --mode", { value: "<path-or-glob>" }),
-            option("--mode", "Mode for the immediately preceding --upsert-resource", {
-                value: "<read|write|exclusive-write>",
-            }),
-            option("--release-resource", "Exact repository-relative resource to release; repeatable", {
-                value: "<path-or-glob>",
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly permit unconditional atomic mutation; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "Apply one or more ordered upsert/release deltas in one backend transaction; exactly one concurrency intent is required.",
-            "Every --upsert-resource must be immediately followed by its own --mode; --release-resource takes exactly one value.",
-            "Target grammar: optional first positional <session> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session transition",
-        summary: "Atomically transition one exact resource claim mode",
-        usage: `${CLI_NAME} session transition [<session>|--session <id>] [--repository <id>] ` +
-            `--resource <path-or-glob> --mode <read|write|exclusive-write> ` +
-            `(--if-generation <non-negative-safe-int> | --force)`,
-        options: [
-            option("--resource", "Exact repository-relative resource to acquire or change", {
-                value: "<path-or-glob>",
-                required: true,
-            }),
-            option("--mode", "Target mode for the immediately preceding --resource", {
-                value: "<read|write|exclusive-write>",
-                required: true,
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly permit unconditional atomic mutation; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "Exactly one resource/mode pair is projected as one atomic upsert delta; same mode is an idempotent no-op.",
-            "Use exactly one concurrency intent: --if-generation <non-negative-safe-int> or explicit --force.",
-            "The target grammar accepts an optional first positional <session> or --session <id>, but not both.",
-        ],
-    },
-    {
-        name: "session claims",
-        summary: "List canonical resource claims",
-        usage: `${CLI_NAME} session claims [<session-id>|--session <id>]`,
-        options: [option("--session", "Select a session; omitted lists all claims", { value: "<id>" })],
-        notes: [
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session release",
-        summary: "Release resource claims",
-        usage: `${CLI_NAME} session release [<session-id>|--session <id>] (--resource <path-or-glob> ... | --claim-id <id> ... | --all) (--if-generation <n> | --force)`,
-        options: [
-            option("--session", "Target session; omitted resolves the current owner", { value: "<id>" }),
-            option("--resource", "Release one exact canonical resource; repeatable", { value: "<path-or-glob>" }),
-            option("--claim-id", "Release one owned claim ID; repeatable", { value: "<id>" }),
-            option("--all", "Explicitly release all claims owned by the target session"),
-            option("--if-generation", "Require the expected claim-set generation; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly allow unconditional release; mutually exclusive with --if-generation"),
-        ],
-        notes: [
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-            "Exactly one selector family is required: repeated --resource, repeated --claim-id, or explicit --all.",
-            "Exactly one destructive concurrency intent is required: --if-generation <non-negative-safe-int> or --force.",
-        ],
-    },
-    {
-        name: "resource claim",
-        summary: "Add a canonical resource claim (alias)",
-        usage: `${CLI_NAME} resource claim [<session-id>|--session <id>] --resource <path-or-glob> --mode <read|write|exclusive-write>`,
-        options: [],
-        notes: [
-            "Target grammar matches session claim: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "resource update",
-        summary: "Atomically replace a session's complete resource claim set (alias)",
-        usage: `${CLI_NAME} resource update [<session-id>|--session <id>] --resource <path-or-glob> --mode <read|write|exclusive-write> [--resource <path-or-glob> --mode <read|write|exclusive-write> ...]`,
-        options: [
-            option("--resource", "Repository-relative resource; repeatable, each paired with the --mode immediately after it", {
-                value: "<path-or-glob>",
-                required: true,
-            }),
-            option("--mode", "Mode for the --resource immediately before it; repeatable", {
-                value: "<read|write|exclusive-write>",
-                required: true,
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-integer>",
-            }),
-            option("--force", "Explicitly permit unconditional complete replacement; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "The desired claim set is a full replacement performed atomically in one updateClaims() transaction; " +
-                "use exactly one concurrency intent: --if-generation <non-negative-integer> for claim-set generation CAS, " +
-                "or explicit --force for unconditional replacement. On any invalid, conflicting, or stale claim the prior set is left unchanged.",
-            "Each --resource must be immediately followed by its own --mode; pairing is positional adjacency, not flag order.",
-            "Target grammar matches session update: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "resource mutate",
-        summary: "Atomically apply exact-resource claim additions, changes, and releases (alias)",
-        usage: `${CLI_NAME} resource mutate [<session>|--session <id>] [--repository <id>] ` +
-            `(--upsert-resource <path-or-glob> --mode <read|write|exclusive-write> | --release-resource <path-or-glob>)+ ` +
-            `(--if-generation <non-negative-safe-int> | --force)`,
-        options: [
-            option("--upsert-resource", "Exact repository-relative resource to add or change; each occurrence must be immediately followed by --mode", { value: "<path-or-glob>" }),
-            option("--mode", "Mode for the immediately preceding --upsert-resource", {
-                value: "<read|write|exclusive-write>",
-            }),
-            option("--release-resource", "Exact repository-relative resource to release; repeatable", {
-                value: "<path-or-glob>",
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly permit unconditional atomic mutation; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "Apply one or more ordered upsert/release deltas in one backend transaction; exactly one concurrency intent is required.",
-            "Every --upsert-resource must be immediately followed by its own --mode; --release-resource takes exactly one value.",
-            "Target grammar matches session mutate: optional first positional <session> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "resource transition",
-        summary: "Atomically transition one exact resource claim mode (alias)",
-        usage: `${CLI_NAME} resource transition [<session>|--session <id>] [--repository <id>] ` +
-            `--resource <path-or-glob> --mode <read|write|exclusive-write> ` +
-            `(--if-generation <non-negative-safe-int> | --force)`,
-        options: [
-            option("--resource", "Exact repository-relative resource to acquire or change", {
-                value: "<path-or-glob>",
-                required: true,
-            }),
-            option("--mode", "Target mode for the immediately preceding --resource", {
-                value: "<read|write|exclusive-write>",
-                required: true,
-            }),
-            option("--if-generation", "Expected claim-set generation for CAS; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly permit unconditional atomic mutation; mutually exclusive with --if-generation"),
-            option("--session", "Target active session; omitted resolves the current owner", { value: "<id>" }),
-            option("--repository", "Expected repository identity", { value: "<id>" }),
-        ],
-        notes: [
-            "Exactly one resource/mode pair is projected as one atomic upsert delta; same mode is an idempotent no-op.",
-            "Use exactly one concurrency intent: --if-generation <non-negative-safe-int> or explicit --force.",
-            "The target grammar accepts an optional first positional <session> or --session <id>, but not both.",
-        ],
-    },
-    {
-        name: "resource list",
-        summary: "List canonical resource claims (alias)",
-        usage: `${CLI_NAME} resource list [<session-id>|--session <id>]`,
-        options: [option("--session", "Select a session; omitted lists all claims", { value: "<id>" })],
-        notes: [
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "resource release",
-        summary: "Release resource claims (alias)",
-        usage: `${CLI_NAME} resource release [<session-id>|--session <id>] (--resource <path-or-glob> ... | --claim-id <id> ... | --all) (--if-generation <n> | --force)`,
-        options: [
-            option("--session", "Target session; omitted resolves the current owner", { value: "<id>" }),
-            option("--resource", "Release one exact canonical resource; repeatable", { value: "<path-or-glob>" }),
-            option("--claim-id", "Release one owned claim ID; repeatable", { value: "<id>" }),
-            option("--all", "Explicitly release all claims owned by the target session"),
-            option("--if-generation", "Require the expected claim-set generation; mutually exclusive with --force", {
-                value: "<non-negative-safe-int>",
-            }),
-            option("--force", "Explicitly allow unconditional release; mutually exclusive with --if-generation"),
-        ],
-        notes: [
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-            "Exactly one selector family is required: repeated --resource, repeated --claim-id, or explicit --all.",
-            "Exactly one destructive concurrency intent is required: --if-generation <non-negative-safe-int> or --force.",
-        ],
-    },
-    {
-        name: "session close",
-        summary: "Close the current or selected session",
-        usage: `${CLI_NAME} session close [<session-id>|--session <id>] [--integrated-revision <rev>] [--fetch-remote <name> --fetch-branch <branch>]`,
-        options: [
-            option("--session", "Select a session instead of the current worktree owner", { value: "<id>" }),
-            option("--integrated-revision", "Externally evidenced revision proving non-ancestry (squash/rebase) integration; independently re-verified via exact Git tree-object equivalence, never trusted blindly", { value: "<rev>" }),
-            option("--fetch-remote", "Explicitly fetch one remote integration branch into a disposable proof ref", {
-                value: "<name>",
-            }),
-            option("--fetch-branch", "Integration branch to fetch; requires --fetch-remote", { value: "<branch>" }),
-        ],
-        notes: [
-            "Ordinary ancestry-based close remains the cheap/default path and requires no flags.",
-            "Network access is never implicit; --fetch-remote and --fetch-branch are accepted only with a full lowercase --integrated-revision SHA.",
-            "Fetch updates only a disposable internal proof ref with no tags, FETCH_HEAD, tracking-ref, or local integration-branch changes; remote tip races fail closed.",
-            "Nawabari never calls provider APIs such as GitHub; only explicit --fetch-remote/--fetch-branch options connect to the configured Git remote.",
-            "Target grammar: optional first positional <session-id> is an alias for --session <id>; do not supply both.",
-        ],
-    },
-    {
-        name: "session discard",
-        summary: "Explicitly discard one selected session and its owned resources",
-        usage: `${CLI_NAME} session discard <session-id>|--session <id>`,
-        options: [
-            option("--session", "Required explicit target; the current session is never inferred", {
-                value: "<id>",
-                required: true,
-            }),
-        ],
-        notes: [
-            "Destructive and explicit: unintegrated commits and uncommitted work in the selected owned worktree may be destroyed.",
-            "Discard never changes close, gc, doctor, reconciliation, or integration-lineage proof behavior.",
-            "Use exactly one target form: positional <session-id> or --session <id>; do not supply both.",
-            "Machine JSON mode is non-interactive and deterministic.",
-        ],
-    },
-    {
-        name: "authorize",
-        summary: "Authorize an operation against concrete claims",
-        usage: `${CLI_NAME} authorize --operation <name> --resource <path> [--resource <path>] [--session <id>]`,
-        options: [
-            option("--session", "Assert the current session identity", { value: "<id>" }),
-            option("--operation", "Operation vocabulary entry", { value: "<name>", required: true }),
-            option("--resource", "Concrete repository-relative path; repeatable", { value: "<path>", required: true }),
-        ],
-    },
-    {
-        name: "checkpoint",
-        summary: "Capture bounded Git execution evidence",
-        usage: `${CLI_NAME} checkpoint [--session <id>]`,
-        options: [option("--session", "Assert the current session identity", { value: "<id>" })],
-    },
-    {
-        name: "evidence snapshot",
-        summary: "Capture bounded read-only evidence for one owned session",
-        usage: `${CLI_NAME} evidence snapshot --session <id>`,
-        options: [option("--session", "Explicit owned session to observe", { value: "<id>", required: true })],
-        notes: ["The result is Git-observable physical evidence only; it contains no task or semantic interpretation."],
-    },
-    {
-        name: "diff",
-        summary: "Inspect bounded Git evidence for explicit paths",
-        usage: `${CLI_NAME} diff --session <id> --path <path> [options]`,
-        options: [
-            option("--session", "Explicit owned session to observe", { value: "<id>", required: true }),
-            option("--path", "Concrete repository-relative path; repeatable", { value: "<path>", required: true }),
-            option("--from", "Commit/ref at the start of the range", { value: "<ref>", default: "HEAD" }),
-            option("--to", "Commit/ref at the end of the range; omitted means worktree", { value: "<ref>" }),
-            option("--patch", "Include patch text; requires the bounded byte/hunk limits"),
-            option("--max-bytes", "Maximum UTF-8 patch bytes", { value: "<n>", default: String(EVIDENCE_MAX_DIFF_BYTES) }),
-            option("--max-hunks", "Maximum patch hunks", { value: "<n>", default: String(EVIDENCE_MAX_DIFF_HUNKS) }),
-        ],
-    },
-    {
-        name: "commit",
-        summary: "Commit explicit claim-authorized resources",
-        usage: `${CLI_NAME} commit --message <final-message> --resource <path> [--resource <path>] [--session <id>] [--message-pattern <regex>]`,
-        options: [
-            option("--session", "Assert the current session identity", { value: "<id>" }),
-            option("--message", "Caller-decided final commit message", { value: "<final-message>", required: true }),
-            option("--resource", "Claim-covered concrete path; repeatable", { value: "<path>", required: true }),
-            option("--message-pattern", "Caller-declared commit-message rule; validated only when supplied", {
-                value: "<regex>",
-            }),
-        ],
-    },
-    {
-        name: "push",
-        summary: "Push the owned branch to an explicit target",
-        usage: `${CLI_NAME} push --remote <name> --branch <name> --resource <path> [options]`,
-        options: [
-            option("--session", "Assert the current session identity", { value: "<id>" }),
-            option("--resource", "Claim-covered concrete path; repeatable", { value: "<path>", required: true }),
-            option("--remote", "Explicit Git remote", { value: "<name>", required: true }),
-            option("--branch", "Explicit target branch", { value: "<name>", required: true }),
-            option("--remote-branch", "Explicit remote branch alias for --branch", { value: "<name>" }),
-            option("--force", "Allow force-with-lease when relation requires it"),
-            option("--create-upstream", "Allow creation of a missing upstream"),
-        ],
-    },
-    {
-        name: "status",
-        summary: "Show repository context and bounded session status",
-        usage: `${CLI_NAME} status [--all|--history]`,
-        options: [
-            option("--all", "Include closed history; explicit unbounded history view"),
-            option("--history", "Alias for --all"),
-        ],
-        notes: ["The default machine result exposes managed_worktree_root for session-create path discovery."],
-    },
-    {
-        name: "guard",
-        summary: "Authorize the current worktree or operation",
-        usage: `${CLI_NAME} guard [--session <id>] [--operation <name> --resource <path>]`,
-        options: [
-            option("--session", "Assert the current session identity", { value: "<id>" }),
-            option("--operation", "Authorize an operation when resources are supplied", { value: "<name>" }),
-            option("--resource", "Concrete resource; repeatable with --operation", { value: "<path>" }),
-        ],
-    },
-    {
-        name: "gc",
-        summary: "Detect or clean eligible stale sessions",
-        usage: `${CLI_NAME} gc [--dry-run|--apply]`,
-        options: [
-            option("--apply", "Apply only cleanup that passes safety checks"),
-            option("--dry-run", "Preflight eligible stale cleanup without mutation"),
-        ],
-        notes: [
-            "Default stale threshold is 24 hours (86,400,000 ms). Eligibility uses persisted state age or missing/prunable Git worktree physical state; closed history is not a stale candidate.",
-        ],
-    },
-    {
-        name: "doctor",
-        summary: "Check local Nawabari prerequisites and reconciliation",
-        usage: `${CLI_NAME} doctor`,
-        options: [],
-    },
-    {
-        name: "capabilities",
-        summary: "Describe the standalone CLI/JSON contract",
-        usage: `${CLI_NAME} capabilities`,
-        options: [],
-    },
+import { CLI_COMMAND_REGISTRY, GLOBAL_HELP_OPTIONS, ROOT_HELP_SPEC, publicCliCommandDefinitions, publicCliCommandNames, resolveCliCommandDefinition, canonicalCommandForName, } from "./cli-command-registry.js";
+export { CLI_COMMAND_REGISTRY, COMMAND_REGISTRY, publicCliCommandDefinitions, publicCliCommandNames, resolveCliCommandDefinition, canonicalCommandForName, } from "./cli-command-registry.js";
+/**
+ * The dispatcher deliberately keeps its command branches specialized, but
+ * this inventory makes the executable surface explicit for structural parity
+ * checks. Aliases are listed because they are public entry points too.
+ */
+export const DISPATCHER_COMMAND_INVENTORY = [
+    "session create",
+    "session id",
+    "session show",
+    "session inspect",
+    "session run",
+    "session exec",
+    "session list",
+    "session claim",
+    "resource claim",
+    "session update",
+    "resource update",
+    "session mutate",
+    "resource mutate",
+    "session transition",
+    "resource transition",
+    "session claims",
+    "resource list",
+    "resource claims",
+    "session release",
+    "resource release",
+    "session close",
+    "session discard",
+    "authorize",
+    "checkpoint",
+    "evidence snapshot",
+    "diff",
+    "commit",
+    "push",
+    "status",
+    "guard",
+    "gc",
+    "doctor",
+    "migrate",
+    "capabilities",
 ];
-const ROOT_HELP_SPEC = {
-    name: "root",
-    summary: "Standalone local Git/session ownership CLI",
-    usage: `${CLI_NAME} <command> [options]`,
-    options: GLOBAL_HELP_OPTIONS,
+/** Dispatcher option inventory, keyed by canonical registry command identity. */
+export const DISPATCHER_OPTION_INVENTORY = {
+    "session create": ["--branch", "--worktree", "--worktree-root", "--base", "--label"],
+    "session id": [],
+    "session show": ["--session"],
+    "session inspect": ["--session", "--integrated-revision"],
+    "session run": ["--session"],
+    "session list": ["--all", "--history", "--limit", "--offset"],
+    "session claim": ["--resource", "--mode", "--session", "--repository"],
+    "session update": ["--resource", "--mode", "--if-generation", "--force", "--session", "--repository"],
+    "session mutate": [
+        "--upsert-resource",
+        "--mode",
+        "--release-resource",
+        "--if-generation",
+        "--force",
+        "--session",
+        "--repository",
+    ],
+    "session transition": ["--resource", "--mode", "--if-generation", "--force", "--session", "--repository"],
+    "session claims": ["--session"],
+    "session release": ["--session", "--resource", "--claim-id", "--all", "--if-generation", "--force"],
+    "session close": ["--session", "--integrated-revision", "--fetch-remote", "--fetch-branch"],
+    "session discard": ["--session", "--preview"],
+    authorize: ["--session", "--operation", "--resource"],
+    checkpoint: ["--session"],
+    "evidence snapshot": ["--session"],
+    diff: ["--session", "--path", "--from", "--to", "--patch", "--max-bytes", "--max-hunks"],
+    commit: ["--session", "--message", "--resource", "--all-claimed", "--message-pattern"],
+    push: [
+        "--session",
+        "--resource",
+        "--all-claimed",
+        "--remote",
+        "--branch",
+        "--remote-branch",
+        "--force",
+        "--create-upstream",
+    ],
+    status: ["--all", "--history", "--limit", "--offset"],
+    guard: ["--session", "--operation", "--resource"],
+    gc: ["--apply", "--dry-run"],
+    doctor: [],
+    migrate: [],
+    capabilities: [],
 };
+function optionNames(definition) {
+    return definition.options.flatMap((candidate) => [candidate.name, ...(candidate.aliases ?? [])]);
+}
+function canonicalName(name) {
+    return CLI_COMMAND_REGISTRY.find((definition) => definition.name === name || definition.aliases?.includes(name))
+        ?.name;
+}
+/** Return the registry-backed option set used by a specialized dispatcher parser. */
+export function dispatcherAllowedOptions(command) {
+    const canonical = canonicalName(command);
+    if (canonical === undefined)
+        throw new Error(`Dispatcher command is not registered: ${command}`);
+    return new Set(DISPATCHER_OPTION_INVENTORY[canonical] ?? []);
+}
+/**
+ * Verify both executable command/option inventory and registry metadata. This
+ * is intentionally structural: parser semantics remain in their command
+ * handlers, while drift becomes a deterministic failure in tests/startup.
+ */
+export function validateCliRegistryParity() {
+    const publicNames = publicCliCommandNames();
+    const publicSet = new Set(publicNames);
+    const dispatcherSet = new Set(DISPATCHER_COMMAND_INVENTORY);
+    const missingFromDispatcher = publicNames.filter((name) => !dispatcherSet.has(name));
+    const missingFromRegistry = DISPATCHER_COMMAND_INVENTORY.filter((name) => !publicSet.has(name));
+    if (missingFromDispatcher.length > 0 || missingFromRegistry.length > 0) {
+        throw new Error(`CLI command registry parity failure: missing_from_dispatcher=${missingFromDispatcher.join(",")}; ` +
+            `missing_from_registry=${missingFromRegistry.join(",")}`);
+    }
+    for (const name of publicNames) {
+        const canonical = canonicalName(name);
+        if (canonical === undefined)
+            throw new Error(`CLI command registry cannot resolve ${name}`);
+        const expected = new Set(DISPATCHER_OPTION_INVENTORY[canonical] ?? []);
+        const actual = new Set(optionNames(resolveCliCommandDefinition(name)));
+        const missing = [...actual].filter((option) => !expected.has(option));
+        const extra = [...expected].filter((option) => !actual.has(option));
+        if (missing.length > 0 || extra.length > 0) {
+            throw new Error(`CLI option registry parity failure for ${name}: missing_from_dispatcher=${missing.join(",")}; ` +
+                `missing_from_registry=${extra.join(",")}`);
+        }
+    }
+    for (const command of ["authorize", "guard"]) {
+        const definition = resolveCliCommandDefinition(command);
+        const operation = definition?.options.find((candidate) => candidate.name === "--operation");
+        if (operation === undefined || operation.values === undefined) {
+            throw new Error(`CLI operation vocabulary parity failure for ${command}: missing --operation values`);
+        }
+        if (operation.values.join("\u0000") !== OPERATION_VOCABULARY.join("\u0000")) {
+            throw new Error(`CLI operation vocabulary parity failure for ${command}: expected=${OPERATION_VOCABULARY.join(",")}; ` +
+                `actual=${operation.values.join(",")}`);
+        }
+    }
+}
+validateCliRegistryParity();
 function helpSpecFor(commandArguments) {
     if (commandArguments.length === 0)
         return ROOT_HELP_SPEC;
-    let key = commandArguments[0] === "resource"
+    const key = commandArguments[0] === "resource"
         ? `resource ${commandArguments[1] ?? "list"}`
-        : commandArguments[0] === "session" && commandArguments[1] === "exec"
-            ? "session run"
-            : commandArguments.slice(0, 2).join(" ");
-    if (key === "resource claims")
-        key = "resource list";
-    const direct = HELP_COMMANDS.find((spec) => spec.name === key);
-    if (direct !== undefined && !direct.name.startsWith("resource "))
-        return direct;
-    const aliasTarget = direct?.name.replace(/^resource /u, "session ");
-    const target = aliasTarget === undefined ? undefined : HELP_COMMANDS.find((spec) => spec.name === aliasTarget);
-    if (direct !== undefined && target !== undefined) {
-        return {
-            name: direct.name,
-            summary: direct.summary,
-            usage: direct.usage,
-            options: direct.options,
-            notes: direct.notes,
-        };
-    }
-    return HELP_COMMANDS.find((spec) => spec.name === commandArguments[0]) ?? ROOT_HELP_SPEC;
+        : commandArguments.slice(0, 2).join(" ");
+    return resolveCliCommandDefinition(key) ?? resolveCliCommandDefinition(commandArguments[0]) ?? ROOT_HELP_SPEC;
 }
 function helpPayload(spec) {
     if (spec.name === "root") {
+        const publicCommands = publicCliCommandDefinitions();
         const optionNames = (options) => options.map((candidate) => candidate.name);
-        const sessionOptions = HELP_COMMANDS.filter((command) => command.name.startsWith("session ")).flatMap((command) => command.options);
+        const sessionOptions = publicCommands
+            .filter((command) => command.name.startsWith("session "))
+            .flatMap((command) => command.options);
         const unique = (values) => values.filter((value, index) => values.indexOf(value) === index);
         const sessionListOnlyOptions = new Set(["--all", "--history"]);
-        const optionsFor = (name) => optionNames(HELP_COMMANDS.find((command) => command.name === name)?.options ?? []);
+        const sessionTargetingCommands = CLI_COMMAND_REGISTRY.filter((command) => command.name.startsWith("session ") && command.usage.includes("<session")).map((command) => command.name.slice("session ".length));
+        const optionsFor = (name) => optionNames(publicCommands.find((command) => command.name === name)?.options ?? []);
         return {
             usage: `Usage: ${spec.usage}`,
-            commands: HELP_COMMANDS.map((command) => command.name),
-            options: ["--json", "--help", "--version"],
+            commands: publicCommands.map((command) => command.name),
+            options: GLOBAL_HELP_OPTIONS.map((candidate) => candidate.name),
             session_options: unique(sessionOptions.map((option) => option.name).filter((name) => !sessionListOnlyOptions.has(name))),
             authorization_options: optionsFor("authorize"),
             checkpoint_options: optionsFor("checkpoint"),
@@ -535,18 +188,7 @@ function helpPayload(spec) {
             session_targeting: {
                 canonical: "--session <id>",
                 positional_alias: "<session-id> as the first argument after a session-scoped subcommand",
-                commands: [
-                    "show",
-                    "inspect",
-                    "claim",
-                    "claims",
-                    "release",
-                    "update",
-                    "mutate",
-                    "transition",
-                    "close",
-                    "discard",
-                ],
+                commands: sessionTargetingCommands,
                 ambiguity: "supplying both positional and --session is rejected",
                 discard_requires_explicit_target: true,
             },
@@ -554,13 +196,26 @@ function helpPayload(spec) {
     }
     const options = spec.options.map((candidate) => ({
         name: candidate.name,
+        ...(candidate.aliases === undefined ? {} : { aliases: [...candidate.aliases] }),
+        ...(candidate.alias_of === undefined ? {} : { alias_of: candidate.alias_of }),
         ...(candidate.value === undefined ? {} : { value: candidate.value }),
         required: candidate.required === true,
+        ...(candidate.repeatable === undefined ? {} : { repeatable: candidate.repeatable }),
         ...(candidate.default === undefined ? {} : { default: candidate.default }),
+        ...(candidate.minimum === undefined ? {} : { minimum: candidate.minimum }),
+        ...(candidate.maximum === undefined ? {} : { maximum: candidate.maximum }),
+        ...(candidate.values === undefined ? {} : { values: [...candidate.values] }),
+        ...(candidate.required_unless === undefined ? {} : { required_unless: [...candidate.required_unless] }),
+        ...(candidate.mutually_exclusive_with === undefined
+            ? {}
+            : { mutually_exclusive_with: [...candidate.mutually_exclusive_with] }),
         description: candidate.description,
     }));
+    const canonical = canonicalCommandForName(spec.name);
     return {
         help_for: spec.name,
+        ...(canonical === undefined || canonical.name === spec.name ? {} : { canonical_command: canonical.name }),
+        ...(canonical?.aliases === undefined || canonical.name !== spec.name ? {} : { aliases: [...canonical.aliases] }),
         usage: spec.usage,
         summary: spec.summary,
         required_options: spec.options
@@ -580,8 +235,9 @@ function helpText(spec) {
     const lines = [`Usage: ${spec.usage}`, "", spec.summary];
     if (spec.name === "root") {
         lines.push("", "Commands:");
-        for (const command of HELP_COMMANDS)
+        for (const command of publicCliCommandDefinitions()) {
             lines.push(`  ${command.name.padEnd(20)} ${command.summary}`);
+        }
         lines.push("", "Global options:");
         for (const candidate of GLOBAL_HELP_OPTIONS) {
             const label = candidate.name === "--help" ? "-h, --help" : candidate.name;
@@ -597,7 +253,15 @@ function helpText(spec) {
             const qualifier = candidate.required === true
                 ? "required"
                 : `optional${candidate.default === undefined ? "" : `; default: ${candidate.default}`}`;
-            lines.push(`  ${label.padEnd(38)} ${qualifier}; ${candidate.description}`);
+            const bounds = candidate.minimum === undefined && candidate.maximum === undefined
+                ? ""
+                : `; bounds: ${candidate.minimum ?? "-∞"}..${candidate.maximum ?? "∞"}`;
+            const values = candidate.values === undefined ? "" : `; values: ${candidate.values.join(", ")}`;
+            const requiredUnless = candidate.required_unless === undefined ? "" : `; required unless: ${candidate.required_unless.join(", ")}`;
+            const mutuallyExclusive = candidate.mutually_exclusive_with === undefined
+                ? ""
+                : `; mutually exclusive with: ${candidate.mutually_exclusive_with.join(", ")}`;
+            lines.push(`  ${label.padEnd(38)} ${qualifier}${bounds}${values}${requiredUnless}${mutuallyExclusive}; ${candidate.description}`);
         }
         if (spec.notes !== undefined) {
             lines.push("", "Notes:");
@@ -675,6 +339,7 @@ function parseOptions(arguments_, allowed) {
         apply: false,
         force: false,
         create_upstream: false,
+        all_claimed: false,
         all: false,
         history: false,
         limit: null,
@@ -688,6 +353,7 @@ function parseOptions(arguments_, allowed) {
         integrated_revision: null,
         fetch_remote: null,
         fetch_branch: null,
+        preview: false,
     };
     let dryRun = false;
     for (let index = 0; index < arguments_.length; index += 1) {
@@ -699,9 +365,11 @@ function parseOptions(arguments_, allowed) {
             name === "--dry-run" ||
             name === "--force" ||
             name === "--create-upstream" ||
+            name === "--all-claimed" ||
             name === "--all" ||
             name === "--history" ||
-            name === "--patch") {
+            name === "--patch" ||
+            name === "--preview") {
             if (inlineValue !== null) {
                 return failure(usageError("INVALID_ARGUMENT", `${name} does not accept a value.`, { option: name }));
             }
@@ -713,12 +381,16 @@ function parseOptions(arguments_, allowed) {
                 options.force = true;
             else if (name === "--create-upstream")
                 options.create_upstream = true;
+            else if (name === "--all-claimed")
+                options.all_claimed = true;
             else if (name === "--all")
                 options.all = true;
             else if (name === "--history")
                 options.history = true;
-            else
+            else if (name === "--patch")
                 options.patch = true;
+            else
+                options.preview = true;
             continue;
         }
         const value = inlineValue ?? arguments_[index + 1];
@@ -895,7 +567,7 @@ function parseReleaseSelection(arguments_) {
         expected_claim_set_generation: null,
         force: false,
     };
-    const recognized = new Set(["--session", "--resource", "--claim-id", "--all", ...CLAIM_CONCURRENCY_OPTION_NAMES]);
+    const recognized = dispatcherAllowedOptions("session release");
     const targetArguments = positional.value.arguments;
     for (let index = 0; index < targetArguments.length; index += 1) {
         const { name, inlineValue } = optionParts(targetArguments[index]);
@@ -985,14 +657,7 @@ function parseClaimDeltaMutation(arguments_) {
         expected_claim_set_generation: null,
         force: false,
     };
-    const recognized = new Set([
-        "--session",
-        "--repository",
-        "--upsert-resource",
-        "--mode",
-        "--release-resource",
-        ...CLAIM_CONCURRENCY_OPTION_NAMES,
-    ]);
+    const recognized = dispatcherAllowedOptions("session mutate");
     const rejectPending = (name) => failure(usageError("INVALID_ARGUMENT", `${name} cannot appear between --upsert-resource and its --mode; only --mode is permitted immediately after --upsert-resource.`, { option: name }));
     const targetArguments = positional.value.arguments;
     for (let index = 0; index < targetArguments.length; index += 1) {
@@ -1086,7 +751,7 @@ function parseClaimDeltaMutation(arguments_) {
  * constrains its public projection to exactly one upsert pair.
  */
 function parseClaimTransition(arguments_) {
-    const parsed = parseClaimReplacementPairs(arguments_);
+    const parsed = parseClaimReplacementPairs(arguments_, true, "session transition");
     if (!parsed.ok)
         return parsed;
     if (parsed.value.pairs.length !== 1) {
@@ -1121,7 +786,7 @@ function parseClaimTransition(arguments_) {
  * parallel-array position, so argv order can never associate a resource
  * with the wrong mode.
  */
-function parseClaimReplacementPairs(arguments_, requireConcurrencyIntent = true) {
+function parseClaimReplacementPairs(arguments_, requireConcurrencyIntent = true, command = "session update") {
     const positional = splitPositionalSessionTarget(arguments_);
     if (!positional.ok)
         return positional;
@@ -1135,14 +800,11 @@ function parseClaimReplacementPairs(arguments_, requireConcurrencyIntent = true)
     };
     sessionId = positional.value.sessionId;
     const targetArguments = positional.value.arguments;
+    const recognized = dispatcherAllowedOptions(command);
     for (let index = 0; index < targetArguments.length; index += 1) {
         const { name, inlineValue } = optionParts(targetArguments[index]);
         const isConcurrencyOption = isClaimConcurrencyOption(name);
-        if (name !== "--session" &&
-            name !== "--repository" &&
-            name !== "--resource" &&
-            name !== "--mode" &&
-            !(requireConcurrencyIntent && isConcurrencyOption)) {
+        if (!recognized.has(name) || (!requireConcurrencyIntent && isConcurrencyOption)) {
             return failure(usageError("INVALID_ARGUMENT", `Unknown option: ${name}.`, { option: name }));
         }
         if (pendingResource !== null && name !== "--mode") {
@@ -1210,7 +872,7 @@ function parseClaimReplacementPairs(arguments_, requireConcurrencyIntent = true)
  * first pair (last-wins).
  */
 function parseSingleClaimPair(arguments_) {
-    const parsed = parseClaimReplacementPairs(arguments_, false);
+    const parsed = parseClaimReplacementPairs(arguments_, false, "session claim");
     if (!parsed.ok)
         return parsed;
     if (parsed.value.pairs.length > 1) {
@@ -1333,6 +995,39 @@ async function executeRelease(arguments_, backend, context, operation) {
     const result = await backend.releaseClaims(context, options);
     return result.ok ? { ok: true, value: result.value } : result;
 }
+/**
+ * The one dispatcher boundary for protected managed execution.
+ *
+ * The public registry owns the command identity (including aliases); this
+ * function owns only the routing contract.  Resolution is always enforced
+ * and the resolved request is handed to the #145 launcher.  In particular,
+ * there is no ambient child-process path to select when resolution or launch
+ * fails.
+ */
+async function executeProtectedSessionCommand(arguments_, dependencies, context) {
+    const delimiter = arguments_.indexOf("--");
+    if (delimiter === -1) {
+        return failure(usageError("MISSING_ARGUMENT", "session run requires a -- terminator before the command."));
+    }
+    const parsed = parseOptions(arguments_.slice(0, delimiter), new Set(["--session"]));
+    if (!parsed.ok)
+        return parsed;
+    const command = arguments_[delimiter + 1];
+    if (command === undefined || command.length === 0) {
+        return failure(usageError("MISSING_ARGUMENT", "session run requires a command after --."));
+    }
+    const request = await resolveSandboxExecutionRequest(dependencies.backend, context, { session_id: parsed.value.session_id, enforce: true }, dependencies.sandboxProbe, dependencies.sandboxRuntimeLayout);
+    if (!request.ok)
+        return request;
+    // `sandboxRunner` is an injection seam for unit tests. Production always
+    // reaches the canonical protected launcher exported by #145.
+    const runner = dependencies.sandboxRunner ?? runSandboxedCommand;
+    const result = await runner(request.value, {
+        command,
+        args: arguments_.slice(delimiter + 2),
+    });
+    return result.ok ? { ok: true, value: result.value } : result;
+}
 async function executeCommand(commandArguments, dependencies) {
     const [command, subcommand, ...rest] = commandArguments;
     const context = sessionContext(dependencies.cwd);
@@ -1340,6 +1035,12 @@ async function executeCommand(commandArguments, dependencies) {
         if (subcommand === undefined) {
             return failure(usageError("MISSING_ARGUMENT", "session requires a subcommand."));
         }
+        // Resolve the subcommand through the canonical registry before dispatch.
+        // This keeps `session exec` an alias of the same protected route instead
+        // of creating a second launch path.
+        if (canonicalCommandForName(`session ${subcommand}`)?.name === "session run") {
+            return executeProtectedSessionCommand(rest, dependencies, context);
+        }
         if (subcommand === "claim") {
             const parsed = parseSingleClaimPair(rest);
             if (!parsed.ok)
@@ -1380,7 +1081,7 @@ async function executeCommand(commandArguments, dependencies) {
             return executeClaimTransition(rest, dependencies.backend, context, "session transition");
         }
         if (subcommand === "claims") {
-            const parsed = parseTargetedOptions(rest, new Set(["--session"]));
+            const parsed = parseTargetedOptions(rest, dispatcherAllowedOptions("session claims"));
             if (!parsed.ok)
                 return parsed;
             if (dependencies.backend.listClaims === undefined)
@@ -1392,7 +1093,7 @@ async function executeCommand(commandArguments, dependencies) {
             return executeRelease(rest, dependencies.backend, context, "session release");
         }
         if (subcommand === "create") {
-            const parsed = parseOptions(rest, new Set(["--branch", "--worktree", "--worktree-root", "--base", "--label"]));
+            const parsed = parseOptions(rest, dispatcherAllowedOptions("session create"));
             if (!parsed.ok)
                 return parsed;
             if (parsed.value.worktree !== null && parsed.value.worktree_root !== null) {
@@ -1408,30 +1109,8 @@ async function executeCommand(commandArguments, dependencies) {
             const result = await dependencies.backend.createSession(context, options);
             return result.ok ? { ok: true, value: result.value } : result;
         }
-        if (subcommand === "run" || subcommand === "exec") {
-            const delimiter = rest.indexOf("--");
-            if (delimiter === -1) {
-                return failure(usageError("MISSING_ARGUMENT", "session run requires a -- terminator before the command."));
-            }
-            const parsed = parseOptions(rest.slice(0, delimiter), new Set(["--session"]));
-            if (!parsed.ok)
-                return parsed;
-            const command = rest[delimiter + 1];
-            if (command === undefined || command.length === 0) {
-                return failure(usageError("MISSING_ARGUMENT", "session run requires a command after --."));
-            }
-            const request = await resolveSandboxExecutionRequest(dependencies.backend, context, { session_id: parsed.value.session_id, enforce: true }, dependencies.sandboxProbe, dependencies.sandboxRuntimeLayout);
-            if (!request.ok)
-                return request;
-            const runner = dependencies.sandboxRunner ?? runSandboxedCommand;
-            const result = await runner(request.value, {
-                command,
-                args: rest.slice(delimiter + 2),
-            });
-            return result.ok ? { ok: true, value: result.value } : result;
-        }
         if (subcommand === "inspect") {
-            const parsed = parseTargetedOptions(rest, new Set(["--session", "--integrated-revision"]));
+            const parsed = parseTargetedOptions(rest, dispatcherAllowedOptions("session inspect"));
             if (!parsed.ok)
                 return parsed;
             if (dependencies.backend.sessionDiagnostic === undefined)
@@ -1444,9 +1123,15 @@ async function executeCommand(commandArguments, dependencies) {
             return result.ok ? { ok: true, value: result.value } : result;
         }
         if (subcommand === "discard") {
-            const parsed = parseTargetedOptions(rest, new Set(["--session"]), true);
+            const parsed = parseTargetedOptions(rest, dispatcherAllowedOptions("session discard"), true);
             if (!parsed.ok)
                 return parsed;
+            if (parsed.value.preview) {
+                if (dependencies.backend.discardPreview === undefined)
+                    return sessionDiscardPreviewCapabilityUnavailable();
+                const preview = await dependencies.backend.discardPreview(context, parsed.value.session_id);
+                return preview.ok ? { ok: true, value: preview.value } : preview;
+            }
             if (dependencies.backend.discardSession === undefined)
                 return sessionDiscardCapabilityUnavailable();
             const result = await dependencies.backend.discardSession(context, parsed.value.session_id);
@@ -1462,9 +1147,7 @@ async function executeCommand(commandArguments, dependencies) {
                     return selected;
                 return { ok: true, value: { session_id: selected.value.session_id } };
             }
-            const parsed = parseTargetedOptions(rest, new Set(subcommand === "close"
-                ? ["--session", "--integrated-revision", "--fetch-remote", "--fetch-branch"]
-                : ["--session"]));
+            const parsed = parseTargetedOptions(rest, dispatcherAllowedOptions(subcommand === "close" ? "session close" : "session show"));
             if (!parsed.ok)
                 return parsed;
             if (subcommand === "close") {
@@ -1491,7 +1174,7 @@ async function executeCommand(commandArguments, dependencies) {
             return selected.ok ? { ok: true, value: selected.value } : selected;
         }
         if (subcommand === "list") {
-            const parsed = parseOptions(rest, new Set(["--all", "--history", "--limit", "--offset"]));
+            const parsed = parseOptions(rest, dispatcherAllowedOptions("session list"));
             if (!parsed.ok)
                 return parsed;
             const options = sessionListingOptions(parsed.value);
@@ -1544,7 +1227,7 @@ async function executeCommand(commandArguments, dependencies) {
             return executeClaimTransition(rest, dependencies.backend, context, "resource transition");
         }
         if (resourceSubcommand === "list" || resourceSubcommand === "claims") {
-            const parsed = parseTargetedOptions(rest, new Set(["--session"]));
+            const parsed = parseTargetedOptions(rest, dispatcherAllowedOptions("session claims"));
             if (!parsed.ok)
                 return parsed;
             if (dependencies.backend.listClaims === undefined)
@@ -1560,7 +1243,7 @@ async function executeCommand(commandArguments, dependencies) {
         }));
     }
     if (command === "authorize") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session", "--operation", "--resource"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("authorize"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.operation === null) {
@@ -1584,7 +1267,7 @@ async function executeCommand(commandArguments, dependencies) {
             : deniedAuthorization(result.value);
     }
     if (command === "checkpoint") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("checkpoint"));
         if (!parsed.ok)
             return parsed;
         if (dependencies.backend.checkpoint === undefined)
@@ -1594,7 +1277,7 @@ async function executeCommand(commandArguments, dependencies) {
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "evidence" && subcommand === "snapshot") {
-        const parsed = parseOptions(rest, new Set(["--session"]));
+        const parsed = parseOptions(rest, dispatcherAllowedOptions("evidence snapshot"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.session_id === null) {
@@ -1608,7 +1291,7 @@ async function executeCommand(commandArguments, dependencies) {
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "diff") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session", "--path", "--from", "--to", "--patch", "--max-bytes", "--max-hunks"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("diff"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.session_id === null) {
@@ -1645,13 +1328,18 @@ async function executeCommand(commandArguments, dependencies) {
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "commit") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session", "--message", "--resource", "--message-pattern"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("commit"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.message === null) {
             return failure(usageError("MISSING_ARGUMENT", "--message requires a value.", { option: "--message" }));
         }
-        if (parsed.value.resources.length === 0) {
+        if (parsed.value.all_claimed && parsed.value.resources.length > 0) {
+            return failure(usageError("INVALID_ARGUMENT", "--resource and --all-claimed cannot be used together.", {
+                options: ["--resource", "--all-claimed"],
+            }));
+        }
+        if (!parsed.value.all_claimed && parsed.value.resources.length === 0) {
             return failure(usageError("MISSING_ARGUMENT", "--resource requires a value.", { option: "--resource" }));
         }
         if (dependencies.backend.commit === undefined)
@@ -1660,12 +1348,13 @@ async function executeCommand(commandArguments, dependencies) {
             session_id: parsed.value.session_id,
             message: parsed.value.message,
             resources: parsed.value.resources,
+            ...(parsed.value.all_claimed ? { all_claimed: true } : {}),
             message_pattern: parsed.value.message_pattern,
         });
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "push") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session", "--resource", "--remote", "--branch", "--remote-branch", "--force", "--create-upstream"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("push"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.remote === null) {
@@ -1679,7 +1368,12 @@ async function executeCommand(commandArguments, dependencies) {
             parsed.value.branch !== parsed.value.remote_branch) {
             return failure(usageError("INVALID_ARGUMENT", "--branch and --remote-branch must identify the same target."));
         }
-        if (parsed.value.resources.length === 0) {
+        if (parsed.value.all_claimed && parsed.value.resources.length > 0) {
+            return failure(usageError("INVALID_ARGUMENT", "--resource and --all-claimed cannot be used together.", {
+                options: ["--resource", "--all-claimed"],
+            }));
+        }
+        if (!parsed.value.all_claimed && parsed.value.resources.length === 0) {
             return failure(usageError("MISSING_ARGUMENT", "--resource requires a value.", { option: "--resource" }));
         }
         if (dependencies.backend.push === undefined)
@@ -1687,6 +1381,7 @@ async function executeCommand(commandArguments, dependencies) {
         const result = await dependencies.backend.push(context, {
             session_id: parsed.value.session_id,
             resources: parsed.value.resources,
+            ...(parsed.value.all_claimed ? { all_claimed: true } : {}),
             remote: parsed.value.remote,
             branch: parsed.value.branch ?? parsed.value.remote_branch,
             force: parsed.value.force,
@@ -1695,7 +1390,7 @@ async function executeCommand(commandArguments, dependencies) {
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "status") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--all", "--history", "--limit", "--offset"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("status"));
         if (!parsed.ok)
             return parsed;
         const options = sessionListingOptions(parsed.value);
@@ -1705,7 +1400,7 @@ async function executeCommand(commandArguments, dependencies) {
         return result.ok ? { ok: true, value: result.value } : result;
     }
     if (command === "guard") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--session", "--operation", "--resource"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("guard"));
         if (!parsed.ok)
             return parsed;
         if (parsed.value.resources.length > 0 && parsed.value.operation === null) {
@@ -1749,7 +1444,7 @@ async function executeCommand(commandArguments, dependencies) {
         }));
     }
     if (command === "gc") {
-        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), new Set(["--apply", "--dry-run"]));
+        const parsed = parseOptions([subcommand, ...rest].filter((argument) => argument !== undefined), dispatcherAllowedOptions("gc"));
         if (!parsed.ok)
             return parsed;
         const options = { apply: parsed.value.apply };
@@ -1760,7 +1455,7 @@ async function executeCommand(commandArguments, dependencies) {
         const parsed = noOptions([subcommand, ...rest].filter((argument) => argument !== undefined));
         if (!parsed.ok)
             return parsed;
-        const report = await runDoctor(dependencies.cwd);
+        const report = await runDoctor(dependencies.cwd, dependencies.sandboxProbe);
         if (!report.ok)
             return report;
         if (report.value.ok)
@@ -1768,8 +1463,18 @@ async function executeCommand(commandArguments, dependencies) {
         return failure(new DomainError("DOCTOR_FAILED", "One or more local Nawabari checks failed.", {
             checks: report.value.checks,
             repository: report.value.repository,
+            sandbox: report.value.sandbox,
         }));
     }
+    if (command === "migrate") {
+        const parsed = noOptions([subcommand, ...rest].filter((argument) => argument !== undefined));
+        if (!parsed.ok)
+            return parsed;
+        if (dependencies.backend.migrate === undefined)
+            return migrationCapabilityUnavailable();
+        const result = await dependencies.backend.migrate(context);
+        return result.ok ? { ok: true, value: result.value } : result;
+    }
     if (command === undefined)
         return failure(new DomainError("NO_COMMAND", "A command is required."));
     return failure(new DomainError("UNKNOWN_COMMAND", `Unknown command: ${command}.`, { command }));
@@ -1777,8 +1482,9 @@ async function executeCommand(commandArguments, dependencies) {
 function commandName(commandArguments) {
     if (commandArguments[0] === "session")
         return commandArguments.slice(0, 2).join(" ");
-    if (commandArguments[0] === "resource")
-        return commandArguments.slice(0, 2).join(" ");
+    if (commandArguments[0] === "resource") {
+        return commandArguments[1] === undefined ? "resource list" : commandArguments.slice(0, 2).join(" ");
+    }
     if (commandArguments[0] === "evidence")
         return commandArguments.slice(0, 2).join(" ");
     return commandArguments[0] ?? "cli";
@@ -1786,6 +1492,11 @@ function commandName(commandArguments) {
 function claimCapabilityUnavailable(operation) {
     return failure(new DomainError("BACKEND_UNAVAILABLE", "Resource claim capability is not available.", { operation }));
 }
+function migrationCapabilityUnavailable() {
+    return failure(new DomainError("BACKEND_UNAVAILABLE", "Registry migration capability is not available.", {
+        operation: "migrate",
+    }));
+}
 function authorizationCapabilityUnavailable() {
     return failure(new DomainError("BACKEND_UNAVAILABLE", "Operation authorization capability is not available.", {
         operation: "authorize",
@@ -1806,6 +1517,11 @@ function sessionDiscardCapabilityUnavailable() {
         operation: "session.discard",
     }));
 }
+function sessionDiscardPreviewCapabilityUnavailable() {
+    return failure(new DomainError("BACKEND_UNAVAILABLE", "Session discard preview capability is not available.", {
+        operation: "session.discard.preview",
+    }));
+}
 function repositoryEvidenceCapabilityUnavailable(operation) {
     return failure(new DomainError("BACKEND_UNAVAILABLE", "Repository evidence capability is not available.", { operation }));
 }
@@ -1948,12 +1664,15 @@ export async function runCli(argv, dependencies = {}) {
             const enriched = await enrichInvalidSessionIdError(result.error, backend, sessionContext(cwd));
             return emitFailure(mode, command, enriched, io);
         }
+        const childExitCode = result.value.exit_code;
+        const childSignal = result.value.signal;
         io.stdout(renderSuccess(mode, command, result.value));
         if ((command === "session run" || command === "session exec") &&
-            typeof result.value.exit_code === "number" &&
-            result.value.exit_code !== 0) {
-            return result.value.exit_code >= 1 && result.value.exit_code <= 255
-                ? result.value.exit_code
+            (childSignal !== null || (typeof childExitCode === "number" && childExitCode !== 0))) {
+            if (childSignal !== null)
+                return EXIT_CODES.rejected;
+            return typeof childExitCode === "number" && childExitCode >= 1 && childExitCode <= 255
+                ? childExitCode
                 : EXIT_CODES.rejected;
         }
         return EXIT_CODES.success;