@pasko70/pibo 3.0.1 → 3.1.0

package/dist/debug/index.js

@@ -604,6 +604,8 @@ async function runDebugEvents(args) {
         if (!selector)
             throw new Error("pibo debug events <pibo-session-id> show requires <stream-id-or-event-id>");
         const result = inspectDebugEventShow(piboSessionId, resolveDebugStore("chat"), selector, { ...detailOptions(options), payload: options.payload, raw: options.raw, field: options.field });
+        if (!result.event)
+            process.exitCode = 1;
         if (options.json)
             console.log(formatJson(result));
         else
@@ -639,7 +641,7 @@ async function runDebugJobs(args) {
         if (command === "list") {
             const jobs = reliability.listJobs({ queue: options.queue, limit: options.limit ? Number(options.limit) : undefined });
             if (options.json)
-                console.log(formatJson({ jobs }));
+                console.log(formatJson({ jobs: jobs.map(observableJobRow) }));
             else
                 console.log(formatRows(jobs.map(compactJobRow)));
             return;
@@ -647,7 +649,7 @@ async function runDebugJobs(args) {
         if (command === "dead") {
             const jobs = reliability.listDead({ queue: options.queue, limit: options.limit ? Number(options.limit) : undefined });
             if (options.json)
-                console.log(formatJson({ jobs }));
+                console.log(formatJson({ jobs: jobs.map(observableDeadJobRow) }));
             else
                 console.log(formatRows(jobs.map(compactDeadJobRow)));
             return;
@@ -976,26 +978,68 @@ function compactEventRow(event) {
     };
 }
 function compactJobRow(job) {
+    const correlation = outputPersistenceJobCorrelation(job.payload);
     return {
         jobId: job.jobId,
         queue: job.queue,
         state: job.state,
         runAt: job.runAt,
         attempts: `${job.attempts}/${job.maxAttempts}`,
+        piboSessionId: correlation.piboSessionId,
+        eventId: correlation.eventId,
+        phase: correlation.phase,
         workerId: job.workerId,
         lastError: job.lastError,
     };
 }
 function compactDeadJobRow(job) {
+    const correlation = outputPersistenceJobCorrelation(job.payload);
     return {
         jobId: job.jobId,
         queue: job.queue,
         attempts: `${job.attempts}/${job.maxAttempts}`,
+        piboSessionId: correlation.piboSessionId,
+        eventId: correlation.eventId,
+        phase: correlation.phase,
         deadAt: job.deadAt,
         deadReason: job.deadReason,
         lastError: job.lastError,
     };
 }
+function observableJobRow(job) {
+    return { ...compactJobRow(job), attempts: job.attempts, maxAttempts: job.maxAttempts };
+}
+function observableDeadJobRow(job) {
+    return { ...compactDeadJobRow(job), attempts: job.attempts, maxAttempts: job.maxAttempts };
+}
+function outputPersistenceJobCorrelation(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return {};
+    const envelope = payload;
+    const state = envelope.state;
+    let phase;
+    if (state && typeof state === "object" && !Array.isArray(state)) {
+        const deliveries = state.deliveries;
+        if (Array.isArray(deliveries) && deliveries.length) {
+            const rows = deliveries.filter((delivery) => !!delivery && typeof delivery === "object" && !Array.isArray(delivery));
+            if (rows.length === deliveries.length) {
+                if (rows.every((delivery) => delivery.sideEffectsDelivered === true || delivery.persisted === true))
+                    phase = "delivered";
+                else if (rows.every((delivery) => delivery.reliabilityDelivered === true))
+                    phase = "side-effects";
+                else if (rows.every((delivery) => delivery.v2 !== undefined))
+                    phase = "reliability";
+                else
+                    phase = "v2";
+            }
+        }
+    }
+    return {
+        ...(typeof envelope.piboSessionId === "string" ? { piboSessionId: envelope.piboSessionId } : {}),
+        ...(typeof envelope.eventId === "string" ? { eventId: envelope.eventId } : {}),
+        ...(phase ? { phase } : {}),
+    };
+}
 function compactRunRow(run) {
     return {
         runId: run.runId,

package/dist/debug/pty.js

@@ -1,6 +1,7 @@
 import { spawn, spawnSync } from "node:child_process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { performance } from "node:perf_hooks";
 const DEFAULT_ROWS = 24;
 const DEFAULT_COLS = 100;
 const DEFAULT_TIMEOUT_MS = 60_000;
@@ -95,6 +96,12 @@ if exit_code is None:
     exit_code = proc.wait(timeout=1)
 sys.exit(exit_code if exit_code is not None else 1)
 `;
+class WallClockTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`PTY command timed out after ${timeoutMs}ms`);
+        this.name = "WallClockTimeoutError";
+    }
+}
 export async function runDebugPty(args) {
     if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
         printPtyDiscovery();
@@ -409,26 +416,31 @@ function parseSteps(value, source) {
 }
 async function executePtyScenario(input, options) {
     const scenario = normalizeScenario(input, options);
-    const started = Date.now();
-    const startedAt = new Date(started).toISOString();
+    const startedAt = new Date().toISOString();
+    const started = performance.now();
+    const deadline = createDeadline(scenario.timeoutMs, started);
     let runner;
     const assertions = [];
     let iterations = 0;
     let stopReason = "completed";
+    let exitCode = null;
+    let signal = null;
     try {
         validateProviderSafety(scenario, options);
         runner = await startRunner(scenario);
-        let lastOutputAt = Date.now();
+        throwIfDeadlineExpired(deadline);
+        let lastOutputAt = performance.now();
         let outputLength = 0;
         const refreshOutputTimestamp = () => {
             const raw = runner?.getRawOutput() ?? "";
             if (raw.length !== outputLength) {
                 outputLength = raw.length;
-                lastOutputAt = Date.now();
+                lastOutputAt = performance.now();
             }
             return lastOutputAt;
         };
         for (const step of scenario.steps) {
+            throwIfDeadlineExpired(deadline);
             if (step.iteration === true) {
                 iterations += 1;
                 if (scenario.providerMode === "real" && scenario.maxIterations !== undefined && iterations > scenario.maxIterations) {
@@ -437,7 +449,8 @@ async function executePtyScenario(input, options) {
                 }
             }
             await checkIdle(runner, refreshOutputTimestamp, scenario.idleTimeoutMs);
-            await runStep(runner, scenario, step, assertions, refreshOutputTimestamp);
+            await runStep(runner, scenario, step, assertions, refreshOutputTimestamp, deadline);
+            throwIfDeadlineExpired(deadline);
             refreshOutputTimestamp();
             const clean = cleanTerminalText(runner.getRawOutput());
             const matchedStop = scenario.stopPatterns.find((pattern) => clean.includes(pattern));
@@ -446,32 +459,40 @@ async function executePtyScenario(input, options) {
                 break;
             }
         }
-        const exit = await waitForExitOrIdle(runner, Math.max(1, scenario.timeoutMs - (Date.now() - started)), scenario.idleTimeoutMs, refreshOutputTimestamp);
+        const stoppedByPattern = stopReason.startsWith("stop_pattern:");
+        if (stoppedByPattern)
+            await runner.terminate(stopReason);
+        const exit = await waitForExitOrIdle(runner, deadline, scenario.idleTimeoutMs, refreshOutputTimestamp);
+        exitCode = exit.exitCode;
+        signal = exit.signal;
         if (exit.idleTimedOut) {
             stopReason = "idle_timeout";
             throw new Error(`PTY command produced no output for ${scenario.idleTimeoutMs}ms`);
         }
         if (exit.timedOut) {
-            stopReason = stopReason === "completed" ? "wall_clock_timeout" : stopReason;
-            throw new Error(`PTY command timed out after ${scenario.timeoutMs}ms`);
+            throw new WallClockTimeoutError(scenario.timeoutMs);
         }
+        throwIfDeadlineExpired(deadline);
         const clean = cleanTerminalText(runner.getRawOutput());
         assertPatterns(clean, scenario.expect, scenario.reject, assertions);
-        if (exit.exitCode !== 0) {
+        throwIfDeadlineExpired(deadline);
+        if (exit.exitCode !== 0 && !stoppedByPattern) {
             stopReason = `exit_code:${exit.exitCode ?? "signal"}`;
             throw new Error(`PTY command exited with status ${exit.exitCode ?? exit.signal ?? "unknown"}`);
         }
-        const result = buildResult(scenario, runner, true, assertions, iterations, started, startedAt, stopReason, exit.exitCode, exit.signal);
+        const result = buildResult(scenario, runner, true, assertions, iterations, started, startedAt, stopReason, exitCode, signal);
         if (scenario.writeArtifactsOnSuccess)
             result.artifactDir = await writeArtifacts(scenario, result);
         return result;
     }
     catch (error) {
-        if (stopReason === "completed")
+        if (error instanceof WallClockTimeoutError && stopReason === "completed")
+            stopReason = "wall_clock_timeout";
+        else if (stopReason === "completed")
             stopReason = runner ? "error" : "preflight_error";
         if (runner)
             await runner.terminate(stopReason);
-        const result = buildResult(scenario, runner, false, assertions, iterations, started, startedAt, stopReason, null, null);
+        const result = buildResult(scenario, runner, false, assertions, iterations, started, startedAt, stopReason, exitCode, signal);
         result.artifactDir = await writeArtifacts(scenario, result, error instanceof Error ? error.message : String(error));
         const message = `${error instanceof Error ? error.message : String(error)}\nPTY artifacts: ${result.artifactDir}`;
         throw new Error(message);
@@ -601,6 +622,26 @@ function wrapChild(child, backend, ptyMethod) {
         driverStderr += `${error.message}\n`;
         events.push({ t: Date.now(), source: "system", kind: "error", detail: error.message });
     });
+    const waitForExit = async (timeoutMs) => {
+        if (exitState)
+            return { ...exitState, timedOut: false };
+        if (timeoutMs <= 0)
+            return { exitCode: null, signal: null, timedOut: true };
+        return new Promise((resolve) => {
+            let settled = false;
+            let timer;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve(value);
+            };
+            exitPromise.then((value) => finish({ ...value, timedOut: false }));
+            timer = setTimeout(() => finish({ exitCode: null, signal: null, timedOut: true }), timeoutMs);
+        });
+    };
     return {
         backend,
         ptyMethod,
@@ -615,51 +656,46 @@ function wrapChild(child, backend, ptyMethod) {
             if (exitState)
                 return;
             child.kill("SIGTERM");
-            await Promise.race([
-                exitPromise,
-                delay(1_000).then(() => {
-                    if (!exitState)
-                        child.kill("SIGKILL");
-                }),
-            ]);
-        },
-        async waitForExit(timeoutMs) {
-            if (exitState)
-                return { ...exitState, timedOut: false };
-            const timeout = delay(timeoutMs).then(() => ({ exitCode: null, signal: null, timedOut: true }));
-            const exit = exitPromise.then((value) => ({ ...value, timedOut: false }));
-            return Promise.race([exit, timeout]);
+            if (await waitForChildExit(exitPromise, 1_000))
+                return;
+            child.kill("SIGKILL");
+            await waitForChildExit(exitPromise, 1_000);
         },
+        waitForExit,
         getRawOutput: () => rawOutput,
         getDriverStderr: () => driverStderr,
         getEvents: () => events,
     };
 }
-async function runStep(runner, scenario, step, assertions, markOutput) {
+async function runStep(runner, scenario, step, assertions, markOutput, deadline) {
     if (step.waitFor !== undefined) {
-        await waitForText(runner, step.waitFor, step.timeoutMs ?? scenario.timeoutMs, scenario.idleTimeoutMs, markOutput);
+        await waitForText(runner, step.waitFor, step.timeoutMs ?? scenario.timeoutMs, scenario.idleTimeoutMs, markOutput, deadline);
         return;
     }
     if (step.typeText !== undefined) {
         for (const char of step.typeText) {
+            throwIfDeadlineExpired(deadline);
             await runner.write(char);
-            if (scenario.inputDelayMs > 0)
-                await delay(scenario.inputDelayMs);
+            throwIfDeadlineExpired(deadline);
+            await delayWithinDeadline(scenario.inputDelayMs, deadline);
         }
         return;
     }
     if (step.writeBytes !== undefined) {
+        throwIfDeadlineExpired(deadline);
         await runner.write(step.writeBytes);
+        throwIfDeadlineExpired(deadline);
         return;
     }
     if (step.press !== undefined) {
+        throwIfDeadlineExpired(deadline);
         await runner.write(keySequence(step.press));
-        if (scenario.inputDelayMs > 0)
-            await delay(scenario.inputDelayMs);
+        throwIfDeadlineExpired(deadline);
+        await delayWithinDeadline(scenario.inputDelayMs, deadline);
         return;
     }
     if (step.sleepMs !== undefined) {
-        await delay(step.sleepMs);
+        await delayWithinDeadline(step.sleepMs, deadline);
         return;
     }
     const clean = cleanTerminalText(runner.getRawOutput());
@@ -670,35 +706,41 @@ async function runStep(runner, scenario, step, assertions, markOutput) {
     if (step.reject !== undefined)
         assertPatterns(clean, [], [step.reject], assertions);
 }
-async function waitForText(runner, pattern, timeoutMs, idleTimeoutMs, markOutput) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
+async function waitForText(runner, pattern, timeoutMs, idleTimeoutMs, markOutput, globalDeadline) {
+    const stepDeadline = performance.now() + timeoutMs;
+    while (true) {
+        throwIfDeadlineExpired(globalDeadline);
         const lastOutputAt = markOutput();
         if (cleanTerminalText(runner.getRawOutput()).includes(pattern))
             return;
-        if (Date.now() - lastOutputAt > idleTimeoutMs) {
+        const now = performance.now();
+        if (now - lastOutputAt > idleTimeoutMs) {
             await runner.terminate("idle_timeout");
             throw new Error(`PTY command produced no output for ${idleTimeoutMs}ms while waiting for ${JSON.stringify(pattern)}`);
         }
-        await delay(50);
+        if (now >= stepDeadline)
+            break;
+        await delay(Math.max(1, Math.min(50, stepDeadline - now, remainingMs(globalDeadline), idleTimeoutMs - (now - lastOutputAt))));
     }
     throw new Error(`Timed out waiting for PTY output ${JSON.stringify(pattern)} after ${timeoutMs}ms`);
 }
-async function waitForExitOrIdle(runner, timeoutMs, idleTimeoutMs, markOutput) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
+async function waitForExitOrIdle(runner, deadline, idleTimeoutMs, markOutput) {
+    while (remainingMs(deadline) > 0) {
         const lastOutputAt = markOutput();
-        const remaining = Math.max(1, Math.min(100, deadline - Date.now()));
+        const remaining = Math.max(1, Math.min(100, remainingMs(deadline)));
         const exit = await runner.waitForExit(remaining);
-        if (!exit.timedOut)
+        if (!exit.timedOut) {
+            if (remainingMs(deadline) <= 0)
+                return { exitCode: null, signal: null, timedOut: true, idleTimedOut: false };
             return { ...exit, timedOut: false, idleTimedOut: false };
-        if (Date.now() - lastOutputAt > idleTimeoutMs)
+        }
+        if (performance.now() - lastOutputAt > idleTimeoutMs)
             return { exitCode: null, signal: null, timedOut: false, idleTimedOut: true };
     }
     return { exitCode: null, signal: null, timedOut: true, idleTimedOut: false };
 }
 async function checkIdle(runner, lastOutputAt, idleTimeoutMs) {
-    if (Date.now() - lastOutputAt() > idleTimeoutMs) {
+    if (performance.now() - lastOutputAt() > idleTimeoutMs) {
         await runner.terminate("idle_timeout");
         throw new Error(`PTY command produced no output for ${idleTimeoutMs}ms`);
     }
@@ -741,7 +783,7 @@ function cleanTerminalText(raw) {
         .replace(/\r/g, "\n");
 }
 function buildResult(scenario, runner, ok, assertions, iterations, started, startedAt, stopReason, exitCode, signal) {
-    const ended = Date.now();
+    const endedAt = new Date().toISOString();
     return {
         ok,
         name: scenario.name,
@@ -750,8 +792,8 @@ function buildResult(scenario, runner, ok, assertions, iterations, started, star
         signal,
         stopReason,
         startedAt,
-        endedAt: new Date(ended).toISOString(),
-        durationMs: ended - started,
+        endedAt,
+        durationMs: Math.round(performance.now() - started),
         rawOutput: runner?.getRawOutput() ?? "",
         driverStderr: runner?.getDriverStderr() ?? "",
         events: runner?.getEvents() ?? [],
@@ -915,9 +957,46 @@ function optionalStringRecord(value, field, source) {
 function safeName(name) {
     return name.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "pty-scenario";
 }
+function createDeadline(timeoutMs, started = performance.now()) {
+    return { expiresAt: started + timeoutMs, timeoutMs };
+}
+function remainingMs(deadline) {
+    return Math.max(0, deadline.expiresAt - performance.now());
+}
+function throwIfDeadlineExpired(deadline) {
+    if (remainingMs(deadline) <= 0)
+        throw new WallClockTimeoutError(deadline.timeoutMs);
+}
+async function delayWithinDeadline(ms, deadline) {
+    throwIfDeadlineExpired(deadline);
+    if (ms <= 0)
+        return;
+    const remaining = remainingMs(deadline);
+    if (ms >= remaining) {
+        await delay(remaining);
+        throw new WallClockTimeoutError(deadline.timeoutMs);
+    }
+    await delay(ms);
+    throwIfDeadlineExpired(deadline);
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function waitForChildExit(exitPromise, timeoutMs) {
+    let timeout;
+    try {
+        return await Promise.race([
+            exitPromise.then(() => true),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(false), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
 export const __debugPtyForTests = {
     cleanTerminalText,
     keySequence,

package/dist/gateway/cli.js

@@ -407,6 +407,10 @@ export async function runGatewayCli(argv = process.argv) {
     const subcommand = args[1];
     const hasForceFlag = args.includes("--force");
     if (subcommand === "web" || subcommand === "dev") {
+        if (args.slice(2).some((arg) => arg === "--help" || arg === "-h")) {
+            printGatewayHelp();
+            return;
+        }
         const handled = await runManagedGatewayCommand(subcommand, args[2], args.slice(3), argv);
         if (!handled) {
             console.error(`Unknown gateway ${subcommand} subcommand: ${args[2] ?? ""}`);

package/dist/gateway/web.js

@@ -1,11 +1,9 @@
 import { CHAT_WEB_APP_NAME } from "../apps/chat/web-app.js";
 import { createDefaultPiboPlugins } from "../plugins/builtin.js";
 import { createPiboBetterAuthPlugin } from "../plugins/better-auth.js";
-import { createPiboChatCustomAgentProfilesPlugin } from "../plugins/chat-custom-agents.js";
-import { createPiboChatUserSkillsPlugin } from "../plugins/chat-user-skills.js";
 import { createPiboChatWebPlugin } from "../plugins/chat-web.js";
 import { createPiboChatVscodeWebPlugin } from "../plugins/chat-vscode-web.js";
-import { createPiboContextFilesPlugin } from "../plugins/context-files.js";
+import { createPiboUserProfileResourcePlugins } from "../plugins/user-profile-resources.js";
 import { createPiboPreviewPlugin } from "../previews/plugin.js";
 import { createPiboCronPlugin } from "../cron/plugin.js";
 import { createPiboLoopPlugin } from "../loops/plugin.js";
@@ -154,13 +152,15 @@ export function createWebPiboPluginRegistry(options = {}) {
                 landingAppName: CHAT_WEB_APP_NAME,
             }),
             createPiboCronPlugin({ cronStorePath: resolvedOptions.chat?.cronStorePath, dataStorePath: resolvedOptions.chat?.dataStorePath, dataPayloadRootDir: resolvedOptions.chat?.dataPayloadRootDir }),
-            createPiboChatUserSkillsPlugin({
-                globalRoot: resolvedOptions.chat?.userSkillGlobalRoot,
-                workspaceRoot: resolvedOptions.chat?.userSkillWorkspaceRoot,
+            ...createPiboUserProfileResourcePlugins({
+                userSkills: {
+                    globalRoot: resolvedOptions.chat?.userSkillGlobalRoot,
+                    workspaceRoot: resolvedOptions.chat?.userSkillWorkspaceRoot,
+                },
+                contextFiles: resolvedOptions.contextFiles,
+                customAgents: { agentStorePath: resolvedOptions.chat?.agentStorePath },
             }),
-            createPiboChatCustomAgentProfilesPlugin({ agentStorePath: resolvedOptions.chat?.agentStorePath }),
             createPiboLoopPlugin({ loopStorePath: resolvedOptions.chat?.ralphStorePath, dataStorePath: resolvedOptions.chat?.dataStorePath, dataPayloadRootDir: resolvedOptions.chat?.dataPayloadRootDir }),
-            createPiboContextFilesPlugin(resolvedOptions.contextFiles),
             createPiboPreviewPlugin(),
             createPiboChatWebPlugin(resolvedOptions.chat),
             createPiboChatVscodeWebPlugin(),

package/dist/local/client.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { PiboSessionRouter } from "../core/session-router.js";
-import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
+import { createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
+import { createDefaultPiboUserProfileRegistry } from "../plugins/user-profile-resources.js";
 import { getDefaultPiboWorkspace } from "../core/workspace.js";
 import { InMemoryPiboSessionStore, } from "../sessions/store.js";
 export const LOCAL_TUI_CHANNEL_NAME = "local-tui";
@@ -52,7 +53,7 @@ export class LocalRoutedTuiClient {
     }
 }
 export function createLocalRoutedTuiClient(options = {}) {
-    const registry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
+    const registry = options.pluginRegistry ?? createDefaultPiboUserProfileRegistry();
     const profileName = resolvePiboProfileNameFromRegistryOrDefault(registry, options.profile);
     const profile = createPiboProfileFromRegistryOrDefault(registry, profileName);
     const sessionName = options.sessionName ?? "default";

package/dist/loops/channel.js

@@ -4,5 +4,7 @@ let currentLoopService;
 export function getPiboLoopService() { return currentLoopService; }
 export function createPiboLoopChannel(options = {}) {
     return { name: 'pibo.loop', kind: 'custom', description: 'Runs continuous Loop Pibo agent jobs.', auth: { mode: 'trusted-local' }, start(context) { if (currentLoopService)
-            return; currentLoopService = new PiboLoopService({ ...options, context, store: createDefaultPiboLoopStore({ path: options.loopStorePath }) }); currentLoopService.start(); }, stop() { currentLoopService?.stop(); currentLoopService = undefined; } };
+            return; currentLoopService = new PiboLoopService({ ...options, context, store: createDefaultPiboLoopStore({ path: options.loopStorePath }) }); currentLoopService.start(); }, async stop() { const service = currentLoopService; if (!service)
+            return; await service.stop(); if (currentLoopService === service)
+            currentLoopService = undefined; } };
 }

package/dist/loops/cli.js

@@ -27,7 +27,8 @@ Commands:
 
 Next: ${commandName} add --help`);
 }
-function targetFromOptions(options) { if (options.room)
+function targetFromOptions(options) { if (options.room && options.defaultChat)
+    throw new Error('Choose either --room <room-id> or --default-chat, not both'); if (options.room)
     return { kind: 'room', roomId: options.room }; if (options.defaultChat)
     return { kind: 'default-chat' }; throw new Error('Choose a target: --room <room-id> or --default-chat'); }
 function maybeTargetFromOptions(options) { if (options.room || options.defaultChat)

package/dist/loops/service.js

@@ -84,6 +84,11 @@ export class PiboLoopService {
     random;
     timer;
     activeRuns = 0;
+    activeRunWork = new Set();
+    pendingRunStarts = 0;
+    schedulerWork;
+    shutdownPromise;
+    ownedWorkWaiters = new Set();
     stopped = true;
     cancelledRuns = new Set();
     browserLeaseHeartbeatTimers = new Map();
@@ -106,13 +111,52 @@ export class PiboLoopService {
     }
     start() { if (!this.stopped)
         return; this.stopped = false; this.store.recoverInterruptedRuns(); this.repairGoalSessionMetadata(); this.unsubscribeProductEvents = this.options.context.subscribeProductEvents?.((event) => this.handleProductEvent(event)); this.unsubscribeOutputEvents = this.options.context.subscribe((event) => this.handleOutputEvent(event)); this.arm(250); }
-    stop() { this.stopped = true; if (this.timer)
-        clearTimeout(this.timer); this.timer = undefined; for (const timer of this.browserLeaseHeartbeatTimers.values())
-        clearInterval(timer); this.browserLeaseHeartbeatTimers.clear(); this.unsubscribeProductEvents?.(); this.unsubscribeProductEvents = undefined; this.unsubscribeOutputEvents?.(); this.unsubscribeOutputEvents = undefined; this.dataStore.close(); this.store.close(); }
+    stop() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        for (const timer of this.browserLeaseHeartbeatTimers.values())
+            clearInterval(timer);
+        this.browserLeaseHeartbeatTimers.clear();
+        const closeStores = () => {
+            this.unsubscribeProductEvents?.();
+            this.unsubscribeProductEvents = undefined;
+            this.unsubscribeOutputEvents?.();
+            this.unsubscribeOutputEvents = undefined;
+            this.dataStore.close();
+            this.store.close();
+        };
+        if (!this.hasOwnedWork()) {
+            closeStores();
+            this.shutdownPromise = Promise.resolve();
+            return this.shutdownPromise;
+        }
+        this.shutdownPromise = this.drainOwnedWork().then(closeStores);
+        return this.shutdownPromise;
+    }
     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; }
+    async startJob(id) {
+        if (this.stopped)
+            return undefined;
+        this.pendingRunStarts += 1;
+        try {
+            const job = this.store.updateJob(id, { enabled: true });
+            if (!job)
+                return undefined;
+            const reserved = await this.reserveAfterBeforeRunEvaluation(job);
+            if (!reserved)
+                return undefined;
+            this.launchReservedRun(reserved.job, reserved.run);
+            return reserved.run;
+        }
+        finally {
+            this.pendingRunStarts -= 1;
+            this.notifyOwnedWorkChange();
+        }
+    }
     stopJob(id) { const job = this.store.requestStop(id); this.armSoon(); return job; }
     removeJob(id) {
         const job = this.store.getJob(id);
@@ -244,9 +288,17 @@ export class PiboLoopService {
         const { loopJobId: _loopJobId, loopRunId: _loopRunId, ...metadata } = session.metadata ?? {};
         this.options.context.updateSession(piboSessionId, { metadata });
     }
-    arm(delayMs) { if (this.stopped)
-        return; if (this.timer)
-        clearTimeout(this.timer); this.timer = setTimeout(() => void this.tick(), delayMs ?? this.intervalMs); }
+    arm(delayMs) {
+        if (this.stopped)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            const work = this.tick();
+            this.schedulerWork = work;
+            void work.then(() => this.finishSchedulerWork(work), (error) => { console.error('[loop] scheduler work failed', error); this.finishSchedulerWork(work); });
+        }, delayMs ?? this.intervalMs);
+    }
     armSoon() { this.arm(250); }
     async tick() { if (this.stopped)
         return; try {
@@ -257,7 +309,7 @@ export class PiboLoopService {
             for (const job of jobs) {
                 const reserved = await this.reserveAfterBeforeRunEvaluation(job);
                 if (reserved)
-                    void this.executeReserved(reserved.job, reserved.run).finally(() => this.armSoon());
+                    this.launchReservedRun(reserved.job, reserved.run);
             }
         }
     }
@@ -280,11 +332,38 @@ export class PiboLoopService {
         this.store.applyStopEvaluation({ jobId: fresh.id, evaluation, conditionStates, disable: false });
         if (fresh.mode === 'goal' && !await this.renewGoalBrowserLeases(fresh))
             return undefined;
-        const reserved = this.store.reserveRun(fresh.id, now);
+        if (this.stopped)
+            return undefined;
+        const reserved = this.store.reserveAdmittedRun(fresh.id, now);
         if (reserved)
             this.startGoalBrowserLeaseHeartbeat(reserved.job, reserved.run);
         return reserved;
     }
+    launchReservedRun(job, run) {
+        const work = this.executeReserved(job, run);
+        this.activeRunWork.add(work);
+        void work.then(() => this.finishActiveRunWork(work), (error) => { console.error(`[loop] active run ${run.id} finalization failed`, error); this.finishActiveRunWork(work); });
+    }
+    finishActiveRunWork(work) {
+        this.activeRunWork.delete(work);
+        this.armSoon();
+        this.notifyOwnedWorkChange();
+    }
+    finishSchedulerWork(work) {
+        if (this.schedulerWork === work)
+            this.schedulerWork = undefined;
+        this.notifyOwnedWorkChange();
+    }
+    hasOwnedWork() { return this.pendingRunStarts > 0 || this.schedulerWork !== undefined || this.activeRunWork.size > 0; }
+    async drainOwnedWork() {
+        while (this.hasOwnedWork())
+            await new Promise((resolve) => this.ownedWorkWaiters.add(resolve));
+    }
+    notifyOwnedWorkChange() {
+        for (const resolve of this.ownedWorkWaiters)
+            resolve();
+        this.ownedWorkWaiters.clear();
+    }
     startGoalBrowserLeaseHeartbeat(job, run) {
         if (job.mode !== 'goal' || (job.resources?.browserLeaseIds?.length ?? 0) === 0)
             return;