@getpaseo/server 0.1.88 → 0.1.90

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

@@ -300,6 +300,23 @@ export async function createAgentMcpServer(options) {
     });
     const registerRawTool = server.registerTool.bind(server);
     const registerTool = (name, config, handler) => registerRawTool(name, relaxMcpToolOutputSchema(config), (async (args, extra) => addModelVisibleStructuredContent(await handler(args, extra))));
+    const buildCronScheduleCadence = (input) => {
+        const expression = input.cron?.trim() ?? "";
+        if (!expression) {
+            throw new Error("cron is required");
+        }
+        const timezone = normalizeScheduleTimeZoneArg(input.timezone);
+        return {
+            type: "cron",
+            expression,
+            ...(timezone !== undefined ? { timezone } : {}),
+        };
+    };
+    const buildScheduleExpiry = (expiresIn) => {
+        return expiresIn === undefined
+            ? undefined
+            : new Date(Date.now() + parseDurationString(expiresIn)).toISOString();
+    };
     const resolveCallerAgent = () => {
         if (!callerAgentId) {
             return null;
@@ -325,7 +342,7 @@ export async function createAgentMcpServer(options) {
             if (opts?.required) {
                 throw new Error("cwd is required");
             }
-            throw new Error("cwd is required when no caller agent is available");
+            throw new Error("cwd is required outside an agent-scoped session");
         }
         return expandUserPath(trimmedCwd);
     };
@@ -469,7 +486,7 @@ export async function createAgentMcpServer(options) {
         cwd: z
             .string()
             .optional()
-            .describe("Optional working directory. Defaults to the caller agent working directory."),
+            .describe("Optional working directory. Defaults to your current working directory."),
         title: z
             .string()
             .trim()
@@ -484,16 +501,16 @@ export async function createAgentMcpServer(options) {
             .trim()
             .min(1, "initialPrompt is required")
             .describe("Required first task to run immediately after creation."),
-        background: z
+        detached: z
             .boolean()
             .optional()
             .default(false)
-            .describe("Run agent in background. If false (default), waits for completion or permission request. If true, returns immediately."),
+            .describe("If true, the created agent stands on its own: it does not appear in your subagent track and is not archived with you."),
         notifyOnFinish: z
             .boolean()
             .optional()
-            .default(false)
-            .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."),
+            .default(true)
+            .describe("Get notified when the created agent finishes, errors, or needs permission. Set false only for truly fire-and-forget agents."),
     };
     const topLevelInputSchema = {
         cwd: z
@@ -541,7 +558,7 @@ export async function createAgentMcpServer(options) {
             .boolean()
             .optional()
             .default(false)
-            .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."),
+            .describe("Agent-scoped only: get notified when the created agent finishes, errors, or needs permission."),
     };
     const createAgentInputSchema = callerAgentId ? agentToAgentInputSchema : topLevelInputSchema;
     const agentToAgentCreateAgentArgsSchema = z.object(agentToAgentInputSchema).strict();
@@ -574,7 +591,7 @@ export async function createAgentMcpServer(options) {
             }
             const handler = resolveSpeakHandler?.(callerAgentId) ?? null;
             if (!handler) {
-                throw new Error(`No speak handler registered for caller agent '${callerAgentId}'`);
+                throw new Error(`No speak handler registered for your session '${callerAgentId}'`);
             }
             await handler({
                 text: args.text,
@@ -603,14 +620,30 @@ export async function createAgentMcpServer(options) {
             availableModes: z.array(ProviderModeSchema),
             lastMessage: z.string().nullable().optional(),
             permission: AgentPermissionRequestPayloadSchema.nullable().optional(),
+            guidance: z.string().optional(),
         },
     }, async (args) => {
-        const { parsedArgs, worktree } = resolveCreateAgentToolArgs(args);
-        const { snapshot, background, initialPromptStarted } = await createAgentCommand({
+        const resolvedArgs = resolveCreateAgentToolArgs(args);
+        const { parsedArgs, worktree } = resolvedArgs;
+        let requestedBackground;
+        let notifyOnFinish;
+        let detached;
+        if (resolvedArgs.kind === "agent-scoped") {
+            requestedBackground = true;
+            notifyOnFinish = resolvedArgs.parsedArgs.notifyOnFinish;
+            detached = resolvedArgs.parsedArgs.detached;
+        }
+        else {
+            requestedBackground = resolvedArgs.parsedArgs.background;
+            notifyOnFinish = resolvedArgs.parsedArgs.notifyOnFinish ?? false;
+            detached = false;
+        }
+        const { snapshot, background: createdInBackground, initialPromptStarted, } = await createAgentCommand({
             agentManager,
             agentStorage,
             logger: childLogger,
             paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
             workspaceGitService: options.workspaceGitService,
             terminalManager,
             providerSnapshotManager,
@@ -625,14 +658,15 @@ export async function createAgentMcpServer(options) {
             features: parsedArgs.settings?.features,
             labels: parsedArgs.labels,
             mode: parsedArgs.settings?.modeId,
-            background: parsedArgs.background ?? false,
-            notifyOnFinish: parsedArgs.notifyOnFinish ?? false,
+            background: requestedBackground,
+            notifyOnFinish,
+            detached,
             callerAgentId,
             callerContext,
             worktree,
         });
         try {
-            if (!background && initialPromptStarted) {
+            if (!createdInBackground && initialPromptStarted) {
                 const result = await waitForAgentWithTimeout(agentManager, snapshot.id, {
                     waitForActive: true,
                 });
@@ -659,8 +693,11 @@ export async function createAgentMcpServer(options) {
             childLogger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
             throw error;
         }
-        // Return immediately if background=true
+        // Return immediately for async creation.
         const currentSnapshot = agentManager.getAgent(snapshot.id) ?? snapshot;
+        const guidance = callerAgentId && notifyOnFinish && initialPromptStarted
+            ? "You will get notified when the created agent finishes, errors, or needs permission. Do not call wait_for_agent or poll for status; continue with other work until the notification arrives."
+            : undefined;
         const response = {
             content: [],
             structuredContent: ensureValidJson({
@@ -672,6 +709,7 @@ export async function createAgentMcpServer(options) {
                 availableModes: currentSnapshot.availableModes,
                 lastMessage: null,
                 permission: null,
+                ...(guidance ? { guidance } : {}),
             }),
         };
         return response;
@@ -679,12 +717,14 @@ export async function createAgentMcpServer(options) {
     function resolveCreateAgentToolArgs(args) {
         if (callerAgentId) {
             return {
+                kind: "agent-scoped",
                 parsedArgs: agentToAgentCreateAgentArgsSchema.parse(args),
                 worktree: undefined,
             };
         }
         const parsedArgs = topLevelCreateAgentArgsSchema.parse(args);
         return {
+            kind: "top-level",
             parsedArgs,
             worktree: resolveTopLevelCreateAgentWorktree(parsedArgs),
         };
@@ -784,7 +824,7 @@ export async function createAgentMcpServer(options) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission."),
+                .describe("Agent-scoped only: get notified when this run finishes, errors, or needs permission."),
         },
         outputSchema: {
             success: z.boolean(),
@@ -1025,7 +1065,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional working directory. Defaults to the caller agent cwd."),
+                .describe("Optional working directory. Defaults to your current working directory."),
             all: z.boolean().optional().describe("List terminals across all working directories."),
         },
         outputSchema: {
@@ -1058,7 +1098,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional working directory. Defaults to the caller agent cwd."),
+                .describe("Optional working directory. Defaults to your current working directory."),
             name: z.string().optional().describe("Optional terminal name."),
         },
         outputSchema: TerminalSummarySchema.shape,
@@ -1168,79 +1208,80 @@ export async function createAgentMcpServer(options) {
     });
     registerTool("create_schedule", {
         title: "Create schedule",
-        description: "Create a recurring schedule that runs on an agent or a new agent.",
+        description: "Create a recurring schedule that starts a new agent on a cron cadence.",
         inputSchema: {
             prompt: z.string().trim().min(1, "prompt is required"),
-            every: z.string().optional(),
-            cron: z.string().optional(),
+            cron: z.string().trim().min(1, "cron is required"),
             timezone: z
                 .string()
                 .trim()
                 .min(1)
                 .optional()
-                .describe("IANA time zone for cron cadence; requires cron. For example: America/New_York."),
+                .describe("IANA time zone for the cron cadence. 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)."),
+            provider: AgentProviderEnum.describe("Provider, or provider/model (for example: codex or codex/gpt-5.4)."),
             cwd: z.string().optional(),
             maxRuns: z.number().int().positive().optional(),
             expiresIn: z.string().optional(),
         },
         outputSchema: ScheduleSummarySchema.shape,
-    }, async ({ prompt, every, cron, timezone, name, target, provider, cwd, maxRuns, expiresIn }) => {
+    }, async ({ prompt, cron, timezone, name, 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");
+        const expiresAt = buildScheduleExpiry(expiresIn);
+        const schedule = await scheduleService.create({
+            prompt: prompt.trim(),
+            cadence: buildCronScheduleCadence({
+                cron,
+                ...(timezone !== undefined ? { timezone } : {}),
+            }),
+            target: resolveNewAgentScheduleTarget({ provider, cwd }),
+            ...(name?.trim() ? { name: name.trim() } : {}),
+            ...(maxRuns === undefined ? {} : { maxRuns }),
+            ...(expiresAt === undefined ? {} : { expiresAt }),
+        });
+        return {
+            content: [],
+            structuredContent: ensureValidJson(toScheduleSummary(schedule)),
+        };
+    });
+    registerTool("create_heartbeat", {
+        title: "Create heartbeat",
+        description: "Create a recurring heartbeat that sends you a prompt on a cron cadence.",
+        inputSchema: {
+            prompt: z.string().trim().min(1, "prompt is required"),
+            cron: z.string().trim().min(1, "cron is required"),
+            timezone: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("IANA time zone for the cron cadence. For example: America/New_York."),
+            name: z.string().optional(),
+            maxRuns: z.number().int().positive().optional(),
+            expiresIn: z.string().optional(),
+        },
+        outputSchema: ScheduleSummarySchema.shape,
+    }, async ({ prompt, cron, timezone, name, maxRuns, expiresIn }) => {
+        if (!scheduleService) {
+            throw new Error("Schedule service is not configured");
         }
-        if (normalizedTimeZone !== undefined && normalizedCron === undefined) {
-            throw new Error("timezone can only be used with cron");
+        if (!callerAgentId) {
+            throw new Error("create_heartbeat requires an agent-scoped session");
         }
-        const scheduleTarget = target === "self"
-            ? (() => {
-                const callerAgent = resolveCallerAgent();
-                if (!callerAgentId || !callerAgent) {
-                    throw new Error("target=self requires a caller agent");
-                }
-                const trimmedCwd = cwd?.trim();
-                if (trimmedCwd && expandUserPath(trimmedCwd) !== callerAgent.cwd) {
-                    throw new Error("cwd can only differ from the caller agent when target=new-agent");
-                }
-                if (provider !== undefined) {
-                    const resolved = resolveScheduleProviderAndModel({
-                        provider,
-                        defaultProvider: callerAgent.provider,
-                    });
-                    if (resolved.provider !== callerAgent.provider ||
-                        (resolved.model !== undefined && resolved.model !== callerAgent.config.model)) {
-                        throw new Error("provider can only differ from the caller agent when target=new-agent");
-                    }
-                }
-                return { type: "agent", agentId: callerAgentId };
-            })()
-            : (() => {
-                return resolveNewAgentScheduleTarget({ provider, cwd });
-            })();
+        resolveCallerAgent();
+        const expiresAt = buildScheduleExpiry(expiresIn);
         const schedule = await scheduleService.create({
             prompt: prompt.trim(),
-            cadence: normalizedEvery !== undefined
-                ? { type: "every", everyMs: parseDurationString(normalizedEvery) }
-                : {
-                    type: "cron",
-                    expression: normalizedCron,
-                    ...(normalizedTimeZone !== undefined ? { timezone: normalizedTimeZone } : {}),
-                },
-            target: scheduleTarget,
+            cadence: buildCronScheduleCadence({
+                cron,
+                ...(timezone !== undefined ? { timezone } : {}),
+            }),
+            target: { type: "agent", agentId: callerAgentId },
             ...(name?.trim() ? { name: name.trim() } : {}),
             ...(maxRuns === undefined ? {} : { maxRuns }),
-            ...(expiresIn === undefined
-                ? {}
-                : { expiresAt: new Date(Date.now() + parseDurationString(expiresIn)).toISOString() }),
+            ...(expiresAt === undefined ? {} : { expiresAt }),
         });
         return {
             content: [],
@@ -1518,7 +1559,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional repository cwd. Defaults to the caller agent cwd."),
+                .describe("Optional repository cwd. Defaults to your current working directory."),
         },
         outputSchema: {
             worktrees: z.array(WorktreeSummarySchema),
@@ -1578,6 +1619,7 @@ export async function createAgentMcpServer(options) {
         const repoRoot = resolveScopedCwd(cwd, { required: true });
         const commandResult = await createPaseoWorktreeCommand({
             paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
             createPaseoWorktreeWorkflow: options.createPaseoWorktree,
         }, createMcpWorktreeCommandInput(repoRoot, target));
         if (!commandResult.ok) {
@@ -1603,7 +1645,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional repository cwd. Defaults to the caller agent cwd."),
+                .describe("Optional repository cwd. Defaults to your current working directory."),
             worktreePath: z.string().optional(),
             worktreeSlug: z.string().optional(),
         },
@@ -1778,6 +1820,7 @@ function archiveWorktreeDependencies(options, context) {
     }
     return {
         paseoHome: options.paseoHome,
+        worktreesRoot: options.worktreesRoot,
         github: options.github,
         workspaceGitService: options.workspaceGitService,
         agentManager: context.agentManager,

package/dist/server/server/agent/provider-snapshot-manager.d.ts

@@ -28,12 +28,13 @@ interface ProviderSnapshotProviderOptions {
     provider: AgentProvider;
     wait?: boolean;
 }
-interface ResolveProviderCreateConfigOptions {
+export interface ResolveProviderCreateConfigOptions {
     cwd?: string | null;
     provider: AgentProvider;
     requestedMode: string | undefined;
     featureValues: Record<string, unknown> | undefined;
     parent: ManagedAgent | null;
+    unattended: boolean;
 }
 export interface ResolvedProviderCreateConfig {
     modeId: string | undefined;

package/dist/server/server/agent/provider-snapshot-manager.js

@@ -175,11 +175,13 @@ export class ProviderSnapshotManager {
             wait: true,
         });
         const definition = this.requireProvider(input.provider);
+        const parent = input.parent ? this.resolveParent(input.parent) : null;
         return definition.resolveCreateConfig({
             provider: input.provider,
             requestedMode: input.requestedMode,
             featureValues: input.featureValues,
-            parent: input.parent ? this.resolveParent(input.parent) : null,
+            parent,
+            unattended: input.unattended || parent?.isUnattended === true,
             availableModes: entry.modes ?? [],
         });
     }
@@ -227,12 +229,26 @@ export class ProviderSnapshotManager {
         this.providerLoads.clear();
     }
     buildRegistry() {
-        return buildProviderRegistry(this.logger, {
+        const registry = buildProviderRegistry(this.logger, {
             runtimeSettings: this.runtimeSettings,
             providerOverrides: this.providerOverrides,
             workspaceGitService: this.workspaceGitService,
             isDev: this.isDev,
         });
+        for (const [provider, client] of Object.entries(this.extraClients)) {
+            const definition = registry[provider];
+            if (!definition)
+                continue;
+            registry[provider] = {
+                ...definition,
+                createClient: () => client,
+                resolveCreateConfig: client.resolveCreateConfig?.bind(client) ?? definition.resolveCreateConfig,
+                isCreateConfigUnattended: client.isCreateConfigUnattended?.bind(client) ?? definition.isCreateConfigUnattended,
+                fetchModels: client.listModels.bind(client),
+                fetchModes: client.listModes?.bind(client) ?? definition.fetchModes,
+            };
+        }
+        return registry;
     }
     resolveParent(parent) {
         const definition = this.requireProvider(parent.provider);

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -181,6 +181,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private readonly subscribers;
     private readonly pendingPermissions;
     private readonly messageAssemblies;
+    private readonly submittedUserMessageIds;
     private readonly toolCalls;
     private readonly terminalEntries;
     private readonly persistedHistory;
@@ -208,15 +209,13 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private closed;
     private historyPending;
     private replayingHistory;
-    private suppressUserEchoMessageId;
-    private suppressUserEchoText;
     private bootstrapThreadEventPending;
     constructor(config: AgentSessionConfig, options: ACPAgentSessionOptions);
     get id(): string | null;
     initializeNewSession(): Promise<void>;
     initializeResumedSession(): Promise<void>;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
-    startTurn(prompt: AgentPromptInput, _options?: AgentRunOptions): Promise<{
+    startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{
         turnId: string;
     }>;
     subscribe(callback: (event: AgentStreamEvent) => void): () => void;
@@ -275,6 +274,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     private handlePromptResponse;
     private wrapTimeline;
     private pushEvent;
+    private emitSubmittedUserMessage;
     private runtimeInfo;
     private finishTurn;
     private emitBootstrapThreadEvent;

package/dist/server/server/agent/providers/acp-agent.js

@@ -518,6 +518,7 @@ export class ACPAgentSession {
         this.subscribers = new Set();
         this.pendingPermissions = new Map();
         this.messageAssemblies = new Map();
+        this.submittedUserMessageIds = new Set();
         this.toolCalls = new Map();
         this.terminalEntries = new Map();
         this.persistedHistory = [];
@@ -539,8 +540,6 @@ export class ACPAgentSession {
         this.closed = false;
         this.historyPending = false;
         this.replayingHistory = false;
-        this.suppressUserEchoMessageId = null;
-        this.suppressUserEchoText = null;
         this.bootstrapThreadEventPending = false;
         this.provider = options.provider;
         this.capabilities = options.capabilities;
@@ -635,7 +634,7 @@ export class ACPAgentSession {
         }
         return result;
     }
-    async startTurn(prompt, _options) {
+    async startTurn(prompt, options) {
         if (this.closed) {
             throw new Error(`${this.provider} session is closed`);
         }
@@ -646,12 +645,11 @@ export class ACPAgentSession {
             throw new Error("A foreground turn is already active");
         }
         const turnId = randomUUID();
-        const messageId = randomUUID();
+        const messageId = options?.messageId ?? randomUUID();
         this.activeForegroundTurnId = turnId;
-        this.suppressUserEchoMessageId = messageId;
-        this.suppressUserEchoText = extractPromptText(prompt);
         this.emitBootstrapThreadEvent();
         this.pushEvent({ type: "turn_started", provider: this.provider, turnId });
+        this.emitSubmittedUserMessage(prompt, messageId, turnId);
         void this.connection
             .prompt({
             sessionId: this.sessionId,
@@ -1360,11 +1358,7 @@ export class ACPAgentSession {
                 if (!item) {
                     return [];
                 }
-                const shouldSuppress = this.suppressUserEchoMessageId &&
-                    update.messageId === this.suppressUserEchoMessageId &&
-                    this.suppressUserEchoText &&
-                    item.text === this.suppressUserEchoText;
-                if (shouldSuppress) {
+                if (update.messageId && this.submittedUserMessageIds.has(update.messageId)) {
                     return [];
                 }
                 return [this.wrapTimeline(item)];
@@ -1533,6 +1527,19 @@ export class ACPAgentSession {
             subscriber(event);
         }
     }
+    emitSubmittedUserMessage(prompt, messageId, turnId) {
+        const text = extractPromptText(prompt);
+        if (text.trim().length === 0) {
+            return;
+        }
+        this.submittedUserMessageIds.add(messageId);
+        this.pushEvent({
+            type: "timeline",
+            provider: this.provider,
+            turnId,
+            item: { type: "user_message", text, messageId },
+        });
+    }
     runtimeInfo() {
         return {
             provider: this.provider,
@@ -1548,8 +1555,6 @@ export class ACPAgentSession {
     }
     finishTurn(event) {
         this.activeForegroundTurnId = null;
-        this.suppressUserEchoMessageId = null;
-        this.suppressUserEchoText = null;
         this.pushEvent(event);
     }
     emitBootstrapThreadEvent() {

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -572,6 +572,10 @@ function filterCodexThreadsByCwd(threads, cwd) {
     const matchesCwd = createPathEquivalenceMatcher(cwd);
     return threads.filter((thread) => typeof thread.cwd === "string" && matchesCwd(thread.cwd));
 }
+function buildCodexThreadListTimeline(thread) {
+    const preview = typeof thread.preview === "string" ? thread.preview.trim() : "";
+    return preview ? [{ type: "user_message", text: preview }] : [];
+}
 export function toAgentUsage(tokenUsage) {
     const usage = toObjectRecord(tokenUsage);
     if (!usage)
@@ -4315,31 +4319,21 @@ export class CodexAppServerAgentClient {
             await client.request("initialize", buildCodexAppServerInitializeParams());
             client.notify("initialized", {});
             const limit = options?.limit ?? 20;
-            // thread/list returns the cheap `cwd` field. When the caller supplied
-            // a cwd hint we filter here so the per-thread `thread/read includeTurns`
-            // hydration below only runs for matching threads. Fetch a wider window
-            // when filtering since most threads will be from other cwds.
+            // thread/list returns the cheap `cwd` field. Fetch a wider window when
+            // filtering since most threads will be from other cwds, then keep the
+            // local realpath-aware filter for symlink-equivalent workspace paths.
             const listLimit = options?.cwd ? Math.max(limit, 50) : limit;
-            const response = toObjectRecord(await client.request("thread/list", { limit: listLimit }));
+            const response = toObjectRecord(await client.request("thread/list", {
+                limit: listLimit,
+                ...(options?.cwd ? { cwd: options.cwd } : {}),
+            }));
             const allThreads = Array.isArray(response?.data) ? response.data.filter(isRecord) : [];
             const threads = filterCodexThreadsByCwd(allThreads, options?.cwd);
-            const descriptors = await Promise.all(threads.slice(0, limit).map(async (thread) => {
+            const descriptors = threads.slice(0, limit).map((thread) => {
                 const threadId = typeof thread.id === "string" ? thread.id : "";
                 const cwd = typeof thread.cwd === "string" ? thread.cwd : process.cwd();
-                const title = typeof thread.preview === "string" ? thread.preview : null;
-                let timeline = [];
-                try {
-                    timeline = await loadCodexThreadHistoryTimeline({
-                        threadId,
-                        cwd,
-                        requestThread: (threadIdToRead) => {
-                            return readCodexThread(client, threadIdToRead);
-                        },
-                    });
-                }
-                catch {
-                    timeline = [];
-                }
+                const preview = typeof thread.preview === "string" ? thread.preview : null;
+                const title = typeof thread.name === "string" && thread.name.trim() ? thread.name : preview;
                 return {
                     provider: CODEX_PROVIDER,
                     sessionId: threadId,
@@ -4359,9 +4353,9 @@ export class CodexAppServerAgentClient {
                             threadId,
                         },
                     },
-                    timeline: timeline.map((entry) => entry.item),
+                    timeline: buildCodexThreadListTimeline(thread),
                 };
-            }));
+            });
             return descriptors;
         }
         finally {

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -65,7 +65,9 @@ export declare class MockLoadTestAgentSession implements AgentSession {
     private scheduleLargePayloadTurn;
     private scheduleStressTurn;
     private schedulePlanApprovalTurn;
+    private scheduleQuestionPromptTurn;
     private emitPlanApprovalTurn;
+    private emitQuestionPromptTurn;
     private emitStressTurn;
     private emitLargePayloadTurn;
     private tick;