@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-mutation-runtime.js

@@ -0,0 +1,521 @@
+"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.runSemanticMutationRuntime = runSemanticMutationRuntime;
+exports.withSemanticOperationExecute = withSemanticOperationExecute;
+exports.estimateSemanticMutationRowCount = estimateSemanticMutationRowCount;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const env_vars_1 = require("../config/env-vars");
+const product_storage_1 = require("../config/product-storage");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const refactor_batch_execution_cache_1 = require("../commands/refactor-batch-execution-cache");
+const refactor_batch_preview_cache_1 = require("../commands/refactor-batch-preview-cache");
+const mutation_execution_cache_1 = require("../commands/mutation-execution-cache");
+const runtime_lifecycle_1 = require("../session/runtime-lifecycle");
+const mutation_recovery_journal_1 = require("../commands/mutation-recovery-journal");
+const semantic_mutation_engine_1 = require("./semantic-mutation-engine");
+async function runSemanticMutationRuntime(cwd, payload, options, action, runtimeOptions) {
+    if (action === "apply") {
+        if (!runtimeOptions.previewId) {
+            throw new errors_1.CliError("SEMANTIC_MUTATION_PREVIEW_ID_REQUIRED", "semantic mutation apply expects a preview id.");
+        }
+        const syncWaitMs = runtimeOptions.syncWaitMs ?? readSemanticMutationSyncWaitMs();
+        if (syncWaitMs > 0) {
+            const record = readValidatedSemanticPreviewRecord(cwd, runtimeOptions.previewId);
+            const normalizedPayload = withOperationExecute(record.normalizedPayload, true);
+            return runSemanticMutationPayloadWithExecution(cwd, normalizedPayload, options, action, runtimeOptions, syncWaitMs);
+        }
+        return applySemanticPreview(cwd, runtimeOptions.previewId, options, runtimeOptions);
+    }
+    if (!payload) {
+        throw new errors_1.CliError("SEMANTIC_MUTATION_PAYLOAD_REQUIRED", "semantic mutation expects a payload.");
+    }
+    if (action === "execute" && (runtimeOptions.syncWaitMs ?? readSemanticMutationSyncWaitMs()) > 0) {
+        return runSemanticMutationPayloadWithExecution(cwd, payload, options, action, runtimeOptions, runtimeOptions.syncWaitMs ?? readSemanticMutationSyncWaitMs());
+    }
+    return runSemanticMutationPayload(cwd, payload, options, action, runtimeOptions);
+}
+function withSemanticOperationExecute(rawPayload, execute) {
+    return withOperationExecute(rawPayload, execute);
+}
+function estimateSemanticMutationRowCount(payload) {
+    const operations = Array.isArray(payload.operations)
+        ? payload.operations
+        : Array.isArray(payload.requests)
+            ? payload.requests
+            : [];
+    let count = 0;
+    for (const operation of operations) {
+        if (!isJsonObject(operation)) {
+            count += 1;
+            continue;
+        }
+        const rawEntities = Array.isArray(operation.entities)
+            ? operation.entities
+            : Array.isArray(operation.symbols)
+                ? operation.symbols
+                : [];
+        const rawRenames = Array.isArray(operation.renames)
+            ? operation.renames
+            : isJsonObject(operation.renames)
+                ? Object.keys(operation.renames)
+                : [];
+        count += Math.max(1, rawEntities.length, rawRenames.length);
+    }
+    return Math.max(1, count);
+}
+async function applySemanticPreview(cwd, previewId, options, runtimeOptions) {
+    const record = readValidatedSemanticPreviewRecord(cwd, previewId);
+    return runSemanticMutationPayload(cwd, withOperationExecute(record.normalizedPayload, true), options, "apply", {
+        ...runtimeOptions,
+        previewId
+    });
+}
+function readValidatedSemanticPreviewRecord(cwd, previewId) {
+    const record = (0, refactor_batch_preview_cache_1.readRefactorBatchPreviewRecord)(cwd, previewId);
+    const changedFile = record.files.find((file) => {
+        const existed = fs.existsSync(file.file);
+        return existed !== file.existed || (0, refactor_batch_preview_cache_1.hashFileIfExists)(file.file) !== file.hash;
+    });
+    if (changedFile) {
+        throw new errors_1.CliError("SEMANTIC_MUTATION_PREVIEW_FILES_CHANGED", "Touched files changed after semantic mutation preview. Rerun preview.", {
+            previewId,
+            file: compactPath(cwd, changedFile.file)
+        });
+    }
+    return record;
+}
+async function runSemanticMutationPayloadWithExecution(cwd, payload, options, action, runtimeOptions, syncWaitMs) {
+    const executionId = (0, refactor_batch_execution_cache_1.buildRefactorBatchExecutionId)();
+    const operation = `${runtimeOptions.operationPrefix}.${action}`;
+    const estimatedDurationMs = estimateSemanticMutationDurationMs(payload);
+    const status = (0, refactor_batch_execution_cache_1.createRefactorBatchExecutionStatus)(cwd, executionId, operation, estimateSemanticMutationRowCount(payload));
+    (0, refactor_batch_execution_cache_1.writeRefactorBatchExecutionStatus)(cwd, status);
+    const startedAtMs = Date.now();
+    const backgroundEnv = captureSemanticMutationBackgroundEnv();
+    const executionOptions = {
+        ...options,
+        ...(options.metricsEnabled === true ? { semanticMoveMetricsExecutionId: executionId } : {}),
+        semanticRenameExecutionEvidence: {
+            beforeApply(writeSet) {
+                options.semanticRenameExecutionEvidence?.beforeApply(writeSet);
+                status.phase = "applying";
+                status.plannedWriteSet = [...writeSet];
+                status.potentiallyModifiedFiles = [...writeSet];
+                (0, refactor_batch_execution_cache_1.writeRefactorBatchExecutionStatus)(cwd, status);
+            },
+            afterProgress(progress) {
+                options.semanticRenameExecutionEvidence?.afterProgress?.(progress);
+            }
+        },
+        semanticMoveExecutionEvidence: {
+            beforeApply(writeSet) {
+                options.semanticMoveExecutionEvidence?.beforeApply(writeSet);
+                status.phase = "applying";
+                status.plannedWriteSet = [...writeSet];
+                status.potentiallyModifiedFiles = [...writeSet];
+                (0, refactor_batch_execution_cache_1.writeRefactorBatchExecutionStatus)(cwd, status);
+            },
+            afterProgress(progress) {
+                options.semanticMoveExecutionEvidence?.afterProgress?.(progress);
+            },
+            afterRoute(route) {
+                options.semanticMoveExecutionEvidence?.afterRoute?.(route);
+            }
+        }
+    };
+    const jobPromise = startSemanticMutationBackgroundJob(() => (0, product_storage_1.runWithProductStorageOverride)(backgroundEnv[env_vars_1.CLI_ENV.productStorageDir], () => withSemanticMutationBackgroundEnv(backgroundEnv, async () => {
+        try {
+            const output = await runSemanticMutationPayload(cwd, payload, executionOptions, action, runtimeOptions, executionId);
+            const rows = readResponseRows(output.result);
+            status.status = output.result.ok === false ? "failed" : "completed";
+            status.phase = "completed";
+            status.completedRows = rows.filter((row) => row.ok !== false).length;
+            status.failedRows = rows.filter((row) => row.ok === false).length;
+            status.filesWritten = collectFilesFromSemanticMutationResult(output.result);
+            status.potentiallyModifiedFiles = readStringArray(output.result.potentiallyModifiedFiles);
+            if (isJsonObject(output.result.journal)) {
+                status.journal = output.result.journal;
+            }
+            status.result = output.result;
+            if (output.result.ok === false) {
+                status.error = readString(output.result.code) ?? "SEMANTIC_MUTATION_FAILED";
+            }
+            (0, refactor_batch_execution_cache_1.writeRefactorBatchExecutionStatus)(cwd, status);
+            return output;
+        }
+        catch (error) {
+            status.status = "failed";
+            status.phase = "completed";
+            status.error = error instanceof Error ? error.message : String(error);
+            if (status.plannedWriteSet && status.potentiallyModifiedFiles === undefined) {
+                status.potentiallyModifiedFiles = [...status.plannedWriteSet];
+            }
+            (0, refactor_batch_execution_cache_1.writeRefactorBatchExecutionStatus)(cwd, status);
+            throw error;
+        }
+    })));
+    const waitResult = await waitForSemanticMutationJob(jobPromise, syncWaitMs);
+    if (waitResult.status === "result") {
+        return waitResult.result;
+    }
+    jobPromise.catch(() => undefined);
+    return {
+        result: buildSemanticMutationStillRunningResponse(cwd, executionId, operation, estimatedDurationMs, Date.now() - startedAtMs)
+    };
+}
+async function runSemanticMutationPayload(cwd, payload, options, action, runtimeOptions, executionId) {
+    await maybeDelaySemanticMutationForTest();
+    const operation = `${runtimeOptions.operationPrefix}.${action}`;
+    const engineResult = await (0, semantic_mutation_engine_1.runSemanticMutationEngine)(cwd, payload, options, operation);
+    const result = {
+        ...engineResult.result
+    };
+    if ((action === "preview" || action === "validate") && result.ok !== false) {
+        const normalizedPayload = withOperationExecute(payload, false);
+        const previewId = (0, refactor_batch_preview_cache_1.buildRefactorBatchPreviewId)(normalizedPayload);
+        const files = collectSemanticPreviewFiles(cwd, engineResult.builtBatch.payload);
+        const previewHash = (0, refactor_batch_preview_cache_1.buildRefactorBatchPreviewHash)(normalizedPayload, files, result);
+        (0, refactor_batch_preview_cache_1.writeRefactorBatchPreviewRecord)(cwd, {
+            previewId,
+            previewHash,
+            createdAt: new Date().toISOString(),
+            cwd: path.resolve(cwd),
+            normalizedPayload,
+            files,
+            builder: engineResult.builtBatch.summary,
+            previewResult: result
+        });
+        result.previewId = previewId;
+        result.next = `${runtimeOptions.previewApplyCommand} ${previewId}`;
+    }
+    const formatted = runtimeOptions.formatResult
+        ? runtimeOptions.formatResult(result, engineResult.builtBatch.summary, engineResult.response, action, {
+            ...(runtimeOptions.formatOptions ?? {}),
+            ...(typeof result.previewId === "string" ? { previewId: result.previewId } : {}),
+            ...(typeof result.next === "string" ? { next: result.next } : {})
+        })
+        : result;
+    if (executionId && (action === "execute" || action === "apply")) {
+        const journal = writeSemanticMutationJournal(cwd, executionId, operation, engineResult.builtBatch.payload, engineResult.builtBatch.summary, engineResult.response, formatted);
+        const journalSummary = (0, mutation_recovery_journal_1.mutationRecoveryJournalSummary)(journal);
+        if (journalSummary) {
+            formatted.journal = journalSummary;
+        }
+    }
+    return {
+        result: formatted,
+        builtBatch: engineResult.builtBatch.summary,
+        response: engineResult.response
+    };
+}
+function buildSemanticMutationStillRunningResponse(cwd, executionId, operation, estimatedDurationMs, elapsedMs) {
+    const status = (0, refactor_batch_execution_cache_1.readRefactorBatchExecutionStatus)(cwd, executionId);
+    const estimatedRemainingMs = Math.max(0, estimatedDurationMs - elapsedMs);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildSemanticMutationExecutionSummary(status),
+        progress: `${status.completedRows}/${status.rowCount}`,
+        filesWritten: status.filesWritten,
+        potentiallyModifiedFiles: status.potentiallyModifiedFiles ?? [],
+        updatedAt: status.updatedAt,
+        estimatedRemainingMs,
+        ...(status.journal ? { journal: status.journal } : {})
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatSemanticMutationStillRunningText(operation, status, estimatedRemainingMs));
+}
+function formatSemanticMutationStillRunningText(operation, status, estimatedRemainingMs) {
+    return [
+        `${operation} ${status.executionId}`,
+        buildSemanticMutationExecutionSummary(status),
+        "applying mutation",
+        estimatedRemainingMs > 0
+            ? `estimated remaining: ${formatDuration(Math.max(estimatedRemainingMs, 5_000))}`
+            : "estimated remaining: check status again soon"
+    ].join("\n");
+}
+function buildSemanticMutationExecutionSummary(status) {
+    if (status.status === "completed") {
+        return `completed, ${status.completedRows}/${status.rowCount} rows, ${status.filesWritten.length} files written`;
+    }
+    if (status.status === "failed") {
+        return `failed, ${status.completedRows}/${status.rowCount} rows, ${status.failedRows} failed`;
+    }
+    return `in progress, ${status.completedRows}/${status.rowCount} rows`;
+}
+function writeSemanticMutationJournal(cwd, executionId, operation, builtPayload, builtSummary, response, result) {
+    const operations = readBuiltBatchOperations(builtPayload);
+    const journal = (0, mutation_recovery_journal_1.createSemanticMutationRecoveryJournal)(cwd, executionId, operation, operations.map((item) => ({
+        id: item.id,
+        kind: item.kind,
+        source: item.source,
+        target: item.target
+    })));
+    (0, mutation_recovery_journal_1.writeMutationRecoveryJournal)(cwd, journal);
+    (0, mutation_recovery_journal_1.writeMutationRecoveryPlan)(cwd, journal, {
+        builtPayload,
+        builtSummary
+    });
+    for (const operationRow of operations) {
+        (0, mutation_recovery_journal_1.updateMutationRecoveryJournalRow)(cwd, journal, operationRow.id, { phase: "started" });
+        (0, mutation_recovery_journal_1.writeMutationRecoveryDetail)(cwd, journal, "provider", operationRow.id, {
+            id: operationRow.id,
+            kind: operationRow.kind,
+            body: operationRow.body
+        });
+    }
+    const responseRows = readResponseRows({ response });
+    const responseRowById = new Map(responseRows.map((row) => [readString(row.id), row]));
+    for (const operationRow of operations) {
+        const responseRow = responseRowById.get(operationRow.id) ?? null;
+        if (!responseRow) {
+            continue;
+        }
+        (0, mutation_recovery_journal_1.writeMutationRecoveryDetail)(cwd, journal, "apply", operationRow.id, {
+            row: responseRow,
+            result: {
+                ok: result.ok !== false,
+                operation: readString(result.operation) ?? null
+            }
+        });
+        const error = readString(responseRow.error) ?? readString(responseRow.skipReason);
+        (0, mutation_recovery_journal_1.updateMutationRecoveryJournalRow)(cwd, journal, operationRow.id, {
+            phase: semanticJournalPhase(responseRow),
+            filesWritten: readStringArray(responseRow.savedFiles),
+            touchedFiles: readStringArray(responseRow.touchedFiles),
+            ...(error ? { error } : {})
+        });
+    }
+    return journal;
+}
+function readBuiltBatchOperations(payload) {
+    const operations = Array.isArray(payload.operations) ? payload.operations.filter(isJsonObject) : [];
+    return operations.map((operation, index) => {
+        const body = isJsonObject(operation.body) ? operation.body : {};
+        const kind = readString(operation.kind) ?? "operation";
+        return {
+            id: readString(operation.id) ?? `row-${index + 1}`,
+            kind,
+            source: readString(body.sourceFile) ?? "",
+            target: semanticOperationTarget(kind, body),
+            body
+        };
+    });
+}
+function semanticOperationTarget(kind, body) {
+    if (kind === "moveRefactor") {
+        return readString(body.targetFile) ?? "";
+    }
+    if (kind === "renameSymbol") {
+        return readString(body.newName) ?? "";
+    }
+    return "";
+}
+function semanticJournalPhase(row) {
+    if (row.skipped === true) {
+        return "skipped";
+    }
+    return row.ok === false ? "failed" : "completed";
+}
+function collectSemanticPreviewFiles(cwd, payload) {
+    const operations = Array.isArray(payload.operations) ? payload.operations.filter(isJsonObject) : [];
+    const files = new Set();
+    for (const operation of operations) {
+        const body = isJsonObject(operation.body) ? operation.body : {};
+        const sourceFile = readString(body.sourceFile);
+        const targetFile = readString(body.targetFile);
+        if (sourceFile) {
+            files.add(resolvePreviewPath(cwd, sourceFile));
+        }
+        if (targetFile) {
+            files.add(resolvePreviewPath(cwd, targetFile));
+        }
+    }
+    return Array.from(files)
+        .sort((left, right) => left.localeCompare(right))
+        .map((file) => ({
+        file,
+        existed: fs.existsSync(file),
+        hash: (0, refactor_batch_preview_cache_1.hashFileIfExists)(file)
+    }));
+}
+function collectFilesFromSemanticMutationResult(result) {
+    const rows = readResponseRows(result);
+    return uniqueStrings(rows.flatMap((row) => readStringArray(row.savedFiles)));
+}
+function readResponseRows(result) {
+    const response = isJsonObject(result.response) ? result.response : null;
+    return Array.isArray(response?.rows) ? response.rows.filter(isJsonObject) : [];
+}
+function withOperationExecute(rawPayload, execute) {
+    const operations = Array.isArray(rawPayload.operations)
+        ? rawPayload.operations
+        : Array.isArray(rawPayload.requests)
+            ? rawPayload.requests
+            : null;
+    if (!operations) {
+        return {
+            ...rawPayload,
+            execute
+        };
+    }
+    const { operations: _operations, ...payloadRest } = rawPayload;
+    return {
+        ...payloadRest,
+        requests: operations.map((operation) => operation && typeof operation === "object" && !Array.isArray(operation)
+            ? { ...operation, execute }
+            : operation),
+        execute
+    };
+}
+function estimateSemanticMutationDurationMs(payload) {
+    const rowCount = estimateSemanticMutationRowCount(payload);
+    return 12_000 + rowCount * 2_000;
+}
+function readSemanticMutationSyncWaitMs() {
+    return (0, mutation_execution_cache_1.readMutationSyncWaitMs)(process.env[env_vars_1.CLI_ENV.refactorBatchSyncWaitMs], 120_000);
+}
+function startSemanticMutationBackgroundJob(job) {
+    return (0, runtime_lifecycle_1.trackSessionBackgroundPromise)(new Promise((resolve, reject) => {
+        setImmediate(() => {
+            job().then(resolve, reject);
+        });
+    }), "semantic-mutation-background");
+}
+async function waitForSemanticMutationJob(jobPromise, deadlineMs) {
+    let timeout = null;
+    const deadlinePromise = new Promise((resolve) => {
+        timeout = setTimeout(() => resolve({ status: "deadline" }), Math.max(0, deadlineMs));
+    });
+    const result = await Promise.race([
+        jobPromise.then((value) => ({ status: "result", result: value })),
+        deadlinePromise
+    ]);
+    if (timeout) {
+        clearTimeout(timeout);
+    }
+    return result;
+}
+async function maybeDelaySemanticMutationForTest() {
+    const raw = process.env[env_vars_1.CLI_ENV.testRefactorBatchDelayMs];
+    if (!raw) {
+        return;
+    }
+    const delayMs = Number.parseInt(raw, 10);
+    if (!Number.isFinite(delayMs) || delayMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delayMs, 120_000)));
+}
+function captureSemanticMutationBackgroundEnv() {
+    const keys = [
+        env_vars_1.CLI_ENV.productStorageDir,
+        env_vars_1.CLI_ENV.trace,
+        env_vars_1.CLI_ENV.traceDir,
+        env_vars_1.CLI_ENV.metrics,
+        env_vars_1.CLI_ENV.metricsDir,
+        env_vars_1.CLI_ENV.metricsTag,
+        env_vars_1.CLI_ENV.mutationImpactMetrics,
+        env_vars_1.CLI_ENV.mutationImpactStream,
+        env_vars_1.CLI_ENV.semanticRenameDirectApply,
+        env_vars_1.CLI_ENV.testMoveToFileFailEntity,
+        env_vars_1.CLI_ENV.testRefactorBatchDelayMs
+    ];
+    const env = {};
+    for (const key of keys) {
+        env[key] = process.env[key];
+    }
+    return env;
+}
+async function withSemanticMutationBackgroundEnv(env, callback) {
+    const previous = {};
+    for (const [key, value] of Object.entries(env)) {
+        previous[key] = process.env[key];
+        if (value === undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
+    }
+    try {
+        return await callback();
+    }
+    finally {
+        for (const [key, value] of Object.entries(previous)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+function resolvePreviewPath(cwd, filePath) {
+    return path.normalize(path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath));
+}
+function compactPath(cwd, filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const cwdNormalized = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+    const lower = normalized.toLowerCase();
+    const cwdLower = cwdNormalized.toLowerCase();
+    return lower.startsWith(`${cwdLower}/`) ? normalized.slice(cwdNormalized.length + 1) : normalized;
+}
+function formatDuration(milliseconds) {
+    const seconds = Math.max(1, Math.round(milliseconds / 1000));
+    if (seconds < 60) {
+        return `~${seconds} sec`;
+    }
+    const minutes = Math.max(1, Math.round(seconds / 60));
+    return `~${minutes} min`;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function readString(value) {
+    return typeof value === "string" ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/mutation/semantic-planner-retry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_PLANNER_RETRY_TESTING = void 0;
+exports.runSemanticPlannerWithRetry = runSemanticPlannerWithRetry;
+const RETRYABLE_STALE_PLAN_CODES = new Set([
+    "SEMANTIC_MOVE_SOURCE_SNAPSHOT_CHANGED",
+    "SEMANTIC_MOVE_EDIT_SNAPSHOT_CHANGED",
+    "SEMANTIC_MOVE_SNAPSHOT_CHANGED",
+    "SEMANTIC_RENAME_SOURCE_SNAPSHOT_CHANGED",
+    "SEMANTIC_RENAME_EDIT_SNAPSHOT_CHANGED",
+    "SEMANTIC_RENAME_SNAPSHOT_CHANGED"
+]);
+const DEFAULT_MAX_ATTEMPTS = 2;
+async function runSemanticPlannerWithRetry(runAttempt, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
+    const boundedAttempts = Math.max(1, Math.floor(maxAttempts));
+    let result = await runAttempt(1);
+    for (let attempt = 2; attempt <= boundedAttempts; attempt += 1) {
+        if (result.complete || !RETRYABLE_STALE_PLAN_CODES.has(result.code))
+            return result;
+        result = await runAttempt(attempt);
+    }
+    return result;
+}
+exports.SEMANTIC_PLANNER_RETRY_TESTING = {
+    defaultMaxAttempts: DEFAULT_MAX_ATTEMPTS
+};

package/dist/mutation/semantic-program-roots.js

@@ -0,0 +1,69 @@
+"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.focusedSemanticProgramRootFiles = focusedSemanticProgramRootFiles;
+const path = __importStar(require("node:path"));
+function focusedSemanticProgramRootFiles(input) {
+    if (!input.discovery.complete) {
+        throw new Error("Focused semantic Program roots require complete neutral discovery.");
+    }
+    const configKey = pathKey(input.configFilePath);
+    return uniquePaths([
+        ...input.requiredFiles,
+        ...input.discovery.fileOwners
+            .filter((entry) => entry.ownerConfigs.some((config) => pathKey(config) === configKey))
+            .map((entry) => entry.file),
+        ...input.discovery.semanticEnvironmentFiles
+            .filter((entry) => entry.ownerConfigs.some((config) => pathKey(config) === configKey))
+            .map((entry) => entry.file)
+    ]);
+}
+function uniquePaths(files) {
+    const seen = new Set();
+    const output = [];
+    for (const file of files) {
+        const resolved = path.resolve(file);
+        const key = pathKey(resolved);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        output.push(resolved);
+    }
+    return output;
+}
+function pathKey(file) {
+    const normalized = path.resolve(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}