@pasko70/pibo 3.0.2 → 3.1.1

package/dist/debug/agents.js

@@ -1,4 +1,5 @@
-import { normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationText, } from "../subagents/observations.js";
+import { normalizePiboAgentObservationLimit, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationText, } from "../subagents/observations.js";
+import { preparePiboAgentObservationQuery, selectPiboAgentObservationPage, } from "../subagents/observation-query.js";
 import { createDebugPayloadStore, hydrateDebugEventRow } from "./persisted-payloads.js";
 import { eventAttributes, eventPayload } from "./payloads.js";
 import { openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
@@ -36,17 +37,21 @@ export async function runDebugAgentsCli(args) {
         return;
     }
     const result = inspectDebugAgentObservations(parentPiboSessionId, store, {
+        toolCallIds: parsed.toolCallIds.length ? parsed.toolCallIds : undefined,
         agentIds: parsed.agentIds.length ? parsed.agentIds : undefined,
         names: parsed.names.length ? parsed.names : undefined,
         threadKeys: parsed.threadKeys.length ? parsed.threadKeys : undefined,
         eventTypes: parsed.eventTypes.length ? parsed.eventTypes : undefined,
         kinds: parsed.kinds.length ? parsed.kinds : undefined,
+        roles: parsed.roles.length ? parsed.roles : undefined,
         since: parsed.since,
         until: parsed.until,
         textContains: parsed.textContains,
         afterSequence: parsed.afterSequence,
         order: parsed.order,
         limit: parsed.limit,
+        includeTools: parsed.includeTools || undefined,
+        toolDetail: parsed.toolDetail,
         includeDetails: parsed.details,
     });
     if (parsed.json)
@@ -75,104 +80,70 @@ export function inspectDebugAgentObservations(parentPiboSessionId, store, input
         throw new Error(`Debug store "pibo-data" not found at ${store.path}`);
     const db = openReadOnlyDebugDatabase(store);
     try {
-        const order = normalizePiboAgentObservationOrder(input.order);
-        const limit = normalizePiboAgentObservationLimit(input.limit);
-        const afterSequence = normalizePiboAgentObservationCursor(input.afterSequence);
-        const since = parsePiboAgentObservationTimestamp(input.since, "since");
-        const until = parsePiboAgentObservationTimestamp(input.until, "until");
-        if (since !== undefined && until !== undefined && since > until)
-            throw new Error("Agent observation since must not be after until.");
+        const query = preparePiboAgentObservationQuery(input);
         const owned = readOwnedAgents(db, parentPiboSessionId);
         const ownedById = new Map(owned.map((agent) => [agent.agentId, agent]));
         for (const agentId of input.agentIds ?? []) {
             if (!ownedById.has(agentId))
                 throw new Error(`Agent "${agentId}" is not owned by Pibo session "${parentPiboSessionId}".`);
         }
-        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
-        const names = input.names ? new Set(input.names) : undefined;
-        const threadKeys = input.threadKeys ? new Set(input.threadKeys) : undefined;
-        const eventTypes = input.eventTypes ? new Set(input.eventTypes) : undefined;
-        const kinds = input.kinds ? new Set(input.kinds) : undefined;
         const payloadStore = createDebugPayloadStore(db, store);
         const clauses = ["s.parent_id = ?", "s.channel = 'pibo.subagents'", "s.kind = 'subagent'", "s.deleted_at IS NULL"];
         const values = [parentPiboSessionId];
-        if (afterSequence !== undefined) {
+        if (query.afterSequence !== undefined) {
             clauses.push("e.stream_id > ?");
-            values.push(afterSequence);
+            values.push(query.afterSequence);
+        }
+        if (query.scanEventTypes && query.scanEventTypes.length > 0) {
+            clauses.push(`e.type IN (${query.scanEventTypes.map(() => "?").join(", ")})`);
+            values.push(...query.scanEventTypes);
         }
-        const scanOrder = afterSequence !== undefined ? "ASC" : order.toUpperCase();
         const statement = db.prepare(`
 			SELECT e.stream_id, e.session_id, e.session_sequence, e.event_id, e.type, e.created_at,
 				e.payload_ref, e.preview_text, e.attributes_json, s.profile, s.metadata_json
 			FROM event_log e
 			JOIN sessions s ON s.id = e.session_id
 			WHERE ${clauses.join(" AND ")}
-			ORDER BY e.stream_id ${scanOrder}
+			ORDER BY e.stream_id ${query.scanOrder.toUpperCase()}
 		`);
-        const textContains = input.textContains?.toLowerCase();
-        const matches = [];
-        for (const rawRow of statement.iterate(...values)) {
-            const agent = ownedById.get(rawRow.session_id ?? "");
-            if (!agent)
-                continue;
-            if (agentIds && !agentIds.has(agent.agentId))
-                continue;
-            if (names && !names.has(agent.name))
-                continue;
-            if (threadKeys && (!agent.threadKey || !threadKeys.has(agent.threadKey)))
-                continue;
-            if (eventTypes && !eventTypes.has(rawRow.type))
-                continue;
-            const kind = piboAgentObservationKind(rawRow.type);
-            if (kinds && !kinds.has(kind))
-                continue;
-            const createdAt = Date.parse(rawRow.created_at);
-            if (since !== undefined && createdAt < since)
-                continue;
-            if (until !== undefined && createdAt > until)
-                continue;
-            const row = hydrateDebugEventRow(rawRow, payloadStore);
-            const attributes = eventAttributes(row);
-            const payload = { ...attributes, ...eventPayload(row) };
-            const source = debugAgentObservationSource(row, attributes);
-            const text = piboAgentObservationText(source);
-            if (textContains && !(text ?? "").toLowerCase().includes(textContains))
-                continue;
-            const role = piboAgentObservationRole(source);
-            matches.push({
-                streamId: row.stream_id,
-                createdAt: row.created_at,
-                agentId: agent.agentId,
-                name: agent.name,
-                ...(agent.threadKey ? { threadKey: agent.threadKey } : {}),
-                eventType: row.type,
-                kind,
-                ...(role ? { role } : {}),
-                ...(text ? { text } : {}),
-                ...(typeof payload.toolName === "string" ? { toolName: payload.toolName } : {}),
-                ...(typeof payload.toolCallId === "string" ? { toolCallId: payload.toolCallId } : {}),
-                ...(row.type === "tool_execution_finished" ? { isError: payload.isError === true } : row.type === "session_error" ? { isError: true } : {}),
-                ...(input.includeDetails === true ? { details: piboAgentObservationDetails(debugAgentObservationDetails(row, payload)) } : {}),
-            });
-            if (matches.length > limit)
-                break;
+        function* normalizedObservations() {
+            for (const rawRow of statement.iterate(...values)) {
+                const agent = ownedById.get(rawRow.session_id ?? "");
+                if (!agent)
+                    continue;
+                const row = hydrateDebugEventRow(rawRow, payloadStore);
+                const attributes = eventAttributes(row);
+                const payload = { ...attributes, ...eventPayload(row) };
+                const source = debugAgentObservationSource(row, attributes);
+                const text = piboAgentObservationText(source);
+                const role = piboAgentObservationRole(source);
+                yield {
+                    sequence: row.stream_id,
+                    createdAt: row.created_at,
+                    agentId: agent.agentId,
+                    name: agent.name,
+                    ...(agent.threadKey ? { threadKey: agent.threadKey } : {}),
+                    eventType: row.type,
+                    kind: piboAgentObservationKind(row.type),
+                    ...(role ? { role } : {}),
+                    ...(text ? { text } : {}),
+                    ...(typeof payload.toolName === "string" ? { toolName: payload.toolName } : {}),
+                    ...(typeof payload.toolCallId === "string" ? { toolCallId: payload.toolCallId } : {}),
+                    ...(row.type === "tool_execution_finished" ? { isError: payload.isError === true } : row.type === "session_error" ? { isError: true } : {}),
+                    details: piboAgentObservationDetails(debugAgentObservationDetails(row, payload, source)),
+                };
+            }
         }
-        const truncated = matches.length > limit;
-        const observations = matches.slice(0, limit);
-        if (afterSequence !== undefined && order === "desc")
-            observations.reverse();
+        const page = selectPiboAgentObservationPage(normalizedObservations(), query);
         return {
             parentPiboSessionId,
-            filters: {
-                ...input,
-                ...(afterSequence !== undefined ? { afterSequence } : {}),
-                order,
-                limit,
-                includeDetails: input.includeDetails === true,
-            },
-            observations,
-            nextAfterSequence: observations.reduce((maximum, observation) => Math.max(maximum, observation.streamId), afterSequence ?? 0),
-            truncated,
+            filters: page.filters,
+            observations: page.observations.map(({ sequence, ...observation }) => ({
+                streamId: sequence,
+                ...observation,
+            })),
+            nextAfterSequence: page.nextAfterSequence,
+            truncated: page.truncated,
         };
     }
     catch (error) {
@@ -237,12 +208,15 @@ function debugAgentObservationSource(row, attributes) {
         source.subagentName = attributes.subagentName;
     return source;
 }
-function debugAgentObservationDetails(row, payload) {
+function debugAgentObservationDetails(row, payload, source) {
     return {
         type: row.type,
         ...(row.session_id ? { piboSessionId: row.session_id } : {}),
         ...(row.event_id ? { eventId: row.event_id } : {}),
         ...payload,
+        ...(source.args !== undefined ? { args: source.args } : {}),
+        ...(source.partialResult !== undefined ? { partialResult: source.partialResult } : {}),
+        ...(source.result !== undefined ? { result: source.result } : {}),
     };
 }
 function parseObject(value) {
@@ -306,17 +280,31 @@ Filters use exact values. The command inspects only direct pibo.subagents childr
     console.log(`pibo debug agents ${parentPiboSessionId} observe
 
 Usage:
-  pibo debug agents ${parentPiboSessionId} observe [--agent-id ps_...] [--name name] [--thread-key key]
-    [--event-type type] [--kind message|thinking|tool|error|lifecycle|event]
-    [--since iso] [--until iso] [--contains text] [--after-sequence n]
-    [--order asc|desc] [--limit 1..200] [--details] [--json]
+  pibo debug agents ${parentPiboSessionId} observe [--tool-call-id id] [--agent-id ps_...] [--name name]
+    [--thread-key key] [--event-type type] [--kind message|thinking|tool|error|lifecycle|event]
+    [--role role] [--since iso] [--until iso] [--contains text] [--after-sequence n]
+    [--order asc|desc] [--limit 1..200] [--include-tools]
+    [--tool-detail summary|full] [--details] [--json]
 
-Repeat --agent-id, --name, --thread-key, --event-type, or --kind for OR within that field.
+Default: the newest 20 completed assistant messages, with streaming deltas and tools hidden.
+Use --include-tools for compact tool calls and terminal results. Explicit --event-type or --kind
+filters retain access to progress events. Repeat plural filters for OR within that field.
 Different fields combine with AND. With --after-sequence, pages always consume the oldest unseen rows;
 --order desc reverses only the returned page, so nextAfterSequence remains safe for polling.`);
 }
 function parseAgentDebugOptions(args) {
-    const parsed = { json: false, details: false, agentIds: [], names: [], threadKeys: [], eventTypes: [], kinds: [] };
+    const parsed = {
+        json: false,
+        details: false,
+        includeTools: false,
+        toolCallIds: [],
+        agentIds: [],
+        names: [],
+        threadKeys: [],
+        eventTypes: [],
+        kinds: [],
+        roles: [],
+    };
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--json") {
@@ -327,10 +315,16 @@ function parseAgentDebugOptions(args) {
             parsed.details = true;
             continue;
         }
+        if (arg === "--include-tools") {
+            parsed.includeTools = true;
+            continue;
+        }
         const value = args[index + 1];
         if (!value)
             throw new Error(`${arg} requires a value`);
-        if (arg === "--agent-id")
+        if (arg === "--tool-call-id")
+            parsed.toolCallIds.push(value);
+        else if (arg === "--agent-id")
             parsed.agentIds.push(value);
         else if (arg === "--name")
             parsed.names.push(value);
@@ -343,6 +337,8 @@ function parseAgentDebugOptions(args) {
                 throw new Error(`Invalid --kind "${value}"`);
             parsed.kinds.push(value);
         }
+        else if (arg === "--role")
+            parsed.roles.push(value);
         else if (arg === "--status") {
             if (!["running", "idle", "killed"].includes(value))
                 throw new Error(`Invalid --status "${value}"`);
@@ -363,6 +359,11 @@ function parseAgentDebugOptions(args) {
         }
         else if (arg === "--limit")
             parsed.limit = normalizePiboAgentObservationLimit(parseNonNegativeInteger(value, arg));
+        else if (arg === "--tool-detail") {
+            if (value !== "summary" && value !== "full")
+                throw new Error(`Invalid --tool-detail "${value}"`);
+            parsed.toolDetail = value;
+        }
         else
             throw new Error(`Unknown pibo debug agents option "${arg}"`);
         index += 1;
@@ -373,10 +374,11 @@ function validateAgentDebugOptions(command, parsed) {
     if (command === "list") {
         if (parsed.names.length > 1)
             throw new Error("pibo debug agents list accepts at most one --name value");
-        if (parsed.details || parsed.agentIds.length > 0 || parsed.threadKeys.length > 0 || parsed.eventTypes.length > 0
-            || parsed.kinds.length > 0 || parsed.since !== undefined || parsed.until !== undefined
+        if (parsed.details || parsed.includeTools || parsed.toolCallIds.length > 0 || parsed.agentIds.length > 0
+            || parsed.threadKeys.length > 0 || parsed.eventTypes.length > 0 || parsed.kinds.length > 0
+            || parsed.roles.length > 0 || parsed.since !== undefined || parsed.until !== undefined
             || parsed.textContains !== undefined || parsed.afterSequence !== undefined || parsed.order !== undefined
-            || parsed.limit !== undefined)
+            || parsed.limit !== undefined || parsed.toolDetail !== undefined)
             throw new Error("Unsupported option for pibo debug agents list. Run the list command with --help.");
         return;
     }

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

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