@getpaseo/server 0.1.89 → 0.1.90

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

@@ -120,9 +120,12 @@ export async function sendPromptToAgent(params) {
     if (params.sessionMode) {
         await params.agentManager.setAgentMode(params.agentId, params.sessionMode);
     }
+    const runOptions = params.messageId
+        ? { ...params.runOptions, messageId: params.messageId }
+        : params.runOptions;
     return startAgentRun(params.agentManager, params.agentId, params.prompt, params.logger, {
         replaceRunning: true,
-        runOptions: params.runOptions,
+        runOptions,
     });
 }
 export async function startCreatedAgentInitialPrompt(params) {

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -84,6 +84,7 @@ export interface ResolveAgentCreateConfigInput {
     requestedMode: string | undefined;
     featureValues: Record<string, unknown> | undefined;
     parent: AgentCreateConfigParent | null;
+    unattended: boolean;
     availableModes: AgentMode[] | undefined;
 }
 export interface ResolveAgentCreateConfigResult {

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

@@ -1,7 +1,7 @@
-import { randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
+import { writeJsonFileAtomic } from "../atomic-file.js";
 import { AgentFeatureSchema, AgentStatusSchema } from "../messages.js";
 import { toStoredAgentRecord } from "./agent-projections.js";
 const SERIALIZABLE_CONFIG_SCHEMA = z
@@ -109,8 +109,7 @@ export class AgentStorage {
         const agentId = record.id;
         const nextPath = this.buildRecordPath(record);
         const previousPath = this.pathById.get(agentId);
-        await fs.mkdir(path.dirname(nextPath), { recursive: true });
-        await writeFileAtomically(nextPath, JSON.stringify(record, null, 2));
+        await writeJsonFileAtomic(nextPath, record);
         this.addIndexedPath(agentId, nextPath);
         if (previousPath && previousPath !== nextPath) {
             try {
@@ -317,10 +316,4 @@ function projectDirNameFromCwd(cwd) {
     }
     return prefix + withoutRoot.replace(/[\\/]+/g, "-");
 }
-async function writeFileAtomically(targetPath, payload) {
-    const directory = path.dirname(targetPath);
-    const tempPath = path.join(directory, `.agent.tmp-${process.pid}-${Date.now()}-${randomUUID()}`);
-    await fs.writeFile(tempPath, payload, "utf8");
-    await fs.rename(tempPath, targetPath);
-}
 //# sourceMappingURL=agent-storage.js.map

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

@@ -3,7 +3,7 @@ import { expandUserPath, resolvePathFromBase } from "../../path-utils.js";
 import { toWorktreeRequestError } from "../../worktree-errors.js";
 import { scheduleAgentMetadataGeneration } from "../agent-metadata-generator.js";
 import { setupFinishNotification, startCreatedAgentInitialPrompt } from "../agent-prompt.js";
-import { resolveClientMessageId } from "../../client-message-id.js";
+import { normalizeClientMessageId, resolveClientMessageId } from "../../client-message-id.js";
 import { resolveRequiredProviderModel } from "../mcp-shared.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "../timeline-append.js";
 export async function createAgentCommand(dependencies, input) {
@@ -46,6 +46,13 @@ async function resolveSessionCreateAgent(dependencies, input) {
     });
     const prompt = buildAgentPrompt(trimmedPrompt ?? "", input.images, input.attachments);
     const hasPromptContent = Array.isArray(prompt) ? prompt.length > 0 : prompt.length > 0;
+    const clientMessageId = normalizeClientMessageId(input.clientMessageId);
+    const runOptions = input.outputSchema || clientMessageId
+        ? {
+            ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+            ...(clientMessageId ? { messageId: clientMessageId } : {}),
+        }
+        : undefined;
     return {
         config: sessionConfig,
         createOptions: {
@@ -57,7 +64,7 @@ async function resolveSessionCreateAgent(dependencies, input) {
         },
         metadataInitialPrompt: trimmedPrompt,
         prompt: hasPromptContent ? prompt : undefined,
-        runOptions: input.outputSchema ? { outputSchema: input.outputSchema } : undefined,
+        runOptions,
         explicitTitle: input.explicitTitle,
         setupContinuation,
         background: true,
@@ -93,6 +100,7 @@ async function resolveMcpCreateAgent(dependencies, input) {
         requestedMode: input.mode,
         featureValues: input.features,
         parent: parentAgent,
+        unattended: false,
     });
     const labels = mergeLabels({
         callerAgentId: input.callerAgentId,

package/dist/server/server/agent/create-agent-mode.d.ts

@@ -1,18 +1,13 @@
-import type { AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
-interface CreateAgentModeParent {
-    provider: AgentProvider;
-    modeId: string | null;
-    isUnattended: boolean;
-}
+import type { AgentCreateConfigParent, AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
 export interface ResolveCreateAgentModeInput {
     requestedMode: string | undefined;
     targetProvider: AgentProvider;
-    parent: CreateAgentModeParent | null;
+    parent: AgentCreateConfigParent | null;
+    unattended: boolean;
     availableModes: string[] | undefined;
     targetUnattendedMode: string | undefined;
 }
 export declare function resolveAndValidateCreateAgentMode(input: ResolveCreateAgentModeInput): string | undefined;
 export declare function resolveDefaultAgentCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
 export declare function isDefaultAgentCreateConfigUnattended(input: AgentCreateConfigUnattendedInput): boolean;
-export {};
 //# sourceMappingURL=create-agent-mode.d.ts.map

package/dist/server/server/agent/create-agent-mode.js

@@ -4,6 +4,15 @@ function listModes(modes) {
     }
     return modes.length > 0 ? modes.join(", ") : "(none)";
 }
+function isUnattendedCreateConfigParent(parent) {
+    return parent.isUnattended;
+}
+function formatCreateConfigParentMode(parent) {
+    return parent.modeId ?? "<none>";
+}
+function formatCreateConfigParentSource(parent) {
+    return `caller (provider '${parent.provider}')`;
+}
 export function resolveAndValidateCreateAgentMode(input) {
     const { requestedMode, targetProvider, parent, availableModes } = input;
     if (requestedMode !== undefined) {
@@ -13,15 +22,19 @@ export function resolveAndValidateCreateAgentMode(input) {
         return requestedMode;
     }
     if (!parent) {
+        if (input.unattended && input.targetUnattendedMode !== undefined) {
+            return input.targetUnattendedMode;
+        }
         return undefined;
     }
     if (parent.provider === targetProvider) {
         return parent.modeId ?? undefined;
     }
-    if (parent.isUnattended && input.targetUnattendedMode !== undefined) {
+    if ((input.unattended || isUnattendedCreateConfigParent(parent)) &&
+        input.targetUnattendedMode !== undefined) {
         return input.targetUnattendedMode;
     }
-    throw new Error(`cannot inherit mode '${parent.modeId ?? "<none>"}' from caller (provider '${parent.provider}') for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
+    throw new Error(`cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
 }
 export function resolveDefaultAgentCreateConfig(input) {
     const availableModeIds = input.availableModes?.map((mode) => mode.id);
@@ -30,6 +43,7 @@ export function resolveDefaultAgentCreateConfig(input) {
             requestedMode: input.requestedMode,
             targetProvider: input.provider,
             parent: input.parent,
+            unattended: input.unattended,
             availableModes: availableModeIds,
             targetUnattendedMode: input.availableModes?.find(isUnattendedMode)?.id,
         }),

package/dist/server/server/agent/import-sessions.js

@@ -37,7 +37,7 @@ export async function listImportableProviderSessions(input) {
     const providerFilter = request.providers ? new Set(request.providers) : undefined;
     const importedHandles = await collectImportedProviderSessionHandles(agentManager, agentStorage);
     const descriptors = await agentManager.listImportablePersistedAgents({
-        limit: 200,
+        limit,
         providerFilter,
         cwd: request.cwd,
     });

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;

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -62,6 +62,9 @@ const MODELS = [
 function shouldEmitPlanApprovalPrompt(prompt) {
     return /emit\s+(?:a\s+)?synthetic\s+plan\s+approval/i.test(promptToText(prompt));
 }
+function shouldEmitQuestionPrompt(prompt) {
+    return /emit\s+(?:a\s+)?synthetic\s+questions?/i.test(promptToText(prompt));
+}
 function resolveModelProfile(modelId) {
     const model = MODELS.find((entry) => entry.id === modelId) ?? MODELS[0];
     const metadata = model.metadata ?? {};
@@ -389,6 +392,9 @@ export class MockLoadTestAgentSession {
         if (shouldEmitPlanApprovalPrompt(prompt)) {
             this.schedulePlanApprovalTurn(turn);
         }
+        else if (shouldEmitQuestionPrompt(prompt)) {
+            this.scheduleQuestionPromptTurn(turn);
+        }
         else if (largePayload) {
             this.scheduleLargePayloadTurn(turn, largePayload);
         }
@@ -432,9 +438,11 @@ export class MockLoadTestAgentSession {
         return Array.from(this.pendingPermissions.values());
     }
     async respondToPermission(requestId, response) {
-        if (!this.pendingPermissions.delete(requestId)) {
+        const request = this.pendingPermissions.get(requestId);
+        if (!request) {
             return undefined;
         }
+        this.pendingPermissions.delete(requestId);
         const turn = this.activeTurn;
         this.emit({
             type: "permission_resolved",
@@ -444,7 +452,9 @@ export class MockLoadTestAgentSession {
             ...(turn ? { turnId: turn.turnId } : {}),
         });
         if (turn) {
-            this.finishTurnWithText(turn, "Synthetic plan approval resolved");
+            this.finishTurnWithText(turn, request.kind === "question"
+                ? "Synthetic questions resolved"
+                : "Synthetic plan approval resolved");
         }
         return undefined;
     }
@@ -527,6 +537,12 @@ export class MockLoadTestAgentSession {
         }, 0);
         turn.timer.unref?.();
     }
+    scheduleQuestionPromptTurn(turn) {
+        turn.timer = setTimeout(() => {
+            this.emitQuestionPromptTurn(turn);
+        }, 0);
+        turn.timer.unref?.();
+    }
     emitPlanApprovalTurn(turn) {
         if (this.activeTurn !== turn) {
             return;
@@ -575,6 +591,57 @@ export class MockLoadTestAgentSession {
             turnId: turn.turnId,
         });
     }
+    emitQuestionPromptTurn(turn) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.emit({
+            type: "turn_started",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        const request = {
+            id: `mock-questions-${turn.turnId}`,
+            provider: this.provider,
+            name: "MockQuestions",
+            kind: "question",
+            title: "Questions",
+            input: {
+                questions: [
+                    {
+                        question: "Which surface should this apply to?",
+                        header: "surface",
+                        options: [{ label: "App" }, { label: "Desktop" }],
+                        multiSelect: false,
+                    },
+                    {
+                        question: "Which rollout should we use?",
+                        header: "rollout",
+                        options: [{ label: "Immediately" }, { label: "Behind feature flag" }],
+                        multiSelect: false,
+                    },
+                    {
+                        question: "What success criteria should we use?",
+                        header: "success",
+                        options: [],
+                        multiSelect: false,
+                        placeholder: "Describe success...",
+                    },
+                ],
+            },
+            metadata: {
+                source: "mock_questions",
+            },
+        };
+        this.pendingPermissions.set(request.id, request);
+        this.emit({
+            type: "permission_requested",
+            provider: this.provider,
+            request,
+            turnId: turn.turnId,
+        });
+    }
     emitStressTurn(turn, stress) {
         if (this.activeTurn !== turn) {
             return;

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

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
+import pLimit from "p-limit";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "../create-agent-mode.js";
@@ -57,10 +58,17 @@ function withOpenCodeAutoAcceptFeature(featureValues, enabled) {
 }
 function resolveOpenCodeCreateConfig(input) {
     const legacyFullAccess = input.requestedMode === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID;
-    const inheritsUnattended = input.requestedMode === undefined && input.parent?.isUnattended === true;
-    const requestedMode = legacyFullAccess ? OPENCODE_BUILD_MODE_ID : input.requestedMode;
+    const parent = input.parent;
+    const isUnattendedCreate = input.unattended || parent?.isUnattended === true;
+    const inheritsUnattended = input.requestedMode === undefined && isUnattendedCreate;
+    const inheritedOpenCodeMode = inheritsUnattended && parent?.provider === input.provider
+        ? (parent.modeId ?? undefined)
+        : undefined;
+    const requestedMode = legacyFullAccess
+        ? OPENCODE_BUILD_MODE_ID
+        : (input.requestedMode ?? inheritedOpenCodeMode);
     const featureValues = legacyFullAccess ||
-        (inheritsUnattended && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
+        (isUnattendedCreate && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
         ? withOpenCodeAutoAcceptFeature(input.featureValues, true)
         : input.featureValues;
     if (inheritsUnattended && requestedMode === undefined) {
@@ -124,6 +132,8 @@ function resolveOpenCodePermissionReply(response) {
 }
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
+const OPENCODE_METADATA_CONCURRENCY = 4;
+const openCodeMetadataLimit = pLimit(OPENCODE_METADATA_CONCURRENCY);
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
     { name: "compact", description: "Compact the current session", argumentHint: "" },
     { name: "summarize", description: "Compact the current session", argumentHint: "" },
@@ -918,7 +928,7 @@ export class OpenCodeAgentClient {
         try {
             // Background model discovery can be legitimately slow while OpenCode refreshes
             // provider state, so allow longer than turn execution paths.
-            const response = await withTimeout(client.provider.list({ directory: options.cwd }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`);
+            const response = await openCodeMetadataLimit(() => withTimeout(client.provider.list({ directory: options.cwd }), OPENCODE_PROVIDER_LIST_TIMEOUT_MS, `OpenCode provider.list timed out after ${OPENCODE_PROVIDER_LIST_TIMEOUT_MS / 1000}s - server may not be authenticated or connected to any providers`));
             if (response.error) {
                 throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
             }
@@ -964,7 +974,7 @@ export class OpenCodeAgentClient {
         const directory = options.cwd;
         const client = this.runtime.createClient({ baseUrl: url, directory });
         try {
-            const response = await withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s");
+            const response = await openCodeMetadataLimit(() => withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s"));
             if (response.error || !response.data) {
                 return DEFAULT_MODES;
             }
@@ -1102,7 +1112,7 @@ export class OpenCodeAgentClient {
         return normalizeOpenCodeConfig({ ...config, provider: "opencode" });
     }
     async populateModelContextWindowCache(client, cwd) {
-        const response = await client.provider.list({ directory: cwd });
+        const response = await openCodeMetadataLimit(() => client.provider.list({ directory: cwd }));
         if (response.error || !response.data) {
             return;
         }
@@ -1794,6 +1804,7 @@ function appendOpenCodeQuestionAsked(event, state, events) {
                 header: q.header,
                 options,
                 ...(q.multiple === true ? { multiSelect: true } : {}),
+                allowOther: true,
             },
         ];
     });
@@ -2467,9 +2478,9 @@ class OpenCodeAgentSession {
         if (this.availableModesCache) {
             return this.availableModesCache;
         }
-        const response = await this.client.app.agents({
+        const response = await openCodeMetadataLimit(() => this.client.app.agents({
             directory: this.config.cwd,
-        });
+        }));
         const agents = response.error || !response.data ? [] : response.data;
         const discoveredModes = agents.filter(isSelectableOpenCodeAgent).map(mapOpenCodeAgentToMode);
         this.availableModesCache = mergeOpenCodeModes(discoveredModes);

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

@@ -270,7 +270,36 @@ 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) {
+    if (!bounds) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: false,
+        };
+    }
+    if (projectedAll.length === 0) {
+        if (input.direction === "after") {
+            const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq >= bounds.minSeq,
+                hasNewer: cursorSeq < bounds.maxSeq,
+            };
+        }
+        if (input.direction === "before") {
+            const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq > bounds.minSeq,
+                hasNewer: cursorSeq <= bounds.maxSeq,
+            };
+        }
         return {
             entries: [],
             startSeq: null,

package/dist/server/server/atomic-file.d.ts

@@ -0,0 +1,3 @@
+export declare function writeFileAtomic(filePath: string, data: string | NodeJS.ArrayBufferView): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;
+//# sourceMappingURL=atomic-file.d.ts.map