@getpaseo/server 0.1.87 → 0.1.88

package/dist/server/server/agent/mcp-server.js

@@ -176,17 +176,28 @@ function normalizeScheduleCadenceArg(value) {
     }
     return trimmed;
 }
+function normalizeScheduleTimeZoneArg(value) {
+    return normalizeScheduleCadenceArg(value);
+}
 function resolveScheduleUpdateCadence(input) {
     const every = normalizeScheduleCadenceArg(input.every);
     const cron = normalizeScheduleCadenceArg(input.cron);
+    const timeZone = normalizeScheduleTimeZoneArg(input.timezone);
     if (every !== undefined && cron !== undefined) {
         throw new Error("Specify at most one of every or cron");
     }
+    if (timeZone !== undefined && cron === undefined) {
+        throw new Error("timezone can only be used with cron");
+    }
     if (every !== undefined) {
         return { type: "every", everyMs: parseDurationString(every) };
     }
     if (cron !== undefined) {
-        return { type: "cron", expression: cron };
+        return {
+            type: "cron",
+            expression: cron,
+            ...(timeZone !== undefined ? { timezone: timeZone } : {}),
+        };
     }
     return undefined;
 }
@@ -1162,6 +1173,12 @@ export async function createAgentMcpServer(options) {
             prompt: z.string().trim().min(1, "prompt is required"),
             every: z.string().optional(),
             cron: z.string().optional(),
+            timezone: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("IANA time zone for cron cadence; requires cron. For example: America/New_York."),
             name: z.string().optional(),
             target: z.enum(["self", "new-agent"]).optional(),
             provider: AgentProviderEnum.optional().describe("Provider, or provider/model (for example: codex or codex/gpt-5.4)."),
@@ -1170,16 +1187,20 @@ export async function createAgentMcpServer(options) {
             expiresIn: z.string().optional(),
         },
         outputSchema: ScheduleSummarySchema.shape,
-    }, async ({ prompt, every, cron, name, target, provider, cwd, maxRuns, expiresIn }) => {
+    }, async ({ prompt, every, cron, timezone, name, target, provider, cwd, maxRuns, expiresIn }) => {
         if (!scheduleService) {
             throw new Error("Schedule service is not configured");
         }
         const normalizedEvery = normalizeScheduleCadenceArg(every);
         const normalizedCron = normalizeScheduleCadenceArg(cron);
+        const normalizedTimeZone = normalizeScheduleTimeZoneArg(timezone);
         const cadenceCount = Number(normalizedEvery !== undefined) + Number(normalizedCron !== undefined);
         if (cadenceCount !== 1) {
             throw new Error("Specify exactly one of every or cron");
         }
+        if (normalizedTimeZone !== undefined && normalizedCron === undefined) {
+            throw new Error("timezone can only be used with cron");
+        }
         const scheduleTarget = target === "self"
             ? (() => {
                 const callerAgent = resolveCallerAgent();
@@ -1209,7 +1230,11 @@ export async function createAgentMcpServer(options) {
             prompt: prompt.trim(),
             cadence: normalizedEvery !== undefined
                 ? { type: "every", everyMs: parseDurationString(normalizedEvery) }
-                : { type: "cron", expression: normalizedCron },
+                : {
+                    type: "cron",
+                    expression: normalizedCron,
+                    ...(normalizedTimeZone !== undefined ? { timezone: normalizedTimeZone } : {}),
+                },
             target: scheduleTarget,
             ...(name?.trim() ? { name: name.trim() } : {}),
             ...(maxRuns === undefined ? {} : { maxRuns }),
@@ -1320,6 +1345,12 @@ export async function createAgentMcpServer(options) {
             id: z.string(),
             every: z.string().optional().describe("New interval duration string (e.g. 5m, 1h)."),
             cron: z.string().optional().describe("New cron expression."),
+            timezone: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("IANA time zone for cron cadence; requires cron. For example: America/New_York."),
             name: z.string().nullable().optional().describe("New name (null to clear)."),
             prompt: z.string().trim().min(1).optional().describe("New prompt text."),
             maxRuns: z

package/dist/server/server/agent/mcp-shared.d.ts

@@ -282,6 +282,7 @@ export declare function toScheduleSummary(schedule: z.infer<typeof StoredSchedul
     } | {
         type: "cron";
         expression: string;
+        timezone?: string | undefined;
     };
     target: {
         agentId: string;

package/dist/server/server/agent/timeline-projection.d.ts

@@ -21,6 +21,13 @@ interface ProjectedWindowSelection {
     minSeq: number | null;
     maxSeq: number | null;
 }
+export interface ProjectedTimelinePageSelection {
+    entries: TimelineProjectionEntry[];
+    startSeq: number | null;
+    endSeq: number | null;
+    hasOlder: boolean;
+    hasNewer: boolean;
+}
 export declare function projectTimelineRows(input: {
     rows: readonly AgentTimelineRow[];
     mode: TimelineProjectionMode;
@@ -34,8 +41,17 @@ export declare function selectTimelineWindowByProjectedLimit(input: {
     rows: readonly AgentTimelineRow[];
     direction: TimelineLimitDirection;
     limit: number;
-    collapseToolLifecycle?: boolean;
 }): ProjectedWindowSelection;
+export declare function selectProjectedTimelinePage(input: {
+    rows: readonly AgentTimelineRow[];
+    bounds?: {
+        minSeq: number;
+        maxSeq: number;
+    };
+    direction: TimelineLimitDirection;
+    cursorSeq?: number;
+    limit?: number;
+}): ProjectedTimelinePageSelection;
 /**
  * Apply a projected-count limit to a flat AgentTimelineItem[] without seq metadata.
  * Used by callers that only have items in hand (e.g. MCP tools reading

package/dist/server/server/agent/timeline-projection.js

@@ -188,9 +188,8 @@ export function projectTimelineRows(input) {
 export function selectTimelineWindowByProjectedLimit(input) {
     const { rows, direction } = input;
     const limit = Math.max(0, Math.floor(input.limit));
-    const collapseTools = input.collapseToolLifecycle ?? true;
     const canonical = makeCanonicalEntries(rows);
-    const projectedAll = mergeReasoningChunks(mergeAssistantChunks(collapseTools ? collapseToolLifecycle(canonical) : canonical));
+    const projectedAll = mergeReasoningChunks(mergeAssistantChunks(collapseToolLifecycle(canonical)));
     if (projectedAll.length === 0) {
         return {
             projectedEntries: [],
@@ -232,23 +231,21 @@ export function selectTimelineWindowByProjectedLimit(input) {
     };
     let { minSeq, maxSeq } = computeWindowBounds(projectedEntries);
     let expandedEntries = projectedEntries;
-    if (collapseTools) {
-        // Expand to include any projected entries that overlap the selected
-        // canonical range. Tool lifecycle collapse can produce non-monotonic
-        // seqEnd values, which would otherwise create cursor gaps.
-        for (let iteration = 0; iteration < projectedAll.length + 1; iteration += 1) {
-            const overlapping = projectedAll.filter((entry) => entry.seqStart <= maxSeq && entry.seqEnd >= minSeq);
-            const nextBounds = computeWindowBounds(overlapping);
-            if (overlapping.length === expandedEntries.length &&
-                nextBounds.minSeq === minSeq &&
-                nextBounds.maxSeq === maxSeq) {
-                expandedEntries = overlapping;
-                break;
-            }
+    // Expand to include any projected entries that overlap the selected canonical
+    // range. Tool lifecycle collapse can produce non-monotonic seqEnd values,
+    // which would otherwise create cursor gaps.
+    for (let iteration = 0; iteration < projectedAll.length + 1; iteration += 1) {
+        const overlapping = projectedAll.filter((entry) => entry.seqStart <= maxSeq && entry.seqEnd >= minSeq);
+        const nextBounds = computeWindowBounds(overlapping);
+        if (overlapping.length === expandedEntries.length &&
+            nextBounds.minSeq === minSeq &&
+            nextBounds.maxSeq === maxSeq) {
             expandedEntries = overlapping;
-            minSeq = nextBounds.minSeq;
-            maxSeq = nextBounds.maxSeq;
+            break;
         }
+        expandedEntries = overlapping;
+        minSeq = nextBounds.minSeq;
+        maxSeq = nextBounds.maxSeq;
     }
     const selectedRows = rows.filter((row) => row.seq >= minSeq && row.seq <= maxSeq);
     return {
@@ -258,6 +255,74 @@ export function selectTimelineWindowByProjectedLimit(input) {
         maxSeq: Number.isFinite(maxSeq) ? maxSeq : null,
     };
 }
+function getTimelineBounds(rows) {
+    const first = rows[0];
+    const last = rows[rows.length - 1];
+    if (!first || !last) {
+        return null;
+    }
+    return { minSeq: first.seq, maxSeq: last.seq };
+}
+function selectEntriesOverlappingSeqRange(input) {
+    return input.entries.filter((entry) => entry.seqStart <= input.endSeq && entry.seqEnd >= input.startSeq);
+}
+export function selectProjectedTimelinePage(input) {
+    const limit = input.limit === undefined ? 0 : Math.max(0, Math.floor(input.limit));
+    const bounds = input.bounds ?? getTimelineBounds(input.rows);
+    const projectedAll = projectTimelineRows({ rows: input.rows, mode: "projected" });
+    if (projectedAll.length === 0 || !bounds) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: false,
+        };
+    }
+    if (input.direction === "tail") {
+        const selected = selectTimelineWindowByProjectedLimit({
+            rows: input.rows,
+            direction: "tail",
+            limit,
+        });
+        return {
+            entries: selected.projectedEntries,
+            startSeq: selected.minSeq,
+            endSeq: selected.maxSeq,
+            hasOlder: selected.minSeq !== null && selected.minSeq > bounds.minSeq,
+            hasNewer: false,
+        };
+    }
+    let startSeq;
+    let endSeq;
+    if (input.direction === "after") {
+        const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+        startSeq = Math.max(bounds.minSeq, cursorSeq + 1);
+        endSeq = limit === 0 ? bounds.maxSeq : Math.min(bounds.maxSeq, cursorSeq + limit);
+    }
+    else {
+        const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+        endSeq = Math.min(bounds.maxSeq, cursorSeq - 1);
+        startSeq = limit === 0 ? bounds.minSeq : Math.max(bounds.minSeq, cursorSeq - limit);
+    }
+    if (startSeq > endSeq) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: startSeq > bounds.minSeq,
+            hasNewer: endSeq < bounds.maxSeq,
+        };
+    }
+    const entries = selectEntriesOverlappingSeqRange({ entries: projectedAll, startSeq, endSeq });
+    return {
+        entries,
+        startSeq,
+        endSeq,
+        hasOlder: startSeq > bounds.minSeq,
+        hasNewer: endSeq < bounds.maxSeq,
+    };
+}
 export function selectItemsByProjectedLimit(input) {
     const rows = input.items.map((item, index) => ({
         seq: index + 1,

package/dist/server/server/persisted-config.d.ts

@@ -199,7 +199,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
                     label: z.ZodString;
                     description: z.ZodOptional<z.ZodString>;
                     isDefault: z.ZodOptional<z.ZodBoolean>;
-                }, "strict", z.ZodTypeAny, {
+                }, "strip", z.ZodTypeAny, {
                     id: string;
                     label: string;
                     description?: string | undefined;
@@ -210,7 +210,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
                     description?: string | undefined;
                     isDefault?: boolean | undefined;
                 }>, "many">>;
-            }, "strict", z.ZodTypeAny, {
+            }, "strip", z.ZodTypeAny, {
                 id: string;
                 label: string;
                 description?: string | undefined;
@@ -243,7 +243,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
                     label: z.ZodString;
                     description: z.ZodOptional<z.ZodString>;
                     isDefault: z.ZodOptional<z.ZodBoolean>;
-                }, "strict", z.ZodTypeAny, {
+                }, "strip", z.ZodTypeAny, {
                     id: string;
                     label: string;
                     description?: string | undefined;
@@ -254,7 +254,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
                     description?: string | undefined;
                     isDefault?: boolean | undefined;
                 }>, "many">>;
-            }, "strict", z.ZodTypeAny, {
+            }, "strip", z.ZodTypeAny, {
                 id: string;
                 label: string;
                 description?: string | undefined;
@@ -280,7 +280,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             order: z.ZodOptional<z.ZodNumber>;
-        }, "strict", z.ZodTypeAny, {
+        }, "strip", z.ZodTypeAny, {
             description?: string | undefined;
             label?: string | undefined;
             enabled?: boolean | undefined;

package/dist/server/server/schedule/cron.js

@@ -71,9 +71,59 @@ function parseCronExpression(expression) {
 function startOfNextMinute(date) {
     return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes() + 1, 0, 0));
 }
+function assertValidTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone }).format(new Date(0));
+    }
+    catch {
+        throw new Error(`Invalid cron time zone: ${timeZone}`);
+    }
+}
+function createCronDatePartsReader(timeZone) {
+    if (timeZone === undefined) {
+        return (date) => ({
+            minute: date.getUTCMinutes(),
+            hour: date.getUTCHours(),
+            dayOfMonth: date.getUTCDate(),
+            month: date.getUTCMonth() + 1,
+            dayOfWeek: date.getUTCDay(),
+        });
+    }
+    assertValidTimeZone(timeZone);
+    const formatter = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+    });
+    return (date) => {
+        const values = {};
+        for (const part of formatter.formatToParts(date)) {
+            if (part.type !== "literal") {
+                values[part.type] = part.value;
+            }
+        }
+        const year = Number.parseInt(values.year, 10);
+        const month = Number.parseInt(values.month, 10);
+        const dayOfMonth = Number.parseInt(values.day, 10);
+        return {
+            minute: Number.parseInt(values.minute, 10),
+            hour: Number.parseInt(values.hour, 10),
+            dayOfMonth,
+            month,
+            dayOfWeek: new Date(Date.UTC(year, month - 1, dayOfMonth)).getUTCDay(),
+        };
+    };
+}
 export function validateScheduleCadence(cadence) {
     if (cadence.type === "cron") {
         parseCronExpression(cadence.expression);
+        if (cadence.timezone !== undefined) {
+            assertValidTimeZone(cadence.timezone);
+        }
     }
 }
 export function computeNextRunAt(cadence, after) {
@@ -81,14 +131,11 @@ export function computeNextRunAt(cadence, after) {
         return new Date(after.getTime() + cadence.everyMs);
     }
     const cron = parseCronExpression(cadence.expression);
+    const readDateParts = createCronDatePartsReader(cadence.timezone);
     const limit = 366 * 24 * 60;
     let cursor = startOfNextMinute(after);
     for (let index = 0; index < limit; index += 1) {
-        const minute = cursor.getUTCMinutes();
-        const hour = cursor.getUTCHours();
-        const dayOfMonth = cursor.getUTCDate();
-        const month = cursor.getUTCMonth() + 1;
-        const dayOfWeek = cursor.getUTCDay();
+        const { minute, hour, dayOfMonth, month, dayOfWeek } = readDateParts(cursor);
         if (cron.minute.matches(minute) &&
             cron.hour.matches(hour) &&
             cron.dayOfMonth.matches(dayOfMonth) &&

package/dist/server/server/session.d.ts

@@ -489,7 +489,10 @@ export declare class Session {
     private handleWorkspaceSetupStatusRequest;
     private handleArchiveWorkspaceRequest;
     private handleFetchAgent;
-    private loadProjectedTimelineWindow;
+    private shouldUseFullTimelineForProjectedPage;
+    private selectCanonicalTimelineProjection;
+    private selectProjectedTimelineProjection;
+    private selectTimelineProjection;
     private handleFetchAgentTimelineRequest;
     private handleSendAgentMessageRequest;
     private handleWaitForFinish;

package/dist/server/server/session.js

@@ -38,7 +38,7 @@ import { createAgentCommand } from "./agent/create-agent/create.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
 import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
-import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from "./agent/timeline-projection.js";
+import { projectTimelineRows, selectProjectedTimelinePage, } from "./agent/timeline-projection.js";
 import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
 import { resolveStructuredGenerationProviders, } from "./agent/structured-generation-providers.js";
 import { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.js";
@@ -370,6 +370,7 @@ export class Session {
             hasBinaryChannel: () => this.onBinaryMessage !== null,
             isPathWithinRoot: (rootPath, candidatePath) => this.isPathWithinRoot(rootPath, candidatePath),
             sessionLogger: this.sessionLogger,
+            clientSupportsWrapReflow: () => this.clientCapabilities.has(CLIENT_CAPS.terminalReflowableSnapshot),
         });
         this.createAgentLifecycleDispatch = new CreateAgentLifecycleDispatch({
             paseoHome: this.paseoHome,
@@ -5652,62 +5653,63 @@ export class Session {
             payload: { requestId, agent, project, error: null },
         });
     }
-    loadProjectedTimelineWindow(params) {
-        const { agentId, direction, cursor, requestedLimit } = params;
-        let timeline = params.timeline;
-        const projectedLimit = Math.max(1, Math.floor(requestedLimit));
-        let fetchLimit = projectedLimit;
-        let projectedWindow = selectTimelineWindowByProjectedLimit({
+    shouldUseFullTimelineForProjectedPage(input) {
+        const { timeline } = input;
+        if (timeline.reset || timeline.rows.length === 0 || !timeline.hasOlder) {
+            return false;
+        }
+        const firstRow = timeline.rows[0];
+        if (firstRow?.item.type === "assistant_message" ||
+            firstRow?.item.type === "reasoning" ||
+            firstRow?.item.type === "tool_call") {
+            return true;
+        }
+        return timeline.rows.some((row) => row.item.type === "tool_call");
+    }
+    selectCanonicalTimelineProjection(input) {
+        const entries = projectTimelineRows({ rows: input.timeline.rows, mode: "canonical" });
+        return {
+            timeline: input.timeline,
+            entries,
+            startSeq: entries[0]?.seqStart ?? null,
+            endSeq: entries[entries.length - 1]?.seqEnd ?? null,
+            hasOlder: input.timeline.hasOlder,
+            hasNewer: input.timeline.hasNewer,
+        };
+    }
+    selectProjectedTimelineProjection(input) {
+        const timeline = this.shouldUseFullTimelineForProjectedPage({
+            timeline: input.controlTimeline,
+        })
+            ? this.agentManager.fetchTimeline(input.agentId, { direction: "tail", limit: 0 })
+            : input.controlTimeline;
+        const page = selectProjectedTimelinePage({
             rows: timeline.rows,
-            direction,
-            limit: projectedLimit,
-            collapseToolLifecycle: false,
+            bounds: timeline.window,
+            direction: input.controlTimeline.reset ? "tail" : input.direction,
+            ...(input.cursor ? { cursorSeq: input.cursor.seq } : {}),
+            limit: input.pageLimit,
         });
-        while (timeline.hasOlder) {
-            const needsMoreProjectedEntries = projectedWindow.projectedEntries.length < projectedLimit;
-            const firstLoadedRow = timeline.rows[0];
-            const firstSelectedRow = projectedWindow.selectedRows[0];
-            const startsAtLoadedBoundary = firstLoadedRow != null &&
-                firstSelectedRow != null &&
-                firstSelectedRow.seq === firstLoadedRow.seq;
-            const boundaryIsAssistantChunk = startsAtLoadedBoundary && firstLoadedRow.item.type === "assistant_message";
-            if (!needsMoreProjectedEntries && !boundaryIsAssistantChunk) {
-                break;
-            }
-            const maxRows = Math.max(0, timeline.window.maxSeq - timeline.window.minSeq + 1);
-            const nextFetchLimit = Math.min(maxRows, fetchLimit * 2);
-            if (nextFetchLimit <= fetchLimit) {
-                break;
-            }
-            fetchLimit = nextFetchLimit;
-            timeline = this.agentManager.fetchTimeline(agentId, {
-                direction,
-                cursor,
-                limit: fetchLimit,
-            });
-            projectedWindow = selectTimelineWindowByProjectedLimit({
-                rows: timeline.rows,
-                direction,
-                limit: projectedLimit,
-                collapseToolLifecycle: false,
-            });
-        }
         return {
             timeline,
-            selectedRows: projectedWindow.selectedRows,
-            minSeq: projectedWindow.minSeq,
-            maxSeq: projectedWindow.maxSeq,
+            entries: page.entries,
+            startSeq: page.startSeq,
+            endSeq: page.endSeq,
+            hasOlder: page.hasOlder || (page.startSeq !== null && page.startSeq > timeline.window.minSeq),
+            hasNewer: page.hasNewer,
         };
     }
+    selectTimelineProjection(input) {
+        if (input.projection === "canonical") {
+            return this.selectCanonicalTimelineProjection({ timeline: input.controlTimeline });
+        }
+        return this.selectProjectedTimelineProjection(input);
+    }
     async handleFetchAgentTimelineRequest(msg) {
         const direction = msg.direction ?? (msg.cursor ? "after" : "tail");
         const projection = msg.projection ?? "projected";
         const requestedLimit = msg.limit;
-        const limit = requestedLimit ?? (direction === "after" ? 0 : undefined);
-        const shouldLimitByProjectedWindow = projection === "canonical" &&
-            direction === "tail" &&
-            typeof requestedLimit === "number" &&
-            requestedLimit > 0;
+        const pageLimit = requestedLimit ?? (direction === "after" ? 0 : 200);
         const cursor = msg.cursor
             ? {
                 epoch: msg.cursor.epoch,
@@ -5721,42 +5723,25 @@ export class Session {
                 logger: this.sessionLogger,
             });
             const agentPayload = await this.buildAgentPayload(snapshot);
-            let timeline = this.agentManager.fetchTimeline(msg.agentId, {
+            const controlTimeline = this.agentManager.fetchTimeline(msg.agentId, {
                 direction,
                 cursor,
-                limit: shouldLimitByProjectedWindow && typeof requestedLimit === "number"
-                    ? Math.max(1, Math.floor(requestedLimit))
-                    : limit,
-            });
-            let hasOlder = timeline.hasOlder;
-            let hasNewer = timeline.hasNewer;
-            let startCursor = null;
-            let endCursor = null;
-            let entries;
-            if (shouldLimitByProjectedWindow) {
-                const projectedResult = this.loadProjectedTimelineWindow({
-                    agentId: msg.agentId,
-                    direction,
-                    cursor,
-                    requestedLimit,
-                    timeline,
-                });
-                timeline = projectedResult.timeline;
-                entries = projectTimelineRows({ rows: projectedResult.selectedRows, mode: projection });
-                if (projectedResult.minSeq !== null && projectedResult.maxSeq !== null) {
-                    startCursor = { epoch: timeline.epoch, seq: projectedResult.minSeq };
-                    endCursor = { epoch: timeline.epoch, seq: projectedResult.maxSeq };
-                    hasOlder = projectedResult.minSeq > timeline.window.minSeq;
-                    hasNewer = false;
-                }
-            }
-            else {
-                const firstRow = timeline.rows[0];
-                const lastRow = timeline.rows[timeline.rows.length - 1];
-                startCursor = firstRow ? { epoch: timeline.epoch, seq: firstRow.seq } : null;
-                endCursor = lastRow ? { epoch: timeline.epoch, seq: lastRow.seq } : null;
-                entries = projectTimelineRows({ rows: timeline.rows, mode: projection });
-            }
+                limit: pageLimit,
+            });
+            const selectedTimeline = this.selectTimelineProjection({
+                agentId: msg.agentId,
+                projection,
+                controlTimeline,
+                direction,
+                ...(cursor ? { cursor } : {}),
+                pageLimit,
+            });
+            const startCursor = selectedTimeline.startSeq !== null
+                ? { epoch: selectedTimeline.timeline.epoch, seq: selectedTimeline.startSeq }
+                : null;
+            const endCursor = selectedTimeline.endSeq !== null
+                ? { epoch: selectedTimeline.timeline.epoch, seq: selectedTimeline.endSeq }
+                : null;
             this.emit({
                 type: "fetch_agent_timeline_response",
                 payload: {
@@ -5765,16 +5750,16 @@ export class Session {
                     agent: agentPayload,
                     direction,
                     projection,
-                    epoch: timeline.epoch,
-                    reset: timeline.reset,
-                    staleCursor: timeline.staleCursor,
-                    gap: timeline.gap,
-                    window: timeline.window,
+                    epoch: selectedTimeline.timeline.epoch,
+                    reset: controlTimeline.reset,
+                    staleCursor: controlTimeline.staleCursor,
+                    gap: controlTimeline.gap,
+                    window: selectedTimeline.timeline.window,
                     startCursor,
                     endCursor,
-                    hasOlder,
-                    hasNewer,
-                    entries: entries.map((entry) => ({
+                    hasOlder: selectedTimeline.hasOlder,
+                    hasNewer: selectedTimeline.hasNewer,
+                    entries: selectedTimeline.entries.map((entry) => ({
                         provider: snapshot.provider,
                         item: entry.item,
                         timestamp: entry.timestamp,

package/dist/server/terminal/terminal-manager.js

@@ -1,6 +1,7 @@
 import { createTerminal, } from "./terminal.js";
 import { captureTerminalLines } from "./terminal-capture.js";
 import { resolve, sep, win32, posix } from "node:path";
+import { isSameOrDescendantPath } from "../server/path-utils.js";
 export function createTerminalManager() {
     const terminalsByCwd = new Map();
     const terminalsById = new Map();
@@ -99,7 +100,16 @@ export function createTerminalManager() {
     return {
         async getTerminals(cwd) {
             assertAbsolutePath(cwd);
-            return terminalsByCwd.get(cwd) ?? [];
+            // Terminals are bucketed by exact cwd, but an agent can open a terminal in
+            // a subdirectory of the workspace. A query for the workspace root must
+            // surface those too, so aggregate every bucket at or below `cwd`.
+            const sessions = [];
+            for (const [bucketCwd, bucketSessions] of terminalsByCwd) {
+                if (isSameOrDescendantPath(cwd, bucketCwd)) {
+                    sessions.push(...bucketSessions);
+                }
+            }
+            return sessions;
         },
         async createTerminal(options) {
             assertAbsolutePath(options.cwd);

package/dist/server/terminal/terminal-session-controller.d.ts

@@ -9,6 +9,7 @@ export interface TerminalSessionControllerOptions {
     hasBinaryChannel: () => boolean;
     isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
     sessionLogger: pino.Logger;
+    clientSupportsWrapReflow?: () => boolean;
 }
 export interface TerminalSessionControllerMetrics {
     directorySubscriptionCount: number;
@@ -21,6 +22,7 @@ export declare class TerminalSessionController {
     private readonly hasBinaryChannel;
     private readonly isPathWithinRoot;
     private readonly sessionLogger;
+    private readonly clientSupportsWrapReflow;
     private readonly subscribedDirectories;
     private unsubscribeTerminalsChanged;
     private readonly exitSubscriptions;
@@ -45,7 +47,7 @@ export declare class TerminalSessionController {
     private handleTerminalsChanged;
     private handleSubscribeTerminalsRequest;
     private handleUnsubscribeTerminalsRequest;
-    private emitInitialTerminalsChangedSnapshot;
+    private emitTerminalsSnapshotForRoot;
     private handleListTerminalsRequest;
     private getAllTerminalSessions;
     private handleCreateTerminalRequest;

package/dist/server/terminal/terminal-session-controller.js

@@ -29,12 +29,15 @@ export class TerminalSessionController {
         this.hasBinaryChannel = options.hasBinaryChannel;
         this.isPathWithinRoot = options.isPathWithinRoot;
         this.sessionLogger = options.sessionLogger;
+        this.clientSupportsWrapReflow = options.clientSupportsWrapReflow ?? (() => false);
     }
     start() {
         if (!this.terminalManager) {
             return;
         }
-        this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => this.handleTerminalsChanged(event));
+        this.unsubscribeTerminalsChanged = this.terminalManager.subscribeTerminalsChanged((event) => {
+            void this.handleTerminalsChanged(event);
+        });
     }
     getMetrics() {
         return {
@@ -173,23 +176,25 @@ export class TerminalSessionController {
             ...(title ? { title } : {}),
         };
     }
-    handleTerminalsChanged(event) {
-        if (!this.subscribedDirectories.has(event.cwd)) {
-            return;
+    async handleTerminalsChanged(event) {
+        // A terminal can live in a subdirectory of a subscribed workspace root (an
+        // agent can open one there). Deliver the change to every subscribed root at
+        // or above the terminal's cwd, keyed by that root, carrying the full
+        // aggregated list — so the client's cache replacement doesn't drop the
+        // terminals that live directly at the root.
+        const matchingRoots = Array.from(this.subscribedDirectories).filter((root) => this.isPathWithinRoot(root, event.cwd));
+        for (const root of matchingRoots) {
+            await this.emitTerminalsSnapshotForRoot(root);
         }
-        this.emitTerminalsChangedSnapshot({
-            cwd: event.cwd,
-            terminals: event.terminals.map((terminal) => Object.assign({ id: terminal.id, name: terminal.name }, terminal.title ? { title: terminal.title } : {})),
-        });
     }
     handleSubscribeTerminalsRequest(msg) {
         this.subscribedDirectories.add(msg.cwd);
-        void this.emitInitialTerminalsChangedSnapshot(msg.cwd);
+        void this.emitTerminalsSnapshotForRoot(msg.cwd);
     }
     handleUnsubscribeTerminalsRequest(msg) {
         this.subscribedDirectories.delete(msg.cwd);
     }
-    async emitInitialTerminalsChangedSnapshot(cwd) {
+    async emitTerminalsSnapshotForRoot(cwd) {
         if (!this.terminalManager || !this.subscribedDirectories.has(cwd)) {
             return;
         }
@@ -618,7 +623,9 @@ export class TerminalSessionController {
         }
     }
     async emitLegacySnapshot(activeStream, terminalManager) {
-        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId);
+        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, {
+            includeWrapFlags: this.clientSupportsWrapReflow(),
+        });
         if (this.activeStreams.get(activeStream.slot) !== activeStream) {
             return { shouldContinue: false };
         }
@@ -637,7 +644,10 @@ export class TerminalSessionController {
         if (snapshotOptions === null) {
             return { shouldContinue: true };
         }
-        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, snapshotOptions);
+        const snapshot = await terminalManager.getTerminalState(activeStream.terminalId, {
+            ...snapshotOptions,
+            includeWrapFlags: this.clientSupportsWrapReflow(),
+        });
         if (this.activeStreams.get(activeStream.slot) !== activeStream) {
             return { shouldContinue: false };
         }

package/dist/server/terminal/terminal.d.ts

@@ -13,6 +13,7 @@ export interface TerminalStateSnapshot {
 }
 export interface TerminalStateSnapshotOptions {
     scrollbackLines?: number;
+    includeWrapFlags?: boolean;
 }
 export interface TerminalSubscribeOptions {
     initialSnapshot?: "state" | "ready";

package/dist/server/terminal/terminal.js

@@ -232,6 +232,32 @@ function extractScrollback(terminal, options) {
     }
     return scrollback;
 }
+// xterm marks a line `isWrapped` when it is a continuation of the PREVIOUS line.
+// The snapshot carries the inverse, tmux-style flag — "this row continues onto the
+// next row" — so the client can rejoin and reflow logical lines. So row y's flag is
+// whether line y+1 is a wrapped continuation.
+function lineContinuesToNext(terminal, absoluteRow) {
+    return terminal.buffer.active.getLine(absoluteRow + 1)?.isWrapped === true;
+}
+function extractGridWrapped(terminal) {
+    const baseY = terminal.buffer.active.baseY;
+    const wrapped = [];
+    for (let row = 0; row < terminal.rows; row++) {
+        wrapped.push(lineContinuesToNext(terminal, baseY + row));
+    }
+    return wrapped;
+}
+function extractScrollbackWrapped(terminal, options) {
+    const scrollbackLines = terminal.buffer.active.baseY;
+    const startRow = typeof options?.scrollbackLines === "number"
+        ? Math.max(0, scrollbackLines - options.scrollbackLines)
+        : 0;
+    const wrapped = [];
+    for (let row = startRow; row < scrollbackLines; row++) {
+        wrapped.push(lineContinuesToNext(terminal, row));
+    }
+    return wrapped;
+}
 function extractCursorState(terminal) {
     const coreService = terminal
         ._core?.coreService;
@@ -659,6 +685,14 @@ export async function createTerminal(options) {
             }),
             cursor: extractCursorState(terminal),
             ...(title ? { title } : {}),
+            ...(snapshotOptions?.includeWrapFlags
+                ? {
+                    gridWrapped: extractGridWrapped(terminal),
+                    scrollbackWrapped: extractScrollbackWrapped(terminal, {
+                        scrollbackLines: snapshotOptions?.scrollbackLines,
+                    }),
+                }
+                : {}),
         };
     }
     function getStateSnapshot(snapshotOptions) {

package/dist/server/utils/checkout-git.js

@@ -375,7 +375,7 @@ function buildGitDiffArgs(args) {
     return ["diff", ...(args.ignoreWhitespace ? ["-w"] : []), ...args.extra];
 }
 const TRACKED_DIFF_NUMSTAT_MAX_BYTES = 2 * 1024 * 1024; // 2MB
-const TRACKED_MAX_CHANGED_LINES = 40000;
+const TRACKED_DIFF_PER_FILE_MAX_CHARS = 1024 * 1024;
 const EMPTY_TREE_OBJECT_ID = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 function isUnbornHeadDiffError(error) {
     return (error instanceof Error &&
@@ -423,11 +423,56 @@ async function getTrackedNumstatByPath(cwd, refs, ignoreWhitespace = false) {
     }
     return stats;
 }
-function isTrackedDiffTooLarge(stat) {
-    if (!stat || stat.isBinary) {
-        return false;
+function extractTrackedDiffMetadataPath(section, prefix) {
+    const line = section.split("\n").find((candidate) => candidate.startsWith(prefix));
+    if (!line) {
+        return null;
+    }
+    const path = line.slice(prefix.length).replace(/\t.*$/, "").trimEnd();
+    if (path === "/dev/null") {
+        return null;
+    }
+    return path.startsWith("a/") || path.startsWith("b/") ? path.slice(2) : path;
+}
+function extractTrackedDiffSectionPath(section) {
+    const firstLineEnd = section.indexOf("\n");
+    const firstLine = firstLineEnd === -1 ? section : section.slice(0, firstLineEnd);
+    const header = firstLine.startsWith("diff --git ") ? firstLine.slice("diff --git ".length) : "";
+    const prefixedPathMatch = header.match(/^a\/(.+) b\/(.+)$/);
+    if (prefixedPathMatch) {
+        return prefixedPathMatch[2] ?? null;
+    }
+    const metadataPath = extractTrackedDiffMetadataPath(section, "+++ ") ??
+        extractTrackedDiffMetadataPath(section, "--- ");
+    if (metadataPath) {
+        return metadataPath;
+    }
+    const pathMatch = header.match(/^(\S+)\s+(\S+)$/);
+    return pathMatch?.[2] ?? null;
+}
+function splitTrackedDiffSections(diffText) {
+    const starts = [];
+    const diffHeaderPattern = /^diff --git /gm;
+    let match;
+    while ((match = diffHeaderPattern.exec(diffText))) {
+        starts.push(match.index);
+    }
+    const sections = [];
+    for (let index = 0; index < starts.length; index += 1) {
+        const start = starts[index];
+        const end = starts[index + 1] ?? diffText.length;
+        const text = diffText.slice(start, end);
+        const path = extractTrackedDiffSectionPath(text);
+        if (!path) {
+            continue;
+        }
+        sections.push({
+            path,
+            text,
+            isTooLarge: text.length > TRACKED_DIFF_PER_FILE_MAX_CHARS,
+        });
     }
-    return stat.additions + stat.deletions > TRACKED_MAX_CHANGED_LINES;
+    return sections;
 }
 export class NotGitRepoError extends Error {
     constructor(cwd) {
@@ -1500,6 +1545,62 @@ async function processUntrackedChange(input) {
         status: "ok",
     });
 }
+async function processTrackedChanges(input) {
+    const { cwd, refsForDiff, trackedChanges, ignoreWhitespace, appendDiff } = input;
+    const trackedChangeByPath = new Map(trackedChanges.map((change) => [change.path, change]));
+    const trackedNumstatByPath = trackedChanges.length > 0
+        ? await getTrackedNumstatByPath(cwd, refsForDiff, ignoreWhitespace)
+        : new Map();
+    const trackedDiffPaths = [];
+    const trackedPlaceholderByPath = new Map();
+    for (const change of trackedChanges) {
+        const stat = trackedNumstatByPath.get(change.path) ?? null;
+        if (stat?.isBinary) {
+            trackedPlaceholderByPath.set(change.path, { status: "binary", stat });
+            continue;
+        }
+        trackedDiffPaths.push(change.path);
+    }
+    let trackedDiffText = "";
+    let trackedDiffTruncated = false;
+    if (trackedDiffPaths.length > 0) {
+        const trackedDiffResult = await runGitCommand(buildGitDiffArgs({
+            ignoreWhitespace,
+            extra: [...getCheckoutDiffRefArgs(refsForDiff), "--", ...trackedDiffPaths],
+        }), {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+            maxOutputBytes: TOTAL_DIFF_MAX_BYTES,
+        });
+        trackedDiffTruncated = trackedDiffResult.truncated;
+        const visibleTrackedDiffs = [];
+        const sections = splitTrackedDiffSections(trackedDiffResult.stdout);
+        for (let index = 0; index < sections.length; index += 1) {
+            const section = sections[index];
+            const isTruncatedTail = trackedDiffTruncated && index === sections.length - 1;
+            if (section.isTooLarge || isTruncatedTail) {
+                trackedPlaceholderByPath.set(section.path, {
+                    status: "too_large",
+                    stat: trackedNumstatByPath.get(section.path) ?? null,
+                });
+                continue;
+            }
+            visibleTrackedDiffs.push(section.text);
+        }
+        trackedDiffText = visibleTrackedDiffs.join("");
+        appendDiff(trackedDiffText);
+        if (trackedDiffTruncated) {
+            appendDiff("# tracked diff truncated\n");
+        }
+    }
+    return {
+        trackedChangeByPath,
+        trackedNumstatByPath,
+        trackedPlaceholderByPath,
+        trackedDiffText,
+        trackedDiffTruncated,
+    };
+}
 async function resolveCheckoutDiffRefs(cwd, compare, context) {
     if (compare.mode === "uncommitted") {
         return { baseRef: "HEAD", includeUntracked: true };
@@ -1565,42 +1666,13 @@ export async function getCheckoutDiff(cwd, compare, context) {
     };
     const trackedChanges = changes.filter((change) => !change.isUntracked);
     const untrackedChanges = changes.filter((change) => change.isUntracked === true);
-    const trackedChangeByPath = new Map(trackedChanges.map((change) => [change.path, change]));
-    const trackedNumstatByPath = trackedChanges.length > 0
-        ? await getTrackedNumstatByPath(cwd, effectiveRefsForDiff, ignoreWhitespace)
-        : new Map();
-    const trackedDiffPaths = [];
-    const trackedPlaceholderByPath = new Map();
-    for (const change of trackedChanges) {
-        const stat = trackedNumstatByPath.get(change.path) ?? null;
-        if (stat?.isBinary) {
-            trackedPlaceholderByPath.set(change.path, { status: "binary", stat });
-            continue;
-        }
-        if (isTrackedDiffTooLarge(stat)) {
-            trackedPlaceholderByPath.set(change.path, { status: "too_large", stat });
-            continue;
-        }
-        trackedDiffPaths.push(change.path);
-    }
-    let trackedDiffText = "";
-    let trackedDiffTruncated = false;
-    if (trackedDiffPaths.length > 0) {
-        const trackedDiffResult = await runGitCommand(buildGitDiffArgs({
-            ignoreWhitespace,
-            extra: [...getCheckoutDiffRefArgs(effectiveRefsForDiff), "--", ...trackedDiffPaths],
-        }), {
-            cwd,
-            envOverlay: READ_ONLY_GIT_ENV,
-            maxOutputBytes: TOTAL_DIFF_MAX_BYTES,
-        });
-        trackedDiffText = trackedDiffResult.stdout;
-        trackedDiffTruncated = trackedDiffResult.truncated;
-        appendDiff(trackedDiffText);
-        if (trackedDiffTruncated) {
-            appendDiff("# tracked diff truncated\n");
-        }
-    }
+    const trackedDiff = await processTrackedChanges({
+        cwd,
+        refsForDiff: effectiveRefsForDiff,
+        trackedChanges,
+        ignoreWhitespace,
+        appendDiff,
+    });
     const appendTrackedPlaceholderComment = (change, status) => {
         if (status === "binary") {
             appendDiff(`# ${change.path}: binary diff omitted\n`);
@@ -1612,11 +1684,11 @@ export async function getCheckoutDiff(cwd, compare, context) {
         await appendStructuredTrackedDiffs({
             cwd,
             trackedChanges,
-            trackedChangeByPath,
-            trackedNumstatByPath,
-            trackedPlaceholderByPath,
-            trackedDiffText,
-            trackedDiffTruncated,
+            trackedChangeByPath: trackedDiff.trackedChangeByPath,
+            trackedNumstatByPath: trackedDiff.trackedNumstatByPath,
+            trackedPlaceholderByPath: trackedDiff.trackedPlaceholderByPath,
+            trackedDiffText: trackedDiff.trackedDiffText,
+            trackedDiffTruncated: trackedDiff.trackedDiffTruncated,
             refsForDiff: effectiveRefsForDiff,
             ignoreWhitespace,
             structured,
@@ -1626,7 +1698,7 @@ export async function getCheckoutDiff(cwd, compare, context) {
     }
     else {
         for (const change of trackedChanges) {
-            const placeholder = trackedPlaceholderByPath.get(change.path);
+            const placeholder = trackedDiff.trackedPlaceholderByPath.get(change.path);
             if (placeholder) {
                 appendTrackedPlaceholderComment(change, placeholder.status);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.87",
+  "version": "0.1.88",
   "description": "Paseo backend server",
   "files": [
     "dist/server",
@@ -57,10 +57,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.17.1",
     "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@getpaseo/client": "0.1.87",
-    "@getpaseo/highlight": "0.1.87",
-    "@getpaseo/protocol": "0.1.87",
-    "@getpaseo/relay": "0.1.87",
+    "@getpaseo/client": "0.1.88",
+    "@getpaseo/highlight": "0.1.88",
+    "@getpaseo/protocol": "0.1.88",
+    "@getpaseo/relay": "0.1.88",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",