@tiangong-lca/cli 0.0.7 → 0.0.8

package/dist/src/cli.js

@@ -21,7 +21,10 @@ 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';
@@ -39,6 +42,13 @@ 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
 
@@ -57,9 +67,9 @@ Commands:
 Implemented Commands:
   doctor     show environment diagnostics
   search     flow | process | lifecyclemodel
-  process    get | list | scope-statistics | dedup-review | auto-build | resume-build | publish-build | save-draft | batch-build | refresh-references | verify-rows
-  dataset    validate | references rewrite
-  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
+  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
@@ -78,16 +88,29 @@ Examples:
   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
@@ -97,6 +120,8 @@ Examples:
   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
@@ -191,6 +216,13 @@ 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() {
@@ -210,12 +242,148 @@ function renderDatasetHelp() {
   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() {
@@ -235,21 +403,135 @@ Outputs written under --out-dir:
   - 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
-  --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
+  --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:
@@ -261,6 +543,10 @@ 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() {
@@ -270,6 +556,8 @@ function renderFlowHelp() {
 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
@@ -286,6 +574,8 @@ Examples:
   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
@@ -299,6 +589,52 @@ Examples:
   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-lca flow get --id <flow-id> [options]
@@ -435,6 +771,7 @@ 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();
 }
@@ -470,6 +807,7 @@ 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();
 }
@@ -949,6 +1287,36 @@ Outputs written under --out-dir:
   - 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]
@@ -1045,6 +1413,30 @@ 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]
@@ -1115,11 +1507,14 @@ function renderProcessHelp() {
 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
@@ -1129,17 +1524,36 @@ Examples:
   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) {
     const lines = [
         'TianGong CLI doctor',
@@ -1371,11 +1785,479 @@ function parseDatasetValidateFlags(args) {
         help: Boolean(values.help),
         json: Boolean(values.json),
         inputPath: typeof values.input === 'string' ? values.input : '',
-        type: typeof values.type === 'string' ? values.type : undefined,
+        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 parseDatasetReferencesRewriteFlags(args) {
+function parseBuildPlanFlags(args) {
     let values;
     try {
         ({ values } = parseArgs({
@@ -1386,14 +2268,8 @@ function parseDatasetReferencesRewriteFlags(args) {
                 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' },
+                'report-only': { type: 'boolean' },
             },
         }));
     }
@@ -1403,29 +2279,12 @@ function parseDatasetReferencesRewriteFlags(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),
+        outDir: typeof values['out-dir'] === 'string' ? values['out-dir'] : null,
+        reportOnly: Boolean(values['report-only']),
     };
 }
 function parseFlowRemediateFlags(args) {
@@ -2830,6 +3689,40 @@ 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 {
@@ -2982,7 +3875,11 @@ export async function executeCli(argv, deps) {
         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;
@@ -2999,8 +3896,20 @@ 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: '' };
         }
@@ -3046,6 +3955,110 @@ export async function executeCli(argv, deps) {
         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) {
@@ -3062,17 +4075,151 @@ export async function executeCli(argv, deps) {
                 stderr: '',
             };
         }
+        if (command === 'dataset' && subcommand === 'verify-remote') {
+            const datasetFlags = parseDatasetRemoteVerifyFlags(commandArgs);
+            if (datasetFlags.help) {
+                return { exitCode: 0, stdout: `${renderDatasetRemoteVerifyHelp()}\n`, stderr: '' };
+            }
+            const report = await datasetRemoteVerifyImpl({
+                inputPath: datasetFlags.inputPath,
+                outDir: datasetFlags.outDir,
+                rootPolicy: datasetFlags.rootPolicy,
+                env: deps.env,
+                fetchImpl: deps.fetchImpl,
+            });
+            return {
+                exitCode: report.status === 'blocked_remote_verification' ? 1 : 0,
+                stdout: stringifyJson(report, datasetFlags.json),
+                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 === 'dataset' && subcommand === 'evidence-search') {
+            const action = commandArgs[0] ?? '';
+            if (!action || action === '--help' || action === '-h') {
+                return { exitCode: 0, stdout: `${renderDatasetEvidenceSearchHelp()}\n`, stderr: '' };
+            }
+            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: 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 (action !== 'rewrite') {
-                throw new CliError("dataset references action must be 'rewrite'.", {
+            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: '' };
@@ -3327,6 +4474,71 @@ 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) {
@@ -3430,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) {
@@ -3562,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) {