@tiangong-lca/cli 0.0.6 → 0.0.8

package/dist/src/cli.js

@@ -8,14 +8,23 @@ import { runLifecyclemodelBuildResultingProcess, } from './lib/lifecyclemodel-re
 import { runLifecyclemodelPublishResultingProcess, } from './lib/lifecyclemodel-publish-resulting-process.js';
 import { runLifecyclemodelValidateBuild, } from './lib/lifecyclemodel-validate-build.js';
 import { runLifecyclemodelPublishBuild, } from './lib/lifecyclemodel-publish-build.js';
+import { runLifecyclemodelSaveDraft, } from './lib/lifecyclemodel-save-draft-run.js';
+import { runLifecyclemodelGraph, } from './lib/lifecyclemodel-graph.js';
 import { runLifecyclemodelOrchestrate, } from './lib/lifecyclemodel-orchestrate.js';
 import { runProcessAutoBuild, } from './lib/process-auto-build.js';
 import { runProcessGet, } from './lib/process-get.js';
 import { runProcessList, } from './lib/process-list.js';
 import { runProcessBatchBuild, } from './lib/process-batch-build.js';
+import { runProcessScopeStatistics, } from './lib/process-scope-statistics.js';
+import { runProcessRefreshReferences, } from './lib/process-refresh-references.js';
+import { runProcessDedupReview, } from './lib/process-dedup-review.js';
 import { runProcessResumeBuild, } from './lib/process-resume-build.js';
 import { runProcessPublishBuild, } from './lib/process-publish-build.js';
 import { runProcessSaveDraft, } from './lib/process-save-draft-run.js';
+import { runProcessRequiredFieldsComplete, } from './lib/process-required-fields.js';
+import { runProcessVerifyRows, } from './lib/process-verify-rows.js';
+import { runFlowBuildPlanMaterialize, runFlowBuildPlanValidate, runProcessBuildPlanMaterialize, runProcessBuildPlanValidate, } from './lib/process-flow-build-plan.js';
+import { runFlowIdentityPreflight, runProcessIdentityPreflight, } from './lib/identity-preflight.js';
 import { runPublish } from './lib/publish.js';
 import { runProcessReview, } from './lib/review-process.js';
 import { runFlowReview, } from './lib/review-flow.js';
@@ -31,6 +40,15 @@ import { runFlowBuildAliasMap, } from './lib/flow-build-alias-map.js';
 import { runFlowApplyProcessFlowRepairs, runFlowPlanProcessFlowRepairs, runFlowRegenProduct, runFlowScanProcessFlowRefs, runFlowValidateProcesses, } from './lib/flow-regen-product.js';
 import { executeRemoteCommand, getRemoteCommandHelp } from './lib/remote.js';
 import { runValidation, } from './lib/validation.js';
+import { runDatasetValidate, } from './lib/dataset-validate.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';
+import { runDatasetBilingualApply, runDatasetBilingualExtract, runDatasetBilingualValidate, } from './lib/dataset-bilingual.js';
+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';
 function renderMainHelp(dotEnvStatus) {
     return `TianGong LCA CLI
 
@@ -43,15 +61,16 @@ Design principles:
   - file-first input and JSON-first output
 
 Usage:
-  tiangong <command> [subcommand] [options]
+  tiangong-lca <command> [subcommand] [options]
 
 Commands:
 Implemented Commands:
   doctor     show environment diagnostics
   search     flow | process | lifecyclemodel
-  process    get | list | auto-build | resume-build | publish-build | save-draft | batch-build
-  flow       get | list | 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 | build-resulting-process | publish-resulting-process | orchestrate
+  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
+  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
   review     process | flow | lifecyclemodel
   publish    run
   validation run
@@ -64,40 +83,63 @@ Planned Surface (not implemented yet):
 Planned commands currently print an explicit "not implemented yet" message and exit with code 2.
 
 Examples:
-  tiangong doctor
-  tiangong search flow --input ./request.json
-  tiangong search process --input ./request.json --dry-run
-  tiangong process get --id <process-id>
-  tiangong process list --state-code 100 --limit 20
-  tiangong process auto-build --input ./pff-request.json
-  tiangong process resume-build --run-id <id>
-  tiangong process publish-build --run-id <id>
-  tiangong process save-draft --input ./patched-processes.jsonl --dry-run
-  tiangong process batch-build --input ./batch-request.json
-  tiangong lifecyclemodel auto-build --input ./lifecyclemodel-auto-build.request.json
-  tiangong lifecyclemodel validate-build --run-dir ./artifacts/lifecyclemodel_auto_build/<run_id>
-  tiangong lifecyclemodel publish-build --run-dir ./artifacts/lifecyclemodel_auto_build/<run_id>
-  tiangong lifecyclemodel orchestrate plan --input ./lifecyclemodel-orchestrate.request.json --out-dir ./artifacts/lifecyclemodel_recursive/run-001
-  tiangong flow get --id <flow-id> --version <version>
-  tiangong flow list --id <flow-id> --state-code 100 --limit 20
-  tiangong flow fetch-rows --refs-file ./flow-refs.json --out-dir ./flow-fetch
-  tiangong flow materialize-decisions --decision-file ./approved-decisions.json --flow-rows-file ./review-input-rows.jsonl --out-dir ./flow-decisions
-  tiangong flow remediate --input-file ./invalid-flows.jsonl --out-dir ./flow-remediation
-  tiangong flow publish-version --input-file ./ready-flows.jsonl --out-dir ./flow-publish --commit
-  tiangong flow publish-reviewed-data --flow-rows-file ./reviewed-flows.jsonl --original-flow-rows-file ./original-flows.jsonl --out-dir ./flow-publish-review
-  tiangong flow build-alias-map --old-flow-file ./old-flows.jsonl --new-flow-file ./new-flows.jsonl --out-dir ./flow-alias-map
-  tiangong flow scan-process-flow-refs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-scan
-  tiangong flow plan-process-flow-repairs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-repair-plan
-  tiangong flow apply-process-flow-repairs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-repair-apply
-  tiangong flow regen-product --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-regeneration --apply
-  tiangong flow validate-processes --original-processes-file ./before.jsonl --patched-processes-file ./after.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-validation
-  tiangong review process --rows-file ./processes.jsonl --out-dir ./review
-  tiangong review process --run-root ./artifacts/process_from_flow/<run_id> --run-id <run_id> --out-dir ./review
-  tiangong review flow --rows-file ./flows.json --out-dir ./review
-  tiangong review lifecyclemodel --run-dir ./artifacts/lifecyclemodel_auto_build/<run_id> --out-dir ./lifecyclemodel-review
-  tiangong publish run --input ./publish-request.json --dry-run
-  tiangong validation run --input-dir ./package --engine auto
-  tiangong admin embedding-run --input ./jobs.json
+  tiangong-lca doctor
+  tiangong-lca search flow --input ./request.json
+  tiangong-lca search process --input ./request.json --dry-run
+  tiangong-lca process get --id <process-id>
+  tiangong-lca process list --state-code 100 --limit 20
+  tiangong-lca process identity-preflight --input ./process-preflight.json --out-dir ./process-preflight
+  tiangong-lca process build-plan validate --input ./process-build-plan.json --out-dir ./process-build-plan
+  tiangong-lca process scope-statistics --out-dir /abs/path/to/process-scope --state-code 0 --state-code 100
+  tiangong-lca process dedup-review --input ./duplicate-groups.json --out-dir /abs/path/to/process-dedup
+  tiangong-lca process auto-build --input ./pff-request.json --out-dir /abs/path/to/process-run
+  tiangong-lca process resume-build --run-dir /abs/path/to/process-run
+  tiangong-lca process publish-build --run-dir /abs/path/to/process-run
+  tiangong-lca process complete-required-fields --input ./processes.jsonl --out ./processes.completed.jsonl --default-unit MJ
+  tiangong-lca process save-draft --input ./patched-processes.jsonl --out-dir /abs/path/to/process-save-draft --dry-run
+  tiangong-lca process batch-build --input ./batch-request.json --out-dir /abs/path/to/process-batch
+  tiangong-lca process refresh-references --out-dir /abs/path/to/process-refresh --dry-run
+  tiangong-lca process verify-rows --rows-file ./process-list-report.json --out-dir /abs/path/to/process-verify
+  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 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 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
+  tiangong-lca dataset bilingual validate --input ./rows/processes.translated.jsonl --type process --out-dir ./translation-validate
+  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 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
+  tiangong-lca lifecyclemodel save-draft --input ./lifecyclemodels.jsonl --out-dir /abs/path/to/lifecyclemodel-save-draft --dry-run
+  tiangong-lca lifecyclemodel graph --input ./lifecyclemodels.jsonl --out-dir /abs/path/to/lifecyclemodel-graph --format all
+  tiangong-lca lifecyclemodel orchestrate plan --input ./lifecyclemodel-orchestrate.request.json --out-dir /abs/path/to/lifecyclemodel-recursive-run
+  tiangong-lca flow get --id <flow-id> --version <version>
+  tiangong-lca flow list --id <flow-id> --state-code 100 --limit 20
+  tiangong-lca flow identity-preflight --input ./flow-preflight.json --out-dir ./flow-preflight
+  tiangong-lca flow build-plan validate --input ./flow-build-plan.json --out-dir ./flow-build-plan
+  tiangong-lca flow fetch-rows --refs-file ./flow-refs.json --out-dir ./flow-fetch
+  tiangong-lca flow materialize-decisions --decision-file ./approved-decisions.json --flow-rows-file ./review-input-rows.jsonl --out-dir ./flow-decisions
+  tiangong-lca flow remediate --input-file ./invalid-flows.jsonl --out-dir ./flow-remediation
+  tiangong-lca flow publish-version --input-file ./ready-flows.jsonl --out-dir ./flow-publish --commit
+  tiangong-lca flow publish-reviewed-data --flow-rows-file ./reviewed-flows.jsonl --original-flow-rows-file ./original-flows.jsonl --out-dir ./flow-publish-review
+  tiangong-lca flow build-alias-map --old-flow-file ./old-flows.jsonl --new-flow-file ./new-flows.jsonl --out-dir ./flow-alias-map
+  tiangong-lca flow scan-process-flow-refs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-scan
+  tiangong-lca flow plan-process-flow-repairs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-repair-plan
+  tiangong-lca flow apply-process-flow-repairs --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-repair-apply
+  tiangong-lca flow regen-product --processes-file ./processes.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-regeneration --apply
+  tiangong-lca flow validate-processes --original-processes-file ./before.jsonl --patched-processes-file ./after.jsonl --scope-flow-file ./flows.jsonl --out-dir ./flow-validation
+  tiangong-lca review process --rows-file ./processes.jsonl --out-dir ./review
+  tiangong-lca review process --run-root /abs/path/to/process-run --run-id <run_id> --out-dir ./review
+  tiangong-lca review flow --rows-file ./flows.json --out-dir ./review
+  tiangong-lca review lifecyclemodel --run-dir /abs/path/to/lifecyclemodel-run --out-dir ./lifecyclemodel-review
+  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
 
 Environment:
   .env loaded: ${dotEnvStatus.loaded ? `yes (${dotEnvStatus.path}, ${dotEnvStatus.count} keys)` : 'no'}
@@ -105,7 +147,7 @@ Environment:
 }
 function renderDoctorHelp() {
     return `Usage:
-  tiangong doctor [--json]
+  tiangong-lca doctor [--json]
 
 Options:
   --json    Print structured environment diagnostics
@@ -114,7 +156,7 @@ Options:
 }
 function renderSearchHelp() {
     return `Usage:
-  tiangong search <flow|process|lifecyclemodel> --input <file> [options]
+  tiangong-lca search <flow|process|lifecyclemodel> --input <file> [options]
 
 Options:
   --input <file>   JSON request file
@@ -139,7 +181,7 @@ Runtime note:
 }
 function renderAdminHelp() {
     return `Usage:
-  tiangong admin embedding-run --input <file> [options]
+  tiangong-lca admin embedding-run --input <file> [options]
 
 Options:
   --input <file>   JSON request file
@@ -162,7 +204,7 @@ Runtime note:
 }
 function renderPublishHelp() {
     return `Usage:
-  tiangong publish run --input <file> [options]
+  tiangong-lca publish run --input <file> [options]
 
 Options:
   --input <file>       JSON publish request file
@@ -174,11 +216,18 @@ Options:
 
 Path rule:
   Relative out_dir values from the request body or --out-dir resolve from the request file directory.
+
+Outputs written under out_dir:
+  - normalized-request.json
+  - collected-inputs.json
+  - relation-manifest.json
+  - verification-report.json
+  - publish-report.json
 `.trim();
 }
 function renderValidationHelp() {
     return `Usage:
-  tiangong validation run --input-dir <dir> [options]
+  tiangong-lca validation run --input-dir <dir> [options]
 
 Options:
   --input-dir <dir>    TIDAS package directory
@@ -188,13 +237,327 @@ Options:
   -h, --help
 `.trim();
 }
+function renderDatasetHelp() {
+    return `Usage:
+  tiangong-lca dataset <subcommand> [options]
+
+Implemented Subcommands:
+  contract get        Write TIDAS schema / methodology / ruleset contract artifacts
+  context-pack        Write an AI-ready TIDAS contract context pack
+  import-lca convert  Convert supported external LCA packages through tidas-tools
+  author              Extract source evidence and prepare TIDAS context packs for AI authoring
+  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
+  bilingual apply      Apply reviewed bilingual translations back to local rows
+  bilingual validate   Validate bilingual rows with deterministic scans and schema/review gates
+  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
+
+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 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 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
+  tiangong-lca dataset bilingual apply --input ./rows.jsonl --translations ./trans-reviewed.jsonl --out ./rows.translated.jsonl --help
+  tiangong-lca dataset bilingual validate --input ./rows.translated.jsonl --type process --out-dir ./translation-validate --help
+  tiangong-lca dataset evidence-search plan --query "中国2026年电力结构数据" --out-dir ./evidence-search --help
+  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
+`.trim();
+}
+function renderDatasetContractHelp() {
+    return `Usage:
+  tiangong-lca dataset contract get --type <type> --out-dir <dir> [options]
+
+Options:
+  --type <type>       TIDAS target type: process, flow, source, contact, unitgroup, flowproperty, lifecyclemodel, lciamethod
+  --include <list>    Comma-separated or repeatable list: schema, methodology, ruleset (default: all)
+  --profile <name>    default | ai-import (default: default)
+  --out-dir <dir>     Artifact directory
+  --json              Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/contract-manifest.json
+  - outputs/schema.json when requested and available
+  - outputs/methodology.yaml when requested and available
+  - outputs/runtime-ruleset.json when requested and available
+  - outputs/contract-report.json
+`.trim();
+}
+function renderDatasetContextPackHelp() {
+    return `Usage:
+  tiangong-lca dataset context-pack --type <type> --out-dir <dir> [options]
+
+Options:
+  --type <type>       TIDAS target type for AI authoring or repair
+  --include <list>    Comma-separated or repeatable list: schema, methodology, ruleset (default: all)
+  --profile <name>    default | ai-import (default: ai-import)
+  --out-dir <dir>     Artifact directory
+  --json              Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/contract-manifest.json
+  - outputs/schema.json
+  - outputs/methodology.yaml when available
+  - outputs/runtime-ruleset.json when available
+  - outputs/ai-context.json
+  - outputs/ai-context.md
+  - outputs/contract-report.json
+`.trim();
+}
+function renderDatasetImportLcaHelp() {
+    return `Usage:
+  tiangong-lca dataset import-lca convert --input <path> --output-dir <dir> [options]
+
+Options:
+  --input <path>          Source file, directory, or package to import
+  --output-dir <dir>      Output directory for generated package and reports
+  --from-format <format>  auto, ecospold1, ecospold2, openlca-jsonld, openlca-process-xlsx, simapro-csv
+  --target <target>       tidas | ilcd | both (default: tidas)
+  --report <file>         Conversion report path (default: <output-dir>/conversion-report.json)
+  --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)
+  --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)
+  --tidas-tools-dir <dir> Explicit tidas-tools checkout path
+  --json                  Print compact JSON
+  -h, --help
+
+Outputs written under --output-dir:
+  - conversion-report.json
+  - tidas/ when target includes TIDAS and not detect-only
+  - ilcd/ when target includes ILCD and not detect-only
+  - mapping.csv when not detect-only
+  - outputs/import-lca-report.json
+`.trim();
+}
+function renderDatasetAuthorHelp() {
+    return `Usage:
+  tiangong-lca dataset author --input <file> --target-types <types> --out-dir <dir> [options]
+
+Options:
+  --input <file>          PDF, Excel, image, markdown, or source document file
+  --target-types <list>   Comma-separated or repeatable TIDAS types, for example process,flow,source
+  --out-dir <dir>         Artifact directory
+  --prompt <text>         Optional extraction prompt passed to the unstructured parser
+  --provider <name>       Optional unstructured parser provider override
+  --model <name>          Optional unstructured parser model override
+  --timeout-ms <n>        Parser timeout in milliseconds (default: 120000)
+  --json                  Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/source-extract.json
+  - context/<type>/outputs/contract-manifest.json
+  - context/<type>/outputs/ai-context.json
+  - outputs/authoring-report.json
+
+Environment:
+  TIANGONG_LCA_UNSTRUCTURED_API_BASE_URL and TIANGONG_LCA_UNSTRUCTURED_API_KEY
+`.trim();
+}
+function renderDatasetRemoteVerifyHelp() {
+    return `Usage:
+  tiangong-lca dataset verify-remote --input <file> --out-dir <dir> [options]
+
+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)
+  --json                 Print compact JSON
+  -h, --help
+
+Environment:
+  TIANGONG_LCA_API_BASE_URL, TIANGONG_LCA_API_KEY, and TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY
+
+Outputs written under --out-dir:
+  - outputs/remote-verification-report.json
+  - outputs/remote-verification.jsonl
+  - outputs/blockers.jsonl
+`.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)
+  --out-dir <dir>  Optional artifact directory for validation report and row splits
+  --json           Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/validation-report.json
+  - outputs/valid-rows.jsonl
+  - outputs/invalid-rows.jsonl
+`.trim();
+}
+function renderDatasetBilingualHelp() {
+    return `Usage:
+  tiangong-lca dataset bilingual <extract|apply|validate> [options]
+
+Subcommands:
+  extract    Extract trans-units.jsonl from process/flow/lifecyclemodel rows
+  apply      Apply reviewed translations to rows and write translation-evidence.json
+  validate   Run placeholder/mixed-language scans plus schema and process/flow review gates
+
+Examples:
+  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
+  tiangong-lca dataset bilingual validate --input ./rows/processes.translated.jsonl --type process --out-dir ./translation-validate
+`.trim();
+}
+function renderDatasetBilingualExtractHelp() {
+    return `Usage:
+  tiangong-lca dataset bilingual extract --input <file> [options]
+
+Options:
+  --input <file>        Local rows as JSON or JSONL
+  --type <type>         auto | flow | process | lifecyclemodel (default: auto)
+  --source-lang <lang>  Source language code (default: en)
+  --target-lang <lang>  Target language code (default: zh)
+  --out-dir <dir>       Artifact directory for trans-units.jsonl and extract-report.json
+  --json                Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/trans-units.jsonl
+  - outputs/extract-report.json
+`.trim();
+}
+function renderDatasetBilingualApplyHelp() {
+    return `Usage:
+  tiangong-lca dataset bilingual apply --input <file> --translations <file> --out <file> [options]
+
+Options:
+  --input <file>         Local rows as JSON or JSONL
+  --translations <file>  Reviewed translation JSONL from extract units
+  --out <file>           Output JSONL with translations applied
+  --target-lang <lang>   Target language code (default: zh)
+  --out-dir <dir>        Optional artifact directory; defaults to the output file directory
+  --json                 Print compact JSON
+  -h, --help
+
+Translation row fields:
+  unit_id, row_index, field_path, source_lang, target_lang, source_text, translated_text,
+  basis, review_status, reviewer
+
+Outputs:
+  - translated rows at --out
+  - outputs/translation-evidence.json
+  - outputs/bilingual-apply-report.json
+`.trim();
+}
+function renderDatasetBilingualValidateHelp() {
+    return `Usage:
+  tiangong-lca dataset bilingual validate --input <file> [options]
+
+Options:
+  --input <file>   Local rows as JSON or JSONL
+  --type <type>    auto | flow | process | lifecyclemodel (default: auto)
+  --out-dir <dir>  Artifact directory for scan, schema, and review outputs
+  --json           Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/bilingual-validate-report.json
+  - outputs/bilingual-findings.jsonl
+  - schema/outputs/validation-report.json
+  - review/process/... and/or review/flow/... when applicable
+`.trim();
+}
+function renderDatasetEvidenceSearchHelp() {
+    return `Usage:
+  tiangong-lca dataset evidence-search <plan|run> [options]
+
+Plan:
+  tiangong-lca dataset evidence-search plan --query <text> --out-dir <dir>
+
+Run:
+  tiangong-lca dataset evidence-search run --input <request.json> --results <search-results.json> --out-dir <dir>
+  tiangong-lca dataset evidence-search run --query <text> --provider-url <url> --out-dir <dir>
+
+Options:
+  --query <text>             Evidence question when no --input is supplied
+  --input <file>             JSON request with question, field, budget, preferred_domains, and required_evidence
+  --results <file>           Normalized external search results JSON/JSONL captured from web/search tools
+  --provider-url <url>       Optional generic JSON search provider endpoint
+  --provider-key <key>       Optional bearer token for --provider-url
+  --profile <profile>        shallow | balanced | deep (default: balanced)
+  --max-queries <n>          Override query budget
+  --max-results-per-query <n> Override per-query result budget
+  --timeout-ms <n>           Provider request timeout in milliseconds
+  --out-dir <dir>            Artifact directory
+  --json                     Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/evidence-search-plan.json
+  - outputs/evidence-search-results.jsonl
+  - outputs/evidence-search-report.json
+  - outputs/evidence-search-declaration.json when evidence is absent or only partial
+`.trim();
+}
+function renderDatasetReferencesHelp() {
+    return `Usage:
+  tiangong-lca dataset references <rewrite|refresh-remote> [options]
+
+Rewrite:
+  tiangong-lca dataset references rewrite --input <file> --from flow:<id>[@<version>] --to flow:<id>[@<version>] [options]
+
+Refresh remote versions:
+  tiangong-lca dataset references refresh-remote --input <file> --out <file> --out-dir <dir> [options]
+
+Options:
+  --input <file>   Local rows as JSON or JSONL; process and lifecyclemodel rows are supported
+  --from <ref>     Source flow reference, for example flow:<old-id>@01.00.000
+  --to <ref>       Target flow reference, for example flow:<new-id>@01.01.000
+  --out <file>           Output JSONL path for refresh-remote patched rows
+  --root-policy <mode>   existing | candidate for refresh-remote root rows (default: existing)
+  --type <type>          Repeatable row type filter: process | lifecyclemodel (default: both)
+  --types <csv>          Comma-separated alias for one or more row types
+  --scope <label>        Optional artifact label for the already-frozen input scope
+  --out-dir <dir>        Artifact directory for rewrite plan and patched rows
+  --commit               Execute state-aware save-draft writes for patched rows
+  --dry-run              Keep the command local-only (default)
+  --json                 Print compact JSON
+  -h, --help
+
+Environment:
+  none for local dry-run
+  TIANGONG_LCA_API_BASE_URL, TIANGONG_LCA_API_KEY, and TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY
+  when --commit executes remote writes
+
+Outputs written under --out-dir:
+  - outputs/patched-rows.jsonl
+  - outputs/rewrite-plan.json
+  - outputs/summary.json
+  - outputs/remote-refresh-report.json
+  - outputs/remote-refresh-patches.jsonl
+  - pre-refresh-verify/outputs/remote-verification-report.json
+  - post-refresh-verify/outputs/remote-verification-report.json
+`.trim();
+}
 function renderFlowHelp() {
     return `Usage:
-  tiangong flow <subcommand> [options]
+  tiangong-lca flow <subcommand> [options]
 
 Implemented Subcommands:
   get          Load one flow dataset by identifier through direct Supabase access
   list         Enumerate flow datasets through direct Supabase access with deterministic filters
+  identity-preflight Compare one target flow against local candidates before generation
+  build-plan  Validate or materialize a flow build plan into gate artifacts
   fetch-rows   Materialize real DB flow refs into local review-input rows and fetch artifacts
   materialize-decisions Materialize approved merge decisions into canonical-map, rewrite-plan, and seed artifacts
   remediate    Deterministically repair invalid local flow rows and emit artifact-first outputs
@@ -208,25 +571,73 @@ Implemented Subcommands:
   validate-processes Validate locally patched process rows against allowed flow-reference-only changes
 
 Examples:
-  tiangong flow --help
-  tiangong flow get --help
-  tiangong flow list --help
-  tiangong flow fetch-rows --help
-  tiangong flow materialize-decisions --help
-  tiangong flow remediate --help
-  tiangong flow publish-version --help
-  tiangong flow publish-reviewed-data --help
-  tiangong flow build-alias-map --help
-  tiangong flow scan-process-flow-refs --help
-  tiangong flow plan-process-flow-repairs --help
-  tiangong flow apply-process-flow-repairs --help
-  tiangong flow regen-product --help
-  tiangong flow validate-processes --help
+  tiangong-lca flow --help
+  tiangong-lca flow get --help
+  tiangong-lca flow list --help
+  tiangong-lca flow identity-preflight --help
+  tiangong-lca flow build-plan validate --help
+  tiangong-lca flow fetch-rows --help
+  tiangong-lca flow materialize-decisions --help
+  tiangong-lca flow remediate --help
+  tiangong-lca flow publish-version --help
+  tiangong-lca flow publish-reviewed-data --help
+  tiangong-lca flow build-alias-map --help
+  tiangong-lca flow scan-process-flow-refs --help
+  tiangong-lca flow plan-process-flow-repairs --help
+  tiangong-lca flow apply-process-flow-repairs --help
+  tiangong-lca flow regen-product --help
+  tiangong-lca flow validate-processes --help
+`.trim();
+}
+function renderFlowBuildPlanHelp() {
+    return `Usage:
+  tiangong-lca flow build-plan <validate|materialize> --input <file> [options]
+
+Options:
+  --input <file>     JSON flow build plan; materialize writes a canonical flowDataSet
+  --out-dir <dir>    Optional artifact directory for gate outputs
+  --report-only      Print blocker reports with exit code 0
+  --json             Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/build-plan-gate-report.json
+  - outputs/materialized-flow.json
+`.trim();
+}
+function renderFlowIdentityPreflightHelp() {
+    return `Usage:
+  tiangong-lca flow identity-preflight --input <file> [options]
+
+Options:
+  --input <file>   JSON preflight request with target flow and optional candidates
+  --candidate-input <path>
+                   Optional JSON/JSONL file or directory of candidate flow rows; repeatable
+  --remote-candidates
+                   Also fetch candidate rows from flow_hybrid_search
+  --remote-query <text>
+                   Override the remote search query; defaults to target identity text
+  --remote-limit <n>
+                   Limit remote candidate rows after fetch
+  --out-dir <dir>  Optional artifact directory for identity decision outputs
+  --json           Print compact JSON
+  -h, --help
+
+Input contract:
+  {
+    "target": { "...": "flow target or canonical flowDataSet" },
+    "candidates": [{ "...": "existing flow row or canonical flowDataSet" }]
+  }
+
+Outputs written under --out-dir:
+  - outputs/identity-decision.json
+  - outputs/identity-candidates.jsonl
+  - outputs/identity-candidate-sources.json
 `.trim();
 }
 function renderFlowGetHelp() {
     return `Usage:
-  tiangong flow get --id <flow-id> [options]
+  tiangong-lca flow get --id <flow-id> [options]
 
 Options:
   --id <flow-id>        Flow UUID
@@ -248,7 +659,7 @@ Runtime note:
 }
 function renderFlowListHelp() {
     return `Usage:
-  tiangong flow list [options]
+  tiangong-lca flow list [options]
 
 Options:
   --id <flow-id>                  Repeatable exact flow UUID filter
@@ -276,7 +687,7 @@ Runtime note:
 }
 function renderFlowRemediateHelp() {
     return `Usage:
-  tiangong flow remediate --input-file <file> --out-dir <dir> [options]
+  tiangong-lca flow remediate --input-file <file> --out-dir <dir> [options]
 
 Options:
   --input-file <file>  Invalid flow rows as JSON or JSONL
@@ -295,7 +706,7 @@ Outputs written under --out-dir:
 }
 function renderFlowFetchRowsHelp() {
     return `Usage:
-  tiangong flow fetch-rows --refs-file <file> --out-dir <dir> [options]
+  tiangong-lca flow fetch-rows --refs-file <file> --out-dir <dir> [options]
 
 Options:
   --refs-file <file>         Flow refs as JSON or JSONL
@@ -320,7 +731,7 @@ Outputs written under --out-dir:
 }
 function renderFlowMaterializeDecisionsHelp() {
     return `Usage:
-  tiangong flow materialize-decisions --decision-file <file> --flow-rows-file <file> --out-dir <dir> [options]
+  tiangong-lca flow materialize-decisions --decision-file <file> --flow-rows-file <file> --out-dir <dir> [options]
 
 Options:
   --decision-file <file>     Approved cluster decisions as JSON or JSONL
@@ -339,7 +750,7 @@ Outputs written under --out-dir:
 }
 function renderFlowPublishVersionHelp() {
     return `Usage:
-  tiangong flow publish-version --input-file <file> --out-dir <dir> [options]
+  tiangong-lca flow publish-version --input-file <file> --out-dir <dir> [options]
 
 Options:
   --input-file <file>       Ready-for-publish flow rows as JSON or JSONL
@@ -360,12 +771,13 @@ Environment:
 Outputs written under --out-dir:
   - flows_tidas_sdk_plus_classification_mcp_success_list.json
   - flows_tidas_sdk_plus_classification_remote_validation_failed.jsonl
+  - flow-publish-version-gate-report.json
   - flows_tidas_sdk_plus_classification_mcp_sync_report.json
 `.trim();
 }
 function renderFlowPublishReviewedDataHelp() {
     return `Usage:
-  tiangong flow publish-reviewed-data --out-dir <dir> [--flow-rows-file <file>] [--process-rows-file <file>] [options]
+  tiangong-lca flow publish-reviewed-data --out-dir <dir> [--flow-rows-file <file>] [--process-rows-file <file>] [options]
 
 Options:
   --flow-rows-file <file>           Reviewed flow rows as JSON or JSONL
@@ -395,12 +807,13 @@ Outputs written under --out-dir:
   - publish-report.json
   - flows_tidas_sdk_plus_classification_mcp_success_list.json
   - flows_tidas_sdk_plus_classification_remote_validation_failed.jsonl
+  - flow-publish-version-gate-report.json
   - flows_tidas_sdk_plus_classification_mcp_sync_report.json
 `.trim();
 }
 function renderFlowBuildAliasMapHelp() {
     return `Usage:
-  tiangong flow build-alias-map --old-flow-file <file> --new-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow build-alias-map --old-flow-file <file> --new-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --old-flow-file <file>          Repeatable pre-governance flow snapshot as JSON or JSONL
@@ -420,7 +833,7 @@ Outputs written under --out-dir:
 }
 function renderFlowScanProcessFlowRefsHelp() {
     return `Usage:
-  tiangong flow scan-process-flow-refs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow scan-process-flow-refs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --processes-file <file>         Process rows as JSON or JSONL
@@ -441,7 +854,7 @@ Outputs written under --out-dir:
 }
 function renderFlowPlanProcessFlowRepairsHelp() {
     return `Usage:
-  tiangong flow plan-process-flow-repairs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow plan-process-flow-repairs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --processes-file <file>         Process rows as JSON or JSONL
@@ -462,7 +875,7 @@ Outputs written under --out-dir:
 }
 function renderFlowApplyProcessFlowRepairsHelp() {
     return `Usage:
-  tiangong flow apply-process-flow-repairs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow apply-process-flow-repairs --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --processes-file <file>         Process rows as JSON or JSONL
@@ -486,7 +899,7 @@ Outputs written under --out-dir:
 }
 function renderFlowRegenProductHelp() {
     return `Usage:
-  tiangong flow regen-product --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow regen-product --processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --processes-file <file>         Process rows as JSON or JSONL
@@ -512,7 +925,7 @@ Outputs written under --out-dir:
 }
 function renderFlowValidateProcessesHelp() {
     return `Usage:
-  tiangong flow validate-processes --original-processes-file <file> --patched-processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
+  tiangong-lca flow validate-processes --original-processes-file <file> --patched-processes-file <file> --scope-flow-file <file> --out-dir <dir> [options]
 
 Options:
   --original-processes-file <file>  Original process rows before repair as JSON or JSONL
@@ -530,7 +943,7 @@ Outputs written under --out-dir:
 }
 function renderReviewHelp() {
     return `Usage:
-  tiangong review <subcommand> [options]
+  tiangong-lca review <subcommand> [options]
 
 Implemented Subcommands:
   process      Review process build runs or rows-file snapshots and emit artifact-first findings
@@ -538,15 +951,15 @@ Implemented Subcommands:
   lifecyclemodel Review one local lifecyclemodel build run and emit artifact-first findings
 
 Examples:
-  tiangong review --help
-  tiangong review process --help
-  tiangong review flow --help
-  tiangong review lifecyclemodel --help
+  tiangong-lca review --help
+  tiangong-lca review process --help
+  tiangong-lca review flow --help
+  tiangong-lca review lifecyclemodel --help
 `.trim();
 }
 function renderReviewProcessHelp() {
     return `Usage:
-  tiangong review process (--rows-file <file> | --run-root <dir>) --out-dir <dir> [options]
+  tiangong-lca review process (--rows-file <file> | --run-root <dir>) --out-dir <dir> [options]
 
 Options:
   --rows-file <file>        Process rows JSON/JSONL file; full process list reports with rows[] are also accepted
@@ -565,7 +978,7 @@ Options:
 }
 function renderReviewFlowHelp() {
     return `Usage:
-  tiangong review flow (--rows-file <file> | --flows-dir <dir> | --run-root <dir>) --out-dir <dir> [options]
+  tiangong-lca review flow (--rows-file <file> | --flows-dir <dir> | --run-root <dir>) --out-dir <dir> [options]
 
 Options:
   --rows-file <file>        Flow rows JSON / JSONL file; the CLI materializes review-input/flows automatically
@@ -588,7 +1001,7 @@ Options:
 }
 function renderReviewLifecyclemodelHelp() {
     return `Usage:
-  tiangong review lifecyclemodel --run-dir <dir> --out-dir <dir> [options]
+  tiangong-lca review lifecyclemodel --run-dir <dir> --out-dir <dir> [options]
 
 Options:
   --run-dir <dir>          Existing lifecyclemodel auto-build run directory
@@ -607,7 +1020,7 @@ This command:
 }
 function renderLifecyclemodelBuildResultingProcessHelp() {
     return `Usage:
-  tiangong lifecyclemodel build-resulting-process --input <file> [options]
+  tiangong-lca lifecyclemodel build-resulting-process --input <file> [options]
 
 Options:
   --input <file>     JSON request file
@@ -623,7 +1036,7 @@ Remote lookup env (only when process_sources.allow_remote_lookup=true):
 }
 function renderLifecyclemodelPublishResultingProcessHelp() {
     return `Usage:
-  tiangong lifecyclemodel publish-resulting-process --run-dir <dir> [options]
+  tiangong-lca lifecyclemodel publish-resulting-process --run-dir <dir> [options]
 
 Options:
   --run-dir <dir>         Existing lifecyclemodel resulting-process run directory
@@ -633,30 +1046,83 @@ Options:
   -h, --help
 `.trim();
 }
+function renderLifecyclemodelSaveDraftHelp() {
+    return `Usage:
+  tiangong-lca lifecyclemodel save-draft --input <file> [options]
+
+Options:
+  --input <file>     Lifecyclemodel rows JSON/JSONL file or publish-request.json
+  --out-dir <dir>    Run root written relative to cwd when a relative path is passed
+  --commit           Execute remote save-draft writes
+  --dry-run          Keep the command local-only (default)
+  --json             Print compact JSON
+  -h, --help
+
+Environment:
+  none for local dry-run
+  TIANGONG_LCA_API_BASE_URL, TIANGONG_LCA_API_KEY, and TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY
+  when --commit executes remote writes
+
+Local gate:
+  canonical lifecyclemodel payloads are validated against LifeCycleModelSchema before any remote write;
+  schema-invalid rows stay in failures.jsonl instead of being committed
+
+Outputs written under --out-dir:
+  - inputs/normalized-input.json
+  - outputs/save-draft-bundle/selected-lifecyclemodels.jsonl
+  - outputs/save-draft-bundle/progress.jsonl
+  - outputs/save-draft-bundle/failures.jsonl
+  - outputs/save-draft-bundle/summary.json
+`.trim();
+}
+function renderLifecyclemodelGraphHelp() {
+    return `Usage:
+  tiangong-lca lifecyclemodel graph --input <file> [options]
+
+Options:
+  --input <file>          Lifecyclemodel rows JSON/JSONL file
+  --out-dir <dir>         Artifact directory for graph files and findings
+  --format <format>       json | dot | svg | all (default: all)
+  --check-connections     Fail when process-instance links are missing or unresolved
+  --json                  Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/graph-report.json
+  - outputs/findings.jsonl
+  - graphs/*.json
+  - graphs/*.dot
+  - graphs/*.svg
+`.trim();
+}
 function renderLifecyclemodelHelp() {
     return `Usage:
-  tiangong lifecyclemodel <subcommand> [options]
+  tiangong-lca lifecyclemodel <subcommand> [options]
 
 Implemented Subcommands:
   auto-build                Build native lifecyclemodel json_ordered artifacts from local process run exports
   validate-build            Re-run local validation on one lifecyclemodel build run
   publish-build             Prepare lifecyclemodel publish handoff artifacts from one local build run
+  save-draft                Save canonical lifecyclemodel datasets through the bundle save path
+  graph                     Derive lifecyclemodel graph artifacts and connection findings
   build-resulting-process   Deterministically aggregate a lifecycle model into a resulting process bundle
   publish-resulting-process Prepare publish-bundle.json and publish-intent.json from a prior resulting-process run
   orchestrate               Plan, execute, or publish a recursive lifecyclemodel assembly run
 
 Examples:
-  tiangong lifecyclemodel --help
-  tiangong lifecyclemodel auto-build --help
-  tiangong lifecyclemodel validate-build --help
-  tiangong lifecyclemodel publish-build --help
-  tiangong lifecyclemodel build-resulting-process --help
-  tiangong lifecyclemodel orchestrate --help
+  tiangong-lca lifecyclemodel --help
+  tiangong-lca lifecyclemodel auto-build --help
+  tiangong-lca lifecyclemodel validate-build --help
+  tiangong-lca lifecyclemodel publish-build --help
+  tiangong-lca lifecyclemodel save-draft --help
+  tiangong-lca lifecyclemodel graph --help
+  tiangong-lca lifecyclemodel build-resulting-process --help
+  tiangong-lca lifecyclemodel orchestrate --help
 `.trim();
 }
 function renderLifecyclemodelOrchestrateHelp() {
     return `Usage:
-  tiangong lifecyclemodel orchestrate <plan|execute|publish> [options]
+  tiangong-lca lifecyclemodel orchestrate <plan|execute|publish> [options]
 
 Plan / execute options:
   --input <file>                           JSON request file
@@ -682,11 +1148,11 @@ This command:
 }
 function renderLifecyclemodelAutoBuildHelp() {
     return `Usage:
-  tiangong lifecyclemodel auto-build --input <file> [options]
+  tiangong-lca lifecyclemodel auto-build --input <file> [options]
 
 Options:
   --input <file>     JSON request file
-  --out-dir <dir>    Override the default lifecyclemodel build run root
+  --out-dir <dir>    Explicit run root; otherwise request.out_dir is required
   --json             Print compact JSON
   -h, --help
 
@@ -696,6 +1162,7 @@ Minimal request contract:
   }
 
 This first CLI slice is local-only and read-only:
+  - applies no implicit repo-local ./artifacts fallback; callers must provide a run root
   - loads local process build run directories
   - infers the process graph from shared flow UUIDs
   - emits native lifecyclemodel json_ordered artifacts
@@ -704,7 +1171,7 @@ This first CLI slice is local-only and read-only:
 }
 function renderLifecyclemodelValidateBuildHelp() {
     return `Usage:
-  tiangong lifecyclemodel validate-build --run-dir <dir> [options]
+  tiangong-lca lifecyclemodel validate-build --run-dir <dir> [options]
 
 Options:
   --run-dir <dir>    Existing lifecyclemodel auto-build run directory
@@ -720,7 +1187,7 @@ This command:
 }
 function renderLifecyclemodelPublishBuildHelp() {
     return `Usage:
-  tiangong lifecyclemodel publish-build --run-dir <dir> [options]
+  tiangong-lca lifecyclemodel publish-build --run-dir <dir> [options]
 
 Options:
   --run-dir <dir>    Existing lifecyclemodel auto-build run directory
@@ -730,24 +1197,26 @@ Options:
 This command:
   - collects native lifecyclemodel json_ordered payloads from one local build run
   - writes publish-bundle.json, publish-request.json, and publish-intent.json
-  - keeps actual dry-run / commit execution in tiangong publish run
+  - keeps actual dry-run / commit execution in tiangong-lca publish run
   - routes lifecyclemodel commit through save_lifecycle_model_bundle internally
 `.trim();
 }
 function renderProcessAutoBuildHelp() {
     return `Usage:
-  tiangong process auto-build --input <file> [options]
+  tiangong-lca process auto-build --input <file> [options]
 
 Options:
   --input <file>     JSON request file
-  --out-dir <dir>    Override the default run root directory
+  --out-dir <dir>    Explicit run root; otherwise request.workspace_run_root is required
   --json             Print compact JSON
   -h, --help
+
+This command applies no implicit repo-local ./artifacts fallback.
 `.trim();
 }
 function renderProcessGetHelp() {
     return `Usage:
-  tiangong process get --id <process-id> [options]
+  tiangong-lca process get --id <process-id> [options]
 
 Options:
   --id <process-id>    Process UUID
@@ -767,7 +1236,7 @@ Runtime note:
 }
 function renderProcessListHelp() {
     return `Usage:
-  tiangong process list [options]
+  tiangong-lca process list [options]
 
 Options:
   --id <process-id>               Repeatable exact process UUID filter
@@ -792,31 +1261,132 @@ Runtime note:
   and authenticates that client with the resolved user access token.
 `.trim();
 }
+function renderProcessScopeStatisticsHelp() {
+    return `Usage:
+  tiangong-lca process scope-statistics --out-dir <dir> [options]
+
+Options:
+  --out-dir <dir>          Artifact root to write inputs/outputs/reports
+  --scope <name>           visible | current-user (default: visible)
+  --state-code <code>      Repeatable non-negative integer state code filter
+  --state-codes <csv>      Comma-separated alias for one or more state codes
+  --page-size <n>          Remote page size (default: 200)
+  --reuse-snapshot         Reuse inputs/processes.snapshot.rows.jsonl instead of refetching
+  --json                   Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - inputs/processes.snapshot.manifest.json
+  - inputs/processes.snapshot.rows.jsonl
+  - outputs/process-scope-summary.json
+  - outputs/domain-summary.json
+  - outputs/craft-summary.json
+  - outputs/product-summary.json
+  - outputs/type-of-dataset-summary.json
+  - reports/process-scope-statistics.md
+  - reports/process-scope-statistics.zh-CN.md
+`.trim();
+}
+function renderProcessIdentityPreflightHelp() {
+    return `Usage:
+  tiangong-lca process identity-preflight --input <file> [options]
+
+Options:
+  --input <file>   JSON preflight request with target process and optional candidates
+  --candidate-input <path>
+                   Optional JSON/JSONL file or directory of candidate process rows; repeatable
+  --remote-candidates
+                   Also fetch candidate rows from process_hybrid_search
+  --remote-query <text>
+                   Override the remote search query; defaults to target identity text
+  --remote-limit <n>
+                   Limit remote candidate rows after fetch
+  --out-dir <dir>  Optional artifact directory for identity decision outputs
+  --json           Print compact JSON
+  -h, --help
+
+Input contract:
+  {
+    "target": { "...": "process target or canonical processDataSet" },
+    "candidates": [{ "...": "existing process row or canonical processDataSet" }]
+  }
+
+Outputs written under --out-dir:
+  - outputs/identity-decision.json
+  - outputs/identity-candidates.jsonl
+  - outputs/identity-candidate-sources.json
+`.trim();
+}
+function renderProcessDedupReviewHelp() {
+    return `Usage:
+  tiangong-lca process dedup-review --input <file> --out-dir <dir> [options]
+
+Options:
+  --input <file>           Grouped duplicate-candidate JSON input
+  --out-dir <dir>          Artifact root to write inputs/outputs
+  --skip-remote            Skip optional TianGong remote enrichment and reference scans
+  --json                   Print compact JSON
+  -h, --help
+
+Input contract:
+  {
+    "source_label": "duplicate-processes-export",
+    "groups": [
+      {
+        "group_id": 1,
+        "processes": [
+          {
+            "process_id": "proc-1",
+            "version": "01.00.000",
+            "name_en": "Example",
+            "name_zh": "示例",
+            "sheet_exchange_rows": [
+              {
+                "flow_id": "flow-1",
+                "direction": "Input",
+                "mean_amount": "1",
+                "resulting_amount": "1"
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+
+Outputs written under --out-dir:
+  - inputs/dedup-input.manifest.json
+  - inputs/processes.remote-metadata.json (when remote enrichment succeeds)
+  - outputs/duplicate-groups.json
+  - outputs/delete-plan.json
+  - outputs/current-user-reference-scan.json (when reference scan succeeds)
+`.trim();
+}
 function renderProcessResumeBuildHelp() {
     return `Usage:
-  tiangong process resume-build [--run-id <id>] [--run-dir <dir>] [options]
+  tiangong-lca process resume-build --run-dir <dir> [options]
 
 Options:
-  --run-id <id>      Existing process build run id
   --run-dir <dir>    Existing process build run directory
+  --run-id <id>      Optional run id consistency check
   --json             Print compact JSON
   -h, --help
 `.trim();
 }
 function renderProcessPublishBuildHelp() {
     return `Usage:
-  tiangong process publish-build [--run-id <id>] [--run-dir <dir>] [options]
+  tiangong-lca process publish-build --run-dir <dir> [options]
 
 Options:
-  --run-id <id>      Existing process build run id
   --run-dir <dir>    Existing process build run directory
+  --run-id <id>      Optional run id consistency check
   --json             Print compact JSON
   -h, --help
 `.trim();
 }
 function renderProcessSaveDraftHelp() {
     return `Usage:
-  tiangong process save-draft --input <file> [options]
+  tiangong-lca process save-draft --input <file> [options]
 
 Options:
   --input <file>     Process rows JSON/JSONL file or publish-request.json
@@ -831,6 +1401,10 @@ Environment:
   TIANGONG_LCA_API_BASE_URL, TIANGONG_LCA_API_KEY, and TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY
   when --commit executes remote writes
 
+Local gate:
+  canonical process payloads are validated against ProcessSchema before any remote write;
+  schema-invalid rows stay in failures.jsonl instead of being committed
+
 Outputs written under --out-dir:
   - inputs/normalized-input.json
   - outputs/save-draft-rpc/selected-processes.jsonl
@@ -839,39 +1413,145 @@ Outputs written under --out-dir:
   - outputs/save-draft-rpc/summary.json
 `.trim();
 }
+function renderProcessRequiredFieldsHelp() {
+    return `Usage:
+  tiangong-lca process complete-required-fields --input <file> --out <file> [options]
+
+Options:
+  --input <file>        Process rows JSON/JSONL file
+  --out <file>          Output JSONL with required fields completed
+  --out-dir <dir>       Optional artifact directory for report and evidence
+  --flows <file>        Optional flow rows JSON/JSONL used to infer reference-flow units
+  --default-unit <unit> Unit suffix to use when it cannot be inferred (default: unit)
+  --json                Print compact JSON
+  -h, --help
+
+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.
+
+Outputs:
+  - completed rows at --out
+  - outputs/process-required-fields-report.json
+  - outputs/process-required-fields-evidence.jsonl
+`.trim();
+}
+function renderProcessRefreshReferencesHelp() {
+    return `Usage:
+  tiangong-lca process refresh-references --out-dir <dir> [options]
+
+Options:
+  --out-dir <dir>      Artifact root for manifest, progress, blockers, and reports
+  --apply              Commit state-aware draft writes after local validation passes
+  --dry-run            Refresh references locally only (default)
+  --reuse-manifest     Reuse inputs/processes.manifest.json instead of refetching the owner snapshot
+  --limit <n>          Process at most n manifest rows
+  --page-size <n>      Snapshot page size (default: 500)
+  --concurrency <n>    Parallel row workers (default: 1, max: 8)
+  --json               Print compact JSON
+  -h, --help
+
+Required env:
+  TIANGONG_LCA_API_BASE_URL
+  TIANGONG_LCA_API_KEY
+  TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY
+
+Guardrails:
+  - refresh only the current authenticated user's process snapshot
+  - skip rows with state_code >= 20 instead of forcing an unsupported write path
+  - block remote writes when ProcessSchema validation fails or references stay unresolved
+  - never requires raw SUPABASE_EMAIL / SUPABASE_PASSWORD in the skill layer
+
+Outputs written under --out-dir:
+  - inputs/processes.manifest.json
+  - outputs/progress.jsonl
+  - outputs/errors.jsonl
+  - outputs/validation-blockers.jsonl
+  - outputs/summary.json
+  - reports/process-refresh-references.md
+`.trim();
+}
+function renderProcessVerifyRowsHelp() {
+    return `Usage:
+  tiangong-lca process verify-rows --rows-file <file> --out-dir <dir> [options]
+
+Options:
+  --rows-file <file>   Raw process rows JSON/JSONL file; full process list reports with rows[] are also accepted
+  --out-dir <dir>      Output directory for summary and verification JSONL artifacts
+  --json               Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/summary.json
+  - outputs/verification.jsonl
+`.trim();
+}
 function renderProcessBatchBuildHelp() {
     return `Usage:
-  tiangong process batch-build --input <file> [options]
+  tiangong-lca process batch-build --input <file> [options]
 
 Options:
   --input <file>     JSON batch manifest file
-  --out-dir <dir>    Override the batch artifact output directory
+  --out-dir <dir>    Explicit batch root; otherwise request.out_dir is required
   --json             Print compact JSON
   -h, --help
+
+This command applies no implicit repo-local ./artifacts fallback.
 `.trim();
 }
 function renderProcessHelp() {
     return `Usage:
-  tiangong process <subcommand> [options]
+  tiangong-lca process <subcommand> [options]
 
 Implemented Subcommands:
   get          Load one process dataset by identifier through direct Supabase access
   list         List visible process rows through direct Supabase access
+  identity-preflight Compare one target process against local candidates before generation
+  build-plan  Validate or materialize a process build plan into gate artifacts
+  scope-statistics Count repeatable coverage statistics from visible or owner-filtered process snapshots
+  dedup-review Review grouped duplicate process candidates and emit keep/delete evidence
   auto-build   Prepare a local process-from-flow run scaffold and artifact workspace
   resume-build Prepare a local resume handoff from one existing process build run
   publish-build Prepare publish handoff artifacts from one existing process build run
+  complete-required-fields Complete deterministic required authoring fields in process rows
   save-draft   Save canonical process datasets through the state-aware draft-maintenance path
   batch-build  Run multiple process auto-build requests through one batch-oriented CLI surface
+  refresh-references Refresh current-user process references to the latest reachable dataset versions
+  verify-rows  Re-validate fetched process rows and required naming fields locally
 
 Examples:
-  tiangong process --help
-  tiangong process get --id <process-id>
-  tiangong process list --state-code 100 --limit 20 --help
-  tiangong process auto-build --help
-  tiangong process resume-build --run-id <id> --help
-  tiangong process publish-build --run-id <id> --help
-  tiangong process save-draft --input ./patched-processes.jsonl --help
-  tiangong process batch-build --input ./batch-request.json --help
+  tiangong-lca process --help
+  tiangong-lca process get --id <process-id>
+  tiangong-lca process list --state-code 100 --limit 20 --help
+  tiangong-lca process identity-preflight --input ./process-preflight.json --help
+  tiangong-lca process build-plan validate --input ./process-build-plan.json --help
+  tiangong-lca process scope-statistics --out-dir ./process-scope --state-code 0 --state-code 100 --help
+  tiangong-lca process dedup-review --input ./duplicate-groups.json --out-dir ./process-dedup --help
+  tiangong-lca process auto-build --help
+  tiangong-lca process resume-build --run-dir /abs/path/to/process-run --help
+  tiangong-lca process publish-build --run-dir /abs/path/to/process-run --help
+  tiangong-lca process complete-required-fields --input ./processes.jsonl --out ./processes.completed.jsonl --help
+  tiangong-lca process save-draft --input ./patched-processes.jsonl --help
+  tiangong-lca process batch-build --input ./batch-request.json --help
+  tiangong-lca process refresh-references --out-dir ./process-refresh --help
+  tiangong-lca process verify-rows --rows-file ./process-list-report.json --out-dir ./process-verify --help
+`.trim();
+}
+function renderProcessBuildPlanHelp() {
+    return `Usage:
+  tiangong-lca process build-plan <validate|materialize> --input <file> [options]
+
+Options:
+  --input <file>     JSON process build plan; materialize writes a canonical processDataSet
+  --out-dir <dir>    Optional artifact directory for gate outputs
+  --report-only      Print blocker reports with exit code 0
+  --json             Print compact JSON
+  -h, --help
+
+Outputs written under --out-dir:
+  - outputs/build-plan-gate-report.json
+  - outputs/materialized-process.json
 `.trim();
 }
 function renderDoctorText(report) {
@@ -1079,7 +1759,7 @@ function parseValidationFlags(args) {
         reportFile: typeof values['report-file'] === 'string' ? values['report-file'] : null,
     };
 }
-function parseFlowRemediateFlags(args) {
+function parseDatasetValidateFlags(args) {
     let values;
     try {
         ({ values } = parseArgs({
@@ -1089,7 +1769,8 @@ function parseFlowRemediateFlags(args) {
             options: {
                 help: { type: 'boolean', short: 'h' },
                 json: { type: 'boolean' },
-                'input-file': { type: 'string' },
+                input: { type: 'string' },
+                type: { type: 'string' },
                 'out-dir': { type: 'string' },
             },
         }));
@@ -1103,8 +1784,535 @@ function parseFlowRemediateFlags(args) {
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
-        inputFile: typeof values['input-file'] === 'string' ? values['input-file'] : '',
-        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        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,
+    };
+}
+function parseDatasetContractFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                type: { type: 'string' },
+                include: { type: 'string', multiple: true },
+                profile: { 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 : undefined,
+        include: Array.isArray(values.include)
+            ? values.include.filter((value) => typeof value === 'string')
+            : [],
+        profile: typeof values.profile === 'string' ? values.profile : undefined,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetImportLcaConvertFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'output-dir': { type: 'string' },
+                'from-format': { type: 'string' },
+                target: { type: 'string' },
+                report: { type: 'string' },
+                'mapping-dir': { type: 'string' },
+                language: { type: 'string' },
+                'validation-jobs': { type: 'string' },
+                'detect-only': { type: 'boolean' },
+                'fail-on-warning': { type: 'boolean' },
+                python: { type: 'string' },
+                'tidas-tools-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const validationJobs = typeof values['validation-jobs'] === 'string' ? Number(values['validation-jobs']) : undefined;
+    if (validationJobs !== undefined && (!Number.isInteger(validationJobs) || validationJobs < 0)) {
+        throw new CliError('--validation-jobs must be a non-negative integer.', {
+            code: 'DATASET_IMPORT_LCA_VALIDATION_JOBS_INVALID',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        outputDir: typeof values['output-dir'] === 'string' ? values['output-dir'] : '',
+        fromFormat: typeof values['from-format'] === 'string' ? values['from-format'] : undefined,
+        target: typeof values.target === 'string' ? values.target : undefined,
+        reportPath: typeof values.report === 'string' ? values.report : undefined,
+        mappingDir: typeof values['mapping-dir'] === 'string' ? values['mapping-dir'] : undefined,
+        language: typeof values.language === 'string' ? values.language : undefined,
+        validationJobs,
+        detectOnly: Boolean(values['detect-only']),
+        failOnWarning: Boolean(values['fail-on-warning']),
+        pythonBin: typeof values.python === 'string' ? values.python : undefined,
+        tidasToolsDir: typeof values['tidas-tools-dir'] === 'string' ? values['tidas-tools-dir'] : undefined,
+    };
+}
+function parseDatasetAuthorFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'target-types': { type: 'string', multiple: true },
+                'out-dir': { type: 'string' },
+                prompt: { type: 'string' },
+                provider: { type: 'string' },
+                model: { type: 'string' },
+                'timeout-ms': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const timeoutMs = typeof values['timeout-ms'] === 'string' ? Number(values['timeout-ms']) : undefined;
+    if (timeoutMs !== undefined && (!Number.isInteger(timeoutMs) || timeoutMs <= 0)) {
+        throw new CliError('--timeout-ms must be a positive integer.', {
+            code: 'DATASET_AUTHOR_TIMEOUT_INVALID',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        targetTypes: Array.isArray(values['target-types'])
+            ? values['target-types'].filter((value) => typeof value === 'string')
+            : [],
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        prompt: typeof values.prompt === 'string' ? values.prompt : undefined,
+        provider: typeof values.provider === 'string' ? values.provider : undefined,
+        model: typeof values.model === 'string' ? values.model : undefined,
+        timeoutMs,
+    };
+}
+function parseDatasetRemoteVerifyFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'root-policy': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const rawRootPolicy = typeof values['root-policy'] === 'string' ? values['root-policy'] : 'existing';
+    if (!['existing', 'candidate'].includes(rawRootPolicy)) {
+        throw new CliError("--root-policy must be 'existing' or 'candidate'.", {
+            code: 'DATASET_REMOTE_VERIFY_ROOT_POLICY_INVALID',
+            exitCode: 2,
+        });
+    }
+    const rootPolicy = rawRootPolicy;
+    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,
+    };
+}
+function parseDatasetBilingualExtractFlags(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' },
+                'source-lang': { type: 'string' },
+                'target-lang': { 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 : undefined,
+        sourceLang: typeof values['source-lang'] === 'string' ? values['source-lang'] : null,
+        targetLang: typeof values['target-lang'] === 'string' ? values['target-lang'] : null,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetBilingualApplyFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                translations: { type: 'string' },
+                out: { type: 'string' },
+                'target-lang': { 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 : '',
+        translationsPath: typeof values.translations === 'string' ? values.translations : '',
+        outPath: typeof values.out === 'string' ? values.out : '',
+        targetLang: typeof values['target-lang'] === 'string' ? values['target-lang'] : null,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetBilingualValidateFlags(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 : undefined,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+    };
+}
+function parseDatasetEvidenceSearchFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                query: { type: 'string' },
+                input: { type: 'string' },
+                results: { type: 'string' },
+                'provider-url': { type: 'string' },
+                'provider-key': { type: 'string' },
+                profile: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'max-queries': { type: 'string' },
+                'max-results-per-query': { type: 'string' },
+                'timeout-ms': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const readNumber = (value) => {
+        if (typeof value !== 'string') {
+            return null;
+        }
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : Number.NaN;
+    };
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        query: typeof values.query === 'string' ? values.query : null,
+        inputPath: typeof values.input === 'string' ? values.input : null,
+        resultsPath: typeof values.results === 'string' ? values.results : null,
+        providerUrl: typeof values['provider-url'] === 'string' ? values['provider-url'] : null,
+        providerKey: typeof values['provider-key'] === 'string' ? values['provider-key'] : null,
+        profile: typeof values.profile === 'string' ? values.profile : null,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        maxQueries: readNumber(values['max-queries']),
+        maxResultsPerQuery: readNumber(values['max-results-per-query']),
+        timeoutMs: readNumber(values['timeout-ms']),
+    };
+}
+function parseDatasetReferencesRewriteFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                from: { type: 'string' },
+                to: { type: 'string' },
+                type: { type: 'string', multiple: true },
+                types: { type: 'string', multiple: true },
+                scope: { 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: 'DATASET_REFERENCES_REWRITE_MODE_CONFLICT',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        from: typeof values.from === 'string' ? values.from : '',
+        to: typeof values.to === 'string' ? values.to : '',
+        types: [
+            ...(Array.isArray(values.type)
+                ? values.type.filter((value) => typeof value === 'string')
+                : []),
+            ...(Array.isArray(values.types)
+                ? values.types.filter((value) => typeof value === 'string')
+                : []),
+        ],
+        scope: typeof values.scope === 'string' ? values.scope : null,
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        commit: Boolean(values.commit),
+    };
+}
+function parseDatasetReferencesRefreshRemoteFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                out: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'root-policy': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const rawRootPolicy = typeof values['root-policy'] === 'string' ? values['root-policy'] : 'existing';
+    if (!['existing', 'candidate'].includes(rawRootPolicy)) {
+        throw new CliError("--root-policy must be 'existing' or 'candidate'.", {
+            code: 'DATASET_REMOTE_REFRESH_ROOT_POLICY_INVALID',
+            exitCode: 2,
+        });
+    }
+    const rootPolicy = rawRootPolicy;
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        outPath: typeof values.out === 'string' ? values.out : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        rootPolicy,
+    };
+}
+function parseIdentityPreflightFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'candidate-input': { type: 'string', multiple: true },
+                'remote-candidates': { type: 'boolean' },
+                'remote-query': { type: 'string' },
+                'remote-limit': { type: 'string' },
+                'out-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const candidateInputValue = values['candidate-input'];
+    const parseRemoteLimit = (value) => {
+        if (typeof value !== 'string') {
+            return null;
+        }
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new CliError('Expected --remote-limit to be a positive integer.', {
+                code: 'INVALID_IDENTITY_PREFLIGHT_REMOTE_LIMIT',
+                exitCode: 2,
+            });
+        }
+        return parsed;
+    };
+    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'] : null,
+        candidateInputPaths: Array.isArray(candidateInputValue)
+            ? candidateInputValue.filter((entry) => typeof entry === 'string')
+            : [],
+        remoteCandidateSearch: Boolean(values['remote-candidates']),
+        remoteQuery: typeof values['remote-query'] === 'string' ? values['remote-query'] : null,
+        remoteLimit: parseRemoteLimit(values['remote-limit']),
+    };
+}
+function parseBuildPlanFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'report-only': { 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 : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        reportOnly: Boolean(values['report-only']),
+    };
+}
+function parseFlowRemediateFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'input-file': { 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),
+        inputFile: typeof values['input-file'] === 'string' ? values['input-file'] : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
     };
 }
 function parseFlowPublishVersionFlags(args) {
@@ -1968,11 +3176,74 @@ function parseLifecyclemodelValidateBuildFlags(args) {
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
-        runDir: typeof values['run-dir'] === 'string' ? values['run-dir'] : '',
-        engine: typeof values.engine === 'string' ? values.engine : undefined,
+        runDir: typeof values['run-dir'] === 'string' ? values['run-dir'] : '',
+        engine: typeof values.engine === 'string' ? values.engine : undefined,
+    };
+}
+function parseLifecyclemodelPublishBuildFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'run-dir': { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        runDir: typeof values['run-dir'] === 'string' ? values['run-dir'] : '',
+    };
+}
+function parseLifecyclemodelSaveDraftFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { 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_LIFECYCLEMODEL_SAVE_DRAFT_MODE',
+            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'] : null,
+        commit: Boolean(values.commit),
     };
 }
-function parseLifecyclemodelPublishBuildFlags(args) {
+function parseLifecyclemodelGraphFlags(args) {
     let values;
     try {
         ({ values } = parseArgs({
@@ -1982,7 +3253,10 @@ function parseLifecyclemodelPublishBuildFlags(args) {
             options: {
                 help: { type: 'boolean', short: 'h' },
                 json: { type: 'boolean' },
-                'run-dir': { type: 'string' },
+                input: { type: 'string' },
+                'out-dir': { type: 'string' },
+                format: { type: 'string' },
+                'check-connections': { type: 'boolean' },
             },
         }));
     }
@@ -1995,7 +3269,10 @@ function parseLifecyclemodelPublishBuildFlags(args) {
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
-        runDir: typeof values['run-dir'] === 'string' ? values['run-dir'] : '',
+        inputPath: typeof values.input === 'string' ? values.input : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        format: typeof values.format === 'string' ? values.format : undefined,
+        checkConnections: Boolean(values['check-connections']),
     };
 }
 function parseLifecyclemodelBuildFlags(args) {
@@ -2214,6 +3491,111 @@ function parseProcessListFlags(args) {
         order: typeof values.order === 'string' ? values.order : null,
     };
 }
+function parseProcessScopeStatisticsFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'out-dir': { type: 'string' },
+                scope: { type: 'string' },
+                'state-code': { type: 'string', multiple: true },
+                'state-codes': { type: 'string' },
+                'page-size': { type: 'string' },
+                'reuse-snapshot': { type: 'boolean' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const parseStateCode = (value) => {
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isInteger(parsed) || parsed < 0) {
+            throw new CliError('Expected --state-code to be a non-negative integer.', {
+                code: 'INVALID_PROCESS_SCOPE_STATE_CODE',
+                exitCode: 2,
+            });
+        }
+        return parsed;
+    };
+    const stateCodes = [
+        ...(Array.isArray(values['state-code'])
+            ? values['state-code'].map((value) => parseStateCode(String(value)))
+            : []),
+        ...(typeof values['state-codes'] === 'string' ? values['state-codes'].split(',') : [])
+            .map((value) => value.trim())
+            .filter(Boolean)
+            .map((value) => parseStateCode(value)),
+    ];
+    let pageSize = null;
+    if (typeof values['page-size'] === 'string') {
+        const parsed = Number.parseInt(values['page-size'], 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new CliError('Expected --page-size to be a positive integer.', {
+                code: 'INVALID_PROCESS_SCOPE_PAGE_SIZE',
+                exitCode: 2,
+            });
+        }
+        pageSize = parsed;
+    }
+    let scope;
+    if (typeof values.scope === 'string') {
+        if (values.scope !== 'visible' && values.scope !== 'current-user') {
+            throw new CliError("Expected --scope to be either 'visible' or 'current-user'.", {
+                code: 'INVALID_PROCESS_SCOPE_SCOPE',
+                exitCode: 2,
+            });
+        }
+        scope = values.scope;
+    }
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        scope,
+        stateCodes,
+        pageSize,
+        reuseSnapshot: Boolean(values['reuse-snapshot']),
+    };
+}
+function parseProcessDedupReviewFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                'out-dir': { type: 'string' },
+                'skip-remote': { 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 : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        skipRemote: Boolean(values['skip-remote']),
+    };
+}
 function parseProcessResumeBuildFlags(args) {
     let values;
     try {
@@ -2307,6 +3689,124 @@ function parseProcessSaveDraftFlags(args) {
         commit: Boolean(values.commit),
     };
 }
+function parseProcessRequiredFieldsFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                input: { type: 'string' },
+                out: { type: 'string' },
+                'out-dir': { type: 'string' },
+                flows: { type: 'string' },
+                'default-unit': { 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 : '',
+        outPath: typeof values.out === 'string' ? values.out : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        flowInputPath: typeof values.flows === 'string' ? values.flows : null,
+        defaultUnit: typeof values['default-unit'] === 'string' ? values['default-unit'] : null,
+    };
+}
+function parseProcessRefreshReferencesFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'out-dir': { type: 'string' },
+                apply: { type: 'boolean' },
+                'dry-run': { type: 'boolean' },
+                'reuse-manifest': { type: 'boolean' },
+                limit: { type: 'string' },
+                'page-size': { type: 'string' },
+                concurrency: { type: 'string' },
+            },
+        }));
+    }
+    catch (error) {
+        throw new CliError(String(error), {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    if (values.apply && values['dry-run']) {
+        throw new CliError('Cannot pass both --apply and --dry-run.', {
+            code: 'PROCESS_REFRESH_MODE_CONFLICT',
+            exitCode: 2,
+        });
+    }
+    const parseOptionalPositiveIntegerFlag = (value, label, code) => {
+        if (typeof value !== 'string') {
+            return null;
+        }
+        const parsed = Number.parseInt(value, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            throw new CliError(`Expected ${label} to be a positive integer.`, {
+                code,
+                exitCode: 2,
+            });
+        }
+        return parsed;
+    };
+    return {
+        help: Boolean(values.help),
+        json: Boolean(values.json),
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+        apply: Boolean(values.apply),
+        reuseManifest: Boolean(values['reuse-manifest']),
+        limit: parseOptionalPositiveIntegerFlag(values.limit, '--limit', 'INVALID_PROCESS_REFRESH_LIMIT'),
+        pageSize: parseOptionalPositiveIntegerFlag(values['page-size'], '--page-size', 'INVALID_PROCESS_REFRESH_PAGE_SIZE'),
+        concurrency: parseOptionalPositiveIntegerFlag(values.concurrency, '--concurrency', 'INVALID_PROCESS_REFRESH_CONCURRENCY'),
+    };
+}
+function parseProcessVerifyRowsFlags(args) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args,
+            allowPositionals: false,
+            strict: true,
+            options: {
+                help: { type: 'boolean', short: 'h' },
+                json: { type: 'boolean' },
+                'rows-file': { 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),
+        rowsFile: typeof values['rows-file'] === 'string' ? values['rows-file'] : '',
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : '',
+    };
+}
 function parseProcessBatchBuildFlags(args) {
     let values;
     try {
@@ -2362,14 +3862,24 @@ export async function executeCli(argv, deps) {
         const lifecyclemodelPublishImpl = deps.runLifecyclemodelPublishResultingProcessImpl ?? runLifecyclemodelPublishResultingProcess;
         const lifecyclemodelValidateImpl = deps.runLifecyclemodelValidateBuildImpl ?? runLifecyclemodelValidateBuild;
         const lifecyclemodelPublishBuildImpl = deps.runLifecyclemodelPublishBuildImpl ?? runLifecyclemodelPublishBuild;
+        const lifecyclemodelSaveDraftImpl = deps.runLifecyclemodelSaveDraftImpl ?? runLifecyclemodelSaveDraft;
+        const lifecyclemodelGraphImpl = deps.runLifecyclemodelGraphImpl ?? runLifecyclemodelGraph;
         const lifecyclemodelOrchestrateImpl = deps.runLifecyclemodelOrchestrateImpl ?? runLifecyclemodelOrchestrate;
         const processGetImpl = deps.runProcessGetImpl ?? runProcessGet;
         const processListImpl = deps.runProcessListImpl ?? runProcessList;
         const processAutoBuildImpl = deps.runProcessAutoBuildImpl ?? runProcessAutoBuild;
         const processBatchBuildImpl = deps.runProcessBatchBuildImpl ?? runProcessBatchBuild;
+        const processScopeStatisticsImpl = deps.runProcessScopeStatisticsImpl ?? runProcessScopeStatistics;
+        const processRefreshReferencesImpl = deps.runProcessRefreshReferencesImpl ?? runProcessRefreshReferences;
+        const processDedupReviewImpl = deps.runProcessDedupReviewImpl ?? runProcessDedupReview;
         const processResumeBuildImpl = deps.runProcessResumeBuildImpl ?? runProcessResumeBuild;
         const processPublishBuildImpl = deps.runProcessPublishBuildImpl ?? runProcessPublishBuild;
         const processSaveDraftImpl = deps.runProcessSaveDraftImpl ?? runProcessSaveDraft;
+        const processRequiredFieldsCompleteImpl = deps.runProcessRequiredFieldsCompleteImpl ?? runProcessRequiredFieldsComplete;
+        const processVerifyRowsImpl = deps.runProcessVerifyRowsImpl ?? runProcessVerifyRows;
+        const processIdentityPreflightImpl = deps.runProcessIdentityPreflightImpl ?? runProcessIdentityPreflight;
+        const processBuildPlanValidateImpl = deps.runProcessBuildPlanValidateImpl ?? runProcessBuildPlanValidate;
+        const processBuildPlanMaterializeImpl = deps.runProcessBuildPlanMaterializeImpl ?? runProcessBuildPlanMaterialize;
         const processReviewImpl = deps.runProcessReviewImpl ?? runProcessReview;
         const flowReviewImpl = deps.runFlowReviewImpl ?? runFlowReview;
         const lifecyclemodelReviewImpl = deps.runLifecyclemodelReviewImpl ?? runLifecyclemodelReview;
@@ -2386,45 +3896,348 @@ export async function executeCli(argv, deps) {
         const flowApplyProcessFlowRepairsImpl = deps.runFlowApplyProcessFlowRepairsImpl ?? runFlowApplyProcessFlowRepairs;
         const flowRegenProductImpl = deps.runFlowRegenProductImpl ?? runFlowRegenProduct;
         const flowValidateProcessesImpl = deps.runFlowValidateProcessesImpl ?? runFlowValidateProcesses;
+        const flowIdentityPreflightImpl = deps.runFlowIdentityPreflightImpl ?? runFlowIdentityPreflight;
+        const flowBuildPlanValidateImpl = deps.runFlowBuildPlanValidateImpl ?? runFlowBuildPlanValidate;
+        const flowBuildPlanMaterializeImpl = deps.runFlowBuildPlanMaterializeImpl ?? runFlowBuildPlanMaterialize;
+        const datasetValidateImpl = deps.runDatasetValidateImpl ?? runDatasetValidate;
+        const datasetReferencesRewriteImpl = deps.runDatasetReferencesRewriteImpl ?? runDatasetReferencesRewrite;
+        const datasetRemoteRefreshImpl = deps.runDatasetRemoteRefreshImpl ?? runDatasetRemoteRefresh;
+        const datasetRemoteVerifyImpl = deps.runDatasetRemoteVerifyImpl ?? runDatasetRemoteVerify;
+        const datasetBilingualExtractImpl = deps.runDatasetBilingualExtractImpl ?? runDatasetBilingualExtract;
+        const datasetBilingualApplyImpl = deps.runDatasetBilingualApplyImpl ?? runDatasetBilingualApply;
+        const datasetBilingualValidateImpl = deps.runDatasetBilingualValidateImpl ?? runDatasetBilingualValidate;
+        const datasetEvidenceSearchImpl = deps.runDatasetEvidenceSearchImpl ?? runDatasetEvidenceSearch;
+        const datasetContractImpl = deps.runDatasetContractImpl ?? runDatasetContract;
+        const datasetImportLcaConvertImpl = deps.runDatasetImportLcaConvertImpl ?? runDatasetImportLcaConvert;
+        const datasetAuthorImpl = deps.runDatasetAuthorImpl ?? runDatasetAuthor;
         if (flags.version) {
             return { exitCode: 0, stdout: `${loadCliPackageVersion(import.meta.url)}\n`, stderr: '' };
         }
-        if (!command || command === 'help' || flags.help) {
-            return { exitCode: 0, stdout: `${renderMainHelp(deps.dotEnvStatus)}\n`, stderr: '' };
+        if (!command || command === 'help' || flags.help) {
+            return { exitCode: 0, stdout: `${renderMainHelp(deps.dotEnvStatus)}\n`, stderr: '' };
+        }
+        if (command === 'doctor') {
+            const doctorFlags = parseDoctorFlags(commandArgs);
+            if (doctorFlags.help) {
+                return { exitCode: 0, stdout: `${renderDoctorHelp()}\n`, stderr: '' };
+            }
+            const report = buildDoctorReport(deps.env, deps.dotEnvStatus);
+            return {
+                exitCode: report.ok ? 0 : 1,
+                stdout: doctorFlags.json ? `${JSON.stringify(report)}\n` : renderDoctorText(report),
+                stderr: '',
+            };
+        }
+        if (command === 'search' && !subcommand && commandArgs.includes('--help')) {
+            return { exitCode: 0, stdout: `${renderSearchHelp()}\n`, stderr: '' };
+        }
+        if (command === 'search' && subcommand) {
+            const remoteFlags = parseRemoteFlags(commandArgs);
+            const commandKey = `search:${subcommand}`;
+            if (remoteFlags.help) {
+                return { exitCode: 0, stdout: `${getRemoteCommandHelp(commandKey)}\n`, stderr: '' };
+            }
+            const env = applyRemoteOverrides(deps.env, remoteFlags);
+            return {
+                exitCode: 0,
+                stdout: await executeRemoteCommand({
+                    commandKey,
+                    inputPath: remoteFlags.inputPath,
+                    env,
+                    timeoutMs: remoteFlags.timeoutMs,
+                    dryRun: remoteFlags.dryRun,
+                    compactJson: remoteFlags.json,
+                    fetchImpl: deps.fetchImpl,
+                }),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && !subcommand) {
+            return { exitCode: 0, stdout: `${renderDatasetHelp()}\n`, stderr: '' };
+        }
+        if (command === 'dataset' && subcommand === 'contract') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetContractHelp()}\n`, stderr: '' };
+            }
+            if (action !== 'get') {
+                throw new CliError("dataset contract action must be 'get'.", {
+                    code: 'DATASET_CONTRACT_ACTION_INVALID',
+                    exitCode: 2,
+                });
+            }
+            const datasetFlags = parseDatasetContractFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetContractHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetContractImpl({
+                type: datasetFlags.type,
+                include: datasetFlags.include,
+                profile: datasetFlags.profile,
+                outDir: datasetFlags.outDir,
+                mode: 'contract',
+            });
+            return {
+                exitCode: 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'context-pack') {
+            const datasetFlags = parseDatasetContractFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetContextPackHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetContractImpl({
+                type: datasetFlags.type,
+                include: datasetFlags.include,
+                profile: datasetFlags.profile,
+                outDir: datasetFlags.outDir,
+                mode: 'context-pack',
+            });
+            return {
+                exitCode: 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'import-lca') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetImportLcaHelp()}\n`, stderr: '' };
+            }
+            if (action !== 'convert') {
+                throw new CliError("dataset import-lca action must be 'convert'.", {
+                    code: 'DATASET_IMPORT_LCA_ACTION_INVALID',
+                    exitCode: 2,
+                });
+            }
+            const datasetFlags = parseDatasetImportLcaConvertFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetImportLcaHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetImportLcaConvertImpl({
+                inputPath: datasetFlags.inputPath,
+                outputDir: datasetFlags.outputDir,
+                fromFormat: datasetFlags.fromFormat,
+                target: datasetFlags.target,
+                reportPath: datasetFlags.reportPath,
+                mappingDir: datasetFlags.mappingDir,
+                language: datasetFlags.language,
+                validationJobs: datasetFlags.validationJobs,
+                detectOnly: datasetFlags.detectOnly,
+                failOnWarning: datasetFlags.failOnWarning,
+                pythonBin: datasetFlags.pythonBin,
+                tidasToolsDir: datasetFlags.tidasToolsDir,
+                env: deps.env,
+            });
+            return {
+                exitCode: report.status === 'completed' ? 0 : 1,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'author') {
+            const datasetFlags = parseDatasetAuthorFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetAuthorHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetAuthorImpl({
+                inputPath: datasetFlags.inputPath,
+                targetTypes: datasetFlags.targetTypes,
+                outDir: datasetFlags.outDir,
+                prompt: datasetFlags.prompt,
+                provider: datasetFlags.provider,
+                model: datasetFlags.model,
+                timeoutMs: datasetFlags.timeoutMs,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'validate') {
+            const datasetFlags = parseDatasetValidateFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetValidateHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetValidateImpl({
+                inputPath: datasetFlags.inputPath,
+                type: datasetFlags.type,
+                outDir: datasetFlags.outDir,
+            });
+            return {
+                exitCode: report.counts.invalid > 0 ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
         }
-        if (command === 'doctor') {
-            const doctorFlags = parseDoctorFlags(commandArgs);
-            if (doctorFlags.help) {
-                return { exitCode: 0, stdout: `${renderDoctorHelp()}\n`, stderr: '' };
+        if (command === 'dataset' && subcommand === 'verify-remote') {
+            const datasetFlags = parseDatasetRemoteVerifyFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetRemoteVerifyHelp()}\n`, stderr: '' };
             }
-            const report = buildDoctorReport(deps.env, deps.dotEnvStatus);
+            const report = await datasetRemoteVerifyImpl({
+                inputPath: datasetFlags.inputPath,
+                outDir: datasetFlags.outDir,
+                rootPolicy: datasetFlags.rootPolicy,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
             return {
-                exitCode: report.ok ? 0 : 1,
-                stdout: doctorFlags.json ? `${JSON.stringify(report)}\n` : renderDoctorText(report),
+                exitCode: report.status === 'blocked_remote_verification' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
                 stderr: '',
             };
         }
-        if (command === 'search' && !subcommand && commandArgs.includes('--help')) {
-            return { exitCode: 0, stdout: `${renderSearchHelp()}\n`, stderr: '' };
+        if (command === 'dataset' && subcommand === 'bilingual') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetBilingualHelp()}\n`, stderr: '' };
+            }
+            if (action === 'extract') {
+                const datasetFlags = parseDatasetBilingualExtractFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetBilingualExtractHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetBilingualExtractImpl({
+                    inputPath: datasetFlags.inputPath,
+                    type: datasetFlags.type,
+                    sourceLang: datasetFlags.sourceLang,
+                    targetLang: datasetFlags.targetLang,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'apply') {
+                const datasetFlags = parseDatasetBilingualApplyFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetBilingualApplyHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetBilingualApplyImpl({
+                    inputPath: datasetFlags.inputPath,
+                    translationsPath: datasetFlags.translationsPath,
+                    outPath: datasetFlags.outPath,
+                    targetLang: datasetFlags.targetLang,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            if (action === 'validate') {
+                const datasetFlags = parseDatasetBilingualValidateFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetBilingualValidateHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetBilingualValidateImpl({
+                    inputPath: datasetFlags.inputPath,
+                    type: datasetFlags.type,
+                    outDir: datasetFlags.outDir,
+                });
+                return {
+                    exitCode: report.status === 'blocked' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            throw new CliError("dataset bilingual action must be 'extract', 'apply', or 'validate'.", {
+                code: 'INVALID_ARGS',
+                exitCode: 2,
+            });
         }
-        if (command === 'search' && subcommand) {
-            const remoteFlags = parseRemoteFlags(commandArgs);
-            const commandKey = `search:${subcommand}`;
-            if (remoteFlags.help) {
-                return { exitCode: 0, stdout: `${getRemoteCommandHelp(commandKey)}\n`, stderr: '' };
+        if (command === 'dataset' && subcommand === 'evidence-search') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetEvidenceSearchHelp()}\n`, stderr: '' };
             }
-            const env = applyRemoteOverrides(deps.env, remoteFlags);
+            if (action !== 'plan' && action !== 'run') {
+                throw new CliError("dataset evidence-search action must be 'plan' or 'run'.", {
+                    code: 'INVALID_ARGS',
+                    exitCode: 2,
+                });
+            }
+            const datasetFlags = parseDatasetEvidenceSearchFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetEvidenceSearchHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetEvidenceSearchImpl({
+                mode: action,
+                query: datasetFlags.query,
+                inputPath: datasetFlags.inputPath,
+                resultsPath: datasetFlags.resultsPath,
+                providerUrl: datasetFlags.providerUrl,
+                providerKey: datasetFlags.providerKey,
+                profile: datasetFlags.profile,
+                outDir: datasetFlags.outDir,
+                maxQueries: datasetFlags.maxQueries,
+                maxResultsPerQuery: datasetFlags.maxResultsPerQuery,
+                timeoutMs: datasetFlags.timeoutMs,
+                fetchImpl: deps.fetchImpl,
+            });
             return {
-                exitCode: 0,
-                stdout: await executeRemoteCommand({
-                    commandKey,
-                    inputPath: remoteFlags.inputPath,
-                    env,
-                    timeoutMs: remoteFlags.timeoutMs,
-                    dryRun: remoteFlags.dryRun,
-                    compactJson: remoteFlags.json,
+                exitCode: report.status === 'completed_no_sufficient_evidence' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'dataset' && subcommand === 'references') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetReferencesHelp()}\n`, stderr: '' };
+            }
+            if (!['rewrite', 'refresh-remote'].includes(action)) {
+                throw new CliError("dataset references action must be 'rewrite' or 'refresh-remote'.", {
+                    code: 'INVALID_ARGS',
+                    exitCode: 2,
+                });
+            }
+            if (action === 'refresh-remote') {
+                const datasetFlags = parseDatasetReferencesRefreshRemoteFlags(commandArgs.slice(1));
+                if (datasetFlags.help) {
+                    return { exitCode: 0, stdout: `${renderDatasetReferencesHelp()}\n`, stderr: '' };
+                }
+                const report = await datasetRemoteRefreshImpl({
+                    inputPath: datasetFlags.inputPath,
+                    outPath: datasetFlags.outPath,
+                    outDir: datasetFlags.outDir,
+                    rootPolicy: datasetFlags.rootPolicy,
+                    env: deps.env,
                     fetchImpl: deps.fetchImpl,
-                }),
+                });
+                return {
+                    exitCode: report.status === 'completed_with_blockers' ? 1 : 0,
+                    stdout: stringifyJson(report, datasetFlags.json),
+                    stderr: '',
+                };
+            }
+            const datasetFlags = parseDatasetReferencesRewriteFlags(commandArgs.slice(1));
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetReferencesHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetReferencesRewriteImpl({
+                inputPath: datasetFlags.inputPath,
+                from: datasetFlags.from,
+                to: datasetFlags.to,
+                types: datasetFlags.types,
+                scope: datasetFlags.scope,
+                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: '',
             };
         }
@@ -2531,6 +4344,49 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'lifecyclemodel' && subcommand === 'save-draft') {
+            const lifecyclemodelFlags = parseLifecyclemodelSaveDraftFlags(commandArgs);
+            if (lifecyclemodelFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderLifecyclemodelSaveDraftHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await lifecyclemodelSaveDraftImpl({
+                inputPath: lifecyclemodelFlags.inputPath,
+                outDir: lifecyclemodelFlags.outDir,
+                commit: lifecyclemodelFlags.commit,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'completed_with_failures' ? 1 : 0,
+                stdout: stringifyJson(report, lifecyclemodelFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'lifecyclemodel' && subcommand === 'graph') {
+            const lifecyclemodelFlags = parseLifecyclemodelGraphFlags(commandArgs);
+            if (lifecyclemodelFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderLifecyclemodelGraphHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await lifecyclemodelGraphImpl({
+                inputPath: lifecyclemodelFlags.inputPath,
+                outDir: lifecyclemodelFlags.outDir,
+                format: lifecyclemodelFlags.format,
+                checkConnections: lifecyclemodelFlags.checkConnections,
+            });
+            return {
+                exitCode: report.status === 'completed_with_findings' ? 1 : 0,
+                stdout: stringifyJson(report, lifecyclemodelFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'lifecyclemodel' && subcommand === 'orchestrate') {
             const lifecyclemodelFlags = parseLifecyclemodelOrchestrateFlags(commandArgs);
             if (lifecyclemodelFlags.help || !lifecyclemodelFlags.action) {
@@ -2618,6 +4474,117 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'process' && subcommand === 'identity-preflight') {
+            const processFlags = parseIdentityPreflightFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessIdentityPreflightHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processIdentityPreflightImpl({
+                inputPath: processFlags.inputPath,
+                outDir: processFlags.outDir,
+                candidateInputPaths: processFlags.candidateInputPaths,
+                remoteCandidateSearch: processFlags.remoteCandidateSearch,
+                remoteQuery: processFlags.remoteQuery,
+                remoteLimit: processFlags.remoteLimit,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'passed' ? 0 : 1,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'process' && subcommand === 'build-plan') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessBuildPlanHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            if (action !== 'validate' && action !== 'materialize') {
+                throw new CliError("process build-plan action must be 'validate' or 'materialize'.", {
+                    code: 'INVALID_ARGS',
+                    exitCode: 2,
+                });
+            }
+            const processFlags = parseBuildPlanFlags(commandArgs.slice(1));
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessBuildPlanHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = action === 'validate'
+                ? await processBuildPlanValidateImpl({
+                    inputPath: processFlags.inputPath,
+                    outDir: processFlags.outDir,
+                    reportOnly: processFlags.reportOnly,
+                })
+                : await processBuildPlanMaterializeImpl({
+                    inputPath: processFlags.inputPath,
+                    outDir: processFlags.outDir,
+                    reportOnly: processFlags.reportOnly,
+                });
+            return {
+                exitCode: report.status === 'blocked' && !processFlags.reportOnly ? 1 : 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'process' && subcommand === 'scope-statistics') {
+            const processFlags = parseProcessScopeStatisticsFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessScopeStatisticsHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processScopeStatisticsImpl({
+                outDir: processFlags.outDir,
+                scope: processFlags.scope,
+                stateCodes: processFlags.stateCodes,
+                pageSize: processFlags.pageSize,
+                reuseSnapshot: processFlags.reuseSnapshot,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'process' && subcommand === 'dedup-review') {
+            const processFlags = parseProcessDedupReviewFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessDedupReviewHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processDedupReviewImpl({
+                inputPath: processFlags.inputPath,
+                outDir: processFlags.outDir,
+                skipRemote: processFlags.skipRemote,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'process' && subcommand === 'auto-build') {
             const processFlags = parseProcessAutoBuildFlags(commandArgs);
             if (processFlags.help) {
@@ -2675,6 +4642,28 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'process' && subcommand === 'complete-required-fields') {
+            const processFlags = parseProcessRequiredFieldsFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessRequiredFieldsHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processRequiredFieldsCompleteImpl({
+                inputPath: processFlags.inputPath,
+                outPath: processFlags.outPath,
+                outDir: processFlags.outDir,
+                flowInputPath: processFlags.flowInputPath,
+                defaultUnit: processFlags.defaultUnit,
+            });
+            return {
+                exitCode: report.status === 'completed_with_blockers' ? 1 : 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'process' && subcommand === 'save-draft') {
             const processFlags = parseProcessSaveDraftFlags(commandArgs);
             if (processFlags.help) {
@@ -2697,6 +4686,50 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'process' && subcommand === 'refresh-references') {
+            const processFlags = parseProcessRefreshReferencesFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessRefreshReferencesHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processRefreshReferencesImpl({
+                outDir: processFlags.outDir,
+                apply: processFlags.apply,
+                reuseManifest: processFlags.reuseManifest,
+                limit: processFlags.limit,
+                pageSize: processFlags.pageSize,
+                concurrency: processFlags.concurrency,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'completed_process_reference_refresh_with_errors' ? 1 : 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'process' && subcommand === 'verify-rows') {
+            const processFlags = parseProcessVerifyRowsFlags(commandArgs);
+            if (processFlags.help) {
+                return {
+                    exitCode: 0,
+                    stdout: `${renderProcessVerifyRowsHelp()}\n`,
+                    stderr: '',
+                };
+            }
+            const report = await processVerifyRowsImpl({
+                rowsFile: processFlags.rowsFile,
+                outDir: processFlags.outDir,
+            });
+            return {
+                exitCode: report.invalid_count > 0 ? 1 : 0,
+                stdout: stringifyJson(report, processFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'process' && subcommand === 'batch-build') {
             const processFlags = parseProcessBatchBuildFlags(commandArgs);
             if (processFlags.help) {
@@ -2763,6 +4796,59 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'flow' && subcommand === 'identity-preflight') {
+            const flowFlags = parseIdentityPreflightFlags(commandArgs);
+            if (flowFlags.help) {
+                return { exitCode: 0, stdout: `${renderFlowIdentityPreflightHelp()}\n`, stderr: '' };
+            }
+            const report = await flowIdentityPreflightImpl({
+                inputPath: flowFlags.inputPath,
+                outDir: flowFlags.outDir,
+                candidateInputPaths: flowFlags.candidateInputPaths,
+                remoteCandidateSearch: flowFlags.remoteCandidateSearch,
+                remoteQuery: flowFlags.remoteQuery,
+                remoteLimit: flowFlags.remoteLimit,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'passed' ? 0 : 1,
+                stdout: stringifyJson(report, flowFlags.json),
+                stderr: '',
+            };
+        }
+        if (command === 'flow' && subcommand === 'build-plan') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderFlowBuildPlanHelp()}\n`, stderr: '' };
+            }
+            if (action !== 'validate' && action !== 'materialize') {
+                throw new CliError("flow build-plan action must be 'validate' or 'materialize'.", {
+                    code: 'INVALID_ARGS',
+                    exitCode: 2,
+                });
+            }
+            const flowFlags = parseBuildPlanFlags(commandArgs.slice(1));
+            if (flowFlags.help) {
+                return { exitCode: 0, stdout: `${renderFlowBuildPlanHelp()}\n`, stderr: '' };
+            }
+            const report = action === 'validate'
+                ? await flowBuildPlanValidateImpl({
+                    inputPath: flowFlags.inputPath,
+                    outDir: flowFlags.outDir,
+                    reportOnly: flowFlags.reportOnly,
+                })
+                : await flowBuildPlanMaterializeImpl({
+                    inputPath: flowFlags.inputPath,
+                    outDir: flowFlags.outDir,
+                    reportOnly: flowFlags.reportOnly,
+                });
+            return {
+                exitCode: report.status === 'blocked' && !flowFlags.reportOnly ? 1 : 0,
+                stdout: stringifyJson(report, flowFlags.json),
+                stderr: '',
+            };
+        }
         if (command === 'flow' && subcommand === 'remediate') {
             const flowFlags = parseFlowRemediateFlags(commandArgs);
             if (flowFlags.help) {