@tiangong-lca/cli 0.0.6 → 0.0.7

package/dist/src/lib/process-dedup-review.js

@@ -0,0 +1,870 @@
+import path from 'node:path';
+import { writeJsonArtifact } from './artifacts.js';
+import { CliError } from './errors.js';
+import { readJsonInput } from './io.js';
+import { deriveSupabaseProjectBaseUrl, requireSupabaseRestRuntime } from './supabase-client.js';
+import { resolveSupabaseUserSession } from './supabase-session.js';
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_MAX_RETRIES = 4;
+const DEFAULT_PAGE_SIZE = 100;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function trimText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function nowIso(now = new Date()) {
+    return now.toISOString();
+}
+function requiredNonEmpty(value, label, code) {
+    const normalized = value.trim();
+    if (!normalized) {
+        throw new CliError(`Missing required ${label}.`, {
+            code,
+            exitCode: 2,
+        });
+    }
+    return normalized;
+}
+function toPositiveInteger(value, label, code) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new CliError(`Expected ${label} to be a positive integer.`, {
+            code,
+            exitCode: 2,
+        });
+    }
+    return value;
+}
+function normalizeOptionalToken(value) {
+    const normalized = trimText(value);
+    return normalized ? normalized : null;
+}
+function asArray(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    if (value === null || value === undefined || value === '') {
+        return [];
+    }
+    return [value];
+}
+function toGroupId(value, fallback) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    const normalized = trimText(value);
+    if (!normalized) {
+        return fallback;
+    }
+    if (/^\d+$/u.test(normalized)) {
+        return Number.parseInt(normalized, 10);
+    }
+    return normalized;
+}
+function normalizeExchangeCount(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    const normalized = trimText(value);
+    if (!normalized) {
+        return null;
+    }
+    const parsed = Number.parseInt(normalized, 10);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+function normalizeAmount(value) {
+    const normalized = trimText(value);
+    if (!normalized) {
+        return '';
+    }
+    if (/^[+-]?\d+(?:\.\d+)?$/u.test(normalized)) {
+        let result = normalized.replace(/^\+/u, '');
+        result = result.replace(/^(-?)0+(?=\d)/u, '$1');
+        if (result.includes('.')) {
+            result = result.replace(/0+$/u, '').replace(/\.$/u, '');
+        }
+        if (result === '' || result === '-' || result === '-0') {
+            return '0';
+        }
+        return result;
+    }
+    const parsed = Number(normalized);
+    if (Number.isFinite(parsed)) {
+        return parsed.toString();
+    }
+    return normalized;
+}
+function getLangList(value) {
+    if (value === null || value === undefined || value === '') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.filter((entry) => isRecord(entry));
+    }
+    if (isRecord(value)) {
+        const langString = value['common:langString'];
+        if (Array.isArray(langString)) {
+            return langString.filter((entry) => isRecord(entry));
+        }
+        if (isRecord(langString)) {
+            return [langString];
+        }
+        if (value['#text'] !== undefined || value['@xml:lang'] !== undefined) {
+            return [value];
+        }
+    }
+    if (typeof value === 'string') {
+        return [{ '@xml:lang': 'en', '#text': value }];
+    }
+    return [];
+}
+function getLangText(value, lang) {
+    const entries = getLangList(value);
+    for (const entry of entries) {
+        if (trimText(entry['@xml:lang']).toLowerCase() === lang.toLowerCase() &&
+            trimText(entry['#text'])) {
+            return trimText(entry['#text']);
+        }
+    }
+    for (const entry of entries) {
+        if (trimText(entry['#text'])) {
+            return trimText(entry['#text']);
+        }
+    }
+    return '';
+}
+function normalizeExchangeSummaryRow(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const flowRef = isRecord(value.referenceToFlowDataSet) ? value.referenceToFlowDataSet : {};
+    const flowShortDescription = value.flow_short_description ?? flowRef['common:shortDescription'];
+    const normalized = {
+        exchange_internal_id: trimText(value.exchange_internal_id ?? value['@dataSetInternalID']),
+        flow_id: trimText(value.flow_id ?? flowRef['@refObjectId']),
+        flow_version: trimText(value.flow_version ?? flowRef['@version']),
+        direction: trimText(value.direction ?? value.exchangeDirection),
+        mean_amount: trimText(value.mean_amount ?? value.meanAmount),
+        resulting_amount: trimText(value.resulting_amount ?? value.resultingAmount),
+        flow_short_description_en: trimText(value.flow_short_description_en) || getLangText(flowShortDescription, 'en'),
+        flow_short_description_zh: trimText(value.flow_short_description_zh) || getLangText(flowShortDescription, 'zh'),
+    };
+    if (!normalized.exchange_internal_id &&
+        !normalized.flow_id &&
+        !normalized.direction &&
+        !normalized.mean_amount &&
+        !normalized.resulting_amount) {
+        return null;
+    }
+    return normalized;
+}
+function normalizeExchangeRows(value) {
+    return asArray(value)
+        .map((entry) => normalizeExchangeSummaryRow(entry))
+        .filter((entry) => entry !== null);
+}
+function normalizeInputProcess(value) {
+    if (!isRecord(value)) {
+        throw new CliError('Each process dedup candidate must be a JSON object.', {
+            code: 'PROCESS_DEDUP_INPUT_INVALID_PROCESS',
+            exitCode: 2,
+        });
+    }
+    const processId = requiredNonEmpty(trimText(value.process_id ?? value.id), 'process_id', 'PROCESS_DEDUP_PROCESS_ID_REQUIRED');
+    return {
+        process_id: processId,
+        version: trimText(value.version),
+        name_en: trimText(value.name_en ?? value.remote_name_en),
+        name_zh: trimText(value.name_zh ?? value.remote_name_zh),
+        exchange_count: normalizeExchangeCount(value.exchange_count),
+        overview_fingerprint: trimText(value.overview_fingerprint),
+        sheet_exchange_rows: normalizeExchangeRows(value.sheet_exchange_rows ??
+            value.analysis_exchanges ??
+            value.remote_exchanges ??
+            value.exchanges),
+    };
+}
+function normalizeInputGroup(value, fallbackGroupId, index) {
+    if (!isRecord(value)) {
+        throw new CliError('Each process dedup group must be a JSON object.', {
+            code: 'PROCESS_DEDUP_INPUT_INVALID_GROUP',
+            exitCode: 2,
+        });
+    }
+    const processes = asArray(value.processes).map((entry) => normalizeInputProcess(entry));
+    if (processes.length === 0) {
+        throw new CliError(`Process dedup group ${index + 1} is missing processes.`, {
+            code: 'PROCESS_DEDUP_GROUP_PROCESSES_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return {
+        group_id: toGroupId(value.group_id, fallbackGroupId),
+        processes,
+    };
+}
+function normalizeInputDocument(value, resolvedInputPath) {
+    if (!isRecord(value)) {
+        throw new CliError('Process dedup review input must be a JSON object.', {
+            code: 'PROCESS_DEDUP_INPUT_INVALID',
+            exitCode: 2,
+        });
+    }
+    const sourceLabel = trimText(value.source_label ?? value.source_workbook ?? value.source_file) ||
+        path.basename(resolvedInputPath);
+    const rawGroups = value.groups;
+    let groups = [];
+    if (Array.isArray(rawGroups)) {
+        groups = rawGroups.map((entry, index) => normalizeInputGroup(entry, String(index + 1), index));
+    }
+    else if (isRecord(rawGroups)) {
+        groups = Object.entries(rawGroups).map(([groupId, entry], index) => normalizeInputGroup(entry, groupId, index));
+    }
+    if (groups.length === 0) {
+        throw new CliError('Process dedup review input must contain at least one group.', {
+            code: 'PROCESS_DEDUP_GROUPS_REQUIRED',
+            exitCode: 2,
+        });
+    }
+    return {
+        sourceLabel,
+        groups,
+    };
+}
+async function parseJsonResponse(response, label) {
+    const text = await response.text();
+    const contentType = response.headers.get('content-type') ?? '';
+    if (!text.trim()) {
+        return null;
+    }
+    if (!contentType.includes('application/json')) {
+        return text;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new CliError(`${label} returned invalid JSON.`, {
+            code: 'PROCESS_DEDUP_REMOTE_INVALID_JSON',
+            exitCode: 1,
+            details: String(error),
+        });
+    }
+}
+async function fetchJsonWithRetry(options) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= options.maxRetries; attempt += 1) {
+        try {
+            const response = await options.fetchImpl(options.url, {
+                ...options.init,
+                signal: AbortSignal.timeout(options.timeoutMs),
+            });
+            const body = await parseJsonResponse(response, options.label);
+            if (!response.ok) {
+                throw new CliError(`${options.label} failed with ${response.status}.`, {
+                    code: 'PROCESS_DEDUP_REMOTE_REQUEST_FAILED',
+                    exitCode: 1,
+                    details: {
+                        status: response.status,
+                        body,
+                        url: options.url,
+                    },
+                });
+            }
+            return {
+                status: response.status,
+                headers: new Headers({
+                    'content-range': response.headers.get('content-range') ?? '',
+                    'content-type': response.headers.get('content-type') ?? '',
+                }),
+                body,
+            };
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= options.maxRetries) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, attempt * 1_500));
+        }
+    }
+    if (lastError instanceof CliError) {
+        throw lastError;
+    }
+    throw new CliError(`${options.label} failed after ${options.maxRetries} attempt(s).`, {
+        code: 'PROCESS_DEDUP_REMOTE_REQUEST_FAILED',
+        exitCode: 1,
+        details: String(lastError),
+    });
+}
+async function fetchCurrentUserId(options) {
+    const response = await fetchJsonWithRetry({
+        url: `${options.projectBaseUrl}/auth/v1/user`,
+        init: {
+            method: 'GET',
+            headers: {
+                apikey: options.publishableKey,
+                Authorization: `Bearer ${options.accessToken}`,
+                Accept: 'application/json',
+            },
+        },
+        label: 'supabase current-user lookup',
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        maxRetries: options.maxRetries,
+    });
+    if (!isRecord(response.body)) {
+        return null;
+    }
+    return normalizeOptionalToken(response.body.id);
+}
+async function resolveRemoteAuthContext(options) {
+    const runtime = requireSupabaseRestRuntime(options.env);
+    const session = await resolveSupabaseUserSession({
+        runtime,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        now: options.now,
+    });
+    const projectBaseUrl = deriveSupabaseProjectBaseUrl(runtime.apiBaseUrl);
+    let userId;
+    try {
+        userId = await fetchCurrentUserId({
+            projectBaseUrl,
+            publishableKey: runtime.publishableKey,
+            accessToken: session.accessToken,
+            fetchImpl: options.fetchImpl,
+            timeoutMs: options.timeoutMs,
+            maxRetries: options.maxRetries,
+        });
+    }
+    catch {
+        userId = null;
+    }
+    return {
+        projectBaseUrl,
+        publishableKey: runtime.publishableKey,
+        accessToken: session.accessToken,
+        userId,
+    };
+}
+function summarizeRemoteExchanges(processJson) {
+    if (!isRecord(processJson)) {
+        return [];
+    }
+    const processDataSet = isRecord(processJson.processDataSet) ? processJson.processDataSet : {};
+    const exchanges = isRecord(processDataSet.exchanges) ? processDataSet.exchanges.exchange : [];
+    return normalizeExchangeRows(exchanges);
+}
+async function fetchRemoteMetadata(options) {
+    if (options.processIds.length === 0) {
+        return {};
+    }
+    const url = new URL(`${options.auth.projectBaseUrl}/rest/v1/processes`);
+    url.searchParams.set('select', 'id,version,state_code,created_at,modified_at,user_id,team_id,model_id,json');
+    url.searchParams.set('id', `in.(${options.processIds.join(',')})`);
+    url.searchParams.set('order', 'id.asc');
+    const response = await fetchJsonWithRetry({
+        url: url.toString(),
+        init: {
+            method: 'GET',
+            headers: {
+                apikey: options.auth.publishableKey,
+                Authorization: `Bearer ${options.auth.accessToken}`,
+                Accept: 'application/json',
+            },
+        },
+        label: 'process dedup remote metadata fetch',
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        maxRetries: options.maxRetries,
+    });
+    const rows = Array.isArray(response.body) ? response.body : [];
+    const byId = {};
+    for (const row of rows) {
+        if (!isRecord(row)) {
+            continue;
+        }
+        const processId = trimText(row.id);
+        if (!processId) {
+            continue;
+        }
+        const payload = row.json;
+        const processDataSet = isRecord(payload) && isRecord(payload.processDataSet) ? payload.processDataSet : {};
+        const processInformation = isRecord(processDataSet.processInformation)
+            ? processDataSet.processInformation
+            : {};
+        const dataSetInformation = isRecord(processInformation.dataSetInformation)
+            ? processInformation.dataSetInformation
+            : {};
+        const name = isRecord(dataSetInformation.name) ? dataSetInformation.name : {};
+        byId[processId] = {
+            process_id: processId,
+            version: trimText(row.version),
+            state_code: typeof row.state_code === 'number' ? row.state_code : null,
+            created_at: normalizeOptionalToken(row.created_at),
+            modified_at: normalizeOptionalToken(row.modified_at),
+            user_id: normalizeOptionalToken(row.user_id),
+            team_id: normalizeOptionalToken(row.team_id),
+            model_id: normalizeOptionalToken(row.model_id),
+            remote_name_en: getLangText(name.baseName, 'en'),
+            remote_name_zh: getLangText(name.baseName, 'zh'),
+            remote_exchanges: summarizeRemoteExchanges(payload),
+        };
+    }
+    return byId;
+}
+async function fetchCurrentUserRows(options) {
+    const rows = [];
+    let offset = 0;
+    let total = null;
+    while (total === null || offset < total) {
+        const url = new URL(`${options.auth.projectBaseUrl}/rest/v1/${options.tableName}`);
+        url.searchParams.set('select', options.select);
+        url.searchParams.set('user_id', `eq.${options.userId}`);
+        url.searchParams.set('order', 'id.asc');
+        url.searchParams.set('limit', String(DEFAULT_PAGE_SIZE));
+        url.searchParams.set('offset', String(offset));
+        const page = await fetchJsonWithRetry({
+            url: url.toString(),
+            init: {
+                method: 'GET',
+                headers: {
+                    apikey: options.auth.publishableKey,
+                    Authorization: `Bearer ${options.auth.accessToken}`,
+                    Accept: 'application/json',
+                    Prefer: total === null ? 'count=exact' : 'count=planned',
+                },
+            },
+            label: `${options.tableName} current-user reference scan`,
+            fetchImpl: options.fetchImpl,
+            timeoutMs: options.timeoutMs,
+            maxRetries: options.maxRetries,
+        });
+        const pageRows = Array.isArray(page.body) ? page.body : [];
+        rows.push(...pageRows);
+        if (total === null) {
+            const contentRange = page.headers.get('content-range');
+            const match = contentRange ? contentRange.match(/\/(\d+)$/u) : null;
+            total = match ? Number.parseInt(match[1], 10) : rows.length;
+        }
+        if (pageRows.length === 0) {
+            break;
+        }
+        offset += DEFAULT_PAGE_SIZE;
+    }
+    return rows;
+}
+function collectReferenceHits(root, targetIds) {
+    const hits = [];
+    const visited = new Set();
+    const walk = (value) => {
+        if (value === null || value === undefined) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            if (visited.has(value)) {
+                return;
+            }
+            visited.add(value);
+            value.forEach((entry) => walk(entry));
+            return;
+        }
+        if (!isRecord(value)) {
+            return;
+        }
+        if (visited.has(value)) {
+            return;
+        }
+        visited.add(value);
+        const refObjectId = trimText(value['@refObjectId']);
+        if (refObjectId && targetIds.has(refObjectId)) {
+            hits.push(refObjectId);
+        }
+        Object.values(value).forEach((entry) => walk(entry));
+    };
+    walk(root);
+    return hits;
+}
+function buildEmptyReferenceHits(processIds) {
+    return {
+        processes: Object.fromEntries(processIds.map((processId) => [processId, []])),
+        lifecyclemodels: Object.fromEntries(processIds.map((processId) => [processId, []])),
+    };
+}
+async function fetchCurrentUserReferenceHits(options) {
+    const targetIds = new Set(options.targetProcessIds);
+    const results = buildEmptyReferenceHits(options.targetProcessIds);
+    const processRows = await fetchCurrentUserRows({
+        auth: options.auth,
+        tableName: 'processes',
+        userId: options.userId,
+        select: 'id,version,state_code,user_id,model_id,json',
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        maxRetries: options.maxRetries,
+    });
+    for (const row of processRows) {
+        if (!isRecord(row)) {
+            continue;
+        }
+        const rowId = trimText(row.id);
+        const hits = collectReferenceHits(row.json, targetIds);
+        for (const hit of hits) {
+            if (rowId === hit) {
+                continue;
+            }
+            results.processes[hit]?.push({
+                id: rowId,
+                version: trimText(row.version),
+                state_code: typeof row.state_code === 'number' ? row.state_code : null,
+                model_id: normalizeOptionalToken(row.model_id),
+            });
+        }
+    }
+    const lifecyclemodelRows = await fetchCurrentUserRows({
+        auth: options.auth,
+        tableName: 'lifecyclemodels',
+        userId: options.userId,
+        select: 'id,version,state_code,user_id,json',
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        maxRetries: options.maxRetries,
+    });
+    for (const row of lifecyclemodelRows) {
+        if (!isRecord(row)) {
+            continue;
+        }
+        const hits = collectReferenceHits(row.json, targetIds);
+        for (const hit of hits) {
+            results.lifecyclemodels[hit]?.push({
+                id: trimText(row.id),
+                version: trimText(row.version),
+                state_code: typeof row.state_code === 'number' ? row.state_code : null,
+            });
+        }
+    }
+    return results;
+}
+function normalizedSignature(exchanges) {
+    return [...exchanges]
+        .map((exchange) => [
+        trimText(exchange.flow_id),
+        trimText(exchange.direction),
+        normalizeAmount(exchange.mean_amount),
+        normalizeAmount(exchange.resulting_amount),
+    ])
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+function normalizedSignatureKey(exchanges) {
+    return JSON.stringify(normalizedSignature(exchanges));
+}
+function detectGroupPattern(processes) {
+    const sample = processes.find((process) => process.analysis_exchanges.length > 0)?.analysis_exchanges;
+    if (!sample || sample.length === 0) {
+        return 'unknown';
+    }
+    const inputExchanges = sample.filter((exchange) => trimText(exchange.direction).toLowerCase() === 'input');
+    const outputExchanges = sample.filter((exchange) => trimText(exchange.direction).toLowerCase() === 'output');
+    const inputFlowIds = new Set(inputExchanges.map((exchange) => trimText(exchange.flow_id)).filter(Boolean));
+    const outputFlowIds = new Set(outputExchanges.map((exchange) => trimText(exchange.flow_id)).filter(Boolean));
+    const hasTransportInput = inputExchanges.some((exchange) => {
+        const en = trimText(exchange.flow_short_description_en).toLowerCase();
+        const zh = trimText(exchange.flow_short_description_zh);
+        return en.includes('transport;') || zh.includes('运输;');
+    });
+    if (outputFlowIds.size > 0 && [...outputFlowIds].every((flowId) => inputFlowIds.has(flowId))) {
+        return hasTransportInput ? 'transport_pass_through' : 'same_flow_pass_through';
+    }
+    return 'other';
+}
+function scoreProcessName(process, groupPattern) {
+    const nameEn = trimText(process.remote_name_en ?? process.name_en);
+    const nameZh = trimText(process.remote_name_zh ?? process.name_zh);
+    const lowerEn = nameEn.toLowerCase();
+    const reasons = [];
+    let score = 0;
+    if (groupPattern === 'transport_pass_through') {
+        if (lowerEn.includes('transport') || nameZh.includes('运输')) {
+            score += 30;
+            reasons.push('name matches explicit transport-service input');
+        }
+        if (lowerEn.includes('logistics') || nameZh.includes('物流')) {
+            score -= 10;
+            reasons.push('name is broader than the observed transport-service input');
+        }
+    }
+    if (groupPattern === 'same_flow_pass_through') {
+        if (lowerEn.includes('processing') || nameZh.includes('加工')) {
+            score -= 20;
+            reasons.push('same-flow pass-through does not support a processing label');
+        }
+        if (lowerEn.includes('reception') || nameZh.includes('接收')) {
+            score += 20;
+            reasons.push('reception matches same-flow intake/output handling');
+        }
+    }
+    if (lowerEn.includes('collection') || nameZh.includes('收集')) {
+        score += 20;
+        reasons.push('collection is semantically consistent with a gather/sort process');
+    }
+    if (lowerEn.includes('wastepaper')) {
+        score -= 5;
+        reasons.push("compressed English form is less standardized than 'waste paper'");
+    }
+    if (lowerEn.includes('waste paper')) {
+        score += 3;
+        reasons.push('English wording is standardized');
+    }
+    if (nameEn.includes('/') || nameZh.includes('/')) {
+        score += 5;
+        reasons.push('name keeps the broader material scope explicit');
+    }
+    return { score, reasons };
+}
+function createdAtKey(process) {
+    return trimText(process.created_at) || '9999-12-31T23:59:59+00:00';
+}
+function compareGroupIds(left, right) {
+    return String(left).localeCompare(String(right), 'en', { numeric: true });
+}
+function analyzeGroups(groups, remoteById, referenceHits) {
+    const duplicateGroups = [];
+    const deletePlanGroups = [];
+    for (const group of [...groups].sort((left, right) => compareGroupIds(left.group_id, right.group_id))) {
+        const processes = group.processes.map((process) => {
+            const remote = remoteById[process.process_id];
+            const analysisExchanges = remote && remote.remote_exchanges.length > 0
+                ? remote.remote_exchanges
+                : process.sheet_exchange_rows;
+            const initialScore = scoreProcessName({
+                name_en: process.name_en,
+                name_zh: process.name_zh,
+                remote_name_en: remote?.remote_name_en,
+                remote_name_zh: remote?.remote_name_zh,
+            }, 'unknown');
+            return {
+                ...process,
+                ...remote,
+                analysis_exchanges: analysisExchanges,
+                normalized_exchange_signature: normalizedSignature(analysisExchanges),
+                name_score: initialScore.score,
+                name_score_reasons: initialScore.reasons,
+            };
+        });
+        const exactDuplicate = processes.length > 1 &&
+            new Set(processes.map((process) => normalizedSignatureKey(process.analysis_exchanges)))
+                .size === 1;
+        const groupPattern = detectGroupPattern(processes);
+        for (const process of processes) {
+            const rescored = scoreProcessName(process, groupPattern);
+            process.name_score = rescored.score;
+            process.name_score_reasons = rescored.reasons;
+        }
+        const sortedProcesses = [...processes].sort((left, right) => right.name_score - left.name_score ||
+            createdAtKey(left).localeCompare(createdAtKey(right)) ||
+            left.process_id.localeCompare(right.process_id));
+        duplicateGroups.push({
+            group_id: group.group_id,
+            group_pattern: groupPattern,
+            exact_duplicate: exactDuplicate,
+            processes,
+        });
+        if (!exactDuplicate) {
+            continue;
+        }
+        const keep = sortedProcesses[0];
+        const deleteCandidates = sortedProcesses.slice(1);
+        const scoreGap = keep.name_score - deleteCandidates[0].name_score;
+        const confidence = scoreGap >= 15 ? 'high' : 'medium';
+        const keepProcessRefs = referenceHits.processes[keep.process_id];
+        const keepLifecyclemodelRefs = referenceHits.lifecyclemodels[keep.process_id];
+        const deleteRefs = Object.fromEntries(deleteCandidates.map((candidate) => [
+            candidate.process_id,
+            {
+                process_refs: referenceHits.processes[candidate.process_id].length,
+                lifecyclemodel_refs: referenceHits.lifecyclemodels[candidate.process_id].length,
+            },
+        ]));
+        const notes = ['exact duplicate confirmed by normalized exchange signature'];
+        if (Object.values(deleteRefs).every((entry) => entry.process_refs === 0 && entry.lifecyclemodel_refs === 0)) {
+            notes.push('current-user reference scan found no downstream hits for delete candidates');
+        }
+        else {
+            notes.push('current-user reference scan found downstream hits; delete requires reference cleanup');
+        }
+        notes.push('global or shared-team reference verification is outside this command');
+        deletePlanGroups.push({
+            group_id: group.group_id,
+            status: 'priority_delete_candidates',
+            confidence,
+            current_user_reference_hits: {
+                keep_process_refs: keepProcessRefs.length,
+                keep_lifecyclemodel_refs: keepLifecyclemodelRefs.length,
+                delete_refs: deleteRefs,
+            },
+            keep: {
+                process_id: keep.process_id,
+                name_en: trimText(keep.remote_name_en ?? keep.name_en),
+                name_zh: trimText(keep.remote_name_zh ?? keep.name_zh),
+                score: keep.name_score,
+                reasons: keep.name_score_reasons,
+            },
+            delete: deleteCandidates.map((candidate) => ({
+                process_id: candidate.process_id,
+                name_en: trimText(candidate.remote_name_en ?? candidate.name_en),
+                name_zh: trimText(candidate.remote_name_zh ?? candidate.name_zh),
+                score: candidate.name_score,
+                reasons: candidate.name_score_reasons,
+            })),
+            notes,
+        });
+    }
+    return {
+        duplicateGroups,
+        deletePlanGroups,
+    };
+}
+export async function runProcessDedupReview(options) {
+    const inputPath = requiredNonEmpty(options.inputPath, '--input', 'PROCESS_DEDUP_INPUT_REQUIRED');
+    const outDir = requiredNonEmpty(options.outDir, '--out-dir', 'PROCESS_DEDUP_OUT_DIR_REQUIRED');
+    const resolvedInputPath = path.resolve(inputPath);
+    const resolvedOutDir = path.resolve(outDir);
+    const timeoutMs = toPositiveInteger(options.timeoutMs ?? DEFAULT_TIMEOUT_MS, '--timeout-ms', 'PROCESS_DEDUP_TIMEOUT_INVALID');
+    const maxRetries = toPositiveInteger(options.maxRetries ?? DEFAULT_MAX_RETRIES, '--max-retries', 'PROCESS_DEDUP_MAX_RETRIES_INVALID');
+    const generatedAtUtc = nowIso(options.now);
+    const document = normalizeInputDocument(readJsonInput(resolvedInputPath), resolvedInputPath);
+    const processIds = [
+        ...new Set(document.groups.flatMap((group) => group.processes.map((process) => process.process_id))),
+    ];
+    const inputManifestPath = path.join(resolvedOutDir, 'inputs', 'dedup-input.manifest.json');
+    writeJsonArtifact(inputManifestPath, {
+        schema_version: 1,
+        generated_at_utc: generatedAtUtc,
+        input_file: resolvedInputPath,
+        source_label: document.sourceLabel,
+        group_count: document.groups.length,
+        process_count: processIds.length,
+    });
+    const remoteStatus = {
+        enabled: false,
+        loaded: 0,
+        error: null,
+        reference_scan: options.skipRemote ? 'skipped_by_flag' : 'not_run',
+    };
+    let remoteMetadataPath = null;
+    let referenceScanPath = null;
+    let remoteById = {};
+    let referenceHits = buildEmptyReferenceHits(processIds);
+    if (!options.skipRemote) {
+        try {
+            const env = options.env ?? process.env;
+            const fetchImpl = options.fetchImpl ?? fetch;
+            const auth = await resolveRemoteAuthContext({
+                env,
+                fetchImpl,
+                timeoutMs,
+                maxRetries,
+                now: options.now ?? new Date(),
+            });
+            remoteById = await fetchRemoteMetadata({
+                processIds,
+                auth,
+                fetchImpl,
+                timeoutMs,
+                maxRetries,
+            });
+            remoteStatus.enabled = true;
+            remoteStatus.loaded = Object.keys(remoteById).length;
+            remoteMetadataPath = path.join(resolvedOutDir, 'inputs', 'processes.remote-metadata.json');
+            writeJsonArtifact(remoteMetadataPath, remoteById);
+            if (auth.userId) {
+                try {
+                    referenceHits = await fetchCurrentUserReferenceHits({
+                        auth,
+                        userId: auth.userId,
+                        targetProcessIds: processIds,
+                        fetchImpl,
+                        timeoutMs,
+                        maxRetries,
+                    });
+                    referenceScanPath = path.join(resolvedOutDir, 'outputs', 'current-user-reference-scan.json');
+                    writeJsonArtifact(referenceScanPath, referenceHits);
+                    remoteStatus.reference_scan = 'current_user_completed';
+                }
+                catch (error) {
+                    remoteStatus.reference_scan = 'failed';
+                    remoteStatus.error = errorMessage(error);
+                }
+            }
+            else {
+                remoteStatus.reference_scan = 'skipped_missing_user_id';
+            }
+        }
+        catch (error) {
+            remoteStatus.error = errorMessage(error);
+        }
+    }
+    const analysis = analyzeGroups(document.groups, remoteById, referenceHits);
+    const duplicateGroupsPath = path.join(resolvedOutDir, 'outputs', 'duplicate-groups.json');
+    const deletePlanPath = path.join(resolvedOutDir, 'outputs', 'delete-plan.json');
+    writeJsonArtifact(duplicateGroupsPath, {
+        schema_version: 1,
+        generated_at_utc: generatedAtUtc,
+        input_file: resolvedInputPath,
+        source_label: document.sourceLabel,
+        remote_status: remoteStatus,
+        groups: analysis.duplicateGroups,
+    });
+    writeJsonArtifact(deletePlanPath, {
+        schema_version: 1,
+        generated_at_utc: generatedAtUtc,
+        input_file: resolvedInputPath,
+        source_label: document.sourceLabel,
+        remote_status: remoteStatus,
+        groups: analysis.deletePlanGroups,
+    });
+    return {
+        schema_version: 1,
+        generated_at_utc: generatedAtUtc,
+        status: 'completed_process_dedup_review',
+        input_file: resolvedInputPath,
+        out_dir: resolvedOutDir,
+        source_label: document.sourceLabel,
+        group_count: analysis.duplicateGroups.length,
+        exact_duplicate_group_count: analysis.duplicateGroups.filter((group) => group.exact_duplicate)
+            .length,
+        remote_status: remoteStatus,
+        files: {
+            input_manifest: inputManifestPath,
+            remote_metadata: remoteMetadataPath,
+            duplicate_groups: duplicateGroupsPath,
+            delete_plan: deletePlanPath,
+            current_user_reference_scan: referenceScanPath,
+        },
+    };
+}
+export const __testInternals = {
+    analyzeGroups,
+    collectReferenceHits,
+    detectGroupPattern,
+    errorMessage,
+    fetchCurrentUserId,
+    fetchCurrentUserReferenceHits,
+    fetchCurrentUserRows,
+    fetchJsonWithRetry,
+    fetchRemoteMetadata,
+    getLangList,
+    getLangText,
+    normalizeAmount,
+    normalizeExchangeRows,
+    normalizeInputDocument,
+    normalizedSignature,
+    parseJsonResponse,
+    resolveRemoteAuthContext,
+    scoreProcessName,
+};
+//# sourceMappingURL=process-dedup-review.js.map