@pasko70/pibo 1.7.11 → 1.7.12

package/dist/core/routed-session.js

@@ -565,6 +565,7 @@ export class RoutedSession {
     getStatus() {
         const enabledTools = this.runtime.session.getActiveToolNames();
         const thinkingLevel = this.runtime.session.thinkingLevel;
+        const settingsManager = this.runtime.session.settingsManager;
         return {
             piboSessionId: this.piboSessionId,
             queuedMessages: this.queue.length,
@@ -576,6 +577,12 @@ export class RoutedSession {
             disposed: this.disposed,
             thinkingLevel,
             fastMode: this.getFastModeResult().mode === "fast",
+            ...(settingsManager ? {
+                retry: {
+                    ...settingsManager.getRetrySettings(),
+                    provider: settingsManager.getProviderRetrySettings(),
+                },
+            } : {}),
         };
     }
     getContextUsage() {

package/dist/core/runtime-telemetry.js

@@ -68,7 +68,7 @@ export class PiboRuntimeTelemetryRecorder {
                 this.recordToolExecutionFinished(event, context);
                 return;
             case "session_error":
-                this.recordTurnTerminal(event, context, "error", "error", event.error);
+                this.recordTurnTerminal(event, context, "error", "error", event.error, event.errorDetails?.category ?? event.errorDetails?.errorClass);
                 return;
             case "execution_result":
                 this.recordExecutionResult(event, context);
@@ -368,13 +368,13 @@ export class PiboRuntimeTelemetryRecorder {
             return;
         this.startOrProgressPhase(turn, phaseName, new Date().toISOString(), summary, { updateTurn: true });
     }
-    recordTurnTerminal(event, context, status, phaseName, summary) {
+    recordTurnTerminal(event, context, status, phaseName, summary, errorCategory) {
         const turn = this.turnContextForEvent(event.piboSessionId, event.eventId, undefined, context) ?? this.activeTurnContext(event.piboSessionId, context);
         if (!turn)
             return;
         const now = new Date().toISOString();
         this.finishOpenPhases(turn.turnId, terminalPhaseStatus(status), now);
-        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary);
+        this.finishActiveProviderRequests(turn.turnId, providerStatusForTurnStatus(status), now, summary, errorCategory);
         this.finishActiveToolCalls(turn.turnId, status, now, summary);
         this.telemetry.upsertPhase({
             phaseId: phaseId(turn.turnId, phaseName),
@@ -486,7 +486,7 @@ export class PiboRuntimeTelemetryRecorder {
             normalizedEventCount: request.normalizedEventCount + 1,
         });
     }
-    finishActiveProviderRequests(turnId, status, now, summary) {
+    finishActiveProviderRequests(turnId, status, now, summary, errorCategory) {
         const timeline = this.store?.getTurnTimeline(turnId, { limit: 100 });
         for (const request of timeline?.providerRequests ?? []) {
             if (isTerminalProviderStatus(request.status))
@@ -494,7 +494,7 @@ export class PiboRuntimeTelemetryRecorder {
             this.upsertProviderRequestFromExisting(request, {
                 status,
                 completedAt: now,
-                errorCategory: status === "error" ? "runtime_error" : undefined,
+                errorCategory: status === "error" ? errorCategory ?? "runtime_error" : undefined,
                 errorMessage: status === "error" ? safeSummary(summary) : undefined,
             });
         }

package/dist/core/runtime.js

@@ -25,6 +25,27 @@ import { PIBO_APP_CONTEXT } from "../app-context.js";
 import { createRuntimeToolDefinition } from "../tools/runtime/tool.js";
 import { RuntimeSessionRegistry } from "../tools/runtime/registry.js";
 import { compactValidationToolResultForContext } from "./test-output-compaction.js";
+function hasOwnRetrySetting(settings, key) {
+    return settings !== undefined && settings !== null && Object.prototype.hasOwnProperty.call(settings, key);
+}
+export function applyPiboRuntimeRetryDefaults(settingsManager, defaults) {
+    if (!defaults)
+        return;
+    const globalRetry = settingsManager.getGlobalSettings().retry;
+    const projectRetry = settingsManager.getProjectSettings().retry;
+    const overrides = {};
+    if (!hasOwnRetrySetting(globalRetry, "enabled") && !hasOwnRetrySetting(projectRetry, "enabled") && defaults.enabled !== undefined) {
+        overrides.enabled = defaults.enabled;
+    }
+    if (!hasOwnRetrySetting(globalRetry, "maxRetries") && !hasOwnRetrySetting(projectRetry, "maxRetries") && defaults.maxRetries !== undefined) {
+        overrides.maxRetries = defaults.maxRetries;
+    }
+    if (!hasOwnRetrySetting(globalRetry, "baseDelayMs") && !hasOwnRetrySetting(projectRetry, "baseDelayMs") && defaults.baseDelayMs !== undefined) {
+        overrides.baseDelayMs = defaults.baseDelayMs;
+    }
+    if (Object.keys(overrides).length > 0)
+        settingsManager.applyOverrides({ retry: overrides });
+}
 function resolveProfilePath(cwd, path) {
     return isAbsolute(path) ? path : resolve(cwd, path);
 }
@@ -243,6 +264,7 @@ export async function createPiboRuntime(options = {}) {
                 }),
             },
         });
+        applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
         registerOpenAiGpt56Models(services.modelRegistry);
         registerMiniMaxProvider(services.modelRegistry);
         registerGlmProvider(services.modelRegistry);

package/dist/core/session-errors.js

@@ -1,3 +1,16 @@
+const PROVIDER_NETWORK_ERROR_MARKERS = [
+    "fetch failed",
+    "network error",
+    "connection error",
+    "connection refused",
+    "connection lost",
+    "connection reset",
+    "other side closed",
+    "upstream connect",
+    "reset before headers",
+    "socket hang up",
+    "socket connection was closed",
+];
 export function classifySessionErrorMessage(message, options = {}) {
     const normalized = message.toLowerCase();
     if (normalized.includes("context_length_exceeded") || normalized.includes("context window")) {
@@ -18,6 +31,9 @@ export function classifySessionErrorMessage(message, options = {}) {
     if (normalized.includes("timeout") || normalized.includes("timed out")) {
         return { category: "provider_transport", errorClass: "provider_transport", code: "timeout", origin: "provider", retryable: true, userMessage: "The provider request timed out." };
     }
+    if (PROVIDER_NETWORK_ERROR_MARKERS.some((marker) => normalized.includes(marker))) {
+        return { category: "provider_transport", errorClass: "provider_transport", code: "network_error", origin: "provider", retryable: true, userMessage: "The provider network connection failed." };
+    }
     if (/\b5\d\d\b/.test(normalized)) {
         return { category: "provider_server", errorClass: "provider_server", code: "provider_server_error", origin: "provider", retryable: true, userMessage: "The provider returned a server error." };
     }

package/dist/core/session-router.js

@@ -20,6 +20,14 @@ import { withWorkflowSessionKind } from "../sessions/workflow-session-kind.js";
 import { PiboRuntimeTelemetryRecorder } from "./runtime-telemetry.js";
 import { createPiboProviderTelemetryExtension } from "./provider-telemetry.js";
 const DEFAULT_SUBAGENT_REPLY_TIMEOUT_MS = 10 * 60 * 1000;
+export const RALPH_RUNTIME_RETRY_DEFAULTS = {
+    enabled: true,
+    maxRetries: 7,
+    baseDelayMs: 2_000,
+};
+export function resolvePiboSessionRetryDefaults(kind, configured) {
+    return configured ?? (kind === "ralph" ? RALPH_RUNTIME_RETRY_DEFAULTS : undefined);
+}
 export function resolvePiboSessionInitialThinkingLevel(session) {
     const value = session.metadata?.initialThinkingLevel;
     return typeof value === "string" && isPiboThinkingLevel(value) ? value : undefined;
@@ -360,6 +368,7 @@ export class PiboSessionRouter {
             cwd: piboSession.workspace ?? this.options.cwd,
             persistSession: this.options.persistSession,
             thinkingLevel: initialThinkingLevel ?? this.options.thinkingLevel,
+            retryDefaults: resolvePiboSessionRetryDefaults(piboSession.kind, this.options.retryDefaults),
             profile: profileForSession(profile, piboSession.piSessionId, parentPiSessionId),
             extensionFactories: [
                 ...(telemetryExtension ? [telemetryExtension] : []),

package/dist/gateway/cli.js

@@ -1,5 +1,5 @@
 import { spawn, execFile } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, openSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
@@ -87,28 +87,40 @@ function resolveGatewayWebCommand(argv, target) {
     ];
     return { command: process.execPath, args };
 }
-function managedGatewayPidPath(target) {
-    return join(managedGatewayHome(target), "gateway.pid");
+function managedGatewayPidPaths(target) {
+    const home = managedGatewayHome(target);
+    try {
+        const legacy = readdirSync(home)
+            .filter((name) => /^gateway-\d+\.pid$/.test(name))
+            .map((name) => join(home, name));
+        return [join(home, "gateway.pid"), ...legacy];
+    }
+    catch {
+        return [join(home, "gateway.pid")];
+    }
 }
 function readManagedGatewayPid(target) {
-    try {
-        const path = managedGatewayPidPath(target);
-        if (!existsSync(path))
-            return undefined;
-        const pid = Number(readFileSync(path, "utf-8").trim());
-        if (!Number.isInteger(pid) || pid <= 0)
-            return undefined;
+    for (const path of managedGatewayPidPaths(target)) {
         try {
-            process.kill(pid, 0);
-            return pid;
+            if (!existsSync(path))
+                continue;
+            const pid = Number(readFileSync(path, "utf-8").trim());
+            if (!Number.isInteger(pid) || pid <= 0)
+                continue;
+            try {
+                process.kill(pid, 0);
+                return pid;
+            }
+            catch (error) {
+                if (error.code === "EPERM")
+                    return pid;
+            }
         }
         catch {
-            return undefined;
+            // Try the next current or legacy PID file.
         }
     }
-    catch {
-        return undefined;
-    }
+    return undefined;
 }
 async function waitForTargetGatewayDown(target, maxRetries = 40, intervalMs = 250) {
     const port = targetPort(target);
@@ -322,6 +334,13 @@ async function runManagedGatewayCommand(target, command, args, argv = process.ar
             process.exitCode = 1;
             return true;
         }
+        const existingPid = readManagedGatewayPid(target);
+        if (existingPid !== undefined) {
+            console.error(`Start blocked: ${managedGatewayHome(target)} is already owned by gateway PID ${existingPid}.`);
+            console.error(`The configured status port ${targetPort(target)} is not reachable; check the gateway port configuration instead of starting a second gateway with the same PIBO_HOME.`);
+            process.exitCode = 1;
+            return true;
+        }
         console.error(`Starting ${target === "web" ? "production" : "dev"} gateway...`);
         try {
             await runGatewayManager("start", target, argv);

package/dist/gateway/pidfile.js

@@ -1,84 +1,130 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { piboHomePath } from "../core/pibo-home.js";
-function gatewayPidPath(port) {
-    return piboHomePath(port === undefined ? "gateway.pid" : `gateway-${port}.pid`);
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getPiboHome, piboHomePath } from "../core/pibo-home.js";
+function gatewayPidPath() {
+    return piboHomePath("gateway.pid");
 }
 function fallbackGatewayPidPath() {
     return piboHomePath("gateway-fallback.pid");
 }
-export function readPidFile(port) {
+function legacyGatewayPidPaths() {
+    try {
+        const home = getPiboHome();
+        return readdirSync(home)
+            .filter((name) => /^gateway-\d+\.pid$/.test(name))
+            .map((name) => join(home, name));
+    }
+    catch {
+        return [];
+    }
+}
+function storedPid(path) {
     try {
-        const path = gatewayPidPath(port);
         if (!existsSync(path))
             return undefined;
         const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
-        if (Number.isNaN(pid))
-            return undefined;
-        try {
-            process.kill(pid, 0);
+        return Number.isNaN(pid) ? undefined : pid;
+    }
+    catch {
+        return undefined;
+    }
+}
+function livePid(path) {
+    const pid = storedPid(path);
+    if (pid === undefined)
+        return undefined;
+    try {
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch (error) {
+        if (error.code === "EPERM")
             return pid;
+        return undefined;
+    }
+}
+function claimPidFile(path, label) {
+    mkdirSync(dirname(path), { recursive: true });
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            writeFileSync(path, String(process.pid), { encoding: "utf-8", flag: "wx" });
+            return;
         }
-        catch {
-            return undefined;
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existingPid = livePid(path);
+            if (existingPid === process.pid)
+                return;
+            if (existingPid !== undefined)
+                throw new Error(`${label} already running (PID ${existingPid})`);
+            try {
+                unlinkSync(path);
+            }
+            catch (unlinkError) {
+                if (unlinkError.code !== "ENOENT")
+                    throw unlinkError;
+            }
         }
     }
+    throw new Error(`Unable to claim ${label.toLowerCase()} PID file`);
+}
+function clearPidFileIfOwned(path) {
+    try {
+        if (storedPid(path) === process.pid)
+            unlinkSync(path);
+    }
     catch {
-        return undefined;
+        // ignore
     }
 }
-export function clearPidFile(port) {
+export function readPidFile() {
+    return livePid(gatewayPidPath()) ?? legacyGatewayPidPaths().map(livePid).find((pid) => pid !== undefined);
+}
+export function clearPidFile() {
     try {
-        const path = gatewayPidPath(port);
-        if (existsSync(path)) {
+        const path = gatewayPidPath();
+        if (existsSync(path))
             unlinkSync(path);
-        }
     }
     catch {
         // ignore
     }
 }
-export function writeGatewayPid(port) {
-    const existingPid = readPidFile(port);
+export function releaseGatewayPid() {
+    clearPidFileIfOwned(gatewayPidPath());
+}
+export function writeGatewayPid() {
+    const existingPid = readPidFile();
     if (existingPid !== undefined && existingPid !== process.pid) {
         throw new Error(`Gateway already running (PID ${existingPid})`);
     }
-    writeFileSync(gatewayPidPath(port), String(process.pid), "utf-8");
-}
-export function readFallbackPidFile() {
-    try {
-        const path = fallbackGatewayPidPath();
-        if (!existsSync(path))
-            return undefined;
-        const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
-        if (Number.isNaN(pid))
-            return undefined;
+    for (const path of legacyGatewayPidPaths()) {
+        if (livePid(path) !== undefined)
+            continue;
         try {
-            process.kill(pid, 0);
-            return pid;
-        }
-        catch {
-            return undefined;
+            unlinkSync(path);
         }
+        catch { }
     }
-    catch {
-        return undefined;
-    }
+    claimPidFile(gatewayPidPath(), "Gateway");
+}
+export function readFallbackPidFile() {
+    return livePid(fallbackGatewayPidPath());
 }
 export function clearFallbackPidFile() {
     try {
         const path = fallbackGatewayPidPath();
-        if (existsSync(path)) {
+        if (existsSync(path))
             unlinkSync(path);
-        }
     }
     catch {
         // ignore
     }
 }
+export function releaseFallbackGatewayPid() {
+    clearPidFileIfOwned(fallbackGatewayPidPath());
+}
 export function writeFallbackGatewayPid() {
-    const existingPid = readFallbackPidFile();
-    if (existingPid !== undefined && existingPid !== process.pid) {
-        throw new Error(`Fallback gateway already running (PID ${existingPid})`);
-    }
-    writeFileSync(fallbackGatewayPidPath(), String(process.pid), "utf-8");
+    claimPidFile(fallbackGatewayPidPath(), "Fallback gateway");
 }

package/dist/gateway/server.js

@@ -3,7 +3,7 @@ import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault
 import { PiboSessionRouter } from "../core/session-router.js";
 import { loadPiboModelDefaults, selectRequestedModelProfile } from "../core/model-defaults.js";
 import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, isGatewaySubscribeFrame, } from "./protocol.js";
-import { clearFallbackPidFile, clearPidFile, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
+import { releaseFallbackGatewayPid, releaseGatewayPid, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const DEFAULT_MAX_BACKPRESSURE_FRAMES = 1_000;
 const DEFAULT_MAX_BACKPRESSURE_BYTES = 4 * 1024 * 1024;
 function parseJsonLine(line) {
@@ -342,31 +342,37 @@ export class PiboGatewayServer {
     }
 }
 export async function runGatewayServer(options = {}) {
-    const server = new PiboGatewayServer(options);
-    await server.start();
+    const fallbackMode = process.env.PIBO_FALLBACK_MODE === "1";
     try {
-        if (process.env.PIBO_FALLBACK_MODE === "1") {
+        if (fallbackMode)
             writeFallbackGatewayPid();
-        }
-        else {
+        else
             writeGatewayPid();
-        }
     }
-    catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
-        await server.stop();
-        process.exit(1);
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+        return;
+    }
+    const releasePid = fallbackMode ? releaseFallbackGatewayPid : releaseGatewayPid;
+    let server;
+    try {
+        server = new PiboGatewayServer(options);
+        await server.start();
+    }
+    catch (error) {
+        releasePid();
+        throw error;
     }
     const host = options.host ?? DEFAULT_GATEWAY_HOST;
     const port = options.port ?? DEFAULT_GATEWAY_PORT;
     console.error(`pibo gateway listening on ${host}:${port}`);
     const stop = async () => {
-        await server.stop();
-        if (process.env.PIBO_FALLBACK_MODE === "1") {
-            clearFallbackPidFile();
+        try {
+            await server.stop();
         }
-        else {
-            clearPidFile();
+        finally {
+            releasePid();
         }
     };
     process.once("SIGINT", () => {

package/dist/gateway/web.js

@@ -13,7 +13,7 @@ import { createPiboWebHostPlugin } from "../plugins/web.js";
 import { DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT } from "../web/channel.js";
 import { loadPiboConfig } from "../config/config.js";
 import { PiboGatewayServer } from "./server.js";
-import { clearFallbackPidFile, clearPidFile, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
+import { releaseFallbackGatewayPid, releaseGatewayPid, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const PUBLIC_WEB_CHANNEL_HOST = "0.0.0.0";
 const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
 function isComputeWorkerRuntime() {
@@ -175,37 +175,43 @@ function createChatAppURL(options, host, port) {
     return `http://${host}:${port}/apps/chat`;
 }
 export async function runWebGatewayServer(options = {}) {
-    const resolvedOptions = resolveWebGatewayServerOptions(options);
-    const pluginRegistry = resolvedOptions.pluginRegistry ?? createWebPiboPluginRegistry(resolvedOptions);
-    const pidFilePort = resolvedOptions.port;
-    const server = new PiboGatewayServer({
-        ...resolvedOptions,
-        pluginRegistry,
-    });
-    await server.start();
+    const fallbackMode = process.env.PIBO_FALLBACK_MODE === "1";
     try {
-        if (process.env.PIBO_FALLBACK_MODE === "1") {
+        if (fallbackMode)
             writeFallbackGatewayPid();
-        }
-        else {
-            writeGatewayPid(pidFilePort);
-        }
+        else
+            writeGatewayPid();
     }
-    catch (err) {
-        console.error(err instanceof Error ? err.message : String(err));
-        await server.stop();
-        process.exit(1);
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+        return;
+    }
+    const releasePid = fallbackMode ? releaseFallbackGatewayPid : releaseGatewayPid;
+    let resolvedOptions;
+    let server;
+    try {
+        resolvedOptions = resolveWebGatewayServerOptions(options);
+        const pluginRegistry = resolvedOptions.pluginRegistry ?? createWebPiboPluginRegistry(resolvedOptions);
+        server = new PiboGatewayServer({
+            ...resolvedOptions,
+            pluginRegistry,
+        });
+        await server.start();
+    }
+    catch (error) {
+        releasePid();
+        throw error;
     }
     const host = resolvedOptions.web?.host ?? DEFAULT_WEB_CHANNEL_HOST;
     const port = resolvedOptions.web?.port ?? DEFAULT_WEB_CHANNEL_PORT;
     console.error(`pibo chat app available at ${createChatAppURL(resolvedOptions, host, port)}`);
     const stop = async () => {
-        await server.stop();
-        if (process.env.PIBO_FALLBACK_MODE === "1") {
-            clearFallbackPidFile();
+        try {
+            await server.stop();
         }
-        else {
-            clearPidFile(pidFilePort);
+        finally {
+            releasePid();
         }
     };
     process.once("SIGINT", () => {

package/dist/ralph/service.js

@@ -10,6 +10,14 @@ 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); }
@@ -137,9 +145,10 @@ export class PiboRalphService {
             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' : evaluation.reason, stopAfterRun: fatalProfileError || evaluation.finalAction !== 'continue', stopEvaluation: evaluation, conditionStates });
+            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);
@@ -256,24 +265,55 @@ export class PiboRalphService {
     } const room = this.roomService.ensureDefaultRoom({ name: 'Shared Chat' }); return { roomId: room.id, workspace: room.workspace ?? getDefaultPiboWorkspace() }; }
     async emitMessageAndWait(piboSessionId, text, options = {}) {
         const eventId = `ralph_msg_${randomUUID()}`;
-        return await new Promise((resolve, reject) => { let settled = false; let deltaAnswer = ''; let finalAnswer = ''; let lastSessionError; 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(() => finish(new Error(lastSessionError ? `Ralph run timed out after session error: ${lastSessionError}` : 'Ralph run timed out')), this.runTimeoutMs); unsubscribe = this.options.context.subscribe((event) => { if (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;
-            const providerAttempt = event.errorDetails?.origin === 'provider' && Boolean(event.errorDetails.api || event.errorDetails.provider || event.errorDetails.model);
-            if (!providerAttempt || options.isCancelled?.())
-                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)))); });
+        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;
+                    const providerAttempt = event.errorDetails?.origin === 'provider' && Boolean(event.errorDetails.api || event.errorDetails.provider || event.errorDetails.model);
+                    if (!providerAttempt || options.isCancelled?.())
+                        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/store.js

@@ -328,7 +328,7 @@ export class PiboRalphStore {
         if (!job)
             return;
         const timestamp = nowIso(now);
-        const state = { ...job.state, runningAt: undefined, conditionStates: input.conditionStates ?? job.state.conditionStates, lastStopEvaluation: input.evaluation };
+        const state = { ...job.state, conditionStates: input.conditionStates ?? job.state.conditionStates, lastStopEvaluation: input.evaluation };
         this.db.prepare('UPDATE pibo_ralph_jobs SET enabled = ?, state_json = ?, updated_at = ? WHERE id = ?').run(input.disable ? 0 : job.enabled ? 1 : 0, JSON.stringify(state), timestamp, job.id);
     }
     completeRun(input, now = new Date()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.7.11",
+  "version": "1.7.12",
   "type": "module",
   "imports": {
     "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"