@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/commands/mutate-command.js

@@ -0,0 +1,1394 @@
+"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.formatMutateResponseForReplay = exports.readCachedMutateExecution = void 0;
+exports.runMutateCommand = runMutateCommand;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const agent_dx_1 = require("../agent-dx/agent-dx");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const mutate_dsl_1 = require("../dsl/mutate-dsl");
+const central_metrics_1 = require("../metrics/central-metrics");
+const mutate_domain_adapters_1 = require("./mutate-domain-adapters");
+const mutate_execution_cache_1 = require("./mutate-execution-cache");
+const mutate_preview_cache_1 = require("./mutate-preview-cache");
+const mutation_execution_cache_1 = require("./mutation-execution-cache");
+const mutation_estimate_1 = require("../mutation/mutation-estimate");
+const mutate_output_values_1 = require("./mutate-output-values");
+const mutate_child_execution_1 = require("./mutate-child-execution");
+const mutate_execution_status_1 = require("./mutate-execution-status");
+var mutate_execution_status_2 = require("./mutate-execution-status");
+Object.defineProperty(exports, "readCachedMutateExecution", { enumerable: true, get: function () { return mutate_execution_status_2.readCachedMutateExecution; } });
+const mutate_result_projection_1 = require("./mutate-result-projection");
+const mutate_failure_output_1 = require("./mutate-failure-output");
+const mutate_file_view_1 = require("./mutate-file-view");
+const exports_star_command_1 = require("./exports-star-command");
+const mutate_aggregate_output_1 = require("./mutate-aggregate-output");
+const mutate_response_replay_1 = require("./mutate-response-replay");
+var mutate_response_replay_2 = require("./mutate-response-replay");
+Object.defineProperty(exports, "formatMutateResponseForReplay", { enumerable: true, get: function () { return mutate_response_replay_2.formatMutateResponseForReplay; } });
+async function runMutateCommand(cwd, restArgs, rawPayload, options = {}, commandOptions = {}) {
+    const [action = "preview", ...actionArgs] = restArgs;
+    if (action === "help" || action === "--help") {
+        return mutateHelp();
+    }
+    if (action === "apply") {
+        const previewId = actionArgs[0];
+        if (!previewId || previewId.startsWith("--")) {
+            throw new errors_1.CliError("MUTATE_PREVIEW_ID_REQUIRED", "mutate apply expects a preview id.", {
+                usage: "aib mutate apply <previewId>"
+            });
+        }
+        return applyMutatePreview(cwd, previewId, options);
+    }
+    if (action !== "preview" && action !== "execute") {
+        throw new errors_1.CliError("UNKNOWN_MUTATE_COMMAND", `Unknown mutate command: ${action}`, {
+            availableCommands: ["preview", "apply", "execute", "help"]
+        });
+    }
+    const payload = normalizeMutatePayload(rawPayload);
+    const plan = (0, mutate_execution_status_1.buildMutatePlan)(cwd, `mutate.${action}`, payload.segments);
+    if (action === "preview") {
+        return previewMutate(cwd, payload, plan, options, commandOptions.semanticContextPool);
+    }
+    const preflightFailure = validateMutateIntentBeforeExecution(cwd, payload.segments, "mutate.execute");
+    if (preflightFailure) {
+        return withMutateMetricsAndText(cwd, preflightFailure, (0, mutate_aggregate_output_1.formatMutateFileLayoutValidationText)(cwd, preflightFailure));
+    }
+    if ((0, mutate_domain_adapters_1.isSingleModulePlanPayload)(payload)) {
+        return (0, mutate_domain_adapters_1.executeSingleModulePlanMutate)(cwd, payload.segments[0], options);
+    }
+    if ((0, mutate_domain_adapters_1.isSingleFilePayload)(payload)) {
+        return (0, mutate_domain_adapters_1.executeSingleFileMutate)(cwd, payload.segments[0], options);
+    }
+    return executeMutateWithStatus(cwd, payload.segments, plan, options);
+}
+async function previewMutate(cwd, payload, plan, options, semanticContextPool) {
+    const preflightFailure = validateMutateIntentBeforeExecution(cwd, payload.segments, "mutate.preview");
+    if (preflightFailure) {
+        const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, preflightFailure, payload.agentDxSignals);
+        return withText(withDx, (0, mutate_aggregate_output_1.formatMutateFileLayoutValidationText)(cwd, withDx));
+    }
+    if (payload.segments.length > 0 && payload.segments.every((segment) => segment.kind === "exports.star")) {
+        return previewExportsStarMutateBatch(cwd, payload, plan, semanticContextPool);
+    }
+    const childSegments = [];
+    const responses = [];
+    let sawDeclarationRemove = false;
+    for (const segment of payload.segments) {
+        if (segment.kind === "imports.normalize" || segment.kind === "imports.rebase" || segment.kind === "declaration" || segment.kind === "exports.object" || segment.kind === "exports.star") {
+            const preparedSegment = prepareDeclarationPreviewSegment(segment, sawDeclarationRemove);
+            const response = await (0, mutate_domain_adapters_1.runMutateSegment)(cwd, preparedSegment, "preview", options);
+            responses.push(response);
+            if (isDeclarationRemoveSegment(segment)) {
+                sawDeclarationRemove = true;
+            }
+            if (response.ok === false && !shouldContinueAfterMutateSegmentFailure(segment, response, createDeclarationCleanupState(payload.segments))) {
+                const summary = (0, mutate_result_projection_1.summarizeSegments)(payload.segments, responses, childSegments, responses.length - 1);
+                const failure = (0, mutate_output_values_1.compactObject)({
+                    ok: false,
+                    operation: "mutate.preview",
+                    failedSegment: responses.length,
+                    segments: summary,
+                    aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+                    filesWritten: [],
+                    filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+                    response,
+                    next: "Fix failed group and rerun mutate preview."
+                });
+                const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, failure, payload.agentDxSignals);
+                if (segment.kind === "exports.object") {
+                    return withText(withDx, (0, mutate_failure_output_1.formatObjectPackFailureAsMutatePreviewText)(response));
+                }
+                return withText(withDx, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, withDx));
+            }
+            const childId = shouldPersistChildPreviewId(preparedSegment) ? readChildPreviewId(segment, response) : null;
+            childSegments.push({
+                kind: String(segment.kind),
+                childId: childId ?? "",
+                response
+            });
+        }
+        else {
+            responses.push(buildCheapMutatePreviewResponse(cwd, segment));
+        }
+    }
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(payload.segments, responses, childSegments);
+    const aggregate = (0, mutate_result_projection_1.buildMutateAggregateModel)(summary);
+    if (isNoopImportsNormalizePreview(payload.segments, aggregate)) {
+        const noPolicy = hasNoPolicyImportsNormalize(aggregate);
+        const response = {
+            operation: "mutate.preview",
+            summary: noPolicy ? "no import normalization policy matched" : "no import normalization changes planned",
+            segments: summary,
+            aggregate,
+            next: noPolicy
+                ? "Add importNormalize config for this scope or rerun with an explicit to= target."
+                : "No action needed unless the scope or target style is wrong."
+        };
+        const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, (0, mutate_file_view_1.attachMutateAggregateFilesView)(cwd, response), payload.agentDxSignals);
+        return withText(withDx, (0, mutate_response_replay_1.formatMutatePreviewAggregateText)(cwd, withDx));
+    }
+    if (isNoopImportsRebasePreview(payload.segments, aggregate)) {
+        const skipped = countImportRebaseSkipped(aggregate);
+        const response = {
+            operation: "mutate.preview",
+            summary: skipped > 0 ? `no import boundary changes planned; ${skipped} skipped` : "no import boundary changes planned",
+            segments: summary,
+            aggregate,
+            next: skipped > 0
+                ? "Review skipped imports; adjust scope/barrel/symbols and rerun if needed."
+                : "No action needed unless the scope/barrel/symbols are wrong."
+        };
+        const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, (0, mutate_file_view_1.attachMutateAggregateFilesView)(cwd, response), payload.agentDxSignals);
+        return withText(withDx, (0, mutate_response_replay_1.formatMutatePreviewAggregateText)(cwd, withDx));
+    }
+    if (payload.segments.length === 1 && payload.segments[0]?.kind === "exports.object" && responses[0]?.applyAvailable === false) {
+        const response = {
+            ok: true,
+            operation: "mutate.preview",
+            summary: "object.unpack semantic preview ready; apply/execute disabled",
+            segments: summary,
+            aggregate,
+            filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+            filesWritten: [],
+            next: "Review object.unpack view evidence; apply/execute is not available yet."
+        };
+        const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, (0, mutate_file_view_1.attachMutateAggregateFilesView)(cwd, response), payload.agentDxSignals);
+        return withText(withDx, (0, mutate_domain_adapters_1.formatTransparentMutateText)(cwd, "preview", undefined, payload.segments, responses, childSegments) ?? (0, mutate_response_replay_1.formatMutatePreviewAggregateText)(cwd, withDx));
+    }
+    const previewId = (0, mutate_preview_cache_1.buildMutatePreviewId)(payload);
+    const previewHash = (0, mutate_preview_cache_1.buildMutatePreviewHash)(payload, childSegments);
+    (0, mutate_preview_cache_1.writeMutatePreviewRecord)(cwd, {
+        previewId,
+        previewHash,
+        createdAt: new Date().toISOString(),
+        cwd,
+        normalizedPayload: payload,
+        plan,
+        segments: childSegments
+    });
+    const response = {
+        operation: "mutate.preview",
+        previewId,
+        summary: `${payload.segments.length} ${payload.segments.length === 1 ? "segment" : "segments"} ready`,
+        segments: summary,
+        aggregate,
+        next: `aib mutate apply ${previewId}`
+    };
+    const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, (0, mutate_file_view_1.attachMutateAggregateFilesView)(cwd, response), payload.agentDxSignals);
+    return withText(withDx, (0, mutate_domain_adapters_1.formatTransparentMutateText)(cwd, "preview", previewId, payload.segments, responses, childSegments) ?? (0, mutate_response_replay_1.formatMutatePreviewAggregateText)(cwd, withDx));
+}
+async function previewExportsStarMutateBatch(cwd, payload, _plan, semanticContextPool) {
+    const responses = await (0, mutate_domain_adapters_1.runExportsStarMutatePreviewBatch)(cwd, payload.segments, semanticContextPool);
+    const previewId = responses.map((response) => (0, mutate_output_values_1.readString)(response.previewId)).find((value) => Boolean(value));
+    const childSegments = payload.segments.map((segment, index) => ({
+        kind: String(segment.kind),
+        childId: previewId ?? "",
+        response: responses[index]
+    }));
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(payload.segments, responses, childSegments);
+    const aggregate = (0, mutate_result_projection_1.buildMutateAggregateModel)(summary);
+    if (previewId) {
+        (0, mutate_preview_cache_1.writeMutatePreviewRecord)(cwd, {
+            previewId,
+            previewHash: (0, mutate_preview_cache_1.buildMutatePreviewHash)(payload, childSegments),
+            createdAt: new Date().toISOString(),
+            cwd,
+            normalizedPayload: payload,
+            segments: childSegments
+        });
+    }
+    const response = {
+        ok: true,
+        operation: "mutate.preview",
+        applyAvailable: Boolean(previewId),
+        ...(previewId ? { previewId } : {}),
+        summary: payload.segments.every((segment) => segment.operation === "collapse")
+            ? previewId ? "exports.star.collapse semantic preview ready" : "exports.star.collapse review evidence ready; no safe edits"
+            : previewId ? "exports.star.expand semantic preview ready"
+                : "exports.star.expand review evidence ready; no safe edits",
+        segments: summary,
+        aggregate,
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+        filesWritten: [],
+        next: previewId ? `aib mutate apply ${previewId}` : payload.segments.every((segment) => segment.operation === "collapse")
+            ? "Review exports.star.collapse view evidence; apply/execute is not available yet."
+            : "Review retained exports.star.expand evidence; no safe edits are available to apply."
+    };
+    const withDx = (0, agent_dx_1.applyAgentDxSignals)(cwd, response, payload.agentDxSignals);
+    return withText(withDx, (0, mutate_domain_adapters_1.formatTransparentMutateText)(cwd, "preview", undefined, payload.segments, responses, childSegments) ?? (0, mutate_response_replay_1.formatMutatePreviewAggregateText)(cwd, withDx));
+}
+function isNoopImportsNormalizePreview(segments, aggregate) {
+    if (segments.length === 0 || !segments.every((segment) => segment.kind === "imports.normalize")) {
+        return false;
+    }
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    const normalizations = (0, mutate_output_values_1.readObjectArray)(operations.importNormalizations);
+    return normalizations.length > 0 && normalizations.every((item) => ((0, mutate_output_values_1.readNumber)(item.edits) ?? 0) === 0);
+}
+function hasNoPolicyImportsNormalize(aggregate) {
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    return (0, mutate_output_values_1.readObjectArray)(operations.importNormalizations).some((item) => item.noPolicy === true);
+}
+function isNoopImportsRebasePreview(segments, aggregate) {
+    if (segments.length === 0 || !segments.every((segment) => segment.kind === "imports.rebase")) {
+        return false;
+    }
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    const importRebases = (0, mutate_output_values_1.readObjectArray)(operations.importRebases);
+    return importRebases.length > 0 && importRebases.every((item) => ((0, mutate_output_values_1.readNumber)(item.edits) ?? 0) === 0 && ((0, mutate_output_values_1.readNumber)(item.filesChanged) ?? 0) === 0);
+}
+function countImportRebaseSkipped(aggregate) {
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    return (0, mutate_output_values_1.readObjectArray)(operations.importRebases)
+        .reduce((count, item) => count + ((0, mutate_output_values_1.readNumber)(item.skippedCount) ?? 0), 0);
+}
+async function applyMutatePreview(cwd, previewId, options) {
+    const record = (0, mutate_preview_cache_1.readMutatePreviewRecord)(cwd, previewId);
+    if (record.segments.length > 0 && record.segments.every((segment) => segment.kind === "exports.star" && segment.childId === previewId)) {
+        return applyMutateSegmentAsResponse(cwd, record.segments[0], options);
+    }
+    if (record.segments.length === 1 && record.segments[0]?.kind === "modulePlan") {
+        return (0, mutate_domain_adapters_1.applySingleModulePlanMutate)(cwd, previewId, record.segments[0], options);
+    }
+    if (record.segments.length === 1 && record.segments[0]?.kind === "file") {
+        return (0, mutate_domain_adapters_1.applySingleFileMutate)(cwd, previewId, record.segments[0], options);
+    }
+    const intentSegments = readMutateRecordIntentSegments(record);
+    const plan = (0, mutate_output_values_1.isObject)(record.plan)
+        ? record.plan
+        : (0, mutate_execution_status_1.buildMutatePlan)(cwd, "mutate.apply", intentSegments);
+    const preflightFailure = validateMutateIntentBeforeExecution(cwd, intentSegments, "mutate.apply", previewId);
+    if (preflightFailure) {
+        return withMutateMetricsAndText(cwd, preflightFailure, (0, mutate_aggregate_output_1.formatMutateFileLayoutValidationText)(cwd, preflightFailure));
+    }
+    const syncWaitMs = (0, mutate_execution_status_1.readMutateSyncWaitMs)();
+    if (syncWaitMs > 0) {
+        return applyMutatePreviewWithStatus(cwd, previewId, intentSegments, record.segments, plan, options, syncWaitMs);
+    }
+    const responses = [];
+    const successfulRemoveSelectors = createDeclarationCleanupState(intentSegments);
+    for (const [index, segment] of intentSegments.entries()) {
+        const previewSegment = record.segments[index];
+        const preparedSegment = prepareDeclarationExecutionSegment(segment, successfulRemoveSelectors);
+        const initialResponse = previewSegment && previewSegment.kind === segment.kind && previewSegment.childId
+            ? await applyMutateSegmentAsResponse(cwd, previewSegment, options)
+            : await runMutateSegmentAsResponse(cwd, preparedSegment, "execute", options);
+        const response = await (0, mutate_child_execution_1.awaitNestedFileMutationResponse)(cwd, initialResponse);
+        responses.push(response);
+        updateSuccessfulDeclarationRemoveSelectors(successfulRemoveSelectors, segment, response);
+        if (response.ok === false && !shouldContinueAfterMutateSegmentFailure(segment, response, successfulRemoveSelectors)) {
+            const summary = (0, mutate_result_projection_1.summarizeSegments)(intentSegments, responses, record.segments, index);
+            const failure = {
+                ok: false,
+                operation: "mutate.apply",
+                previewId,
+                failedSegment: index + 1,
+                segments: summary,
+                aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+                filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+                filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+                response,
+                next: "Fix failed group and rerun remaining mutate intent."
+            };
+            return withMutateMetricsAndText(cwd, failure, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, failure));
+        }
+    }
+    const manualExtractionIndex = findFirstNonBlockingManualExtractionFailure(intentSegments, responses);
+    if (manualExtractionIndex >= 0) {
+        return buildMutateManualExtractionAggregateResponse(cwd, "mutate.apply", intentSegments, responses, record.segments, manualExtractionIndex, previewId);
+    }
+    const partialDeclarationIndex = findFirstPartialDeclarationCleanupFailure(intentSegments, responses);
+    if (partialDeclarationIndex >= 0) {
+        return buildMutatePartialDeclarationCleanupAggregateResponse(cwd, "mutate.apply", intentSegments, responses, record.segments, previewId);
+    }
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(intentSegments, responses, record.segments);
+    const response = {
+        operation: "mutate.apply",
+        previewId,
+        summary: `${responses.length} ${responses.length === 1 ? "segment" : "segments"} applied`,
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses)
+    };
+    return withMutateMetricsAndText(cwd, response, (0, mutate_domain_adapters_1.formatTransparentAppliedMutateText)(cwd, "apply", previewId, record.segments, responses) ?? (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+async function applyMutatePreviewWithStatus(cwd, previewId, intentSegments, previewSegments, plan, options, syncWaitMs) {
+    const executionId = (0, mutate_execution_cache_1.buildMutateExecutionId)();
+    const status = (0, mutate_execution_cache_1.createMutateExecutionStatus)(cwd, executionId, "mutate.apply", (0, mutate_execution_status_1.buildApplyExecutionGroups)(intentSegments, previewSegments, plan), (0, mutate_execution_status_1.selectMutatePollingPolicy)(intentSegments));
+    status.plan = plan;
+    status.estimatedDurationMs = (0, mutation_estimate_1.estimateMutationPlanDurationMs)(plan);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+    const startedAtMs = Date.now();
+    const jobPromise = (0, mutate_execution_status_1.startMutateBackgroundJob)(async () => {
+        try {
+            await (0, mutate_execution_status_1.maybeDeferMutateBackgroundWorkForStatus)(syncWaitMs, intentSegments);
+            const result = await applyMutatePreviewRows(cwd, previewId, intentSegments, previewSegments, options, status);
+            status.status = result.ok === false ? "failed" : "completed";
+            status.phase = "completed";
+            status.result = result;
+            (0, mutate_execution_status_1.mergeMutateStatusFiles)(status, result);
+            if (result.ok === false) {
+                status.error = (0, mutate_output_values_1.readString)(result.code) ?? "MUTATE_APPLY_FAILED";
+            }
+            else {
+                delete status.error;
+            }
+            (0, mutate_execution_status_1.finalizeMutateStatusRows)(status);
+            (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+            return result;
+        }
+        catch (error) {
+            status.status = "failed";
+            status.phase = "completed";
+            status.error = error instanceof Error ? error.message : String(error);
+            (0, mutate_execution_status_1.finalizeMutateStatusRows)(status);
+            (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+            throw error;
+        }
+    });
+    const waitResult = await (0, mutation_execution_cache_1.waitForMutationDeadline)(jobPromise, syncWaitMs);
+    if (waitResult.status === "result") {
+        return waitResult.result;
+    }
+    jobPromise.catch(() => undefined);
+    return (0, mutate_execution_status_1.buildMutateStillRunningResponse)(cwd, executionId, "mutate.apply", (0, mutate_execution_status_1.estimateMutateDurationMs)(status), Date.now() - startedAtMs, syncWaitMs);
+}
+async function applyMutatePreviewRows(cwd, previewId, intentSegments, previewSegments, options, status) {
+    const responses = [];
+    const successfulRemoveSelectors = createDeclarationCleanupState(intentSegments);
+    for (const [index, segment] of intentSegments.entries()) {
+        (0, mutate_execution_status_1.markMutateGroupRunning)(cwd, status, index);
+        const previewSegment = previewSegments[index];
+        const preparedSegment = prepareDeclarationExecutionSegment(segment, successfulRemoveSelectors);
+        const initialResponse = previewSegment && previewSegment.kind === segment.kind && previewSegment.childId
+            ? await applyMutateSegmentAsResponse(cwd, previewSegment, withMutateSemanticRenameEvidence(options, cwd, status, index))
+            : await runMutateSegmentAsResponse(cwd, preparedSegment, "execute", withMutateSemanticRenameEvidence(options, cwd, status, index));
+        const response = await (0, mutate_child_execution_1.awaitNestedFileMutationResponse)(cwd, initialResponse, {
+            onDelegated: (childExecutionId) => (0, mutate_execution_status_1.markMutateGroupDelegated)(cwd, status, index, childExecutionId)
+        });
+        responses.push(response);
+        updateSuccessfulDeclarationRemoveSelectors(successfulRemoveSelectors, segment, response);
+        (0, mutate_execution_status_1.markMutateGroupFinished)(cwd, status, index, response);
+        if (response.ok === false && !shouldContinueAfterMutateSegmentFailure(segment, response, successfulRemoveSelectors)) {
+            (0, mutate_execution_status_1.markMutateGroupsNotRun)(cwd, status, index + 1);
+            const summary = (0, mutate_result_projection_1.summarizeSegments)(intentSegments, responses, previewSegments, index);
+            const failure = {
+                ok: false,
+                operation: "mutate.apply",
+                previewId,
+                failedSegment: index + 1,
+                segments: summary,
+                aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+                filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+                filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+                response,
+                next: "Fix failed group and rerun remaining mutate intent."
+            };
+            return withMutateMetricsAndText(cwd, failure, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, failure));
+        }
+    }
+    const manualExtractionIndex = findFirstNonBlockingManualExtractionFailure(intentSegments, responses);
+    if (manualExtractionIndex >= 0) {
+        return buildMutateManualExtractionAggregateResponse(cwd, "mutate.apply", intentSegments, responses, previewSegments, manualExtractionIndex, previewId);
+    }
+    const partialDeclarationIndex = findFirstPartialDeclarationCleanupFailure(intentSegments, responses);
+    if (partialDeclarationIndex >= 0) {
+        return buildMutatePartialDeclarationCleanupAggregateResponse(cwd, "mutate.apply", intentSegments, responses, previewSegments, previewId);
+    }
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(intentSegments, responses, previewSegments);
+    const response = {
+        operation: "mutate.apply",
+        previewId,
+        summary: `${responses.length} ${responses.length === 1 ? "segment" : "segments"} applied`,
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses)
+    };
+    return withMutateMetricsAndText(cwd, response, (0, mutate_domain_adapters_1.formatTransparentAppliedMutateText)(cwd, "apply", previewId, previewSegments, responses) ?? (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+function readMutateRecordIntentSegments(record) {
+    const segments = (0, mutate_output_values_1.isObject)(record.normalizedPayload) && Array.isArray(record.normalizedPayload.segments)
+        ? record.normalizedPayload.segments.filter(mutate_output_values_1.isObject)
+        : [];
+    if (segments.length > 0) {
+        return segments;
+    }
+    return record.segments.map((segment) => ({
+        kind: segment.kind
+    }));
+}
+async function executeMutateSegments(cwd, segments, action, options) {
+    const responses = [];
+    const successfulRemoveSelectors = createDeclarationCleanupState(segments);
+    for (const [index, segment] of segments.entries()) {
+        const preparedSegment = prepareDeclarationExecutionSegment(segment, successfulRemoveSelectors);
+        const initialResponse = await runMutateSegmentAsResponse(cwd, preparedSegment, action, options);
+        const response = await (0, mutate_child_execution_1.awaitNestedFileMutationResponse)(cwd, initialResponse);
+        responses.push(response);
+        updateSuccessfulDeclarationRemoveSelectors(successfulRemoveSelectors, segment, response);
+        if (response.ok === false && !shouldContinueAfterMutateSegmentFailure(segment, response, successfulRemoveSelectors)) {
+            const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, responses, [], index);
+            const failure = {
+                ok: false,
+                operation: "mutate.execute",
+                failedSegment: index + 1,
+                segments: summary,
+                aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+                filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+                filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+                response,
+                next: "Fix failed group and rerun remaining mutate intent."
+            };
+            return withMutateMetricsAndText(cwd, failure, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, failure));
+        }
+    }
+    const manualExtractionIndex = findFirstNonBlockingManualExtractionFailure(segments, responses);
+    if (manualExtractionIndex >= 0) {
+        return buildMutateManualExtractionAggregateResponse(cwd, "mutate.execute", segments, responses, [], manualExtractionIndex);
+    }
+    const partialDeclarationIndex = findFirstPartialDeclarationCleanupFailure(segments, responses);
+    if (partialDeclarationIndex >= 0) {
+        return buildMutatePartialDeclarationCleanupAggregateResponse(cwd, "mutate.execute", segments, responses, []);
+    }
+    const presentedResponses = segments.length > 0 && segments.every((segment) => segment.kind === "exports.star")
+        ? (0, exports_star_command_1.consolidateExportsStarWriteViews)(cwd, responses)
+        : responses;
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, presentedResponses);
+    const response = {
+        operation: "mutate.execute",
+        summary: `${responses.length} ${responses.length === 1 ? "segment" : "segments"} executed`,
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses)
+    };
+    return withMutateMetricsAndText(cwd, response, (0, mutate_domain_adapters_1.formatTransparentMutateText)(cwd, "execute", undefined, segments, presentedResponses) ?? (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+async function executeMutateWithStatus(cwd, segments, plan, options) {
+    const syncWaitMs = (0, mutate_execution_status_1.readMutateSyncWaitMs)();
+    if (syncWaitMs <= 0) {
+        return executeMutateSegments(cwd, segments, "execute", options);
+    }
+    const executionId = (0, mutate_execution_cache_1.buildMutateExecutionId)();
+    const status = (0, mutate_execution_cache_1.createMutateExecutionStatus)(cwd, executionId, "mutate.execute", (0, mutate_execution_status_1.buildExecuteExecutionGroups)(segments, plan), (0, mutate_execution_status_1.selectMutatePollingPolicy)(segments));
+    status.plan = plan;
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+    const startedAtMs = Date.now();
+    const jobPromise = (0, mutate_execution_status_1.startMutateBackgroundJob)(async () => {
+        try {
+            await (0, mutate_execution_status_1.maybeDeferMutateBackgroundWorkForStatus)(syncWaitMs, segments);
+            const result = await executeMutateSegmentsWithStatus(cwd, segments, options, status);
+            status.status = result.ok === false ? "failed" : "completed";
+            status.phase = "completed";
+            status.result = result;
+            (0, mutate_execution_status_1.mergeMutateStatusFiles)(status, result);
+            if (result.ok === false) {
+                status.error = (0, mutate_output_values_1.readString)(result.code) ?? "MUTATE_EXECUTE_FAILED";
+            }
+            else {
+                delete status.error;
+            }
+            (0, mutate_execution_status_1.finalizeMutateStatusRows)(status);
+            (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+            return result;
+        }
+        catch (error) {
+            status.status = "failed";
+            status.phase = "completed";
+            status.error = error instanceof Error ? error.message : String(error);
+            (0, mutate_execution_status_1.finalizeMutateStatusRows)(status);
+            (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+            throw error;
+        }
+    });
+    const waitResult = await (0, mutation_execution_cache_1.waitForMutationDeadline)(jobPromise, syncWaitMs);
+    if (waitResult.status === "result") {
+        return waitResult.result;
+    }
+    jobPromise.catch(() => undefined);
+    return (0, mutate_execution_status_1.buildMutateStillRunningResponse)(cwd, executionId, "mutate.execute", (0, mutate_execution_status_1.estimateMutateDurationMs)(status), Date.now() - startedAtMs, syncWaitMs);
+}
+async function executeMutateSegmentsWithStatus(cwd, segments, options, status) {
+    await (0, mutate_execution_status_1.maybeDelayMutateForTest)();
+    const responses = [];
+    const successfulRemoveSelectors = createDeclarationCleanupState(segments);
+    for (const [index, segment] of segments.entries()) {
+        (0, mutate_execution_status_1.markMutateGroupRunning)(cwd, status, index);
+        const preparedSegment = prepareDeclarationExecutionSegment(segment, successfulRemoveSelectors);
+        const initialResponse = await runMutateSegmentAsResponse(cwd, preparedSegment, "execute", withMutateSemanticRenameEvidence(options, cwd, status, index));
+        const response = await (0, mutate_child_execution_1.awaitNestedFileMutationResponse)(cwd, initialResponse, {
+            onDelegated: (childExecutionId) => (0, mutate_execution_status_1.markMutateGroupDelegated)(cwd, status, index, childExecutionId)
+        });
+        responses.push(response);
+        updateSuccessfulDeclarationRemoveSelectors(successfulRemoveSelectors, segment, response);
+        (0, mutate_execution_status_1.markMutateGroupFinished)(cwd, status, index, response);
+        if (response.ok === false && !shouldContinueAfterMutateSegmentFailure(segment, response, successfulRemoveSelectors)) {
+            (0, mutate_execution_status_1.markMutateGroupsNotRun)(cwd, status, index + 1);
+            const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, responses, [], index);
+            const failure = {
+                ok: false,
+                operation: "mutate.execute",
+                failedSegment: index + 1,
+                segments: summary,
+                aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+                filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+                filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+                response,
+                next: "Fix failed group and rerun remaining mutate intent."
+            };
+            return withMutateMetricsAndText(cwd, failure, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, failure));
+        }
+    }
+    const manualExtractionIndex = findFirstNonBlockingManualExtractionFailure(segments, responses);
+    if (manualExtractionIndex >= 0) {
+        return buildMutateManualExtractionAggregateResponse(cwd, "mutate.execute", segments, responses, [], manualExtractionIndex);
+    }
+    const partialDeclarationIndex = findFirstPartialDeclarationCleanupFailure(segments, responses);
+    if (partialDeclarationIndex >= 0) {
+        return buildMutatePartialDeclarationCleanupAggregateResponse(cwd, "mutate.execute", segments, responses, []);
+    }
+    const presentedResponses = segments.length > 0 && segments.every((segment) => segment.kind === "exports.star")
+        ? (0, exports_star_command_1.consolidateExportsStarWriteViews)(cwd, responses)
+        : responses;
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, presentedResponses);
+    const response = {
+        operation: "mutate.execute",
+        summary: `${responses.length} ${responses.length === 1 ? "segment" : "segments"} executed`,
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses)
+    };
+    return withMutateMetricsAndText(cwd, response, (0, mutate_domain_adapters_1.formatTransparentMutateText)(cwd, "execute", undefined, segments, presentedResponses) ?? (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+function withMutateSemanticRenameEvidence(options, cwd, status, index) {
+    if (!status) {
+        return options;
+    }
+    return {
+        ...options,
+        semanticRenameExecutionEvidence: {
+            beforeApply(writeSet) {
+                options.semanticRenameExecutionEvidence?.beforeApply(writeSet);
+                (0, mutate_execution_status_1.markMutateGroupApplying)(cwd, status, index, writeSet);
+            },
+            afterProgress(progress) {
+                options.semanticRenameExecutionEvidence?.afterProgress?.(progress);
+                (0, mutate_execution_status_1.markMutateGroupSemanticProgress)(cwd, status, index, progress);
+            }
+        },
+        semanticMoveExecutionEvidence: {
+            beforeApply(writeSet) {
+                options.semanticMoveExecutionEvidence?.beforeApply(writeSet);
+                (0, mutate_execution_status_1.markMutateGroupApplying)(cwd, status, index, writeSet);
+            },
+            afterProgress(progress) {
+                options.semanticMoveExecutionEvidence?.afterProgress?.(progress);
+                (0, mutate_execution_status_1.markMutateGroupSemanticProgress)(cwd, status, index, progress);
+            },
+            afterRoute(route) {
+                options.semanticMoveExecutionEvidence?.afterRoute?.(route);
+            }
+        }
+    };
+}
+async function runMutateSegmentAsResponse(cwd, segment, action, options) {
+    try {
+        return await (0, mutate_domain_adapters_1.runMutateSegment)(cwd, segment, action, options);
+    }
+    catch (error) {
+        return errorToMutateSegmentResponse(error);
+    }
+}
+async function applyMutateSegmentAsResponse(cwd, segment, options) {
+    try {
+        return await (0, mutate_domain_adapters_1.applyMutateSegment)(cwd, segment, options);
+    }
+    catch (error) {
+        return errorToMutateSegmentResponse(error);
+    }
+}
+function findFirstNonBlockingManualExtractionFailure(segments, responses) {
+    return responses.findIndex((response, index) => response.ok === false &&
+        isNonBlockingManualExtractionFailure(segments[index] ?? {}, response));
+}
+function isNonBlockingManualExtractionFailure(segment, response) {
+    const kind = (0, mutate_output_values_1.readString)(segment.kind);
+    if (kind !== "semantic" && kind !== "modulePlan") {
+        return false;
+    }
+    return shouldContinueAfterMutateSegmentFailure(segment, response);
+}
+function findFirstPartialDeclarationCleanupFailure(segments, responses) {
+    let sawSuccessfulRemove = false;
+    let firstDeclarationRemoveNotFound = -1;
+    for (const [index, response] of responses.entries()) {
+        const segment = segments[index] ?? {};
+        if (isDeclarationRemoveSegment(segment) && readPositiveSelectorKeys(response.removed).length > 0) {
+            sawSuccessfulRemove = true;
+        }
+        if (firstDeclarationRemoveNotFound < 0 &&
+            isDeclarationRemoveSegment(segment) &&
+            (0, mutate_output_values_1.readString)(response.code) === "DECLARATION_REMOVE_NOT_FOUND") {
+            firstDeclarationRemoveNotFound = index;
+        }
+        if (response.ok !== false) {
+            continue;
+        }
+        if (isPartialDeclarationCleanupResponse(segment, response)) {
+            return index;
+        }
+        if (sawSuccessfulRemove && isDeclarationAddMissingSegment(segment) && hasDeclarationSourceOrSkippedIssue(response)) {
+            return index;
+        }
+    }
+    if (firstDeclarationRemoveNotFound >= 0 &&
+        responses.some((response) => ((0, mutate_output_values_1.readNumber)(response.declarationsRemoved) ?? 0) > 0 || ((0, mutate_output_values_1.readNumber)(response.importsAdded) ?? 0) > 0)) {
+        return firstDeclarationRemoveNotFound;
+    }
+    return -1;
+}
+function shouldContinueAfterMutateSegmentFailure(segment, response, declarationCleanupState) {
+    if (response.ok !== false) {
+        return false;
+    }
+    const kind = (0, mutate_output_values_1.readString)(segment.kind);
+    if (kind === "semantic") {
+        const failedRows = (0, mutate_execution_status_1.readResponseRows)(response).filter((row) => row.ok === false);
+        return failedRows.length > 0 && failedRows.every(mutate_output_values_1.isSemanticManualExtractionRow);
+    }
+    if (kind === "modulePlan") {
+        const failedRows = (0, mutate_execution_status_1.readResponseRows)(response).filter((row) => row.ok === false);
+        if (failedRows.length === 0 || (0, mutate_output_values_1.readObjectArray)(response.notRun).length > 0) {
+            return false;
+        }
+        return failedRows.every((row) => (0, mutate_output_values_1.readNestedManualExtractionEntities)(row).length > 0);
+    }
+    if (kind === "declaration") {
+        if (isDeclarationRemoveSegment(segment) &&
+            declarationCleanupState?.enabled === true &&
+            (0, mutate_output_values_1.readString)(response.code) === "DECLARATION_REMOVE_NOT_FOUND") {
+            return true;
+        }
+        if (isDeclarationAddMissingSegment(segment) &&
+            declarationCleanupState?.enabled === true &&
+            hasDeclarationSourceOrSkippedIssue(response)) {
+            return true;
+        }
+        return isPartialDeclarationCleanupResponse(segment, response);
+    }
+    return false;
+}
+function isPartialDeclarationCleanupResponse(segment, response) {
+    if (segment.kind !== "declaration" || response.ok !== false) {
+        return false;
+    }
+    if ((0, mutate_output_values_1.readString)(response.code) === "DECLARATION_REMOVE_NOT_FOUND") {
+        return false;
+    }
+    const declarationsRemoved = (0, mutate_output_values_1.readNumber)(response.declarationsRemoved) ?? 0;
+    const importsAdded = (0, mutate_output_values_1.readNumber)(response.importsAdded) ?? 0;
+    return declarationsRemoved > 0 || importsAdded > 0;
+}
+function hasDeclarationSourceOrSkippedIssue(response) {
+    return ((0, mutate_output_values_1.readNumber)(response.sourceFailureCount) ?? 0) > 0 || ((0, mutate_output_values_1.readNumber)(response.skippedCount) ?? 0) > 0;
+}
+function createDeclarationCleanupState(segments) {
+    const removeSegments = segments.filter(isDeclarationRemoveSegment);
+    const hasAddMissing = segments.some(isDeclarationAddMissingSegment);
+    return removeSegments.length > 0 && hasAddMissing
+        ? { enabled: true }
+        : null;
+}
+function prepareDeclarationPreviewSegment(segment, sawDeclarationRemove) {
+    if (!sawDeclarationRemove || !isDeclarationAddMissingSegment(segment)) {
+        return segment;
+    }
+    const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+    return {
+        ...segment,
+        request: {
+            ...request,
+            sourceCheckOnly: true
+        }
+    };
+}
+function shouldPersistChildPreviewId(segment) {
+    const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+    return request.sourceCheckOnly !== true;
+}
+function prepareDeclarationExecutionSegment(segment, state) {
+    if (!state?.enabled || !isDeclarationAddMissingSegment(segment)) {
+        return segment;
+    }
+    const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+    return {
+        ...segment,
+        request: {
+            ...request,
+            cleanupTail: true
+        }
+    };
+}
+function updateSuccessfulDeclarationRemoveSelectors(state, segment, response) {
+}
+function readPositiveSelectorKeys(value) {
+    if (!(0, mutate_output_values_1.isObject)(value)) {
+        return [];
+    }
+    return Object.entries(value)
+        .filter(([, count]) => typeof count === "number" && count > 0)
+        .map(([selector]) => selector);
+}
+function isDeclarationRemoveSegment(segment) {
+    if (segment.kind !== "declaration" || !(0, mutate_output_values_1.isObject)(segment.request)) {
+        return false;
+    }
+    return (0, mutate_output_values_1.readString)(segment.request.operation) === "remove";
+}
+function isDeclarationAddMissingSegment(segment) {
+    if (segment.kind !== "declaration" || !(0, mutate_output_values_1.isObject)(segment.request)) {
+        return false;
+    }
+    return (0, mutate_output_values_1.readString)(segment.request.operation) === "addMissing";
+}
+function buildMutatePartialDeclarationCleanupAggregateResponse(cwd, operation, segments, responses, previews, previewId) {
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, responses, previews);
+    const hasNotFound = responses.some((response) => ((0, mutate_output_values_1.readNumber)(response.notFoundCount) ?? 0) > 0);
+    const response = (0, mutate_output_values_1.compactObject)({
+        ok: false,
+        operation,
+        ...(previewId ? { previewId } : {}),
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+        partialDeclarationCleanup: true,
+        next: hasNotFound
+            ? "Fix missing selectors and rerun only the remaining declaration cleanup intent."
+            : "Fix failed selectors and rerun only the remaining declaration cleanup intent."
+    });
+    return withMutateMetricsAndText(cwd, response, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+function buildMutateManualExtractionAggregateResponse(cwd, operation, segments, responses, previews, failedIndex, previewId) {
+    const summary = (0, mutate_result_projection_1.summarizeSegments)(segments, responses, previews, failedIndex);
+    const response = (0, mutate_output_values_1.compactObject)({
+        ok: false,
+        operation,
+        ...(previewId ? { previewId } : {}),
+        failedSegment: failedIndex + 1,
+        segments: summary,
+        aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+        filesWritten: (0, mutate_execution_status_1.collectResponsesFilesWritten)(responses),
+        filesTouched: (0, mutate_execution_status_1.collectResponsesFilesTouched)(responses),
+        next: "use manual extraction for listed symbols"
+    });
+    return withMutateMetricsAndText(cwd, response, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, response));
+}
+function errorToMutateSegmentResponse(error) {
+    return (0, errors_1.errorPayload)(error);
+}
+function normalizeMutatePayload(rawPayload) {
+    if (!rawPayload || typeof rawPayload !== "object" || Array.isArray(rawPayload)) {
+        throw new errors_1.CliError("MUTATE_PAYLOAD_REQUIRED", "mutate expects a JSON/DSL payload.");
+    }
+    const payload = rawPayload;
+    const segments = (0, mutate_output_values_1.readObjectArray)(payload.segments);
+    if (segments.length === 0) {
+        throw new errors_1.CliError("MUTATE_SEGMENTS_REQUIRED", "mutate expects at least one segment.");
+    }
+    const hasModulePlan = segments.some((segment) => segment.kind === "modulePlan");
+    const hasImportsNormalize = segments.some((segment) => segment.kind === "imports.normalize");
+    const hasImportsRebase = segments.some((segment) => segment.kind === "imports.rebase");
+    const hasImportsMutation = hasImportsNormalize || hasImportsRebase;
+    const hasDeclaration = segments.some((segment) => segment.kind === "declaration");
+    const hasExportsObject = segments.some((segment) => segment.kind === "exports.object");
+    const hasExportsStar = segments.some((segment) => segment.kind === "exports.star");
+    const hasStandardMutation = segments.some((segment) => segment.kind === "semantic" || segment.kind === "file");
+    const hasOtherMutation = segments.some((segment) => segment.kind !== "modulePlan");
+    if (hasModulePlan && hasOtherMutation) {
+        throw new errors_1.CliError("MUTATE_MODULE_PLAN_MIX_UNSUPPORTED", "modulePlan cannot be mixed with other mutation operations yet.", {
+            next: "Run modulePlan as a separate mutate request, then run the remaining mutations."
+        });
+    }
+    if (hasImportsMutation && segments.length > 1) {
+        throw new errors_1.CliError("MUTATE_IMPORTS_MIX_UNSUPPORTED", "imports mutations cannot be mixed with other mutation operations yet.", {
+            next: "Run imports mutation as a separate mutate request."
+        });
+    }
+    if (hasDeclaration && (hasStandardMutation || hasModulePlan || hasImportsMutation)) {
+        throw new errors_1.CliError("MUTATE_DECLARATION_MIX_UNSUPPORTED", "declaration remove/addMissing cannot be mixed with semantic, file, module, or imports.normalize operations yet.", {
+            next: "Run declaration cleanup as a separate mutate request."
+        });
+    }
+    if (hasExportsObject && segments.length > 1) {
+        throw new errors_1.CliError("MUTATE_OBJECT_PACK_MIX_UNSUPPORTED", "object.pack/object.unpack cannot be mixed with other mutation operations yet.", {
+            next: "Run object.pack or object.unpack as a separate mutate request."
+        });
+    }
+    if (hasExportsStar && segments.some((segment) => segment.kind !== "exports.star")) {
+        throw new errors_1.CliError("MUTATE_EXPORTS_STAR_MIX_UNSUPPORTED", "exports.star mutations cannot be mixed with other mutation operations yet.", { next: "Run exports.star.expand or exports.star.collapse as a separate mutate request." });
+    }
+    if (hasExportsStar && new Set(segments.filter((segment) => segment.kind === "exports.star").map((segment) => segment.operation)).size > 1) {
+        throw new errors_1.CliError("MUTATE_EXPORTS_STAR_OPERATION_MIX_UNSUPPORTED", "exports.star.expand and exports.star.collapse cannot be mixed in one request yet.", { next: "Run expand and collapse as separate mutate requests." });
+    }
+    return {
+        segments,
+        agentDxSignals: collectMutateDslAgentDxSignals(payload[mutate_dsl_1.MUTATE_DSL_AGENT_DX_FIELD])
+    };
+}
+function collectMutateDslAgentDxSignals(value) {
+    const diagnostics = Array.isArray(value) ? value.filter(mutate_output_values_1.isObject) : [];
+    const signals = [];
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.kind !== "unknownOption") {
+            continue;
+        }
+        const command = (0, mutate_output_values_1.readString)(diagnostic.command);
+        const flags = (0, mutate_output_values_1.readStringArray)(diagnostic.options);
+        if (!command || flags.length === 0) {
+            continue;
+        }
+        signals.push({
+            kind: "unknownFlag",
+            command,
+            flags
+        });
+    }
+    return signals;
+}
+function readChildPreviewId(segment, response) {
+    if (typeof response.previewId === "string") {
+        return response.previewId;
+    }
+    if (typeof response.planId === "string") {
+        return response.planId;
+    }
+    if (segment.kind === "modulePlan" && typeof response.planId === "string") {
+        return response.planId;
+    }
+    return null;
+}
+function buildCheapMutatePreviewResponse(cwd, segment) {
+    if (segment.kind === "semantic") {
+        return buildCheapSemanticPreviewResponse(segment);
+    }
+    if (segment.kind === "file") {
+        return buildCheapFilePreviewResponse(segment);
+    }
+    if (segment.kind === "modulePlan") {
+        return buildCheapModulePlanPreviewResponse(cwd, segment);
+    }
+    if (segment.kind === "imports.normalize") {
+        const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+        return {
+            operation: "imports.normalize.preview",
+            summary: "imports normalize request ready",
+            rows: [(0, mutate_output_values_1.compactObject)({
+                    ok: true,
+                    scope: (0, mutate_output_values_1.readString)(request.scope),
+                    target: (0, mutate_output_values_1.readString)(request.to) ?? (0, mutate_output_values_1.readString)(request.mode)
+                })]
+        };
+    }
+    if (segment.kind === "imports.rebase") {
+        const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+        return {
+            operation: `${(0, mutate_output_values_1.readString)(request.operation) ?? "imports.rebase"}.preview`,
+            summary: "imports rebase request ready",
+            rows: [(0, mutate_output_values_1.compactObject)({
+                    ok: true,
+                    barrel: (0, mutate_output_values_1.readString)(request.barrel),
+                    scope: (0, mutate_output_values_1.readString)(request.scope),
+                    files: (0, mutate_output_values_1.readStringArray)(request.files),
+                    symbols: (0, mutate_output_values_1.readStringArray)(request.symbols)
+                })]
+        };
+    }
+    if (segment.kind === "declaration") {
+        const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+        return {
+            operation: "declaration.preview",
+            summary: `${(0, mutate_output_values_1.readString)(request.operation) ?? "declaration"} request ready`,
+            rows: [(0, mutate_output_values_1.compactObject)({
+                    ok: true,
+                    operation: (0, mutate_output_values_1.readString)(request.operation),
+                    scope: (0, mutate_output_values_1.readString)(request.scope),
+                    selectors: (0, mutate_output_values_1.readStringArray)(request.selectors)
+                })]
+        };
+    }
+    if (segment.kind === "exports.object") {
+        const operation = (0, mutate_failure_output_1.readObjectOperationFromPacks)((0, mutate_output_values_1.readObjectArray)(segment.packs));
+        const label = `object.${operation}`;
+        return {
+            operation: `exports.object.${operation}.preview`,
+            summary: `${label} request ready`,
+            rows: (0, mutate_output_values_1.readObjectArray)(segment.packs).map((pack) => (0, mutate_output_values_1.compactObject)({
+                ok: true,
+                sourceFile: (0, mutate_output_values_1.readString)(segment.sourceFile),
+                operation: (0, mutate_output_values_1.readString)(pack.operation) ?? operation,
+                objectName: (0, mutate_output_values_1.readString)(pack.objectName),
+                selectors: (0, mutate_output_values_1.readStringArray)(pack.selectors)
+            }))
+        };
+    }
+    return {
+        ok: false,
+        operation: "mutate.preview",
+        code: "MUTATE_SEGMENT_KIND_UNSUPPORTED",
+        error: `Unsupported mutate segment kind: ${String(segment.kind)}`
+    };
+}
+function buildCheapSemanticPreviewResponse(segment) {
+    const builderRows = (0, mutate_output_values_1.readObjectArray)(segment.requests).map((request, requestIndex) => {
+        const op = (0, mutate_output_values_1.readString)(request.op) ?? "unknown";
+        if (op === "rename") {
+            const renames = readRenameMap(request.renames);
+            return (0, mutate_output_values_1.compactObject)({
+                op,
+                sourceFile: (0, mutate_output_values_1.readString)(request.sourceFile),
+                builtRows: renames.map(([entity, newName], index) => ({
+                    id: `preview-rename-${requestIndex + 1}-${index + 1}`,
+                    entity,
+                    sourceFile: (0, mutate_output_values_1.readString)(request.sourceFile),
+                    newName
+                }))
+            });
+        }
+        const entities = (0, mutate_output_values_1.readStringArray)(request.entities);
+        return (0, mutate_output_values_1.compactObject)({
+            op,
+            sourceFile: (0, mutate_output_values_1.readString)(request.sourceFile),
+            targetFile: (0, mutate_output_values_1.readString)(request.targetFile),
+            entities,
+            builtRows: entities.map((entity, index) => ({
+                id: `preview-move-${requestIndex + 1}-${index + 1}`,
+                entity,
+                sourceFile: (0, mutate_output_values_1.readString)(request.sourceFile),
+                targetFile: (0, mutate_output_values_1.readString)(request.targetFile)
+            }))
+        });
+    });
+    const responseRows = builderRows.flatMap((row) => (0, mutate_output_values_1.readObjectArray)(row.builtRows).map((builtRow) => (0, mutate_output_values_1.compactObject)({
+        id: (0, mutate_output_values_1.readString)(builtRow.id),
+        ok: true,
+        outcome: "planned",
+        entity: (0, mutate_output_values_1.readString)(builtRow.entity),
+        sourceFile: (0, mutate_output_values_1.readString)(builtRow.sourceFile),
+        targetFile: (0, mutate_output_values_1.readString)(builtRow.targetFile),
+        newName: (0, mutate_output_values_1.readString)(builtRow.newName)
+    })));
+    return {
+        operation: "mutate.preview",
+        summary: `${responseRows.length} ${responseRows.length === 1 ? "semantic row" : "semantic rows"} planned`,
+        builder: { rows: builderRows },
+        response: {
+            batchStatus: "planned",
+            rows: responseRows
+        }
+    };
+}
+function buildCheapFilePreviewResponse(segment) {
+    const operations = (0, mutate_output_values_1.readObjectArray)(segment.operations);
+    const moves = groupFileMoveOperations(operations);
+    const renames = operations
+        .filter((operation) => operation.kind === "fileRename")
+        .map((operation) => (0, mutate_output_values_1.compactObject)({
+        source: (0, mutate_output_values_1.readString)(operation.sourceFile),
+        target: (0, mutate_output_values_1.readString)(operation.targetFile)
+    }));
+    const rows = operations.map((operation, index) => (0, mutate_output_values_1.compactObject)({
+        id: (0, mutate_output_values_1.readString)(operation.id) ?? `preview-file-${index + 1}`,
+        ok: true,
+        applied: false,
+        sourceFile: (0, mutate_output_values_1.readString)(operation.sourceFile),
+        targetFile: (0, mutate_output_values_1.readString)(operation.targetFile)
+    }));
+    return (0, mutate_output_values_1.compactObject)({
+        operation: "file.mutation.preview",
+        summary: `${operations.length} ${operations.length === 1 ? "file row" : "file rows"} planned`,
+        operationCount: operations.length,
+        moves,
+        renames,
+        rows
+    });
+}
+function buildCheapModulePlanPreviewResponse(cwd, segment) {
+    const sourceFile = (0, mutate_output_values_1.readString)(segment.sourceFile);
+    const modules = (0, mutate_output_values_1.readObjectArray)(segment.modules);
+    const rows = modules.map((module) => {
+        const target = (0, mutate_output_values_1.readString)(module.targetFile) ?? (0, mutate_output_values_1.readString)(module.target) ?? "";
+        const entities = readModulePlanIntentEntities(module);
+        return (0, mutate_output_values_1.compactObject)({
+            target: (0, mutate_failure_output_1.formatPathForMutateOutput)(cwd, target),
+            entities,
+            ok: true,
+            summary: target && !fs.existsSync((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, target)) ? "target will be created" : "target ready"
+        });
+    });
+    return (0, mutate_output_values_1.compactObject)({
+        operation: "modulePlan.preview",
+        sourceFile,
+        summary: (0, mutate_domain_adapters_1.formatReadyModulePlanSummary)(rows),
+        moduleCount: modules.length,
+        rows,
+        targets: rows.map((row) => (0, mutate_output_values_1.compactObject)({
+            file: (0, mutate_output_values_1.readString)(row.target),
+            entities: (0, mutate_output_values_1.readStringArray)(row.entities),
+            summary: (0, mutate_output_values_1.readString)(row.summary)
+        }))
+    });
+}
+function validateMutateIntentBeforeExecution(cwd, segments, operation, previewId) {
+    for (const [index, segment] of segments.entries()) {
+        if (segment.kind !== "file") {
+            continue;
+        }
+        const validation = validateFileLayoutSegment(cwd, segment);
+        if (!validation) {
+            continue;
+        }
+        const summary = summarizePreflightFailureSegments(cwd, segments, index);
+        return (0, mutate_output_values_1.compactObject)({
+            ok: false,
+            operation,
+            ...(previewId ? { previewId } : {}),
+            code: (0, mutate_output_values_1.readString)(validation.code) ?? "MUTATE_FILE_LAYOUT_VALIDATION_FAILED",
+            failedSegment: index + 1,
+            segments: summary,
+            aggregate: (0, mutate_result_projection_1.buildMutateAggregateModel)(summary),
+            validation,
+            filesWritten: [],
+            filesTouched: [],
+            next: `fix the mutate request and rerun ${operation.replace("mutate.", "")}`
+        });
+    }
+    return null;
+}
+function validateFileLayoutSegment(cwd, segment) {
+    const operations = (0, mutate_output_values_1.readObjectArray)(segment.operations);
+    const state = createFileLayoutValidationState();
+    for (const group of groupFileLayoutValidationOperations(operations)) {
+        const validation = validateFileLayoutOperationGroup(cwd, group, state);
+        if (validation) {
+            return validation;
+        }
+        applyFileLayoutValidationGroup(cwd, group, state);
+    }
+    return null;
+}
+function createFileLayoutValidationState() {
+    return {
+        added: new Set(),
+        removed: new Set(),
+        seenTargets: new Set()
+    };
+}
+function validateFileLayoutOperationGroup(cwd, operations, state) {
+    const duplicateTargets = [];
+    const missingSources = [];
+    const unsupportedSources = [];
+    for (const operation of operations) {
+        const source = (0, mutate_output_values_1.readString)(operation.sourceFile);
+        const target = (0, mutate_output_values_1.readString)(operation.targetFile);
+        if (target) {
+            const resolvedTarget = (0, mutate_result_projection_1.normalizePathKey)((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, target));
+            if (state.seenTargets.has(resolvedTarget)) {
+                duplicateTargets.push(target);
+            }
+        }
+        if (source && !fileLayoutPathExists(cwd, source, state)) {
+            missingSources.push(source);
+        }
+        else if (source && isCssLikeFileLayoutSource(source)) {
+            unsupportedSources.push(source);
+        }
+    }
+    const family = operations.every((operation) => operation.kind === "fileRename")
+        ? "file rename"
+        : "file move";
+    if (duplicateTargets.length > 0) {
+        return {
+            code: family === "file rename" ? "MUTATE_FILE_RENAME_DUPLICATE_TARGET" : "MUTATE_FILE_MOVE_DUPLICATE_TARGET",
+            family,
+            duplicateTargets: (0, mutate_output_values_1.uniqueStrings)(duplicateTargets)
+        };
+    }
+    if (missingSources.length > 0) {
+        return {
+            code: family === "file rename" ? "MUTATE_FILE_RENAME_SOURCE_NOT_FOUND" : "MUTATE_FILE_MOVE_SOURCE_NOT_FOUND",
+            family,
+            missingSources: (0, mutate_output_values_1.uniqueStrings)(missingSources)
+        };
+    }
+    if (unsupportedSources.length > 0) {
+        return {
+            code: family === "file rename" ? "FILE_RENAME_SOURCE_ASSET_UNSUPPORTED" : "FILE_MOVE_SOURCE_ASSET_UNSUPPORTED",
+            family,
+            unsupportedSources: (0, mutate_output_values_1.uniqueStrings)(unsupportedSources)
+        };
+    }
+    return null;
+}
+function isCssLikeFileLayoutSource(source) {
+    const extension = path.extname(source).toLowerCase();
+    return extension === ".css" || extension === ".scss";
+}
+function applyFileLayoutValidationGroup(cwd, operations, state) {
+    for (const operation of operations) {
+        const source = (0, mutate_output_values_1.readString)(operation.sourceFile);
+        const target = (0, mutate_output_values_1.readString)(operation.targetFile);
+        if (target) {
+            state.seenTargets.add((0, mutate_result_projection_1.normalizePathKey)((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, target)));
+        }
+        if (source) {
+            const sourceKey = (0, mutate_result_projection_1.normalizePathKey)((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, source));
+            state.added.delete(sourceKey);
+            state.removed.add(sourceKey);
+        }
+        if (target) {
+            const targetKey = (0, mutate_result_projection_1.normalizePathKey)((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, target));
+            state.removed.delete(targetKey);
+            state.added.add(targetKey);
+        }
+    }
+}
+function fileLayoutPathExists(cwd, value, state) {
+    const key = (0, mutate_result_projection_1.normalizePathKey)((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, value));
+    if (state.added.has(key)) {
+        return true;
+    }
+    if (state.removed.has(key)) {
+        return false;
+    }
+    return fs.existsSync((0, mutate_result_projection_1.resolveMaybeRelative)(cwd, value));
+}
+function groupFileLayoutValidationOperations(operations) {
+    const groups = [];
+    for (const operation of operations) {
+        const previousGroup = groups[groups.length - 1];
+        const previousOperation = previousGroup?.[previousGroup.length - 1];
+        if (previousGroup && previousOperation && isSameFileLayoutValidationGroup(previousOperation, operation)) {
+            previousGroup.push(operation);
+            continue;
+        }
+        groups.push([operation]);
+    }
+    return groups;
+}
+function isSameFileLayoutValidationGroup(previous, next) {
+    if (previous.kind !== next.kind) {
+        return false;
+    }
+    if (previous.kind === "fileMoveToDir") {
+        return (0, mutate_output_values_1.readString)(previous.targetDir) === (0, mutate_output_values_1.readString)(next.targetDir);
+    }
+    if (previous.kind === "fileRename") {
+        return (0, mutate_output_values_1.readString)(previous.targetDir) === (0, mutate_output_values_1.readString)(next.targetDir);
+    }
+    return false;
+}
+function summarizePreflightFailureSegments(cwd, segments, failedIndex) {
+    return segments.map((segment, index) => {
+        const status = index === failedIndex ? "failed" : "notRun";
+        const response = index <= failedIndex ? buildCheapMutatePreviewResponse(cwd, segment) : undefined;
+        return (0, mutate_output_values_1.compactObject)({
+            index: index + 1,
+            kind: String(segment.kind ?? "unknown"),
+            status,
+            ok: false,
+            summary: response ? (0, mutate_output_values_1.readSummary)(response) : "not run",
+            estimatedDurationMs: (0, mutate_domain_adapters_1.estimateMutateSegmentDurationMs)(segment),
+            filesWritten: [],
+            filesTouched: [],
+            ...(response ? { details: (0, mutate_result_projection_1.buildMutateSegmentDetails)(segment, response) } : {})
+        });
+    });
+}
+function groupFileMoveOperations(operations) {
+    const groups = new Map();
+    for (const operation of operations) {
+        if (operation.kind !== "fileMoveToDir") {
+            continue;
+        }
+        const targetDir = (0, mutate_output_values_1.readString)(operation.targetDir) ?? "";
+        groups.set(targetDir, [...(groups.get(targetDir) ?? []), (0, mutate_output_values_1.readString)(operation.sourceFile) ?? ""]);
+    }
+    return Array.from(groups.entries()).map(([targetDir, files]) => (0, mutate_output_values_1.compactObject)({
+        targetDir,
+        files: files.filter(Boolean)
+    }));
+}
+function readRenameMap(value) {
+    if (!(0, mutate_output_values_1.isObject)(value)) {
+        return [];
+    }
+    return Object.entries(value)
+        .filter((entry) => typeof entry[1] === "string");
+}
+function readModulePlanIntentEntities(module) {
+    const entities = (0, mutate_output_values_1.readStringArray)(module.entities);
+    if (entities.length > 0) {
+        return entities;
+    }
+    const symbols = Array.isArray(module.symbols) ? module.symbols : [];
+    return symbols
+        .map((symbol) => {
+        if (typeof symbol === "string") {
+            return symbol;
+        }
+        if ((0, mutate_output_values_1.isObject)(symbol)) {
+            return (0, mutate_output_values_1.readString)(symbol.raw) ?? (0, mutate_output_values_1.readString)(symbol.symbolName);
+        }
+        return null;
+    })
+        .filter((symbol) => Boolean(symbol));
+}
+function withText(response, text = null) {
+    return (0, agent_text_1.attachAgentText)(response, text ?? (0, mutate_response_replay_1.formatMutateAgentText)(response));
+}
+function withMutateMetricsAndText(cwd, response, text = null) {
+    const presentationModel = (0, mutate_file_view_1.attachMutateAggregateFilesView)(cwd, (0, mutate_result_projection_1.attachDeclarationCleanupAggregateView)(cwd, response));
+    const prepared = (0, mutate_result_projection_1.attachMutateResultModel)(presentationModel);
+    recordMutateCentralMetrics(cwd, prepared);
+    if (hasDeclarationCleanupOperations(presentationModel)) {
+        return (0, agent_text_1.attachAgentText)(prepared, (0, mutate_aggregate_output_1.formatMutateAggregateText)(cwd, presentationModel) ?? text ?? (0, mutate_response_replay_1.formatMutateAgentText)(presentationModel));
+    }
+    return (0, agent_text_1.attachAgentText)(prepared, text ?? (0, mutate_response_replay_1.formatMutateAgentText)(presentationModel));
+}
+function hasDeclarationCleanupOperations(response) {
+    const aggregate = (0, mutate_output_values_1.isObject)(response.aggregate) ? response.aggregate : {};
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    return (0, mutate_output_values_1.readObjectArray)(operations.declarationCleanups).length > 0;
+}
+function recordMutateCentralMetrics(cwd, response) {
+    const operation = (0, mutate_output_values_1.readString)(response.operation);
+    if (operation !== "mutate.execute" && operation !== "mutate.apply") {
+        return;
+    }
+    const aggregate = (0, mutate_output_values_1.isObject)(response.aggregate) ? response.aggregate : {};
+    const operations = (0, mutate_output_values_1.isObject)(aggregate.operations) ? aggregate.operations : {};
+    const filesWritten = (0, mutate_output_values_1.readStringArray)(response.filesWritten).length > 0
+        ? (0, mutate_output_values_1.readStringArray)(response.filesWritten)
+        : (0, mutate_output_values_1.readStringArray)(aggregate.filesWritten);
+    const filesTouched = (0, mutate_output_values_1.readStringArray)(response.filesTouched).length > 0
+        ? (0, mutate_output_values_1.readStringArray)(response.filesTouched)
+        : (0, mutate_output_values_1.readStringArray)(aggregate.filesTouched);
+    const renames = (0, mutate_output_values_1.readObjectArray)(operations.renames);
+    for (const rename of renames) {
+        (0, central_metrics_1.recordCentralMetric)({
+            kind: "mutation.entity",
+            operation,
+            domainOperation: "rename",
+            cwd: path.resolve(cwd),
+            sourceFile: (0, mutate_output_values_1.readString)(rename.sourceFile),
+            entity: (0, mutate_output_values_1.readString)(rename.entity),
+            newName: (0, mutate_output_values_1.readString)(rename.newName),
+            ok: response.ok !== false,
+            totalEntities: renames.length,
+            changedFileCount: filesTouched.length,
+            savedFileCount: filesWritten.length,
+            ...((0, central_metrics_1.mutationImpactMetricsEnabled)()
+                ? {
+                    impact: {
+                        locationCount: null,
+                        fileCount: filesTouched.length,
+                        impactCollectionMs: null
+                    },
+                    changedFiles: filesTouched,
+                    savedFiles: filesWritten
+                }
+                : {})
+        });
+    }
+    for (const move of (0, mutate_output_values_1.readObjectArray)(operations.declarationMoves)) {
+        const entities = (0, mutate_output_values_1.readStringArray)(move.entities);
+        for (const entity of entities) {
+            (0, central_metrics_1.recordCentralMetric)({
+                kind: "mutation.entity",
+                operation,
+                domainOperation: "move.toFile",
+                cwd: path.resolve(cwd),
+                sourceFile: (0, mutate_output_values_1.readString)(move.sourceFile),
+                targetFile: (0, mutate_output_values_1.readString)(move.targetFile),
+                entity,
+                ok: response.ok !== false,
+                totalEntities: entities.length,
+                changedFileCount: filesTouched.length,
+                savedFileCount: filesWritten.length,
+                ...((0, central_metrics_1.mutationImpactMetricsEnabled)()
+                    ? {
+                        impact: {
+                            referenceCount: null,
+                            fileCount: filesTouched.length,
+                            impactCollectionMs: null
+                        },
+                        changedFiles: filesTouched,
+                        savedFiles: filesWritten
+                    }
+                    : {})
+            });
+        }
+    }
+    (0, central_metrics_1.recordCentralMetric)({
+        kind: "mutation.summary",
+        operation,
+        cwd: path.resolve(cwd),
+        ok: response.ok !== false,
+        summary: (0, mutate_output_values_1.readString)(response.summary) ?? (0, mutate_aggregate_output_1.formatMutateAggregateSummary)(aggregate, operation, response),
+        filesWrittenCount: filesWritten.length,
+        filesTouchedCount: filesTouched.length
+    });
+}
+function mutateHelp() {
+    return {
+        ok: true,
+        command: "mutate",
+        usage: "aib mutate preview --stdin | aib mutate execute --stdin | aib mutate apply <previewId>",
+        notes: [
+            "mutate is the unified mutation entrypoint.",
+            "rename is semantic symbol rename.",
+            "renameFile is whole-file rename.",
+            "move <targetFile>: <entities> is semantic declaration move.",
+            "moveToDir <targetDir>: <files> is whole-file move."
+        ]
+    };
+}