@tiangong-lca/cli 0.0.32 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) TianGong LCA contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -14,18 +14,27 @@ whenToUpdate:
 checkPaths:
   - README.md
   - package.json
+  - pnpm-workspace.yaml
+  - pnpm-lock.yaml
   - bin/**
   - src/cli.ts
   - src/main.ts
   - src/lib/lca-release.ts
   - test/lca-release*.test.ts
-lastReviewedAt: 2026-07-23
-lastReviewedCommit: 5c90ddd60328748ab6d8d89717e59dcaeca8cde7
+lastReviewedAt: 2026-08-25
+lastReviewedCommit: 9078fe123e5909b680f27af1af1d2018bcd02826
+lastReviewedNote: 'Reviewed for Issue #226: the public package guide identifies the 0.1.0 pnpm/TypeScript 7 compatibility release while the tarball remains package-manager neutral.'
 ---
 
 # TianGong LCA CLI
 
-Package: `@tiangong-lca/cli` Executable: `tiangong-lca` Node: `24.x`
+Package: `@tiangong-lca/cli` Executable: `tiangong-lca` Current package version: `0.1.0` Node: `24.x`
+
+Repository development is single-track on pnpm `11.23.0` and TypeScript `7.0.2`. The published package remains a clean, package-manager-neutral consumer artifact: it contains runtime files only, not pnpm, TypeScript, Oxlint, tests, source-only tooling, or repository lockfiles.
+
+Review note, 2026-08-25: Issue #224 migrates repository development and release automation to the sole root `pnpm-workspace.yaml` / `pnpm-lock.yaml`, TypeScript 7.0.2, and type-aware Oxlint on Node 24. The feature change deliberately keeps version 0.0.33. A separate release-only PR should prepare 0.1.0 after the toolchain change merges and its full package/coverage/release gates pass.
+
+Review note, 2026-08-25: Issue #226 publishes that 0.1.0 compatibility boundary after merged PR #225. Version metadata and public release evidence advance to 0.1.0; the runtime JavaScript/assets surface, command behavior, Node 24 runtime, pnpm/TypeScript 7 development baseline, native pnpm Trusted Publishing/provenance, and exact released-commit workspace handoff remain unchanged from the reviewed feature delivery.
 
 Review note, 2026-07-12: `dataset maintenance plan/apply/verify` provides current-user RLS-scoped exact-row maintenance with immutable plans, explicit approval, per-action logs, platform audit correlation, and independent readback. `merge-support-aliases` now runs only in `target_mode=owner_draft`: source/target support and all changed rows stay private `state_code=0`; publication is a separate future workflow.
 
@@ -45,20 +54,26 @@ Review note, 2026-07-23: `dataset save-draft --execution-contract` adds an opt-i
 
 Review note, 2026-07-24: CLI 0.0.32 adds bounded execution-contract concurrency without changing the sealed payload or replay model. `--max-parallel 1..8` keeps the complete dependency prefix serial and exact-read-back, then overlaps only the unique-target suffix. The current owner token is renewed and revalidated before each DML dispatch so long batches do not turn token expiry into an avoidable UNKNOWN.
 
+Review note, 2026-07-24: CLI 0.0.33 adds an explicit `dataset maintenance apply --max-parallel 1..8` profile for large owner-draft flow convergence. It accepts only unique flow delete-only plans with zero frozen and fresh visible-process inbound references, persists `PREPARED` and `DISPATCHED` before each protected RPC, requires exact absent readback for `COMMITTED`, never automatically replays success or UNKNOWN, and continues independent rows.
+
+Review note, 2026-07-25: The complete RLS-visible process fence now paginates in the strict `(id, version)` primary-key order. It still has no `user_id` filter and retains exact-count completeness, while avoiding a redundant owner/state sort before any deletion can dispatch.
+
+Review note, 2026-07-25: Bounded flow deletion can instead accept an explicitly SHA-approved, at-most-30-minute-old SELECT-only proof covering all process rows. The proof binds the exact project, actor, plan, ordered delete targets, and contiguous target chunks and must report zero inbound edges and zero P0/P1 findings. The CLI validates it before approval or dispatch and never executes the proof SQL itself; omitting the flags preserves the live RLS-visible scan.
+
 ## Run
 
 One-off published run:
 
 ```bash
-npm exec --yes --package=@tiangong-lca/cli@latest -- tiangong-lca --help
-npm exec --yes --package=@tiangong-lca/cli@latest -- tiangong-lca doctor
-npm exec --yes --package=@tiangong-lca/cli@latest -- tiangong-lca flow --help
+pnpm dlx @tiangong-lca/cli@latest --help
+pnpm dlx @tiangong-lca/cli@latest doctor
+pnpm dlx @tiangong-lca/cli@latest flow --help
 ```
 
 Install the published CLI:
 
 ```bash
-npm install --global @tiangong-lca/cli
+pnpm add --global @tiangong-lca/cli
 tiangong-lca --help
 tiangong-lca doctor
 tiangong-lca flow --help
@@ -67,8 +82,8 @@ tiangong-lca flow --help
 Run from this repository:
 
 ```bash
-npm ci
-npm run build
+pnpm install --frozen-lockfile
+pnpm build
 node ./bin/tiangong-lca.js --help
 ```
 
@@ -253,7 +268,7 @@ Key outputs under `--out-dir`:
 
 `--candidate-input` is repeatable and accepts JSON, JSONL, or a directory scanned recursively for JSON/JSONL candidate rows. Embedded `candidates` from the request and local-scan candidates are evaluated together. Add `--remote-candidates` when the preflight should also call `process_hybrid_search` or `flow_hybrid_search`; `--remote-query` overrides the target-derived search text and `--remote-limit` caps returned candidate rows. Remote candidate search uses the normal Supabase session env: `TIANGONG_LCA_API_BASE_URL`, `TIANGONG_LCA_API_KEY`, `TIANGONG_LCA_SUPABASE_PUBLISHABLE_KEY`, and optional `TIANGONG_LCA_REGION`.
 
-When remote search is enabled, the CLI sends a compact fielded `query` string plus supported edge-search options to `process_hybrid_search` or `flow_hybrid_search`: `filter`, `match_count`, `page_size`, `data_source`, `match_threshold`, `full_text_weight`, `extracted_text_weight`, `semantic_weight`, and `rrf_k`. Request-level `remote_candidate_search.profile_hints` are not sent to the Edge Function. They are applied locally before scoring candidates so Foundry can provide source-derived facts such as flow type, flow property, reference unit, elementary categories, geography, reference-flow names, technology route, and system boundary without polluting the full-text/semantic query.
+When remote search is enabled, the CLI sends a compact fielded `query` string plus supported edge-search options to `process_hybrid_search` or `flow_hybrid_search`: `filter`, `match_count`, `page_size`, `data_source`, `match_threshold`, `lexical_weight`, `semantic_weight`, and `rrf_k`. `lexical_weight` controls the single database-owned `extracted_md` lexical branch. Request-level `remote_candidate_search.profile_hints` are not sent to the Edge Function. They are applied locally before scoring candidates so Foundry can provide source-derived facts such as flow type, flow property, reference unit, elementary categories, geography, reference-flow names, technology route, and system boundary without polluting the full-text/semantic query.
 
 Exact process exchange fingerprints with matching identity context block duplicate creation, while weaker inventory-only matches still route to manual review. Flow preflight also blocks alias-equivalent flows when type, reference property, unit, and category/CAS evidence match.
 
@@ -268,7 +283,7 @@ tiangong-lca flow build-plan validate --input ./flow-build-plan.json --out-dir .
 tiangong-lca flow build-plan materialize --input ./flow-build-plan.json --out-dir ./flow-build-plan --json
 ```
 
-The minimum plan contract requires an automatic identity decision, EvidenceManifest sources and field bindings, name plan, and the relevant process reference-flow or flow-property fields. Process materialization carries name, quantitative reference, exchange, source evidence, modelling, administrative, and annual supply/production fields from the plan into `processDataSet`; when annual volume source evidence is not explicit, Foundry-facing required-field completion uses the deterministic `9999 missing-data-sentinel/year` value so the schema-required field stays searchable for later database-side curation. Flow materialization carries name, flow type, reference property, source evidence, administrative, and classification fields into `flowDataSet`. `--report-only` keeps exit code `0` while still reporting blockers.
+The minimum plan contract requires an automatic identity decision, EvidenceManifest sources and field bindings, name plan, and the relevant process reference-flow or flow-property fields. Plan-only materialization additionally requires an explicit canonical `classification_path`: continuous level `0..n` objects with exact locked `@classId`/`#text` for process and product/waste flow taxonomies, or `@catId`/`#text` for elementary flows. Label-only, missing, malformed, or taxonomy-spoofed classifications fail before artifact publication. Process materialization carries name, quantitative reference, exchange, source evidence, modelling, administrative, and annual supply/production fields from the plan into `processDataSet`; when annual volume source evidence is not explicit, Foundry-facing required-field completion uses the deterministic `9999 missing-data-sentinel/year` value so the schema-required field stays searchable for later database-side curation. Flow materialization carries name, flow type, reference property, source evidence, administrative, and classification fields into `flowDataSet`. `--report-only` keeps exit code `0` while still reporting blockers.
 
 Key outputs under `--out-dir`:
 
@@ -367,6 +382,7 @@ tiangong-lca dataset classification apply --type location --input ./rows/process
 tiangong-lca dataset curation-queue build --processes ./rows/processes.jsonl --flows ./rows/flows.jsonl --support ./rows/sources.jsonl --out-dir /abs/path/to/curation-queue --json
 tiangong-lca dataset curation-queue next --queue-dir /abs/path/to/curation-queue --type support --json
 tiangong-lca dataset curation-queue verify --queue-dir /abs/path/to/curation-queue --type process --json
+tiangong-lca dataset import-lca convert --input ./external/simapro.csv --output-dir /abs/path/to/imported --from-format simapro-csv --target both --write-mapping --json
 tiangong-lca dataset save-draft --input ./rows.jsonl --type auto --execution-contract ./execution-contract.json --max-parallel 8 --out-dir /abs/path/to/dataset-save-draft --commit --json
 tiangong-lca dataset evidence-search plan --query "中国2026年电力结构数据" --out-dir /abs/path/to/evidence-search --json
 tiangong-lca dataset evidence-search run --input ./evidence-search.request.json --results ./search-results.json --out-dir /abs/path/to/evidence-search --json
@@ -374,6 +390,7 @@ tiangong-lca dataset references rewrite --input ./rows.jsonl --from flow:<old-id
 tiangong-lca dataset maintenance plan --scope ./maintenance-scope.json --operation redo-import --out-dir /abs/path/to/dataset-maintenance --page-size 1000 --timeout-ms 10000 --json
 tiangong-lca dataset maintenance plan --scope ./derivative-rebuild-scope.json --operation rebuild-derivatives --out-dir /abs/path/to/derivative-rebuild --json
 tiangong-lca dataset maintenance apply --plan /abs/path/to/dataset-maintenance/maintenance-plan.json --commit --approve-plan <sha256> --confirm <current-account-email> --timeout-ms 10000 --json
+tiangong-lca dataset maintenance apply --plan /abs/path/to/flow-delete-maintenance/maintenance-plan.json --commit --approve-plan <sha256> --confirm <current-account-email> --max-parallel 8 --timeout-ms 10000 --json
 tiangong-lca dataset maintenance verify --plan /abs/path/to/dataset-maintenance/maintenance-plan.json --out-dir /abs/path/to/dataset-maintenance/verify --page-size 1000 --timeout-ms 10000 --json
 tiangong-lca dataset maintenance run-protected --plan /abs/path/to/maintenance-plan.json --freeze /abs/path/to/protected-execution-freeze.json --approval /abs/path/to/protected-approval.json --out-dir /abs/path/to/protected-run --status-only --json
 tiangong-lca lifecyclemodel auto-build --input ./examples/lifecyclemodel-auto-build.request.json --out-dir /abs/path/to/lifecyclemodel-run --json
@@ -398,12 +415,14 @@ For `qa process`, `--rows-file` accepts either raw process rows as JSON/JSONL or
 
 For `process identity-preflight` and `flow identity-preflight`, canonical TIDAS wrappers are schema-checked when present. Loose target objects are accepted for early planning and produce `schema_validation.status: "not_applicable"` until materialization. Candidate rows can be embedded in the request, loaded from repeatable `--candidate-input` local files/directories, or fetched through explicit `--remote-candidates` hybrid search; `identity-candidate-sources.json` records scanned files, remote endpoints, queries, filters, edge-search options, and row counts. The remote Edge Function receives only search-safe query/options fields; local-only `profile_hints` stay in the preflight target profile and candidate scoring evidence.
 
-For `process build-plan` and `flow build-plan`, canonical payloads embedded in the plan are schema-checked during `materialize`. Plan-only materialization now creates deterministic canonical `processDataSet` / `flowDataSet` wrappers from the build plan and validates them with the TIDAS SDK before reporting `passed`.
+For `process build-plan` and `flow build-plan`, canonical payloads embedded in the plan are schema-checked during `materialize`. Plan-only materialization creates deterministic canonical `processDataSet` / `flowDataSet` wrappers, requires an explicit canonical locked-taxonomy `classification_path`, and validates the result with the TIDAS SDK before reporting `passed`; it never invents taxonomy ids from free-form labels.
 
 For `process save-draft`, canonical process payloads are validated locally with `ProcessSchema` before any `--commit` write. Schema-invalid rows remain in `outputs/save-draft-rpc/failures.jsonl` instead of being persisted. Batch import callers should pass `--target-user-id`; the CLI then verifies the current auth session and any visible draft owner before writing, while downstream readback verification still proves the final owner and payload.
 
 For `dataset save-draft --execution-contract`, the JSON contract uses schema `dataset-save-draft-execution-contract.v1` and supplies `execution_id`, `project_ref`, an exact owner (`user_id`, lowercase `email`, `state_code: 0`), and ordered actions. Each action binds `action_id`, `desired_sha256`, `expected_operation` (`insert` or `save_draft`), table/id/version, `before_sha256`, and earlier `dependency_action_ids`. Contract mode requires `--commit`; account-local Unit Group or Flow Property support rows additionally require `--allow-account-local-support`. `--max-parallel` defaults to 1 and is capped at 8. When it is greater than 1, every action through the highest referenced dependency remains serial; only the later table/id/version-unique suffix may overlap. The exact owner token is renewed and checked before each DML dispatch. Attempts and outcomes are stored under the platform user-state directory (`$XDG_STATE_HOME/tiangong-lca-cli` when configured), not beside the contract or report. Any prior terminal or unresolved attempt is read back or retained without re-dispatch; exit status is nonzero unless every action has exact terminal success.
 
+For `dataset maintenance apply`, explicitly passing `--max-parallel 1..8` opts into the destructive flow-convergence profile. It accepts only a non-empty, unique-target, flow delete-only plan whose current and projected reference impacts are both zero. Before dispatch it completes a fresh SELECT-only scan of every process visible to the owner session and rejects any inbound edge. For a separately governed all-process check, pair `--global-inbound-proof /absolute/proof.json` with `--approve-global-inbound-proof <sha256>`; the proof must be fresh, SELECT-only, complete, zero-inbound, and bound to the exact project, actor, plan, and ordered target set, and it is validated before the live scan is skipped. The CLI never runs raw SQL. Each action writes append-only `PREPARED` and `DISPATCHED` evidence before its protected owner-session RPC, then records `COMMITTED` only after exact absent readback. An ambiguous action is read back, marked `UNKNOWN`, and never replayed automatically; independent actions continue. Omit `--max-parallel` to retain ordinary maintenance apply behavior.
+
 For `flow publish-version`, canonical flow payloads are validated locally with `FlowSchema` before remote visibility planning or writes. The command always writes `flow-publish-version-gate-report.json`; blocked rows are written to the remote-failure JSONL without calling the remote service.
 
 For `process publish-build`, canonical process payloads are validated locally with `ProcessSchema` before publish handoff artifacts are written. The gate report is `reports/process-publish-schema-gate.json`.
@@ -418,6 +437,8 @@ For `dataset validate`, `--type auto` supports mixed support scopes containing c
 
 For `dataset curation-queue build/next/verify`, the CLI owns entity-level Foundry import queue state. `build` writes `outputs/curation-queue-manifest.json`, `outputs/curation-queue-tasks.jsonl`, `outputs/curation-queue-locks.json`, `outputs/curation-queue-blockers.jsonl`, and per-entity `input.jsonl`, `closure.json`, and `entity-run-plan.json`. `next` returns one runnable support/flow/process task based on checkpoint state. `verify` passes only when scoped checkpoints are complete and build blockers are absent. AI authoring must return structured patches or build plans, and remote writes remain gated by deterministic apply, schema/QA, prewrite verify, and readback.
 
+For `dataset import-lca convert`, the CLI delegates all format detection, conversion, validation, bounded spooling, cancellation, and atomic publication to unified Rust `tidas import`; it does not reproduce import logic in TypeScript. Binary selection is `--tidas-bin`, then `TIDAS_BIN`, then `tidas` on PATH. Optional `--tidas-config` maps to native `--config`. Every run first requires a successful `tidas version --format json --progress never` handshake with `tidas.operation-report.v1` and a stable `0.2.x` binary version, then validates the native `tidas.import-execution-report.v1` summary and exact exit-class/code mapping. Native controls include explicit or automatic source format, target, mapping output, process-bundle disablement, warning failure, maximum entry size, memory budget, and queue capacity. The supported release matrix is Linux x86_64/ARM64, macOS Intel/Apple Silicon, and Windows x86_64; Windows ARM64 is unsupported. The npm package includes `assets/import-smoke/simapro.csv` for clean-machine proof but does not bundle a platform binary or require Python.
+
 For `dataset references rewrite`, `--commit` executes the state-aware save-draft path for patched process and lifecyclemodel rows; without `--commit`, the command only writes local rewrite artifacts.
 
 ## Dataset Maintenance

package/assets/import-smoke/simapro.csv

@@ -0,0 +1,20 @@
+{SimaPro 8.0}
+{processes}
+{CSV separator: Semicolon}
+{Decimal separator: ,}
+
+Process
+
+Process name
+Test process
+
+Products
+my product;kg;0,5;100;not defined;Agricultural;
+
+Materials/fuels
+Soy oil, refined, at plant/kg/RNA;kg;0,2;Undefined;0;0;0;
+
+Emissions to air
+carbon dioxide;low. pop.;kg;1,5;Undefined;0;0;0;
+
+End

package/bin/tiangong-lca.js

@@ -24,7 +24,7 @@ export function resolveInvokedUrl(argv1 = process.argv[1]) {
 export async function runFromBin(argv = process.argv.slice(2), env = process.env) {
   if (!existsSync(entryPath)) {
     throw new Error(
-      "Missing built CLI artifacts at 'dist/src/main.js'. Run 'npm run build' or reinstall dependencies to regenerate dist.",
+      "Missing built CLI artifacts at 'dist/src/main.js'. Run 'pnpm build' or reinstall dependencies to regenerate dist.",
     );
   }
 

package/dist/src/cli.js

@@ -335,7 +335,7 @@ Implemented Subcommands:
   curation-queue build Build entity-level AI curation queue artifacts for Foundry imports
   curation-queue next  Return the next runnable support/flow/process queue task
   curation-queue verify Verify queue task checkpoints for a scope
-  import-lca convert  Convert supported external LCA packages through tidas-tools
+  import-lca convert  Import supported external LCA packages through the unified Rust tidas binary
   author              Extract source evidence and prepare TIDAS context packs for AI authoring
   patch apply          Apply AI-authored structured dataset patches deterministically
   save-draft           Save contact/source/support or other canonical dataset rows through the platform dataset command path
@@ -536,6 +536,9 @@ Options:
   --approve-plan <sha256> Exact SHA-256 recorded for the plan
   --confirm <email>      Current authenticated account email
   --timeout-ms <n>       Request timeout in milliseconds
+  --max-parallel <1-8>   Opt into bounded flow delete-only execution with durable dispatch ledger
+  --global-inbound-proof <file> Absolute path to a fresh all-process SELECT-only zero-inbound proof
+  --approve-global-inbound-proof <sha256> Exact SHA-256 of --global-inbound-proof; requires --max-parallel
   --json                 Print compact JSON
   -h, --help
 
@@ -832,30 +835,33 @@ function renderDatasetImportLcaHelp() {
 
 Options:
   --input <path>          Source file, directory, or package to import
-  --output-dir <dir>      Output directory for generated package and reports
+  --output-dir <dir>      Output directory atomically published by tidas
   --from-format <format>  auto, ecospold1, ecospold2, openlca-jsonld, openlca-process-xlsx, simapro-csv, ilcd
   --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)
-  --process-bundles       Write per-process dependency bundles (default: enabled by tidas-tools)
-  --process-bundles-dir <dir>
-                           Custom per-process bundle directory (default: <output-dir>/process-bundles)
+  --report <file>         Persist the native operation report atomically instead of using tidas stdout
+  --write-mapping         Write deterministic mapping.csv.gz
   --no-process-bundles    Disable per-process dependency bundle generation
-  --detect-only           Only detect the input format and write the report
   --fail-on-warning       Return non-zero when converter warnings are present
-  --python <bin>          Python executable (default: python3)
-  --tidas-tools-dir <dir> Explicit tidas-tools checkout path
+  --max-entry-mib <n>     Maximum source-entry size in MiB (tidas default: 128)
+  --memory-budget-mib <n> Maximum accounted in-flight memory in MiB (tidas default: 512)
+  --queue-capacity <n>    Maximum items in each bounded queue (tidas default: 256)
+  --tidas-bin <path>      Rust tidas executable (default: TIDAS_BIN, then tidas on PATH)
+  --tidas-config <path>   Explicit tidas config file (otherwise TIDAS_CONFIG is honored)
   --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
-  - process-bundles/ when not detect-only and process bundles are enabled
-  - outputs/import-lca-report.json
+  - import-report.json and issues.jsonl
+  - tidas/ when target includes TIDAS
+  - ilcd/ when target includes ILCD
+  - process-bundles/ by default
+  - mapping.csv.gz when --write-mapping is used
+
+Runtime contract:
+  - Linux x86_64/ARM64, macOS Intel/Apple Silicon, and Windows x86_64 are supported.
+  - Windows ARM64 is unsupported.
+  - The binary must report tidas.operation-report.v1 and a stable 0.2.x version.
+  - Import publication, cancellation cleanup, and domain validation remain owned by Rust tidas.
 `.trim();
 }
 function renderDatasetAuthorHelp() {
@@ -2853,16 +2859,14 @@ function parseDatasetImportLcaConvertFlags(args) {
                 'from-format': { type: 'string' },
                 target: { type: 'string' },
                 report: { type: 'string' },
-                'mapping-dir': { type: 'string' },
-                language: { type: 'string' },
-                'validation-jobs': { type: 'string' },
-                'process-bundles': { type: 'boolean' },
-                'process-bundles-dir': { type: 'string' },
+                'write-mapping': { type: 'boolean' },
                 'no-process-bundles': { type: 'boolean' },
-                'detect-only': { type: 'boolean' },
                 'fail-on-warning': { type: 'boolean' },
-                python: { type: 'string' },
-                'tidas-tools-dir': { type: 'string' },
+                'max-entry-mib': { type: 'string' },
+                'memory-budget-mib': { type: 'string' },
+                'queue-capacity': { type: 'string' },
+                'tidas-bin': { type: 'string' },
+                'tidas-config': { type: 'string' },
             },
         }));
     }
@@ -2872,25 +2876,9 @@ function parseDatasetImportLcaConvertFlags(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,
-        });
-    }
-    if (values['process-bundles'] && values['no-process-bundles']) {
-        throw new CliError('--process-bundles and --no-process-bundles cannot both be set.', {
-            code: 'DATASET_IMPORT_LCA_PROCESS_BUNDLES_INVALID',
-            exitCode: 2,
-        });
-    }
-    if (values['no-process-bundles'] && typeof values['process-bundles-dir'] === 'string') {
-        throw new CliError('--process-bundles-dir cannot be used with --no-process-bundles.', {
-            code: 'DATASET_IMPORT_LCA_PROCESS_BUNDLES_INVALID',
-            exitCode: 2,
-        });
-    }
+    const maxEntryMib = parsePositiveIntegerFlag(values['max-entry-mib'], '--max-entry-mib');
+    const memoryBudgetMib = parsePositiveIntegerFlag(values['memory-budget-mib'], '--memory-budget-mib');
+    const queueCapacity = parsePositiveIntegerFlag(values['queue-capacity'], '--queue-capacity');
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
@@ -2899,21 +2887,29 @@ function parseDatasetImportLcaConvertFlags(args) {
         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,
-        processBundles: values['no-process-bundles']
-            ? false
-            : values['process-bundles']
-                ? true
-                : undefined,
-        processBundlesDir: typeof values['process-bundles-dir'] === 'string' ? values['process-bundles-dir'] : undefined,
-        detectOnly: Boolean(values['detect-only']),
+        writeMapping: Boolean(values['write-mapping']),
+        processBundles: values['no-process-bundles'] ? false : undefined,
         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,
+        maxEntryMib,
+        memoryBudgetMib,
+        queueCapacity,
+        tidasBin: typeof values['tidas-bin'] === 'string' ? values['tidas-bin'] : undefined,
+        tidasConfig: typeof values['tidas-config'] === 'string' ? values['tidas-config'] : undefined,
     };
 }
+function parsePositiveIntegerFlag(value, flag) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new CliError(`${flag} must be a positive integer.`, {
+            code: 'DATASET_IMPORT_LCA_RUNTIME_BOUND_INVALID',
+            exitCode: 2,
+        });
+    }
+    return parsed;
+}
 function parseDatasetAuthorFlags(args) {
     let values;
     try {
@@ -3459,6 +3455,9 @@ function parseDatasetMaintenanceApplyFlags(args) {
                 confirm: { type: 'string' },
                 'timeout-ms': { type: 'string' },
                 'dry-run': { type: 'boolean' },
+                'max-parallel': { type: 'string' },
+                'global-inbound-proof': { type: 'string' },
+                'approve-global-inbound-proof': { type: 'string' },
             },
         }));
     }
@@ -3468,6 +3467,38 @@ function parseDatasetMaintenanceApplyFlags(args) {
             exitCode: 2,
         });
     }
+    const maxParallelValue = values['max-parallel'];
+    const maxParallel = typeof maxParallelValue === 'string' && /^\d+$/u.test(maxParallelValue)
+        ? Number.parseInt(maxParallelValue, 10)
+        : maxParallelValue === undefined
+            ? undefined
+            : Number.NaN;
+    if (maxParallel !== undefined &&
+        (!Number.isInteger(maxParallel) || maxParallel < 1 || maxParallel > 8)) {
+        throw new CliError('--max-parallel must be an integer from 1 to 8.', {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    const globalInboundProofPath = typeof values['global-inbound-proof'] === 'string' ? values['global-inbound-proof'] : '';
+    const approveGlobalInboundProof = typeof values['approve-global-inbound-proof'] === 'string'
+        ? values['approve-global-inbound-proof']
+        : '';
+    if (Boolean(globalInboundProofPath) !== Boolean(approveGlobalInboundProof)) {
+        throw new CliError('--global-inbound-proof and --approve-global-inbound-proof must be provided together.', { code: 'INVALID_ARGS', exitCode: 2 });
+    }
+    if (globalInboundProofPath && maxParallel === undefined) {
+        throw new CliError('Global inbound proof flags require --max-parallel.', {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
+    if (approveGlobalInboundProof && !/^[0-9a-f]{64}$/u.test(approveGlobalInboundProof)) {
+        throw new CliError('--approve-global-inbound-proof must be a lowercase SHA-256.', {
+            code: 'INVALID_ARGS',
+            exitCode: 2,
+        });
+    }
     return {
         help: Boolean(values.help),
         json: Boolean(values.json),
@@ -3477,6 +3508,9 @@ function parseDatasetMaintenanceApplyFlags(args) {
         confirm: typeof values.confirm === 'string' ? values.confirm : '',
         timeoutMs: parseDatasetMaintenancePositiveInteger(values['timeout-ms'], '--timeout-ms'),
         dryRun: Boolean(values['dry-run']),
+        maxParallel,
+        globalInboundProofPath,
+        approveGlobalInboundProof,
     };
 }
 function parseDatasetMaintenanceFreezeProtectedFlags(args) {
@@ -5741,19 +5775,18 @@ export async function executeCli(argv, deps) {
                 fromFormat: datasetFlags.fromFormat,
                 target: datasetFlags.target,
                 reportPath: datasetFlags.reportPath,
-                mappingDir: datasetFlags.mappingDir,
-                language: datasetFlags.language,
-                validationJobs: datasetFlags.validationJobs,
+                writeMapping: datasetFlags.writeMapping,
                 processBundles: datasetFlags.processBundles,
-                processBundlesDir: datasetFlags.processBundlesDir,
-                detectOnly: datasetFlags.detectOnly,
                 failOnWarning: datasetFlags.failOnWarning,
-                pythonBin: datasetFlags.pythonBin,
-                tidasToolsDir: datasetFlags.tidasToolsDir,
+                maxEntryMib: datasetFlags.maxEntryMib,
+                memoryBudgetMib: datasetFlags.memoryBudgetMib,
+                queueCapacity: datasetFlags.queueCapacity,
+                tidasBin: datasetFlags.tidasBin,
+                tidasConfig: datasetFlags.tidasConfig,
                 env: deps.env,
             });
             return {
-                exitCode: report.status === 'completed' ? 0 : 1,
+                exitCode: report.exit_code,
                 stdout: stringifyJson(report, datasetFlags.json),
                 stderr: '',
             };
@@ -6401,11 +6434,16 @@ export async function executeCli(argv, deps) {
                     approvePlan: datasetFlags.approvePlan,
                     confirm: datasetFlags.confirm,
                     timeoutMs: datasetFlags.timeoutMs,
+                    maxParallel: datasetFlags.maxParallel,
+                    globalInboundProofPath: datasetFlags.globalInboundProofPath || undefined,
+                    approveGlobalInboundProof: datasetFlags.approveGlobalInboundProof || undefined,
                     env: deps.env,
                     fetchImpl: deps.fetchImpl,
                 });
                 return {
-                    exitCode: report.status === 'completed_with_failures' ? 1 : 0,
+                    exitCode: ['completed_with_failures', 'completed_with_unknowns'].includes(report.status)
+                        ? 1
+                        : 0,
                     stdout: stringifyJson(report, datasetFlags.json),
                     stderr: '',
                 };