@tiangong-lca/cli 0.0.1

package/dist/src/lib/process-auto-build.js

@@ -0,0 +1,717 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import { writeJsonArtifact } from './artifacts.js';
+import { CliError } from './errors.js';
+import { readJsonInput } from './io.js';
+import { buildRunManifest, buildUtcTimestamp, ensureRunLayout, sanitizeRunToken, writeLatestRunId, } from './run.js';
+import { withStateFileLock } from './state-lock.js';
+const DEFAULT_SOURCE_POLICY = {
+    step1_route: {
+        preferred: ['user_bundle', 'kb_bundle'],
+        fallback: 'expert_judgement',
+    },
+    step2_process_split: {
+        preferred: ['user_bundle.process_split', 'si_bundle', 'kb_bundle.process_split'],
+        fallback: 'expert_judgement',
+    },
+    step3b_exchange_values: {
+        preferred: ['user_bundle.exchange_values', 'si_bundle', 'kb_bundle.exchange_values'],
+        require_numeric_evidence: true,
+        allow_estimation: true,
+    },
+};
+const PROCESS_AUTO_BUILD_STAGES = [
+    {
+        id: '01_route',
+        title: 'Route planning',
+        output: 'stage_outputs/01_route/route_plan.json',
+        createsCandidatesDir: true,
+        modules: ['kb-search', 'llm'],
+    },
+    {
+        id: '02_process_split',
+        title: 'Process chain split',
+        output: 'stage_outputs/02_process_split/process_chain.json',
+        createsCandidatesDir: true,
+        modules: ['llm'],
+    },
+    {
+        id: '03_exchange_plan',
+        title: 'Exchange planning',
+        output: 'stage_outputs/03_exchange_plan/exchange_plan.json',
+        createsCandidatesDir: false,
+        modules: ['llm'],
+    },
+    {
+        id: '04_exchange_values',
+        title: 'Exchange value extraction',
+        output: 'stage_outputs/04_exchange_values/exchange_values.json',
+        createsCandidatesDir: true,
+        modules: ['unstructured', 'kb-search', 'llm'],
+    },
+    {
+        id: '05_chain_review',
+        title: 'Chain review',
+        output: 'stage_outputs/05_chain_review/chain_review.json',
+        createsCandidatesDir: false,
+        modules: ['llm'],
+    },
+    {
+        id: '06_flow_match',
+        title: 'Flow matching',
+        output: 'stage_outputs/06_flow_match/flow_match_bundle.json',
+        createsCandidatesDir: false,
+        modules: ['search:flow', 'llm'],
+    },
+    {
+        id: '07_source_build',
+        title: 'Source dataset build',
+        output: 'stage_outputs/07_source_build/source_bundle.json',
+        createsCandidatesDir: false,
+        modules: ['validation'],
+    },
+    {
+        id: '08_process_build',
+        title: 'Process dataset build',
+        output: 'stage_outputs/08_process_build/process_bundle.json',
+        createsCandidatesDir: false,
+        modules: ['validation', 'llm'],
+    },
+    {
+        id: '09_qa',
+        title: 'QA and balance review',
+        output: 'stage_outputs/09_qa/qa_bundle.json',
+        createsCandidatesDir: false,
+        modules: ['validation', 'llm'],
+    },
+    {
+        id: '10_publish',
+        title: 'Publish handoff',
+        output: 'stage_outputs/10_publish/publish_bundle.json',
+        createsCandidatesDir: false,
+        modules: ['publish'],
+    },
+];
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function nonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized || null;
+}
+function extractText(value) {
+    const direct = nonEmptyString(value);
+    if (direct) {
+        return direct;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const extracted = extractText(item);
+            if (extracted) {
+                return extracted;
+            }
+        }
+        return null;
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    if ('#text' in value) {
+        return nonEmptyString(value['#text']);
+    }
+    return null;
+}
+function requiredRequestObject(input) {
+    if (!isRecord(input)) {
+        throw new CliError('process auto-build request must be a JSON object.', {
+            code: 'PROCESS_AUTO_BUILD_REQUEST_INVALID',
+            exitCode: 2,
+        });
+    }
+    return input;
+}
+function requiredRequestString(input, key) {
+    const value = nonEmptyString(input[key]);
+    if (!value) {
+        throw new CliError(`process auto-build request is missing '${key}'.`, {
+            code: 'PROCESS_AUTO_BUILD_REQUEST_INVALID',
+            exitCode: 2,
+            details: { key },
+        });
+    }
+    return value;
+}
+function normalizeOperation(value) {
+    const normalized = nonEmptyString(value);
+    if (!normalized) {
+        return 'produce';
+    }
+    if (normalized === 'produce' || normalized === 'treat') {
+        return normalized;
+    }
+    throw new CliError("process auto-build operation must be 'produce' or 'treat'.", {
+        code: 'PROCESS_AUTO_BUILD_OPERATION_INVALID',
+        exitCode: 2,
+        details: normalized,
+    });
+}
+function normalizePreferredList(value, fallback) {
+    if (!Array.isArray(value)) {
+        return [...fallback];
+    }
+    const normalized = value
+        .map((entry) => nonEmptyString(entry))
+        .filter((entry) => Boolean(entry));
+    return normalized.length ? normalized : [...fallback];
+}
+function normalizeBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function buildDefaultSourcePolicy() {
+    return {
+        step1_route: {
+            preferred: [...DEFAULT_SOURCE_POLICY.step1_route.preferred],
+            fallback: DEFAULT_SOURCE_POLICY.step1_route.fallback,
+        },
+        step2_process_split: {
+            preferred: [...DEFAULT_SOURCE_POLICY.step2_process_split.preferred],
+            fallback: DEFAULT_SOURCE_POLICY.step2_process_split.fallback,
+        },
+        step3b_exchange_values: {
+            preferred: [...DEFAULT_SOURCE_POLICY.step3b_exchange_values.preferred],
+            require_numeric_evidence: DEFAULT_SOURCE_POLICY.step3b_exchange_values.require_numeric_evidence,
+            allow_estimation: DEFAULT_SOURCE_POLICY.step3b_exchange_values.allow_estimation,
+        },
+    };
+}
+function normalizeSourcePolicy(value) {
+    if (!isRecord(value)) {
+        return buildDefaultSourcePolicy();
+    }
+    const defaults = buildDefaultSourcePolicy();
+    const step1Route = isRecord(value.step1_route) ? value.step1_route : {};
+    const step2ProcessSplit = isRecord(value.step2_process_split) ? value.step2_process_split : {};
+    const step3ExchangeValues = isRecord(value.step3b_exchange_values)
+        ? value.step3b_exchange_values
+        : {};
+    return {
+        step1_route: {
+            preferred: normalizePreferredList(step1Route.preferred, defaults.step1_route.preferred),
+            fallback: nonEmptyString(step1Route.fallback) ?? DEFAULT_SOURCE_POLICY.step1_route.fallback,
+        },
+        step2_process_split: {
+            preferred: normalizePreferredList(step2ProcessSplit.preferred, defaults.step2_process_split.preferred),
+            fallback: nonEmptyString(step2ProcessSplit.fallback) ??
+                DEFAULT_SOURCE_POLICY.step2_process_split.fallback,
+        },
+        step3b_exchange_values: {
+            preferred: normalizePreferredList(step3ExchangeValues.preferred, defaults.step3b_exchange_values.preferred),
+            require_numeric_evidence: normalizeBoolean(step3ExchangeValues.require_numeric_evidence, DEFAULT_SOURCE_POLICY.step3b_exchange_values.require_numeric_evidence),
+            allow_estimation: normalizeBoolean(step3ExchangeValues.allow_estimation, DEFAULT_SOURCE_POLICY.step3b_exchange_values.allow_estimation),
+        },
+    };
+}
+function extractFlowDatasetRoot(payload) {
+    if (!isRecord(payload)) {
+        throw new CliError('process auto-build flow file must contain a JSON object.', {
+            code: 'PROCESS_AUTO_BUILD_FLOW_INVALID',
+            exitCode: 2,
+        });
+    }
+    if (isRecord(payload.flowDataSet)) {
+        return {
+            flowPayload: payload,
+            flowDataset: payload.flowDataSet,
+            wrapper: 'flowDataSet',
+        };
+    }
+    return {
+        flowPayload: payload,
+        flowDataset: payload,
+        wrapper: 'direct',
+    };
+}
+function extractFlowSummary(flowDataset, wrapper) {
+    const flowInformation = isRecord(flowDataset.flowInformation) ? flowDataset.flowInformation : {};
+    const dataSetInformation = isRecord(flowInformation.dataSetInformation)
+        ? flowInformation.dataSetInformation
+        : {};
+    const administrativeInformation = isRecord(flowDataset.administrativeInformation)
+        ? flowDataset.administrativeInformation
+        : {};
+    const publicationAndOwnership = isRecord(administrativeInformation.publicationAndOwnership)
+        ? administrativeInformation.publicationAndOwnership
+        : {};
+    const name = isRecord(dataSetInformation.name) ? dataSetInformation.name : {};
+    return {
+        wrapper,
+        uuid: nonEmptyString(dataSetInformation['common:UUID']) ??
+            nonEmptyString(flowDataset['@id']) ??
+            null,
+        version: nonEmptyString(publicationAndOwnership['common:dataSetVersion']) ??
+            nonEmptyString(flowDataset['@version']) ??
+            null,
+        base_name: extractText(name.baseName),
+        permanent_uri: nonEmptyString(publicationAndOwnership['common:permanentDataSetURI']) ?? null,
+    };
+}
+function runIdToken(value, fallback) {
+    return sanitizeRunToken(value ?? '', fallback);
+}
+function buildProcessAutoBuildRunId(flowFilePath, operation, summary, now = new Date()) {
+    const stem = path.basename(flowFilePath, path.extname(flowFilePath));
+    const parts = stem.split('_');
+    const flowCode = runIdToken(parts[0] || summary.base_name || summary.uuid, 'flow');
+    const flowUuidShort = runIdToken(parts[1] || summary.uuid, 'unknown').slice(0, 8);
+    const operationToken = operation === 'treat' ? 'treat' : 'produce';
+    return `pfw_${flowCode}_${flowUuidShort}_${operationToken}_${buildUtcTimestamp(now)}`;
+}
+function resolveRunRoot(requestDir, runId, outDirOverride, requestRunRoot) {
+    const override = nonEmptyString(outDirOverride);
+    if (override) {
+        return path.resolve(requestDir, override);
+    }
+    const requestValue = nonEmptyString(requestRunRoot);
+    if (requestValue) {
+        return path.resolve(requestDir, requestValue);
+    }
+    return path.join(requestDir, 'artifacts', 'process_from_flow', runId);
+}
+function normalizeSourceInputType(value) {
+    const normalized = nonEmptyString(value);
+    if (normalized === 'local_file' || normalized === 'local_text') {
+        return normalized;
+    }
+    throw new CliError("process auto-build source_inputs[].type must be 'local_file' or 'local_text'.", {
+        code: 'PROCESS_AUTO_BUILD_SOURCE_INVALID',
+        exitCode: 2,
+        details: { value },
+    });
+}
+function normalizeIntendedRoles(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => nonEmptyString(entry))
+        .filter((entry) => Boolean(entry));
+}
+function normalizeSourceInputs(value, requestDir, evidenceIncomingDir) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new CliError('process auto-build source_inputs must be an array when provided.', {
+            code: 'PROCESS_AUTO_BUILD_SOURCE_INVALID',
+            exitCode: 2,
+        });
+    }
+    const seenIds = new Set();
+    return value.map((entry, index) => {
+        if (!isRecord(entry)) {
+            throw new CliError('process auto-build source_inputs entries must be objects.', {
+                code: 'PROCESS_AUTO_BUILD_SOURCE_INVALID',
+                exitCode: 2,
+                details: { index },
+            });
+        }
+        const sourceId = requiredRequestString(entry, 'source_id');
+        if (seenIds.has(sourceId)) {
+            throw new CliError(`Duplicate process auto-build source_id: ${sourceId}`, {
+                code: 'PROCESS_AUTO_BUILD_SOURCE_DUPLICATE',
+                exitCode: 2,
+            });
+        }
+        seenIds.add(sourceId);
+        const sourcePath = path.resolve(requestDir, requiredRequestString(entry, 'path'));
+        if (!existsSync(sourcePath)) {
+            throw new CliError(`process auto-build source input not found: ${sourcePath}`, {
+                code: 'PROCESS_AUTO_BUILD_SOURCE_NOT_FOUND',
+                exitCode: 2,
+            });
+        }
+        const extension = path.extname(sourcePath);
+        const artifactFileName = `${String(index + 1).padStart(2, '0')}_${runIdToken(sourceId, 'source')}${extension}`;
+        return {
+            source_id: sourceId,
+            type: normalizeSourceInputType(entry.type),
+            source_path: sourcePath,
+            artifact_file_name: artifactFileName,
+            artifact_path: path.join(evidenceIncomingDir, artifactFileName),
+            intended_roles: normalizeIntendedRoles(entry.intended_roles),
+        };
+    });
+}
+function buildLayout(runRoot, runId) {
+    const collectionDir = path.dirname(runRoot);
+    const layout = {
+        namespace: 'process_from_flow',
+        runId,
+        artifactsRoot: path.dirname(collectionDir),
+        collectionDir,
+        runRoot,
+        cacheDir: path.join(runRoot, 'cache'),
+        inputsDir: path.join(runRoot, 'input'),
+        outputsDir: path.join(runRoot, 'exports'),
+        reportsDir: path.join(runRoot, 'reports'),
+        logsDir: path.join(runRoot, 'logs'),
+        manifestsDir: path.join(runRoot, 'manifests'),
+        latestRunIdPath: path.join(collectionDir, '.latest_run_id'),
+    };
+    return {
+        ...layout,
+        requestDir: path.join(runRoot, 'request'),
+        evidenceDir: path.join(runRoot, 'evidence'),
+        evidenceIncomingDir: path.join(runRoot, 'evidence', 'incoming'),
+        evidenceNormalizedDir: path.join(runRoot, 'evidence', 'normalized'),
+        evidenceTextDir: path.join(runRoot, 'evidence', 'text'),
+        evidenceStructuredDir: path.join(runRoot, 'evidence', 'structured'),
+        stageOutputsDir: path.join(runRoot, 'stage_outputs'),
+        reviewsDir: path.join(runRoot, 'reviews'),
+        requestSnapshotPath: path.join(runRoot, 'request', 'pff-request.json'),
+        normalizedRequestPath: path.join(runRoot, 'request', 'request.normalized.json'),
+        sourcePolicyPath: path.join(runRoot, 'request', 'source-policy.json'),
+        flowSummaryPath: path.join(runRoot, 'manifests', 'flow-summary.json'),
+        inputManifestPath: path.join(runRoot, 'input', 'input_manifest.json'),
+        assemblyPlanPath: path.join(runRoot, 'manifests', 'assembly-plan.json'),
+        lineageManifestPath: path.join(runRoot, 'manifests', 'lineage-manifest.json'),
+        invocationIndexPath: path.join(runRoot, 'manifests', 'invocation-index.json'),
+        runManifestPath: path.join(runRoot, 'manifests', 'run-manifest.json'),
+        reportPath: path.join(runRoot, 'reports', 'process-auto-build-report.json'),
+        statePath: path.join(runRoot, 'cache', 'process_from_flow_state.json'),
+        handoffSummaryPath: path.join(runRoot, 'cache', 'agent_handoff_summary.json'),
+        processExportsDir: path.join(runRoot, 'exports', 'processes'),
+        sourceExportsDir: path.join(runRoot, 'exports', 'sources'),
+    };
+}
+function ensureEmptyRunRoot(runRoot) {
+    if (!existsSync(runRoot)) {
+        return;
+    }
+    const entries = readdirSync(runRoot);
+    if (entries.length > 0) {
+        throw new CliError(`process auto-build run root already exists and is not empty: ${runRoot}`, {
+            code: 'PROCESS_AUTO_BUILD_RUN_EXISTS',
+            exitCode: 2,
+        });
+    }
+}
+function ensureProcessAutoBuildLayout(layout) {
+    ensureRunLayout(layout);
+    [
+        layout.requestDir,
+        layout.evidenceDir,
+        layout.evidenceIncomingDir,
+        layout.evidenceNormalizedDir,
+        layout.evidenceTextDir,
+        layout.evidenceStructuredDir,
+        layout.stageOutputsDir,
+        layout.reviewsDir,
+        layout.processExportsDir,
+        layout.sourceExportsDir,
+    ].forEach((dirPath) => {
+        mkdirSync(dirPath, { recursive: true });
+    });
+    for (const stage of PROCESS_AUTO_BUILD_STAGES) {
+        const stageDir = path.join(layout.stageOutputsDir, stage.id);
+        mkdirSync(stageDir, { recursive: true });
+        if (stage.createsCandidatesDir) {
+            mkdirSync(path.join(stageDir, 'candidates'), { recursive: true });
+        }
+    }
+}
+function copyArtifactFile(sourcePath, targetPath, code) {
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    try {
+        copyFileSync(sourcePath, targetPath);
+    }
+    catch (error) {
+        throw new CliError(`Failed to copy artifact file: ${sourcePath}`, {
+            code,
+            exitCode: 1,
+            details: String(error),
+        });
+    }
+}
+function buildAssemblyPlan(runRoot) {
+    return {
+        schema_version: 1,
+        stages: PROCESS_AUTO_BUILD_STAGES.map((stage) => ({
+            id: stage.id,
+            title: stage.title,
+            status: 'pending',
+            modules: stage.modules,
+            output: stage.output,
+            candidates_dir: stage.createsCandidatesDir
+                ? path.posix.join(path.posix.dirname(stage.output), 'candidates')
+                : null,
+            output_abs: path.join(runRoot, stage.output),
+        })),
+    };
+}
+function buildLineageManifest(normalized) {
+    return {
+        schema_version: 1,
+        request_id: normalized.request_id,
+        run_id: normalized.run_id,
+        flow: {
+            source_path: normalized.flow_file,
+            uuid: normalized.flow_summary.uuid,
+            version: normalized.flow_summary.version,
+            base_name: normalized.flow_summary.base_name,
+        },
+        source_inputs: normalized.source_inputs.map((source) => ({
+            source_id: source.source_id,
+            type: source.type,
+            source_path: source.source_path,
+            artifact_path: source.artifact_path,
+            intended_roles: source.intended_roles,
+        })),
+    };
+}
+function buildInvocationIndex(normalized, options, reportPath, now) {
+    const command = ['process', 'auto-build', '--input', options.inputPath];
+    if (options.outDir) {
+        command.push('--out-dir', options.outDir);
+    }
+    return {
+        schema_version: 1,
+        invocations: [
+            {
+                command,
+                cwd: options.cwd ?? process.cwd(),
+                created_at: now.toISOString(),
+                request_path: normalized.request_path,
+                report_path: reportPath,
+            },
+        ],
+    };
+}
+function buildStepMarkers(now) {
+    const completedAt = now.toISOString();
+    const markers = {
+        intake_prepared: {
+            status: 'completed',
+            completed_at: completedAt,
+        },
+    };
+    PROCESS_AUTO_BUILD_STAGES.forEach((stage) => {
+        markers[stage.id] = {
+            status: 'pending',
+        };
+    });
+    return markers;
+}
+function buildInitialState(normalized, flowArtifactPath, now) {
+    return {
+        schema_version: 1,
+        build_status: 'intake_prepared',
+        next_stage: PROCESS_AUTO_BUILD_STAGES[0]?.id ?? null,
+        run_id: normalized.run_id,
+        request_id: normalized.request_id,
+        flow_path: normalized.flow_file,
+        flow_artifact_path: flowArtifactPath,
+        flow_dataset: normalized.flow_dataset,
+        flow_summary: normalized.flow_summary,
+        operation: normalized.operation,
+        source_inputs: normalized.source_inputs,
+        source_policy: normalized.source_policy,
+        scientific_references: {
+            source_inputs: normalized.source_inputs.map((source) => ({
+                source_id: source.source_id,
+                type: source.type,
+                intended_roles: source.intended_roles,
+                source_path: source.source_path,
+            })),
+        },
+        processes: [],
+        process_exchanges: [],
+        matched_process_exchanges: [],
+        process_datasets: [],
+        source_datasets: [],
+        coverage_metrics: {},
+        coverage_history: [],
+        step_markers: buildStepMarkers(now),
+    };
+}
+function buildNextActions(layout, normalized) {
+    return [
+        `inspect: ${layout.normalizedRequestPath}`,
+        `inspect: ${layout.statePath}`,
+        `inspect: ${layout.assemblyPlanPath}`,
+        `future: tiangong process resume-build --run-id ${normalized.run_id}`,
+        `future: tiangong process publish-build --run-id ${normalized.run_id}`,
+    ];
+}
+function buildAgentHandoffSummary(normalized, layout, flowArtifactPath, now) {
+    return {
+        schema_version: 1,
+        generated_at_utc: now.toISOString(),
+        run_id: normalized.run_id,
+        command: 'process auto-build',
+        flow_path: normalized.flow_file,
+        operation: normalized.operation,
+        stop_after: null,
+        process_count: 0,
+        matched_exchange_count: 0,
+        process_dataset_count: 0,
+        source_dataset_count: 0,
+        remaining_placeholder_refs: 0,
+        placeholder_examples: [],
+        publish_summary: {},
+        artifacts: {
+            state_path: layout.statePath,
+            timing_report: null,
+            publish_summary: null,
+            llm_cost_report: null,
+            process_update_report: null,
+            flow_auto_build_manifest: null,
+            request_snapshot: layout.requestSnapshotPath,
+            normalized_request: layout.normalizedRequestPath,
+            assembly_plan: layout.assemblyPlanPath,
+            flow_copy: flowArtifactPath,
+        },
+        next_actions: buildNextActions(layout, normalized),
+        extra: {
+            status: 'prepared_local_process_auto_build_run',
+            request_id: normalized.request_id,
+            source_input_count: normalized.source_inputs.length,
+        },
+    };
+}
+function buildReport(normalized, layout, flowArtifactPath, now) {
+    return {
+        schema_version: 1,
+        generated_at_utc: now.toISOString(),
+        status: 'prepared_local_process_auto_build_run',
+        request_path: normalized.request_path,
+        request_id: normalized.request_id,
+        run_id: normalized.run_id,
+        run_root: normalized.run_root,
+        operation: normalized.operation,
+        flow: {
+            source_path: normalized.flow_file,
+            artifact_path: flowArtifactPath,
+            wrapper: normalized.flow_summary.wrapper,
+            uuid: normalized.flow_summary.uuid,
+            version: normalized.flow_summary.version,
+            base_name: normalized.flow_summary.base_name,
+        },
+        source_input_count: normalized.source_inputs.length,
+        stage_count: PROCESS_AUTO_BUILD_STAGES.length,
+        files: {
+            request_snapshot: layout.requestSnapshotPath,
+            normalized_request: layout.normalizedRequestPath,
+            source_policy: layout.sourcePolicyPath,
+            flow_summary: layout.flowSummaryPath,
+            input_manifest: layout.inputManifestPath,
+            assembly_plan: layout.assemblyPlanPath,
+            lineage_manifest: layout.lineageManifestPath,
+            invocation_index: layout.invocationIndexPath,
+            run_manifest: layout.runManifestPath,
+            state: layout.statePath,
+            handoff_summary: layout.handoffSummaryPath,
+            report: layout.reportPath,
+        },
+        next_actions: buildNextActions(layout, normalized),
+    };
+}
+export function normalizeProcessAutoBuildRequest(input, options) {
+    const request = requiredRequestObject(input);
+    const requestDir = path.dirname(path.resolve(options.inputPath));
+    const operation = normalizeOperation(request.operation);
+    const flowFile = path.resolve(requestDir, requiredRequestString(request, 'flow_file'));
+    const flowPayload = readJsonInput(flowFile);
+    const { flowDataset, wrapper } = extractFlowDatasetRoot(flowPayload);
+    const flowSummary = extractFlowSummary(flowDataset, wrapper);
+    const runId = nonEmptyString(options.runIdOverride) ??
+        nonEmptyString(request.run_id) ??
+        buildProcessAutoBuildRunId(flowFile, operation, flowSummary, options.now);
+    const runRoot = resolveRunRoot(requestDir, runId, options.outDir, request.workspace_run_root);
+    const layout = buildLayout(runRoot, runId);
+    return {
+        schema_version: 1,
+        request_path: path.resolve(options.inputPath),
+        request_id: nonEmptyString(options.requestIdOverride) ??
+            nonEmptyString(request.request_id) ??
+            `pff-${runId}`,
+        flow_file: flowFile,
+        flow_summary: flowSummary,
+        flow_dataset: flowDataset,
+        operation,
+        run_id: runId,
+        run_root: runRoot,
+        source_inputs: normalizeSourceInputs(request.source_inputs, requestDir, layout.evidenceIncomingDir),
+        source_policy: normalizeSourcePolicy(request.source_policy),
+    };
+}
+export async function runProcessAutoBuild(options) {
+    const input = options.inputValue ?? readJsonInput(options.inputPath);
+    const now = options.now ?? new Date();
+    const normalized = normalizeProcessAutoBuildRequest(input, {
+        inputPath: options.inputPath,
+        outDir: options.outDir,
+        now,
+        requestIdOverride: options.requestIdOverride,
+        runIdOverride: options.runIdOverride,
+    });
+    const layout = buildLayout(normalized.run_root, normalized.run_id);
+    const flowArtifactPath = path.join(layout.inputsDir, path.basename(normalized.flow_file));
+    ensureEmptyRunRoot(layout.runRoot);
+    ensureProcessAutoBuildLayout(layout);
+    copyArtifactFile(normalized.flow_file, flowArtifactPath, 'PROCESS_AUTO_BUILD_FLOW_COPY_FAILED');
+    normalized.source_inputs.forEach((source) => {
+        copyArtifactFile(source.source_path, source.artifact_path, 'PROCESS_AUTO_BUILD_SOURCE_COPY_FAILED');
+    });
+    const request = requiredRequestObject(input);
+    writeJsonArtifact(layout.requestSnapshotPath, request);
+    writeJsonArtifact(layout.normalizedRequestPath, normalized);
+    writeJsonArtifact(layout.sourcePolicyPath, normalized.source_policy);
+    writeJsonArtifact(layout.flowSummaryPath, normalized.flow_summary);
+    writeJsonArtifact(layout.inputManifestPath, {
+        run_id: normalized.run_id,
+        flow_path: normalized.flow_file,
+        flow_artifact_path: flowArtifactPath,
+        operation: normalized.operation,
+    });
+    writeJsonArtifact(layout.assemblyPlanPath, buildAssemblyPlan(layout.runRoot));
+    writeJsonArtifact(layout.lineageManifestPath, buildLineageManifest(normalized));
+    writeJsonArtifact(layout.invocationIndexPath, buildInvocationIndex(normalized, options, layout.reportPath, now));
+    writeJsonArtifact(layout.runManifestPath, buildRunManifest({
+        layout,
+        command: options.outDir
+            ? ['process', 'auto-build', '--input', options.inputPath, '--out-dir', options.outDir]
+            : ['process', 'auto-build', '--input', options.inputPath],
+        cwd: options.cwd,
+        createdAt: now,
+    }));
+    const state = buildInitialState(normalized, flowArtifactPath, now);
+    await withStateFileLock(layout.statePath, { reason: 'process-auto-build.initial_state', now }, () => writeJsonArtifact(layout.statePath, state));
+    const handoff = buildAgentHandoffSummary(normalized, layout, flowArtifactPath, now);
+    writeJsonArtifact(layout.handoffSummaryPath, handoff);
+    writeLatestRunId(layout, normalized.run_id);
+    const report = buildReport(normalized, layout, flowArtifactPath, now);
+    writeJsonArtifact(layout.reportPath, report);
+    return report;
+}
+// Exposed for deterministic unit coverage of process auto-build normalization and scaffold helpers.
+export const __testInternals = {
+    PROCESS_AUTO_BUILD_STAGES,
+    extractText,
+    normalizeOperation,
+    normalizeSourcePolicy,
+    extractFlowDatasetRoot,
+    extractFlowSummary,
+    buildProcessAutoBuildRunId,
+    buildLayout,
+    buildAssemblyPlan,
+    buildLineageManifest,
+    buildInvocationIndex,
+    buildInitialState,
+    buildAgentHandoffSummary,
+    buildReport,
+};
+//# sourceMappingURL=process-auto-build.js.map