@tiangong-lca/cli 0.0.25 → 0.0.27

package/README.md

@@ -18,7 +18,7 @@ checkPaths:
   - src/cli.ts
   - src/main.ts
 lastReviewedAt: 2026-07-15
-lastReviewedCommit: ca0cdd7549cad9003d08fb338223ba74682955ae
+lastReviewedCommit: bd145f692b3fd11e398302dd6a1d2831e058883a
 ---
 
 # TianGong LCA CLI
@@ -33,6 +33,8 @@ Review note, 2026-07-14: maintenance now includes the protected derivative-only
 
 Review note, 2026-07-15: `dataset maintenance run-protected` adds a production-only path for one sealed private alias execution and its exact 50-target derivative closure. The protected executor is server-dispatched and fenced by the authenticated owner plus exact actor/user_id/state_code=0 and plan-closure checks; RLS remains a defense on public and independent-read surfaces. It performs one server preflight, writes an immutable local attempt marker before one admission POST, and requires status-only recovery after any marker or ambiguous response. It has no dev, legacy-alias, publication, or state-code fallback.
 
+Review note, 2026-07-15: `dataset maintenance freeze-protected` and `seal-protected-approval` close the preparation gap without adding a second execution path. Freeze preparation authenticates directly to the explicitly confirmed production project, performs only complete account/support reads plus the 50 derivative snapshot RPCs, and writes an unapproved canonical request. Approval sealing is entirely local and requires the exact human-returned UTF-8 bytes plus explicit freeze/request/text hashes and account confirmation. Only the later `run-protected` command can preflight or admit work.
+
 ## Run
 
 One-off published run:
@@ -285,7 +287,7 @@ tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operati
 tiangong-lca dataset maintenance plan --scope ./derivative-rebuild-scope.json --operation rebuild-derivatives --out-dir /abs/path/to/derivative-rebuild --json
 tiangong-lca dataset maintenance apply --plan /abs/path/to/dataset-maintenance/maintenance-plan.json --commit --approve-plan <sha256> --confirm <current-account-email> --timeout-ms 10000 --json
 tiangong-lca dataset maintenance verify --plan /abs/path/to/dataset-maintenance/maintenance-plan.json --out-dir /abs/path/to/dataset-maintenance/verify --page-size 1000 --timeout-ms 10000 --json
-tiangong-lca dataset maintenance run-protected --plan /abs/path/to/maintenance-plan.json --freeze /abs/path/to/protected-execution-seal.json --approval /abs/path/to/protected-approval.json --out-dir /abs/path/to/protected-run --status-only --json
+tiangong-lca dataset maintenance run-protected --plan /abs/path/to/maintenance-plan.json --freeze /abs/path/to/protected-execution-freeze.json --approval /abs/path/to/protected-approval.json --out-dir /abs/path/to/protected-run --status-only --json
 tiangong-lca lifecyclemodel auto-build --input ./examples/lifecyclemodel-auto-build.request.json --out-dir /abs/path/to/lifecyclemodel-run --json
 tiangong-lca lifecyclemodel validate-build --run-dir /abs/path/to/lifecyclemodel-run --json
 tiangong-lca lifecyclemodel publish-build --run-dir /abs/path/to/lifecyclemodel-run --json
@@ -330,7 +332,7 @@ For `dataset references rewrite`, `--commit` executes the state-aware save-draft
 
 ## Dataset Maintenance
 
-`dataset maintenance plan/apply/run-protected/verify` is the row-level cleanup surface for bad imports, the fixed BAFU private alias rewrite, and protected derivative rebuilds. Ordinary planning, apply, and independent verification use the authenticated account and RLS. The protected executor is server-dispatched and additionally enforces the sealed actor, user_id, state_code=0, exact target set, and closure hashes on every write.
+`dataset maintenance plan/apply/freeze-protected/seal-protected-approval/run-protected/verify` is the row-level cleanup surface for bad imports, the fixed BAFU private alias rewrite, and protected derivative rebuilds. Ordinary planning, apply, and independent verification use the authenticated account and RLS. Protected freeze preparation reads the live production owner-draft scope directly with no Dev data replay, while approval sealing is offline. The protected executor is server-dispatched and additionally enforces the sealed actor, user_id, state_code=0, exact target set, and closure hashes on every write.
 
 ```bash
 tiangong-lca dataset maintenance plan \
@@ -356,10 +358,33 @@ tiangong-lca dataset maintenance verify \
   --timeout-ms 10000 \
   --json
 
+tiangong-lca dataset maintenance freeze-protected \
+  --plan ./protected-step2/maintenance-plan.json \
+  --toolchain-evidence ./protected-step2/toolchain-evidence.json \
+  --expected-project-ref <production-project-ref> \
+  --confirm <current-account-email> \
+  --out-dir ./protected-step2/freeze \
+  --page-size 1000 \
+  --timeout-ms 10000 \
+  --json
+
+# After a human returns protected-approval-request.txt byte-for-byte as human-approval.txt:
+tiangong-lca dataset maintenance seal-protected-approval \
+  --freeze ./protected-step2/freeze/protected-execution-freeze.json \
+  --approval-request ./protected-step2/freeze/protected-approval-request.json \
+  --human-approval ./protected-step2/human-approval.txt \
+  --approve-freeze-file <freeze-file-sha256> \
+  --approve-request <approval-request-sha256> \
+  --approve-text <approval-text-sha256> \
+  --confirm <current-account-email> \
+  --approved-at <approved-at-utc-from-request> \
+  --out-dir ./protected-step2/approval \
+  --json
+
 tiangong-lca dataset maintenance run-protected \
   --plan ./protected-step2/maintenance-plan.json \
-  --freeze ./protected-step2/protected-execution-seal.json \
-  --approval ./protected-step2/protected-approval.json \
+  --freeze ./protected-step2/freeze/protected-execution-freeze.json \
+  --approval ./protected-step2/approval/protected-approval.json \
   --out-dir ./protected-step2/run \
   --commit \
   --approve-execution <approved-execution-sha256> \
@@ -372,15 +397,19 @@ tiangong-lca dataset maintenance run-protected \
 
 tiangong-lca dataset maintenance run-protected \
   --plan ./protected-step2/maintenance-plan.json \
-  --freeze ./protected-step2/protected-execution-seal.json \
-  --approval ./protected-step2/protected-approval.json \
+  --freeze ./protected-step2/freeze/protected-execution-freeze.json \
+  --approval ./protected-step2/approval/protected-approval.json \
   --out-dir ./protected-step2/run \
   --status-only \
   --wait-seconds 60 \
   --json
 ```
 
-`run-protected` is a separate one-shot path for an already reviewed and sealed production execution; it does not replace ordinary planning. Both modes require the exact plan, freeze/seal, approval artifact, and private output directory. Commit mode additionally requires `--commit`, the exact approved execution identity through `--approve-execution`, and the authenticated account email through `--confirm`. `--status-only` is mutually exclusive with `--commit` and performs no preflight or admission.
+`run-protected` is a separate one-shot path for an already reviewed and sealed production execution; it does not replace ordinary planning. Both modes require the exact plan, freeze artifact, approval artifact, and private output directory. Commit mode additionally requires `--commit`, the exact approved execution identity through `--approve-execution`, and the authenticated account email through `--confirm`. `--status-only` is mutually exclusive with `--commit` and performs no preflight or admission.
+
+`freeze-protected` is the only supported generator for this fixed protected profile. Its toolchain evidence must be canonical JSON with schema `dataset-alias-protected-toolchain-evidence.v1`, production project ref, released-and-read-back database commit/evidence, the currently running published CLI version/commit/evidence, and the merged root-workspace integration commit/Issue. The fixed BAFU profile also has a compiled production project allowlist; the CLI rejects a Dev or arbitrary project even if the operator supplies matching flag/evidence values. The command verifies the exact 52 actions, two batches, six support snapshots, projected reference closure, and stable 23-flow + 27-process derivative snapshots; every derivative snapshot must have the same primary-row `modified_at` as the immediately preceding complete account census. It writes the entire private immutable alias-request, full baseline, freeze, unapproved request JSON/TXT, and final report into a sibling staging directory and atomically exposes the new output directory only after every file succeeds; preflight, gate, admission, mutation, and approval-artifact counts are all zero.
+
+`seal-protected-approval` receives no environment or HTTP client. The freeze command puts one canonical approval-authority `approved_at_utc` into the request JSON, request hash, and human-visible approval text before review; seal requires `--approved-at` to equal that already approved value. The same text therefore cannot be resealed with another timestamp to mint a second database admission identity. The seal report records its actual generation time separately from this pre-authorized identity timestamp. Both commands hash raw file bytes, reject invalid UTF-8, publish their completed output directories atomically, and reject non-canonical freeze/request files, any changed whitespace or final newline, mismatched explicit hash/account/time bindings, and all three superseded historical Step-2 plan identities. Commit-mode `run-protected` rejects the same historical identities, so an old freeze/approval cannot bypass the fresh preparation chain; status-only remains read-only and available for recovery. Seal writes the canonical approval plus a local report, but does not submit execution. Human approval, sealing, and later execution remain separate events.
 
 Before requesting preflight, the command validates the sealed production project, full current-user RLS before-state, support closure, and exact derivative baseline. The server then returns the three expected gate digests and a token valid for at most 180 seconds; the CLI captures and compares the live gate receipts before admission. The server-dispatched write remains fenced to the authenticated actor's exact `user_id`, `state_code=0` rows and sealed plan/closure; independent readback still uses RLS. The CLI writes an immutable local submission marker and sends at most one admission POST. A marker, admission timeout, connection loss, or ambiguous admission response permanently switches that local run to status-only recovery; status-read failures may be polled only within the configured wait window and never cause a second admission or fallback to dev or the legacy whole-plan RPC. The default status polling interval is 10 seconds.
 

package/dist/src/cli.js

@@ -56,7 +56,9 @@ import { runDatasetClassificationApply, runDatasetClassificationAudit, runDatase
 import { runDatasetMaintenanceClearAccount, } from './lib/dataset-maintenance-clear-account.js';
 import { runDatasetMaintenancePlan } from './lib/dataset-maintenance-plan.js';
 import { runDatasetMaintenanceApply } from './lib/dataset-maintenance-apply.js';
+import { freezeDatasetMaintenanceProtected } from './lib/dataset-maintenance-protected-freeze.js';
 import { runDatasetMaintenanceProtected } from './lib/dataset-maintenance-protected-run.js';
+import { sealDatasetMaintenanceProtectedApproval } from './lib/dataset-maintenance-protected-seal.js';
 import { runDatasetMaintenanceVerify } from './lib/dataset-maintenance-verify.js';
 import { runDatasetSourceUploadAttachments, } from './lib/dataset-source-upload-attachments.js';
 function renderMainHelp(dotEnvStatus) {
@@ -132,6 +134,7 @@ Examples:
   tiangong-lca dataset references rewrite --input ./rows.jsonl --from flow:<old-id>@<old-version> --to flow:<new-id>@<new-version> --out-dir /abs/path/to/dataset-rewrite
   tiangong-lca dataset maintenance clear-account --out-dir /abs/path/to/account-clear --json
   tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operation merge-support-aliases --out-dir /abs/path/to/dataset-maintenance
+  tiangong-lca dataset maintenance freeze-protected --plan ./maintenance-plan.json --toolchain-evidence ./toolchain.json --expected-project-ref <production-ref> --confirm bafudata@126.com --out-dir /abs/path/to/protected-freeze
   tiangong-lca dataset maintenance run-protected --plan ./maintenance-plan.json --freeze ./protected-execution-seal.json --approval ./protected-approval.json --out-dir /abs/path/to/protected-run --status-only
   tiangong-lca lifecyclemodel auto-build --input ./lifecyclemodel-auto-build.request.json --out-dir /abs/path/to/lifecyclemodel-run
   tiangong-lca lifecyclemodel validate-build --run-dir /abs/path/to/lifecyclemodel-run
@@ -285,6 +288,8 @@ Implemented Subcommands:
   maintenance clear-account Dry-run or clear current authenticated account-owned dataset rows through RLS
   maintenance plan    Build an immutable, RLS-visible row-level maintenance plan
   maintenance apply   Execute an explicitly approved maintenance plan through current-user RLS
+  maintenance freeze-protected Read and freeze one exact production owner-draft plan without admitting or mutating it
+  maintenance seal-protected-approval Record byte-exact human approval entirely offline
   maintenance run-protected Run or inspect one sealed, one-shot production maintenance execution
   maintenance verify  Read back affected rows and references against the immutable plan
 
@@ -313,24 +318,30 @@ Examples:
   tiangong-lca dataset references refresh-remote --input ./rows.jsonl --out ./rows.refreshed.jsonl --out-dir ./dataset-reference-refresh --help
   tiangong-lca dataset maintenance clear-account --out-dir ./account-clear --json --help
   tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operation merge-support-aliases --out-dir ./dataset-maintenance --help
+  tiangong-lca dataset maintenance freeze-protected --help
+  tiangong-lca dataset maintenance seal-protected-approval --help
   tiangong-lca dataset maintenance run-protected --help
 `.trim();
 }
 function renderDatasetMaintenanceHelp() {
     return `Usage:
-  tiangong-lca dataset maintenance <clear-account|plan|apply|run-protected|verify> [options]
+  tiangong-lca dataset maintenance <clear-account|plan|apply|freeze-protected|seal-protected-approval|run-protected|verify> [options]
 
 Actions:
   clear-account Dry-run or delete current authenticated account-owned lifecyclemodels, processes, flows, sources, and contacts.
   plan    Build an immutable maintenance plan from a scope manifest, visible remote snapshot, dependency impact report, and intended operation.
   apply   Execute or durably admit an ordinary approved plan through current-user RLS and platform dataset command paths.
+  freeze-protected Re-read the exact production owner-draft census/support/50 derivatives and generate an unapproved freeze request.
+  seal-protected-approval Record a byte-exact human response into an approval artifact with no authentication or network access.
   run-protected Run or inspect one sealed production execution with one-shot admission and terminal derivative proof.
   verify  Re-fetch rows, references, or derivative request state and report passed, pending, or failed independently of apply.
 
 Safety:
-  plan and verify are read-only.
+  plan, verify, and freeze-protected are read-only; seal-protected-approval is local-only.
   apply is commit-only and requires --commit, the exact plan SHA-256 via --approve-plan, and the current account email via --confirm.
   A sealed production merge-support-aliases execution must use run-protected; apply is not its fallback.
+  freeze-protected is production-only and never calls preflight, gate, admission, execution, or mutation RPCs.
+  seal-protected-approval only records the exact human-approved bytes; it never authenticates, connects, or submits execution.
   run-protected is production-only: authenticated owner context plus server-side actor/user_id/state_code=0 and exact-plan closure fences protect writes; RLS remains a defense on public and independent-read surfaces. It never falls back to dev, a legacy alias RPC, or a second admission POST.
 
 Required Artifact Contract:
@@ -349,6 +360,8 @@ Examples:
   tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operation repair-references --out-dir ./dataset-maintenance
   tiangong-lca dataset maintenance plan --scope ./derivative-rebuild-scope.json --operation rebuild-derivatives --out-dir ./derivative-rebuild
   tiangong-lca dataset maintenance apply --plan ./dataset-maintenance/maintenance-plan.json --commit --approve-plan <sha256> --confirm user@example.com
+  tiangong-lca dataset maintenance freeze-protected --plan ./maintenance-plan.json --toolchain-evidence ./toolchain.json --expected-project-ref <production-ref> --confirm bafudata@126.com --out-dir ./protected-freeze
+  tiangong-lca dataset maintenance seal-protected-approval --freeze ./protected-freeze/protected-execution-freeze.json --approval-request ./protected-freeze/protected-approval-request.json --human-approval ./human-approval.txt --approve-freeze-file <sha256> --approve-request <sha256> --approve-text <sha256> --confirm bafudata@126.com --approved-at <iso> --out-dir ./protected-approval
   tiangong-lca dataset maintenance run-protected --plan ./maintenance-plan.json --freeze ./protected-execution-seal.json --approval ./protected-approval.json --out-dir ./protected-run --status-only
   tiangong-lca dataset maintenance verify --plan ./dataset-maintenance/maintenance-plan.json --out-dir ./dataset-maintenance/verify
 `.trim();
@@ -396,6 +409,63 @@ Options:
 Outputs include approval-record.json and commit-report.json alongside an append-only action or admission ledger.
 `.trim();
 }
+function renderDatasetMaintenanceFreezeProtectedHelp() {
+    return `Usage:
+  tiangong-lca dataset maintenance freeze-protected --plan <file> --toolchain-evidence <file> --expected-project-ref <ref> --confirm <email> --out-dir <dir> [options]
+
+Behavior:
+  Authenticates directly to the explicitly confirmed production project and re-reads the complete
+  owner-draft account census, six support snapshots, projected reference closure, and the stable
+  23-flow + 27-process derivative snapshot set. It writes a canonical protected freeze and an
+  unapproved byte-exact human approval request. It never emits an approval artifact.
+
+Required:
+  --plan <file>                 Ready owner-draft merge-support-aliases maintenance plan
+  --toolchain-evidence <file>   Canonical released DB/CLI/root-integration evidence
+  --expected-project-ref <ref>  Explicit production Supabase project ref
+  --confirm <email>             Exact authenticated owner email
+  --out-dir <dir>               New private immutable artifact directory
+
+Options:
+  --page-size <n>               Complete account scan page size, 1-5000
+  --timeout-ms <n>              Positive authentication/read timeout in milliseconds
+  --json                        Print compact JSON
+  -h, --help
+
+Remote safety:
+  This command uses only authenticated table reads and cmd_dataset_derivative_rebuild_snapshot.
+  Preflight, gate, admission, execution, save-draft, delete, state change, and all mutation calls are zero.
+`.trim();
+}
+function renderDatasetMaintenanceSealProtectedApprovalHelp() {
+    return `Usage:
+  tiangong-lca dataset maintenance seal-protected-approval --freeze <file> --approval-request <file> --human-approval <file> --approve-freeze-file <sha256> --approve-request <sha256> --approve-text <sha256> --confirm <email> --approved-at <iso> --out-dir <dir> [options]
+
+Behavior:
+  Records a human-provided approval text only when every UTF-8 byte, freeze-file hash, request hash,
+  text hash, account, and canonical timestamp matches the unapproved request. It writes the approval
+  artifact needed by a later, separate run-protected command; it does not submit that execution.
+
+Required:
+  --freeze <file>               Canonical protected freeze generated by freeze-protected
+  --approval-request <file>     Canonical unapproved approval request JSON
+  --human-approval <file>       Human-returned text, read byte-for-byte without trimming
+  --approve-freeze-file <sha256> Explicit SHA-256 of the exact freeze file bytes
+  --approve-request <sha256>    Explicit request identity SHA-256
+  --approve-text <sha256>       Explicit byte-exact approval text SHA-256
+  --confirm <email>             Exact frozen account email
+  --approved-at <iso>           Exact approval-authority timestamp already embedded in the request
+  --out-dir <dir>               New private immutable artifact directory
+
+Options:
+  --json                        Print compact JSON
+  -h, --help
+
+Offline safety:
+  This command receives no environment or HTTP client and performs zero authentication, network,
+  database, preflight, gate, admission, execution, or mutation calls.
+`.trim();
+}
 function renderDatasetMaintenanceRunProtectedHelp() {
     return `Usage:
   tiangong-lca dataset maintenance run-protected --plan <file> --freeze <file> --approval <file> --out-dir <dir> --commit --approve-execution <sha256> --confirm <email> [options]
@@ -3188,6 +3258,86 @@ function parseDatasetMaintenanceApplyFlags(args) {
         dryRun: Boolean(values['dry-run']),
     };
 }
+function parseDatasetMaintenanceFreezeProtectedFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                plan: { type: 'string' },
+                'toolchain-evidence': { type: 'string' },
+                'out-dir': { type: 'string' },
+                'expected-project-ref': { type: 'string' },
+                confirm: { type: 'string' },
+                'page-size': { type: 'string' },
+                'timeout-ms': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        planPath: typeof values.plan === 'string' ? values.plan : '',
+        toolchainEvidencePath: typeof values['toolchain-evidence'] === 'string' ? values['toolchain-evidence'] : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        expectedProjectRef: typeof values['expected-project-ref'] === 'string' ? values['expected-project-ref'] : '',
+        confirm: typeof values.confirm === 'string' ? values.confirm : '',
+        pageSize: parseDatasetMaintenancePositiveInteger(values['page-size'], '--page-size'),
+        timeoutMs: parseDatasetMaintenancePositiveInteger(values['timeout-ms'], '--timeout-ms'),
+    };
+}
+function parseDatasetMaintenanceSealProtectedApprovalFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                freeze: { type: 'string' },
+                'approval-request': { type: 'string' },
+                'human-approval': { type: 'string' },
+                'out-dir': { type: 'string' },
+                'approve-freeze-file': { type: 'string' },
+                'approve-request': { type: 'string' },
+                'approve-text': { type: 'string' },
+                confirm: { type: 'string' },
+                'approved-at': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        freezePath: typeof values.freeze === 'string' ? values.freeze : '',
+        approvalRequestPath: typeof values['approval-request'] === 'string' ? values['approval-request'] : '',
+        humanApprovalPath: typeof values['human-approval'] === 'string' ? values['human-approval'] : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        approveFreezeFile: typeof values['approve-freeze-file'] === 'string' ? values['approve-freeze-file'] : '',
+        approveRequest: typeof values['approve-request'] === 'string' ? values['approve-request'] : '',
+        approveText: typeof values['approve-text'] === 'string' ? values['approve-text'] : '',
+        confirm: typeof values.confirm === 'string' ? values.confirm : '',
+        approvedAtUtc: typeof values['approved-at'] === 'string' ? values['approved-at'] : '',
+    };
+}
 function parseDatasetMaintenanceProtectedFlags(args) {
     let values;
     try {
@@ -5015,7 +5165,9 @@ export async function executeCli(argv, deps) {
         const datasetMaintenanceClearAccountImpl = deps.runDatasetMaintenanceClearAccountImpl ?? runDatasetMaintenanceClearAccount;
         const datasetMaintenancePlanImpl = deps.runDatasetMaintenancePlanImpl ?? runDatasetMaintenancePlan;
         const datasetMaintenanceApplyImpl = deps.runDatasetMaintenanceApplyImpl ?? runDatasetMaintenanceApply;
+        const datasetMaintenanceProtectedFreezeImpl = deps.freezeDatasetMaintenanceProtectedImpl ?? freezeDatasetMaintenanceProtected;
         const datasetMaintenanceProtectedImpl = deps.runDatasetMaintenanceProtectedImpl ?? runDatasetMaintenanceProtected;
+        const datasetMaintenanceProtectedApprovalSealImpl = deps.sealDatasetMaintenanceProtectedApprovalImpl ?? sealDatasetMaintenanceProtectedApproval;
         const datasetMaintenanceVerifyImpl = deps.runDatasetMaintenanceVerifyImpl ?? runDatasetMaintenanceVerify;
         const datasetSourceUploadAttachmentsImpl = deps.runDatasetSourceUploadAttachmentsImpl ?? runDatasetSourceUploadAttachments;
         if (flags.version) {
@@ -5728,6 +5880,143 @@ export async function executeCli(argv, deps) {
                     stderr: '',
                 };
             }
+            if (action === 'freeze-protected') {
+                const datasetFlags = parseDatasetMaintenanceFreezeProtectedFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return {
+                        exitCode: 0,
+                        stdout: `${renderDatasetMaintenanceFreezeProtectedHelp()}\n`,
+                        stderr: '',
+                    };
+                }
+                if (!datasetFlags.planPath) {
+                    throw new CliError('dataset maintenance freeze-protected requires --plan.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_PLAN_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.toolchainEvidencePath) {
+                    throw new CliError('dataset maintenance freeze-protected requires --toolchain-evidence.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_TOOLCHAIN_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.expectedProjectRef) {
+                    throw new CliError('dataset maintenance freeze-protected requires --expected-project-ref.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_PROJECT_REF_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.confirm) {
+                    throw new CliError('dataset maintenance freeze-protected requires --confirm.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_CONFIRM_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.outDir) {
+                    throw new CliError('dataset maintenance freeze-protected requires --out-dir.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_OUT_DIR_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                const report = await datasetMaintenanceProtectedFreezeImpl({
+                    planPath: datasetFlags.planPath,
+                    toolchainEvidencePath: datasetFlags.toolchainEvidencePath,
+                    outDir: datasetFlags.outDir,
+                    expectedProjectRef: datasetFlags.expectedProjectRef,
+                    confirm: datasetFlags.confirm,
+                    cliVersion: loadCliPackageVersion(import.meta.url),
+                    pageSize: datasetFlags.pageSize,
+                    timeoutMs: datasetFlags.timeoutMs,
+                    env: deps.env,
+                    fetchImpl: deps.fetchImpl,
+                });
+                return {
+                    exitCode: 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'seal-protected-approval') {
+                const datasetFlags = parseDatasetMaintenanceSealProtectedApprovalFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return {
+                        exitCode: 0,
+                        stdout: `${renderDatasetMaintenanceSealProtectedApprovalHelp()}\n`,
+                        stderr: '',
+                    };
+                }
+                if (!datasetFlags.freezePath) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --freeze.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_FREEZE_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.approvalRequestPath) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --approval-request.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_APPROVAL_REQUEST_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.humanApprovalPath) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --human-approval.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_HUMAN_APPROVAL_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.approveFreezeFile) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --approve-freeze-file.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_FREEZE_CONFIRMATION_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.approveRequest) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --approve-request.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_REQUEST_CONFIRMATION_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.approveText) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --approve-text.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_TEXT_CONFIRMATION_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.confirm) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --confirm.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_CONFIRM_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.approvedAtUtc) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --approved-at.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_APPROVED_AT_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                if (!datasetFlags.outDir) {
+                    throw new CliError('dataset maintenance seal-protected-approval requires --out-dir.', {
+                        code: 'DATASET_MAINTENANCE_PROTECTED_OUT_DIR_REQUIRED',
+                        exitCode: 2,
+                    });
+                }
+                const report = await datasetMaintenanceProtectedApprovalSealImpl({
+                    freezePath: datasetFlags.freezePath,
+                    approvalRequestPath: datasetFlags.approvalRequestPath,
+                    humanApprovalPath: datasetFlags.humanApprovalPath,
+                    outDir: datasetFlags.outDir,
+                    approveFreezeFile: datasetFlags.approveFreezeFile,
+                    approveRequest: datasetFlags.approveRequest,
+                    approveText: datasetFlags.approveText,
+                    confirm: datasetFlags.confirm,
+                    approvedAtUtc: datasetFlags.approvedAtUtc,
+                });
+                return {
+                    exitCode: 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
             if (action === 'run-protected') {
                 const datasetFlags = parseDatasetMaintenanceProtectedFlags(commandArgs.slice(1));
                 if (datasetFlags.help) {
@@ -5836,7 +6125,7 @@ export async function executeCli(argv, deps) {
                     stderr: '',
                 };
             }
-            throw new CliError("dataset maintenance action must be 'clear-account', 'plan', 'apply', 'run-protected', or 'verify'.", {
+            throw new CliError("dataset maintenance action must be 'clear-account', 'plan', 'apply', 'freeze-protected', 'seal-protected-approval', 'run-protected', or 'verify'.", {
                 code: 'DATASET_MAINTENANCE_ACTION_INVALID',
                 exitCode: 2,
             });