@sireai/optimus 0.1.1

package/dist/task-environment/orchestration/task-orchestrator.js

@@ -0,0 +1,1122 @@
+import { execFile } from "node:child_process";
+import { access, mkdir, mkdtemp, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+import { basename, dirname, resolve, relative, sep, join } from "node:path";
+import { getVisibleRepoDir } from "../execution-addresses.js";
+import { ExecutionContextAssembler } from "./execution-context-assembler.js";
+import { HarnessResolver } from "./harness-resolver.js";
+import { OptimusLogger } from "../observability/logger.js";
+import { EvolutionSkillGuard } from "../../problem-solving-core/codex/evolution-skill-guard.js";
+import { RepoMemoryService } from "../../problem-solving-core/codex/repo-memory-service.js";
+import { FeishuAnalysisDocService } from "../delivery/feishu-analysis-doc-service.js";
+import { TaskDeliveryDispatcher } from "../delivery/task-delivery-dispatcher.js";
+import { TaskDeliveryService } from "../delivery/task-delivery-service.js";
+import { TaskPublicationService } from "../delivery/task-publication-service.js";
+import { collectBusinessChangePaths, filterBusinessChangeEntries, parseGitStatusOutput, parseRepoProjectStatusReports } from "./git-change-classifier.js";
+const execFileAsync = promisify(execFile);
+const EXEC_MAX_BUFFER = 4 * 1024 * 1024;
+const REPO_MANAGED_TEMP_BRANCH_PATTERN = /^optimus\/task-[a-z0-9-]+$/i;
+function resolveTaskResultPath(resultPath, artifactDir) {
+    if (resultPath.startsWith("/")) {
+        return resolve(resultPath);
+    }
+    return resolve(artifactDir, resultPath);
+}
+export class TaskOrchestrator {
+    store;
+    codexRunner;
+    config;
+    logger;
+    harnessResolver;
+    executionContextAssembler;
+    evolutionSkillGuard;
+    repoMemoryService;
+    taskDeliveryDispatcher;
+    taskDeliveryService;
+    feishuAnalysisDocService;
+    taskPublicationService;
+    constructor(store, codexRunner, config) {
+        this.store = store;
+        this.codexRunner = codexRunner;
+        this.config = config;
+        this.logger = new OptimusLogger(config);
+        this.harnessResolver = new HarnessResolver(config);
+        this.executionContextAssembler = new ExecutionContextAssembler(store, config);
+        this.evolutionSkillGuard = new EvolutionSkillGuard(config);
+        this.repoMemoryService = new RepoMemoryService(config);
+        this.taskDeliveryDispatcher = new TaskDeliveryDispatcher(config);
+        this.taskDeliveryService = new TaskDeliveryService();
+        this.feishuAnalysisDocService = new FeishuAnalysisDocService({ refStore: store });
+        this.taskPublicationService = new TaskPublicationService(this.logger);
+    }
+    // Resolve the queued task into execution inputs, run it once, then persist the terminal outcome.
+    async run(task) {
+        await this.logger.info("task.orchestrator.started", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            runId: task.activeRunId,
+            stage: "orchestrator_start",
+            status: task.status
+        });
+        const taskPackage = await this.store.getTaskPackage(task.taskPackageId);
+        if (!taskPackage) {
+            throw new Error(`Task package not found for task ${task.taskId}`);
+        }
+        const harness = this.harnessResolver.resolve(taskPackage);
+        const startedAt = Date.now();
+        const runId = task.activeRunId;
+        const sourceEventId = task.sourceEventId;
+        let finalStatus = "failed";
+        let finalSummary = "Task failed before completion.";
+        let finalFailureCategory;
+        let preparedContext;
+        let evolutionGuardState;
+        let completionArtifacts = [];
+        let cleanupPending = false;
+        try {
+            await this.logger.info("task.orchestrator.harness_resolved", {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                runId: task.activeRunId,
+                stage: "harness_resolved"
+            });
+            const context = await this.prepareExecutionContext(task, harness, taskPackage, task.abortSignal);
+            preparedContext = context;
+            cleanupPending = Boolean(context.cleanupRequired && context.cleanup);
+            evolutionGuardState = await this.evolutionSkillGuard.prepare(task.taskType);
+            await this.logger.info("skills.evolution.prepare", {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                runId,
+                allowedEvolutionSkillDir: evolutionGuardState.allowedTaskDir,
+                baselineSkillIds: evolutionGuardState.baselineSkillIds,
+                baselineFileCount: evolutionGuardState.baselineFileCount
+            });
+            const executionRequest = await this.prepareExecutionRequest(task, context, taskPackage, harness);
+            const result = await this.codexRunner.runTask(executionRequest, context);
+            await this.persistRepoMemoryIfChanged(task, context);
+            this.validateTaskResultContract(result, context);
+            const completedAt = new Date().toISOString();
+            if (result.status === "completed") {
+                if (context.addresses.mode === "copy") {
+                    await this.validateExecutionIsolation(context);
+                }
+                const patchArtifactPath = await this.writePatchArtifactIfNeeded(context);
+                if (patchArtifactPath) {
+                    completionArtifacts.push({
+                        kind: "patch_diff",
+                        path: patchArtifactPath,
+                        createdAt: completedAt
+                    });
+                }
+            }
+            if (result.resultPath) {
+                const resolvedResultPath = resolveTaskResultPath(result.resultPath, context.addresses.artifactDir);
+                completionArtifacts.unshift({
+                    kind: "result_md",
+                    path: resolvedResultPath,
+                    createdAt: completedAt
+                });
+            }
+            if (completionArtifacts.length > 0) {
+                await this.store.appendArtifacts(task.taskId, completionArtifacts);
+            }
+            finalStatus = result.status === "completed" ? "completed" : "failed";
+            finalSummary = result.status === "completed"
+                ? `Task completed with result file ${result.resultPath ? resolveTaskResultPath(result.resultPath, context.addresses.artifactDir) : "unknown"}.`
+                : result.error?.message ?? "Task failed without an explicit error.";
+            finalFailureCategory = result.status === "failed"
+                ? (result.error?.category ?? result.diagnostics?.failureCategory ?? "unknown")
+                : result.diagnostics?.failureCategory;
+            if (executionRequest.task.status !== finalStatus) {
+                await context.onStatusUpdate?.({ status: finalStatus, detail: finalSummary });
+            }
+            const durationMs = Date.now() - startedAt;
+            if (result.diagnostics?.usedFallback) {
+                await this.logger.warn("task.fallback", {
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    sourceEventId,
+                    runId,
+                    status: finalStatus,
+                    durationMs,
+                    reason: result.diagnostics.fallbackReason ?? "unknown",
+                    failureCategory: result.diagnostics.failureCategory ?? "unknown"
+                });
+            }
+            if (finalStatus === "completed" && evolutionGuardState) {
+                const evolutionChanges = await this.evolutionSkillGuard.evaluate(evolutionGuardState);
+                await this.logger.info("skills.evolution.checked", {
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    runId,
+                    allowedEvolutionSkillDir: preparedContext?.allowedEvolutionSkillDir ?? evolutionGuardState.allowedTaskDir,
+                    baselineSkillIds: evolutionChanges.baselineSkillIds,
+                    currentSkillIds: evolutionChanges.currentSkillIds,
+                    baselineFileCount: evolutionChanges.baselineFileCount,
+                    currentFileCount: evolutionChanges.currentFileCount,
+                    createdSkillIds: evolutionChanges.createdSkillIds,
+                    updatedSkillIds: evolutionChanges.updatedSkillIds,
+                    violationCount: evolutionChanges.violations.length
+                });
+                if (evolutionChanges.violations.length > 0) {
+                    await this.logger.error("skills.evolution.rejected", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        allowedEvolutionSkillDir: preparedContext?.allowedEvolutionSkillDir ?? evolutionGuardState.allowedTaskDir,
+                        violations: evolutionChanges.violations,
+                        createdSkillIds: evolutionChanges.createdSkillIds,
+                        updatedSkillIds: evolutionChanges.updatedSkillIds
+                    });
+                    throw new Error(`Evolution skill guard rejected changes: ${evolutionChanges.violations.join("; ")}`);
+                }
+                await this.logger.writeEvolutionSnapshot({
+                    ok: evolutionChanges.violations.length === 0,
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    runId,
+                    createdSkillIds: evolutionChanges.createdSkillIds,
+                    updatedSkillIds: evolutionChanges.updatedSkillIds,
+                    violations: evolutionChanges.violations,
+                    allowedEvolutionSkillDir: preparedContext?.allowedEvolutionSkillDir ?? null,
+                    updatedAt: new Date().toISOString()
+                });
+                if (evolutionChanges.createdSkillIds.length > 0 || evolutionChanges.updatedSkillIds.length > 0) {
+                    await this.logger.info("skills.evolution.applied", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        createdSkillIds: evolutionChanges.createdSkillIds,
+                        updatedSkillIds: evolutionChanges.updatedSkillIds,
+                        allowedEvolutionSkillDir: preparedContext?.allowedEvolutionSkillDir ?? null
+                    });
+                }
+                else {
+                    await this.logger.info("skills.evolution.noop", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        allowedEvolutionSkillDir: preparedContext?.allowedEvolutionSkillDir ?? null,
+                        baselineSkillIds: evolutionChanges.baselineSkillIds,
+                        currentSkillIds: evolutionChanges.currentSkillIds,
+                        baselineFileCount: evolutionChanges.baselineFileCount,
+                        currentFileCount: evolutionChanges.currentFileCount
+                    });
+                }
+            }
+            await this.logger.info(this.resolveTerminalLogEvent(finalStatus), {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                sourceEventId,
+                runId,
+                status: finalStatus,
+                durationMs,
+                ...(finalFailureCategory ? { failureCategory: finalFailureCategory } : {}),
+                artifactCount: completionArtifacts.length
+            });
+        }
+        catch (error) {
+            finalFailureCategory = this.resolveFailureCategory(error);
+            const errorMessage = error instanceof Error ? error.message : "Unknown task execution error";
+            const canceledByRuntime = task.abortSignal?.aborted === true;
+            finalStatus = canceledByRuntime ? "canceled" : "failed";
+            finalSummary = canceledByRuntime
+                ? `Task canceled: ${String(task.abortSignal?.reason ?? errorMessage)}`
+                : errorMessage;
+            if (canceledByRuntime) {
+                await this.logger.warn("task.canceled", {
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    sourceEventId,
+                    runId,
+                    status: finalStatus,
+                    reason: finalSummary,
+                    failureCategory: finalFailureCategory
+                });
+            }
+            else {
+                await this.logger.error("task.failed", {
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    sourceEventId,
+                    runId,
+                    status: finalStatus,
+                    reason: finalSummary,
+                    failureCategory: finalFailureCategory
+                });
+            }
+        }
+        finally {
+            await this.logger.info("task.orchestrator.finished", {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                runId,
+                stage: "orchestrator_finish",
+                status: finalStatus,
+                failureCategory: finalFailureCategory
+            });
+            await this.store.completeTaskRun(task.taskId, finalStatus, finalSummary, this.buildCompleteTaskRunOptions(finalFailureCategory));
+            try {
+                const postRunStartedAt = Date.now();
+                let postRunStage = "load_final_state";
+                await this.logger.info("task.postrun.started", {
+                    taskId: task.taskId,
+                    taskType: task.taskType,
+                    runId,
+                    status: finalStatus
+                });
+                try {
+                    const persistedArtifacts = await this.store.listTaskArtifacts(task.taskId);
+                    const finalizedTask = await this.store.getTask(task.taskId);
+                    const finalizedRun = runId
+                        ? (await this.store.listTaskRuns()).find((item) => item.runId === runId && item.taskId === task.taskId)
+                        : undefined;
+                    postRunStage = "build_delivery_bundle";
+                    const deliveryBundleBuildStartedAt = Date.now();
+                    await this.logger.info("task.delivery_bundle.build_started", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        artifactCount: persistedArtifacts.length
+                    });
+                    let deliveryBundle = await this.taskDeliveryService.buildBundle({
+                        task: finalizedTask ?? { ...task, status: finalStatus },
+                        ...(taskPackage ? {
+                            taskPackage: {
+                                title: taskPackage.title,
+                                ...(taskPackage.sourceRef ? { sourceRef: taskPackage.sourceRef } : {}),
+                                ...(taskPackage.input.metadata ? { metadata: taskPackage.input.metadata } : {})
+                            }
+                        } : {}),
+                        ...(preparedContext ? { context: preparedContext } : {}),
+                        ...(finalizedRun ? { latestRun: finalizedRun } : {}),
+                        artifacts: persistedArtifacts
+                    });
+                    await this.logger.info("task.delivery_bundle.build_completed", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        durationMs: Date.now() - deliveryBundleBuildStartedAt,
+                        outcome: deliveryBundle.outcome,
+                        hasPatch: Boolean(deliveryBundle.artifacts.patchDiff),
+                        resultMd: deliveryBundle.artifacts.resultMd ?? null
+                    });
+                    if (this.config.delivery.enabled && this.config.delivery.channels.includes("feishu")) {
+                        postRunStage = "upload_analysis_doc";
+                        const analysisDocStartedAt = Date.now();
+                        await this.logger.info("task.delivery_analysis_doc.started", {
+                            taskId: task.taskId,
+                            taskType: task.taskType,
+                            runId,
+                            outcome: deliveryBundle.outcome,
+                            hasExistingAnalysisDocUrl: Boolean(deliveryBundle.summary.analysisDocUrl?.trim())
+                        });
+                        const analysisDocPublish = await this.feishuAnalysisDocService.publishIfNeeded(deliveryBundle);
+                        deliveryBundle = analysisDocPublish.bundle;
+                        if (analysisDocPublish.status === "uploaded") {
+                            await this.logger.info("task.delivery_analysis_doc.uploaded", {
+                                taskId: task.taskId,
+                                taskType: task.taskType,
+                                runId,
+                                durationMs: Date.now() - analysisDocStartedAt,
+                                url: analysisDocPublish.url ?? null
+                            });
+                        }
+                        else if (analysisDocPublish.status === "skipped") {
+                            await this.logger.info("task.delivery_analysis_doc.skipped", {
+                                taskId: task.taskId,
+                                taskType: task.taskType,
+                                runId,
+                                durationMs: Date.now() - analysisDocStartedAt,
+                                reason: analysisDocPublish.reason ?? "unknown"
+                            });
+                        }
+                        else if (analysisDocPublish.status === "failed") {
+                            await this.logger.warn("task.delivery_analysis_doc.failed", {
+                                taskId: task.taskId,
+                                taskType: task.taskType,
+                                runId,
+                                durationMs: Date.now() - analysisDocStartedAt,
+                                reason: analysisDocPublish.reason ?? "unknown"
+                            });
+                        }
+                    }
+                    postRunStage = "persist_delivery_bundle";
+                    await this.store.appendTaskDeliveryBundle(deliveryBundle);
+                    await this.logger.info("task.delivery_bundle.created", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        outcome: deliveryBundle.outcome,
+                        publicationAction: deliveryBundle.publication?.action ?? null,
+                        publicationReason: deliveryBundle.publication?.reason ?? null,
+                        hasPatch: Boolean(deliveryBundle.artifacts.patchDiff)
+                    });
+                    for (const warning of deliveryBundle.warnings ?? []) {
+                        await this.store.appendEvent(task.taskId, "task.delivery_bundle.warning", warning, this.buildTaskEventOptions(runId, sourceEventId));
+                        await this.logger.warn("task.delivery_bundle.warning", {
+                            taskId: task.taskId,
+                            taskType: task.taskType,
+                            runId,
+                            warning,
+                            resultMd: deliveryBundle.artifacts.resultMd ?? null
+                        });
+                    }
+                    postRunStage = "publish";
+                    const publicationStartedAt = Date.now();
+                    await this.logger.info("task.publication.started", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        dryRun: this.config.publication.dryRun,
+                        reviewMode: this.config.publication.reviewMode,
+                        publicationAction: deliveryBundle.publication?.action ?? null,
+                        publicationReason: deliveryBundle.publication?.reason ?? null
+                    });
+                    const publicationResult = await this.taskPublicationService.publish({
+                        bundle: deliveryBundle,
+                        ...(preparedContext ? { context: preparedContext } : {}),
+                        dryRun: this.config.publication.dryRun,
+                        reviewMode: this.config.publication.reviewMode
+                    });
+                    await this.logger.info("task.publication.completed", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        durationMs: Date.now() - publicationStartedAt,
+                        attemptCount: publicationResult.attempts.length,
+                        artifactCount: publicationResult.artifacts.length
+                    });
+                    if (publicationResult.artifacts.length > 0) {
+                        await this.store.appendArtifacts(task.taskId, publicationResult.artifacts);
+                    }
+                    await this.store.appendTaskPublicationAttempts(publicationResult.attempts);
+                    for (const attempt of publicationResult.attempts) {
+                        await this.logger.info("task.publication_attempt.recorded", {
+                            taskId: attempt.taskId,
+                            taskType: task.taskType,
+                            runId: attempt.runId ?? runId,
+                            publicationMode: attempt.mode,
+                            publicationStatus: attempt.status,
+                            summary: attempt.summary,
+                            ...(attempt.artifactPath ? { artifactPath: attempt.artifactPath } : {}),
+                            ...(attempt.error ? { reason: attempt.error } : {})
+                        });
+                    }
+                    postRunStage = "dispatch_delivery";
+                    const deliveryDispatchStartedAt = Date.now();
+                    await this.logger.info("task.delivery_dispatch.started", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        channels: this.config.delivery.channels
+                    });
+                    const deliveryDispatch = await this.taskDeliveryDispatcher.dispatch({
+                        bundle: deliveryBundle,
+                        publicationAttempts: publicationResult.attempts
+                    });
+                    await this.logger.info("task.delivery_dispatch.completed", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        durationMs: Date.now() - deliveryDispatchStartedAt,
+                        attemptCount: deliveryDispatch.attempts.length
+                    });
+                    await this.store.appendTaskDeliveryAttempts(deliveryDispatch.attempts);
+                    for (const attempt of deliveryDispatch.attempts) {
+                        await this.logger.info("task.delivery_attempt.recorded", {
+                            taskId: attempt.taskId,
+                            taskType: task.taskType,
+                            runId: attempt.runId ?? runId,
+                            channel: attempt.channel,
+                            deliveryStatus: attempt.status,
+                            summary: attempt.summary,
+                            ...(attempt.error ? { reason: attempt.error } : {})
+                        });
+                    }
+                    await this.logger.info("task.postrun.completed", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        durationMs: Date.now() - postRunStartedAt
+                    });
+                }
+                catch (postRunError) {
+                    await this.logger.error("task.postrun.failed", {
+                        taskId: task.taskId,
+                        taskType: task.taskType,
+                        runId,
+                        stage: postRunStage,
+                        durationMs: Date.now() - postRunStartedAt,
+                        reason: postRunError instanceof Error ? postRunError.message : String(postRunError)
+                    });
+                    throw postRunError;
+                }
+            }
+            finally {
+                if (cleanupPending && preparedContext?.cleanupRequired && preparedContext.cleanup) {
+                    try {
+                        const cleanupLogContext = {
+                            taskId: task.taskId,
+                            taskType: task.taskType
+                        };
+                        if (runId) {
+                            cleanupLogContext.runId = runId;
+                        }
+                        const visibleRepoDir = getVisibleRepoDir(preparedContext.addresses);
+                        if (visibleRepoDir) {
+                            cleanupLogContext.addressesVisibleRepoDir = visibleRepoDir;
+                        }
+                        cleanupLogContext.addressesResolvedExecutionMode = preparedContext.addresses.mode;
+                        await this.logger.info("repo.inplace.cleanup_started", cleanupLogContext);
+                        await preparedContext.cleanup();
+                        await this.logger.info("repo.inplace.cleanup_completed", cleanupLogContext);
+                    }
+                    catch (cleanupError) {
+                        finalStatus = "failed";
+                        finalFailureCategory = "environment_error";
+                        finalSummary = cleanupError instanceof Error
+                            ? `In-place cleanup failed: ${cleanupError.message}`
+                            : "In-place cleanup failed.";
+                        const cleanupFailureLogContext = {
+                            taskId: task.taskId,
+                            taskType: task.taskType,
+                            reason: finalSummary,
+                            failureCategory: finalFailureCategory
+                        };
+                        if (runId) {
+                            cleanupFailureLogContext.runId = runId;
+                        }
+                        const visibleRepoDir = getVisibleRepoDir(preparedContext.addresses);
+                        if (visibleRepoDir) {
+                            cleanupFailureLogContext.addressesVisibleRepoDir = visibleRepoDir;
+                        }
+                        cleanupFailureLogContext.addressesResolvedExecutionMode = preparedContext.addresses.mode;
+                        await this.logger.error("repo.inplace.cleanup_failed", cleanupFailureLogContext);
+                    }
+                }
+                if (preparedContext?.addresses.mode === "copy") {
+                    try {
+                        await this.cleanupCopyWorkspace(preparedContext);
+                        await this.logger.info("repo.copy.cleanup_completed", {
+                            taskId: task.taskId,
+                            taskType: task.taskType,
+                            runId,
+                            addressesWorkspaceDir: preparedContext.addresses.workspaceDir,
+                            addressesArtifactDir: preparedContext.addresses.artifactDir
+                        });
+                    }
+                    catch (cleanupError) {
+                        finalStatus = "failed";
+                        finalFailureCategory = "environment_error";
+                        finalSummary = cleanupError instanceof Error
+                            ? `Copy workspace cleanup failed: ${cleanupError.message}`
+                            : "Copy workspace cleanup failed.";
+                        await this.logger.error("repo.copy.cleanup_failed", {
+                            taskId: task.taskId,
+                            taskType: task.taskType,
+                            runId,
+                            reason: finalSummary,
+                            failureCategory: finalFailureCategory,
+                            addressesWorkspaceDir: preparedContext.addresses.workspaceDir,
+                            addressesArtifactDir: preparedContext.addresses.artifactDir
+                        });
+                    }
+                }
+            }
+        }
+    }
+    resolveTerminalLogEvent(status) {
+        if (status === "failed") {
+            return "task.failed";
+        }
+        if (status === "needs_human") {
+            return "task.needs_human";
+        }
+        return "task.completed";
+    }
+    async cleanupResidualRepoManagedTempBranches(task, repoRoot) {
+        await this.logger.info("repo.inplace.precheck.temp_branch_cleanup_started", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            runId: task.activeRunId,
+            addressesWorkspaceDir: repoRoot
+        });
+        const projectDirs = await this.listRepoManagedProjectDirs(repoRoot);
+        let cleanedBranchCount = 0;
+        for (const projectDir of projectDirs) {
+            cleanedBranchCount += await this.cleanupRepoManagedProjectBranches(task, projectDir);
+        }
+        await this.logger.info("repo.inplace.precheck.temp_branch_cleanup_completed", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            runId: task.activeRunId,
+            addressesWorkspaceDir: repoRoot,
+            projectCount: projectDirs.length,
+            cleanedBranchCount
+        });
+    }
+    async listRepoManagedProjectDirs(repoRoot) {
+        try {
+            const output = await this.readCommand("repo", ["list", "-p"], { cwd: repoRoot });
+            return output
+                .split(/\r?\n/u)
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .map((line) => join(repoRoot, line));
+        }
+        catch (error) {
+            const discoveredRepos = await this.findNestedGitRepositories(repoRoot);
+            await this.logger.warn("repo.inplace.precheck.temp_branch_cleanup_fallback", {
+                repoRoot,
+                reason: error instanceof Error ? error.message : String(error),
+                projectCount: discoveredRepos.length
+            });
+            return discoveredRepos;
+        }
+    }
+    async findNestedGitRepositories(rootPath) {
+        const discovered = new Set();
+        const visit = async (candidatePath) => {
+            try {
+                await access(join(candidatePath, ".git"));
+                discovered.add(candidatePath);
+                return;
+            }
+            catch {
+                // Continue recursive discovery.
+            }
+            const entries = await readdir(candidatePath, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith(".")) {
+                    continue;
+                }
+                await visit(join(candidatePath, entry.name));
+            }
+        };
+        await visit(rootPath);
+        discovered.delete(rootPath);
+        return [...discovered].sort((left, right) => left.localeCompare(right));
+    }
+    async cleanupRepoManagedProjectBranches(task, projectDir) {
+        const currentBranch = await this.readCommand("git", ["-C", projectDir, "rev-parse", "--abbrev-ref", "HEAD"])
+            .then((value) => value.trim())
+            .catch(() => "HEAD");
+        const branchListing = await this.readCommand("git", ["-C", projectDir, "branch", "--format=%(refname:short)"]);
+        const staleBranches = branchListing
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .filter((line) => REPO_MANAGED_TEMP_BRANCH_PATTERN.test(line));
+        if (staleBranches.length === 0) {
+            return 0;
+        }
+        let cleaned = 0;
+        for (const branchName of staleBranches) {
+            if (branchName === currentBranch) {
+                await this.detachFromResidualTempBranch(projectDir, branchName);
+            }
+            await this.runCommand("git", ["-C", projectDir, "branch", "-D", branchName]);
+            cleaned += 1;
+            await this.logger.info("repo.inplace.precheck.temp_branch_removed", {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                runId: task.activeRunId,
+                projectDir,
+                branchName,
+                wasCurrentBranch: branchName === currentBranch
+            });
+        }
+        return cleaned;
+    }
+    async detachFromResidualTempBranch(projectDir, branchName) {
+        const upstreamRef = await this.readCommand("git", ["-C", projectDir, "rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branchName}@{upstream}`])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        if (upstreamRef) {
+            await this.runCommand("git", ["-C", projectDir, "checkout", "--detach", upstreamRef]);
+            return;
+        }
+        const parentCommit = await this.readCommand("git", ["-C", projectDir, "rev-parse", `${branchName}^`])
+            .then((value) => value.trim())
+            .catch(() => undefined);
+        if (parentCommit) {
+            await this.runCommand("git", ["-C", projectDir, "checkout", "--detach", parentCommit]);
+            return;
+        }
+        throw new Error(`Unable to detach from residual temporary branch ${branchName} in ${projectDir}.`);
+    }
+    async prepareExecutionContext(task, harness, taskPackage, abortSignal) {
+        await this.logger.info("repo.inplace.precheck_started", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            runId: task.activeRunId,
+            stage: "execution_precheck"
+        });
+        const baseContext = await this.executionContextAssembler.assemble(task, harness, taskPackage);
+        if (baseContext.addresses.mode === "inplace" && await this.isRepoManagedWorkspace(baseContext.addresses.workspaceDir)) {
+            await this.cleanupResidualRepoManagedTempBranches(task, baseContext.addresses.workspaceDir);
+        }
+        const visibleRepoDir = getVisibleRepoDir(baseContext.addresses);
+        const transitionOptions = {
+            runStatus: "bootstrapping",
+            health: "waiting_start",
+            eventType: "execution.context.ready",
+            heartbeatAt: new Date().toISOString(),
+            addresses: {
+                workspaceDir: baseContext.addresses.workspaceDir,
+                ...(visibleRepoDir ? { visibleRepoDir } : {}),
+                ...(baseContext.configuredExecutionMode ? { configuredExecutionMode: baseContext.configuredExecutionMode } : {}),
+                resolvedExecutionMode: baseContext.addresses.mode
+            },
+            sandboxMode: baseContext.sandboxMode,
+            approvalPolicy: baseContext.approvalPolicy
+        };
+        if (baseContext.workspaceSkillMountDir) {
+            transitionOptions.workspaceSkillMountDir = baseContext.workspaceSkillMountDir;
+        }
+        if (baseContext.mountedSkills && baseContext.mountedSkills.length > 0) {
+            transitionOptions.mountedSkills = baseContext.mountedSkills;
+        }
+        if (task.activeRunId) {
+            transitionOptions.runId = task.activeRunId;
+        }
+        if (task.sourceEventId) {
+            transitionOptions.sourceEventId = task.sourceEventId;
+        }
+        await this.store.transitionTask(task.taskId, "preparing", `Execution context prepared at ${baseContext.addresses.workspaceDir}.`, transitionOptions);
+        await this.store.appendEvent(task.taskId, "execution.context.ready", `Execution harness resolved with workspace ${baseContext.addresses.workspaceDir}, visible repo ${visibleRepoDir ?? "hidden"}, resolved mode ${baseContext.addresses.mode}, repo memory ${baseContext.repoMemory?.exists ? "loaded" : "missing"}.`, this.buildTaskEventOptions(task.activeRunId, task.sourceEventId));
+        const executionLogContext = {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            taskRootDir: baseContext.taskRootDir,
+            addressesWorkspaceDir: baseContext.addresses.workspaceDir,
+            addressesArtifactDir: baseContext.addresses.artifactDir,
+            cleanupRequired: baseContext.cleanupRequired ?? false,
+            workspaceSkillMountDir: baseContext.workspaceSkillMountDir ?? null,
+            mountedSkillCount: baseContext.mountedSkills?.length ?? 0,
+            repoMemoryExists: baseContext.repoMemory?.exists ?? false,
+            repoMemoryFilePath: baseContext.repoMemory?.memoryFilePath ?? null
+        };
+        if (task.activeRunId) {
+            executionLogContext.runId = task.activeRunId;
+        }
+        if (visibleRepoDir) {
+            executionLogContext.addressesVisibleRepoDir = visibleRepoDir;
+        }
+        executionLogContext.addressesResolvedExecutionMode = baseContext.addresses.mode;
+        if (baseContext.configuredExecutionMode) {
+            executionLogContext.addressesConfiguredExecutionMode = baseContext.configuredExecutionMode;
+        }
+        await this.logger.info("repo.execution_mode_resolved", executionLogContext);
+        if (baseContext.addresses.mode === "inplace") {
+            await this.logger.info("repo.inplace.precheck_passed", {
+                taskId: task.taskId,
+                taskType: task.taskType,
+                runId: task.activeRunId,
+                addressesVisibleRepoDir: visibleRepoDir,
+                addressesResolvedExecutionMode: baseContext.addresses.mode
+            });
+        }
+        return {
+            ...baseContext,
+            ...(abortSignal ? { abortSignal } : {}),
+            onStatusUpdate: async (update) => {
+                const transitionOptions = {
+                    ...this.buildTaskEventOptions(task.activeRunId, task.sourceEventId),
+                    ...(update.runStatus ? { runStatus: update.runStatus } : {}),
+                    ...(update.health ? { health: update.health } : {}),
+                    ...(update.eventType ? { eventType: update.eventType } : {}),
+                    ...(update.sdkThreadId ? { sdkThreadId: update.sdkThreadId } : {}),
+                    ...(update.agentMessagePreview ? { agentMessagePreview: update.agentMessagePreview } : {}),
+                    ...(update.incrementProgressCounter ? { incrementProgressCounter: true } : {}),
+                    ...(update.incrementCommandCount ? { incrementCommandCount: true } : {}),
+                    ...(update.incrementFileChangeCount ? { incrementFileChangeCount: true } : {}),
+                    ...(update.heartbeatAt ? { heartbeatAt: update.heartbeatAt } : {})
+                };
+                await this.store.transitionTask(task.taskId, update.status, update.detail, transitionOptions);
+            }
+        };
+    }
+    // Request preparation records execution intent before the runner starts streaming SDK events.
+    async prepareExecutionRequest(task, context, taskPackage, harness) {
+        await this.store.appendEvent(task.taskId, "task.package.ready", "Task package loaded for execution.", this.buildTaskEventOptions(task.activeRunId, task.sourceEventId));
+        await context.onStatusUpdate?.({
+            status: "running",
+            detail: "Codex execution started.",
+            runStatus: "sdk_starting",
+            health: "waiting_start",
+            eventType: "execution.started",
+            heartbeatAt: new Date().toISOString()
+        });
+        await this.logger.info("task.execution.started", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            sourceEventId: task.sourceEventId,
+            runId: task.activeRunId,
+            status: "running",
+            taskRootDir: context.taskRootDir,
+            addressesWorkspaceDir: context.addresses.workspaceDir,
+            addressesArtifactDir: context.addresses.artifactDir,
+            sandboxMode: context.sandboxMode,
+            approvalPolicy: context.approvalPolicy,
+            workspaceSkillMountDir: context.workspaceSkillMountDir ?? null,
+            mountedSkillCount: context.mountedSkills?.length ?? 0,
+            repoMemoryExists: context.repoMemory?.exists ?? false,
+            repoMemoryFilePath: context.repoMemory?.memoryFilePath ?? null
+        });
+        return {
+            task: {
+                ...task,
+                status: "running"
+            },
+            taskPackage,
+            harness
+        };
+    }
+    // Orchestrator re-validates terminal task results even if the underlying runner was swapped out in tests, fallback mode, or future providers.
+    // This keeps harness delivery guarantees enforced at the scheduling boundary instead of trusting every runner implementation to do it correctly.
+    async persistRepoMemoryIfChanged(task, context) {
+        if (!context.repoMemory) {
+            return;
+        }
+        const { readFile } = await import("node:fs/promises");
+        const { createHash } = await import("node:crypto");
+        const currentContent = await readFile(context.repoMemory.memoryFilePath, "utf8").catch(() => undefined);
+        if (typeof currentContent !== "string") {
+            return;
+        }
+        const currentHash = createHash("sha256").update(currentContent, "utf8").digest("hex");
+        if (context.repoMemory.baselineContentHash && currentHash === context.repoMemory.baselineContentHash) {
+            return;
+        }
+        const persistedMemory = await this.repoMemoryService.persist({
+            taskType: context.repoMemory.taskType,
+            repoAlias: context.repoMemory.repoAlias,
+            content: currentContent,
+            sourceTaskId: task.taskId
+        });
+        context.repoMemory = persistedMemory;
+        await this.logger.writeRepoMemorySnapshot({
+            ok: true,
+            taskId: task.taskId,
+            taskType: task.taskType,
+            repoAlias: persistedMemory.repoAlias,
+            memoryFilePath: persistedMemory.memoryFilePath,
+            updatedAt: new Date().toISOString()
+        });
+        await this.logger.info("repo.memory.updated", {
+            taskId: task.taskId,
+            taskType: task.taskType,
+            runId: task.activeRunId,
+            repoAlias: context.repoMemory.repoAlias,
+            repoMemoryFilePath: context.repoMemory.memoryFilePath
+        });
+    }
+    validateTaskResultContract(result, context) {
+        if (result.status === "failed") {
+            if (!result.error) {
+                const error = new Error("Task result contract mismatch: failed result must include error.");
+                error.failureCategory = "schema_error";
+                throw error;
+            }
+            return;
+        }
+        if (!result.resultPath) {
+            const error = new Error("Task result contract mismatch: completed result must include resultPath.");
+            error.failureCategory = "schema_error";
+            throw error;
+        }
+        const resolvedArtifactDir = resolve(context.addresses.artifactDir);
+        const resolvedResultPath = resolveTaskResultPath(result.resultPath, context.addresses.artifactDir);
+        const relativeResultPath = relative(resolvedArtifactDir, resolvedResultPath);
+        const isWithinArtifactDir = relativeResultPath.length > 0 && !relativeResultPath.startsWith(`..${sep}`) && relativeResultPath !== "..";
+        if (!isWithinArtifactDir) {
+            const error = new Error(`Task result contract mismatch: resultPath ${result.resultPath} is outside artifactDir ${context.addresses.artifactDir}.`);
+            error.failureCategory = "schema_error";
+            throw error;
+        }
+    }
+    // Copy-mode tasks must land their business edits inside the task workspace and must not leak edits back into the source repository.
+    async validateExecutionIsolation(context) {
+        if (context.addresses.mode !== "copy") {
+            return;
+        }
+        const sourceRepoChanges = await this.readGitStatusEntries(context.addresses.sourceDir);
+        const sourceRepoBusinessChanges = filterBusinessChangeEntries(sourceRepoChanges);
+        if (sourceRepoBusinessChanges.length > 0) {
+            const error = new Error(`Copy-mode execution isolation failed: source repository ${context.addresses.sourceDir} was modified during task execution: ${sourceRepoBusinessChanges.map((entry) => entry.raw).join(" | ")}.`);
+            error.failureCategory = "environment_error";
+            throw error;
+        }
+    }
+    // Runtime emits a stable patch artifact whenever a copy-mode task changed business files.
+    // This keeps downstream review artifacts aligned with the actual repository diff instead of relying on result prose.
+    async writePatchArtifactIfNeeded(context) {
+        const patchSourceDir = context.addresses.workspaceDir;
+        let patchContent = "";
+        if (await this.isRepoManagedWorkspace(patchSourceDir)) {
+            const workspaceReports = await this.readRepoWorkspaceStatusReports(patchSourceDir);
+            const workspaceBusinessReports = workspaceReports
+                .map((report) => ({
+                projectPath: report.projectPath,
+                entries: filterBusinessChangeEntries(report.entries)
+            }))
+                .filter((report) => report.entries.length > 0);
+            if (workspaceBusinessReports.length === 0) {
+                return undefined;
+            }
+            patchContent = await this.buildRepoManagedBusinessPatchContent(patchSourceDir, workspaceBusinessReports);
+        }
+        else {
+            const workspaceChanges = await this.readGitStatusEntries(patchSourceDir);
+            const workspaceBusinessChanges = filterBusinessChangeEntries(workspaceChanges);
+            if (workspaceBusinessChanges.length === 0) {
+                return undefined;
+            }
+            patchContent = await this.buildBusinessPatchContent(patchSourceDir, workspaceBusinessChanges);
+        }
+        await mkdir(context.addresses.artifactDir, { recursive: true });
+        const patchArtifactPath = join(context.addresses.artifactDir, "patch.diff");
+        await writeFile(patchArtifactPath, patchContent, "utf8");
+        return patchArtifactPath;
+    }
+    async cleanupCopyWorkspace(context) {
+        if (context.addresses.mode !== "copy") {
+            return;
+        }
+        const workspaceDir = context.addresses.workspaceDir;
+        const taskRootDir = context.taskRootDir;
+        if (resolve(workspaceDir) !== resolve(taskRootDir)) {
+            return;
+        }
+        const artifactRootName = basename(dirname(context.addresses.artifactDir));
+        const artifactRootDir = join(taskRootDir, artifactRootName);
+        const tempRoot = await mkdtemp(join(dirname(taskRootDir), `${basename(taskRootDir)}-preserve-`));
+        const preservedArtifactRoot = join(tempRoot, artifactRootName);
+        const workspaceEntries = await readdir(taskRootDir, { withFileTypes: true });
+        try {
+            await rename(artifactRootDir, preservedArtifactRoot);
+            try {
+                await execFileAsync("git", ["-C", workspaceDir, "worktree", "remove", "--force", workspaceDir]);
+            }
+            catch {
+                await rm(taskRootDir, { recursive: true, force: true });
+            }
+            await mkdir(taskRootDir, { recursive: true });
+            await rename(preservedArtifactRoot, artifactRootDir);
+        }
+        finally {
+            for (const entry of workspaceEntries) {
+                if (entry.name === artifactRootName || entry.name === ".git" || entry.name === ".gitignore") {
+                    continue;
+                }
+                await rm(join(taskRootDir, entry.name), { recursive: true, force: true });
+            }
+            await rm(join(taskRootDir, ".git"), { recursive: true, force: true });
+            await rm(join(taskRootDir, ".gitignore"), { force: true });
+            await rm(tempRoot, { recursive: true, force: true });
+        }
+    }
+    async readGitStatusEntries(repoPath) {
+        const { stdout } = await execFileAsync("git", ["-C", repoPath, "status", "--porcelain=v1", "--untracked-files=all"]);
+        return parseGitStatusOutput(stdout);
+    }
+    async readRepoWorkspaceStatusReports(rootPath) {
+        const { stdout } = await execFileAsync("repo", [
+            "forall",
+            "-pc",
+            "git status --porcelain=v1 --untracked-files=all"
+        ], {
+            cwd: rootPath,
+            maxBuffer: 20 * 1024 * 1024
+        });
+        return parseRepoProjectStatusReports(stdout);
+    }
+    async buildBusinessPatchContent(repoPath, entries) {
+        const trackedPaths = collectBusinessChangePaths(entries.filter((entry) => !entry.isUntracked));
+        const untrackedPaths = collectBusinessChangePaths(entries.filter((entry) => entry.isUntracked));
+        const chunks = [];
+        if (trackedPaths.length > 0) {
+            const { stdout } = await execFileAsync("git", [
+                "-C",
+                repoPath,
+                "diff",
+                "--binary",
+                "--",
+                ...trackedPaths
+            ], { maxBuffer: 20 * 1024 * 1024 });
+            if (stdout.trim()) {
+                chunks.push(stdout.trimEnd());
+            }
+        }
+        for (const relativePath of untrackedPaths) {
+            const diff = await this.buildUntrackedFilePatch(repoPath, relativePath);
+            if (diff.trim()) {
+                chunks.push(diff.trimEnd());
+            }
+        }
+        return chunks.length > 0 ? `${chunks.join("\n")}\n` : "";
+    }
+    async buildRepoManagedBusinessPatchContent(rootPath, reports) {
+        const chunks = [];
+        for (const report of reports) {
+            const projectDir = report.projectPath === "." ? rootPath : join(rootPath, report.projectPath);
+            const projectPatch = await this.buildBusinessPatchContent(projectDir, report.entries);
+            if (!projectPatch.trim()) {
+                continue;
+            }
+            chunks.push(this.prefixPatchPaths(projectPatch, report.projectPath).trimEnd());
+        }
+        return chunks.length > 0 ? `${chunks.join("\n")}\n` : "";
+    }
+    prefixPatchPaths(patchContent, projectPath) {
+        const normalizedProjectPath = projectPath.replace(/\\/gu, "/").replace(/^\.\/+/u, "").replace(/\/$/u, "");
+        if (!normalizedProjectPath || normalizedProjectPath === ".") {
+            return patchContent;
+        }
+        const prefix = (value) => `${normalizedProjectPath}/${value}`;
+        return patchContent
+            .split(/\r?\n/gu)
+            .map((line) => {
+            if (line.startsWith("diff --git a/")) {
+                const match = line.match(/^diff --git a\/(.+) b\/(.+)$/u);
+                const fromPath = match?.[1];
+                const toPath = match?.[2];
+                if (fromPath && toPath) {
+                    return `diff --git a/${prefix(fromPath)} b/${prefix(toPath)}`;
+                }
+            }
+            if (line.startsWith("--- a/")) {
+                return `--- a/${prefix(line.slice("--- a/".length))}`;
+            }
+            if (line.startsWith("+++ b/")) {
+                return `+++ b/${prefix(line.slice("+++ b/".length))}`;
+            }
+            if (line.startsWith("rename from ")) {
+                return `rename from ${prefix(line.slice("rename from ".length))}`;
+            }
+            if (line.startsWith("rename to ")) {
+                return `rename to ${prefix(line.slice("rename to ".length))}`;
+            }
+            if (line.startsWith("copy from ")) {
+                return `copy from ${prefix(line.slice("copy from ".length))}`;
+            }
+            if (line.startsWith("copy to ")) {
+                return `copy to ${prefix(line.slice("copy to ".length))}`;
+            }
+            if (line.startsWith("Binary files a/")) {
+                const match = line.match(/^Binary files a\/(.+) and b\/(.+) differ$/u);
+                const fromPath = match?.[1];
+                const toPath = match?.[2];
+                if (fromPath && toPath) {
+                    return `Binary files a/${prefix(fromPath)} and b/${prefix(toPath)} differ`;
+                }
+            }
+            return line;
+        })
+            .join("\n");
+    }
+    async buildUntrackedFilePatch(repoPath, relativePath) {
+        try {
+            const { stdout } = await execFileAsync("git", [
+                "diff",
+                "--binary",
+                "--no-index",
+                "--",
+                "/dev/null",
+                relativePath
+            ], {
+                cwd: repoPath,
+                maxBuffer: 20 * 1024 * 1024
+            });
+            return stdout;
+        }
+        catch (error) {
+            if (typeof error === "object" && error && "stdout" in error) {
+                return String(error.stdout ?? "");
+            }
+            throw error;
+        }
+    }
+    async isRepoManagedWorkspace(rootPath) {
+        try {
+            await access(join(rootPath, ".repo"));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async runCommand(command, args, options) {
+        try {
+            await execFileAsync(command, args, {
+                cwd: options?.cwd,
+                encoding: "utf8",
+                maxBuffer: EXEC_MAX_BUFFER
+            });
+        }
+        catch (error) {
+            throw new Error(this.renderExecError(command, args, error));
+        }
+    }
+    async readCommand(command, args, options) {
+        try {
+            const { stdout, stderr } = await execFileAsync(command, args, {
+                cwd: options?.cwd,
+                encoding: "utf8",
+                maxBuffer: EXEC_MAX_BUFFER
+            });
+            return `${String(stdout)}${String(stderr)}`.trim();
+        }
+        catch (error) {
+            throw new Error(this.renderExecError(command, args, error));
+        }
+    }
+    renderExecError(command, args, error) {
+        if (error && typeof error === "object") {
+            const failure = error;
+            const output = [failure.stdout, failure.stderr].filter(Boolean).join(" ").trim();
+            return `${command} ${args.join(" ")} failed${failure.message ? `: ${failure.message}` : ""}${output ? ` | ${output}` : ""}`;
+        }
+        return `${command} ${args.join(" ")} failed: ${String(error)}`;
+    }
+    resolveFailureCategory(error) {
+        if (typeof error === "object" && error && "failureCategory" in error) {
+            const failureCategory = error.failureCategory;
+            if (failureCategory) {
+                return failureCategory;
+            }
+        }
+        if (error instanceof Error) {
+            const normalized = error.message.toLowerCase();
+            if (normalized.includes("timeout") || normalized.includes("timed out")) {
+                return "timeout";
+            }
+        }
+        if (error instanceof Error) {
+            const normalized = error.message.toLowerCase();
+            if (normalized.includes("abort") || normalized.includes("aborted")) {
+                return "unknown";
+            }
+        }
+        return "unknown";
+    }
+    buildTaskEventOptions(runId, sourceEventId) {
+        const options = {};
+        if (runId) {
+            options.runId = runId;
+        }
+        if (sourceEventId) {
+            options.sourceEventId = sourceEventId;
+        }
+        return options;
+    }
+    buildCompleteTaskRunOptions(failureCategory) {
+        if (!failureCategory) {
+            return {};
+        }
+        return { failureCategory };
+    }
+}
+//# sourceMappingURL=task-orchestrator.js.map