@pasko70/pibo 1.9.9 → 1.9.11

package/dist/ralph/service.js

@@ -0,0 +1,317 @@
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getDefaultPiboWorkspace } from '../core/workspace.js';
+import { PiboDataStore } from '../data/pibo-store.js';
+import { ChatRoomService } from '../apps/chat/data/room-service.js';
+import { isPiboRoomArchived } from '../apps/chat/types/rooms.js';
+import { browserPoolPaths, releaseBrowserPoolLease } from '../tools/browser-pool.js';
+import { createDefaultPiboRalphStore } from './store.js';
+import { createBuiltInRalphStopConditions, evaluateRalphStopPolicy } from './stopping.js';
+const CHAT_WEB_CHANNEL = 'pibo.chat-web';
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+class RalphRunTimeoutError extends Error {
+    abortFailed;
+    constructor(message, abortFailed = false) {
+        super(message);
+        this.abortFailed = abortFailed;
+        this.name = 'RalphRunTimeoutError';
+    }
+}
+function isUnknownProfileErrorMessage(message) { return /^Unknown profile "[^"]+"/.test(message); }
+function buildRalphPrompt(job) { return ['You are running a continuous Pibo Ralph job.', `Job: ${job.name}`, `Target: ${job.target.kind}`, '', 'Complete the task below. Return the result in this session. When this session finishes, Ralph may start a fresh session with the same task unless a configured stop condition is satisfied.', 'Important: if this job uses a promise-complete stop condition, do not quote, negate, explain, or mention its literal completion marker unless the task is fully complete and you intend to stop the job.', '', 'Task:', job.prompt].join('\n'); }
+function isJsonObject(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+function mergeRunResources(jobResources, runResources) {
+    if (!jobResources && !runResources)
+        return undefined;
+    const browserLeaseIds = [...new Set([...(jobResources?.browserLeaseIds ?? []), ...(runResources?.browserLeaseIds ?? [])])];
+    return {
+        ...(jobResources ?? {}),
+        ...(runResources ?? {}),
+        ...(browserLeaseIds.length ? { browserLeaseIds } : {}),
+    };
+}
+function clearDirtyReason(resources) {
+    const clean = { ...resources };
+    delete clean.dirtyReason;
+    return clean;
+}
+export class PiboRalphService {
+    options;
+    store;
+    dataStore;
+    roomService;
+    intervalMs;
+    maxConcurrentRuns;
+    runTimeoutMs;
+    timer;
+    activeRuns = 0;
+    stopped = true;
+    cancelledRuns = new Set();
+    unsubscribeProductEvents;
+    constructor(options) {
+        this.options = options;
+        this.store = options.store ?? createDefaultPiboRalphStore();
+        this.dataStore = new PiboDataStore(options.dataStorePath, { payloadRootDir: options.dataPayloadRootDir });
+        this.roomService = new ChatRoomService(this.dataStore);
+        this.intervalMs = options.intervalMs ?? 5_000;
+        this.maxConcurrentRuns = Math.max(1, options.maxConcurrentRuns ?? 2);
+        this.runTimeoutMs = options.runTimeoutMs;
+    }
+    start() { if (!this.stopped)
+        return; this.stopped = false; this.store.recoverInterruptedRuns(); this.unsubscribeProductEvents = this.options.context.subscribeProductEvents?.((event) => this.handleProductEvent(event)); this.arm(250); }
+    stop() { this.stopped = true; if (this.timer)
+        clearTimeout(this.timer); this.timer = undefined; this.unsubscribeProductEvents?.(); this.unsubscribeProductEvents = undefined; this.dataStore.close(); this.store.close(); }
+    status() { return { enabled: !this.stopped, ...this.store.status() }; }
+    async startJob(id) { const job = this.store.updateJob(id, { enabled: true }); if (!job)
+        return undefined; const reserved = await this.reserveAfterBeforeRunEvaluation(job); if (!reserved)
+        return undefined; void this.executeReserved(reserved.job, reserved.run).finally(() => this.armSoon()); return reserved.run; }
+    stopJob(id) { const job = this.store.requestStop(id); this.armSoon(); return job; }
+    async cancelJob(id) {
+        const job = this.store.requestCancel(id);
+        if (!job)
+            return undefined;
+        await this.abortJobIfRunning(job);
+        this.armSoon();
+        return this.store.getJob(id);
+    }
+    arm(delayMs) { if (this.stopped)
+        return; if (this.timer)
+        clearTimeout(this.timer); this.timer = setTimeout(() => void this.tick(), delayMs ?? this.intervalMs); }
+    armSoon() { this.arm(250); }
+    async tick() { if (this.stopped)
+        return; try {
+        await this.abortCancelRequestedJobs();
+        const capacity = this.maxConcurrentRuns - this.activeRuns;
+        if (capacity > 0) {
+            const jobs = this.store.listJobs({ includeDisabled: false }).filter((job) => !job.state.runningAt).slice(0, capacity);
+            for (const job of jobs) {
+                const reserved = await this.reserveAfterBeforeRunEvaluation(job);
+                if (reserved)
+                    void this.executeReserved(reserved.job, reserved.run).finally(() => this.armSoon());
+            }
+        }
+    }
+    catch (error) {
+        console.error('[ralph] scheduler tick failed', error);
+    }
+    finally {
+        this.arm();
+    } }
+    async reserveAfterBeforeRunEvaluation(job) {
+        const fresh = this.store.getJob(job.id) ?? job;
+        if (!fresh.enabled || fresh.state.runningAt)
+            return undefined;
+        const { evaluation, conditionStates } = await this.evaluateStopPolicy(fresh, 'before-run');
+        if (evaluation.finalAction !== 'continue') {
+            this.store.applyStopEvaluation({ jobId: fresh.id, evaluation, conditionStates, disable: true });
+            return undefined;
+        }
+        this.store.applyStopEvaluation({ jobId: fresh.id, evaluation, conditionStates, disable: false });
+        return this.store.reserveRun(fresh.id);
+    }
+    async abortCancelRequestedJobs() { for (const job of this.store.listJobs({ includeDisabled: true })) {
+        if (job.state.cancelRequestedAt)
+            await this.abortJobIfRunning(job);
+    } }
+    async abortJobIfRunning(job) {
+        if (!job.state.runningAt || !job.state.lastRunId)
+            return;
+        const sessionId = job.state.lastPiboSessionId;
+        if (!sessionId) {
+            this.markRunResourcesDirty(job, 'Cancel requested but active session is unavailable; browser lease may still exist');
+            return;
+        }
+        this.cancelledRuns.add(job.state.lastRunId);
+        try {
+            await this.options.context.emit({ type: 'execution', piboSessionId: sessionId, action: 'abort', id: `ralph_cancel_${randomUUID()}` });
+        }
+        catch (error) {
+            this.cancelledRuns.delete(job.state.lastRunId);
+            this.markRunResourcesDirty(job, `Cancel requested but abort failed: ${errorMessage(error)}`);
+        }
+    }
+    async executeReserved(job, run) {
+        this.activeRuns += 1;
+        try {
+            const result = await this.executeJob(job, run);
+            const cancelled = this.cancelledRuns.delete(run.id);
+            const outcome = { status: cancelled ? 'cancelled' : 'ok', piboSessionId: result.piboSessionId, finalAnswer: result.finalAnswer };
+            const { evaluation, conditionStates } = await this.evaluateStopPolicy(this.store.getJob(job.id) ?? job, 'after-run', run, outcome);
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: outcome.status, piboSessionId: result.piboSessionId, reason: cancelled ? 'cancelled' : evaluation.reason, stopAfterRun: evaluation.finalAction !== 'continue', stopEvaluation: evaluation, conditionStates });
+            await this.cleanupRunResources(job, run);
+        }
+        catch (error) {
+            const cancelled = this.cancelledRuns.delete(run.id);
+            const message = errorMessage(error);
+            const fatalProfileError = !cancelled && isUnknownProfileErrorMessage(message);
+            const timeoutAbortFailed = error instanceof RalphRunTimeoutError && error.abortFailed;
+            const outcome = { status: cancelled ? 'cancelled' : 'error', error: cancelled ? undefined : message };
+            const { evaluation, conditionStates } = await this.evaluateStopPolicy(this.store.getJob(job.id) ?? job, 'after-run', run, outcome);
+            this.store.completeRun({ jobId: job.id, runId: run.id, status: outcome.status, error: outcome.error, reason: cancelled ? 'cancelled' : fatalProfileError ? 'unknown-profile' : timeoutAbortFailed ? 'timeout-abort-failed' : evaluation.reason, stopAfterRun: fatalProfileError || timeoutAbortFailed || evaluation.finalAction !== 'continue', stopEvaluation: evaluation, conditionStates });
+            await this.cleanupRunResources(job, run);
+            if (!cancelled)
+                console.error(`[ralph] job ${job.id} failed`, error);
+        }
+        finally {
+            this.activeRuns -= 1;
+        }
+    }
+    markRunResourcesDirty(job, dirtyReason) {
+        const latestJob = this.store.getJob(job.id) ?? job;
+        const runId = latestJob.state.lastRunId ?? job.state.lastRunId;
+        const latestRun = runId ? this.store.listRuns({ jobId: latestJob.id, limit: 100 }).find((candidate) => candidate.id === runId) : undefined;
+        const resources = mergeRunResources(latestJob.resources, latestRun?.resources);
+        if (!resources || (!resources.workerId && (resources.browserLeaseIds ?? []).length === 0))
+            return;
+        const nextResources = { ...resources, cleanupState: 'dirty', dirtyReason, updatedAt: new Date().toISOString() };
+        try {
+            if (latestRun)
+                this.store.updateRunResources({ jobId: latestJob.id, runId: latestRun.id, resources: nextResources });
+            this.store.updateJobResources(latestJob.id, nextResources);
+        }
+        catch (error) {
+            console.error(`[ralph] failed to mark resource cleanup dirty for job ${latestJob.id}`, error);
+        }
+    }
+    async cleanupRunResources(job, run) {
+        const latestJob = this.store.getJob(job.id) ?? job;
+        const latestRun = this.store.listRuns({ jobId: job.id, limit: 100 }).find((candidate) => candidate.id === run.id) ?? run;
+        const resources = mergeRunResources(latestJob.resources, latestRun.resources);
+        const leaseIds = resources?.browserLeaseIds ?? [];
+        if (!resources || leaseIds.length === 0)
+            return;
+        const workerId = resources.workerId || process.env.PIBO_BROWSER_POOL_WORKER_ID || process.env.PIBO_COMPUTE_WORKER_ID || process.env.HOSTNAME || 'local';
+        const poolId = this.options.resourceCleanup?.browserPoolId || process.env.PIBO_BROWSER_POOL_ID || 'default';
+        const rootDir = this.options.resourceCleanup?.browserPoolRootDir || process.env.PIBO_BROWSER_POOL_ROOT || join(process.env.BROWSER_USE_HOME || join(homedir(), '.browser-use'), 'pibo-browser-pool');
+        const identity = { workerId, poolId };
+        const paths = browserPoolPaths(rootDir, identity);
+        const release = this.options.resourceCleanup?.releaseBrowserPoolLease ?? releaseBrowserPoolLease;
+        let dirtyReason;
+        for (const leaseId of leaseIds) {
+            try {
+                const result = await release(paths, identity, { leaseId, lockOptions: { holder: `ralph:${run.id}` } });
+                if (result.cleanupStatus === 'failed' || result.state.state === 'dirty' || (!result.released && !!result.state.activeLeaseId))
+                    dirtyReason = result.lastError || `Browser lease ${leaseId} cleanup failed`;
+            }
+            catch (error) {
+                dirtyReason = `Browser lease ${leaseId} cleanup failed: ${errorMessage(error)}`;
+            }
+            if (dirtyReason)
+                break;
+        }
+        const updatedAt = new Date().toISOString();
+        const nextResources = dirtyReason
+            ? { ...resources, workerId, cleanupState: 'dirty', dirtyReason, updatedAt }
+            : clearDirtyReason({ ...resources, workerId, cleanupState: 'released', updatedAt });
+        try {
+            this.store.updateRunResources({ jobId: job.id, runId: run.id, resources: nextResources });
+            this.store.updateJobResources(job.id, nextResources);
+        }
+        catch (error) {
+            console.error(`[ralph] failed to record resource cleanup for run ${run.id}`, error);
+        }
+    }
+    async evaluateStopPolicy(job, phase, run, outcome) {
+        return await evaluateRalphStopPolicy({ job, phase, definitions: this.getStopConditionDefinitions(), facts: this.store.createFactReader(job), run, outcome });
+    }
+    getStopConditionDefinitions() { return this.options.context.getRalphStopConditionDefinitions?.() ?? createBuiltInRalphStopConditions(); }
+    handleProductEvent(event) {
+        if (event.type !== 'pibo.ralph.fact' && event.type !== 'ralph.fact')
+            return;
+        const payload = event.payload;
+        if (!isJsonObject(payload.payload))
+            return;
+        if (typeof payload.jobId !== 'string' || typeof payload.type !== 'string')
+            return;
+        const source = payload.source === 'pi-extension' || payload.source === 'tool' || payload.source === 'plugin' || payload.source === 'pibo' ? payload.source : 'plugin';
+        try {
+            this.store.appendRunFact({ jobId: payload.jobId, runId: typeof payload.runId === 'string' ? payload.runId : undefined, piboSessionId: typeof payload.piboSessionId === 'string' ? payload.piboSessionId : undefined, type: payload.type, source: source, payload: payload.payload });
+        }
+        catch (error) {
+            console.error('[ralph] failed to append run fact', error);
+        }
+    }
+    async executeJob(job, run) {
+        const target = this.resolveTarget(job);
+        const session = this.options.context.createSession({
+            channel: CHAT_WEB_CHANNEL,
+            kind: 'ralph',
+            profile: job.profile,
+            workspace: target.workspace ?? getDefaultPiboWorkspace(),
+            title: job.name,
+            activeModel: job.modelOverride ? { ...job.modelOverride } : undefined,
+            metadata: {
+                ...(target.metadata ?? {}),
+                chatRoomId: target.roomId,
+                ralphJobId: job.id,
+                ralphRunId: run.id,
+                ralphTargetKind: job.target.kind,
+                ...(job.thinkingLevel ? { initialThinkingLevel: job.thinkingLevel } : {}),
+                ...(job.fastMode !== undefined ? { initialFastMode: job.fastMode } : {}),
+            },
+        });
+        this.store.attachRunSession(job.id, run.id, session.id);
+        const finalAnswer = await this.emitMessageAndWait(session.id, buildRalphPrompt(job));
+        return { piboSessionId: session.id, finalAnswer };
+    }
+    resolveTarget(job) { if (job.target.kind === 'room') {
+        const room = this.roomService.getRoom(job.target.roomId);
+        if (!room)
+            throw new Error('Target room no longer exists');
+        if (isPiboRoomArchived(room))
+            throw new Error('Target room is archived');
+        return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() };
+    } const room = this.roomService.ensureDefaultRoom({ name: 'Shared Chat' }); return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() }; }
+    async emitMessageAndWait(piboSessionId, text) {
+        const eventId = `ralph_msg_${randomUUID()}`;
+        return await new Promise((resolve, reject) => {
+            let settled = false;
+            let deltaAnswer = '';
+            let finalAnswer = '';
+            let lastSessionError;
+            let timingOut = false;
+            let unsubscribe;
+            let timeout;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                unsubscribe?.();
+                if (error)
+                    reject(error);
+                else
+                    resolve(finalAnswer || deltaAnswer);
+            };
+            if (this.runTimeoutMs !== undefined) {
+                timeout = setTimeout(() => {
+                    timingOut = true;
+                    const message = lastSessionError ? `Ralph run timed out after session error: ${lastSessionError}` : 'Ralph run timed out';
+                    void this.options.context.emit({ type: 'execution', piboSessionId, action: 'abort', id: `ralph_timeout_${randomUUID()}` })
+                        .then(() => finish(new RalphRunTimeoutError(message)), (abortError) => finish(new RalphRunTimeoutError(`${message}; session abort failed: ${errorMessage(abortError)}`, true)));
+                }, this.runTimeoutMs);
+            }
+            unsubscribe = this.options.context.subscribe((event) => {
+                if (timingOut || event.piboSessionId !== piboSessionId)
+                    return;
+                if ('eventId' in event && event.eventId !== eventId)
+                    return;
+                if (event.type === 'assistant_delta')
+                    deltaAnswer += event.text;
+                if (event.type === 'assistant_message') {
+                    finalAnswer = event.text;
+                    lastSessionError = undefined;
+                }
+                if (event.type === 'message_finished')
+                    finish(lastSessionError ? new Error(lastSessionError) : undefined);
+                if (event.type === 'session_error') {
+                    lastSessionError = event.error;
+                    finish(new Error(event.error));
+                }
+            });
+            this.options.context.emit({ type: 'message', piboSessionId, id: eventId, source: 'service', text }).catch((error) => finish(error instanceof Error ? error : new Error(String(error))));
+        });
+    }
+}

package/dist/ralph/stopping.js

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto';
+export const PROMISE_COMPLETE_STOP_TOKEN = '<promise>COMPLETE</promise>';
+export const MAX_ITERATIONS_STOP_CONDITION = 'pibo.ralph.max-iterations';
+export const PROMISE_COMPLETE_STOP_CONDITION = 'pibo.ralph.promise-complete';
+export const FACT_COUNT_STOP_CONDITION = 'pibo.ralph.fact-count';
+function hasPromiseCompleteMarker(finalAnswer) { return finalAnswer.split(/\r?\n/).some((line) => line.trim() === PROMISE_COMPLETE_STOP_TOKEN); }
+function isObject(value) { return !!value && typeof value === 'object' && !Array.isArray(value); }
+function stringOption(options, key) { const value = options?.[key]; return typeof value === 'string' && value.trim() ? value.trim() : undefined; }
+function numberOption(options, key) { const value = options?.[key]; return typeof value === 'number' && Number.isFinite(value) ? value : undefined; }
+function boolOption(options, key) { const value = options?.[key]; return typeof value === 'boolean' ? value : undefined; }
+export function getDefaultRalphStopPolicy(job) {
+    const conditions = [];
+    if (job.maxIterations !== undefined)
+        conditions.push({ id: 'max-iterations', type: MAX_ITERATIONS_STOP_CONDITION });
+    conditions.push({ id: 'promise-complete', type: PROMISE_COMPLETE_STOP_CONDITION });
+    return { mode: 'any', conditions };
+}
+export function getEffectiveRalphStopPolicy(job) {
+    return job.stopPolicy ?? getDefaultRalphStopPolicy(job);
+}
+export function createBuiltInRalphStopConditions() {
+    return [
+        {
+            type: MAX_ITERATIONS_STOP_CONDITION,
+            name: 'Max iterations',
+            description: 'Stops a Ralph job after its configured number of completed run attempts, regardless of outcome.',
+            phases: ['before-run', 'after-run'],
+            evaluate(context) {
+                const maxIterations = context.job.maxIterations;
+                if (maxIterations === undefined)
+                    return { action: 'continue' };
+                const current = context.job.state.completedIterations ?? 0;
+                const completed = context.phase === 'after-run' && context.outcome ? current + 1 : current;
+                if (completed >= maxIterations)
+                    return { action: 'stop-after-run', reason: 'max-iterations', details: { maxIterations, completedIterations: completed } };
+                return { action: 'continue', details: { maxIterations, completedIterations: completed } };
+            },
+        },
+        {
+            type: PROMISE_COMPLETE_STOP_CONDITION,
+            name: 'Promise complete token',
+            description: 'Stops after a successful run whose final answer contains the promise-complete marker on its own line.',
+            phases: ['after-run'],
+            evaluate(context) {
+                const finalAnswer = context.outcome?.finalAnswer ?? '';
+                if (context.outcome?.status === 'ok' && hasPromiseCompleteMarker(finalAnswer))
+                    return { action: 'stop-after-run', reason: 'promise-complete', details: { token: PROMISE_COMPLETE_STOP_TOKEN } };
+                return { action: 'continue' };
+            },
+        },
+        {
+            type: FACT_COUNT_STOP_CONDITION,
+            name: 'Run fact count',
+            description: 'Stops when the current run or job history contains at least a configured number of matching Ralph run facts.',
+            phases: ['after-run'],
+            defaultOptions: { factType: 'example.fact', threshold: 1, currentRunOnly: true },
+            optionsSchema: {
+                type: 'object',
+                properties: {
+                    factType: { type: 'string', description: 'Fact type to count.' },
+                    threshold: { type: 'number', description: 'Stop after at least this many facts.' },
+                    currentRunOnly: { type: 'boolean', description: 'Only count facts for the current run.' },
+                    reason: { type: 'string', description: 'Optional stop reason.' },
+                },
+            },
+            evaluate(context) {
+                const factType = stringOption(context.instance.options, 'factType');
+                if (!factType)
+                    return { action: 'continue', details: { missingOption: 'factType' } };
+                const threshold = Math.max(1, Math.floor(numberOption(context.instance.options, 'threshold') ?? 1));
+                const currentRunOnly = boolOption(context.instance.options, 'currentRunOnly') ?? true;
+                const runId = currentRunOnly ? context.run?.id : undefined;
+                const count = context.facts.count({ type: factType, runId });
+                if (count >= threshold)
+                    return { action: 'stop-after-run', reason: stringOption(context.instance.options, 'reason') ?? `fact:${factType}`, details: { factType, threshold, count, currentRunOnly } };
+                return { action: 'continue', details: { factType, threshold, count, currentRunOnly } };
+            },
+        },
+    ];
+}
+function severity(action) {
+    if (action === 'cancel-current-run')
+        return 2;
+    if (action === 'stop-after-run')
+        return 1;
+    return 0;
+}
+function highest(left, right) { return severity(right) > severity(left) ? right : left; }
+function sanitizeDecision(value) {
+    if (!isObject(value))
+        throw new Error('condition returned a non-object decision');
+    if (value.action !== 'continue' && value.action !== 'stop-after-run' && value.action !== 'cancel-current-run')
+        throw new Error('condition returned an invalid action');
+    return { action: value.action, reason: typeof value.reason === 'string' ? value.reason : undefined, details: isObject(value.details) ? value.details : undefined, nextState: isObject(value.nextState) ? value.nextState : undefined };
+}
+async function withTimeout(promise, timeoutMs, signal) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return await promise;
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error(`condition timed out after ${timeoutMs}ms`)), timeoutMs);
+        if (signal)
+            signal.addEventListener('abort', () => reject(new Error('condition aborted')), { once: true });
+        promise.then((value) => { clearTimeout(timeout); resolve(value); }, (error) => { clearTimeout(timeout); reject(error); });
+    });
+}
+export async function evaluateRalphStopPolicy(input) {
+    const now = (input.now ?? new Date()).toISOString();
+    const policy = getEffectiveRalphStopPolicy(input.job);
+    const definitions = new Map(input.definitions.map((definition) => [definition.type, definition]));
+    const decisions = [];
+    const conditionStates = { ...(input.job.state.conditionStates ?? {}) };
+    let finalAction = 'continue';
+    for (const instance of policy.conditions) {
+        const base = { id: instance.id, type: instance.type, phase: input.phase };
+        if (instance.enabled === false) {
+            decisions.push({ ...base, action: 'continue', skipped: true, reason: 'disabled' });
+            continue;
+        }
+        const definition = definitions.get(instance.type);
+        if (!definition) {
+            decisions.push({ ...base, action: 'continue', skipped: true, error: `Unknown Ralph stop condition type: ${instance.type}` });
+            continue;
+        }
+        if (!definition.phases.includes(input.phase)) {
+            decisions.push({ ...base, action: 'continue', skipped: true, reason: 'unsupported-phase' });
+            continue;
+        }
+        try {
+            const state = conditionStates[instance.id] ?? {};
+            const decision = sanitizeDecision(await withTimeout(Promise.resolve(definition.evaluate({ phase: input.phase, job: input.job, policy, instance, state, now, run: input.run, outcome: input.outcome, facts: input.facts, signal: input.signal })), instance.timeoutMs ?? definition.timeoutMs, input.signal));
+            if (decision.nextState)
+                conditionStates[instance.id] = decision.nextState;
+            decisions.push({ ...base, action: decision.action, reason: decision.reason, details: decision.details });
+        }
+        catch (error) {
+            const failClosed = instance.failClosed ?? definition.failClosedDefault ?? false;
+            const action = failClosed ? 'stop-after-run' : 'continue';
+            decisions.push({ ...base, action, reason: failClosed ? 'condition-error-fail-closed' : 'condition-error', error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    const active = decisions.filter((decision) => !decision.skipped);
+    if (policy.mode === 'all' && active.length > 0) {
+        const allStop = active.every((decision) => severity(decision.action) >= severity('stop-after-run'));
+        finalAction = allStop ? active.reduce((action, decision) => highest(action, decision.action), 'stop-after-run') : 'continue';
+    }
+    else {
+        finalAction = active.reduce((action, decision) => highest(action, decision.action), 'continue');
+    }
+    const contributing = finalAction === 'continue' ? active.find((decision) => decision.error || decision.reason) : active.find((decision) => decision.action === finalAction) ?? active.find((decision) => severity(decision.action) > 0);
+    return { evaluation: { id: `rse_${randomUUID()}`, phase: input.phase, at: now, mode: policy.mode, finalAction, reason: contributing?.reason ?? (contributing?.error ? 'condition-error' : undefined), decisions }, conditionStates };
+}