@pasko70/pibo 3.0.2 → 3.1.0

package/dist/core/session-router.js

@@ -2,11 +2,12 @@ import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { InitialSessionContext, } from "./profiles.js";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault, selectDefaultPiboProfileName } from "../plugins/builtin.js";
-import { RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
+import { RUN_REMINDER_MAX_DURATION_MS, RuntimeRoutedSession as RoutedSession, } from "../agent-runtime/routed-session.js";
 import { runtimeSessionErrorDetails } from "./session-errors.js";
 import { OutputRenderSequencer, outputRenderHighWaterStore } from "./output-render-sequence.js";
 import { normalizePiboAgentSessionName, } from "../subagents/tool.js";
-import { PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES, normalizePiboAgentObservationCursor, normalizePiboAgentObservationLimit, normalizePiboAgentObservationOrder, normalizePiboAgentObservationToolDetail, parsePiboAgentObservationTimestamp, piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, piboAgentObservationToolSummary, } from "../subagents/observations.js";
+import { piboAgentObservationDetails, piboAgentObservationKind, piboAgentObservationRole, piboAgentObservationSourceFromEvent, piboAgentObservationText, } from "../subagents/observations.js";
+import { preparePiboAgentObservationQuery, selectPiboAgentObservationPage, } from "../subagents/observation-query.js";
 import { PiboRunRegistry } from "../runs/registry.js";
 import { PiboRunCancellationError, PiboRunCancelledError, PiboRunExecutionTimeoutError, waitForRunCancellationSettlement } from "../runs/lifecycle.js";
 import { PiboRunResourceLimitError } from "../runs/resource-isolation.js";
@@ -159,7 +160,11 @@ function formatRunReminderMessage(notification) {
                 toolName: run.toolName,
                 summary: run.summary,
             })),
-            instruction: "Use pibo_run_read for completed, failed, or timed_out runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+            instruction: [
+                `This autonomous run-reminder turn stops after ${RUN_REMINDER_MAX_DURATION_MS / 60_000} minutes of wall-clock time.`,
+                "Handle the listed runs promptly, then finish the turn. Do not start new subagents, yielded runs, or other long-running work from this reminder; leave larger follow-up work for a separate user-initiated or Goal continuation turn.",
+                "Use pibo_run_read for completed, failed, or timed_out runs. Use pibo_run_wait, pibo_run_status, pibo_run_cancel, or pibo_run_ack for runs you still need to manage.",
+            ].join(" "),
         }),
         "</pibo_run_notification>",
     ].join("\n");
@@ -425,9 +430,15 @@ export class PiboSessionRouter {
                 this.signalRegistry.project({ type: "session_created", session });
             this.signalRegistry.project({ type: "pibo_output", event: recovery.event });
         }
+        const recoveredRunReminderControllers = new Set();
         for (const run of this.runRegistry.listAll({ includeConsumed: true, includeDetached: true })) {
             this.signalRegistry.project({ type: "run_changed", run, reason: "recovered" });
+            if (options.recoverInterruptedRuntimeState && isTerminalRunStatus(run.status) && this.sessionStore.get(run.controllerPiboSessionId)) {
+                recoveredRunReminderControllers.add(run.controllerPiboSessionId);
+            }
         }
+        for (const piboSessionId of recoveredRunReminderControllers)
+            this.scheduleRunReminder(piboSessionId, false);
     }
     subscribe(listener) {
         this.listeners.add(listener);
@@ -923,8 +934,12 @@ export class PiboSessionRouter {
             expectedRevision: input.expectedRevision,
             mode,
         });
-        if (switchingRuntime)
-            this.sessionStore.update(piboSessionId, { activeModel: null });
+        if (switchingRuntime) {
+            this.sessionStore.update(piboSessionId, {
+                activeModel: null,
+                metadata: withPiboSessionModelFallbacksMetadata(session.metadata, []),
+            });
+        }
         return structuredClone(persisted);
     }
     getSessionRuntimeStatus(piboSessionId) {
@@ -2069,105 +2084,15 @@ export class PiboSessionRouter {
         return session;
     }
     observeManagedAgents(parentPiboSessionId, input) {
-        const order = normalizePiboAgentObservationOrder(input.order);
-        const limit = normalizePiboAgentObservationLimit(input.limit);
-        const toolDetail = normalizePiboAgentObservationToolDetail(input.toolDetail);
-        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 requestIds = input.requestIds ? new Set(input.requestIds) : undefined;
-        if (input.toolCallIds && input.toolCallIds.length > 50) {
-            throw new Error("Agent observation toolCallIds must contain at most 50 entries.");
-        }
-        const toolCallIds = input.toolCallIds ? new Set(input.toolCallIds) : undefined;
-        const agentIds = input.agentIds ? new Set(input.agentIds) : undefined;
-        if (agentIds) {
-            for (const agentId of agentIds)
-                this.requireManagedAgent(parentPiboSessionId, agentId);
-        }
-        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 roles = input.roles ? new Set(input.roles) : undefined;
-        const textContains = input.textContains?.toLowerCase();
-        const defaultMessageView = eventTypes === undefined && kinds === undefined;
-        const explicitlySelectsTools = input.eventTypes?.some((eventType) => piboAgentObservationKind(eventType) === "tool") === true
-            || input.kinds?.includes("tool") === true
-            || toolCallIds !== undefined;
-        const includeTools = input.includeTools === true || (input.includeTools === undefined && explicitlySelectsTools);
-        const defaultEventTypes = includeTools
-            ? [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES, ...PIBO_AGENT_OBSERVATION_DEFAULT_TOOL_EVENT_TYPES]
-            : [...PIBO_AGENT_OBSERVATION_DEFAULT_EVENT_TYPES];
-        const defaultEventTypeSet = new Set(defaultEventTypes);
-        const matches = this.agentObservations.filter((observation) => {
-            if (observation.managingParentId !== parentPiboSessionId)
-                return false;
-            if (requestIds && (!observation.requestId || !requestIds.has(observation.requestId)))
-                return false;
-            if (toolCallIds && (!observation.toolCallId || !toolCallIds.has(observation.toolCallId)))
-                return false;
-            if (agentIds && !agentIds.has(observation.agentId))
-                return false;
-            if (names && !names.has(observation.name))
-                return false;
-            if (threadKeys && (!observation.threadKey || !threadKeys.has(observation.threadKey)))
-                return false;
-            if (observation.kind === "tool" && !includeTools)
-                return false;
-            if (defaultMessageView && !defaultEventTypeSet.has(observation.eventType))
-                return false;
-            if (eventTypes && !eventTypes.has(observation.eventType))
-                return false;
-            if (kinds && !kinds.has(observation.kind))
-                return false;
-            if (roles && (!observation.role || !roles.has(observation.role)))
-                return false;
-            if (afterSequence !== undefined && observation.sequence <= afterSequence)
-                return false;
-            const createdAt = Date.parse(observation.createdAt);
-            if (since !== undefined && createdAt < since)
-                return false;
-            if (until !== undefined && createdAt > until)
-                return false;
-            if (textContains && !(observation.text ?? "").toLowerCase().includes(textContains))
-                return false;
-            return true;
-        });
-        const cursorPolling = afterSequence !== undefined;
-        const ordered = cursorPolling
-            ? matches.slice(0, limit)
-            : [...matches].sort((left, right) => order === "asc" ? left.sequence - right.sequence : right.sequence - left.sequence).slice(0, limit);
-        if (cursorPolling && order === "desc")
-            ordered.reverse();
-        const selected = ordered.map((observation) => {
-            const { managingParentId: _managingParentId, details, ...visible } = observation;
-            const compact = visible.kind === "tool" && toolDetail === "summary"
-                ? { ...visible, text: piboAgentObservationToolSummary(visible.text, visible.isError, details) }
-                : visible;
-            return input.includeDetails === true && details !== undefined ? { ...compact, details } : compact;
-        });
-        const evictedThrough = this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0;
-        const retentionTruncated = afterSequence === undefined ? evictedThrough > 0 : afterSequence < evictedThrough;
-        const nextAfterSequence = selected.reduce((maximum, observation) => Math.max(maximum, observation.sequence), afterSequence === undefined ? 0 : Math.max(afterSequence, evictedThrough));
-        return {
-            filters: {
-                ...input,
-                ...(defaultMessageView ? { eventTypes: defaultEventTypes } : {}),
-                ...(afterSequence !== undefined ? { afterSequence } : {}),
-                order,
-                limit,
-                includeTools,
-                toolDetail,
-                includeDetails: input.includeDetails === true,
-            },
-            observations: selected,
-            nextAfterSequence,
-            truncated: retentionTruncated || matches.length > selected.length,
-        };
+        for (const agentId of input.agentIds ?? [])
+            this.requireManagedAgent(parentPiboSessionId, agentId);
+        const query = preparePiboAgentObservationQuery(input);
+        const ordered = query.scanOrder === "asc"
+            ? this.agentObservations
+            : [...this.agentObservations].reverse();
+        return selectPiboAgentObservationPage(ordered
+            .filter((observation) => observation.managingParentId === parentPiboSessionId)
+            .map(({ managingParentId: _managingParentId, ...observation }) => observation), query, { evictedThrough: this.agentObservationEvictedThroughByParent.get(parentPiboSessionId) ?? 0 });
     }
     async killManagedAgent(parentPiboSessionId, agentId) {
         const child = this.requireManagedAgent(parentPiboSessionId, agentId);
@@ -2615,7 +2540,10 @@ export class PiboSessionRouter {
         }
     }
     projectKnownSessionSignals() {
-        for (const session of this.sessionStore.list?.() ?? []) {
+        const sessions = this.sessionStore.list?.() ?? [];
+        const depthBySessionId = new Map(sessions.map((session) => [session.id, this.getSubagentDepth(session.id)]));
+        sessions.sort((left, right) => (depthBySessionId.get(left.id) ?? 0) - (depthBySessionId.get(right.id) ?? 0));
+        for (const session of sessions) {
             this.signalRegistry.project({ type: "session_created", session });
         }
     }

package/dist/data/pibo-store.js

@@ -8,7 +8,7 @@ import { MessageStore } from "./message-store.js";
 import { NavigationStore } from "./navigation-store.js";
 import { ObservationStore } from "./observation-store.js";
 import { PayloadStore } from "./payload-store.js";
-import { applyPiboDataSchema } from "./schema.js";
+import { applyPiboDataSchema, assertSupportedPiboDataSchemaVersion } from "./schema.js";
 import { TelemetryStore } from "./telemetry.js";
 import { SessionStore } from "./session-store.js";
 export class PiboDataStore {
@@ -27,6 +27,13 @@ export class PiboDataStore {
         if (this.path !== ":memory:")
             mkdirSync(dirname(this.path), { recursive: true });
         this.db = new DatabaseSync(this.path);
+        try {
+            assertSupportedPiboDataSchemaVersion(this.db);
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
         if (insidePiboHome)
             protectPrivateFileSync(this.path);
         this.db.exec("PRAGMA busy_timeout = 5000");

package/dist/data/schema.js

@@ -1,4 +1,104 @@
 export const PIBO_DATA_SCHEMA_VERSION = 7;
+const retiredScopeColumn = ["owner", "scope"].join("_");
+const retiredScopeTables = [
+    {
+        name: "sessions",
+        columns: [
+            "id", "pi_session_id", "room_id", "root_session_id", "parent_id", "origin_id",
+            "channel", "kind", "profile", "active_model_json", "workspace", "title",
+            "first_message_preview", "status", "archived_at", "deleted_at", "metadata_json",
+            "created_at", "updated_at", "last_activity_at",
+        ],
+        definition: `
+			id TEXT PRIMARY KEY,
+			pi_session_id TEXT UNIQUE,
+			room_id TEXT,
+			root_session_id TEXT,
+			parent_id TEXT,
+			origin_id TEXT,
+			channel TEXT NOT NULL,
+			kind TEXT NOT NULL,
+			profile TEXT NOT NULL,
+			active_model_json TEXT,
+			workspace TEXT,
+			title TEXT NOT NULL DEFAULT 'Untitled Session',
+			first_message_preview TEXT,
+			status TEXT NOT NULL DEFAULT 'idle',
+			archived_at TEXT,
+			deleted_at TEXT,
+			metadata_json TEXT NOT NULL DEFAULT '{}',
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			last_activity_at TEXT NOT NULL
+		`,
+    },
+    {
+        name: "rooms",
+        columns: [
+            "id", "name", "topic", "type", "parent_room_id", "workspace", "archived_at",
+            "retention_policy_id", "metadata_json", "created_at", "updated_at",
+        ],
+        definition: `
+			id TEXT PRIMARY KEY,
+			name TEXT NOT NULL,
+			topic TEXT,
+			type TEXT NOT NULL,
+			parent_room_id TEXT,
+			workspace TEXT,
+			archived_at TEXT,
+			retention_policy_id TEXT,
+			metadata_json TEXT NOT NULL DEFAULT '{}',
+			created_at TEXT NOT NULL,
+			updated_at TEXT NOT NULL
+		`,
+    },
+    {
+        name: "session_navigation",
+        columns: [
+            "room_id", "session_id", "root_session_id", "parent_id", "origin_id", "title",
+            "profile", "status", "archived_at", "last_activity_at", "last_message_preview",
+            "child_count", "sort_key", "updated_at",
+        ],
+        definition: `
+			room_id TEXT,
+			session_id TEXT PRIMARY KEY,
+			root_session_id TEXT,
+			parent_id TEXT,
+			origin_id TEXT,
+			title TEXT NOT NULL,
+			profile TEXT NOT NULL,
+			status TEXT NOT NULL,
+			archived_at TEXT,
+			last_activity_at TEXT NOT NULL,
+			last_message_preview TEXT,
+			child_count INTEGER NOT NULL DEFAULT 0,
+			sort_key TEXT NOT NULL,
+			updated_at TEXT NOT NULL
+		`,
+    },
+];
+function retiredScopeTablesToRebuild(db) {
+    return retiredScopeTables.filter((table) => ((db.prepare(`SELECT 1 FROM pragma_table_info('${table.name}') WHERE name = ?`).get(retiredScopeColumn)) !== undefined));
+}
+function rebuildRetiredScopeTables(db, tablesToRebuild) {
+    for (const table of tablesToRebuild) {
+        const replacement = `__pibo_schema_v7_${table.name}`;
+        const columnList = table.columns.join(", ");
+        db.exec(`
+			CREATE TABLE ${replacement} (${table.definition});
+			INSERT INTO ${replacement} (${columnList}) SELECT ${columnList} FROM ${table.name};
+			DROP TABLE ${table.name};
+			ALTER TABLE ${replacement} RENAME TO ${table.name};
+		`);
+    }
+}
+export function assertSupportedPiboDataSchemaVersion(db) {
+    const version = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
+    if (version > PIBO_DATA_SCHEMA_VERSION) {
+        throw new Error(`Pibo database schema version ${version} is newer than supported version ${PIBO_DATA_SCHEMA_VERSION}`);
+    }
+    return version;
+}
 export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
     "schema",
     "runtime-bindings",
@@ -11,11 +111,27 @@ export const PIBO_DATA_SCHEMA_MIGRATION_STEPS = [
     "user-version",
 ];
 export function applyPiboDataSchema(db, hooks = {}) {
+    const previousVersion = assertSupportedPiboDataSchemaVersion(db);
+    const tablesToRebuild = retiredScopeTablesToRebuild(db);
     const ownsTransaction = !db.isTransaction;
-    if (ownsTransaction)
-        db.exec("BEGIN IMMEDIATE");
+    if (!ownsTransaction && tablesToRebuild.length > 0) {
+        throw new Error("Pibo data schema migration requires an independent transaction");
+    }
+    const foreignKeysEnabled = ownsTransaction
+        && tablesToRebuild.length > 0
+        && Number(db.prepare("PRAGMA foreign_keys").get().foreign_keys ?? 0) === 1;
+    if (foreignKeysEnabled)
+        db.exec("PRAGMA foreign_keys = OFF");
     try {
-        applyPiboDataSchemaInTransaction(db, hooks);
+        if (ownsTransaction)
+            db.exec("BEGIN IMMEDIATE");
+        applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild);
+        if (tablesToRebuild.length > 0) {
+            const violations = db.prepare("PRAGMA foreign_key_check").all();
+            if (violations.length > 0) {
+                throw new Error(`Pibo data schema migration would retain ${violations.length} foreign-key violation(s)`);
+            }
+        }
         if (ownsTransaction)
             db.exec("COMMIT");
     }
@@ -24,12 +140,16 @@ export function applyPiboDataSchema(db, hooks = {}) {
             db.exec("ROLLBACK");
         throw error;
     }
+    finally {
+        if (foreignKeysEnabled)
+            db.exec("PRAGMA foreign_keys = ON");
+    }
 }
-function applyPiboDataSchemaInTransaction(db, hooks) {
-    const previousVersion = Number(db.prepare("PRAGMA user_version").get()?.user_version ?? 0);
+function applyPiboDataSchemaInTransaction(db, hooks, previousVersion, tablesToRebuild) {
     const existingSessionCount = db.prepare("SELECT COUNT(*) AS count FROM sqlite_schema WHERE type = 'table' AND name = 'sessions'").get();
     const hadSessionsBeforeMigration = existingSessionCount.count > 0
         && Number(db.prepare("SELECT COUNT(*) AS count FROM sessions").get().count) > 0;
+    rebuildRetiredScopeTables(db, tablesToRebuild);
     db.exec(`
 		CREATE TABLE IF NOT EXISTS sessions (
 			id TEXT PRIMARY KEY,

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