@tiangong-lca/cli 0.0.10 → 0.0.12

package/dist/src/cli.js

@@ -41,6 +41,7 @@ import { runFlowApplyProcessFlowRepairs, runFlowPlanProcessFlowRepairs, runFlowR
 import { executeRemoteCommand, getRemoteCommandHelp } from './lib/remote.js';
 import { runValidation, } from './lib/validation.js';
 import { runDatasetValidate, } from './lib/dataset-validate.js';
+import { runDatasetCurationQueueBuild, runDatasetCurationQueueNext, runDatasetCurationQueueVerify, } from './lib/dataset-curation-queue.js';
 import { runDatasetReferencesRewrite, } from './lib/dataset-references-rewrite.js';
 import { runDatasetRemoteRefresh, } from './lib/dataset-remote-refresh.js';
 import { runDatasetRemoteVerify, } from './lib/dataset-remote-verify.js';
@@ -49,6 +50,10 @@ import { runDatasetEvidenceSearch, } from './lib/dataset-evidence-search.js';
 import { runDatasetContract, } from './lib/dataset-contract.js';
 import { runDatasetImportLcaConvert, } from './lib/dataset-import-lca.js';
 import { runDatasetAuthor, } from './lib/dataset-author.js';
+import { runDatasetPatchApply, } from './lib/dataset-patch.js';
+import { runDatasetSaveDraft, } from './lib/dataset-save-draft-run.js';
+import { runDatasetClassificationApply, runDatasetClassificationAudit, runDatasetClassificationChildren, runDatasetClassificationPath, } from './lib/dataset-classification.js';
+import { runDatasetMaintenanceClearAccount, } from './lib/dataset-maintenance-clear-account.js';
 function renderMainHelp(dotEnvStatus) {
     return `TianGong LCA CLI
 
@@ -68,7 +73,7 @@ Implemented Commands:
   doctor     show environment diagnostics
   search     flow | process | lifecyclemodel
   process    get | list | identity-preflight | build-plan | scope-statistics | dedup-review | auto-build | resume-build | publish-build | complete-required-fields | save-draft | batch-build | refresh-references | verify-rows
-  dataset    contract get | context-pack | import-lca convert | author | validate | verify-remote | bilingual extract/apply/validate | evidence-search plan/run | references rewrite/refresh-remote
+  dataset    contract get | context-pack | classification children/path/audit/apply | curation-queue build/next/verify | import-lca convert | author | patch apply | save-draft | validate | verify-remote | bilingual extract/apply/validate | evidence-search plan/run | references rewrite/refresh-remote | maintenance clear-account
   flow       get | list | identity-preflight | build-plan | fetch-rows | materialize-decisions | remediate | publish-version | publish-reviewed-data | build-alias-map | scan-process-flow-refs | plan-process-flow-repairs | apply-process-flow-repairs | regen-product | validate-processes
   lifecyclemodel auto-build | validate-build | publish-build | save-draft | graph | build-resulting-process | publish-resulting-process | orchestrate
   qa         process | flow | lifecyclemodel
@@ -79,6 +84,7 @@ Implemented Commands:
 Planned Surface (not implemented yet):
   auth       whoami | doctor-auth
   job        get | wait | logs
+  dataset maintenance plan | apply | verify
 
 Planned commands currently print an explicit "not implemented yet" message and exit with code 2.
 
@@ -103,8 +109,16 @@ Examples:
   tiangong-lca dataset validate --input ./rows.jsonl --type auto --out-dir /abs/path/to/dataset-validate
   tiangong-lca dataset contract get --type process --include schema,methodology,ruleset --out-dir ./contract
   tiangong-lca dataset context-pack --type process --profile ai-import --out-dir ./context-pack
+  tiangong-lca dataset classification children --type process --parent A --out-dir ./classification --json
+  tiangong-lca dataset classification path --type process --code 1080 --out-dir ./classification --json
+  tiangong-lca dataset classification audit --type location --input ./rows/processes.jsonl --out-dir ./classification --json
+  tiangong-lca dataset classification apply --input ./rows/processes.jsonl --decisions ./classification-decisions.jsonl --out ./rows/processes.classified.jsonl --type process --out-dir ./classification --json
+  tiangong-lca dataset curation-queue build --processes ./processes.jsonl --flows ./flows.jsonl --out-dir ./curation-queue
+  tiangong-lca dataset curation-queue next --queue-dir ./curation-queue --type support
+  tiangong-lca dataset curation-queue verify --queue-dir ./curation-queue --type process
   tiangong-lca dataset import-lca convert --input ./external-package --output-dir ./converted --from-format auto --target tidas
   tiangong-lca dataset author --input ./source.pdf --target-types process,flow --out-dir ./authoring
+  tiangong-lca dataset save-draft --input ./contacts.jsonl --type contact --out-dir /abs/path/to/contact-save-draft --commit
   tiangong-lca dataset verify-remote --input ./rows.jsonl --out-dir /abs/path/to/dataset-remote-verify
   tiangong-lca dataset bilingual extract --input ./rows/processes.jsonl --type process --out-dir ./translation
   tiangong-lca dataset bilingual apply --input ./rows/processes.jsonl --translations ./translation/trans-reviewed.jsonl --out ./rows/processes.translated.jsonl
@@ -112,6 +126,8 @@ Examples:
   tiangong-lca dataset evidence-search plan --query "中国2026年电力结构数据" --out-dir ./evidence-search
   tiangong-lca dataset evidence-search run --input ./evidence-search.request.json --results ./search-results.json --out-dir ./evidence-search
   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 redo-import --out-dir /abs/path/to/dataset-maintenance
   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
   tiangong-lca lifecyclemodel publish-build --run-dir /abs/path/to/lifecyclemodel-run
@@ -136,7 +152,7 @@ Examples:
   tiangong-lca qa process --rows-file ./processes.jsonl --out-dir ./qa
   tiangong-lca qa process --run-root /abs/path/to/process-run --run-id <run_id> --out-dir ./qa
   tiangong-lca qa flow --rows-file ./flows.json --out-dir ./qa
-  tiangong-lca qa lifecyclemodel --run-dir /abs/path/to/lifecyclemodel-run --out-dir ./lifecyclemodel-qa
+  tiangong-lca qa lifecyclemodel --rows-file ./lifecyclemodels.jsonl --out-dir ./lifecyclemodel-qa
   tiangong-lca publish run --input ./publish-request.json --dry-run
   tiangong-lca validation run --input-dir ./package --engine auto
   tiangong-lca admin embedding-run --input ./jobs.json
@@ -244,8 +260,14 @@ function renderDatasetHelp() {
 Implemented Subcommands:
   contract get        Write TIDAS schema / methodology / ruleset contract artifacts
   context-pack        Write an AI-ready TIDAS contract context pack
+  classification       Navigate bundled TIDAS classification schemas or apply selected classifications
+  curation-queue build Build entity-level AI curation queue artifacts for Foundry imports
+  curation-queue next  Return the next runnable support/flow/process queue task
+  curation-queue verify Verify queue task checkpoints for a scope
   import-lca convert  Convert supported external LCA packages through tidas-tools
   author              Extract source evidence and prepare TIDAS context packs for AI authoring
+  patch apply          Apply AI-authored structured dataset patches deterministically
+  save-draft           Save contact/source/support or other canonical dataset rows through the platform dataset command path
   validate             Validate local flow / process / lifecyclemodel rows with the TIDAS SDK
   verify-remote        Verify dataset roots and TIDAS references against remote published versions
   bilingual extract    Extract bilingual translation units from local rows
@@ -254,12 +276,25 @@ Implemented Subcommands:
   evidence-search      Plan or record field-level public evidence retrieval
   references rewrite   Rewrite flow references in local process and lifecyclemodel rows
   references refresh-remote Refresh local TIDAS reference versions to latest reachable remote rows
+  maintenance clear-account Dry-run or clear current authenticated account-owned dataset rows through RLS
+
+Planned Subcommands:
+  maintenance plan/apply/verify Plan, execute, and verify RLS-scoped dataset delete/redo maintenance
 
 Examples:
   tiangong-lca dataset contract get --type process --include schema,methodology,ruleset --out-dir ./contract --help
   tiangong-lca dataset context-pack --type process --profile ai-import --out-dir ./context-pack --help
+  tiangong-lca dataset classification children --type process --parent A --out-dir ./classification --help
+  tiangong-lca dataset classification path --type process --code 1080 --out-dir ./classification --help
+  tiangong-lca dataset classification audit --type location --input ./rows/processes.jsonl --out-dir ./classification --help
+  tiangong-lca dataset classification apply --input ./rows/processes.jsonl --decisions ./classification-decisions.jsonl --out ./rows/processes.classified.jsonl --type process --out-dir ./classification --help
+  tiangong-lca dataset curation-queue build --processes ./rows/processes.jsonl --flows ./rows/flows.jsonl --support ./rows/sources.jsonl --out-dir ./curation-queue --help
+  tiangong-lca dataset curation-queue next --queue-dir ./curation-queue --type flow --json
+  tiangong-lca dataset curation-queue verify --queue-dir ./curation-queue --task-id process:abc@00.00.001 --json
   tiangong-lca dataset import-lca convert --input ./external-package --output-dir ./converted --from-format auto --target tidas --help
   tiangong-lca dataset author --input ./source.pdf --target-types process,flow --out-dir ./authoring --help
+  tiangong-lca dataset patch apply --input ./rows.jsonl --patch ./ai-patches.json --out ./rows.patched.jsonl --out-dir ./patch-apply --help
+  tiangong-lca dataset save-draft --input ./contacts.jsonl --type contact --out-dir ./contact-save-draft --commit --help
   tiangong-lca dataset validate --input ./rows.jsonl --type auto --out-dir ./dataset-validate --help
   tiangong-lca dataset verify-remote --input ./rows.jsonl --out-dir ./dataset-remote-verify --help
   tiangong-lca dataset bilingual extract --input ./rows.jsonl --type process --out-dir ./translation --help
@@ -269,6 +304,69 @@ Examples:
   tiangong-lca dataset evidence-search run --input ./request.json --results ./search-results.json --out-dir ./evidence-search --help
   tiangong-lca dataset references rewrite --input ./rows.jsonl --from flow:<old-id>@<old-version> --to flow:<new-id>@<new-version> --out-dir ./dataset-rewrite --help
   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 redo-import --out-dir ./dataset-maintenance --help
+`.trim();
+}
+function renderDatasetMaintenanceHelp() {
+    return `Usage:
+  tiangong-lca dataset maintenance <clear-account|plan|apply|verify> [options]
+
+Status:
+  clear-account is implemented for current authenticated account cleanup.
+  plan/apply/verify remain reserved for row-level RLS-scoped cleanup and redo workflows and currently exit with code 2 for executable actions.
+
+Implemented Actions:
+  clear-account Dry-run or delete current authenticated account-owned lifecyclemodels, processes, flows, sources, and contacts.
+
+Planned Actions:
+  plan    Build an immutable maintenance plan from a scope manifest, visible remote snapshot, dependency impact report, and intended operation.
+  apply   Execute an approved plan through current-user RLS and platform dataset command paths; never bypass RLS or delete rows outside the visible scope.
+  verify  Re-fetch affected rows and references, then prove that deleted, updated, skipped, protected, and redone rows match the plan.
+
+Required Artifact Contract:
+  - maintenance-plan.json
+  - rls-visible-snapshot.json
+  - protected-rows.jsonl
+  - reference-impact-report.json
+  - dry-run-report.json
+  - commit-report.json
+  - readback-verify-report.json
+
+Examples:
+  tiangong-lca dataset maintenance clear-account --out-dir ./account-clear --json
+  tiangong-lca dataset maintenance clear-account --commit --confirm user@example.com --out-dir ./account-clear
+  tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operation redo-import --out-dir ./dataset-maintenance
+  tiangong-lca dataset maintenance apply --plan ./dataset-maintenance/maintenance-plan.json --commit
+  tiangong-lca dataset maintenance verify --plan ./dataset-maintenance/maintenance-plan.json --out-dir ./dataset-maintenance/verify
+`.trim();
+}
+function renderDatasetMaintenanceClearAccountHelp() {
+    return `Usage:
+  tiangong-lca dataset maintenance clear-account [options]
+
+Behavior:
+  Dry-run by default. With --commit, deletes only rows visible to the current authenticated user and filtered by user_id through RLS.
+  Tables are deleted in reference-safe order: lifecyclemodels, processes, flows, sources, contacts.
+  Unit groups and flow properties are not deleted by this command because they are treated as protected support data.
+
+Options:
+  --state-code <n>    Optional repeatable state_code filter. Omit to clear all state codes for the current account.
+  --out-dir <dir>     Artifact directory (default: ./dataset-maintenance/clear-account)
+  --page-size <n>     Snapshot page size, 1-5000 (default: 1000)
+  --timeout-ms <n>    Request timeout in milliseconds (default: 10000)
+  --commit            Execute deletion. Without this flag the command only writes a dry-run report.
+  --dry-run           Explicit dry-run mode
+  --confirm <email>   Required with --commit; must match the current authenticated account email
+  --json              Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - rls-visible-snapshot.json
+  - dry-run-report.json
+  - approval-record.json       (commit only)
+  - commit-report.json         (commit only)
+  - readback-verify-report.json (commit only)
 `.trim();
 }
 function renderDatasetContractHelp() {
@@ -313,6 +411,106 @@ Outputs written under --out-dir:
   - outputs/contract-report.json
 `.trim();
 }
+function renderDatasetClassificationHelp() {
+    return `Usage:
+  tiangong-lca dataset classification children --type <type> [options]
+  tiangong-lca dataset classification path --type <type> --code <code> [options]
+  tiangong-lca dataset classification audit --type location --input <file> [options]
+  tiangong-lca dataset classification apply --input <file> --decisions <file> --out <file> [options]
+
+Classification types:
+  process, flow-product, flow-elementary, source, contact, unitgroup, flowproperty, lciamethod, location
+
+Actions:
+  children   List the next selectable children for a parent code. Omit --parent for top level.
+  path       Resolve one schema code into the full root-to-leaf classification path.
+  audit      Scan local rows for schema-derived location fields that are not valid TIDAS location codes.
+  apply      Apply AI/human classification decisions to local TIDAS rows deterministically.
+
+Options for children:
+  --type <type>     Classification schema type
+  --parent <code>   Parent code to inspect
+  --query <text>    Filter direct children by code or label
+  --limit <n>       Limit returned children
+  --out-dir <dir>   Optional artifact directory
+  --json            Print compact JSON
+
+Options for path:
+  --type <type>     Classification schema type
+  --code <code>     Leaf or intermediate classification code
+  --out-dir <dir>   Optional artifact directory
+  --json            Print compact JSON
+
+Options for audit:
+  --type location   Audit schema-derived location values against tidas_locations_category.json
+  --input <file>    Local rows as JSON or JSONL
+  --out-dir <dir>   Optional artifact directory
+  --json            Print compact JSON
+
+Options for apply:
+  --input <file>     Local rows as JSON or JSONL
+  --decisions <file> JSON/JSONL decisions with row_index or dataset_id plus code/classes
+  --out <file>       Output JSONL path for classified rows
+  --type <type>      Default classification type when decisions omit category_type
+  --out-dir <dir>    Artifact directory; defaults to the output file directory
+  --json             Print compact JSON
+  -h, --help
+
+Decision contract:
+  Decisions may target row_index or dataset_id. They may provide code, leaf_code, class_id, cat_id,
+  or a classes/common:class/common:category path. The CLI normalizes the path against the bundled
+  TIDAS schema copied from tidas-tools before writing it back. Location decisions use location
+  target fields derived from the bundled TIDAS schemas, plus TIDAS LCIA geography fields; use
+  --type location and target_path when a row contains more than one location field.
+
+Outputs:
+  - children/path report under outputs/ when --out-dir is provided
+  - outputs/location-audit-findings.jsonl for audit
+  - outputs/location-audit-report.json for audit
+  - classified rows at --out for apply
+  - outputs/classification-apply-evidence.jsonl
+  - outputs/classification-apply-report.json
+`.trim();
+}
+function renderDatasetCurationQueueHelp() {
+    return `Usage:
+  tiangong-lca dataset curation-queue build --processes <file> --out-dir <dir> [options]
+  tiangong-lca dataset curation-queue next --queue-dir <dir> [--type <type>|--task-id <id>]
+  tiangong-lca dataset curation-queue verify --queue-dir <dir> [--type <type>|--task-id <id>]
+
+Options for build:
+  --processes <file>         Process rows JSON/JSONL
+  --flows <file>             Local flow rows JSON/JSONL used by process references
+  --support <file>           Repeatable support rows JSON/JSONL, for source/contact/unitgroup/flowproperty rows
+  --external-flow-ref <file> Repeatable external flow ref rows JSON/JSONL treated as already resolvable
+  --exclude-process-id <id>  Repeatable process id to skip
+  --process-limit <n>        Limit process tasks for focused validation or retries
+  --out-dir <dir>            Queue artifact directory
+  --json                     Print compact JSON
+  -h, --help
+
+Options for next/verify:
+  --queue-dir <dir>          Queue artifact directory produced by build
+  --type <type>              support | flow | process
+  --task-id <id>             Exact task id such as process:<uuid>@00.00.001
+  --json                     Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/curation-queue-manifest.json
+  - outputs/curation-queue-tasks.jsonl
+  - outputs/curation-queue-locks.json
+  - outputs/curation-queue-blockers.jsonl
+  - entities/<supports|flows|processes>/<id>__<version>/input.jsonl
+  - entities/<supports|flows|processes>/<id>__<version>/closure.json
+  - entities/<supports|flows|processes>/<id>__<version>/entity-run-plan.json
+
+Contract:
+  build creates queue artifacts. next/verify consume those artifacts and entity checkpoint.json files.
+  They do not run AI or write the database. AI authoring must write structured patches or build plans,
+  and remote writes remain blocked until deterministic apply, schema/QA, prewrite verify, and readback gates pass.
+`.trim();
+}
 function renderDatasetImportLcaHelp() {
     return `Usage:
   tiangong-lca dataset import-lca convert --input <path> --output-dir <dir> [options]
@@ -326,6 +524,10 @@ Options:
   --mapping-dir <dir>     Optional custom mapping/reference data directory
   --language <lang>       Default language for generated text (default: en)
   --validation-jobs <n>   Parallel validation jobs passed to tidas-tools (default: 1)
+  --process-bundles       Write per-process dependency bundles (default: enabled)
+  --process-bundles-dir <dir>
+                           Custom per-process bundle directory (default: <output-dir>/process-bundles)
+  --no-process-bundles    Disable per-process dependency bundle generation
   --detect-only           Only detect the input format and write the report
   --fail-on-warning       Return non-zero when converter warnings are present
   --python <bin>          Python executable (default: python3)
@@ -338,6 +540,7 @@ Outputs written under --output-dir:
   - tidas/ when target includes TIDAS and not detect-only
   - ilcd/ when target includes ILCD and not detect-only
   - mapping.csv when not detect-only
+  - process-bundles/ when not detect-only and process bundles are enabled
   - outputs/import-lca-report.json
 `.trim();
 }
@@ -366,6 +569,35 @@ Environment:
   TIANGONG_LCA_UNSTRUCTURED_API_BASE_URL and TIANGONG_LCA_UNSTRUCTURED_API_KEY
 `.trim();
 }
+function renderDatasetPatchHelp() {
+    return `Usage:
+  tiangong-lca dataset patch apply --input <file> --patch <file> --out <file> [options]
+
+Options:
+  --input <file>  Local rows as JSON or JSONL
+  --patch <file>  AI-authored JSON patch set with row_index or dataset_id selectors
+  --out <file>    Output JSONL path for patched rows
+  --out-dir <dir> Artifact directory; defaults to the output file directory
+  --authoring-package-dir <dir> Resolve relative authoring_package paths from this directory
+  --require-authoring-package   Require each patch set to point at a matching authoring package
+  --require-action-item-closure Require patch operations to close package action_items
+  --json          Print compact JSON
+  -h, --help
+
+Patch contract:
+  Patch payloads must declare patch_status=completed before deterministic apply.
+  Patch sets must target a row by row_index or dataset_id and use operations[].
+  Supported operations are test, add, replace, and remove. Non-test operations require basis or evidence.
+  Foundry AI patches should include resolution.mode and resolution.used_context_kinds; these are copied to patch evidence.
+  Strict Foundry mode also requires authoring package lineage and explicit action item closure.
+  If any operation is invalid, the command reports blocked and writes the original rows unchanged.
+
+Outputs:
+  - patched rows at --out
+  - outputs/patch-evidence.jsonl
+  - outputs/dataset-patch-apply-report.json
+`.trim();
+}
 function renderDatasetRemoteVerifyHelp() {
     return `Usage:
   tiangong-lca dataset verify-remote --input <file> --out-dir <dir> [options]
@@ -374,6 +606,9 @@ Options:
   --input <file>         Local rows as JSON or JSONL; objects with rows[] are also accepted
   --out-dir <dir>        Artifact directory for the remote verification report
   --root-policy <mode>   existing | candidate (default: existing)
+  --compare-root-payload Compare each root row payload hash against the remote row
+  --target-user-id <id>  Require root readback rows to belong to this user
+  --state-code <code>    Require root readback rows to have this state_code
   --json                 Print compact JSON
   -h, --help
 
@@ -386,13 +621,37 @@ Outputs written under --out-dir:
   - outputs/blockers.jsonl
 `.trim();
 }
+function renderDatasetSaveDraftHelp() {
+    return `Usage:
+  tiangong-lca dataset save-draft --input <file> --type <type> [options]
+
+Options:
+  --input <file>   Canonical TIDAS rows JSON/JSONL
+  --type <type>    auto, contact, source, flow, process
+  --out-dir <dir>  Artifact directory
+  --commit         Execute remote save-draft writes
+  --dry-run        Validate and plan without remote writes (default)
+  --json           Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/dataset-save-draft/selected-rows.jsonl
+  - outputs/dataset-save-draft/progress.jsonl
+  - outputs/dataset-save-draft/failures.jsonl
+  - outputs/dataset-save-draft/summary.json
+
+Contract:
+  This generic dataset path writes only mutable rows such as contact/source/flow/process. Unit group and flow property rows are reference-only; select existing database rows and rewrite references instead of creating My Data support rows.
+  Process and lifecyclemodel imports may still use their dedicated save-draft commands when the workflow needs their specialized reports.
+`.trim();
+}
 function renderDatasetValidateHelp() {
     return `Usage:
   tiangong-lca dataset validate --input <file> [options]
 
 Options:
   --input <file>   Local rows as JSON or JSONL; objects with rows[] are also accepted
-  --type <type>    auto | flow | process | lifecyclemodel (default: auto)
+  --type <type>    auto | contact | source | unitgroup | flowproperty | flow | process | lifecyclemodel (default: auto)
   --out-dir <dir>  Optional artifact directory for validation report and row splits
   --json           Print compact JSON
   -h, --help
@@ -619,6 +878,9 @@ Options:
                    Override the remote search query; defaults to target identity text
   --remote-limit <n>
                    Limit remote candidate rows after fetch
+  --remote-data-source <tg|co|my|te>
+                   Search TianGong public, community, my data, or team data (default: tg)
+  --timeout-ms <n> Remote search/auth timeout in milliseconds
   --out-dir <dir>  Optional artifact directory for identity decision outputs
   --json           Print compact JSON
   -h, --help
@@ -948,7 +1210,7 @@ function renderQaHelp() {
 Implemented Subcommands:
   process      Run deterministic process QA for build runs or rows-file snapshots
   flow         Run deterministic flow QA for local governance snapshots
-  lifecyclemodel Run deterministic lifecyclemodel QA for one local build run
+  lifecyclemodel Run deterministic lifecyclemodel QA for build runs or rows-file snapshots
 
 Examples:
   tiangong-lca qa process --help
@@ -1000,9 +1262,10 @@ Options:
 }
 function renderQaLifecyclemodelHelp() {
     return `Usage:
-  tiangong-lca qa lifecyclemodel --run-dir <dir> --out-dir <dir> [options]
+  tiangong-lca qa lifecyclemodel (--rows-file <file> | --run-dir <dir>) --out-dir <dir> [options]
 
 Options:
+  --rows-file <file>       Lifecyclemodel rows JSON/JSONL file; payload-level QA for import snapshots
   --run-dir <dir>          Existing lifecyclemodel auto-build run directory
   --out-dir <dir>          QA artifact output directory
   --start-ts <iso>         Optional run start timestamp
@@ -1012,7 +1275,7 @@ Options:
   -h, --help
 
 This command:
-  - reads one existing lifecyclemodel build run under models/*/tidas_bundle/lifecyclemodels
+  - reads one lifecyclemodel rows snapshot or existing build run under models/*/tidas_bundle/lifecyclemodels
   - aggregates validate-build findings when reports/lifecyclemodel-validate-build-report.json is present
   - emits artifact-first model summaries, findings, markdown QA notes, and a structured report
 `.trim();
@@ -1300,6 +1563,9 @@ Options:
                    Override the remote search query; defaults to target identity text
   --remote-limit <n>
                    Limit remote candidate rows after fetch
+  --remote-data-source <tg|co|my|te>
+                   Search TianGong public, community, my data, or team data (default: tg)
+  --timeout-ms <n> Remote search/auth timeout in milliseconds
   --out-dir <dir>  Optional artifact directory for identity decision outputs
   --json           Print compact JSON
   -h, --help
@@ -1428,7 +1694,7 @@ Options:
 Annual supply / production volume policy:
   1. keep an existing valid annualized annualSupplyOrProductionVolume, for example "3.6 MJ/year";
   2. use an explicit value from row-level authoring evidence or evidenceManifest field bindings;
-  3. otherwise complete from the quantitative reference flow meanAmount/resultingAmount and unit.
+  3. otherwise write "9999 missing-data-sentinel/year", an intentionally non-physical searchable sentinel for later database-side curation.
 
 Outputs:
   - completed rows at --out
@@ -1788,6 +2054,45 @@ function parseDatasetValidateFlags(args) {
         outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
     };
 }
+function parseDatasetSaveDraftFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                type: { type: 'string' },
+                'out-dir': { type: 'string' },
+                commit: { type: 'boolean' },
+                'dry-run': { type: 'boolean' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    if (values.commit && values['dry-run']) {
+        throw new CliError('Cannot pass both --commit and --dry-run.', {
+            code: 'INVALID_DATASET_SAVE_DRAFT_MODE',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        type: typeof values.type === 'string' ? values.type : undefined,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        commit: Boolean(values.commit),
+    };
+}
 function parseDatasetContractFlags(args) {
     let values;
     try {
@@ -1822,6 +2127,228 @@ function parseDatasetContractFlags(args) {
         outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
     };
 }
+function parseDatasetClassificationChildrenFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                type: { type: 'string' },
+                parent: { type: 'string' },
+                query: { type: 'string' },
+                limit: { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const limit = typeof values.limit === 'string' ? Number.parseInt(values.limit, 10) : null;
+    if (limit !== null && (!Number.isInteger(limit) || limit <= 0)) {
+        throw new CliError('--limit must be a positive integer.', {
+            code: 'DATASET_CLASSIFICATION_LIMIT_INVALID',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        type: typeof values.type === 'string' ? values.type : '',
+        parent: typeof values.parent === 'string' ? values.parent : null,
+        query: typeof values.query === 'string' ? values.query : null,
+        limit,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetClassificationPathFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                type: { type: 'string' },
+                code: { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        type: typeof values.type === 'string' ? values.type : '',
+        code: typeof values.code === 'string' ? values.code : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetClassificationAuditFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                type: { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        type: typeof values.type === 'string' ? values.type : 'location',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetClassificationApplyFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                decisions: { type: 'string' },
+                out: { type: 'string' },
+                type: { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        decisionsPath: typeof values.decisions === 'string' ? values.decisions : '',
+        outPath: typeof values.out === 'string' ? values.out : '',
+        type: typeof values.type === 'string' ? values.type : null,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetCurationQueueBuildFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                processes: { type: 'string' },
+                flows: { type: 'string' },
+                support: { type: 'string', multiple: true },
+                'external-flow-ref': { type: 'string', multiple: true },
+                'exclude-process-id': { type: 'string', multiple: true },
+                'process-limit': { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const processLimit = typeof values['process-limit'] === 'string'
+        ? Number.parseInt(values['process-limit'], 10)
+        : undefined;
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        processesPath: typeof values.processes === 'string' ? values.processes : '',
+        flowsPath: typeof values.flows === 'string' ? values.flows : undefined,
+        supportPaths: Array.isArray(values.support)
+            ? values.support.filter((value) => typeof value === 'string')
+            : [],
+        externalFlowRefPaths: Array.isArray(values['external-flow-ref'])
+            ? values['external-flow-ref'].filter((value) => typeof value === 'string')
+            : [],
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        excludeProcessIds: Array.isArray(values['exclude-process-id'])
+            ? values['exclude-process-id'].filter((value) => typeof value === 'string')
+            : [],
+        processLimit,
+    };
+}
+function parseDatasetCurationQueueRuntimeFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'queue-dir': { type: 'string' },
+                type: { type: 'string' },
+                'task-id': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const entityType = typeof values.type === 'string' ? values.type : undefined;
+    if (entityType !== undefined &&
+        entityType !== 'support' &&
+        entityType !== 'flow' &&
+        entityType !== 'process') {
+        throw new CliError('--type must be support, flow, or process.', {
+            code: 'DATASET_CURATION_QUEUE_TYPE_INVALID',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        queueDir: typeof values['queue-dir'] === 'string' ? values['queue-dir'] : '',
+        entityType,
+        taskId: typeof values['task-id'] === 'string' ? values['task-id'] : undefined,
+    };
+}
 function parseDatasetImportLcaConvertFlags(args) {
     let values;
     try {
@@ -1840,6 +2367,9 @@ function parseDatasetImportLcaConvertFlags(args) {
                 'mapping-dir': { type: 'string' },
                 language: { type: 'string' },
                 'validation-jobs': { type: 'string' },
+                'process-bundles': { type: 'boolean' },
+                'process-bundles-dir': { type: 'string' },
+                'no-process-bundles': { type: 'boolean' },
                 'detect-only': { type: 'boolean' },
                 'fail-on-warning': { type: 'boolean' },
                 python: { type: 'string' },
@@ -1860,6 +2390,18 @@ function parseDatasetImportLcaConvertFlags(args) {
             exitCode: 2,
         });
     }
+    if (values['process-bundles'] && values['no-process-bundles']) {
+        throw new CliError('--process-bundles and --no-process-bundles cannot both be set.', {
+            code: 'DATASET_IMPORT_LCA_PROCESS_BUNDLES_INVALID',
+            exitCode: 2,
+        });
+    }
+    if (values['no-process-bundles'] && typeof values['process-bundles-dir'] === 'string') {
+        throw new CliError('--process-bundles-dir cannot be used with --no-process-bundles.', {
+            code: 'DATASET_IMPORT_LCA_PROCESS_BUNDLES_INVALID',
+            exitCode: 2,
+        });
+    }
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
@@ -1871,6 +2413,12 @@ function parseDatasetImportLcaConvertFlags(args) {
         mappingDir: typeof values['mapping-dir'] === 'string' ? values['mapping-dir'] : undefined,
         language: typeof values.language === 'string' ? values.language : undefined,
         validationJobs,
+        processBundles: values['no-process-bundles']
+            ? false
+            : values['process-bundles']
+                ? true
+                : undefined,
+        processBundlesDir: typeof values['process-bundles-dir'] === 'string' ? values['process-bundles-dir'] : undefined,
         detectOnly: Boolean(values['detect-only']),
         failOnWarning: Boolean(values['fail-on-warning']),
         pythonBin: typeof values.python === 'string' ? values.python : undefined,
@@ -1924,6 +2472,44 @@ function parseDatasetAuthorFlags(args) {
         timeoutMs,
     };
 }
+function parseDatasetPatchApplyFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                patch: { type: 'string' },
+                out: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'authoring-package-dir': { type: 'string' },
+                'require-authoring-package': { type: 'boolean' },
+                'require-action-item-closure': { type: 'boolean' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        patchPath: typeof values.patch === 'string' ? values.patch : '',
+        outPath: typeof values.out === 'string' ? values.out : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        authoringPackageDir: typeof values['authoring-package-dir'] === 'string' ? values['authoring-package-dir'] : null,
+        requireAuthoringPackage: Boolean(values['require-authoring-package']),
+        requireActionItemClosure: Boolean(values['require-action-item-closure']),
+    };
+}
 function parseDatasetRemoteVerifyFlags(args) {
     let values;
     try {
@@ -1937,6 +2523,9 @@ function parseDatasetRemoteVerifyFlags(args) {
                 input: { type: 'string' },
                 'out-dir': { type: 'string' },
                 'root-policy': { type: 'string' },
+                'compare-root-payload': { type: 'boolean' },
+                'target-user-id': { type: 'string' },
+                'state-code': { type: 'string' },
             },
         }));
     }
@@ -1954,12 +2543,25 @@ function parseDatasetRemoteVerifyFlags(args) {
         });
     }
     const rootPolicy = rawRootPolicy;
+    let stateCode = null;
+    if (typeof values['state-code'] === 'string') {
+        stateCode = Number.parseInt(values['state-code'], 10);
+        if (!Number.isInteger(stateCode) || stateCode < 0) {
+            throw new CliError('--state-code must be a non-negative integer.', {
+                code: 'DATASET_REMOTE_VERIFY_STATE_CODE_INVALID',
+                exitCode: 2,
+            });
+        }
+    }
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
         inputPath: typeof values.input === 'string' ? values.input : '',
         outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
         rootPolicy,
+        compareRootPayload: Boolean(values['compare-root-payload']),
+        targetUserId: typeof values['target-user-id'] === 'string' ? values['target-user-id'] : null,
+        stateCode,
     };
 }
 function parseDatasetBilingualExtractFlags(args) {
@@ -2204,6 +2806,78 @@ function parseDatasetReferencesRefreshRemoteFlags(args) {
         rootPolicy,
     };
 }
+function parseDatasetMaintenanceClearAccountFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'out-dir': { type: 'string' },
+                'state-code': { type: 'string', multiple: true },
+                'page-size': { type: 'string' },
+                'timeout-ms': { type: 'string' },
+                commit: { type: 'boolean' },
+                'dry-run': { type: 'boolean' },
+                confirm: { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    if (values.commit && values['dry-run']) {
+        throw new CliError('Cannot pass both --commit and --dry-run.', {
+            code: 'DATASET_MAINTENANCE_CLEAR_ACCOUNT_MODE_CONFLICT',
+            exitCode: 2,
+        });
+    }
+    const rawStateCodes = Array.isArray(values['state-code'])
+        ? values['state-code'].filter((value) => typeof value === 'string')
+        : [];
+    const stateCodes = rawStateCodes.map((value) => {
+        if (!/^-?\d+$/u.test(value.trim())) {
+            throw new CliError('--state-code must be an integer.', {
+                code: 'DATASET_MAINTENANCE_STATE_CODE_INVALID',
+                exitCode: 2,
+                details: value,
+            });
+        }
+        return Number.parseInt(value.trim(), 10);
+    });
+    const parseOptionalInteger = (value, flagName) => {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        if (!/^\d+$/u.test(value.trim())) {
+            throw new CliError(`${flagName} must be a positive integer.`, {
+                code: 'DATASET_MAINTENANCE_INTEGER_INVALID',
+                exitCode: 2,
+                details: {
+                    flag: flagName,
+                    value,
+                },
+            });
+        }
+        return Number.parseInt(value.trim(), 10);
+    };
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        stateCodes: stateCodes.length > 0 ? stateCodes : null,
+        pageSize: parseOptionalInteger(values['page-size'], '--page-size'),
+        timeoutMs: parseOptionalInteger(values['timeout-ms'], '--timeout-ms'),
+        commit: Boolean(values.commit),
+        confirm: typeof values.confirm === 'string' ? values.confirm : null,
+    };
+}
 function parseIdentityPreflightFlags(args) {
     let values;
     try {
@@ -2219,6 +2893,8 @@ function parseIdentityPreflightFlags(args) {
                 'remote-candidates': { type: 'boolean' },
                 'remote-query': { type: 'string' },
                 'remote-limit': { type: 'string' },
+                'remote-data-source': { type: 'string' },
+                'timeout-ms': { type: 'string' },
                 'out-dir': { type: 'string' },
             },
         }));
@@ -2243,6 +2919,19 @@ function parseIdentityPreflightFlags(args) {
         }
         return parsed;
     };
+    const parseTimeoutMs = (value) => {
+        if (typeof value !== 'string') {
+            return undefined;
+        }
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new CliError('Expected --timeout-ms to be a positive integer.', {
+                code: 'INVALID_IDENTITY_PREFLIGHT_TIMEOUT',
+                exitCode: 2,
+            });
+        }
+        return parsed;
+    };
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
@@ -2251,9 +2940,11 @@ function parseIdentityPreflightFlags(args) {
         candidateInputPaths: Array.isArray(candidateInputValue)
             ? candidateInputValue.filter((entry) => typeof entry === 'string')
             : [],
-        remoteCandidateSearch: Boolean(values['remote-candidates']),
+        remoteCandidateSearch: values['remote-candidates'] === true ? true : undefined,
         remoteQuery: typeof values['remote-query'] === 'string' ? values['remote-query'] : null,
         remoteLimit: parseRemoteLimit(values['remote-limit']),
+        remoteDataSource: typeof values['remote-data-source'] === 'string' ? values['remote-data-source'] : null,
+        timeoutMs: parseTimeoutMs(values['timeout-ms']),
     };
 }
 function parseBuildPlanFlags(args) {
@@ -3097,6 +3788,7 @@ function parseQaLifecyclemodelFlags(args) {
             options: {
                 help: { type: 'boolean', short: 'h' },
                 json: { type: 'boolean' },
+                'rows-file': { type: 'string' },
                 'run-dir': { type: 'string' },
                 'out-dir': { type: 'string' },
                 'start-ts': { type: 'string' },
@@ -3114,6 +3806,7 @@ function parseQaLifecyclemodelFlags(args) {
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
+        rowsFile: typeof values['rows-file'] === 'string' ? values['rows-file'] : undefined,
         runDir: typeof values['run-dir'] === 'string' ? values['run-dir'] : '',
         outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
         startTs: typeof values['start-ts'] === 'string' ? values['start-ts'] : undefined,
@@ -3908,6 +4601,9 @@ export async function executeCli(argv, deps) {
         const flowBuildPlanValidateImpl = deps.runFlowBuildPlanValidateImpl ?? runFlowBuildPlanValidate;
         const flowBuildPlanMaterializeImpl = deps.runFlowBuildPlanMaterializeImpl ?? runFlowBuildPlanMaterialize;
         const datasetValidateImpl = deps.runDatasetValidateImpl ?? runDatasetValidate;
+        const datasetCurationQueueBuildImpl = deps.runDatasetCurationQueueBuildImpl ?? runDatasetCurationQueueBuild;
+        const datasetCurationQueueNextImpl = deps.runDatasetCurationQueueNextImpl ?? runDatasetCurationQueueNext;
+        const datasetCurationQueueVerifyImpl = deps.runDatasetCurationQueueVerifyImpl ?? runDatasetCurationQueueVerify;
         const datasetReferencesRewriteImpl = deps.runDatasetReferencesRewriteImpl ?? runDatasetReferencesRewrite;
         const datasetRemoteRefreshImpl = deps.runDatasetRemoteRefreshImpl ?? runDatasetRemoteRefresh;
         const datasetRemoteVerifyImpl = deps.runDatasetRemoteVerifyImpl ?? runDatasetRemoteVerify;
@@ -3918,6 +4614,13 @@ export async function executeCli(argv, deps) {
         const datasetContractImpl = deps.runDatasetContractImpl ?? runDatasetContract;
         const datasetImportLcaConvertImpl = deps.runDatasetImportLcaConvertImpl ?? runDatasetImportLcaConvert;
         const datasetAuthorImpl = deps.runDatasetAuthorImpl ?? runDatasetAuthor;
+        const datasetPatchApplyImpl = deps.runDatasetPatchApplyImpl ?? runDatasetPatchApply;
+        const datasetSaveDraftImpl = deps.runDatasetSaveDraftImpl ?? runDatasetSaveDraft;
+        const datasetClassificationChildrenImpl = deps.runDatasetClassificationChildrenImpl ?? runDatasetClassificationChildren;
+        const datasetClassificationPathImpl = deps.runDatasetClassificationPathImpl ?? runDatasetClassificationPath;
+        const datasetClassificationAuditImpl = deps.runDatasetClassificationAuditImpl ?? runDatasetClassificationAudit;
+        const datasetClassificationApplyImpl = deps.runDatasetClassificationApplyImpl ?? runDatasetClassificationApply;
+        const datasetMaintenanceClearAccountImpl = deps.runDatasetMaintenanceClearAccountImpl ?? runDatasetMaintenanceClearAccount;
         if (flags.version) {
             return { exitCode: 0, stdout: `${loadCliPackageVersion(import.meta.url)}\n`, stderr: '' };
         }
@@ -4009,6 +4712,146 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'dataset' && subcommand === 'classification') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetClassificationHelp()}\n`, stderr: '' };
+            }
+            if (action === 'children') {
+                const datasetFlags = parseDatasetClassificationChildrenFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetClassificationHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetClassificationChildrenImpl({
+                    type: datasetFlags.type,
+                    parent: datasetFlags.parent,
+                    query: datasetFlags.query,
+                    limit: datasetFlags.limit,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'path') {
+                const datasetFlags = parseDatasetClassificationPathFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetClassificationHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetClassificationPathImpl({
+                    type: datasetFlags.type,
+                    code: datasetFlags.code,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'audit') {
+                const datasetFlags = parseDatasetClassificationAuditFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetClassificationHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetClassificationAuditImpl({
+                    inputPath: datasetFlags.inputPath,
+                    type: datasetFlags.type,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'apply') {
+                const datasetFlags = parseDatasetClassificationApplyFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetClassificationHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetClassificationApplyImpl({
+                    inputPath: datasetFlags.inputPath,
+                    decisionsPath: datasetFlags.decisionsPath,
+                    outPath: datasetFlags.outPath,
+                    type: datasetFlags.type,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            throw new CliError("dataset classification action must be 'children', 'path', 'audit', or 'apply'.", {
+                code: 'DATASET_CLASSIFICATION_ACTION_INVALID',
+                exitCode: 2,
+            });
+        }
+        if (command === 'dataset' && subcommand === 'curation-queue') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetCurationQueueHelp()}\n`, stderr: '' };
+            }
+            if (action !== 'build' && action !== 'next' && action !== 'verify') {
+                throw new CliError("dataset curation-queue action must be 'build', 'next', or 'verify'.", {
+                    code: 'DATASET_CURATION_QUEUE_ACTION_INVALID',
+                    exitCode: 2,
+                });
+            }
+            if (action === 'next') {
+                const datasetFlags = parseDatasetCurationQueueRuntimeFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetCurationQueueHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetCurationQueueNextImpl({
+                    queueDir: datasetFlags.queueDir,
+                    entityType: datasetFlags.entityType,
+                    taskId: datasetFlags.taskId,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'verify') {
+                const datasetFlags = parseDatasetCurationQueueRuntimeFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetCurationQueueHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetCurationQueueVerifyImpl({
+                    queueDir: datasetFlags.queueDir,
+                    entityType: datasetFlags.entityType,
+                    taskId: datasetFlags.taskId,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            const datasetFlags = parseDatasetCurationQueueBuildFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetCurationQueueHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetCurationQueueBuildImpl({
+                processesPath: datasetFlags.processesPath,
+                flowsPath: datasetFlags.flowsPath,
+                supportPaths: datasetFlags.supportPaths,
+                externalFlowRefPaths: datasetFlags.externalFlowRefPaths,
+                outDir: datasetFlags.outDir,
+                excludeProcessIds: datasetFlags.excludeProcessIds,
+                processLimit: datasetFlags.processLimit,
+            });
+            return {
+                exitCode: report.status === 'blocked' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'dataset' && subcommand === 'import-lca') {
             const action = commandArgs[0] ?? '';
             if (!action || action === '--help' || action === '-h') {
@@ -4033,6 +4876,8 @@ export async function executeCli(argv, deps) {
                 mappingDir: datasetFlags.mappingDir,
                 language: datasetFlags.language,
                 validationJobs: datasetFlags.validationJobs,
+                processBundles: datasetFlags.processBundles,
+                processBundlesDir: datasetFlags.processBundlesDir,
                 detectOnly: datasetFlags.detectOnly,
                 failOnWarning: datasetFlags.failOnWarning,
                 pythonBin: datasetFlags.pythonBin,
@@ -4067,6 +4912,55 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'dataset' && subcommand === 'patch') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetPatchHelp()}\n`, stderr: '' };
+            }
+            if (action !== 'apply') {
+                throw new CliError("dataset patch action must be 'apply'.", {
+                    code: 'DATASET_PATCH_ACTION_INVALID',
+                    exitCode: 2,
+                });
+            }
+            const datasetFlags = parseDatasetPatchApplyFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetPatchHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetPatchApplyImpl({
+                inputPath: datasetFlags.inputPath,
+                patchPath: datasetFlags.patchPath,
+                outPath: datasetFlags.outPath,
+                outDir: datasetFlags.outDir,
+                authoringPackageDir: datasetFlags.authoringPackageDir,
+                requireAuthoringPackage: datasetFlags.requireAuthoringPackage,
+                requireActionItemClosure: datasetFlags.requireActionItemClosure,
+            });
+            return {
+                exitCode: report.status === 'blocked' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'save-draft') {
+            const datasetFlags = parseDatasetSaveDraftFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetSaveDraftHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetSaveDraftImpl({
+                inputPath: datasetFlags.inputPath,
+                type: datasetFlags.type,
+                outDir: datasetFlags.outDir,
+                commit: datasetFlags.commit,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'completed_with_failures' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'dataset' && subcommand === 'validate') {
             const datasetFlags = parseDatasetValidateFlags(commandArgs);
             if (datasetFlags.help) {
@@ -4092,6 +4986,9 @@ export async function executeCli(argv, deps) {
                 inputPath: datasetFlags.inputPath,
                 outDir: datasetFlags.outDir,
                 rootPolicy: datasetFlags.rootPolicy,
+                compareRootPayload: datasetFlags.compareRootPayload,
+                targetUserId: datasetFlags.targetUserId,
+                stateCode: datasetFlags.stateCode,
                 env: deps.env,
                 fetchImpl: deps.fetchImpl,
             });
@@ -4249,6 +5146,44 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'dataset' && subcommand === 'maintenance') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetMaintenanceHelp()}\n`, stderr: '' };
+            }
+            if (action === 'clear-account') {
+                const datasetFlags = parseDatasetMaintenanceClearAccountFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return {
+                        exitCode: 0,
+                        stdout: `${renderDatasetMaintenanceClearAccountHelp()}\n`,
+                        stderr: '',
+                    };
+                }
+                const report = await datasetMaintenanceClearAccountImpl({
+                    outDir: datasetFlags.outDir,
+                    stateCodes: datasetFlags.stateCodes,
+                    pageSize: datasetFlags.pageSize,
+                    timeoutMs: datasetFlags.timeoutMs,
+                    commit: datasetFlags.commit,
+                    confirm: datasetFlags.confirm,
+                    env: deps.env,
+                    fetchImpl: deps.fetchImpl,
+                });
+                return {
+                    exitCode: report.status === 'completed_with_failures' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (!['plan', 'apply', 'verify'].includes(action)) {
+                throw new CliError("dataset maintenance action must be 'clear-account', 'plan', 'apply', or 'verify'.", {
+                    code: 'DATASET_MAINTENANCE_ACTION_INVALID',
+                    exitCode: 2,
+                });
+            }
+            return plannedCommand('dataset', `maintenance ${action}`);
+        }
         if (command === 'lifecyclemodel' && !subcommand) {
             return { exitCode: 0, stdout: `${renderLifecyclemodelHelp()}\n`, stderr: '' };
         }
@@ -4498,6 +5433,8 @@ export async function executeCli(argv, deps) {
                 remoteCandidateSearch: processFlags.remoteCandidateSearch,
                 remoteQuery: processFlags.remoteQuery,
                 remoteLimit: processFlags.remoteLimit,
+                remoteDataSource: processFlags.remoteDataSource,
+                timeoutMs: processFlags.timeoutMs,
                 env: deps.env,
                 fetchImpl: deps.fetchImpl,
             });
@@ -4816,6 +5753,8 @@ export async function executeCli(argv, deps) {
                 remoteCandidateSearch: flowFlags.remoteCandidateSearch,
                 remoteQuery: flowFlags.remoteQuery,
                 remoteLimit: flowFlags.remoteLimit,
+                remoteDataSource: flowFlags.remoteDataSource,
+                timeoutMs: flowFlags.timeoutMs,
                 env: deps.env,
                 fetchImpl: deps.fetchImpl,
             });
@@ -5213,6 +6152,7 @@ export async function executeCli(argv, deps) {
                 return { exitCode: 0, stdout: `${renderQaLifecyclemodelHelp()}\n`, stderr: '' };
             }
             const report = await lifecyclemodelQaImpl({
+                ...(qaFlags.rowsFile ? { rowsFile: qaFlags.rowsFile } : {}),
                 runDir: qaFlags.runDir,
                 outDir: qaFlags.outDir,
                 startTs: qaFlags.startTs,