@pasko70/pibo 1.7.11 → 1.8.0

package/dist/core/runtime.js

@@ -14,7 +14,7 @@ import { getMcpAgentContextFile } from "../mcp/agent-context.js";
 import { createPiboSystemPromptTemplateExtension } from "./system-prompt-template.js";
 import { getActivePiboBasePromptPath } from "./base-prompt.js";
 import { createPiboCompactionPromptExtension } from "./compaction-prompt.js";
-import { createPiboAssistantContextGuardExtension } from "./context-guard.js";
+import { cancelPiboAssistantContextGuardRecovery, createPiboAssistantContextGuardExtension, createPiboAssistantContextGuardRecovery, isPiboAssistantContextGuardRecoveryPending, registerPiboAssistantContextGuardRecovery, } from "./context-guard.js";
 import { getPiPackageRuntimeOptions } from "../pi-packages/runtime.js";
 import { getDefaultPiboWorkspace } from "./workspace.js";
 import { DEFAULT_USER_TIMEZONE } from "./user-settings.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);
 }
@@ -145,10 +166,10 @@ function getBuiltinToolAllowlist(profile, customTools) {
         return undefined;
     return [...selectedBuiltinTools, ...customTools.map((tool) => tool.name)];
 }
-function getProfileExtensionFactories(profile, extensionFactories) {
+function getProfileExtensionFactories(profile, extensionFactories, contextGuardRecovery) {
     const piboPromptTemplateExtension = createPiboSystemPromptTemplateExtension();
     const piboCompactionPromptExtension = createPiboCompactionPromptExtension();
-    const piboContextGuardExtension = createPiboAssistantContextGuardExtension();
+    const piboContextGuardExtension = createPiboAssistantContextGuardExtension({}, contextGuardRecovery);
     const providerToolExtensions = profile.tools
         .filter((tool) => tool.enabled !== false)
         .filter(isWebSearchProviderTool)
@@ -213,6 +234,7 @@ export async function createPiboRuntime(options = {}) {
     const sessionManager = await createSessionManager(cwd, profile, options.persistSession !== false);
     const authStorage = AuthStorage.create();
     const createRuntime = async ({ cwd: runtimeCwd, agentDir: runtimeAgentDir, sessionManager: runtimeSessionManager, sessionStartEvent, }) => {
+        const contextGuardRecovery = createPiboAssistantContextGuardRecovery();
         const contextFiles = await loadContextFiles(runtimeCwd, profile.contextFiles);
         const sessionContextFile = createSessionContextFile({ piboSessionId: profile.sessionId, ...options.sessionContext });
         const installedToolContextFile = getInstalledCliToolContextFile();
@@ -226,7 +248,7 @@ export async function createPiboRuntime(options = {}) {
             resourceLoaderOptions: {
                 ...piPackageOptions.resourceLoaderOptions,
                 additionalSkillPaths: skillPaths,
-                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories),
+                extensionFactories: getProfileExtensionFactories(profile, options.extensionFactories, contextGuardRecovery),
                 noExtensions: true,
                 noSkills: true,
                 noPromptTemplates: true,
@@ -243,6 +265,7 @@ export async function createPiboRuntime(options = {}) {
                 }),
             },
         });
+        applyPiboRuntimeRetryDefaults(services.settingsManager, options.retryDefaults);
         registerOpenAiGpt56Models(services.modelRegistry);
         registerMiniMaxProvider(services.modelRegistry);
         registerGlmProvider(services.modelRegistry);
@@ -271,6 +294,10 @@ export async function createPiboRuntime(options = {}) {
             tools: getBuiltinToolAllowlist(profile, customTools),
         });
         installValidationOutputCompaction(created.session.agent);
+        registerPiboAssistantContextGuardRecovery(created.session, contextGuardRecovery);
+        if (options.contextGuardTuiQueueOrdering === true) {
+            installPiboContextGuardTuiQueueOrdering(created.session);
+        }
         const resourceLoader = services.resourceLoader;
         const diagnostics = [
             ...piPackageOptions.diagnostics,
@@ -281,13 +308,14 @@ export async function createPiboRuntime(options = {}) {
                 message: `Failed to load extension "${path}": ${error}`,
             })),
         ];
-        if (localRuntimeRegistry) {
-            const originalDispose = created.session.dispose.bind(created.session);
-            created.session.dispose = () => {
+        const originalDispose = created.session.dispose.bind(created.session);
+        created.session.dispose = () => {
+            cancelPiboAssistantContextGuardRecovery(created.session, new Error("Context guard recovery cancelled because the Pi session was disposed"));
+            if (localRuntimeRegistry) {
                 void localRuntimeRegistry.closeControllerSessions(profile.sessionId ?? "local", { force: true });
-                originalDispose();
-            };
-        }
+            }
+            originalDispose();
+        };
         return {
             ...created,
             services,
@@ -434,6 +462,39 @@ export async function inspectPiboProfile(options = {}) {
         await runtime.dispose();
     }
 }
+function installPiboContextGuardTuiQueueOrdering(session) {
+    const originalSubscribe = session.subscribe.bind(session);
+    const originalPrompt = session.prompt.bind(session);
+    const originalSteer = session.steer.bind(session);
+    session.subscribe = ((listener) => originalSubscribe((event) => {
+        if (event.type === "compaction_end"
+            && event.result
+            && isPiboAssistantContextGuardRecoveryPending(session)) {
+            listener({ ...event, willRetry: true });
+            return;
+        }
+        listener(event);
+    }));
+    session.prompt = async (text, options) => {
+        if (isPiboAssistantContextGuardRecoveryPending(session)) {
+            if (!session.isStreaming) {
+                await session.followUp(text, options?.images);
+                options?.preflightResult?.(true);
+                return;
+            }
+            await originalPrompt(text, { ...options, streamingBehavior: "followUp" });
+            return;
+        }
+        await originalPrompt(text, options);
+    };
+    session.steer = async (text, images) => {
+        if (isPiboAssistantContextGuardRecoveryPending(session)) {
+            await session.followUp(text, images);
+            return;
+        }
+        await originalSteer(text, images);
+    };
+}
 export async function runPiboTui(options = {}) {
     const profile = options.profile ?? createDefaultPiboProfile();
     const hasEnabledSubagents = profile.subagents.some((subagent) => subagent.enabled !== false);
@@ -443,7 +504,7 @@ export async function runPiboTui(options = {}) {
         process.exitCode = 1;
         return;
     }
-    const runtime = await createPiboRuntime({ ...options, profile });
+    const runtime = await createPiboRuntime({ ...options, profile, contextGuardTuiQueueOrdering: true });
     try {
         const fatal = runtime.diagnostics.find((diagnostic) => diagnostic.type === "error");
         for (const diagnostic of runtime.diagnostics) {

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,15 @@ 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;
+const DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS = 30 * 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;
@@ -124,6 +133,8 @@ export class PiboSessionRouter {
     signalRegistry;
     runtimeRegistry;
     scheduledRunReminders = new Map();
+    idleSessionTimers = new Map();
+    routedSessionIdleTimeoutMs;
     baseProfile;
     pluginRegistry;
     sessionStore;
@@ -138,6 +149,12 @@ export class PiboSessionRouter {
         this.telemetryRecorder = this.telemetryStore
             ? new PiboRuntimeTelemetryRecorder(this.telemetryStore, undefined, { providerEventMode: providerEventTelemetryModeFromEnv() })
             : undefined;
+        const idleTimeoutMs = options.routedSessionIdleTimeoutMs;
+        this.routedSessionIdleTimeoutMs = idleTimeoutMs === false
+            ? false
+            : typeof idleTimeoutMs === "number" && Number.isFinite(idleTimeoutMs) && idleTimeoutMs > 0
+                ? idleTimeoutMs
+                : DEFAULT_ROUTED_SESSION_IDLE_TIMEOUT_MS;
         const defaultProfileName = selectDefaultPiboProfileName(this.pluginRegistry);
         this.baseProfile = options.profile ?? createPiboProfileFromRegistryOrDefault(this.pluginRegistry, defaultProfileName);
         this.reliabilityStore = options.reliabilityStore ?? (options.persistSession === false ? undefined : createDefaultPiboReliabilityStore());
@@ -157,20 +174,29 @@ export class PiboSessionRouter {
     }
     async emit(event) {
         const session = await this.getOrCreateSession(event.piboSessionId);
-        if (event.type === "message") {
-            return session.enqueueMessage(event);
-        }
-        const output = await session.executeAction(event);
-        if (event.action === "abort") {
-            this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
-        }
-        if (event.action === "dispose") {
-            this.disposeSignalSubtree(event.piboSessionId, "dispose action");
+        this.clearIdleSessionTimer(event.piboSessionId);
+        try {
+            if (event.type === "message") {
+                return session.enqueueMessage(event);
+            }
+            const output = await session.executeAction(event);
+            if (event.action === "abort") {
+                this.signalRegistry.project({ type: "session_interrupted", piboSessionId: event.piboSessionId, reason: "abort action" });
+            }
+            if (event.action === "dispose") {
+                await this.disposeSessionSubtree(event.piboSessionId, "dispose action", { cancelRuns: true });
+            }
+            else if (event.action === "kill" || event.action === "kill_all") {
+                await this.disposeSessionSubtree(event.piboSessionId, `${event.action} action`, { cancelRuns: event.action === "kill_all" });
+            }
+            else if (shouldResetSessionAfterAction(event.action)) {
+                await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+            }
+            return output;
         }
-        else if (shouldResetSessionAfterAction(event.action)) {
-            await this.resetCachedSession(event.piboSessionId, "provider auth changed");
+        finally {
+            this.scheduleIdleSessionEvictionIfIdle(event.piboSessionId);
         }
-        return output;
     }
     async killSession(piboSessionId, options) {
         const killed = [];
@@ -182,23 +208,32 @@ export class PiboSessionRouter {
                 const runs = this.runRegistry.cancelControllerRuns(piboSessionId);
                 cancelledRuns.push(...runs.map((r) => r.runId));
             }
-            await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
             this.signalRegistry.project({ type: "session_interrupted", piboSessionId, reason: "kill" });
             const children = await this.killChildSessions(piboSessionId, options);
             killed.push(...children.killed);
             cancelledRuns.push(...children.cancelledRuns);
+            await this.disposeSessionSubtree(piboSessionId, "kill", { cancelRuns: false });
         }
         return { killed, cancelledRuns };
     }
-    disposeSignalSubtree(piboSessionId, reason) {
-        const descendants = this.descendantSessionIds(piboSessionId);
-        for (const id of [piboSessionId, ...descendants]) {
-            this.runRegistry.cancelControllerRuns(id);
-            void this.runtimeRegistry.closeControllerSessions(id, { force: true });
-            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+    async disposeSessionSubtree(piboSessionId, reason, options) {
+        const ids = [piboSessionId, ...this.descendantSessionIds(piboSessionId)];
+        const sessions = [];
+        for (const id of ids) {
+            if (options.cancelRuns)
+                this.runRegistry.cancelControllerRuns(id);
+            this.clearIdleSessionTimer(id);
             this.scheduledRunReminders.delete(id);
+            const cached = this.sessions.get(id);
+            if (cached)
+                sessions.push(cached);
             this.sessions.delete(id);
         }
+        await Promise.all(ids.map((id) => this.runtimeRegistry.closeControllerSessions(id, { force: true })));
+        await Promise.all(sessions.map((session) => session.dispose()));
+        for (const id of ids) {
+            this.signalRegistry.project({ type: "session_disposed", piboSessionId: id, reason });
+        }
     }
     descendantSessionIds(parentId) {
         const output = [];
@@ -319,6 +354,9 @@ export class PiboSessionRouter {
     async disposeAll() {
         const sessions = [...this.sessions.values()];
         this.sessions.clear();
+        for (const timer of this.idleSessionTimers.values())
+            clearTimeout(timer);
+        this.idleSessionTimers.clear();
         this.runRegistry.cancelAll("Pibo session router was disposed.");
         for (const session of sessions)
             this.signalRegistry.project({ type: "session_disposed", piboSessionId: session.getStatus().piboSessionId, reason: "router disposed" });
@@ -326,10 +364,54 @@ export class PiboSessionRouter {
         await this.runtimeRegistry.closeAll({ force: true });
         await Promise.all(sessions.map((session) => session.dispose()));
     }
+    clearIdleSessionTimer(piboSessionId) {
+        const timer = this.idleSessionTimers.get(piboSessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.idleSessionTimers.delete(piboSessionId);
+    }
+    scheduleIdleSessionEvictionIfIdle(piboSessionId) {
+        if (this.routedSessionIdleTimeoutMs === false)
+            return;
+        const session = this.sessions.get(piboSessionId);
+        if (!session)
+            return;
+        const status = session.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0) {
+            this.clearIdleSessionTimer(piboSessionId);
+            return;
+        }
+        this.clearIdleSessionTimer(piboSessionId);
+        const timer = setTimeout(() => {
+            this.idleSessionTimers.delete(piboSessionId);
+            void this.evictIdleSession(piboSessionId, session).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                this.emitOutput({
+                    type: "session_error",
+                    piboSessionId,
+                    error: `Failed to dispose idle routed runtime: ${message}`,
+                    errorDetails: runtimeSessionErrorDetails(message),
+                });
+            });
+        }, this.routedSessionIdleTimeoutMs);
+        timer.unref();
+        this.idleSessionTimers.set(piboSessionId, timer);
+    }
+    async evictIdleSession(piboSessionId, expected) {
+        const current = this.sessions.get(piboSessionId);
+        if (current !== expected)
+            return;
+        const status = current.getStatus();
+        if (status.disposed || status.processing || status.streaming || status.queuedMessages > 0)
+            return;
+        await this.resetCachedSession(piboSessionId, "routed runtime idle timeout");
+    }
     async getOrCreateSession(piboSessionId) {
         const existing = this.sessions.get(piboSessionId);
-        if (existing)
+        if (existing) {
+            this.clearIdleSessionTimer(piboSessionId);
             return existing;
+        }
         const pending = this.pendingSessions.get(piboSessionId);
         if (pending)
             return pending;
@@ -360,6 +442,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] : []),
@@ -379,7 +462,16 @@ export class PiboSessionRouter {
         const initialFastMode = resolvePiboSessionInitialFastMode(piboSession) ?? selectRequestedFastMode(profileForSession(profile, piboSession.piSessionId, parentPiSessionId), modelDefaults) ?? false;
         const session = new RoutedSession(piboSession.id, runtime, this.emitOutput, this.pluginRegistry, this.options.forwardPiEvents ?? false, this.telemetryRecorder
             ? (id, event, context) => this.telemetryRecorder?.recordPiEvent(id, event, { session: this.sessionStore.get(id), status: context.status, activeEventId: context.activeEventId })
-            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages }));
+            : undefined, initialFastMode, (result, event) => this.handleSessionOperation(result, event), (id, opts) => this.killChildSessions(id, opts), (state) => {
+            this.signalRegistry.project({ type: "session_processing_changed", piboSessionId: piboSession.id, processing: state.processing, queuedMessages: state.queuedMessages });
+            if (state.disposed || state.processing || state.queuedMessages > 0)
+                this.clearIdleSessionTimer(piboSession.id);
+            else
+                this.scheduleIdleSessionEvictionIfIdle(piboSession.id);
+        }, (messages, reason) => this.telemetryRecorder?.recordMessagesInterrupted(messages, {
+            session: this.sessionStore.get(piboSession.id),
+            status: this.sessions.get(piboSession.id)?.getStatus(),
+        }, reason));
         this.sessions.set(piboSession.id, session);
         return session;
     }
@@ -438,6 +530,7 @@ export class PiboSessionRouter {
     }
     async resetCachedSession(piboSessionId, reason) {
         const cached = this.sessions.get(piboSessionId);
+        this.clearIdleSessionTimer(piboSessionId);
         this.sessions.delete(piboSessionId);
         await this.runtimeRegistry.closeControllerSessions(piboSessionId, { force: true });
         await cached?.dispose();

package/dist/data/telemetry.js

@@ -17,6 +17,61 @@ export class TelemetryStore {
     getTurnTimeline(turnIdOrEventId, input = {}) {
         return getTelemetryTurnTimeline(this.db, turnIdOrEventId, input);
     }
+    getOpenPhaseForTurn(turnId, name) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND name = ? AND status = 'open'
+			ORDER BY COALESCE(last_progress_at, started_at) DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId, name);
+        return row ? phaseFromRow(row) : undefined;
+    }
+    countPhasesForTurn(turnId, name) {
+        const row = this.db.prepare("SELECT COUNT(*) AS count FROM telemetry_phases WHERE turn_id = ? AND name = ?").get(turnId, name);
+        return Number(row.count);
+    }
+    listOpenPhasesForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_phases
+			WHERE turn_id = ? AND status = 'open'
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(phaseFromRow);
+    }
+    getLatestProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ?
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    getActiveProviderRequestForTurn(turnId) {
+        const row = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at DESC, created_at DESC
+			LIMIT 1
+		`).get(turnId);
+        return row ? providerRequestFromRow(row) : undefined;
+    }
+    listActiveProviderRequestsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_provider_requests
+			WHERE turn_id = ? AND status NOT IN ('completed', 'error', 'aborted', 'timeout')
+			ORDER BY started_at ASC, created_at ASC
+		`).all(turnId);
+        return rows.map(providerRequestFromRow);
+    }
+    listActiveToolCallsForTurn(turnId) {
+        const rows = this.db.prepare(`
+			SELECT * FROM telemetry_tool_calls
+			WHERE turn_id = ? AND status NOT IN ('ok', 'error', 'aborted', 'timeout')
+			ORDER BY created_at ASC
+		`).all(turnId);
+        return rows.map(toolCallFromRow);
+    }
     listProviderEventsPage(providerRequestId, input = {}) {
         return listTelemetryProviderEventsPage(this.db, providerRequestId, input);
     }
@@ -176,6 +231,53 @@ export class TelemetryStore {
         const normalizedDelta = input.normalizedEventDelta ?? (input.normalizedType ? 1 : 0);
         this.incrementProviderCounters(input.providerRequestId, input.eventType, receivedAt, byteSize, parseStatus, normalizedDelta);
     }
+    recordProviderProgress(input) {
+        const existing = this.getProviderRequest(input.providerRequestId);
+        if (!existing)
+            return undefined;
+        const eventTypeCounts = { ...existing.eventTypeCounts };
+        for (const [eventType, delta] of Object.entries(input.eventTypeCounts ?? {})) {
+            if (!Number.isFinite(delta) || delta <= 0)
+                continue;
+            const current = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
+            eventTypeCounts[eventType] = current + delta;
+        }
+        const rawEventCount = Math.max(0, input.rawEventCount ?? 0);
+        const normalizedEventCount = Math.max(0, input.normalizedEventCount ?? 0);
+        const parseErrorCount = Math.max(0, input.parseErrorCount ?? 0);
+        const unknownEventCount = Math.max(0, input.unknownEventCount ?? 0);
+        const bytesReceived = Math.max(0, input.bytesReceived ?? 0);
+        const updatedAt = input.updatedAt ?? input.lastNormalizedEventAt ?? input.lastRawEventAt ?? new Date().toISOString();
+        this.db.prepare(`
+			UPDATE telemetry_provider_requests SET
+				status = CASE WHEN status IN ('completed', 'error', 'aborted', 'timeout') THEN status ELSE COALESCE(?, status) END,
+				last_raw_event_at = COALESCE(?, last_raw_event_at),
+				last_normalized_event_at = COALESCE(?, last_normalized_event_at),
+				upstream_response_id = COALESCE(?, upstream_response_id),
+				raw_event_count = raw_event_count + ?,
+				normalized_event_count = normalized_event_count + ?,
+				parse_error_count = parse_error_count + ?,
+				unknown_event_count = unknown_event_count + ?,
+				bytes_received = CASE WHEN ? = 0 THEN bytes_received ELSE COALESCE(bytes_received, 0) + ? END,
+				event_type_counts_json = ?,
+				updated_at = ?
+			WHERE provider_request_id = ?
+		`).run(input.status ?? null, input.lastRawEventAt ?? null, input.lastNormalizedEventAt ?? null, input.upstreamResponseId ?? null, rawEventCount, normalizedEventCount, parseErrorCount, unknownEventCount, bytesReceived, bytesReceived, JSON.stringify(eventTypeCounts), updatedAt, input.providerRequestId);
+        return {
+            ...existing,
+            status: isTerminalProviderRequestStatus(existing.status) ? existing.status : input.status ?? existing.status,
+            lastRawEventAt: input.lastRawEventAt ?? existing.lastRawEventAt,
+            lastNormalizedEventAt: input.lastNormalizedEventAt ?? existing.lastNormalizedEventAt,
+            upstreamResponseId: input.upstreamResponseId ?? existing.upstreamResponseId,
+            rawEventCount: existing.rawEventCount + rawEventCount,
+            normalizedEventCount: existing.normalizedEventCount + normalizedEventCount,
+            parseErrorCount: existing.parseErrorCount + parseErrorCount,
+            unknownEventCount: existing.unknownEventCount + unknownEventCount,
+            bytesReceived: bytesReceived > 0 ? (existing.bytesReceived ?? 0) + bytesReceived : existing.bytesReceived,
+            eventTypeCounts,
+            updatedAt,
+        };
+    }
     appendProviderEventSummary(input) {
         const now = input.updatedAt ?? new Date().toISOString();
         const receivedAt = input.receivedAt ?? now;
@@ -293,34 +395,15 @@ export class TelemetryStore {
         return row.next_sequence;
     }
     incrementProviderCounters(providerRequestId, eventType, receivedAt, byteSize, parseStatus, normalizedDelta) {
-        const existing = this.getProviderRequest(providerRequestId);
-        if (!existing)
-            return;
-        const eventTypeCounts = { ...existing.eventTypeCounts };
-        const currentCount = typeof eventTypeCounts[eventType] === "number" ? eventTypeCounts[eventType] : 0;
-        eventTypeCounts[eventType] = currentCount + 1;
-        this.upsertProviderRequest({
+        this.recordProviderProgress({
             providerRequestId,
-            piboSessionId: existing.piboSessionId,
-            rootSessionId: existing.rootSessionId,
-            roomId: existing.roomId,
-            turnId: existing.turnId,
-            phaseId: existing.phaseId,
-            provider: existing.provider,
-            api: existing.api,
-            model: existing.model,
-            transport: existing.transport,
-            serviceTier: existing.serviceTier,
-            status: existing.status,
             lastRawEventAt: receivedAt,
-            rawEventCount: existing.rawEventCount + 1,
-            normalizedEventCount: existing.normalizedEventCount + normalizedDelta,
-            parseErrorCount: existing.parseErrorCount + (parseStatus === "invalid_json" ? 1 : 0),
-            unknownEventCount: existing.unknownEventCount + (parseStatus === "unknown_type" ? 1 : 0),
-            bytesReceived: (existing.bytesReceived ?? 0) + byteSize,
-            eventTypeCounts,
-            captureMode: existing.captureMode,
-            retentionClass: existing.retentionClass,
+            rawEventCount: 1,
+            normalizedEventCount: normalizedDelta,
+            parseErrorCount: parseStatus === "invalid_json" ? 1 : 0,
+            unknownEventCount: parseStatus === "unknown_type" ? 1 : 0,
+            bytesReceived: byteSize,
+            eventTypeCounts: { [eventType]: 1 },
             updatedAt: receivedAt,
         });
     }
@@ -347,6 +430,9 @@ export class BestEffortTelemetryService {
     recordProviderEventSummary(input) {
         this.safe(() => this.store?.recordProviderEventSummary(input));
     }
+    recordProviderProgress(input) {
+        return this.safe(() => this.store?.recordProviderProgress(input));
+    }
     appendProviderEventSummary(input) {
         return this.safe(() => this.store?.appendProviderEventSummary(input));
     }
@@ -363,6 +449,9 @@ export class BestEffortTelemetryService {
         }
     }
 }
+function isTerminalProviderRequestStatus(status) {
+    return status === "completed" || status === "error" || status === "aborted" || status === "timeout";
+}
 function fail(message) {
     throw new Error(message);
 }

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);