@sireai/optimus 0.1.1

package/dist/task-environment/runtime/optimus-runtime.js

@@ -0,0 +1,751 @@
+import { watch } from "node:fs";
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { OptimusLogger } from "../observability/logger.js";
+import { RuntimePanel } from "../observability/runtime-panel.js";
+import { SoundNotifier } from "../observability/sound-notifier.js";
+import { CliFileIntake } from "../intake/cli-file-intake.js";
+import { PollingProblemIntake } from "../intake/polling-problem-intake.js";
+import { BlockingEventQueue } from "./blocking-event-queue.js";
+import { SQLiteEventStore } from "../storage/sqlite-event-store.js";
+import { TriageRunner } from "../orchestration/triage-runner.js";
+import { SkillSyncService } from "../../problem-solving-core/codex/skill-sync-service.js";
+import { TaskAbortRegistry } from "../cancellation/task-abort-registry.js";
+import { TaskCancellationService } from "../cancellation/task-cancellation-service.js";
+import { TaskCleanupService } from "../cancellation/task-cleanup-service.js";
+import { FeishuNotifier } from "../delivery/feishu-notifier.js";
+export class OptimusRuntime {
+    store;
+    taskOrchestrator;
+    config;
+    logger;
+    get intakeStateStore() {
+        return this.eventStore;
+    }
+    // Resident runtime state.
+    eventStore;
+    eventQueue = new BlockingEventQueue();
+    cliFileIntake;
+    pollingProblemIntake;
+    triageRunner;
+    runtimePanel;
+    soundNotifier;
+    skillSyncService;
+    cleanupService;
+    cancellationService;
+    abortRegistry = new TaskAbortRegistry();
+    runningTaskIds = new Set();
+    running = false;
+    cliWatcher;
+    pollTimers = new Map();
+    maintenanceTimer;
+    cliSignalTimer;
+    lastCliSignalMtimeMs = 0;
+    eventLoopPromise;
+    backgroundDeliveryRetryLastAttemptAt = new Map();
+    // Construction wires runtime collaborators once; hot-path state lives on queue and task sets.
+    constructor(store, taskOrchestrator, config, dependencies = {}) {
+        this.store = store;
+        this.taskOrchestrator = taskOrchestrator;
+        this.config = config;
+        this.logger = new OptimusLogger(config);
+        this.runtimePanel = new RuntimePanel(config.storage.rootDir);
+        this.soundNotifier = new SoundNotifier(config);
+        this.eventStore = new SQLiteEventStore(config.storage.rootDir);
+        this.cliFileIntake = new CliFileIntake(config.intake.cliInboxDir);
+        this.pollingProblemIntake = new PollingProblemIntake(this.eventQueue, this.eventStore, config);
+        this.skillSyncService = new SkillSyncService(config);
+        this.cleanupService = new TaskCleanupService(store, config);
+        this.cancellationService = new TaskCancellationService(store, this.abortRegistry, this.cleanupService, config);
+        // Tests can inject a stubbed resident triage runner so runtime coverage stays deterministic and offline.
+        // Production still uses the real resident Codex triage runner by default.
+        this.triageRunner = dependencies.triageRunner ?? new TriageRunner(config);
+    }
+    // Runtime lifecycle: startup, steady-state processing, and shutdown signaling.
+    async start() {
+        this.runtimePanel.start();
+        await this.store.init();
+        await this.eventStore.init();
+        await this.cliFileIntake.init();
+        this.lastCliSignalMtimeMs = await this.readCliSignalMtimeMs();
+        await this.ensureRuntimeDirs();
+        await this.logger.writeEvolutionSnapshot({
+            ok: true,
+            taskType: null,
+            createdSkillIds: [],
+            updatedSkillIds: [],
+            violations: [],
+            allowedEvolutionSkillDir: null,
+            updatedAt: new Date().toISOString()
+        });
+        const skillSyncStartedAt = new Date().toISOString();
+        const installedSkills = await this.skillSyncService.syncBuiltinSkills();
+        await this.logger.writeSkillSyncSnapshot({
+            ok: true,
+            startedAt: skillSyncStartedAt,
+            finishedAt: new Date().toISOString(),
+            installedCount: installedSkills.length,
+            sharedCount: installedSkills.filter((skill) => skill.level === "shared").length,
+            taskLevelCount: installedSkills.filter((skill) => skill.level === "task").length,
+            embeddedRootDir: this.config.skills.embeddedRootDir,
+            evolutionRootDir: this.config.skills.evolutionRootDir,
+            storeDir: this.config.skills.storeDir,
+            disabledSkills: this.config.skills.disabledSkills,
+            skills: installedSkills.map((skill) => ({
+                id: skill.id,
+                level: skill.level,
+                sourceKind: skill.sourceKind,
+                version: skill.version,
+                taskTypes: skill.taskTypes,
+                storeDir: skill.storeDir
+            }))
+        });
+        await this.recoverStaleActiveTasks();
+        try {
+            await this.triageRunner.initialize();
+            await this.logger.writeTriageStatusSnapshot(this.triageRunner.getStatusSnapshot());
+        }
+        catch (error) {
+            await this.logger.writeTriageStatusSnapshot({
+                ok: false,
+                startedAt: new Date().toISOString(),
+                failureCategory: this.triageRunner.classifyFailure(error),
+                reason: error instanceof Error ? error.message : "Unknown triage startup failure"
+            });
+            throw error;
+        }
+        await this.logger.info("runtime.started", {
+            workerConcurrency: this.config.runtime.workerConcurrency,
+            startupTimeoutMs: this.config.runtime.startupTimeoutMs,
+            idleTimeoutMs: this.config.runtime.idleTimeoutMs,
+            stallWarningMs: this.config.runtime.stallWarningMs,
+            runTimeoutMs: this.config.runtime.runTimeoutMs,
+            pollingEnabled: this.config.intake.pollingEnabled,
+            pollingIntervalMs: this.config.intake.pollingIntervalMs,
+            cliWatchEnabled: this.config.intake.cliWatchEnabled,
+            cliInboxDir: this.config.intake.cliInboxDir,
+            cliSignalWatchIntervalMs: this.config.intake.cliSignalWatchIntervalMs,
+            healthLogIntervalMs: this.config.observability.healthLogIntervalMs,
+            consoleLevel: this.config.observability.consoleLevel,
+            fileLevel: this.config.observability.fileLevel
+        });
+        await this.logger.info("runtime.ready", {
+            installedSkillCount: installedSkills.length,
+            workerConcurrency: this.config.runtime.workerConcurrency,
+            cliInboxDir: this.config.intake.cliInboxDir,
+            taskHarnessRootDir: this.config.runtime.taskHarnessRootDir,
+            codexHomeDir: this.config.codex.homeDir
+        });
+        this.running = true;
+        await this.bootstrapCliInbox();
+        this.startIntakeAdapters();
+        this.startMaintenanceTimer();
+        this.eventLoopPromise = this.runEventLoop();
+        await this.eventLoopPromise;
+    }
+    // Stop pushes a sentinel event so a blocking pop can exit without busy waiting.
+    stop() {
+        this.running = false;
+        this.runtimePanel.stop();
+        this.soundNotifier.stop();
+        this.cliWatcher?.close();
+        for (const timer of this.pollTimers.values()) {
+            clearInterval(timer);
+        }
+        this.pollTimers.clear();
+        if (this.maintenanceTimer) {
+            clearInterval(this.maintenanceTimer);
+        }
+        if (this.cliSignalTimer) {
+            clearInterval(this.cliSignalTimer);
+        }
+        this.eventQueue.push(this.createRuntimeStopEvent());
+    }
+    // The event loop remains the single admission point before anything enters the scheduler queue.
+    async runEventLoop() {
+        while (this.running) {
+            const event = await this.eventQueue.pop();
+            if (event.type === "task.cancel_requested" && event.content.title === "__runtime_stop__") {
+                continue;
+            }
+            await this.handleEvent(event);
+        }
+    }
+    // Runtime first persists the raw event, then routes control events or triages business events into queued tasks.
+    async handleEvent(event) {
+        const existingTask = await this.store.findTaskBySourceEventId(event.eventId);
+        if (existingTask) {
+            await this.logger.warn("event.duplicate_ignored", {
+                eventId: event.eventId,
+                taskId: existingTask.taskId,
+                eventType: event.type,
+                source: event.content.source,
+                status: existingTask.status
+            });
+            return;
+        }
+        await this.eventStore.append(event);
+        await this.logger.info("event.received", {
+            eventId: event.eventId,
+            eventType: event.type,
+            source: event.content.source,
+            queueDepth: this.eventQueue.size()
+        });
+        if (event.type === "task.retry_requested") {
+            await this.handleRetryEvent(event);
+            return;
+        }
+        if (event.type === "task.cancel_requested") {
+            await this.handleCancelEvent(event);
+            return;
+        }
+        await this.eventStore.markTriaging(event.eventId);
+        await this.logger.info("event.triage.started", {
+            eventId: event.eventId,
+            eventType: event.type,
+            source: event.content.source,
+            stage: "triage_start"
+        });
+        let triageDecision;
+        try {
+            triageDecision = await this.triageRunner.triage(event);
+        }
+        catch (error) {
+            const failureCategory = this.triageRunner.classifyFailure(error);
+            await this.eventStore.completeTriage(event.eventId, "failed");
+            await this.logger.error("triage.failed", {
+                eventId: event.eventId,
+                eventType: event.type,
+                source: event.content.source,
+                failureCategory,
+                reason: error instanceof Error ? error.message : "Unknown triage failure"
+            });
+            return;
+        }
+        if (triageDecision.decision === "rejected") {
+            await this.eventStore.completeTriage(event.eventId, "rejected", triageDecision);
+            await this.logger.warn("triage.rejected", {
+                eventId: event.eventId,
+                reason: triageDecision.reason,
+                summary: triageDecision.summary
+            });
+            return;
+        }
+        if (triageDecision.taskPackage.idempotencyKey) {
+            const duplicatedTask = await this.store.findTaskByIdempotencyKey(triageDecision.taskPackage.idempotencyKey);
+            if (duplicatedTask) {
+                await this.eventStore.completeTriage(event.eventId, "accepted", triageDecision);
+                await this.logger.warn("task.idempotent_duplicate_ignored", {
+                    eventId: event.eventId,
+                    taskId: duplicatedTask.taskId,
+                    taskType: duplicatedTask.taskType,
+                    status: duplicatedTask.status,
+                    idempotencyKey: triageDecision.taskPackage.idempotencyKey
+                });
+                return;
+            }
+        }
+        const task = await this.store.createTaskFromPackage(triageDecision.taskPackage, { sourceEventId: event.eventId });
+        await this.eventStore.completeTriage(event.eventId, "accepted", triageDecision);
+        await this.logger.info("event.triage.finished", {
+            eventId: event.eventId,
+            eventType: event.type,
+            source: event.content.source,
+            stage: "triage_finish",
+            status: "accepted",
+            taskId: task.taskId,
+            taskType: task.taskType
+        });
+        await this.logger.info("task.received", {
+            eventId: event.eventId,
+            taskId: task.taskId,
+            taskPackageId: task.taskPackageId,
+            taskType: task.taskType,
+            status: task.status
+        });
+        await this.dispatchAvailableTasks();
+    }
+    async handleRetryEvent(event) {
+        const retryTargetId = event.content.sourceRef?.trim();
+        if (!retryTargetId) {
+            await this.logger.warn("task.retry_ignored", {
+                eventId: event.eventId,
+                reason: "missing_source_ref"
+            });
+            return;
+        }
+        const retriedTask = await this.store.retryTask(retryTargetId, event.eventId);
+        if (!retriedTask) {
+            await this.logger.warn("task.retry_ignored", {
+                eventId: event.eventId,
+                taskId: retryTargetId,
+                reason: "task_not_retryable"
+            });
+            return;
+        }
+        await this.logger.info("task.retry_enqueued", {
+            eventId: event.eventId,
+            taskId: retriedTask.taskId,
+            status: retriedTask.status
+        });
+        await this.dispatchAvailableTasks();
+    }
+    async handleCancelEvent(event) {
+        const cancelTargetId = event.content.sourceRef?.trim();
+        if (!cancelTargetId) {
+            await this.logger.warn("task.cancel_ignored", {
+                eventId: event.eventId,
+                reason: "missing_source_ref"
+            });
+            return;
+        }
+        const cancelResult = await this.cancellationService.requestCancel({
+            eventId: event.eventId,
+            taskId: cancelTargetId,
+            reason: event.content.description?.trim() || `Manual cancellation requested for ${cancelTargetId}.`,
+            cancelSource: this.resolveCancelSource(event),
+            force: event.content.metadata?.forceCancel === true,
+            keepArtifacts: event.content.metadata?.keepArtifacts === true
+        });
+        if (!cancelResult) {
+            await this.logger.warn("task.cancel_ignored", {
+                eventId: event.eventId,
+                taskId: cancelTargetId,
+                reason: "task_not_cancelable"
+            });
+        }
+    }
+    // Dispatch respects global concurrency and lets the store arbitrate task claiming.
+    async dispatchAvailableTasks() {
+        const availableSlots = this.config.runtime.workerConcurrency - this.runningTaskIds.size;
+        if (availableSlots <= 0) {
+            return;
+        }
+        const tasks = await this.store.listRunnableTasks({
+            limit: availableSlots,
+            excludeTaskIds: Array.from(this.runningTaskIds)
+        });
+        for (const task of tasks) {
+            const claimedTask = await this.store.claimTask(task.taskId);
+            if (!claimedTask) {
+                continue;
+            }
+            this.runningTaskIds.add(claimedTask.taskId);
+            void this.runClaimedTask(claimedTask);
+        }
+    }
+    // Claimed tasks are still run under the orchestrator; runtime only manages queueing and concurrency.
+    async runClaimedTask(task) {
+        await this.store.appendEvent(task.taskId, "runtime.dispatch", "Task picked by background runtime worker.", this.buildTaskEventOptions(task.activeRunId, task.sourceEventId));
+        await this.logger.info("task.dispatched", {
+            taskId: task.taskId,
+            stage: "dispatch",
+            taskType: task.taskType,
+            sourceEventId: task.sourceEventId,
+            runId: task.activeRunId,
+            status: task.status,
+            activeRunId: task.activeRunId,
+            runCount: task.runCount,
+            activeWorkers: this.runningTaskIds.size
+        });
+        const abortController = new AbortController();
+        const unregisterAbortHandle = task.activeRunId
+            ? this.abortRegistry.register({
+                taskId: task.taskId,
+                runId: task.activeRunId,
+                controller: abortController
+            })
+            : undefined;
+        try {
+            await this.taskOrchestrator.run({
+                ...task,
+                ...(task.activeRunId ? { abortSignal: abortController.signal } : {})
+            });
+        }
+        finally {
+            unregisterAbortHandle?.();
+            const latestTask = await this.store.getTask(task.taskId);
+            if (latestTask?.status === "canceled") {
+                await this.cleanupService.cleanupCanceledTask({
+                    taskId: task.taskId,
+                    cancelSource: "runtime"
+                });
+            }
+            this.runningTaskIds.delete(task.taskId);
+            await this.dispatchAvailableTasks();
+        }
+    }
+    // Manual and automated intake adapters feed one shared runtime queue.
+    startIntakeAdapters() {
+        if (this.config.intake.cliWatchEnabled) {
+            try {
+                this.cliWatcher = watch(this.cliFileIntake.getSignalPath(), () => {
+                    void this.drainCliInbox();
+                });
+                this.cliWatcher.on("error", (error) => {
+                    void this.handleCliWatcherFailure(error);
+                });
+            }
+            catch (error) {
+                void this.handleCliWatcherFailure(error);
+            }
+        }
+        const pollingSources = this.pollingProblemIntake.listConfiguredSources();
+        for (const source of pollingSources) {
+            const intervalMs = source.intervalMs ?? this.config.intake.pollingIntervalMs;
+            const timer = setInterval(() => {
+                void this.pollQualityProblems(source.id);
+            }, intervalMs);
+            this.pollTimers.set(source.id, timer);
+            if (source.enabled) {
+                void this.pollQualityProblems(source.id);
+            }
+        }
+    }
+    // Maintenance stays off the hot path so health work never blocks dispatch.
+    startMaintenanceTimer() {
+        this.maintenanceTimer = setInterval(() => {
+            void this.runMaintenanceCycle();
+        }, this.config.observability.healthLogIntervalMs);
+    }
+    async bootstrapCliInbox() {
+        await this.drainCliInbox();
+    }
+    // CLI inbox files are normalized into runtime events and removed after successful enqueue.
+    async drainCliInbox() {
+        const files = await this.cliFileIntake.listInboxFiles();
+        for (const file of files) {
+            try {
+                const event = await this.cliFileIntake.readEventFromFile(file);
+                this.eventQueue.push(event);
+                await this.cliFileIntake.deleteInboxFile(file);
+                await this.logger.info("intake.cli.accepted", {
+                    eventId: event.eventId,
+                    eventType: event.type,
+                    source: event.content.source,
+                    queueDepth: this.eventQueue.size()
+                });
+            }
+            catch (error) {
+                await this.logger.error("intake.cli.failed", {
+                    file,
+                    reason: error instanceof Error ? error.message : "Unknown inbox parse error"
+                });
+            }
+        }
+    }
+    // When fs watching fails, runtime degrades to signal polling instead of dropping intake.
+    async handleCliWatcherFailure(error) {
+        this.cliWatcher?.close();
+        this.cliWatcher = undefined;
+        if (!this.cliSignalTimer) {
+            this.cliSignalTimer = setInterval(() => {
+                void this.pollCliSignal();
+            }, this.config.intake.cliSignalWatchIntervalMs);
+        }
+        await this.logger.warn("intake.cli.watch_fallback", {
+            reason: error instanceof Error ? error.message : "Unknown cli watcher error",
+            fallbackIntervalMs: this.config.intake.cliSignalWatchIntervalMs
+        });
+    }
+    async pollCliSignal() {
+        const currentMtimeMs = await this.readCliSignalMtimeMs();
+        if (currentMtimeMs <= this.lastCliSignalMtimeMs) {
+            return;
+        }
+        this.lastCliSignalMtimeMs = currentMtimeMs;
+        await this.drainCliInbox();
+    }
+    async readCliSignalMtimeMs() {
+        const metadata = await stat(this.cliFileIntake.getSignalPath());
+        return metadata.mtimeMs;
+    }
+    resolveCancelSource(event) {
+        if (event.content.source === "system") {
+            return "runtime";
+        }
+        if (event.content.source === "api") {
+            return "api";
+        }
+        return "cli";
+    }
+    async resolveRunnablePoller(pollerId) {
+        const source = this.pollingProblemIntake.listConfiguredSources().find((candidate) => candidate.id === pollerId);
+        if (!source || !source.enabled) {
+            return undefined;
+        }
+        const state = (await this.eventStore.listPollerStates()).find((candidate) => candidate.pollerId === pollerId);
+        if (state && !state.enabled) {
+            return undefined;
+        }
+        return source;
+    }
+    async runPollerOnce(pollerId) {
+        await this.pollQualityProblems(pollerId);
+    }
+    async pollQualityProblems(pollerId) {
+        const source = await this.resolveRunnablePoller(pollerId);
+        if (!source) {
+            return;
+        }
+        const intervalMs = source.intervalMs ?? this.config.intake.pollingIntervalMs;
+        await this.eventStore.recordPollerRunStarted(source, intervalMs);
+        try {
+            const result = await this.pollingProblemIntake.pollAndEnqueue(source);
+            await this.eventStore.recordPollerRunSucceeded(source, intervalMs, result);
+            await this.logger.info("intake.poll.tick", {
+                pollerId: source.id,
+                pollingIntervalMs: intervalMs,
+                pollingProvider: source.type,
+                acceptedCount: result.acceptedCount,
+                duplicateCount: result.duplicateCount,
+                updatedCount: result.updatedCount,
+                skippedCount: result.skippedCount,
+                checkpoint: result.checkpoint ? JSON.stringify(result.checkpoint) : undefined,
+                eventType: source.eventType ?? "problem.discovered",
+                queueDepth: this.eventQueue.size()
+            });
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : "Unknown polling failure";
+            await this.eventStore.recordPollerRunFailed(source, intervalMs, reason);
+            await this.logger.error("intake.poll.failed", {
+                pollerId: source.id,
+                pollingIntervalMs: intervalMs,
+                pollingProvider: source.type,
+                eventType: source.eventType ?? "problem.discovered",
+                reason
+            });
+        }
+    }
+    async recoverStaleActiveTasks() {
+        const recovered = await this.store.recoverActiveTasks();
+        if (recovered.length === 0) {
+            return;
+        }
+        await this.logger.warn("runtime.recovery.requeued", {
+            recoveredCount: recovered.length,
+            recoveredTaskIds: recovered.map((item) => item.taskId),
+            recoveredRunIds: recovered.map((item) => item.runId)
+        });
+    }
+    // Active run monitoring upgrades raw progress fields into health judgments for the scheduler.
+    async monitorActiveRuns() {
+        const runs = await this.store.listTaskRuns();
+        const activeRuns = runs.filter((run) => !run.endedAt);
+        const now = Date.now();
+        for (const run of activeRuns) {
+            const lastSignalAt = Date.parse(run.lastEventAt ?? run.startedAt);
+            const elapsedMs = now - Date.parse(run.startedAt);
+            const idleMs = Number.isNaN(lastSignalAt) ? 0 : now - lastSignalAt;
+            if (run.status === "cancel_requested") {
+                this.abortRegistry.cancelRun(run.runId, `Cancellation requested for ${run.taskId}.`);
+                continue;
+            }
+            if (run.status === "timed_out") {
+                this.abortRegistry.cancelRun(run.runId, `Run previously marked timed_out for ${run.taskId}.`);
+                continue;
+            }
+            if (elapsedMs >= this.config.runtime.runTimeoutMs) {
+                this.abortRegistry.cancelRun(run.runId, `Run exceeded hard timeout after ${elapsedMs}ms.`);
+                await this.store.updateTaskRun(run.taskId, run.runId, {
+                    runStatus: "timed_out",
+                    health: "timed_out",
+                    failureCategory: "timeout",
+                    summary: "Run exceeded the configured hard runtime timeout.",
+                    eventType: "runtime.timeout.hard"
+                });
+                const task = await this.store.getTask(run.taskId);
+                if (task?.activeRunId === run.runId) {
+                    await this.logger.error("task.timed_out", {
+                        taskId: run.taskId,
+                        runId: run.runId,
+                        durationMs: elapsedMs,
+                        timeoutKind: "hard_timeout",
+                        failureCategory: "timeout"
+                    });
+                }
+                continue;
+            }
+            const waitingForFirstSignal = run.status === "leased" || run.status === "bootstrapping" || run.status === "sdk_starting";
+            if (waitingForFirstSignal && elapsedMs >= this.config.runtime.startupTimeoutMs) {
+                this.abortRegistry.cancelRun(run.runId, `Run exceeded startup timeout after ${elapsedMs}ms without first progress signal.`);
+                await this.store.updateTaskRun(run.taskId, run.runId, {
+                    runStatus: "timed_out",
+                    health: "timed_out",
+                    failureCategory: "timeout",
+                    summary: "Run exceeded the configured startup timeout before the first progress signal.",
+                    eventType: "runtime.timeout.startup"
+                });
+                const task = await this.store.getTask(run.taskId);
+                if (task?.activeRunId === run.runId) {
+                    await this.logger.error("task.timed_out", {
+                        taskId: run.taskId,
+                        runId: run.runId,
+                        durationMs: elapsedMs,
+                        timeoutKind: "startup_timeout",
+                        failureCategory: "timeout"
+                    });
+                }
+                continue;
+            }
+            if (!waitingForFirstSignal && idleMs >= this.config.runtime.idleTimeoutMs) {
+                this.abortRegistry.cancelRun(run.runId, `Run exceeded idle timeout after ${idleMs}ms without new progress events.`);
+                await this.store.updateTaskRun(run.taskId, run.runId, {
+                    runStatus: "timed_out",
+                    health: "timed_out",
+                    failureCategory: "timeout",
+                    summary: "Run exceeded the configured idle timeout without new progress events.",
+                    eventType: "runtime.timeout.idle"
+                });
+                const task = await this.store.getTask(run.taskId);
+                if (task?.activeRunId === run.runId) {
+                    await this.logger.error("task.timed_out", {
+                        taskId: run.taskId,
+                        runId: run.runId,
+                        durationMs: elapsedMs,
+                        idleMs,
+                        timeoutKind: "idle_timeout",
+                        failureCategory: "timeout"
+                    });
+                }
+                continue;
+            }
+            if (!waitingForFirstSignal && idleMs >= this.config.runtime.stallWarningMs) {
+                await this.store.updateTaskRun(run.taskId, run.runId, {
+                    health: "suspected_stall",
+                    eventType: "runtime.stall_warning"
+                });
+                continue;
+            }
+            if (run.health !== "healthy_running" && run.health !== "waiting_start") {
+                await this.store.updateTaskRun(run.taskId, run.runId, {
+                    health: run.status === "sdk_starting" || run.status === "bootstrapping" || run.status === "leased"
+                        ? "waiting_start"
+                        : "healthy_running",
+                    eventType: "runtime.health_refresh"
+                });
+            }
+        }
+    }
+    async runMaintenanceCycle() {
+        await this.logHealth();
+        await this.retryFailedDeliveryAttempts();
+    }
+    async retryFailedDeliveryAttempts() {
+        if (!this.config.delivery.retry.backgroundEnabled) {
+            return;
+        }
+        const retryableAttempts = await this.store.listRetryableDeliveryAttempts(this.config.delivery.retry.backgroundScanLimit);
+        for (const attempt of retryableAttempts) {
+            const retryKey = `${attempt.taskId}:${attempt.channel}`;
+            const now = Date.now();
+            const lastAttemptAt = this.backgroundDeliveryRetryLastAttemptAt.get(retryKey) ?? 0;
+            if (now - lastAttemptAt < this.config.delivery.retry.backgroundCooldownMs) {
+                continue;
+            }
+            this.backgroundDeliveryRetryLastAttemptAt.set(retryKey, now);
+            await this.retryFailedDeliveryAttempt(attempt);
+        }
+    }
+    async retryFailedDeliveryAttempt(attempt) {
+        if (attempt.channel !== "feishu") {
+            return;
+        }
+        const bundle = await this.store.getLatestTaskDeliveryBundle(attempt.taskId);
+        if (!bundle) {
+            await this.logger.warn("task.delivery_retry.skipped", {
+                taskId: attempt.taskId,
+                channel: attempt.channel,
+                reason: "bundle_missing"
+            });
+            return;
+        }
+        const publicationAttempts = await this.store.listTaskPublicationAttempts(attempt.taskId);
+        const notifier = new FeishuNotifier({
+            publicationAttempts,
+            retryPolicy: this.config.delivery.retry
+        });
+        const retriedAttempts = await notifier.dispatch(bundle);
+        await this.store.appendTaskDeliveryAttempts(retriedAttempts);
+        const success = retriedAttempts.every((candidate) => candidate.status === "dispatched");
+        await this.logger.info("task.delivery_retry.executed", {
+            taskId: attempt.taskId,
+            channel: attempt.channel,
+            status: success ? "dispatched" : "failed",
+            retriedAttemptCount: retriedAttempts.length,
+            previousAttemptCreatedAt: attempt.createdAt,
+            ...(attempt.error ? { previousError: attempt.error } : {})
+        });
+    }
+    // Health logs summarize runtime pressure and state distribution for operators.
+    async logHealth() {
+        await this.monitorActiveRuns();
+        const tasks = await this.store.listTasks();
+        const summary = tasks.reduce((accumulator, task) => {
+            accumulator[task.status] = (accumulator[task.status] ?? 0) + 1;
+            return accumulator;
+        }, {});
+        const runs = await this.store.listTaskRuns();
+        const activeRuns = runs.filter((run) => !run.endedAt);
+        const stalledRuns = activeRuns.filter((run) => run.health === "suspected_stall");
+        const recentTasks = tasks
+            .slice(-this.config.observability.maxRecentTasksInHealthLog)
+            .map((task) => `${task.taskId}:${task.status}:${task.activeRunId ?? "-"}`)
+            .join(",");
+        await this.logger.info("runtime.health", {
+            totalTasks: tasks.length,
+            queueDepth: this.eventQueue.size(),
+            activeWorkers: this.runningTaskIds.size,
+            activeRuns: activeRuns.length,
+            stalledRuns: stalledRuns.length,
+            queued: summary.queued ?? 0,
+            preparing: summary.preparing ?? 0,
+            running: summary.running ?? 0,
+            patchGenerated: summary.patch_generated ?? 0,
+            validating: summary.validating ?? 0,
+            needsHuman: summary.needs_human ?? 0,
+            failed: summary.failed ?? 0,
+            completed: summary.completed ?? 0,
+            recentTasks
+        });
+    }
+    createRuntimeStopEvent() {
+        return {
+            eventId: `event-stop-${Date.now()}`,
+            type: "task.cancel_requested",
+            content: {
+                source: "system",
+                title: "__runtime_stop__",
+                description: "runtime stop signal",
+                content: "runtime stop signal"
+            },
+            createdAt: new Date().toISOString()
+        };
+    }
+    async ensureRuntimeDirs() {
+        await rm(join(this.config.storage.rootDir, "data", "tasks.db"), { force: true });
+        await mkdir(join(this.config.storage.rootDir, "artifacts"), { recursive: true });
+        await mkdir(join(this.config.storage.rootDir, "workspaces"), { recursive: true });
+        await mkdir(this.config.skills.evolutionRootDir, { recursive: true });
+    }
+    buildTaskEventOptions(runId, sourceEventId) {
+        const options = {};
+        if (runId) {
+            options.runId = runId;
+        }
+        if (sourceEventId) {
+            options.sourceEventId = sourceEventId;
+        }
+        return options;
+    }
+    // Manual submission writes into the same inbox path consumed by the resident runtime.
+    async writeManualSubmission(payload) {
+        await this.cliFileIntake.init();
+        const path = this.cliFileIntake.buildInboxFilePath();
+        await writeFile(path, JSON.stringify(payload, null, 2), "utf8");
+        await this.cliFileIntake.touchSignal();
+        return path;
+    }
+}
+//# sourceMappingURL=optimus-runtime.js.map