@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/mutation/semantic-move-standalone-engine.js

@@ -0,0 +1,919 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStandaloneSemanticMoveBatch = runStandaloneSemanticMoveBatch;
+const path = __importStar(require("node:path"));
+const workspace_root_1 = require("../config/workspace-root");
+const types_1 = require("../shared/types");
+const import_rules_1 = require("../config/import-rules");
+const mutation_comments_1 = require("../config/mutation-comments");
+const module_plan_timeline_1 = require("../diagnostics/module-plan-timeline");
+const semantic_move_standalone_planner_1 = require("./semantic-move-standalone-planner");
+const semantic_move_transaction_1 = require("./semantic-move-transaction");
+const semantic_planner_retry_1 = require("./semantic-planner-retry");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_execution_progress_1 = require("./semantic-execution-progress");
+async function runStandaloneSemanticMoveBatch(cwd, builtBatch, evidence, dependencies = {
+    plan: semantic_move_standalone_planner_1.planStandaloneSemanticMove,
+    apply: semantic_move_transaction_1.applyStandaloneSemanticMoveTransaction
+}, metrics, internal) {
+    const startedAt = Date.now();
+    const metricStartedAt = internal?.suppressMetricsLifecycle ? undefined : metrics?.start();
+    let metricPlan;
+    let metricEntityCount = 0;
+    const finish = (response) => {
+        if (internal?.suppressMetricsLifecycle)
+            return response;
+        if (metricStartedAt !== undefined)
+            metrics?.end("operation.total", metricStartedAt);
+        const edits = metricPlan?.edits ?? [];
+        metrics?.finish({
+            ok: response.batchOk === true,
+            code: readString(response.code) ?? (response.batchOk === true ? "SEMANTIC_MOVE_PLAN_COMPLETE" : "SEMANTIC_MOVE_FAILED"),
+            entityCount: metricEntityCount,
+            ownerConfigCount: metricPlan?.discovery.ownerConfigCount ?? 0,
+            editFileCount: edits.length,
+            textChangeCount: edits.reduce((sum, edit) => sum + edit.textChanges.length, 0)
+        });
+        return response;
+    };
+    const observePlan = (plan) => {
+        metricPlan = plan;
+        internal?.onPlan?.(plan);
+    };
+    const parsed = parseMoveOperations(cwd, builtBatch.payload);
+    metricEntityCount = parsed.operations.length;
+    if (!parsed.ok)
+        return finish(failedBatch(parsed.operations, parsed.code, parsed.error, Date.now() - startedAt));
+    const operations = parsed.operations;
+    const progressTracker = internal?.progressTracker ?? (0, semantic_execution_progress_1.createSemanticExecutionProgressTracker)(builtBatch);
+    if (new Set(operations.map((item) => item.execute)).size !== 1) {
+        return finish(failedBatch(operations, "SEMANTIC_MOVE_EXECUTION_MODE_MISMATCH", "Every semantic move row must use the same execution mode.", Date.now() - startedAt));
+    }
+    if (operations[0].execute && !evidence) {
+        return finish(failedBatch(operations, "SEMANTIC_MOVE_EXECUTION_EVIDENCE_REQUIRED", "Standalone semantic move refuses writes without a durable owned execution write-set.", Date.now() - startedAt));
+    }
+    const routes = groupContiguousRoutes(operations);
+    if (routes.length > 1) {
+        return finish(await runStandaloneSemanticMoveRoutes({
+            cwd,
+            builtBatch,
+            operations,
+            routes,
+            evidence,
+            dependencies,
+            metrics,
+            observePlan,
+            internal,
+            progressTracker,
+            startedAt
+        }));
+    }
+    if (new Set(operations.map((item) => pathKey(item.sourceFile))).size !== 1 ||
+        new Set(operations.map((item) => pathKey(item.targetFile))).size !== 1) {
+        return finish(failedBatch(operations, "SEMANTIC_MOVE_MULTI_ROUTE_UNSUPPORTED", "One atomic standalone semantic move batch must use one exact source and target file.", Date.now() - startedAt));
+    }
+    if (new Set(operations.map((item) => `${item.symbolName}\0${item.symbolKind ?? "*"}`)).size !== operations.length) {
+        return finish(failedBatch(operations, "SEMANTIC_MOVE_ENTITY_DUPLICATE", "Semantic move entity names must be unique within one atomic group.", Date.now() - startedAt));
+    }
+    if (new Set(operations.map(policySignature)).size !== 1) {
+        return finish(failedBatch(operations, "SEMANTIC_MOVE_POLICY_MISMATCH", "Every semantic move row in one route must use the same import/comment policy.", Date.now() - startedAt));
+    }
+    const workspaceRoot = (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? path.resolve(cwd);
+    const computeWorkspaceFingerprint = internal?.semanticContextPool
+        ? (root) => internal.semanticContextPool.withWorkspaceProjectIndex((index) => (0, file_mutation_discovery_1.computeFileMutationWorkspaceFingerprintWithProjectIndex)(index, root))
+        : undefined;
+    let cumulativeDurableWriteSet = [];
+    const publishBeforeApply = (writeSet) => {
+        cumulativeDurableWriteSet = uniqueStrings([...cumulativeDurableWriteSet, ...writeSet]);
+        evidence.beforeApply(cumulativeDurableWriteSet);
+    };
+    const planOperations = async (selected) => (0, semantic_planner_retry_1.runSemanticPlannerWithRetry)(() => dependencies.plan({
+        workspaceRoot,
+        sourceFile: operations[0].sourceFile,
+        targetFile: operations[0].targetFile,
+        entities: selected.map((operation) => ({
+            id: operation.id,
+            name: operation.symbolName,
+            ...(operation.symbolKind ? { kind: operation.symbolKind } : {})
+        })),
+        importRules: operations[0].importRules,
+        mutationComments: operations[0].mutationComments,
+        ...(internal?.semanticContextPool ? { semanticContextPool: internal.semanticContextPool } : {}),
+        ...(metrics ? { metrics } : {})
+    }));
+    const plan = await planOperations(operations);
+    observePlan(plan);
+    if (!plan.complete) {
+        if (!isBestEffortPlanningFailure(plan.code)) {
+            return finish(failedBatch(operations, plan.code, plan.error ?? "Standalone semantic move planning failed.", Date.now() - startedAt, plan));
+        }
+        if (plan.code === "SEMANTIC_MOVE_ENTITIES_NOT_CONTIGUOUS") {
+            const contiguousRoutes = buildContiguousEntityRoutes(operations, plan.contiguousEntityGroups);
+            if (contiguousRoutes) {
+                return finish(await runStandaloneSemanticMoveRoutes({
+                    cwd,
+                    builtBatch,
+                    operations,
+                    routes: contiguousRoutes,
+                    evidence,
+                    dependencies,
+                    metrics,
+                    observePlan,
+                    internal,
+                    progressTracker,
+                    startedAt
+                }));
+            }
+        }
+        const rows = new Array(operations.length);
+        const publishFinalRows = (indexes) => {
+            const progress = progressTracker.finalize(indexes.flatMap((index) => {
+                const row = rows[index];
+                return row ? [{ id: operations[index].id, failed: row.ok !== true }] : [];
+            }));
+            if (progress)
+                evidence?.afterProgress?.(progress);
+        };
+        let pending = operations.map((_, index) => index);
+        const overlapAttempts = new Map();
+        let totalAppliedFiles = [];
+        let totalTouchedFiles = [];
+        let totalEditCount = 0;
+        const maxPasses = Math.max(2, operations.length + 1);
+        for (let pass = 0; pending.length > 0 && pass < maxPasses; pass += 1) {
+            const deferred = [];
+            let completedThisPass = 0;
+            for (const index of pending) {
+                const operation = operations[index];
+                const itemPlan = await planOperations([operation]);
+                observePlan(itemPlan);
+                if (itemPlan.complete) {
+                    if (!operation.execute) {
+                        rows[index] = completedRow(operation, previewResponse(operation, itemPlan), itemPlan.totalMs);
+                        publishFinalRows([index]);
+                        completedThisPass += 1;
+                        continue;
+                    }
+                    const applied = dependencies.apply({
+                        workspaceRoot,
+                        plan: itemPlan,
+                        beforeApply: publishBeforeApply,
+                        ...(computeWorkspaceFingerprint ? { computeWorkspaceFingerprint } : {}),
+                        ...(metrics ? { metrics } : {})
+                    });
+                    if (!applied.ok) {
+                        rows[index] = failedRow(operation, applied.code, applied.error, overlapAttempts.get(index) ?? 0, applied.potentiallyModifiedFiles);
+                        publishFinalRows([index]);
+                        return finish(bestEffortBatch(operations, rows, Date.now() - startedAt, {
+                            code: applied.code,
+                            error: applied.error,
+                            rollback: applied.rollback,
+                            potentiallyModifiedFiles: applied.potentiallyModifiedFiles,
+                            ...(applied.rollbackErrors ? { rollbackErrors: applied.rollbackErrors } : {})
+                        }));
+                    }
+                    totalAppliedFiles = uniqueStrings([...totalAppliedFiles, ...applied.savedFiles]);
+                    totalTouchedFiles = uniqueStrings([...totalTouchedFiles, ...applied.touchedFiles]);
+                    totalEditCount += applied.editCount;
+                    rows[index] = completedRow(operation, {
+                        ...previewResponse(operation, itemPlan),
+                        execute: true,
+                        applied: true,
+                        applyMode: "standaloneSemanticMoveTransaction",
+                        touchedFiles: applied.touchedFiles,
+                        savedFiles: applied.savedFiles
+                    }, itemPlan.totalMs);
+                    const attemptedBeforeSuccess = overlapAttempts.get(index) ?? 0;
+                    if (attemptedBeforeSuccess > 0) {
+                        rows[index].deferredRetry = {
+                            attemptedBeforeSuccess,
+                            reason: "changesOverlap",
+                            codes: ["TS_MOVE_TO_FILE_REFACTOR_FAILED"]
+                        };
+                    }
+                    publishFinalRows([index]);
+                    completedThisPass += 1;
+                    continue;
+                }
+                if (itemPlan.code === "SEMANTIC_MOVE_PROVIDER_UNSUPPORTED") {
+                    rows[index] = manualExtractionRow(operation, "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE", "providerUnsupported", itemPlan.error);
+                    publishFinalRows([index]);
+                    continue;
+                }
+                if (itemPlan.code === "SEMANTIC_MOVE_OWNER_DIVERGENCE") {
+                    internal?.onDivergence?.({
+                        operationId: operation.id,
+                        entity: operation.entity,
+                        sourceFile: operation.sourceFile,
+                        targetFile: operation.targetFile,
+                        code: "SEMANTIC_MOVE_OWNER_DIVERGENCE",
+                        evidence: itemPlan.divergences ?? []
+                    });
+                    rows[index] = manualExtractionRow(operation, itemPlan.code, "manualExtractionRequired", itemPlan.error);
+                    publishFinalRows([index]);
+                    continue;
+                }
+                if (itemPlan.code === "SEMANTIC_MOVE_CHANGES_OVERLAP") {
+                    overlapAttempts.set(index, (overlapAttempts.get(index) ?? 0) + 1);
+                    (0, module_plan_timeline_1.recordModulePlanTimeline)(cwd, undefined, "moveToFile.entity.end", {
+                        entity: operation.entity,
+                        deferred: true,
+                        code: "TS_MOVE_TO_FILE_REFACTOR_FAILED",
+                        error: "Changes overlap"
+                    });
+                    deferred.push(index);
+                    continue;
+                }
+                if (isDeclarationLocalPlanningFailure(itemPlan.code)) {
+                    rows[index] = declarationFailureRow(operation, itemPlan.code, itemPlan.error ?? "Standalone semantic move planning failed.", overlapAttempts.get(index) ?? 0, itemPlan);
+                    publishFinalRows([index]);
+                    continue;
+                }
+                rows[index] = failedRow(operation, itemPlan.code, itemPlan.error ?? "Standalone semantic move planning failed.", overlapAttempts.get(index) ?? 0);
+                publishFinalRows([index]);
+                return finish(bestEffortBatch(operations, rows, Date.now() - startedAt, {
+                    code: itemPlan.code,
+                    error: itemPlan.error ?? "Standalone semantic move planning failed.",
+                    rollback: "not-needed",
+                    potentiallyModifiedFiles: []
+                }));
+            }
+            if (deferred.length === 0)
+                break;
+            if (!operations[0].execute || completedThisPass === 0) {
+                for (const index of deferred) {
+                    rows[index] = manualExtractionRow(operations[index], "TS_MOVE_TO_FILE_REFACTOR_FAILED", "changesOverlapAfterDeferredRetry", "Changes overlap", overlapAttempts.get(index) ?? 1);
+                    publishFinalRows([index]);
+                }
+                break;
+            }
+            pending = deferred;
+        }
+        for (const [index, row] of rows.entries()) {
+            if (!row) {
+                rows[index] = failedRow(operations[index], "SEMANTIC_MOVE_RETRY_BUDGET_EXHAUSTED", "Semantic move retry budget was exhausted.", overlapAttempts.get(index) ?? 0);
+                publishFinalRows([index]);
+            }
+        }
+        return finish(bestEffortBatch(operations, rows, Date.now() - startedAt, {
+            savedFiles: totalAppliedFiles,
+            touchedFiles: totalTouchedFiles,
+            editCount: totalEditCount,
+            rollback: "not-needed",
+            potentiallyModifiedFiles: []
+        }));
+    }
+    if (!operations[0].execute) {
+        publishCompletedOperationProgress(progressTracker, operations, evidence, false);
+        return finish(completedBatch(operations, plan, null, Date.now() - startedAt));
+    }
+    const applied = dependencies.apply({
+        workspaceRoot,
+        plan,
+        beforeApply: publishBeforeApply,
+        ...(computeWorkspaceFingerprint ? { computeWorkspaceFingerprint } : {}),
+        ...(metrics ? { metrics } : {})
+    });
+    if (!applied.ok) {
+        publishCompletedOperationProgress(progressTracker, operations, evidence, true);
+        return finish(failedBatch(operations, applied.code, applied.error, Date.now() - startedAt, plan, {
+            rollback: applied.rollback,
+            potentiallyModifiedFiles: applied.potentiallyModifiedFiles,
+            ...(applied.rollbackErrors ? { rollbackErrors: applied.rollbackErrors } : {})
+        }));
+    }
+    publishCompletedOperationProgress(progressTracker, operations, evidence, false);
+    return finish(completedBatch(operations, plan, applied, Date.now() - startedAt));
+}
+function isBestEffortPlanningFailure(code) {
+    return [
+        "SEMANTIC_MOVE_PROVIDER_UNSUPPORTED",
+        "SEMANTIC_MOVE_OWNER_DIVERGENCE",
+        "SEMANTIC_MOVE_CHANGES_OVERLAP",
+        "SEMANTIC_MOVE_ENTITY_NOT_FOUND",
+        "SEMANTIC_MOVE_ENTITY_AMBIGUOUS",
+        "SEMANTIC_MOVE_ENTITIES_NOT_CONTIGUOUS",
+        "SEMANTIC_MOVE_REQUIRED_EDGE_UNCHANGED"
+    ].includes(code);
+}
+function isDeclarationLocalPlanningFailure(code) {
+    return code === "SEMANTIC_MOVE_ENTITY_NOT_FOUND" ||
+        code === "SEMANTIC_MOVE_ENTITY_AMBIGUOUS" ||
+        code === "SEMANTIC_MOVE_REQUIRED_EDGE_UNCHANGED";
+}
+function groupContiguousRoutes(operations) {
+    const routes = [];
+    for (const operation of operations) {
+        const key = [pathKey(operation.sourceFile), pathKey(operation.targetFile), policySignature(operation)].join("\0");
+        const current = routes[routes.length - 1];
+        if (current?.key === key)
+            current.operations.push(operation);
+        else
+            routes.push({ key, operations: [operation] });
+    }
+    return routes;
+}
+function buildContiguousEntityRoutes(operations, groups) {
+    if (!groups || groups.length < 2)
+        return null;
+    const byId = new Map(operations.map((operation) => [operation.id, operation]));
+    const seen = new Set();
+    const routes = [];
+    for (const [index, ids] of groups.entries()) {
+        const selected = [];
+        for (const id of ids) {
+            const operation = byId.get(id);
+            if (!operation || seen.has(id))
+                return null;
+            seen.add(id);
+            selected.push(operation);
+        }
+        if (selected.length === 0)
+            return null;
+        routes.push({ key: `contiguous:${index}`, operations: selected });
+    }
+    return seen.size === operations.length ? routes : null;
+}
+async function runStandaloneSemanticMoveRoutes(input) {
+    const rawOperations = Array.isArray(input.builtBatch.payload.operations) ? input.builtBatch.payload.operations : [];
+    const rowsByIndex = new Map();
+    const routeEvidence = [];
+    let cumulativeDurableWriteSet = [];
+    let savedFiles = [];
+    let touchedFiles = [];
+    let potentiallyModifiedFiles = [];
+    let editCount = 0;
+    let terminal = null;
+    const publishBeforeApply = input.evidence ? {
+        beforeApply(writeSet) {
+            cumulativeDurableWriteSet = uniqueStrings([...cumulativeDurableWriteSet, ...writeSet]);
+            input.evidence.beforeApply(cumulativeDurableWriteSet);
+        },
+        afterProgress(progress) {
+            input.evidence.afterProgress?.(progress);
+        }
+    } : undefined;
+    for (const [routeIndex, route] of input.routes.entries()) {
+        if (terminal)
+            break;
+        const routeStartedAt = Date.now();
+        const subBatch = {
+            payload: {
+                ...input.builtBatch.payload,
+                operations: route.operations.map((operation) => rawOperations[operation.index]).filter(isObject)
+            },
+            summary: input.builtBatch.summary
+        };
+        const result = await runStandaloneSemanticMoveBatch(input.cwd, subBatch, publishBeforeApply, input.dependencies, input.metrics, {
+            suppressMetricsLifecycle: true,
+            onPlan: input.observePlan,
+            progressTracker: input.progressTracker,
+            ...(input.internal?.semanticContextPool ? { semanticContextPool: input.internal.semanticContextPool } : {}),
+            ...(input.internal?.onDivergence ? { onDivergence: input.internal.onDivergence } : {})
+        });
+        const resultRows = Array.isArray(result.rows) ? result.rows.filter(isObject) : [];
+        for (const [rowIndex, operation] of route.operations.entries()) {
+            const row = resultRows[rowIndex];
+            rowsByIndex.set(operation.index, row ? { ...row, index: operation.index + 1 } : failedRow(operation, "SEMANTIC_MOVE_ROUTE_RESULT_MISSING", "Standalone semantic move route did not return evidence for this row.", 0));
+        }
+        savedFiles = uniqueStrings([...savedFiles, ...readStrings(result.savedFiles)]);
+        touchedFiles = uniqueStrings([...touchedFiles, ...readStrings(result.touchedFiles)]);
+        potentiallyModifiedFiles = uniqueStrings([...potentiallyModifiedFiles, ...readStrings(result.potentiallyModifiedFiles)]);
+        editCount += typeof result.editCount === "number" ? result.editCount : 0;
+        const routeTerminal = resultRows.some((row) => row.ok !== true && row.outcome !== "manualExtractionRequired" && !isObject(row.declarationFailure));
+        const routeHasDeclarationFailures = resultRows.some((row) => isObject(row.declarationFailure));
+        routeEvidence.push({
+            index: routeIndex + 1,
+            sourceFile: route.operations[0].sourceFile,
+            targetFile: route.operations[0].targetFile,
+            requestedRowCount: route.operations.length,
+            durationMs: Date.now() - routeStartedAt,
+            status: routeTerminal
+                ? "failed"
+                : result.batchOk === true
+                    ? "completed"
+                    : routeHasDeclarationFailures
+                        ? "completedWithErrors"
+                        : "completedWithManualExtraction",
+            ...(isObject(result.planner) ? { planner: result.planner } : {}),
+            ...(typeof result.code === "string" ? { code: result.code } : {})
+        });
+        input.evidence?.afterRoute?.({
+            index: routeIndex,
+            sourceFile: route.operations[0].sourceFile,
+            targetFile: route.operations[0].targetFile,
+            requestedRowCount: route.operations.length,
+            result
+        });
+        if (routeTerminal) {
+            terminal = {
+                code: readString(result.code) ?? "SEMANTIC_MOVE_ROUTE_FAILED",
+                error: readString(result.error) ?? "Standalone semantic move route failed.",
+                rollback: readString(result.rollback) ?? "not-needed",
+                ...(readStrings(result.rollbackErrors).length > 0 ? { rollbackErrors: readStrings(result.rollbackErrors) } : {})
+            };
+        }
+    }
+    for (const operation of input.operations) {
+        if (!rowsByIndex.has(operation.index)) {
+            rowsByIndex.set(operation.index, notAttemptedRow(operation));
+        }
+    }
+    const rows = input.operations.map((operation) => rowsByIndex.get(operation.index));
+    const failedRows = rows.filter((row) => row.ok === false && row.skipped !== true);
+    const passedRows = rows.filter((row) => row.ok === true);
+    const manualRows = rows.filter((row) => row.outcome === "manualExtractionRequired");
+    const declarationFailures = rows.map((row) => row.declarationFailure).filter(isObject);
+    const missingEntities = collectMissingEntities(declarationFailures);
+    const code = terminal?.code ?? (manualRows.length > 0 ? "SEMANTIC_MOVE_MANUAL_EXTRACTION_REQUIRED" : "SEMANTIC_MOVE_PLAN_COMPLETE");
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        contract: {
+            version: 2,
+            execution: "sequential-routes",
+            continueOnError: true,
+            rollback: "verified-route-transactions",
+            transactional: false,
+            rowOutcomeValues: ["applied", "validated", "manualExtractionRequired", "failed", "skipped"]
+        },
+        execution: "sequential-routes",
+        continueOnError: true,
+        batchOk: failedRows.length === 0,
+        batchStatus: failedRows.length === 0 ? "completed" : "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: rows.filter((row) => row.attempted === true).length,
+        rowCount: rows.length,
+        passedRowCount: passedRows.length,
+        failedRowCount: failedRows.length,
+        skippedRowCount: rows.filter((row) => row.skipped === true).length,
+        durationMs: Date.now() - input.startedAt,
+        code,
+        ...(terminal ? { error: terminal.error } : {}),
+        guidance: failedRows.length === 0 ? null : {
+            hint: terminal
+                ? "Fix the failed route; earlier successful routes were preserved and later routes were not attempted."
+                : "Use manual extraction for listed symbols; successful independent routes were preserved."
+        },
+        providerLimitations: rows
+            .map((row) => isObject(row.response) ? row.response.providerLimitation : null)
+            .filter(isObject),
+        rows,
+        routes: routeEvidence,
+        ...(declarationFailures.length > 0 ? { declarationFailures } : {}),
+        ...(missingEntities.length > 0 ? { missingEntities } : {}),
+        savedFiles,
+        touchedFiles,
+        editCount,
+        rollback: terminal?.rollback ?? "not-needed",
+        potentiallyModifiedFiles,
+        ...(terminal?.rollbackErrors ? { rollbackErrors: terminal.rollbackErrors } : {})
+    };
+}
+function publishCompletedOperationProgress(tracker, operations, evidence, failed) {
+    const progress = tracker.finalize(operations.map((operation) => ({ id: operation.id, failed })));
+    if (progress)
+        evidence?.afterProgress?.(progress);
+}
+function previewResponse(operation, plan) {
+    return {
+        ok: true,
+        execute: false,
+        applied: false,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        symbolName: operation.entity,
+        operationSummary: {
+            operation: "moveToFile",
+            editCount: plan.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0),
+            changedFiles: plan.edits.map((edit) => path.normalize(edit.fileName))
+        }
+    };
+}
+function manualExtractionRow(operation, code, reason, error = "Manual extraction is required.", attemptedBeforeSuccess = 0) {
+    const response = {
+        ok: false,
+        code,
+        error,
+        execute: operation.execute,
+        applied: false,
+        ...(code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE"
+            ? { providerLimitation: { kind: "typescript-move-to-file-unsupported", code, retryable: false, continueTail: true } }
+            : {}),
+        touchedFiles: [],
+        savedFiles: []
+    };
+    return {
+        ...completedRow(operation, response, 0),
+        outcome: "manualExtractionRequired",
+        ...(code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE"
+            ? { providerLimitation: { kind: "typescript-move-to-file-unsupported", code, retryable: false, continueTail: true } }
+            : {}),
+        ...(attemptedBeforeSuccess > 0
+            ? { deferredRetry: { attemptedBeforeSuccess, reason: "changesOverlap", codes: [code] } }
+            : {}),
+        manualExtractionRequired: [{ entity: operation.entity, code, reason, retryable: false }]
+    };
+}
+function failedRow(operation, code, error, attemptedBeforeSuccess, potentiallyModifiedFiles = []) {
+    return {
+        ...completedRow(operation, {
+            ok: false,
+            code,
+            error,
+            execute: operation.execute,
+            applied: false,
+            touchedFiles: potentiallyModifiedFiles,
+            savedFiles: []
+        }, 0),
+        ...(attemptedBeforeSuccess > 0
+            ? { deferredRetry: { attemptedBeforeSuccess, reason: "changesOverlap", codes: [code] } }
+            : {})
+    };
+}
+function declarationFailureRow(operation, code, error, attemptedBeforeSuccess, plan) {
+    const ambiguity = plan?.ambiguities?.find((item) => item.entity === operation.symbolName);
+    const availableSelectors = ambiguity?.kinds.map((kind) => `${operation.selectorSyntax.aliases[kind]}${operation.selectorSyntax.separator}${operation.symbolName}`) ?? [];
+    return {
+        ...failedRow(operation, code, error, attemptedBeforeSuccess),
+        ...(availableSelectors.length > 0 ? { availableSelectors } : {}),
+        declarationFailure: {
+            entity: operation.entity,
+            sourceFile: operation.sourceFile,
+            targetFile: operation.targetFile,
+            phase: "planning",
+            code,
+            error,
+            ...(availableSelectors.length > 0 ? { availableSelectors } : {})
+        }
+    };
+}
+function notAttemptedRow(operation) {
+    const error = "Semantic move route was not attempted after a terminal failure.";
+    return {
+        index: operation.index + 1,
+        id: operation.id,
+        kind: operation.kind,
+        planned: true,
+        attempted: false,
+        skipped: true,
+        outcome: "skipped",
+        ok: false,
+        statusCode: 424,
+        durationMs: 0,
+        responseOk: false,
+        applied: false,
+        touchedFiles: [],
+        savedFiles: [],
+        error,
+        response: {
+            ok: false,
+            code: "SEMANTIC_MOVE_NOT_ATTEMPTED",
+            error,
+            execute: operation.execute,
+            applied: false,
+            touchedFiles: [],
+            savedFiles: []
+        }
+    };
+}
+function bestEffortBatch(operations, rawRows, durationMs, extra) {
+    const rows = rawRows.map((row, index) => row ?? failedRow(operations[index], "SEMANTIC_MOVE_NOT_ATTEMPTED", "Semantic move was not attempted after a terminal failure.", 0));
+    const failedRows = rows.filter((row) => row.ok === false);
+    const passedRows = rows.filter((row) => row.ok === true);
+    const providerLimitations = rows
+        .map((row) => isObject(row.response) ? row.response.providerLimitation : null)
+        .filter(isObject);
+    const declarationFailures = rows
+        .map((row) => row.declarationFailure)
+        .filter(isObject);
+    const missingEntities = collectMissingEntities(declarationFailures);
+    const batchOk = failedRows.length === 0;
+    const manualOnly = failedRows.length > 0 && failedRows.every((row) => row.outcome === "manualExtractionRequired");
+    const fallbackCode = manualOnly ? "SEMANTIC_MOVE_MANUAL_EXTRACTION_REQUIRED" : "SEMANTIC_MOVE_FAILED";
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        contract: {
+            version: 2,
+            execution: "sequential-subgroups",
+            continueOnError: true,
+            rollback: "verified-subgroup-transactions",
+            transactional: false,
+            rowOutcomeValues: ["applied", "validated", "manualExtractionRequired", "failed"]
+        },
+        execution: "sequential-subgroups",
+        continueOnError: true,
+        batchOk,
+        batchStatus: batchOk ? "completed" : "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: rows.length,
+        rowCount: rows.length,
+        passedRowCount: passedRows.length,
+        failedRowCount: failedRows.length,
+        skippedRowCount: 0,
+        durationMs,
+        guidance: batchOk ? null : { hint: "Use manual extraction for listed symbols; successful independent moves were preserved." },
+        providerLimitations,
+        ...(declarationFailures.length > 0 ? { declarationFailures } : {}),
+        ...(missingEntities.length > 0 ? { missingEntities } : {}),
+        rows,
+        ...extra,
+        ...(!batchOk && typeof extra.code !== "string" ? { code: fallbackCode } : {})
+    };
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => path.normalize(value)))];
+}
+function collectMissingEntities(failures) {
+    return failures.flatMap((failure) => {
+        if (failure.code !== "SEMANTIC_MOVE_ENTITY_NOT_FOUND")
+            return [];
+        const entity = readString(failure.entity);
+        const sourceFile = readString(failure.sourceFile);
+        const targetFile = readString(failure.targetFile);
+        return entity && sourceFile && targetFile ? [{ entity, sourceFile, targetFile }] : [];
+    });
+}
+function parseMoveOperations(cwd, payload) {
+    const rawOperations = Array.isArray(payload.operations) ? payload.operations : [];
+    const operations = [];
+    const workspaceRoot = (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? path.resolve(cwd);
+    const selectorSyntax = readSelectorSyntax(payload);
+    for (const [index, raw] of rawOperations.entries()) {
+        if (!isObject(raw) || raw.kind !== "moveRefactor" || !isObject(raw.body)) {
+            return {
+                ok: false,
+                operations: fallbackOperations(cwd, payload),
+                code: "SEMANTIC_MOVE_BATCH_MIXED_UNSUPPORTED",
+                error: "A batch containing semantic move cannot include IDE-owned semantic operations."
+            };
+        }
+        const id = readString(raw.id);
+        const sourceFile = readString(raw.body.sourceFile);
+        const targetFile = readString(raw.body.targetFile);
+        const symbolName = readString(raw.body.symbolName);
+        const symbolKind = readEntityKind(raw.body.symbolKind);
+        const entity = readString(raw.body.selector) ?? symbolName;
+        const invalidKind = raw.body.symbolKind !== null && raw.body.symbolKind !== undefined && !symbolKind;
+        if (!id || !sourceFile || !targetFile || !entity || !symbolName || invalidKind || readString(raw.body.parentName)) {
+            return {
+                ok: false,
+                operations: fallbackOperations(cwd, payload),
+                code: "SEMANTIC_MOVE_ROW_UNSUPPORTED",
+                error: "Standalone semantic move requires top-level symbolName/sourceFile/targetFile rows."
+            };
+        }
+        let importRules;
+        let mutationComments;
+        try {
+            importRules = (0, import_rules_1.normalizeImportRules)(workspaceRoot, raw.body.importRules);
+            mutationComments = (0, mutation_comments_1.normalizeMutationCommentsPolicy)(raw.body.mutationComments);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                operations: fallbackOperations(cwd, payload),
+                code: "SEMANTIC_MOVE_POLICY_INVALID",
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+        operations.push({
+            index,
+            id,
+            kind: "moveRefactor",
+            sourceFile: resolveInputPath(cwd, sourceFile),
+            targetFile: resolveInputPath(cwd, targetFile),
+            entity,
+            symbolName,
+            symbolKind,
+            selectorSyntax,
+            importRules,
+            mutationComments,
+            execute: raw.body.execute === true
+        });
+    }
+    if (operations.length === 0) {
+        return { ok: false, operations, code: "SEMANTIC_MOVE_ROWS_REQUIRED", error: "Standalone semantic move expects at least one move row." };
+    }
+    return { ok: true, operations };
+}
+function fallbackOperations(cwd, payload) {
+    const rawOperations = Array.isArray(payload.operations) ? payload.operations : [];
+    const workspaceRoot = (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? path.resolve(cwd);
+    const selectorSyntax = readSelectorSyntax(payload);
+    return rawOperations.map((raw, index) => {
+        const operation = isObject(raw) ? raw : {};
+        const body = isObject(operation.body) ? operation.body : {};
+        return {
+            index,
+            id: readString(operation.id) ?? `row-${index + 1}`,
+            kind: readString(operation.kind) ?? "operation",
+            sourceFile: resolveInputPath(cwd, readString(body.sourceFile) ?? cwd),
+            targetFile: resolveInputPath(cwd, readString(body.targetFile) ?? cwd),
+            entity: readString(body.symbolName) ?? "",
+            symbolName: readString(body.symbolName) ?? "",
+            symbolKind: readEntityKind(body.symbolKind),
+            selectorSyntax,
+            importRules: safeImportRules(workspaceRoot, body.importRules),
+            mutationComments: safeMutationComments(body.mutationComments),
+            execute: body.execute === true
+        };
+    });
+}
+function readSelectorSyntax(payload) {
+    const syntax = isObject(payload.selectorSyntax) ? payload.selectorSyntax : {};
+    const rawAliases = isObject(syntax.entityKindAliases) ? syntax.entityKindAliases : {};
+    const aliases = Object.fromEntries(types_1.ENTITY_KIND_IDS.map((kind) => [kind, readString(rawAliases[kind]) ?? kind]));
+    return {
+        separator: readString(syntax.separator) ?? "-",
+        aliases
+    };
+}
+function completedBatch(operations, plan, applied, durationMs) {
+    const execute = operations[0].execute;
+    const plannedFiles = plan.edits.map((edit) => path.normalize(edit.fileName));
+    const rows = operations.map((operation) => completedRow(operation, {
+        ok: true,
+        execute,
+        applied: execute,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        symbolName: operation.entity,
+        operationSummary: {
+            operation: "moveToFile",
+            editCount: plan.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0),
+            changedFiles: plannedFiles
+        },
+        ...(execute ? {
+            applyMode: "standaloneSemanticMoveTransaction",
+            touchedFiles: applied?.touchedFiles ?? plannedFiles,
+            savedFiles: applied?.savedFiles ?? plannedFiles
+        } : {})
+    }, durationMs / operations.length));
+    return batchEnvelope(rows, true, durationMs, {
+        code: "SEMANTIC_MOVE_PLAN_COMPLETE",
+        rollback: "not-needed",
+        potentiallyModifiedFiles: [],
+        planner: plannerEvidence(plan),
+        ...(applied ? { savedFiles: applied.savedFiles, touchedFiles: applied.touchedFiles, editCount: applied.editCount } : {})
+    });
+}
+function failedBatch(operations, code, error, durationMs, plan, evidence = {}) {
+    const potentiallyModifiedFiles = readStrings(evidence.potentiallyModifiedFiles);
+    const rows = operations.map((operation) => completedRow(operation, {
+        ok: false,
+        code,
+        error,
+        execute: operation.execute,
+        applied: false,
+        touchedFiles: potentiallyModifiedFiles,
+        savedFiles: []
+    }, operations.length > 0 ? durationMs / operations.length : durationMs));
+    return batchEnvelope(rows, false, durationMs, {
+        code,
+        error,
+        rollback: readString(evidence.rollback) ?? "not-needed",
+        potentiallyModifiedFiles,
+        ...(Array.isArray(evidence.rollbackErrors) ? { rollbackErrors: evidence.rollbackErrors } : {}),
+        ...(plan ? { planner: plannerEvidence(plan) } : {})
+    });
+}
+function completedRow(operation, response, durationMs) {
+    const ok = response.ok === true && (response.execute !== true || response.applied === true);
+    return {
+        index: operation.index + 1,
+        id: operation.id,
+        kind: operation.kind,
+        planned: true,
+        attempted: true,
+        outcome: ok ? (response.applied === true ? "applied" : "validated") : "failed",
+        ok,
+        statusCode: ok ? 200 : 400,
+        durationMs,
+        responseOk: ok,
+        applied: response.applied === true,
+        touchedFiles: readStrings(response.touchedFiles),
+        savedFiles: readStrings(response.savedFiles),
+        ...(typeof response.error === "string" ? { error: response.error } : {}),
+        response
+    };
+}
+function batchEnvelope(rows, ok, durationMs, extra) {
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        contract: {
+            version: 2,
+            execution: "atomic",
+            continueOnError: false,
+            rollback: "verified-semantic-move-transaction",
+            transactional: true,
+            rowOutcomeValues: ["applied", "validated", "failed"]
+        },
+        execution: "atomic",
+        continueOnError: false,
+        batchOk: ok,
+        batchStatus: ok ? "completed" : "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: rows.length,
+        rowCount: rows.length,
+        passedRowCount: ok ? rows.length : 0,
+        failedRowCount: ok ? 0 : rows.length,
+        skippedRowCount: 0,
+        durationMs,
+        guidance: ok ? null : { hint: "Fix the standalone semantic move failure and rerun the complete group." },
+        providerLimitations: [],
+        rows,
+        ...extra
+    };
+}
+function plannerEvidence(plan) {
+    return {
+        code: plan.code,
+        sourceFile: plan.sourceFile,
+        targetFile: plan.targetFile,
+        workspaceRoot: plan.workspaceRoot,
+        snapshotHash: plan.snapshotHash,
+        planHash: plan.planHash,
+        totalMs: plan.totalMs,
+        discovery: plan.discovery,
+        configWorkers: plan.configWorkers
+    };
+}
+function resolveInputPath(cwd, value) {
+    return path.isAbsolute(value) ? path.resolve(value) : path.resolve(cwd, value);
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readEntityKind(value) {
+    return typeof value === "string" && types_1.ENTITY_KIND_IDS.includes(value)
+        ? value
+        : null;
+}
+function safeImportRules(workspaceRoot, value) {
+    try {
+        return (0, import_rules_1.normalizeImportRules)(workspaceRoot, value);
+    }
+    catch {
+        return [];
+    }
+}
+function safeMutationComments(value) {
+    try {
+        return (0, mutation_comments_1.normalizeMutationCommentsPolicy)(value);
+    }
+    catch {
+        return (0, mutation_comments_1.normalizeMutationCommentsPolicy)(undefined);
+    }
+}
+function policySignature(operation) {
+    return JSON.stringify({ importRules: operation.importRules, mutationComments: operation.mutationComments });
+}
+function readStrings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pathKey(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}