agentic-orchestrator 0.1.27 → 0.2.0

package/dist/apps/control-plane/cli/dashboard-runtime-runner.js

@@ -0,0 +1,724 @@
+import path from 'node:path';
+import { AopKernel } from '../core/kernel.js';
+import { TOOLS } from '../core/constants.js';
+import { atomicWriteJson, ensureDir, nowIso, readJson, withFileLock } from '../core/fs.js';
+import { createToolingRuntime, resolveToolClient } from '../mcp/runtime-factory.js';
+import { MergeCommandHandler } from './merge-command-handler.js';
+import { ResumeCommandHandler } from './resume-command-handler.js';
+import { RetryCommandHandler } from './retry-command-handler.js';
+import { mergeFailureRequiresRepairLoop, shouldAttemptAutoResumeAfterRetry, } from './retry-resume-decision.js';
+import { callCliTool } from './tooling.js';
+import { CliCommand } from './types.js';
+import { computeInstanceId, defaultConfigPath, } from '../application/services/instance-isolation-service.js';
+import { DefaultWorkerProviderFactory, resolveWorkerProviderMode, resolveWorkerProviderObservability, resolveWorkerProviderPolicy, resolveWorkerProviderRuntime, resolvePromptOverlayDir, } from '../providers/worker-provider-factory.js';
+import { SupervisorRuntime } from '../supervisor/runtime.js';
+import { NullWorkerProvider, resolveProviderSelection, resolveProviderSelectionsByRole, } from '../providers/providers.js';
+const COMMAND_POLL_INTERVAL_MS = 250;
+const COMMAND_LOCK_TIMEOUT_MS = 5_000;
+const COMPLETED_COMMAND_RETENTION = 50;
+const SAME_INSTANCE_HEARTBEAT_GRACE_MS = 120_000;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asString(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizeLaunchFeatures(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const normalized = value
+        .map((item) => {
+        const record = asRecord(item);
+        const featureId = asString(record.feature_id);
+        const specPath = asString(record.spec_path);
+        return featureId && specPath ? { feature_id: featureId, spec_path: specPath } : null;
+    })
+        .filter((item) => item !== null);
+    const unique = new Map();
+    for (const item of normalized) {
+        unique.set(item.feature_id, item);
+    }
+    return [...unique.values()].sort((left, right) => left.feature_id.localeCompare(right.feature_id));
+}
+function isToolResponse(value) {
+    return value !== null && typeof value === 'object' && typeof asRecord(value).ok === 'boolean';
+}
+function normalizeToolResponse(value) {
+    if (isToolResponse(value)) {
+        return value;
+    }
+    return {
+        ok: false,
+        error: {
+            code: 'dashboard_runtime_invalid_response',
+            message: 'Dashboard runtime command returned an invalid response envelope',
+        },
+    };
+}
+function normalizeError(error, fallbackCode = 'dashboard_runtime_failed') {
+    if (error instanceof Error) {
+        return {
+            ok: false,
+            error: {
+                code: fallbackCode,
+                message: error.message,
+            },
+        };
+    }
+    return {
+        ok: false,
+        error: {
+            code: fallbackCode,
+            message: typeof error === 'string' ? error : 'Dashboard runtime command failed',
+        },
+    };
+}
+function emptyCommandSnapshot(instanceId) {
+    return {
+        version: 1,
+        instance_id: instanceId,
+        updated_at: nowIso(),
+        items: [],
+    };
+}
+function pruneCompletedItems(items) {
+    const pending = items.filter((item) => item.status === 'pending' || item.status === 'processing');
+    const completed = items
+        .filter((item) => item.status === 'completed' || item.status === 'failed')
+        .sort((left, right) => right.requested_at.localeCompare(left.requested_at))
+        .slice(0, COMPLETED_COMMAND_RETENTION);
+    return [...pending, ...completed].sort((left, right) => left.requested_at.localeCompare(right.requested_at));
+}
+function isConflictPreparedForHandoff(response) {
+    return (response.ok === false &&
+        response.error?.code === 'reconciliation_failed' &&
+        response.error.details?.conflict_worktree_prepared === true);
+}
+function isConflictAlreadyDispatched(response) {
+    return (isConflictPreparedForHandoff(response) &&
+        response.error?.details?.dispatched_to_reconciler === true);
+}
+function markConflictDispatched(response) {
+    if (!isConflictPreparedForHandoff(response) || !response.error) {
+        return response;
+    }
+    return {
+        ...response,
+        error: {
+            ...response.error,
+            details: {
+                ...response.error.details,
+                dispatched_to_reconciler: true,
+            },
+        },
+    };
+}
+export function buildResumeAcceptedResponse(params) {
+    return {
+        ok: true,
+        data: {
+            command: 'resume',
+            feature_id: params.featureId,
+            handoff_started: true,
+            handoff_target: 'runtime',
+            started: params.started,
+            already_running: params.alreadyRunning,
+        },
+    };
+}
+export function buildRuntimeBusyResponse(activeFeatureId) {
+    return buildRuntimeBusyResponseForCommand('feature.resume', activeFeatureId);
+}
+function buildRuntimeBusyResponseForCommand(command, activeFeatureId) {
+    const action = command === 'launch.submit'
+        ? `starting execution for ${activeFeatureId}`
+        : `resuming ${activeFeatureId}`;
+    return {
+        ok: false,
+        error: {
+            code: 'dashboard_runtime_busy',
+            message: `Dashboard runtime is busy ${action}`,
+            details: {
+                active_feature_id: activeFeatureId,
+                active_command: command,
+                retryable: true,
+                requires_human: false,
+            },
+        },
+    };
+}
+export function buildReconcilerHandoffResponse(featureId, mergeResponse, autoResume) {
+    return {
+        ok: true,
+        data: {
+            feature_id: featureId,
+            handoff_started: true,
+            handoff_target: 'reconciler',
+            merge: mergeResponse,
+            auto_resume: autoResume,
+        },
+    };
+}
+function buildLaunchAcceptedResponse(params) {
+    return {
+        ok: true,
+        data: {
+            command: 'launch.submit',
+            mode: 'runtime_start',
+            run_id: params.runId,
+            feature_id: params.featureIds[0] ?? 'launch',
+            feature_ids: params.featureIds,
+            handoff_started: true,
+            handoff_target: 'runtime',
+            started: params.started,
+            already_running: params.alreadyRunning,
+            request_status: 'started',
+            requested_features: params.featureIds.map((featureId) => ({
+                feature_id: featureId,
+                spec_path: `.aop/features/${featureId}/spec.md`,
+            })),
+        },
+    };
+}
+function buildReconcilerDispatchFailedResponse(featureId, details = {}) {
+    return {
+        ok: false,
+        error: {
+            code: 'reconciliation_failed',
+            message: 'Prepared reconciler handoff could not be dispatched to the active run',
+            details: {
+                feature_id: featureId,
+                dispatched_to_reconciler: false,
+                retryable: true,
+                requires_human: true,
+                ...details,
+            },
+        },
+    };
+}
+export class DashboardRuntimeRunner {
+    repoRoot;
+    instanceId;
+    env;
+    queuePath;
+    queueLockPath;
+    statePath;
+    kernel;
+    startedAt;
+    toolClientPromise = null;
+    stopping = false;
+    currentCommand = null;
+    backgroundCommand = null;
+    lastBackgroundError = null;
+    backgroundTaskFeatureId = null;
+    backgroundTaskCommand = null;
+    backgroundTaskPromise = null;
+    constructor(input) {
+        this.repoRoot = input.repoRoot;
+        this.instanceId = input.instanceId ?? computeInstanceId(defaultConfigPath(input.repoRoot));
+        this.env = input.env ?? process.env;
+        const runtimeRoot = path.join(this.repoRoot, '.aop', 'runtime', this.instanceId);
+        this.queuePath = path.join(runtimeRoot, 'dashboard-runtime-commands.json');
+        this.queueLockPath = path.join(runtimeRoot, '.dashboard-runtime-commands.lock');
+        this.statePath = path.join(runtimeRoot, 'dashboard-runtime-state.json');
+        this.kernel = new AopKernel(this.repoRoot, this.instanceId);
+        this.startedAt = nowIso();
+    }
+    async start() {
+        await ensureDir(path.dirname(this.queuePath));
+        await this.kernel.ensureLoaded();
+        await this.getToolClient();
+        await this.ensureCommandSnapshot();
+        await this.writeState('running');
+        this.registerSignalHandlers();
+        while (!this.stopping) {
+            await this.processNextCommand();
+            await this.writeState('running');
+            await sleep(COMMAND_POLL_INTERVAL_MS);
+        }
+        await this.writeState('stopped');
+    }
+    async waitForIdle() {
+        if (this.backgroundTaskPromise !== null) {
+            await this.backgroundTaskPromise;
+        }
+    }
+    async handleCommand(item) {
+        if (item.command === 'review.approve') {
+            return await this.handleApprove(item.feature_id, item.args);
+        }
+        if (item.command === 'feature.resume') {
+            if (await this.hasFreshActiveRun()) {
+                return await this.executeResumeCommand(item.feature_id);
+            }
+            const launch = await this.startBackgroundResume(item.feature_id);
+            if (!launch.ok) {
+                return launch;
+            }
+            return buildResumeAcceptedResponse({
+                featureId: item.feature_id,
+                started: launch.data.started,
+                alreadyRunning: launch.data.already_running,
+            });
+        }
+        if (item.command === 'launch.submit') {
+            return await this.handleLaunchSubmit(item.feature_id, item.args);
+        }
+        return {
+            ok: false,
+            error: {
+                code: 'dashboard_runtime_unsupported_command',
+                message: `Unsupported dashboard runtime command: ${String(item.command)}`,
+            },
+        };
+    }
+    async hasFreshActiveRun() {
+        const runtimeSessions = await this.kernel.getRuntimeSessions();
+        if (runtimeSessions.run_id === 'none' || runtimeSessions.owner_instance_id === 'none') {
+            return false;
+        }
+        if (this.kernel.isRunLeaseFresh(runtimeSessions)) {
+            return true;
+        }
+        if (runtimeSessions.owner_instance_id !== this.instanceId) {
+            return false;
+        }
+        const heartbeat = Date.parse(runtimeSessions.last_heartbeat_at);
+        return Number.isFinite(heartbeat) && heartbeat + SAME_INSTANCE_HEARTBEAT_GRACE_MS > Date.now();
+    }
+    async executeResumeCommand(featureId) {
+        const toolClient = await this.getToolClient();
+        const response = normalizeToolResponse(await new ResumeCommandHandler().execute({
+            repoRoot: this.repoRoot,
+            env: this.env,
+            runId: `run:dashboard-runtime:${Date.now()}`,
+            transport: 'inprocess',
+            options: {
+                command: CliCommand.Resume,
+                feature_id: featureId,
+                takeover_stale_run: true,
+            },
+            kernel: this.kernel,
+            toolClient,
+        }));
+        if (!response.ok) {
+            return response;
+        }
+        // Best-effort redrive; ignore failures — supervisor handles reconciliation in its coordinator cycle
+        await this.redrivePreparedReconcilerConflict(featureId);
+        return response;
+    }
+    async attemptMergeRepairChain(featureId, mergeResponse) {
+        try {
+            const toolClient = await this.getToolClient();
+            const runId = `run:dashboard-runtime:${Date.now()}`;
+            const retryHandler = new RetryCommandHandler(toolClient, runId);
+            const retryResult = normalizeToolResponse(await retryHandler.execute({
+                command: CliCommand.Retry,
+                feature_id: featureId,
+                no_resume: true,
+            }));
+            const decision = shouldAttemptAutoResumeAfterRetry(retryResult);
+            if (decision.attempt) {
+                const resumeResult = await this.executeResumeCommand(featureId);
+                return {
+                    ok: true,
+                    data: {
+                        merge: mergeResponse,
+                        retry: retryResult.data,
+                        auto_resume: resumeResult.data,
+                    },
+                };
+            }
+            return {
+                ok: true,
+                data: {
+                    merge: mergeResponse,
+                    retry: retryResult.data,
+                },
+            };
+        }
+        catch {
+            // If repair chain fails, return the original merge response
+            return mergeResponse;
+        }
+    }
+    createKernelControlProvider() {
+        try {
+            const selection = resolveProviderSelection({
+                cli: {},
+                env: this.env,
+                agentsConfig: this.kernel.getAgentsConfig(),
+            });
+            const runtimeConfig = resolveWorkerProviderRuntime(this.kernel.getAgentsConfig().runtime);
+            const policySnapshot = this.kernel.getPolicySnapshot();
+            const executionPolicy = policySnapshot.execution && typeof policySnapshot.execution === 'object'
+                ? policySnapshot.execution
+                : null;
+            const observabilityPolicy = policySnapshot.observability && typeof policySnapshot.observability === 'object'
+                ? policySnapshot.observability
+                : null;
+            const overlayDir = resolvePromptOverlayDir(this.repoRoot, this.kernel.getAgentsConfig().runtime?.prompt_overlay_dir);
+            return new DefaultWorkerProviderFactory().create({
+                selection,
+                mode: resolveWorkerProviderMode(undefined, this.kernel.getAgentsConfig().runtime?.worker_provider_mode, 'live'),
+                context: 'resume',
+                policy: resolveWorkerProviderPolicy(executionPolicy),
+                observability: resolveWorkerProviderObservability(observabilityPolicy),
+                runtime: runtimeConfig,
+                repoRoot: this.repoRoot,
+                overlayDir,
+            });
+        }
+        catch {
+            return new NullWorkerProvider({
+                provider: 'custom',
+                model: 'dashboard-runtime',
+                provider_config_env: null,
+                provider_config_ref: null,
+            });
+        }
+    }
+    async initializeToolClient() {
+        this.kernel.setProvider(this.createKernelControlProvider());
+        const tooling = await createToolingRuntime(this.repoRoot, this.kernel, {
+            generateToolsMarkdown: false,
+        });
+        return resolveToolClient('inprocess', tooling);
+    }
+    async getToolClient() {
+        if (this.toolClientPromise === null) {
+            await this.kernel.ensureLoaded();
+            this.toolClientPromise = this.initializeToolClient();
+        }
+        return await this.toolClientPromise;
+    }
+    registerSignalHandlers() {
+        const stop = () => {
+            this.stopping = true;
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+    }
+    async processNextCommand() {
+        const item = await this.claimNextCommand();
+        if (!item) {
+            return;
+        }
+        this.currentCommand = {
+            request_id: item.request_id,
+            command: item.command,
+            feature_id: item.feature_id,
+            started_at: nowIso(),
+        };
+        await this.writeState('running');
+        let response;
+        try {
+            response = await this.handleCommand(item);
+        }
+        catch (error) {
+            response = normalizeError(error);
+        }
+        this.currentCommand = null;
+        await this.completeCommand(item.request_id, response);
+    }
+    async handleApprove(featureId, args) {
+        const toolClient = await this.getToolClient();
+        const mergeHandler = new MergeCommandHandler(toolClient, `run:dashboard-runtime:${Date.now()}`);
+        const mergeResponse = normalizeToolResponse(await mergeHandler.execute({
+            command: CliCommand.Merge,
+            feature_id: featureId,
+            approval_token: asString(args.approval_token) ?? '',
+            merge_strategy: asString(args.merge_strategy) ?? 'merge_commit',
+            commit_message: asString(args.commit_message) ?? `Merge feature ${featureId}`,
+            sync_remote: 'auto',
+        }));
+        if (!isConflictPreparedForHandoff(mergeResponse)) {
+            // Check if merge failed with MERGE_DISABLED and recovery is available (merge repair loop)
+            const repairFeatureId = mergeFailureRequiresRepairLoop(mergeResponse);
+            if (repairFeatureId) {
+                return await this.attemptMergeRepairChain(repairFeatureId, mergeResponse);
+            }
+            return mergeResponse;
+        }
+        if (isConflictAlreadyDispatched(mergeResponse)) {
+            return buildReconcilerHandoffResponse(featureId, mergeResponse, {
+                attempted: false,
+                started: false,
+                already_running: false,
+                feature_id: featureId,
+            });
+        }
+        if (await this.hasFreshActiveRun()) {
+            const dispatched = await this.redrivePreparedReconcilerConflict(featureId);
+            if (dispatched) {
+                return buildReconcilerHandoffResponse(featureId, markConflictDispatched(mergeResponse), {
+                    attempted: false,
+                    started: false,
+                    already_running: false,
+                    feature_id: featureId,
+                });
+            }
+            return buildReconcilerDispatchFailedResponse(featureId, mergeResponse.error?.details);
+        }
+        const launch = await this.startBackgroundResume(featureId);
+        if (!launch.ok) {
+            return launch;
+        }
+        return buildReconcilerHandoffResponse(featureId, mergeResponse, launch.data);
+    }
+    async startBackgroundResume(featureId) {
+        return await this.startBackgroundCommand('feature.resume', featureId, async () => {
+            await this.runResumeInBackground(featureId);
+        });
+    }
+    async runResumeInBackground(featureId) {
+        const response = await this.executeResumeCommand(featureId);
+        if (!response.ok) {
+            throw new Error(response.error?.message ?? 'Dashboard background resume failed');
+        }
+    }
+    async redrivePreparedReconcilerConflict(featureId) {
+        try {
+            return await this.kernel.redrivePreparedReconcilerConflict(featureId);
+        }
+        catch {
+            return false;
+        }
+    }
+    async handleLaunchSubmit(featureId, args) {
+        const features = normalizeLaunchFeatures(args.features);
+        if (features.length === 0) {
+            return {
+                ok: false,
+                error: {
+                    code: 'invalid_input',
+                    message: 'launch.submit requires at least one prepared feature.',
+                },
+            };
+        }
+        if (await this.hasFreshActiveRun()) {
+            return await this.submitLaunchToActiveRun(features);
+        }
+        const runId = `run:dashboard-launch:${Date.now()}`;
+        const launch = await this.startBackgroundLaunch(featureId, features, runId);
+        if (!launch.ok) {
+            return launch;
+        }
+        return buildLaunchAcceptedResponse({
+            featureIds: features.map((entry) => entry.feature_id),
+            runId,
+            started: launch.data.started,
+            alreadyRunning: launch.data.already_running,
+        });
+    }
+    async submitLaunchToActiveRun(features) {
+        const toolClient = await this.getToolClient();
+        const runtimeSessions = await this.kernel.getRuntimeSessions();
+        try {
+            const submitted = await callCliTool(toolClient, runtimeSessions.run_id, TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT, {
+                run_id: runtimeSessions.run_id,
+                owner_instance_id: runtimeSessions.owner_instance_id,
+                request_type: 'add_features',
+                features,
+            });
+            return {
+                ok: true,
+                data: {
+                    command: 'launch.submit',
+                    mode: 'active_run_enrollment',
+                    ...submitted.data,
+                },
+            };
+        }
+        catch (error) {
+            const normalized = normalizeError(error);
+            return {
+                ok: false,
+                error: {
+                    code: normalized.error?.code,
+                    message: normalized.error?.message ?? 'Failed to submit launch features to the active run',
+                    details: normalized.error?.details,
+                },
+            };
+        }
+    }
+    async startBackgroundLaunch(featureId, features, runId) {
+        return await this.startBackgroundCommand('launch.submit', featureId, async () => {
+            await this.runLaunchInBackground(runId, features);
+        });
+    }
+    async startBackgroundCommand(command, featureId, operation) {
+        if (this.backgroundTaskFeatureId === featureId &&
+            this.backgroundTaskCommand === command &&
+            this.backgroundTaskPromise !== null) {
+            return {
+                ok: true,
+                data: {
+                    attempted: true,
+                    started: false,
+                    already_running: true,
+                    feature_id: featureId,
+                },
+            };
+        }
+        if (this.backgroundTaskFeatureId && this.backgroundTaskCommand) {
+            return buildRuntimeBusyResponseForCommand(this.backgroundTaskCommand, this.backgroundTaskFeatureId);
+        }
+        this.backgroundTaskFeatureId = featureId;
+        this.backgroundTaskCommand = command;
+        this.backgroundCommand = {
+            command,
+            feature_id: featureId,
+            started_at: nowIso(),
+        };
+        this.lastBackgroundError = null;
+        await this.writeState('running');
+        this.backgroundTaskPromise = operation()
+            .catch((error) => {
+            const normalized = normalizeError(error);
+            this.lastBackgroundError = {
+                command,
+                feature_id: featureId,
+                code: normalized.error?.code,
+                message: normalized.error?.message ?? 'Dashboard background command failed',
+                at: nowIso(),
+            };
+            console.error(normalized.error?.message ?? 'Dashboard background command failed');
+        })
+            .finally(async () => {
+            this.backgroundTaskFeatureId = null;
+            this.backgroundTaskCommand = null;
+            this.backgroundTaskPromise = null;
+            this.backgroundCommand = null;
+            await this.writeState('running');
+        });
+        return {
+            ok: true,
+            data: {
+                attempted: true,
+                started: true,
+                already_running: false,
+                feature_id: featureId,
+            },
+        };
+    }
+    async runLaunchInBackground(runId, features) {
+        const toolClient = await this.getToolClient();
+        const selection = resolveProviderSelection({
+            cli: {},
+            env: this.env,
+            agentsConfig: this.kernel.getAgentsConfig(),
+        });
+        const roleSelections = resolveProviderSelectionsByRole({
+            cli: {},
+            env: this.env,
+            agentsConfig: this.kernel.getAgentsConfig(),
+        });
+        for (const [role, roleSelection] of Object.entries(roleSelections)) {
+            if (roleSelection.provider !== selection.provider) {
+                const error = new Error('role_provider_overrides.provider must match the active provider selection');
+                error.code = 'invalid_cli_args';
+                error.details = {
+                    role,
+                    base_provider: selection.provider,
+                    role_provider: roleSelection.provider,
+                };
+                throw error;
+            }
+        }
+        const runtimeConfig = resolveWorkerProviderRuntime(this.kernel.getAgentsConfig().runtime);
+        const policySnapshot = this.kernel.getPolicySnapshot();
+        const executionPolicy = policySnapshot.execution && typeof policySnapshot.execution === 'object'
+            ? policySnapshot.execution
+            : null;
+        const observabilityPolicy = policySnapshot.observability && typeof policySnapshot.observability === 'object'
+            ? policySnapshot.observability
+            : null;
+        const overlayDir = resolvePromptOverlayDir(this.repoRoot, this.kernel.getAgentsConfig().runtime?.prompt_overlay_dir);
+        const provider = new DefaultWorkerProviderFactory().create({
+            selection,
+            mode: resolveWorkerProviderMode(undefined, this.kernel.getAgentsConfig().runtime?.worker_provider_mode, 'live'),
+            context: 'run',
+            policy: resolveWorkerProviderPolicy(executionPolicy),
+            observability: resolveWorkerProviderObservability(observabilityPolicy),
+            runtime: runtimeConfig,
+            repoRoot: this.repoRoot,
+            overlayDir,
+        });
+        const supervisor = new SupervisorRuntime(this.kernel, provider, toolClient, {
+            max_active_features: 5,
+            max_parallel_gate_runs: 3,
+            run_id: runId,
+            owner_instance_id: this.instanceId,
+            takeover_stale_run: true,
+            role_selections: roleSelections,
+        });
+        await supervisor.start(features.map((feature) => ({ feature_id: feature.feature_id })));
+    }
+    async ensureCommandSnapshot() {
+        const snapshot = (await readJson(this.queuePath, null)) ??
+            emptyCommandSnapshot(this.instanceId);
+        await atomicWriteJson(this.queuePath, snapshot);
+    }
+    async claimNextCommand() {
+        return await withFileLock(this.queueLockPath, async () => {
+            const snapshot = (await readJson(this.queuePath, null)) ??
+                emptyCommandSnapshot(this.instanceId);
+            const next = snapshot.items.find((item) => item.status === 'pending');
+            if (!next) {
+                return null;
+            }
+            next.status = 'processing';
+            snapshot.updated_at = nowIso();
+            await atomicWriteJson(this.queuePath, snapshot);
+            return { ...next };
+        }, {
+            timeoutMs: COMMAND_LOCK_TIMEOUT_MS,
+        });
+    }
+    async completeCommand(requestId, result) {
+        await withFileLock(this.queueLockPath, async () => {
+            const snapshot = (await readJson(this.queuePath, null)) ??
+                emptyCommandSnapshot(this.instanceId);
+            snapshot.items = pruneCompletedItems(snapshot.items.map((item) => item.request_id === requestId
+                ? {
+                    ...item,
+                    status: result.ok ? 'completed' : 'failed',
+                    processed_at: nowIso(),
+                    result,
+                }
+                : item));
+            snapshot.updated_at = nowIso();
+            await atomicWriteJson(this.queuePath, snapshot);
+        }, {
+            timeoutMs: COMMAND_LOCK_TIMEOUT_MS,
+        });
+    }
+    async writeState(status) {
+        await atomicWriteJson(this.statePath, {
+            version: 1,
+            instance_id: this.instanceId,
+            started_at: this.startedAt,
+            last_heartbeat_at: nowIso(),
+            pid: process.pid,
+            status,
+            current_command: this.currentCommand,
+            active_background_command: this.backgroundCommand,
+            last_background_error: this.lastBackgroundError,
+        });
+    }
+}
+//# sourceMappingURL=dashboard-runtime-runner.js.map