@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/file-refactor-batch.js

@@ -0,0 +1,1154 @@
+"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.FILE_REFACTOR_BATCH_TESTING = void 0;
+exports.runFileRefactorBatch = runFileRefactorBatch;
+exports.runFileRefactorBatchExecutionWorker = runFileRefactorBatchExecutionWorker;
+exports.readCachedFileRefactorBatchExecution = readCachedFileRefactorBatchExecution;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const zod_1 = require("zod");
+const env_vars_1 = require("../config/env-vars");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const inspect_cycles_1 = require("./inspect-cycles");
+const file_mutation_worker_apply_1 = require("./file-mutation-worker-apply");
+const mutation_eta_1 = require("./mutation-eta");
+const file_refactor_batch_preview_cache_1 = require("./file-refactor-batch-preview-cache");
+const file_refactor_batch_execution_cache_1 = require("./file-refactor-batch-execution-cache");
+const file_mutation_runtime_1 = require("./file-mutation-runtime");
+const mutation_execution_cache_1 = require("./mutation-execution-cache");
+const mutation_recovery_journal_1 = require("./mutation-recovery-journal");
+const file_impact_scan_1 = require("../mutation/file-impact-scan");
+const runtime_lifecycle_1 = require("../session/runtime-lifecycle");
+const FileRefactorBatchPayloadSchema = zod_1.z.object({
+    operations: zod_1.z.array(zod_1.z.object({
+        kind: zod_1.z.union([zod_1.z.literal("fileMoveToDir"), zod_1.z.literal("fileRename")]),
+        sourceFile: zod_1.z.string().min(1),
+        targetDir: zod_1.z.string().min(1),
+        targetFile: zod_1.z.string().min(1),
+        testCrashAfterFsMove: zod_1.z.string().optional()
+    })).min(1),
+    execute: zod_1.z.boolean().optional(),
+    testCrashAfterFsMove: zod_1.z.string().optional()
+});
+async function runFileRefactorBatch(cwd, rawPayload, options = {}, restArgs = []) {
+    const runtimeOptions = readFileRefactorBatchRuntimeOptions();
+    const action = restArgs[0] ?? "preview";
+    if (action === "help" || action === "--help") {
+        return FileRefactorBatchHelp();
+    }
+    if (action === "apply") {
+        const previewId = restArgs[1];
+        if (!previewId || previewId.startsWith("--")) {
+            throw new errors_1.CliError("FILE_REFACTOR_BATCH_PREVIEW_ID_REQUIRED", "file refactor batch apply expects a preview id.", {
+                usage: "aib file refactor batch apply <previewId>"
+            });
+        }
+        return applyFileRefactorBatchPreview(cwd, previewId, options, runtimeOptions);
+    }
+    if (action !== "preview" && action !== "execute" && action !== "validate") {
+        throw new errors_1.CliError("UNKNOWN_FILE_REFACTOR_BATCH_COMMAND", `Unknown file refactor batch command: ${action}`, {
+            availableCommands: ["preview", "apply", "execute", "validate", "help"]
+        });
+    }
+    const payload = FileRefactorBatchPayloadSchema.parse(rawPayload);
+    const payloadRuntimeOptions = runtimeOptionsWithPayloadOverrides(runtimeOptions, payload);
+    if (action === "execute" && readFileRefactorBatchSyncWaitMs() > 0) {
+        return runFileRefactorBatchPayloadWithExecution(cwd, {
+            ...payload,
+            execute: true
+        }, options, "execute", readFileRefactorBatchSyncWaitMs(), payloadRuntimeOptions);
+    }
+    return runFileRefactorBatchPayload(cwd, {
+        ...payload,
+        execute: action === "execute"
+    }, options, action, payloadRuntimeOptions);
+}
+async function applyFileRefactorBatchPreview(cwd, previewId, options, runtimeOptions) {
+    const record = (0, file_refactor_batch_preview_cache_1.readFileRefactorBatchPreviewRecord)(cwd, previewId);
+    (0, file_refactor_batch_preview_cache_1.validateFileMoveStates)(record);
+    const payload = FileRefactorBatchPayloadSchema.parse({
+        ...record.normalizedPayload,
+        execute: true
+    });
+    const syncWaitMs = readFileRefactorBatchSyncWaitMs();
+    if (syncWaitMs > 0) {
+        return runFileRefactorBatchPayloadWithExecution(cwd, payload, options, "apply", syncWaitMs, runtimeOptions, previewId);
+    }
+    const result = await runFileRefactorBatchPayload(cwd, payload, options, "apply", runtimeOptions, previewId);
+    return result.ok === false
+        ? (0, agent_text_1.attachAgentText)({ ...result, next: "Fix the file refactor batch request and rerun preview." }, formatFileRefactorBatchAgentText({ ...result, next: "Fix the file refactor batch request and rerun preview." }))
+        : result;
+}
+async function runFileRefactorBatchPayloadWithExecution(cwd, payload, options, action, syncWaitMs, runtimeOptions, previewIdFromApply) {
+    const normalized = normalizePayload(cwd, payload, true);
+    const executionId = (0, file_refactor_batch_execution_cache_1.buildFileRefactorBatchExecutionId)();
+    const operation = `file.refactor.batch.${action}`;
+    const etaEstimate = (0, file_mutation_runtime_1.estimateFileMutationEta)(buildFileMutationEtaInput(cwd, normalized.operations));
+    const estimatedDurationMs = etaEstimate.selectedMs;
+    const status = (0, file_refactor_batch_execution_cache_1.createFileRefactorBatchExecutionStatus)(cwd, executionId, operation, buildPlannedMoves(cwd, normalized.operations));
+    const recoveryJournal = (0, mutation_recovery_journal_1.createFileMutationRecoveryJournal)(cwd, executionId, operation, normalized.operations.map((row) => ({
+        id: row.id,
+        kind: row.kind,
+        source: formatRelativePath(cwd, row.sourceFile),
+        target: formatRelativePath(cwd, row.targetFile)
+    })));
+    (0, mutation_recovery_journal_1.writeMutationRecoveryJournal)(cwd, recoveryJournal);
+    (0, mutation_recovery_journal_1.writeMutationRecoveryPlan)(cwd, recoveryJournal, buildFileRefactorBatchRecoveryPlan(cwd, normalized));
+    (0, file_refactor_batch_execution_cache_1.writeFileRefactorBatchExecutionStatus)(cwd, status);
+    const startedAtMs = Date.now();
+    const backgroundEnv = captureFileRefactorBatchBackgroundEnv();
+    const workerInputPath = writeFileRefactorBatchWorkerInput(cwd, executionId, {
+        schemaVersion: 1,
+        cwd,
+        payload,
+        normalized,
+        options: serializeResolveTargetInstanceOptions(options),
+        action,
+        runtimeOptions,
+        executionId,
+        status,
+        previewIdFromApply: previewIdFromApply ?? null,
+        recoveryJournal
+    });
+    startFileRefactorBatchWorkerProcess(cwd, workerInputPath, backgroundEnv);
+    const result = await waitForFileRefactorBatchWorkerResult(cwd, executionId, syncWaitMs);
+    if (result) {
+        return result;
+    }
+    const finalStatus = (0, file_refactor_batch_execution_cache_1.tryReadFileRefactorBatchExecutionStatus)(cwd, executionId);
+    if (finalStatus && finalStatus.status !== "running") {
+        return isObject(finalStatus.result)
+            ? finalStatus.result
+            : readCachedFileRefactorBatchExecution(cwd, executionId);
+    }
+    return buildFileRefactorBatchStillRunningResponse(cwd, executionId, operation, estimatedDurationMs, Date.now() - startedAtMs, etaEstimate);
+}
+async function runFileRefactorBatchExecutionWorker(input) {
+    const status = input.status;
+    try {
+        const result = await executeFileRefactorBatchOperations(input.cwd, input.normalized, input.action, input.options, input.runtimeOptions, input.executionId, status, input.previewIdFromApply ?? undefined, input.recoveryJournal);
+        const rows = readFileRefactorBatchRows(result);
+        status.status = result.ok === false ? "failed" : "completed";
+        status.phase = "completed";
+        status.completedRows = result.ok === false ? rows.filter((row) => row.ok !== false).length : status.rowCount;
+        status.failedRows = result.ok === false ? rows.filter((row) => row.ok === false).length : 0;
+        status.notRunRows = result.ok === false ? Math.max(0, status.rowCount - rows.length) : 0;
+        status.filesWritten = readStringArray(result.filesWritten);
+        status.touchedFiles = readStringArray(result.touchedFiles);
+        status.moves = Array.isArray(result.changes) ? result.changes.filter(isObject) : [];
+        status.rows = rows;
+        if (isObject(result.postMutation)) {
+            status.postMutation = result.postMutation;
+        }
+        const recovery = (0, mutation_recovery_journal_1.mutationRecoveryJournalSummary)(input.recoveryJournal);
+        if (recovery) {
+            status.recovery = recovery;
+        }
+        status.result = result;
+        if (result.ok === false) {
+            status.error = readString(result.code) ?? readFirstFailedCode(rows) ?? "FILE_REFACTOR_BATCH_FAILED";
+        }
+        (0, file_refactor_batch_execution_cache_1.writeFileRefactorBatchExecutionStatus)(input.cwd, status);
+        return result;
+    }
+    catch (error) {
+        status.status = "failed";
+        status.phase = "completed";
+        status.failedRows = Math.max(1, status.failedRows);
+        status.notRunRows = Math.max(0, status.rowCount - status.completedRows - status.failedRows);
+        status.error = error instanceof Error ? error.message : String(error);
+        (0, file_refactor_batch_execution_cache_1.writeFileRefactorBatchExecutionStatus)(input.cwd, status);
+        throw error;
+    }
+}
+function writeFileRefactorBatchWorkerInput(cwd, executionId, input) {
+    const filePath = path.join((0, mutation_recovery_journal_1.mutationRecoveryJournalDir)(cwd, executionId), "worker-input.json");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(input, null, 2)}\n`);
+    fs.renameSync(tmpPath, filePath);
+    return filePath;
+}
+function startFileRefactorBatchWorkerProcess(cwd, inputPath, envPatch) {
+    const env = { ...process.env };
+    for (const [key, value] of Object.entries(envPatch)) {
+        if (value === undefined) {
+            delete env[key];
+        }
+        else {
+            env[key] = value;
+        }
+    }
+    const child = (0, node_child_process_1.spawn)(process.execPath, [fileRefactorBatchWorkerScriptPath(), inputPath], {
+        cwd,
+        env,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+    });
+    child.on("error", () => undefined);
+    (0, runtime_lifecycle_1.trackSessionOwnedProcess)(child, "file-refactor-batch-worker");
+    child.unref();
+}
+function fileRefactorBatchWorkerScriptPath() {
+    return path.join(__dirname, "file-refactor-batch-worker.js");
+}
+async function waitForFileRefactorBatchWorkerResult(cwd, executionId, syncWaitMs) {
+    if (syncWaitMs <= 0) {
+        return null;
+    }
+    const deadline = Date.now() + syncWaitMs;
+    while (Date.now() < deadline) {
+        const status = (0, file_refactor_batch_execution_cache_1.tryReadFileRefactorBatchExecutionStatus)(cwd, executionId);
+        if (status && isFinalFileRefactorBatchWorkerStatus(status)) {
+            return isObject(status.result)
+                ? status.result
+                : readCachedFileRefactorBatchExecution(cwd, executionId);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    const finalStatus = (0, file_refactor_batch_execution_cache_1.tryReadFileRefactorBatchExecutionStatus)(cwd, executionId);
+    if (finalStatus && isFinalFileRefactorBatchWorkerStatus(finalStatus)) {
+        return isObject(finalStatus.result)
+            ? finalStatus.result
+            : readCachedFileRefactorBatchExecution(cwd, executionId);
+    }
+    return null;
+}
+function isFinalFileRefactorBatchWorkerStatus(status) {
+    return isObject(status.result) || status.phase === "completed";
+}
+function serializeResolveTargetInstanceOptions(options) {
+    return {
+        ...(options.metricsEnabled !== undefined ? { metricsEnabled: options.metricsEnabled } : {}),
+        ...(options.importRules ? { importRules: options.importRules } : {}),
+        ...(options.mutationComments ? { mutationComments: options.mutationComments } : {})
+    };
+}
+async function runFileRefactorBatchPayload(cwd, payload, options, action, runtimeOptions, previewIdFromApply, executionId, normalizedFromExecution) {
+    await (0, file_mutation_runtime_1.maybeDelayFileMutationForTest)(process.env[env_vars_1.CLI_ENV.testFileRefactorBatchDelayMs]);
+    const normalized = normalizedFromExecution ?? normalizePayload(cwd, payload, action === "execute" || action === "apply");
+    const result = normalized.execute
+        ? await executeFileRefactorBatchOperations(cwd, normalized, action === "apply" ? "apply" : "execute", options, runtimeOptions, executionId, undefined, previewIdFromApply)
+        : buildLocalFileRefactorBatchPreviewResult(normalized.operations);
+    const response = compactFileRefactorBatchResponse(cwd, result, normalized, action, previewIdFromApply, executionId);
+    if ((action === "preview" || action === "validate") && response.ok !== false) {
+        const previewId = (0, file_refactor_batch_preview_cache_1.buildFileRefactorBatchPreviewId)(normalized.normalizedPayload);
+        const states = (0, file_refactor_batch_preview_cache_1.readFileMoveStates)(normalized.operations);
+        const previewHash = (0, file_refactor_batch_preview_cache_1.buildFileRefactorBatchPreviewHash)(normalized.normalizedPayload, states, response);
+        (0, file_refactor_batch_preview_cache_1.writeFileRefactorBatchPreviewRecord)(cwd, {
+            previewId,
+            previewHash,
+            createdAt: new Date().toISOString(),
+            cwd: path.resolve(cwd),
+            normalizedPayload: normalized.normalizedPayload,
+            states,
+            previewResult: response
+        });
+        response.previewId = previewId;
+        response.next = `aib file refactor batch apply ${previewId}`;
+    }
+    return (0, agent_text_1.attachAgentText)(response, formatFileRefactorBatchAgentText(response));
+}
+async function executeFileRefactorBatchOperations(cwd, normalized, action, options, runtimeOptions, executionId, status, previewIdFromApply, recoveryJournal) {
+    const rawRows = [];
+    const filesWritten = new Set();
+    const touchedFiles = new Set();
+    const preMutationCycles = runPostMutationCyclesSnapshot(cwd, normalized.operations.map((operation) => operation.sourceFile));
+    let cleanup = [];
+    let postMutation = null;
+    for (const operation of normalized.operations) {
+        (0, mutation_recovery_journal_1.updateMutationRecoveryJournalRow)(cwd, recoveryJournal ?? null, operation.id, { phase: "started" });
+        if (status) {
+            status.phase = "movingFile";
+            status.status = "running";
+            const recovery = (0, mutation_recovery_journal_1.mutationRecoveryJournalSummary)(recoveryJournal ?? null);
+            if (recovery) {
+                status.recovery = recovery;
+            }
+            persistFileRefactorBatchExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        const rowResult = await executeFileRefactorBatchMutationRowInWorker(cwd, operation, options, runtimeOptions, recoveryJournal ?? null);
+        const row = Array.isArray(rowResult.rows) && isObject(rowResult.rows[0])
+            ? rowResult.rows[0]
+            : localFailureRow(operation, "FILE_REFACTOR_BATCH_FAILED", "Extension did not return a file refactor batch row.");
+        const finalRow = row;
+        rawRows.push(finalRow);
+        for (const savedFile of collectStringArray(finalRow.savedFiles)) {
+            filesWritten.add(path.normalize(savedFile));
+        }
+        for (const touchedFile of collectStringArray(finalRow.touchedFiles)) {
+            touchedFiles.add(path.normalize(touchedFile));
+        }
+        for (const cleanupRow of Array.isArray(finalRow.cleanup) ? finalRow.cleanup.filter(isObject) : []) {
+            cleanup.push(cleanupRow);
+        }
+        const rowRecoveryPatch = {
+            phase: finalRow.ok === false ? "failed" : "completed",
+            filesWritten: collectStringArray(finalRow.savedFiles).map((file) => formatRelativePath(cwd, file)),
+            touchedFiles: collectStringArray(finalRow.touchedFiles).map((file) => formatRelativePath(cwd, file))
+        };
+        const finalRowError = readString(finalRow.error);
+        if (finalRowError) {
+            rowRecoveryPatch.error = finalRowError;
+        }
+        (0, mutation_recovery_journal_1.updateMutationRecoveryJournalRow)(cwd, recoveryJournal ?? null, operation.id, rowRecoveryPatch);
+        if (status) {
+            const recovery = (0, mutation_recovery_journal_1.mutationRecoveryJournalSummary)(recoveryJournal ?? null);
+            if (recovery) {
+                status.recovery = recovery;
+            }
+            persistFileRefactorBatchExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        if (finalRow.ok === false) {
+            break;
+        }
+        await (0, file_mutation_runtime_1.delayFileMutationForTest)(runtimeOptions.testRowDelayMs);
+    }
+    const rowsOk = rawRows.every((row) => row.ok !== false) && rawRows.length === normalized.operations.length;
+    const cleanupOk = cleanup.every((row) => row.ok !== false);
+    if (rowsOk && cleanupOk) {
+        if (status) {
+            status.phase = "postMutation.cycles";
+            persistFileRefactorBatchExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        await maybeDelayPostMutationCycles(runtimeOptions.testPostMutationCyclesDelayMs);
+        const postMutationFocusFiles = uniqueStrings([...Array.from(touchedFiles), ...Array.from(filesWritten)]);
+        const postMutationCycles = runPostMutationCyclesSnapshot(cwd, postMutationFocusFiles);
+        postMutation = {
+            cycles: diffPostMutationCycles(preMutationCycles, postMutationCycles, new Set(formatCycleFocusFiles(cwd, postMutationFocusFiles)))
+        };
+    }
+    const rawResult = compactObject({
+        ...(!rowsOk || !cleanupOk ? { ok: false } : {}),
+        operation: "fileMutation",
+        execute: true,
+        rowCount: normalized.operations.length,
+        appliedCount: rawRows.filter((row) => row.applied === true).length,
+        savedFiles: Array.from(filesWritten),
+        touchedFiles: Array.from(touchedFiles),
+        cleanup,
+        rows: rawRows,
+        recovery: (0, mutation_recovery_journal_1.mutationRecoveryJournalSummary)(recoveryJournal ?? null),
+        postMutation
+    });
+    const response = compactFileRefactorBatchResponse(cwd, rawResult, normalized, action, previewIdFromApply, executionId);
+    return (0, agent_text_1.attachAgentText)(response, formatFileRefactorBatchAgentText(response));
+}
+function unwrapFileRefactorBatchRow(result, operation) {
+    return Array.isArray(result.rows) && isObject(result.rows[0])
+        ? result.rows[0]
+        : localFailureRow(operation, "FILE_REFACTOR_BATCH_FAILED", "Extension did not return a file refactor batch row.");
+}
+function persistFileRefactorBatchExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles) {
+    const compactRows = rawRows.map((row) => compactRow(cwd, row));
+    status.rows = compactRows;
+    status.completedRows = compactRows.filter((row) => row.ok !== false).length;
+    status.failedRows = compactRows.filter((row) => row.ok === false).length;
+    status.notRunRows = status.failedRows > 0 ? Math.max(0, status.rowCount - compactRows.length) : 0;
+    status.filesWritten = Array.from(filesWritten).sort((left, right) => left.localeCompare(right)).map((file) => formatRelativePath(cwd, file));
+    status.touchedFiles = Array.from(touchedFiles).sort((left, right) => left.localeCompare(right)).map((file) => formatRelativePath(cwd, file));
+    if (status.failedRows > 0) {
+        status.status = "failed";
+        status.error = readFirstFailedCode(compactRows) ?? "FILE_REFACTOR_BATCH_FAILED";
+    }
+    (0, file_refactor_batch_execution_cache_1.writeFileRefactorBatchExecutionStatus)(cwd, status);
+}
+async function executeFileRefactorBatchMutationRowInWorker(cwd, operation, options, runtimeOptions, recoveryJournal, executeRow = file_mutation_worker_apply_1.executeWorkerOwnedFileMutationRow) {
+    let response;
+    try {
+        response = await executeRow(cwd, operation, options, runtimeOptions);
+    }
+    catch (error) {
+        response = {
+            rows: [localFailureRow(operation, error instanceof errors_1.CliError ? error.code : "FILE_REFACTOR_BATCH_WORKER_FAILED", error instanceof Error ? error.message : String(error))]
+        };
+    }
+    const row = Array.isArray(response.rows) && isObject(response.rows[0]) ? response.rows[0] : null;
+    (0, mutation_recovery_journal_1.writeMutationRecoveryDetail)(cwd, recoveryJournal, "apply", operation.id, {
+        response,
+        savedFiles: row ? collectStringArray(row.savedFiles).map((file) => formatRelativePath(cwd, file)) : [],
+        touchedFiles: row ? collectStringArray(row.touchedFiles).map((file) => formatRelativePath(cwd, file)) : [],
+        planner: row && isObject(row.planner) ? row.planner : null,
+        discovery: row && isObject(row.discovery) ? row.discovery : null
+    });
+    return response;
+}
+exports.FILE_REFACTOR_BATCH_TESTING = {
+    executeWorkerOwnedRow: executeFileRefactorBatchMutationRowInWorker,
+    compactRow
+};
+function readCachedFileRefactorBatchExecution(cwd, executionId) {
+    const status = (0, file_refactor_batch_execution_cache_1.readFileRefactorBatchExecutionStatus)(cwd, executionId);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildFileRefactorBatchExecutionSummary(status),
+        progress: `${status.completedRows}/${status.rowCount}`,
+        filesWritten: status.filesWritten,
+        touchedFiles: status.touchedFiles,
+        ...(status.recovery ? { recovery: status.recovery } : {}),
+        ...(status.postMutation ? { postMutation: status.postMutation } : {}),
+        updatedAt: status.updatedAt,
+        ...(status.error ? { error: status.error } : {})
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatFileRefactorBatchExecutionStatusText(status));
+}
+function buildFileRefactorBatchStillRunningResponse(cwd, executionId, operation, estimatedDurationMs, elapsedMs, estimate = null) {
+    const status = (0, file_refactor_batch_execution_cache_1.readFileRefactorBatchExecutionStatus)(cwd, executionId);
+    const estimatedRemainingMs = Math.max(0, estimatedDurationMs - elapsedMs);
+    const eta = (0, mutation_eta_1.buildMutationEtaHint)(status.executionId, estimatedRemainingMs);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildFileRefactorBatchExecutionSummary(status),
+        progress: `${status.completedRows}/${status.rowCount}`,
+        filesWritten: status.filesWritten,
+        touchedFiles: status.touchedFiles,
+        ...(status.recovery ? { recovery: status.recovery } : {}),
+        ...(status.postMutation ? { postMutation: status.postMutation } : {}),
+        updatedAt: status.updatedAt,
+        ...(estimate ? { eta: estimate } : {}),
+        estimatedRemainingMs: eta.estimatedRemainingMs,
+        suggestedFirstCheckMs: eta.suggestedFirstCheckMs,
+        next: eta.next
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatFileRefactorBatchStillRunningText(operation, status, eta));
+}
+function formatFileRefactorBatchStillRunningText(operation, status, eta) {
+    return [
+        `${operation} ${status.executionId}`,
+        buildFileRefactorBatchExecutionSummary(status),
+        formatFileRefactorBatchPhaseLine(status),
+        ...(0, mutation_eta_1.formatMutationEtaLines)(eta)
+    ].join("\n");
+}
+function formatFileRefactorBatchExecutionStatusText(status) {
+    const lines = [
+        buildFileRefactorBatchExecutionSummary(status)
+    ];
+    if (status.status === "running") {
+        lines.push(formatFileRefactorBatchPhaseLine(status));
+        return lines.join("\n");
+    }
+    appendExecutionChangeLines(lines, status);
+    const failedRows = status.rows.filter((row) => row.ok === false);
+    const firstFailed = failedRows[0];
+    if (firstFailed) {
+        const code = readString(firstFailed.code) ?? status.error ?? "FILE_REFACTOR_BATCH_FAILED";
+        lines.push(`code: ${code}`);
+        if (typeof firstFailed.error === "string") {
+            lines.push(firstFailed.error);
+        }
+        if (typeof firstFailed.rollback === "string") {
+            lines.push(`rollback: ${firstFailed.rollback}`);
+        }
+        if (typeof firstFailed.hint === "string") {
+            lines.push(`hint: ${firstFailed.hint}`);
+        }
+        lines.push("failed:");
+        for (const row of failedRows) {
+            lines.push(`${readString(row.source) ?? "source"} -> ${readString(row.target) ?? "target"}`);
+        }
+    }
+    else if (status.error) {
+        lines.push(status.error);
+    }
+    appendExecutionNotRunLines(lines, status);
+    appendRecoveryLines(lines, status);
+    if (status.filesWritten.length > 0) {
+        appendFilesWrittenLines(lines, status.filesWritten, status.plannedMoves.map((move) => move.target));
+    }
+    if (isObject(status.postMutation) && isObject(status.postMutation.cycles)) {
+        appendPostMutationCyclesText(lines, status.postMutation.cycles);
+    }
+    if (status.status === "failed") {
+        lines.push("next: Fix failed rename row and rerun file.refactor.batch preview.");
+    }
+    return lines.join("\n");
+}
+function formatFileRefactorBatchPhaseLine(status) {
+    if (status.phase === "postProcessImports") {
+        return "updating imports";
+    }
+    if (status.phase === "postMutation.cycles") {
+        return "checking cycles";
+    }
+    if (status.phase === "recoveringFileMutation") {
+        return "recovering file mutation";
+    }
+    return "moving/renaming files";
+}
+function buildFileRefactorBatchExecutionSummary(status) {
+    const percent = Math.floor((Math.max(0, status.completedRows) / Math.max(1, status.rowCount)) * 100);
+    if (status.status === "completed") {
+        return `completed, ${status.completedRows}/${status.rowCount} rows, ${percent}% files, ${status.filesWritten.length} files written`;
+    }
+    if (status.status === "failed") {
+        const parts = [
+            `failed, ${status.completedRows}/${status.rowCount} rows, ${percent}% files`,
+            `${status.failedRows} failed`
+        ];
+        if (status.notRunRows > 0) {
+            parts.push(`${status.notRunRows} not run`);
+        }
+        parts.push(`${status.filesWritten.length} files written`);
+        return parts.join(", ");
+    }
+    return `in progress, ${status.completedRows}/${status.rowCount} rows, ${percent}% files`;
+}
+function normalizePayload(cwd, payload, execute) {
+    const baseDir = path.resolve(cwd);
+    const operations = [];
+    const seenTargets = new Set();
+    for (const inputOperation of payload.operations) {
+        const sourceFile = resolveCliFilePath(cwd, inputOperation.sourceFile);
+        assertInsideCwd(cwd, sourceFile, "FILE_REFACTOR_BATCH_SOURCE_OUTSIDE_CWD");
+        const targetFile = resolveCliFilePath(cwd, inputOperation.targetFile);
+        assertInsideCwd(cwd, targetFile, "FILE_REFACTOR_BATCH_TARGET_OUTSIDE_CWD");
+        const targetDir = resolveCliFilePath(cwd, inputOperation.targetDir);
+        assertInsideCwd(cwd, targetDir, "FILE_REFACTOR_BATCH_TARGET_OUTSIDE_CWD");
+        const targetKey = normalizeKey(targetFile);
+        if (seenTargets.has(targetKey)) {
+            throw new errors_1.CliError("FILE_REFACTOR_BATCH_DUPLICATE_TARGET", "Several file refactor batch rows resolve to the same target.", {
+                targetFile: formatRelativePath(cwd, targetFile)
+            });
+        }
+        seenTargets.add(targetKey);
+        operations.push({
+            id: `${inputOperation.kind === "fileRename" ? "rename" : "move"}-${operations.length + 1}`,
+            kind: inputOperation.kind,
+            sourceFile,
+            targetDir,
+            targetFile,
+            execute,
+            testCrashAfterFsMove: readString(inputOperation.testCrashAfterFsMove)
+        });
+    }
+    if (operations.length === 0) {
+        throw new errors_1.CliError("FILE_REFACTOR_BATCH_ROWS_REQUIRED", "file refactor batch expects at least one operation.");
+    }
+    return {
+        execute,
+        baseDir,
+        operations,
+        normalizedPayload: {
+            operations: normalizedPayloadOperations(operations),
+            execute
+        }
+    };
+}
+function buildLocalFileRefactorBatchPreviewResult(operations) {
+    const rows = [];
+    const virtualFiles = new Set();
+    const removedFiles = new Set();
+    const virtualDirs = new Set();
+    for (const operation of operations) {
+        if (rows.some((row) => row.ok === false)) {
+            break;
+        }
+        const row = validateLocalMoveOperation(operation, { virtualFiles, removedFiles, virtualDirs });
+        rows.push(row);
+        if (row.ok !== false) {
+            removedFiles.add(normalizeKey(operation.sourceFile));
+            virtualFiles.delete(normalizeKey(operation.sourceFile));
+            virtualFiles.add(normalizeKey(operation.targetFile));
+            virtualDirs.add(normalizeKey(operation.targetDir));
+        }
+    }
+    const ok = rows.every((row) => row.ok !== false) && rows.length === operations.length;
+    return {
+        ...(ok ? {} : { ok: false }),
+        operation: "fileMutation",
+        execute: false,
+        rowCount: operations.length,
+        appliedCount: 0,
+        savedFiles: [],
+        rows
+    };
+}
+function validateLocalMoveOperation(operation, virtualState) {
+    if (operation.kind !== "fileMoveToDir" && operation.kind !== "fileRename") {
+        return localFailureRow(operation, "FILE_MUTATION_KIND_UNSUPPORTED", `Unsupported file mutation kind: ${operation.kind}`);
+    }
+    const sourceKey = normalizeKey(operation.sourceFile);
+    const targetKey = normalizeKey(operation.targetFile);
+    const targetDirKey = normalizeKey(operation.targetDir);
+    const sourceExists = virtualState?.virtualFiles.has(sourceKey) === true || (!virtualState?.removedFiles.has(sourceKey) && fs.existsSync(operation.sourceFile));
+    if (!sourceExists) {
+        return localFailureRow(operation, "FILE_REFACTOR_BATCH_SOURCE_NOT_FOUND", "Source file does not exist.");
+    }
+    if (virtualState?.virtualFiles.has(sourceKey) !== true) {
+        try {
+            const stat = fs.statSync(operation.sourceFile);
+            if (!stat.isFile()) {
+                return localFailureRow(operation, "FILE_REFACTOR_BATCH_SOURCE_DIRECTORY_UNSUPPORTED", "file refactor batch v1 supports files only, not directories.");
+            }
+        }
+        catch (error) {
+            return localFailureRow(operation, "FILE_REFACTOR_BATCH_SOURCE_STAT_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    const targetExists = virtualState?.virtualFiles.has(targetKey) === true || (!virtualState?.removedFiles.has(targetKey) && fs.existsSync(operation.targetFile));
+    if (targetExists) {
+        return localFailureRow(operation, "FILE_REFACTOR_BATCH_TARGET_EXISTS", "Target file already exists.", "Pick another target directory/name or remove the target collision.");
+    }
+    const targetDirExists = virtualState?.virtualDirs.has(targetDirKey) === true || fs.existsSync(operation.targetDir);
+    if (operation.kind === "fileRename" && !targetDirExists) {
+        return localFailureRow(operation, "FILE_REFACTOR_BATCH_TARGET_DIR_NOT_FOUND", "Target parent directory does not exist.");
+    }
+    return {
+        id: operation.id,
+        ok: true,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        applied: false
+    };
+}
+function localFailureRow(operation, code, error, hint) {
+    return {
+        id: operation.id,
+        ok: false,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        applied: false,
+        code,
+        error,
+        ...(hint ? { hint } : {})
+    };
+}
+function normalizedPayloadOperations(operations) {
+    return operations.map((operation) => ({
+        kind: operation.kind,
+        sourceFile: operation.sourceFile,
+        targetDir: operation.targetDir,
+        targetFile: operation.targetFile,
+        ...(operation.testCrashAfterFsMove ? { testCrashAfterFsMove: operation.testCrashAfterFsMove } : {})
+    }));
+}
+function resolveSourceFile(cwd, baseDir, rawPath) {
+    const trimmed = rawPath.trim();
+    if (path.isAbsolute(trimmed)) {
+        return path.normalize(trimmed);
+    }
+    const baseRelative = path.normalize(path.resolve(baseDir, trimmed));
+    if (fs.existsSync(baseRelative)) {
+        return baseRelative;
+    }
+    const cwdRelative = path.normalize(path.resolve(cwd, trimmed));
+    if (fs.existsSync(cwdRelative)) {
+        return cwdRelative;
+    }
+    return baseRelative;
+}
+function resolveRenameTargetFile(cwd, baseDir, sourceFile, rawTarget) {
+    const trimmed = rawTarget.trim();
+    if (path.isAbsolute(trimmed)) {
+        return path.normalize(trimmed);
+    }
+    if (trimmed.includes("/") || trimmed.includes("\\")) {
+        return path.normalize(path.resolve(baseDir, trimmed));
+    }
+    return path.normalize(path.resolve(path.dirname(sourceFile), trimmed));
+}
+function resolveInsideCwd(cwd, rawPath) {
+    const resolved = path.normalize(path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath));
+    assertInsideCwd(cwd, resolved, "FILE_REFACTOR_BATCH_PATH_OUTSIDE_CWD");
+    return resolved;
+}
+function assertInsideCwd(cwd, filePath, code) {
+    const root = path.resolve(cwd);
+    const relative = path.relative(root, filePath);
+    if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+        return;
+    }
+    throw new errors_1.CliError(code, "File move paths must stay inside the current workspace.", {
+        cwd: root,
+        filePath
+    });
+}
+function compactFileRefactorBatchResponse(cwd, raw, normalized, action, previewIdFromApply, executionId) {
+    const rows = Array.isArray(raw.rows)
+        ? raw.rows.filter(isObject).map((row) => compactRow(cwd, row))
+        : [];
+    const ok = raw.ok !== false && rows.every((row) => row.ok !== false);
+    const changedFiles = collectRows(rows, "target");
+    const filesWritten = collectExistingFiles(cwd, collectStringArray(raw.savedFiles)).map((file) => formatRelativePath(cwd, file));
+    const operation = action === "apply"
+        ? "file.refactor.batch.apply"
+        : normalized.execute
+            ? "file.refactor.batch.execute"
+            : "file.refactor.batch.preview";
+    const response = compactObject({
+        ...(ok ? {} : { ok: false }),
+        operation,
+        executionId: executionId ?? null,
+        base: formatRelativePath(cwd, normalized.baseDir),
+        operationCount: normalized.operations.length,
+        summary: ok
+            ? normalized.execute
+                ? `${normalized.operations.length} ${plural(normalized.operations.length, "file", "files")} changed, ${filesWritten.length} ${plural(filesWritten.length, "file", "files")} written`
+                : `${normalized.operations.length} ${plural(normalized.operations.length, "file", "files")} ready`
+            : buildFailureSummary(rows, normalized.operations.length, normalized.execute || action === "apply"),
+        changes: formatChangePairs(cwd, normalized.operations),
+        ...(normalized.execute || action === "apply" ? { filesWritten, filesChanged: changedFiles } : {}),
+        ...(isObject(raw.postMutation) ? { postMutation: raw.postMutation } : {}),
+        ...(isObject(raw.recovery) ? { recovery: raw.recovery } : {}),
+        rows: ok ? null : rows,
+        previewId: previewIdFromApply ?? null
+    });
+    return response;
+}
+function compactRow(cwd, row) {
+    return compactObject({
+        id: readString(row.id),
+        ok: row.ok !== false,
+        source: formatRelativePath(cwd, readString(row.sourceFile) ?? ""),
+        target: formatRelativePath(cwd, readString(row.targetFile) ?? ""),
+        applied: typeof row.applied === "boolean" ? row.applied : null,
+        rollback: readString(row.rollback),
+        potentiallyModifiedFiles: compactList(collectStringArray(row.potentiallyModifiedFiles).map((file) => formatRelativePath(cwd, file)), 10),
+        rollbackErrors: compactList(collectStringArray(row.rollbackErrors), 10),
+        recovered: row.recovered === true ? true : null,
+        recoveryReason: readString(row.recoveryReason),
+        savedFiles: compactList(collectStringArray(row.savedFiles).map((file) => formatRelativePath(cwd, file)), 5),
+        code: readString(row.code),
+        error: readString(row.error),
+        hint: readString(row.hint)
+    });
+}
+function formatChangePairs(cwd, operations) {
+    return operations.map((operation) => ({
+        source: formatRelativePath(cwd, operation.sourceFile),
+        target: formatRelativePath(cwd, operation.targetFile)
+    }));
+}
+function buildFailureSummary(rows, total, executed) {
+    const failed = rows.filter((row) => row.ok === false).length;
+    const notRun = Math.max(0, total - rows.length);
+    if (!executed) {
+        const checked = Math.min(total, rows.length);
+        return `${total} ${plural(total, "file", "files")}, validation blocked at row ${checked}`;
+    }
+    return `${total} ${plural(total, "file", "files")}, ${failed} failed${notRun > 0 ? `, ${notRun} not run` : ""}`;
+}
+function buildFileRefactorBatchRecoveryPlan(cwd, normalized) {
+    return {
+        domain: "file",
+        operation: "fileMutation",
+        execute: normalized.execute,
+        base: formatRelativePath(cwd, normalized.baseDir),
+        rowCount: normalized.operations.length,
+        rows: normalized.operations.map((operation) => ({
+            id: operation.id,
+            kind: operation.kind,
+            source: formatRelativePath(cwd, operation.sourceFile),
+            target: formatRelativePath(cwd, operation.targetFile),
+            targetDir: formatRelativePath(cwd, operation.targetDir),
+            applySteps: [
+                "provider.fileRenameEdits",
+                operation.kind === "fileRename" ? "fs.rename" : "fs.moveToDir",
+                "textEdits.requiredImports",
+                "textEdits.assetImports",
+                "postProcess.importCleanup"
+            ]
+        }))
+    };
+}
+function buildPlannedMoves(cwd, operations) {
+    return operations.map((operation) => ({
+        source: formatRelativePath(cwd, operation.sourceFile),
+        target: formatRelativePath(cwd, operation.targetFile),
+        targetDir: formatRelativePath(cwd, operation.targetDir)
+    }));
+}
+function readFileRefactorBatchRows(result) {
+    return Array.isArray(result.rows) ? result.rows.filter(isObject) : [];
+}
+function buildFileMutationEtaInput(cwd, operations) {
+    const targetDirs = new Set(operations.map((operation) => operation.targetDir));
+    let dirsToCreate = 0;
+    for (const targetDir of targetDirs) {
+        if (!fs.existsSync(targetDir)) {
+            dirsToCreate += 1;
+        }
+    }
+    const impact = (0, file_impact_scan_1.estimateFileMutationImpact)(cwd, operations.map((operation) => operation.sourceFile));
+    return {
+        rowCount: operations.length,
+        targetDirCount: targetDirs.size,
+        dirsToCreate,
+        importingFileCount: impact.importingFileCount,
+        importStatementCount: impact.importStatementCount,
+        barrelExportCount: impact.barrelExportCount,
+        sourceFileCount: impact.sourceFileCount,
+        existingSourceFileCount: impact.existingSourceFileCount,
+        scanTruncated: impact.truncated
+    };
+}
+function readFirstFailedCode(rows) {
+    const failed = rows.find((row) => row.ok === false);
+    return failed ? readString(failed.code) : null;
+}
+function appendExecutionChangeLines(lines, status) {
+    const completedSources = new Set(status.rows.filter((row) => row.ok !== false).map((row) => readString(row.source)).filter((value) => Boolean(value)));
+    const pairs = [];
+    for (const move of status.plannedMoves) {
+        if (status.status !== "completed" && !completedSources.has(move.source)) {
+            continue;
+        }
+        pairs.push(`${move.source} -> ${move.target}`);
+    }
+    if (pairs.length === 0) {
+        return;
+    }
+    lines.push("changes:");
+    for (const pair of pairs) {
+        lines.push(pair);
+    }
+}
+function appendExecutionNotRunLines(lines, status) {
+    if (status.notRunRows <= 0) {
+        return;
+    }
+    const seenSources = new Set(status.rows.map((row) => readString(row.source)).filter((value) => Boolean(value)));
+    const notRun = status.plannedMoves.filter((move) => !seenSources.has(move.source));
+    if (notRun.length === 0) {
+        return;
+    }
+    lines.push("not run:");
+    for (const move of notRun) {
+        lines.push(move.source);
+    }
+}
+function appendRecoveryLines(lines, status) {
+    if (!isObject(status.recovery) || !Array.isArray(status.recovery.rows)) {
+        return;
+    }
+    const rows = status.recovery.rows.filter(isObject);
+    const visibleRows = rows.filter((row) => {
+        const phase = readString(row.phase);
+        return phase && phase !== "planned" && phase !== "started" && phase !== "completed";
+    });
+    if (visibleRows.length === 0) {
+        return;
+    }
+    lines.push("recovery:");
+    for (const row of visibleRows) {
+        const source = readString(row.source) ?? "source";
+        const target = readString(row.target) ?? "target";
+        const phase = readString(row.phase) ?? "unknown";
+        lines.push(`${source} -> ${target}: ${phase}`);
+    }
+}
+function readFileRefactorBatchSyncWaitMs() {
+    return (0, mutation_execution_cache_1.readMutationSyncWaitMs)(process.env[env_vars_1.CLI_ENV.fileRefactorBatchSyncWaitMs], 120_000);
+}
+function readFileRefactorBatchRuntimeOptions() {
+    return {
+        postProcessImports: (0, file_mutation_runtime_1.isFileMutationImportPostProcessEnabled)(),
+        testFailRequiredImportUpdate: readString(process.env[env_vars_1.CLI_ENV.testFileRefactorBatchFailImports]),
+        testCrashAfterFsMove: readString(process.env[env_vars_1.CLI_ENV.testFileRefactorBatchCrashAfterFsMove]),
+        testRowDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testFileRefactorBatchRowDelayMs], 60_000),
+        testImportPostProcessDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testFileRefactorBatchImportsDelayMs], 60_000),
+        testPostMutationCyclesDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testPostMutationCyclesDelayMs], 60_000)
+    };
+}
+function captureFileRefactorBatchBackgroundEnv() {
+    return (0, file_mutation_runtime_1.captureFileMutationBackgroundEnv)([
+        env_vars_1.CLI_ENV.testFileRefactorBatchDelayMs,
+        env_vars_1.CLI_ENV.testFileRefactorBatchRowDelayMs,
+        env_vars_1.CLI_ENV.testFileRefactorBatchImportsDelayMs,
+        env_vars_1.CLI_ENV.testFileRefactorBatchFailImports,
+        env_vars_1.CLI_ENV.testFileRefactorBatchCrashAfterFsMove
+    ]);
+}
+function runtimeOptionsWithPayloadOverrides(runtimeOptions, payload) {
+    return {
+        ...runtimeOptions,
+        testCrashAfterFsMove: readString(payload.testCrashAfterFsMove) ?? runtimeOptions.testCrashAfterFsMove
+    };
+}
+function formatFileRefactorBatchAgentText(response) {
+    const operation = readString(response.operation);
+    if (!operation?.startsWith("file.refactor.batch.")) {
+        return null;
+    }
+    const lines = [];
+    const previewId = readString(response.previewId);
+    const executionId = readString(response.executionId);
+    lines.push(response.ok === false
+        ? `${operation} failed`
+        : previewId && operation === "file.refactor.batch.preview"
+            ? `${operation} ${previewId}`
+            : executionId && (operation === "file.refactor.batch.apply" || operation === "file.refactor.batch.execute")
+                ? `${operation} ${executionId}`
+                : operation);
+    if (typeof response.summary === "string") {
+        lines.push(response.summary);
+    }
+    const changes = Array.isArray(response.changes) ? response.changes.filter(isObject) : [];
+    if (changes.length > 0 && response.ok !== false) {
+        lines.push("changes:");
+        for (const change of changes) {
+            const source = readString(change.source);
+            const target = readString(change.target);
+            if (source && target) {
+                lines.push(`${source} -> ${target}`);
+            }
+        }
+    }
+    appendFailureLines(lines, response);
+    const filesWritten = Array.isArray(response.filesWritten) ? response.filesWritten : [];
+    if (filesWritten.length > 0) {
+        appendFilesWrittenLines(lines, filesWritten, Array.isArray(response.filesChanged) ? response.filesChanged : []);
+    }
+    if (isObject(response.postMutation) && isObject(response.postMutation.cycles)) {
+        appendPostMutationCyclesText(lines, response.postMutation.cycles);
+    }
+    if (typeof response.next === "string") {
+        lines.push(`next: ${response.next}`);
+    }
+    return lines.join("\n");
+}
+function appendFailureLines(lines, response) {
+    if (response.ok !== false || !Array.isArray(response.rows)) {
+        return;
+    }
+    const failed = response.rows.filter(isObject).find((row) => row.ok === false);
+    if (!failed) {
+        return;
+    }
+    lines.push("failed:");
+    lines.push(`${readString(failed.source) ?? "source"} -> ${readString(failed.target) ?? "target"}`);
+    lines.push(`code: ${readString(failed.code) ?? "FILE_REFACTOR_BATCH_FAILED"}`);
+    if (typeof failed.error === "string") {
+        lines.push(failed.error);
+    }
+    if (typeof failed.rollback === "string") {
+        lines.push(`rollback: ${failed.rollback}`);
+    }
+    if (typeof failed.hint === "string") {
+        lines.push(`hint: ${failed.hint}`);
+    }
+}
+function FileRefactorBatchHelp() {
+    return {
+        ok: true,
+        command: "file refactor batch",
+        usage: "aib file refactor batch preview --stdin | aib file refactor batch execute --stdin | aib file refactor batch apply <previewId>",
+        dsl: [
+            "@base packages/agent-project-tooling/src",
+            "rename workspace-runner-cli.ts->cli.ts workspace-runner-command-hints.ts->command-hints.ts"
+        ],
+        notes: [
+            "preview validates planned file refactor batchs without writing.",
+            "execute moves/renames files and updates TypeScript imports.",
+            "apply uses the cached preview id and refuses stale source/target state."
+        ]
+    };
+}
+function collectRows(rows, field) {
+    return rows.map((row) => readString(row[field])).filter((value) => Boolean(value));
+}
+function collectStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function runPostMutationCyclesSnapshot(cwd, files) {
+    const existingFiles = formatCycleFocusFiles(cwd, files).filter((file) => fs.existsSync(resolveCliFilePath(cwd, file)));
+    if (existingFiles.length === 0) {
+        return {
+            op: "cycles",
+            componentCount: 0,
+            components: []
+        };
+    }
+    const args = ["cycles"];
+    for (const file of existingFiles) {
+        args.push("--files", file);
+    }
+    args.push("--detail", "imports", "--limit", "50");
+    return (0, inspect_cycles_1.runInspectCycles)(cwd, args, undefined);
+}
+function diffPostMutationCycles(prePayload, postPayload, touchedFiles) {
+    const preKeys = new Set(readCycleComponents(prePayload).map(cycleComponentKey));
+    const newOrChanged = readCycleComponents(postPayload).filter((component) => readStringArray(component.files).some((file) => touchedFiles.has(file)) &&
+        !preKeys.has(cycleComponentKey(component)));
+    return {
+        status: newOrChanged.length > 0 ? "new-or-changed" : "none",
+        detail: "imports",
+        newOrChangedCount: newOrChanged.length,
+        preComponentCount: readNumber(prePayload.componentCount),
+        postComponentCount: readNumber(postPayload.componentCount),
+        components: newOrChanged
+    };
+}
+function readCycleComponents(payload) {
+    return (Array.isArray(payload.components) ? payload.components : [])
+        .filter(isObject)
+        .map((component) => ({
+        kind: readString(component.kind) ?? "mixed",
+        files: readStringArray(component.files).sort(),
+        chain: readString(component.chain) ?? "",
+        ...(isObject(component.cycle) ? { cycle: component.cycle } : {}),
+        imports: readCycleImports(component)
+    }));
+}
+function readCycleImports(component) {
+    const cycle = isObject(component.cycle) ? component.cycle : {};
+    return readStringArray(cycle.imports);
+}
+function cycleComponentKey(component) {
+    return `${readString(component.kind) ?? "mixed"}:${readStringArray(component.files).sort().join("|")}`;
+}
+function formatCycleFocusFiles(cwd, files) {
+    return uniqueStrings(files.map((file) => formatRelativePath(cwd, resolveCliFilePath(cwd, file))));
+}
+function resolveCliFilePath(cwd, file) {
+    return path.normalize(path.isAbsolute(file) ? file : path.resolve(cwd, file));
+}
+function readStringArray(value) {
+    return collectStringArray(value);
+}
+function collectExistingFiles(cwd, files) {
+    return files.filter((file) => {
+        const resolved = path.isAbsolute(file) ? file : path.resolve(cwd, file);
+        return fs.existsSync(resolved);
+    });
+}
+function compactList(items, limit) {
+    const unique = Array.from(new Set(items)).sort((left, right) => left.localeCompare(right));
+    const visible = unique.slice(0, limit);
+    const hidden = unique.length - visible.length;
+    return hidden > 0 ? [...visible, `+ ${hidden} more`] : visible;
+}
+function formatInlineList(values, limit) {
+    const visible = values.slice(0, limit);
+    const hidden = values.length - visible.length;
+    return hidden > 0 ? `${visible.join(", ")}, + ${hidden} more` : visible.join(", ");
+}
+function appendFilesWrittenLines(lines, values, movedTargets) {
+    const files = values.filter((value) => typeof value === "string");
+    if (files.length === 0) {
+        return;
+    }
+    const moved = new Set(movedTargets.filter((value) => typeof value === "string"));
+    const movedFiles = files.filter((file) => moved.has(file));
+    const referenceFiles = files.filter((file) => !moved.has(file));
+    const visibleReferenceFiles = referenceFiles.slice(0, 8);
+    const hiddenReferenceFiles = referenceFiles.length - visibleReferenceFiles.length;
+    lines.push("filesWritten:");
+    for (const file of [...movedFiles, ...visibleReferenceFiles]) {
+        lines.push(file);
+    }
+    if (hiddenReferenceFiles > 0) {
+        lines.push(`+ ${hiddenReferenceFiles} reference ${plural(hiddenReferenceFiles, "file", "files")}`);
+    }
+}
+function appendPostMutationCyclesText(lines, cycles) {
+    lines.push("cycles:");
+    const count = readNumber(cycles.newOrChangedCount);
+    if (count === 0) {
+        lines.push("no new/changed cycles involving touched files");
+        return;
+    }
+    const components = Array.isArray(cycles.components) ? cycles.components.filter(isObject) : [];
+    lines.push(formatPostMutationCycleSummary(count, components));
+    components.forEach((component, index) => {
+        (0, inspect_cycles_1.appendCycleComponentText)(lines, component, {
+            detail: "imports",
+            prefix: components.length === 1 ? "" : `${index + 1}. `,
+            indent: components.length === 1 ? "" : "   "
+        });
+    });
+}
+function formatPostMutationCycleSummary(count, components) {
+    const kinds = components.map((component) => readString(component.kind) ?? "mixed");
+    const uniqueKinds = Array.from(new Set(kinds));
+    const kindText = uniqueKinds.length === 1 ? `${uniqueKinds[0]} ` : "";
+    return `${count} new/changed ${kindText}${count === 1 ? "cycle" : "cycles"} involving touched files`;
+}
+function plural(count, one, many) {
+    return count === 1 ? one : many;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        return !(Array.isArray(value) && value.length === 0);
+    }));
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeKey(filePath) {
+    const normalized = path.normalize(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+async function maybeDelayPostMutationCycles(delayMs) {
+    if (delayMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function formatRelativePath(cwd, filePath) {
+    if (!filePath) {
+        return "";
+    }
+    return path.relative(cwd, filePath).replace(/\\/g, "/");
+}